diff options
Diffstat (limited to 'compiler/jni/quick/jni_compiler.cc')
| -rw-r--r-- | compiler/jni/quick/jni_compiler.cc | 295 |
1 files changed, 105 insertions, 190 deletions
diff --git a/compiler/jni/quick/jni_compiler.cc b/compiler/jni/quick/jni_compiler.cc index 9d96372962..5752c7562a 100644 --- a/compiler/jni/quick/jni_compiler.cc +++ b/compiler/jni/quick/jni_compiler.cc @@ -86,12 +86,15 @@ enum class JniEntrypoint { template <PointerSize kPointerSize> static ThreadOffset<kPointerSize> GetJniEntrypointThreadOffset(JniEntrypoint which, bool reference_return, - bool is_synchronized) { + bool is_synchronized, + bool is_fast_native) { if (which == JniEntrypoint::kStart) { // JniMethodStart ThreadOffset<kPointerSize> jni_start = is_synchronized ? QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodStartSynchronized) - : QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodStart); + : (is_fast_native + ? QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodFastStart) + : QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodStart)); return jni_start; } else { // JniMethodEnd @@ -100,11 +103,15 @@ static ThreadOffset<kPointerSize> GetJniEntrypointThreadOffset(JniEntrypoint whi // Pass result. jni_end = is_synchronized ? QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodEndWithReferenceSynchronized) - : QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodEndWithReference); + : (is_fast_native + ? QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodFastEndWithReference) + : QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodEndWithReference)); } else { jni_end = is_synchronized ? QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodEndSynchronized) - : QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodEnd); + : (is_fast_native + ? QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodFastEnd) + : QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodEnd)); } return jni_end; @@ -122,7 +129,6 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp uint32_t access_flags, uint32_t method_idx, const DexFile& dex_file) { - constexpr size_t kRawPointerSize = static_cast<size_t>(kPointerSize); const bool is_native = (access_flags & kAccNative) != 0; CHECK(is_native); const bool is_static = (access_flags & kAccStatic) != 0; @@ -188,7 +194,6 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp JniCallingConvention::Create(&allocator, is_static, is_synchronized, - is_fast_native, is_critical_native, shorty, instruction_set); @@ -213,7 +218,6 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp JniCallingConvention::Create(&allocator, is_static, is_synchronized, - is_fast_native, is_critical_native, jni_end_shorty, instruction_set)); @@ -239,7 +243,6 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp // Spill all register arguments. // TODO: Pass these in a single call to let the assembler use multi-register stores. // TODO: Spill native stack args straight to their stack locations (adjust SP earlier). - // TODO: For @FastNative, move args in registers, spill only references. mr_conv->ResetIterator(FrameOffset(current_frame_size)); for (; mr_conv->HasNext(); mr_conv->Next()) { if (mr_conv->IsCurrentParamInRegister()) { @@ -254,6 +257,7 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp // NOTE: @CriticalNative does not need to store the stack pointer to the thread // because garbage collections are disabled within the execution of a // @CriticalNative method. + // (TODO: We could probably disable it for @FastNative too). } // if (!is_critical_native) // 3. Move frame down to allow space for out going args. @@ -286,12 +290,13 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp // two pointer arguments. std::unique_ptr<JNIMacroLabel> monitor_enter_exception_slow_path = UNLIKELY(is_synchronized) ? __ CreateLabel() : nullptr; - if (LIKELY(!is_critical_native && !is_fast_native)) { - // Skip this for @CriticalNative and @FastNative methods. They do not call JniMethodStart. + if (LIKELY(!is_critical_native)) { + // Skip this for @CriticalNative methods. They do not call JniMethodStart. ThreadOffset<kPointerSize> jni_start = GetJniEntrypointThreadOffset<kPointerSize>(JniEntrypoint::kStart, reference_return, - is_synchronized); + is_synchronized, + is_fast_native); main_jni_conv->ResetIterator(FrameOffset(main_out_arg_size)); if (is_synchronized) { // Pass object for locking. @@ -358,8 +363,9 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp ArenaVector<ArgumentLocation> src_args(allocator.Adapter()); ArenaVector<ArgumentLocation> dest_args(allocator.Adapter()); // Move the method pointer to the hidden argument register. - dest_args.push_back(ArgumentLocation(main_jni_conv->HiddenArgumentRegister(), kRawPointerSize)); - src_args.push_back(ArgumentLocation(mr_conv->MethodRegister(), kRawPointerSize)); + size_t pointer_size = static_cast<size_t>(kPointerSize); + dest_args.push_back(ArgumentLocation(main_jni_conv->HiddenArgumentRegister(), pointer_size)); + src_args.push_back(ArgumentLocation(mr_conv->MethodRegister(), pointer_size)); // Move normal arguments to their locations. mr_conv->ResetIterator(FrameOffset(current_frame_size)); main_jni_conv->ResetIterator(FrameOffset(main_out_arg_size)); @@ -376,26 +382,6 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp DCHECK(!main_jni_conv->HasNext()); __ MoveArguments(ArrayRef<ArgumentLocation>(dest_args), ArrayRef<ArgumentLocation>(src_args)); } else { - if (UNLIKELY(!method_register.IsNoRegister())) { - DCHECK(is_fast_native); - // In general, we do not know if the method register shall be clobbered by initializing - // some argument below. However, for most supported architectures (arm, arm64, x86_64), - // the `method_register` is the same as the `JNIEnv*` argument register which is - // initialized last, so we can quickly check that case and use the original method - // register to initialize the `jclass` for static methods. Otherwise, move the method - // to the `callee_save_temp` as we shall need it for the call. - main_jni_conv->ResetIterator(FrameOffset(main_out_arg_size)); - if (main_jni_conv->IsCurrentParamInRegister() && - main_jni_conv->CurrentParamRegister().Equals(method_register) && - is_static) { - // Keep the current `method_register`. - } else { - ManagedRegister new_method_reg = __ CoreRegisterWithSize(callee_save_temp, kRawPointerSize); - __ Move(new_method_reg, method_register, kRawPointerSize); - method_register = new_method_reg; - } - } - // Iterate over arguments placing values from managed calling convention in // to the convention required for a native call (shuffling). For references // place an index/pointer to the reference after checking whether it is @@ -433,36 +419,25 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp } // 8. For static method, create jclass argument as a pointer to the method's declaring class. - // Make sure the method is in a register even for non-static methods. - DCHECK_EQ(ArtMethod::DeclaringClassOffset().SizeValue(), 0u); - FrameOffset method_offset = - FrameOffset(current_out_arg_size + mr_conv->MethodStackOffset().SizeValue()); if (is_static) { main_jni_conv->ResetIterator(FrameOffset(main_out_arg_size)); main_jni_conv->Next(); // Skip JNIEnv* - // Load reference to the method's declaring class. For normal native, the method register - // has been clobbered by the above call, so we need to load the method from the stack. - if (method_register.IsNoRegister()) { - // Use the `callee_save_temp` if the parameter goes on the stack. - method_register = main_jni_conv->IsCurrentParamOnStack() - ? __ CoreRegisterWithSize(callee_save_temp, kRawPointerSize) - : main_jni_conv->CurrentParamRegister(); - __ Load(method_register, method_offset, kRawPointerSize); - } - DCHECK(!method_register.IsNoRegister()); + // Load reference to the method's declaring class. The method register has been + // clobbered by the above call, so we need to load the method from the stack. + FrameOffset method_offset = + FrameOffset(current_out_arg_size + mr_conv->MethodStackOffset().SizeValue()); + DCHECK_EQ(ArtMethod::DeclaringClassOffset().SizeValue(), 0u); if (main_jni_conv->IsCurrentParamOnStack()) { - // Store the method argument. FrameOffset out_off = main_jni_conv->CurrentParamStackOffset(); - __ Store(out_off, method_register, kRawPointerSize); + __ Copy(out_off, method_offset, static_cast<size_t>(kPointerSize)); + // TODO(x86): Get hold of the register used to copy the method pointer, + // so that we can use it also for loading the method entrypoint below. } else { ManagedRegister out_reg = main_jni_conv->CurrentParamRegister(); - __ Move(out_reg, method_register, kRawPointerSize); // No-op if equal. + __ Load(out_reg, method_offset, static_cast<size_t>(kPointerSize)); + // Reuse the register also for loading the method entrypoint below. method_register = out_reg; } - } else if (LIKELY(method_register.IsNoRegister())) { - // Load the method for non-static methods to `callee_save_temp` as we need it for the call. - method_register = __ CoreRegisterWithSize(callee_save_temp, kRawPointerSize); - __ Load(method_register, method_offset, kRawPointerSize); } // Set the iterator back to the incoming Method*. @@ -471,10 +446,10 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp // 9. Create 1st argument, the JNI environment ptr. if (main_jni_conv->IsCurrentParamInRegister()) { ManagedRegister jni_env_arg = main_jni_conv->CurrentParamRegister(); - __ Move(jni_env_arg, jni_env_reg, kRawPointerSize); + __ Move(jni_env_arg, jni_env_reg, static_cast<size_t>(kPointerSize)); } else { FrameOffset jni_env_arg_offset = main_jni_conv->CurrentParamStackOffset(); - __ Store(jni_env_arg_offset, jni_env_reg, kRawPointerSize); + __ Store(jni_env_arg_offset, jni_env_reg, static_cast<size_t>(kPointerSize)); } } @@ -488,11 +463,12 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp __ Call(main_jni_conv->HiddenArgumentRegister(), jni_entrypoint_offset); } } else { - DCHECK(method_register.IsRegister()); - __ Call(method_register, jni_entrypoint_offset); - // We shall not need the method register anymore. And we may clobber it below - // if it's the `callee_save_temp`, so clear it here to make sure it's not used. - method_register = ManagedRegister::NoRegister(); + if (method_register.IsRegister()) { + __ Call(method_register, jni_entrypoint_offset); + } else { + __ Call(FrameOffset(current_out_arg_size + mr_conv->MethodStackOffset().SizeValue()), + jni_entrypoint_offset); + } } // 11. Fix differences in result widths. @@ -523,9 +499,8 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp __ Store(return_save_location, main_jni_conv->ReturnRegister(), main_jni_conv->SizeOfReturnValue()); - } else if (UNLIKELY(is_fast_native || is_critical_native) && - main_jni_conv->SizeOfReturnValue() != 0) { - // For @FastNative and @CriticalNative only, + } else if (UNLIKELY(is_critical_native) && main_jni_conv->SizeOfReturnValue() != 0) { + // For @CriticalNative only, // move the JNI return register into the managed return register (if they don't match). ManagedRegister jni_return_reg = main_jni_conv->ReturnRegister(); ManagedRegister mr_return_reg = mr_conv->ReturnRegister(); @@ -534,7 +509,7 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp // If they differ, only then do we have to do anything about it. // Otherwise the return value is already in the right place when we return. if (!jni_return_reg.Equals(mr_return_reg)) { - CHECK(!is_critical_native || !main_jni_conv->UseTailCall()); + CHECK(!main_jni_conv->UseTailCall()); // This is typically only necessary on ARM32 due to native being softfloat // while managed is hardfloat. // -- For example VMOV {r0, r1} -> D0; VMOV r0 -> S0. @@ -546,30 +521,10 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp } } - // 13. For @FastNative that returns a reference, do an early exception check so that the - // `JniDecodeReferenceResult()` in the main path does not need to check for exceptions. - std::unique_ptr<JNIMacroLabel> exception_slow_path = - LIKELY(!is_critical_native) ? __ CreateLabel() : nullptr; - if (UNLIKELY(is_fast_native) && reference_return) { - __ ExceptionPoll(exception_slow_path.get()); - } - - // 14. For @FastNative that returns a reference, do an early suspend check so that we - // do not need to encode the decoded reference in a stack map. - std::unique_ptr<JNIMacroLabel> suspend_check_slow_path = - UNLIKELY(is_fast_native) ? __ CreateLabel() : nullptr; - std::unique_ptr<JNIMacroLabel> suspend_check_resume = - UNLIKELY(is_fast_native) ? __ CreateLabel() : nullptr; - if (UNLIKELY(is_fast_native) && reference_return) { - __ SuspendCheck(suspend_check_slow_path.get()); - __ Bind(suspend_check_resume.get()); - } - if (LIKELY(!is_critical_native)) { // Increase frame size for out args if needed by the end_jni_conv. const size_t end_out_arg_size = end_jni_conv->OutFrameSize(); if (end_out_arg_size > current_out_arg_size) { - DCHECK(!is_fast_native); size_t out_arg_size_diff = end_out_arg_size - current_out_arg_size; current_out_arg_size = end_out_arg_size; __ IncreaseFrameSize(out_arg_size_diff); @@ -578,94 +533,84 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp } end_jni_conv->ResetIterator(FrameOffset(end_out_arg_size)); - // 15. Call JniMethodEnd for normal native. - // For @FastNative with reference return, decode the `jobject`. - if (LIKELY(!is_fast_native) || reference_return) { - ThreadOffset<kPointerSize> jni_end = is_fast_native - ? QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniDecodeReferenceResult) - : GetJniEntrypointThreadOffset<kPointerSize>(JniEntrypoint::kEnd, - reference_return, - is_synchronized); - if (reference_return) { - // Pass result. - SetNativeParameter(jni_asm.get(), end_jni_conv.get(), end_jni_conv->ReturnRegister()); - end_jni_conv->Next(); - } - if (is_synchronized) { - // Pass object for unlocking. - if (is_static) { - // Load reference to the method's declaring class. The method register has been - // clobbered by the above call, so we need to load the method from the stack. - FrameOffset method_offset = - FrameOffset(current_out_arg_size + mr_conv->MethodStackOffset().SizeValue()); - DCHECK_EQ(ArtMethod::DeclaringClassOffset().SizeValue(), 0u); - if (end_jni_conv->IsCurrentParamOnStack()) { - FrameOffset out_off = end_jni_conv->CurrentParamStackOffset(); - __ Copy(out_off, method_offset, kRawPointerSize); - } else { - ManagedRegister out_reg = end_jni_conv->CurrentParamRegister(); - __ Load(out_reg, method_offset, kRawPointerSize); - } + // 13. Call JniMethodEnd + ThreadOffset<kPointerSize> jni_end = + GetJniEntrypointThreadOffset<kPointerSize>(JniEntrypoint::kEnd, + reference_return, + is_synchronized, + is_fast_native); + if (reference_return) { + // Pass result. + SetNativeParameter(jni_asm.get(), end_jni_conv.get(), end_jni_conv->ReturnRegister()); + end_jni_conv->Next(); + } + if (is_synchronized) { + // Pass object for unlocking. + if (is_static) { + // Load reference to the method's declaring class. The method register has been + // clobbered by the above call, so we need to load the method from the stack. + FrameOffset method_offset = + FrameOffset(current_out_arg_size + mr_conv->MethodStackOffset().SizeValue()); + DCHECK_EQ(ArtMethod::DeclaringClassOffset().SizeValue(), 0u); + if (end_jni_conv->IsCurrentParamOnStack()) { + FrameOffset out_off = end_jni_conv->CurrentParamStackOffset(); + __ Copy(out_off, method_offset, static_cast<size_t>(kPointerSize)); } else { - mr_conv->ResetIterator(FrameOffset(current_frame_size)); - FrameOffset this_offset = mr_conv->CurrentParamStackOffset(); - if (end_jni_conv->IsCurrentParamOnStack()) { - FrameOffset out_off = end_jni_conv->CurrentParamStackOffset(); - __ CreateJObject(out_off, this_offset, /*null_allowed=*/ false); - } else { - ManagedRegister out_reg = end_jni_conv->CurrentParamRegister(); - __ CreateJObject(out_reg, - this_offset, - ManagedRegister::NoRegister(), - /*null_allowed=*/ false); - } + ManagedRegister out_reg = end_jni_conv->CurrentParamRegister(); + __ Load(out_reg, method_offset, static_cast<size_t>(kPointerSize)); } - end_jni_conv->Next(); - } - if (end_jni_conv->IsCurrentParamInRegister()) { - __ GetCurrentThread(end_jni_conv->CurrentParamRegister()); - __ Call(end_jni_conv->CurrentParamRegister(), Offset(jni_end)); } else { - __ GetCurrentThread(end_jni_conv->CurrentParamStackOffset()); - __ CallFromThread(jni_end); + mr_conv->ResetIterator(FrameOffset(current_frame_size)); + FrameOffset this_offset = mr_conv->CurrentParamStackOffset(); + if (end_jni_conv->IsCurrentParamOnStack()) { + FrameOffset out_off = end_jni_conv->CurrentParamStackOffset(); + __ CreateJObject(out_off, this_offset, /*null_allowed=*/ false); + } else { + ManagedRegister out_reg = end_jni_conv->CurrentParamRegister(); + __ CreateJObject(out_reg, + this_offset, + ManagedRegister::NoRegister(), + /*null_allowed=*/ false); + } } + end_jni_conv->Next(); + } + if (end_jni_conv->IsCurrentParamInRegister()) { + __ GetCurrentThread(end_jni_conv->CurrentParamRegister()); + __ Call(end_jni_conv->CurrentParamRegister(), Offset(jni_end)); + } else { + __ GetCurrentThread(end_jni_conv->CurrentParamStackOffset()); + __ CallFromThread(jni_end); } - // 16. Reload return value + // 14. Reload return value if (spill_return_value) { __ Load(mr_conv->ReturnRegister(), return_save_location, mr_conv->SizeOfReturnValue()); } } // if (!is_critical_native) - // 17. Pop local reference frame. - if (LIKELY(!is_critical_native)) { + // 15. Pop local reference frame. + if (!is_critical_native) { PopLocalReferenceFrame<kPointerSize>( jni_asm.get(), jni_env_reg, saved_cookie_reg, callee_save_temp); } - // 18. Move frame up now we're done with the out arg space. + // 16. Move frame up now we're done with the out arg space. // @CriticalNative remove out args together with the frame in RemoveFrame(). if (LIKELY(!is_critical_native)) { __ DecreaseFrameSize(current_out_arg_size); current_frame_size -= current_out_arg_size; } - // 19. Process pending exceptions from JNI call or monitor exit. + // 17. Process pending exceptions from JNI call or monitor exit. // @CriticalNative methods do not need exception poll in the stub. - // @FastNative methods with reference return emit the exception poll earlier. - if (LIKELY(!is_critical_native) && (LIKELY(!is_fast_native) || !reference_return)) { + std::unique_ptr<JNIMacroLabel> exception_slow_path = + LIKELY(!is_critical_native) ? __ CreateLabel() : nullptr; + if (LIKELY(!is_critical_native)) { __ ExceptionPoll(exception_slow_path.get()); } - // 20. For @FastNative, we never transitioned out of runnable, so there is no transition back. - // Perform a suspend check if there is a flag raised, unless we have done that above - // for reference return. - if (UNLIKELY(is_fast_native) && !reference_return) { - __ SuspendCheck(suspend_check_slow_path.get()); - __ Bind(suspend_check_resume.get()); - } - - // 21. Remove activation - need to restore callee save registers since the GC may have changed + // 18. Remove activation - need to restore callee save registers since the GC may have changed // them. DCHECK_EQ(jni_asm->cfi().GetCurrentCFAOffset(), static_cast<int>(current_frame_size)); if (LIKELY(!is_critical_native) || !main_jni_conv->UseTailCall()) { @@ -676,7 +621,7 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp DCHECK_EQ(jni_asm->cfi().GetCurrentCFAOffset(), static_cast<int>(current_frame_size)); } - // 22. Read barrier slow path for the declaring class in the method for a static call. + // 19. Read barrier slow path for the declaring class in the method for a static call. // Skip this for @CriticalNative because we're not passing a `jclass` to the native method. if (kUseReadBarrier && is_static && !is_critical_native) { __ Bind(jclass_read_barrier_slow_path.get()); @@ -715,12 +660,12 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp __ GetCurrentThread(main_jni_conv->CurrentParamStackOffset()); __ CallFromThread(read_barrier); } - if (UNLIKELY(is_synchronized || is_fast_native)) { + if (is_synchronized) { // Reload the method pointer in the slow path because it is needed - // as an argument for the `JniMethodStartSynchronized`, or for @FastNative. + // as an argument for the `JniMethodStartSynchronized`. __ Load(method_register, FrameOffset(main_out_arg_size + mr_conv->MethodStackOffset().SizeValue()), - kRawPointerSize); + static_cast<size_t>(kPointerSize)); } // Return to main path. @@ -732,47 +677,17 @@ static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& comp } } - // 23. Emit suspend check slow path. - if (UNLIKELY(is_fast_native)) { - __ Bind(suspend_check_slow_path.get()); - if (reference_return && main_out_arg_size != 0) { - jni_asm->cfi().AdjustCFAOffset(main_out_arg_size); - __ DecreaseFrameSize(main_out_arg_size); - } - __ CallFromThread(QUICK_ENTRYPOINT_OFFSET(kPointerSize, pTestSuspend)); - if (reference_return) { - // Suspend check entry point overwrites top of managed stack and leaves it clobbered. - // We need to restore the top for subsequent runtime call to `JniDecodeReferenceResult()`. - __ StoreStackPointerToThread(Thread::TopOfManagedStackOffset<kPointerSize>()); - } - if (reference_return && main_out_arg_size != 0) { - __ IncreaseFrameSize(main_out_arg_size); - jni_asm->cfi().AdjustCFAOffset(-main_out_arg_size); - } - __ Jump(suspend_check_resume.get()); - } - - // 24. Emit exception poll slow paths. + // 20. Emit exception poll slow paths. if (LIKELY(!is_critical_native)) { if (UNLIKELY(is_synchronized)) { - DCHECK(!is_fast_native); __ Bind(monitor_enter_exception_slow_path.get()); if (main_out_arg_size != 0) { jni_asm->cfi().AdjustCFAOffset(main_out_arg_size); __ DecreaseFrameSize(main_out_arg_size); } } - __ Bind(exception_slow_path.get()); - if (UNLIKELY(is_fast_native) && reference_return) { - // We performed the exception check early, so we need to adjust SP and pop IRT frame. - if (main_out_arg_size != 0) { - jni_asm->cfi().AdjustCFAOffset(main_out_arg_size); - __ DecreaseFrameSize(main_out_arg_size); - } - PopLocalReferenceFrame<kPointerSize>( - jni_asm.get(), jni_env_reg, saved_cookie_reg, callee_save_temp); - } DCHECK_EQ(jni_asm->cfi().GetCurrentCFAOffset(), static_cast<int>(current_frame_size)); + __ Bind(exception_slow_path.get()); __ DeliverPendingException(); } @@ -796,9 +711,9 @@ static void PushLocalReferenceFrame(JNIMacroAssembler<kPointerSize>* jni_asm, ManagedRegister jni_env_reg, ManagedRegister saved_cookie_reg, ManagedRegister temp_reg) { - const size_t kRawPointerSize = static_cast<size_t>(kPointerSize); - const MemberOffset jni_env_cookie_offset = JNIEnvExt::LocalRefCookieOffset(kRawPointerSize); - const MemberOffset jni_env_segment_state_offset = JNIEnvExt::SegmentStateOffset(kRawPointerSize); + const size_t pointer_size = static_cast<size_t>(kPointerSize); + const MemberOffset jni_env_cookie_offset = JNIEnvExt::LocalRefCookieOffset(pointer_size); + const MemberOffset jni_env_segment_state_offset = JNIEnvExt::SegmentStateOffset(pointer_size); // Load the old cookie that we shall need to restore. __ Load(saved_cookie_reg, jni_env_reg, jni_env_cookie_offset, kIRTCookieSize); @@ -813,9 +728,9 @@ static void PopLocalReferenceFrame(JNIMacroAssembler<kPointerSize>* jni_asm, ManagedRegister jni_env_reg, ManagedRegister saved_cookie_reg, ManagedRegister temp_reg) { - const size_t kRawPointerSize = static_cast<size_t>(kPointerSize); - const MemberOffset jni_env_cookie_offset = JNIEnvExt::LocalRefCookieOffset(kRawPointerSize); - const MemberOffset jni_env_segment_state_offset = JNIEnvExt::SegmentStateOffset(kRawPointerSize); + const size_t pointer_size = static_cast<size_t>(kPointerSize); + const MemberOffset jni_env_cookie_offset = JNIEnvExt::LocalRefCookieOffset(pointer_size); + const MemberOffset jni_env_segment_state_offset = JNIEnvExt::SegmentStateOffset(pointer_size); // Set the current segment state to the current cookie in JNI environment. __ Load(temp_reg, jni_env_reg, jni_env_cookie_offset, kIRTCookieSize); |