| /* |
| * Copyright (C) 2011 The Android Open Source Project |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| */ |
| |
| #include "jni_compiler.h" |
| |
| #include <algorithm> |
| #include <fstream> |
| #include <ios> |
| #include <memory> |
| #include <vector> |
| |
| #include "art_method.h" |
| #include "base/arena_allocator.h" |
| #include "base/arena_containers.h" |
| #include "base/enums.h" |
| #include "base/logging.h" // For VLOG. |
| #include "base/macros.h" |
| #include "base/memory_region.h" |
| #include "base/utils.h" |
| #include "calling_convention.h" |
| #include "class_linker.h" |
| #include "dwarf/debug_frame_opcode_writer.h" |
| #include "dex/dex_file-inl.h" |
| #include "driver/compiler_options.h" |
| #include "entrypoints/quick/quick_entrypoints.h" |
| #include "jni/jni_env_ext.h" |
| #include "thread.h" |
| #include "utils/arm/managed_register_arm.h" |
| #include "utils/arm64/managed_register_arm64.h" |
| #include "utils/assembler.h" |
| #include "utils/jni_macro_assembler.h" |
| #include "utils/managed_register.h" |
| #include "utils/x86/managed_register_x86.h" |
| |
| #define __ jni_asm-> |
| |
| namespace art { |
| |
| constexpr size_t kIRTCookieSize = JniCallingConvention::SavedLocalReferenceCookieSize(); |
| |
| template <PointerSize kPointerSize> |
| static void PushLocalReferenceFrame(JNIMacroAssembler<kPointerSize>* jni_asm, |
| ManagedRegister jni_env_reg, |
| ManagedRegister saved_cookie_reg, |
| ManagedRegister temp_reg); |
| template <PointerSize kPointerSize> |
| static void PopLocalReferenceFrame(JNIMacroAssembler<kPointerSize>* jni_asm, |
| ManagedRegister jni_env_reg, |
| ManagedRegister saved_cookie_reg, |
| ManagedRegister temp_reg); |
| |
| template <PointerSize kPointerSize> |
| static void SetNativeParameter(JNIMacroAssembler<kPointerSize>* jni_asm, |
| JniCallingConvention* jni_conv, |
| ManagedRegister in_reg); |
| |
| template <PointerSize kPointerSize> |
| static std::unique_ptr<JNIMacroAssembler<kPointerSize>> GetMacroAssembler( |
| ArenaAllocator* allocator, InstructionSet isa, const InstructionSetFeatures* features) { |
| return JNIMacroAssembler<kPointerSize>::Create(allocator, isa, features); |
| } |
| |
| |
| // Generate the JNI bridge for the given method, general contract: |
| // - Arguments are in the managed runtime format, either on stack or in |
| // registers, a reference to the method object is supplied as part of this |
| // convention. |
| // |
| template <PointerSize kPointerSize> |
| static JniCompiledMethod ArtJniCompileMethodInternal(const CompilerOptions& compiler_options, |
| uint32_t access_flags, |
| uint32_t method_idx, |
| const DexFile& dex_file, |
| ArenaAllocator* allocator) { |
| 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; |
| const bool is_synchronized = (access_flags & kAccSynchronized) != 0; |
| const char* shorty = dex_file.GetMethodShorty(dex_file.GetMethodId(method_idx)); |
| InstructionSet instruction_set = compiler_options.GetInstructionSet(); |
| const InstructionSetFeatures* instruction_set_features = |
| compiler_options.GetInstructionSetFeatures(); |
| |
| // i.e. if the method was annotated with @FastNative |
| const bool is_fast_native = (access_flags & kAccFastNative) != 0u; |
| |
| // i.e. if the method was annotated with @CriticalNative |
| const bool is_critical_native = (access_flags & kAccCriticalNative) != 0u; |
| |
| VLOG(jni) << "JniCompile: Method :: " |
| << dex_file.PrettyMethod(method_idx, /* with signature */ true) |
| << " :: access_flags = " << std::hex << access_flags << std::dec; |
| |
| if (UNLIKELY(is_fast_native)) { |
| VLOG(jni) << "JniCompile: Fast native method detected :: " |
| << dex_file.PrettyMethod(method_idx, /* with signature */ true); |
| } |
| |
| if (UNLIKELY(is_critical_native)) { |
| VLOG(jni) << "JniCompile: Critical native method detected :: " |
| << dex_file.PrettyMethod(method_idx, /* with signature */ true); |
| } |
| |
| if (kIsDebugBuild) { |
| // Don't allow both @FastNative and @CriticalNative. They are mutually exclusive. |
| if (UNLIKELY(is_fast_native && is_critical_native)) { |
| LOG(FATAL) << "JniCompile: Method cannot be both @CriticalNative and @FastNative" |
| << dex_file.PrettyMethod(method_idx, /* with_signature= */ true); |
| } |
| |
| // @CriticalNative - extra checks: |
| // -- Don't allow virtual criticals |
| // -- Don't allow synchronized criticals |
| // -- Don't allow any objects as parameter or return value |
| if (UNLIKELY(is_critical_native)) { |
| CHECK(is_static) |
| << "@CriticalNative functions cannot be virtual since that would" |
| << "require passing a reference parameter (this), which is illegal " |
| << dex_file.PrettyMethod(method_idx, /* with_signature= */ true); |
| CHECK(!is_synchronized) |
| << "@CriticalNative functions cannot be synchronized since that would" |
| << "require passing a (class and/or this) reference parameter, which is illegal " |
| << dex_file.PrettyMethod(method_idx, /* with_signature= */ true); |
| for (size_t i = 0; i < strlen(shorty); ++i) { |
| CHECK_NE(Primitive::kPrimNot, Primitive::GetType(shorty[i])) |
| << "@CriticalNative methods' shorty types must not have illegal references " |
| << dex_file.PrettyMethod(method_idx, /* with_signature= */ true); |
| } |
| } |
| } |
| |
| // Calling conventions used to iterate over parameters to method |
| std::unique_ptr<JniCallingConvention> main_jni_conv = |
| JniCallingConvention::Create(allocator, |
| is_static, |
| is_synchronized, |
| is_fast_native, |
| is_critical_native, |
| shorty, |
| instruction_set); |
| bool reference_return = main_jni_conv->IsReturnAReference(); |
| |
| std::unique_ptr<ManagedRuntimeCallingConvention> mr_conv( |
| ManagedRuntimeCallingConvention::Create( |
| allocator, is_static, is_synchronized, shorty, instruction_set)); |
| |
| // Assembler that holds generated instructions |
| std::unique_ptr<JNIMacroAssembler<kPointerSize>> jni_asm = |
| GetMacroAssembler<kPointerSize>(allocator, instruction_set, instruction_set_features); |
| jni_asm->cfi().SetEnabled(compiler_options.GenerateAnyDebugInfo()); |
| jni_asm->SetEmitRunTimeChecksInDebugMode(compiler_options.EmitRunTimeChecksInDebugMode()); |
| |
| // 1. Build and register the native method frame. |
| |
| // 1.1. Build the frame saving all callee saves, Method*, and PC return address. |
| // For @CriticalNative, this includes space for out args, otherwise just the managed frame. |
| const size_t managed_frame_size = main_jni_conv->FrameSize(); |
| const size_t main_out_arg_size = main_jni_conv->OutFrameSize(); |
| size_t current_frame_size = is_critical_native ? main_out_arg_size : managed_frame_size; |
| ManagedRegister method_register = |
| is_critical_native ? ManagedRegister::NoRegister() : mr_conv->MethodRegister(); |
| ArrayRef<const ManagedRegister> callee_save_regs = main_jni_conv->CalleeSaveRegisters(); |
| __ BuildFrame(current_frame_size, method_register, callee_save_regs); |
| DCHECK_EQ(jni_asm->cfi().GetCurrentCFAOffset(), static_cast<int>(current_frame_size)); |
| |
| // 1.2. Check if we need to go to the slow path to emit the read barrier |
| // 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. |
| std::unique_ptr<JNIMacroLabel> jclass_read_barrier_slow_path; |
| std::unique_ptr<JNIMacroLabel> jclass_read_barrier_return; |
| if (gUseReadBarrier && is_static && LIKELY(!is_critical_native)) { |
| jclass_read_barrier_slow_path = __ CreateLabel(); |
| jclass_read_barrier_return = __ CreateLabel(); |
| |
| // Check if gc_is_marking is set -- if it's not, we don't need a read barrier. |
| __ TestGcMarking(jclass_read_barrier_slow_path.get(), JNIMacroUnaryCondition::kNotZero); |
| |
| // If marking, the slow path returns after the check. |
| __ Bind(jclass_read_barrier_return.get()); |
| } |
| |
| // 1.3 Spill reference register arguments. |
| constexpr FrameOffset kInvalidReferenceOffset = |
| JNIMacroAssembler<kPointerSize>::kInvalidReferenceOffset; |
| ArenaVector<ArgumentLocation> src_args(allocator->Adapter()); |
| ArenaVector<ArgumentLocation> dest_args(allocator->Adapter()); |
| ArenaVector<FrameOffset> refs(allocator->Adapter()); |
| if (LIKELY(!is_critical_native)) { |
| mr_conv->ResetIterator(FrameOffset(current_frame_size)); |
| for (; mr_conv->HasNext(); mr_conv->Next()) { |
| if (mr_conv->IsCurrentParamInRegister() && mr_conv->IsCurrentParamAReference()) { |
| // Spill the reference as raw data. |
| src_args.emplace_back(mr_conv->CurrentParamRegister(), kObjectReferenceSize); |
| dest_args.emplace_back(mr_conv->CurrentParamStackOffset(), kObjectReferenceSize); |
| refs.push_back(kInvalidReferenceOffset); |
| } |
| } |
| __ MoveArguments(ArrayRef<ArgumentLocation>(dest_args), |
| ArrayRef<ArgumentLocation>(src_args), |
| ArrayRef<FrameOffset>(refs)); |
| } |
| |
| // 1.4. Write out the end of the quick frames. After this, we can walk the stack. |
| // 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. |
| if (LIKELY(!is_critical_native)) { |
| __ StoreStackPointerToThread(Thread::TopOfManagedStackOffset<kPointerSize>()); |
| } |
| |
| // 2. Lock the object (if synchronized) and transition out of Runnable (if normal native). |
| |
| // 2.1. Lock the synchronization object (`this` or class) for synchronized methods. |
| if (UNLIKELY(is_synchronized)) { |
| // We are using a custom calling convention for locking where the assembly thunk gets |
| // the object to lock in a register (even on x86), it can use callee-save registers |
| // as temporaries (they were saved above) and must preserve argument registers. |
| ManagedRegister to_lock = main_jni_conv->LockingArgumentRegister(); |
| if (is_static) { |
| // Pass the declaring class. It was already marked if needed. |
| DCHECK_EQ(ArtMethod::DeclaringClassOffset().SizeValue(), 0u); |
| __ Load(to_lock, method_register, MemberOffset(0u), kObjectReferenceSize); |
| } else { |
| // Pass the `this` argument. |
| mr_conv->ResetIterator(FrameOffset(current_frame_size)); |
| if (mr_conv->IsCurrentParamInRegister()) { |
| __ Move(to_lock, mr_conv->CurrentParamRegister(), kObjectReferenceSize); |
| } else { |
| __ Load(to_lock, mr_conv->CurrentParamStackOffset(), kObjectReferenceSize); |
| } |
| } |
| __ CallFromThread(QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniLockObject)); |
| } |
| |
| // 2.2. Transition from Runnable to Suspended. |
| // Managed callee-saves were already saved, so these registers are now available. |
| ArrayRef<const ManagedRegister> callee_save_scratch_regs = UNLIKELY(is_critical_native) |
| ? ArrayRef<const ManagedRegister>() |
| : main_jni_conv->CalleeSaveScratchRegisters(); |
| std::unique_ptr<JNIMacroLabel> transition_to_native_slow_path; |
| std::unique_ptr<JNIMacroLabel> transition_to_native_resume; |
| if (LIKELY(!is_critical_native && !is_fast_native)) { |
| transition_to_native_slow_path = __ CreateLabel(); |
| transition_to_native_resume = __ CreateLabel(); |
| __ TryToTransitionFromRunnableToNative(transition_to_native_slow_path.get(), |
| callee_save_scratch_regs); |
| __ Bind(transition_to_native_resume.get()); |
| } |
| |
| // 3. Push local reference frame. |
| // Skip this for @CriticalNative methods, they cannot use any references. |
| ManagedRegister jni_env_reg = ManagedRegister::NoRegister(); |
| ManagedRegister saved_cookie_reg = ManagedRegister::NoRegister(); |
| ManagedRegister callee_save_temp = ManagedRegister::NoRegister(); |
| if (LIKELY(!is_critical_native)) { |
| // To pop the local reference frame later, we shall need the JNI environment pointer |
| // as well as the cookie, so we preserve them across calls in callee-save registers. |
| CHECK_GE(callee_save_scratch_regs.size(), 3u); // At least 3 for each supported architecture. |
| jni_env_reg = callee_save_scratch_regs[0]; |
| saved_cookie_reg = __ CoreRegisterWithSize(callee_save_scratch_regs[1], kIRTCookieSize); |
| callee_save_temp = __ CoreRegisterWithSize(callee_save_scratch_regs[2], kIRTCookieSize); |
| |
| // Load the JNI environment pointer. |
| __ LoadRawPtrFromThread(jni_env_reg, Thread::JniEnvOffset<kPointerSize>()); |
| |
| // Push the local reference frame. |
| PushLocalReferenceFrame<kPointerSize>( |
| jni_asm.get(), jni_env_reg, saved_cookie_reg, callee_save_temp); |
| } |
| |
| // 4. Make the main native call. |
| |
| // 4.1. Move frame down to allow space for out going args. |
| size_t current_out_arg_size = main_out_arg_size; |
| if (UNLIKELY(is_critical_native)) { |
| DCHECK_EQ(main_out_arg_size, current_frame_size); |
| } else { |
| __ IncreaseFrameSize(main_out_arg_size); |
| current_frame_size += main_out_arg_size; |
| } |
| |
| // 4.2. Fill arguments except the `JNIEnv*`. |
| // Note: Non-null reference arguments in registers may point to the from-space if we |
| // took the slow-path for locking or transition to Native. However, we only need to |
| // compare them with null to construct `jobject`s, so we can still use them. |
| src_args.clear(); |
| dest_args.clear(); |
| refs.clear(); |
| mr_conv->ResetIterator(FrameOffset(current_frame_size)); |
| main_jni_conv->ResetIterator(FrameOffset(main_out_arg_size)); |
| if (UNLIKELY(is_critical_native)) { |
| // Move the method pointer to the hidden argument register. |
| // TODO: Pass this as the last argument, not first. Change ARM assembler |
| // not to expect all register destinations at the beginning. |
| src_args.emplace_back(mr_conv->MethodRegister(), kRawPointerSize); |
| dest_args.emplace_back(main_jni_conv->HiddenArgumentRegister(), kRawPointerSize); |
| refs.push_back(kInvalidReferenceOffset); |
| } else { |
| main_jni_conv->Next(); // Skip JNIEnv*. |
| FrameOffset method_offset(current_out_arg_size + mr_conv->MethodStackOffset().SizeValue()); |
| if (!is_static || main_jni_conv->IsCurrentParamOnStack()) { |
| // The method shall not be available in the `jclass` argument register. |
| // Make sure it is available in `callee_save_temp` for the call below. |
| // (The old method register can be clobbered by argument moves.) |
| ManagedRegister new_method_reg = __ CoreRegisterWithSize(callee_save_temp, kRawPointerSize); |
| DCHECK(!method_register.IsNoRegister()); |
| __ Move(new_method_reg, method_register, kRawPointerSize); |
| method_register = new_method_reg; |
| } |
| if (is_static) { |
| // For static methods, move/load the method to the `jclass` argument. |
| DCHECK_EQ(ArtMethod::DeclaringClassOffset().SizeValue(), 0u); |
| if (method_register.IsNoRegister()) { |
| DCHECK(main_jni_conv->IsCurrentParamInRegister()); |
| src_args.emplace_back(method_offset, kRawPointerSize); |
| } else { |
| src_args.emplace_back(method_register, kRawPointerSize); |
| } |
| if (main_jni_conv->IsCurrentParamInRegister()) { |
| // The `jclass` argument becomes the new method register needed for the call. |
| method_register = main_jni_conv->CurrentParamRegister(); |
| dest_args.emplace_back(method_register, kRawPointerSize); |
| } else { |
| dest_args.emplace_back(main_jni_conv->CurrentParamStackOffset(), kRawPointerSize); |
| } |
| refs.push_back(kInvalidReferenceOffset); |
| main_jni_conv->Next(); |
| } |
| } |
| // Move normal arguments to their locations. |
| for (; mr_conv->HasNext(); mr_conv->Next(), main_jni_conv->Next()) { |
| DCHECK(main_jni_conv->HasNext()); |
| static_assert(kObjectReferenceSize == 4u); |
| bool is_reference = mr_conv->IsCurrentParamAReference(); |
| size_t src_size = (!is_reference && mr_conv->IsCurrentParamALongOrDouble()) ? 8u : 4u; |
| size_t dest_size = is_reference ? kRawPointerSize : src_size; |
| src_args.push_back(mr_conv->IsCurrentParamInRegister() |
| ? ArgumentLocation(mr_conv->CurrentParamRegister(), src_size) |
| : ArgumentLocation(mr_conv->CurrentParamStackOffset(), src_size)); |
| dest_args.push_back(main_jni_conv->IsCurrentParamInRegister() |
| ? ArgumentLocation(main_jni_conv->CurrentParamRegister(), dest_size) |
| : ArgumentLocation(main_jni_conv->CurrentParamStackOffset(), dest_size)); |
| refs.push_back(is_reference ? mr_conv->CurrentParamStackOffset() : kInvalidReferenceOffset); |
| } |
| DCHECK(!main_jni_conv->HasNext()); |
| __ MoveArguments(ArrayRef<ArgumentLocation>(dest_args), |
| ArrayRef<ArgumentLocation>(src_args), |
| ArrayRef<FrameOffset>(refs)); |
| |
| // 4.3. Create 1st argument, the JNI environment ptr. |
| if (LIKELY(!is_critical_native)) { |
| main_jni_conv->ResetIterator(FrameOffset(main_out_arg_size)); |
| if (main_jni_conv->IsCurrentParamInRegister()) { |
| ManagedRegister jni_env_arg = main_jni_conv->CurrentParamRegister(); |
| __ Move(jni_env_arg, jni_env_reg, kRawPointerSize); |
| } else { |
| FrameOffset jni_env_arg_offset = main_jni_conv->CurrentParamStackOffset(); |
| __ Store(jni_env_arg_offset, jni_env_reg, kRawPointerSize); |
| } |
| } |
| |
| // 4.4. Plant call to native code associated with method. |
| MemberOffset jni_entrypoint_offset = |
| ArtMethod::EntryPointFromJniOffset(InstructionSetPointerSize(instruction_set)); |
| if (UNLIKELY(is_critical_native)) { |
| if (main_jni_conv->UseTailCall()) { |
| __ Jump(main_jni_conv->HiddenArgumentRegister(), jni_entrypoint_offset); |
| } else { |
| __ 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(); |
| } |
| |
| // 4.5. Fix differences in result widths. |
| if (main_jni_conv->RequiresSmallResultTypeExtension()) { |
| DCHECK(main_jni_conv->HasSmallReturnType()); |
| CHECK_IMPLIES(is_critical_native, !main_jni_conv->UseTailCall()); |
| if (main_jni_conv->GetReturnType() == Primitive::kPrimByte || |
| main_jni_conv->GetReturnType() == Primitive::kPrimShort) { |
| __ SignExtend(main_jni_conv->ReturnRegister(), |
| Primitive::ComponentSize(main_jni_conv->GetReturnType())); |
| } else { |
| CHECK(main_jni_conv->GetReturnType() == Primitive::kPrimBoolean || |
| main_jni_conv->GetReturnType() == Primitive::kPrimChar); |
| __ ZeroExtend(main_jni_conv->ReturnRegister(), |
| Primitive::ComponentSize(main_jni_conv->GetReturnType())); |
| } |
| } |
| |
| // 4.6. Move the JNI return register into the managed return register (if they don't match). |
| if (main_jni_conv->SizeOfReturnValue() != 0) { |
| ManagedRegister jni_return_reg = main_jni_conv->ReturnRegister(); |
| ManagedRegister mr_return_reg = mr_conv->ReturnRegister(); |
| |
| // Check if the JNI return register matches the managed return register. |
| // 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_IMPLIES(is_critical_native, !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. |
| __ Move(mr_return_reg, jni_return_reg, main_jni_conv->SizeOfReturnValue()); |
| } else if (jni_return_reg.IsNoRegister() && mr_return_reg.IsNoRegister()) { |
| // Check that if the return value is passed on the stack for some reason, |
| // that the size matches. |
| CHECK_EQ(main_jni_conv->SizeOfReturnValue(), mr_conv->SizeOfReturnValue()); |
| } |
| } |
| |
| // 5. Transition to Runnable (if normal native). |
| |
| // 5.1. Try transitioning to Runnable with a fast-path implementation. |
| // If fast-path fails, make a slow-path call to `JniMethodEnd()`. |
| std::unique_ptr<JNIMacroLabel> transition_to_runnable_slow_path; |
| std::unique_ptr<JNIMacroLabel> transition_to_runnable_resume; |
| if (LIKELY(!is_critical_native && !is_fast_native)) { |
| transition_to_runnable_slow_path = __ CreateLabel(); |
| transition_to_runnable_resume = __ CreateLabel(); |
| __ TryToTransitionFromNativeToRunnable(transition_to_runnable_slow_path.get(), |
| main_jni_conv->ArgumentScratchRegisters(), |
| mr_conv->ReturnRegister()); |
| __ Bind(transition_to_runnable_resume.get()); |
| } |
| |
| // 5.2. For methods that return 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 (reference_return) { |
| DCHECK(!is_critical_native); |
| __ ExceptionPoll(exception_slow_path.get()); |
| } |
| |
| // 5.3. 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()); |
| } |
| |
| // 5.4 For methods with reference return, decode the `jobject` with `JniDecodeReferenceResult()`. |
| if (reference_return) { |
| DCHECK(!is_critical_native); |
| // We abuse the JNI calling convention here, that is guaranteed to support passing |
| // two pointer arguments, `JNIEnv*` and `jclass`/`jobject`. |
| main_jni_conv->ResetIterator(FrameOffset(main_out_arg_size)); |
| ThreadOffset<kPointerSize> jni_decode_reference_result = |
| QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniDecodeReferenceResult); |
| // Pass result. |
| SetNativeParameter(jni_asm.get(), main_jni_conv.get(), mr_conv->ReturnRegister()); |
| main_jni_conv->Next(); |
| if (main_jni_conv->IsCurrentParamInRegister()) { |
| __ GetCurrentThread(main_jni_conv->CurrentParamRegister()); |
| __ Call(main_jni_conv->CurrentParamRegister(), Offset(jni_decode_reference_result)); |
| } else { |
| __ GetCurrentThread(main_jni_conv->CurrentParamStackOffset()); |
| __ CallFromThread(jni_decode_reference_result); |
| } |
| } // if (!is_critical_native) |
| |
| // 6. Pop local reference frame. |
| if (LIKELY(!is_critical_native)) { |
| PopLocalReferenceFrame<kPointerSize>( |
| jni_asm.get(), jni_env_reg, saved_cookie_reg, callee_save_temp); |
| } |
| |
| // 7. Return from the JNI stub. |
| |
| // 7.1. 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; |
| } |
| |
| // 7.2 Unlock the synchronization object for synchronized methods. |
| // Do this before exception poll to avoid extra unlocking in the exception slow path. |
| if (UNLIKELY(is_synchronized)) { |
| ManagedRegister to_lock = main_jni_conv->LockingArgumentRegister(); |
| mr_conv->ResetIterator(FrameOffset(current_frame_size)); |
| if (is_static) { |
| // Pass the declaring class. |
| DCHECK(method_register.IsNoRegister()); // TODO: Preserve the method in `callee_save_temp`. |
| ManagedRegister temp = __ CoreRegisterWithSize(callee_save_temp, kRawPointerSize); |
| FrameOffset method_offset = mr_conv->MethodStackOffset(); |
| __ Load(temp, method_offset, kRawPointerSize); |
| DCHECK_EQ(ArtMethod::DeclaringClassOffset().SizeValue(), 0u); |
| __ Load(to_lock, temp, MemberOffset(0u), kObjectReferenceSize); |
| } else { |
| // Pass the `this` argument from its spill slot. |
| __ Load(to_lock, mr_conv->CurrentParamStackOffset(), kObjectReferenceSize); |
| } |
| __ CallFromThread(QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniUnlockObject)); |
| } |
| |
| // 7.3. Process pending exceptions from JNI call or monitor exit. |
| // @CriticalNative methods do not need exception poll in the stub. |
| // Methods with reference return emit the exception poll earlier. |
| if (LIKELY(!is_critical_native) && !reference_return) { |
| __ ExceptionPoll(exception_slow_path.get()); |
| } |
| |
| // 7.4. 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()); |
| } |
| |
| // 7.5. 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()) { |
| // We expect the compiled method to possibly be suspended during its |
| // execution, except in the case of a CriticalNative method. |
| bool may_suspend = !is_critical_native; |
| __ RemoveFrame(current_frame_size, callee_save_regs, may_suspend); |
| DCHECK_EQ(jni_asm->cfi().GetCurrentCFAOffset(), static_cast<int>(current_frame_size)); |
| } |
| |
| // 8. Emit slow paths. |
| |
| // 8.1. 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 (gUseReadBarrier && is_static && !is_critical_native) { |
| __ Bind(jclass_read_barrier_slow_path.get()); |
| |
| // Construct slow path for read barrier: |
| // |
| // For baker read barrier, do a fast check whether the class is already marked. |
| // |
| // Call into the runtime's `art_jni_read_barrier` and have it fix up |
| // the class address if it was moved. |
| // |
| // The entrypoint preserves the method register and argument registers. |
| |
| if (kUseBakerReadBarrier) { |
| // We enter the slow path with the method register unclobbered and callee-save |
| // registers already spilled, so we can use callee-save scratch registers. |
| method_register = mr_conv->MethodRegister(); |
| ManagedRegister temp = __ CoreRegisterWithSize( |
| main_jni_conv->CalleeSaveScratchRegisters()[0], kObjectReferenceSize); |
| // Load the declaring class reference. |
| DCHECK_EQ(ArtMethod::DeclaringClassOffset().SizeValue(), 0u); |
| __ Load(temp, method_register, MemberOffset(0u), kObjectReferenceSize); |
| // Return to main path if the class object is marked. |
| __ TestMarkBit(temp, jclass_read_barrier_return.get(), JNIMacroUnaryCondition::kNotZero); |
| } |
| |
| ThreadOffset<kPointerSize> read_barrier = QUICK_ENTRYPOINT_OFFSET(kPointerSize, |
| pJniReadBarrier); |
| __ CallFromThread(read_barrier); |
| |
| // Return to main path. |
| __ Jump(jclass_read_barrier_return.get()); |
| } |
| |
| // 8.2. Slow path for transition to Native. |
| if (LIKELY(!is_critical_native && !is_fast_native)) { |
| __ Bind(transition_to_native_slow_path.get()); |
| __ CallFromThread(QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodStart)); |
| __ Jump(transition_to_native_resume.get()); |
| } |
| |
| // 8.3. Slow path for transition to Runnable. |
| if (LIKELY(!is_critical_native && !is_fast_native)) { |
| __ Bind(transition_to_runnable_slow_path.get()); |
| __ CallFromThread(QUICK_ENTRYPOINT_OFFSET(kPointerSize, pJniMethodEnd)); |
| __ Jump(transition_to_runnable_resume.get()); |
| } |
| |
| // 8.4. 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()); |
| } |
| |
| // 8.5. Exception poll slow path(s). |
| if (LIKELY(!is_critical_native)) { |
| __ Bind(exception_slow_path.get()); |
| if (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)); |
| __ DeliverPendingException(); |
| } |
| |
| // 9. Finalize code generation. |
| __ FinalizeCode(); |
| size_t cs = __ CodeSize(); |
| std::vector<uint8_t> managed_code(cs); |
| MemoryRegion code(&managed_code[0], managed_code.size()); |
| __ FinalizeInstructions(code); |
| |
| return JniCompiledMethod(instruction_set, |
| std::move(managed_code), |
| managed_frame_size, |
| main_jni_conv->CoreSpillMask(), |
| main_jni_conv->FpSpillMask(), |
| ArrayRef<const uint8_t>(*jni_asm->cfi().data())); |
| } |
| |
| template <PointerSize kPointerSize> |
| 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); |
| |
| // Load the old cookie that we shall need to restore. |
| __ Load(saved_cookie_reg, jni_env_reg, jni_env_cookie_offset, kIRTCookieSize); |
| |
| // Set the cookie in JNI environment to the current segment state. |
| __ Load(temp_reg, jni_env_reg, jni_env_segment_state_offset, kIRTCookieSize); |
| __ Store(jni_env_reg, jni_env_cookie_offset, temp_reg, kIRTCookieSize); |
| } |
| |
| template <PointerSize kPointerSize> |
| 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); |
| |
| // Set the current segment state to the current cookie in JNI environment. |
| __ Load(temp_reg, jni_env_reg, jni_env_cookie_offset, kIRTCookieSize); |
| __ Store(jni_env_reg, jni_env_segment_state_offset, temp_reg, kIRTCookieSize); |
| |
| // Restore the cookie in JNI environment to the saved value. |
| __ Store(jni_env_reg, jni_env_cookie_offset, saved_cookie_reg, kIRTCookieSize); |
| } |
| |
| template <PointerSize kPointerSize> |
| static void SetNativeParameter(JNIMacroAssembler<kPointerSize>* jni_asm, |
| JniCallingConvention* jni_conv, |
| ManagedRegister in_reg) { |
| if (jni_conv->IsCurrentParamOnStack()) { |
| FrameOffset dest = jni_conv->CurrentParamStackOffset(); |
| __ StoreRawPtr(dest, in_reg); |
| } else { |
| if (!jni_conv->CurrentParamRegister().Equals(in_reg)) { |
| __ Move(jni_conv->CurrentParamRegister(), in_reg, jni_conv->CurrentParamSize()); |
| } |
| } |
| } |
| |
| JniCompiledMethod ArtQuickJniCompileMethod(const CompilerOptions& compiler_options, |
| uint32_t access_flags, |
| uint32_t method_idx, |
| const DexFile& dex_file, |
| ArenaAllocator* allocator) { |
| if (Is64BitInstructionSet(compiler_options.GetInstructionSet())) { |
| return ArtJniCompileMethodInternal<PointerSize::k64>( |
| compiler_options, access_flags, method_idx, dex_file, allocator); |
| } else { |
| return ArtJniCompileMethodInternal<PointerSize::k32>( |
| compiler_options, access_flags, method_idx, dex_file, allocator); |
| } |
| } |
| |
| } // namespace art |
