Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 1 | // Copyright 2011 Google Inc. All Rights Reserved. |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 2 | |
| 3 | #include "jni_compiler.h" |
| 4 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 5 | #include <sys/mman.h> |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 6 | #include <vector> |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 7 | |
| 8 | #include "assembler.h" |
| 9 | #include "calling_convention.h" |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 10 | #include "compiled_method.h" |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 11 | #include "constants.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 12 | #include "jni_internal.h" |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 13 | #include "logging.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 14 | #include "macros.h" |
| 15 | #include "managed_register.h" |
Brian Carlstrom | 578bbdc | 2011-07-21 14:07:47 -0700 | [diff] [blame] | 16 | #include "thread.h" |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 17 | #include "UniquePtr.h" |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 18 | |
| 19 | namespace art { |
| 20 | |
Shih-wei Liao | 31384c5 | 2011-09-06 15:27:45 -0700 | [diff] [blame] | 21 | namespace arm { |
| 22 | ByteArray* CreateJniStub(); |
| 23 | } |
| 24 | |
| 25 | namespace x86 { |
| 26 | ByteArray* CreateJniStub(); |
| 27 | } |
| 28 | |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 29 | ByteArray* JniCompiler::CreateJniStub(InstructionSet instruction_set) { |
| 30 | switch (instruction_set) { |
| 31 | case kArm: |
| 32 | case kThumb2: |
| 33 | return arm::CreateJniStub(); |
| 34 | case kX86: |
| 35 | return x86::CreateJniStub(); |
| 36 | default: |
| 37 | LOG(FATAL) << "Unknown InstructionSet " << (int) instruction_set; |
| 38 | return NULL; |
| 39 | } |
| 40 | } |
| 41 | |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 42 | JniCompiler::JniCompiler(InstructionSet instruction_set) { |
| 43 | if (instruction_set == kThumb2) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 44 | // currently only ARM code generation is supported |
| 45 | instruction_set_ = kArm; |
| 46 | } else { |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 47 | instruction_set_ = instruction_set; |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 48 | } |
| 49 | } |
| 50 | |
| 51 | JniCompiler::~JniCompiler() {} |
| 52 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 53 | // Generate the JNI bridge for the given method, general contract: |
| 54 | // - Arguments are in the managed runtime format, either on stack or in |
| 55 | // registers, a reference to the method object is supplied as part of this |
| 56 | // convention. |
| 57 | // |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 58 | CompiledMethod* JniCompiler::Compile(const Method* native_method) { |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 59 | CHECK(native_method->IsNative()); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 60 | |
| 61 | // Calling conventions used to iterate over parameters to method |
| 62 | UniquePtr<JniCallingConvention> jni_conv( |
| 63 | JniCallingConvention::Create(native_method, instruction_set_)); |
| 64 | UniquePtr<ManagedRuntimeCallingConvention> mr_conv( |
| 65 | ManagedRuntimeCallingConvention::Create(native_method, instruction_set_)); |
| 66 | |
| 67 | // Assembler that holds generated instructions |
| 68 | UniquePtr<Assembler> jni_asm(Assembler::Create(instruction_set_)); |
| 69 | #define __ jni_asm-> |
| 70 | |
| 71 | // Offsets into data structures |
| 72 | // TODO: if cross compiling these offsets are for the host not the target |
| 73 | const Offset functions(OFFSETOF_MEMBER(JNIEnvExt, functions)); |
| 74 | const Offset monitor_enter(OFFSETOF_MEMBER(JNINativeInterface, MonitorEnter)); |
| 75 | const Offset monitor_exit(OFFSETOF_MEMBER(JNINativeInterface, MonitorExit)); |
| 76 | |
| 77 | // Cache of IsStatic as we call it often enough |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 78 | const bool is_static = native_method->IsStatic(); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 79 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 80 | // 1. Build the frame saving all callee saves |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 81 | const size_t frame_size(jni_conv->FrameSize()); |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 82 | const std::vector<ManagedRegister>& callee_save_regs = jni_conv->CalleeSaveRegisters(); |
| 83 | __ BuildFrame(frame_size, mr_conv->MethodRegister(), callee_save_regs); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 84 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 85 | // 2. Set up the StackIndirectReferenceTable |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 86 | mr_conv->ResetIterator(FrameOffset(frame_size)); |
| 87 | jni_conv->ResetIterator(FrameOffset(0)); |
| 88 | __ StoreImmediateToFrame(jni_conv->SirtNumRefsOffset(), |
| 89 | jni_conv->ReferenceCount(), |
| 90 | mr_conv->InterproceduralScratchRegister()); |
| 91 | __ CopyRawPtrFromThread(jni_conv->SirtLinkOffset(), |
| 92 | Thread::TopSirtOffset(), |
| 93 | mr_conv->InterproceduralScratchRegister()); |
| 94 | __ StoreStackOffsetToThread(Thread::TopSirtOffset(), |
| 95 | jni_conv->SirtOffset(), |
| 96 | mr_conv->InterproceduralScratchRegister()); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 97 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 98 | // 3. Place incoming reference arguments into SIRT |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 99 | jni_conv->Next(); // Skip JNIEnv* |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 100 | // 3.5. Create Class argument for static methods out of passed method |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 101 | if (is_static) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 102 | FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset(); |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 103 | // Check sirt offset is within frame |
| 104 | CHECK_LT(sirt_offset.Uint32Value(), frame_size); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 105 | __ LoadRef(jni_conv->InterproceduralScratchRegister(), |
| 106 | mr_conv->MethodRegister(), Method::DeclaringClassOffset()); |
| 107 | __ VerifyObject(jni_conv->InterproceduralScratchRegister(), false); |
| 108 | __ StoreRef(sirt_offset, jni_conv->InterproceduralScratchRegister()); |
| 109 | jni_conv->Next(); // in SIRT so move to next argument |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 110 | } |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 111 | while (mr_conv->HasNext()) { |
| 112 | CHECK(jni_conv->HasNext()); |
| 113 | bool ref_param = jni_conv->IsCurrentParamAReference(); |
| 114 | CHECK(!ref_param || mr_conv->IsCurrentParamAReference()); |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 115 | // References need placing in SIRT and the entry value passing |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 116 | if (ref_param) { |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 117 | // Compute SIRT entry, note null is placed in the SIRT but its boxed value |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 118 | // must be NULL |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 119 | FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset(); |
Ian Rogers | 5a7a74a | 2011-09-26 16:32:29 -0700 | [diff] [blame] | 120 | // Check SIRT offset is within frame and doesn't run into the saved segment state |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 121 | CHECK_LT(sirt_offset.Uint32Value(), frame_size); |
Ian Rogers | 5a7a74a | 2011-09-26 16:32:29 -0700 | [diff] [blame] | 122 | CHECK_NE(sirt_offset.Uint32Value(), |
| 123 | jni_conv->SavedLocalReferenceCookieOffset().Uint32Value()); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 124 | bool input_in_reg = mr_conv->IsCurrentParamInRegister(); |
| 125 | bool input_on_stack = mr_conv->IsCurrentParamOnStack(); |
Shih-wei Liao | 5381cf9 | 2011-07-27 00:28:04 -0700 | [diff] [blame] | 126 | CHECK(input_in_reg || input_on_stack); |
| 127 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 128 | if (input_in_reg) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 129 | ManagedRegister in_reg = mr_conv->CurrentParamRegister(); |
| 130 | __ VerifyObject(in_reg, mr_conv->IsCurrentArgPossiblyNull()); |
| 131 | __ StoreRef(sirt_offset, in_reg); |
Shih-wei Liao | 5381cf9 | 2011-07-27 00:28:04 -0700 | [diff] [blame] | 132 | } else if (input_on_stack) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 133 | FrameOffset in_off = mr_conv->CurrentParamStackOffset(); |
| 134 | __ VerifyObject(in_off, mr_conv->IsCurrentArgPossiblyNull()); |
| 135 | __ CopyRef(sirt_offset, in_off, |
| 136 | mr_conv->InterproceduralScratchRegister()); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 137 | } |
| 138 | } |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 139 | mr_conv->Next(); |
| 140 | jni_conv->Next(); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 141 | } |
| 142 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 143 | // 4. Transition from being in managed to native code. Save the top_of_managed_stack_ |
| 144 | // so that the managed stack can be crawled while in native code. Clear the corresponding |
| 145 | // PC value that has no meaning for the this frame. |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 146 | __ StoreStackPointerToThread(Thread::TopOfManagedStackOffset()); |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 147 | __ StoreImmediateToThread(Thread::TopOfManagedStackPcOffset(), 0, |
| 148 | mr_conv->InterproceduralScratchRegister()); |
Ian Rogers | e5de95b | 2011-09-18 20:31:38 -0700 | [diff] [blame] | 149 | ChangeThreadState(jni_asm.get(), Thread::kNative, |
| 150 | mr_conv->InterproceduralScratchRegister(), |
| 151 | ManagedRegister::NoRegister(), FrameOffset(0), 0); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 152 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 153 | // 5. Move frame down to allow space for out going args. Do for as short a |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 154 | // time as possible to aid profiling.. |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 155 | const size_t out_arg_size = jni_conv->OutArgSize(); |
| 156 | __ IncreaseFrameSize(out_arg_size); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 157 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 158 | // 6. Acquire lock for synchronized methods. |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 159 | if (native_method->IsSynchronized()) { |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 160 | // Compute arguments in registers to preserve |
| 161 | mr_conv->ResetIterator(FrameOffset(frame_size + out_arg_size)); |
| 162 | std::vector<ManagedRegister> live_argument_regs; |
| 163 | while (mr_conv->HasNext()) { |
| 164 | if (mr_conv->IsCurrentParamInRegister()) { |
| 165 | live_argument_regs.push_back(mr_conv->CurrentParamRegister()); |
| 166 | } |
| 167 | mr_conv->Next(); |
| 168 | } |
| 169 | |
| 170 | // Copy arguments to preserve to callee save registers |
| 171 | CHECK_LE(live_argument_regs.size(), callee_save_regs.size()); |
| 172 | for (size_t i = 0; i < live_argument_regs.size(); i++) { |
| 173 | __ Move(callee_save_regs.at(i), live_argument_regs.at(i)); |
| 174 | } |
| 175 | |
| 176 | // Get SIRT entry for 1st argument (jclass or this) to be 1st argument to |
| 177 | // monitor enter |
| 178 | mr_conv->ResetIterator(FrameOffset(frame_size + out_arg_size)); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 179 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
| 180 | jni_conv->Next(); // Skip JNIEnv* |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 181 | if (is_static) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 182 | FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset(); |
| 183 | if (jni_conv->IsCurrentParamOnStack()) { |
| 184 | FrameOffset out_off = jni_conv->CurrentParamStackOffset(); |
| 185 | __ CreateSirtEntry(out_off, sirt_offset, |
| 186 | mr_conv->InterproceduralScratchRegister(), |
| 187 | false); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 188 | } else { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 189 | ManagedRegister out_reg = jni_conv->CurrentParamRegister(); |
| 190 | __ CreateSirtEntry(out_reg, sirt_offset, |
| 191 | ManagedRegister::NoRegister(), false); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 192 | } |
| 193 | } else { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 194 | CopyParameter(jni_asm.get(), mr_conv.get(), jni_conv.get(), frame_size, |
| 195 | out_arg_size); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 196 | } |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 197 | |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 198 | // Generate JNIEnv* in place and leave a copy in jni_fns_register |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 199 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 200 | ManagedRegister jni_fns_register = |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 201 | jni_conv->InterproceduralScratchRegister(); |
| 202 | __ LoadRawPtrFromThread(jni_fns_register, Thread::JniEnvOffset()); |
| 203 | SetNativeParameter(jni_asm.get(), jni_conv.get(), jni_fns_register); |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 204 | |
Ian Rogers | a04d397 | 2011-08-17 11:33:44 -0700 | [diff] [blame] | 205 | // Call JNIEnv->MonitorEnter(object) |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 206 | __ LoadRawPtr(jni_fns_register, jni_fns_register, functions); |
| 207 | __ Call(jni_fns_register, monitor_enter, |
| 208 | jni_conv->InterproceduralScratchRegister()); |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 209 | |
| 210 | // Check for exceptions |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 211 | __ ExceptionPoll(jni_conv->InterproceduralScratchRegister()); |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 212 | |
| 213 | // Restore live arguments |
| 214 | for (size_t i = 0; i < live_argument_regs.size(); i++) { |
| 215 | __ Move(live_argument_regs.at(i), callee_save_regs.at(i)); |
| 216 | } |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 217 | } |
| 218 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 219 | // 7. Iterate over arguments placing values from managed calling convention in |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 220 | // to the convention required for a native call (shuffling). For references |
| 221 | // place an index/pointer to the reference after checking whether it is |
| 222 | // NULL (which must be encoded as NULL). |
Elliott Hughes | 20cde90 | 2011-10-04 17:37:27 -0700 | [diff] [blame] | 223 | // Note: we do this prior to materializing the JNIEnv* and static's jclass to |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 224 | // give as many free registers for the shuffle as possible |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 225 | mr_conv->ResetIterator(FrameOffset(frame_size+out_arg_size)); |
Shih-wei Liao | 82da44b | 2011-09-01 00:38:04 -0700 | [diff] [blame] | 226 | uint32_t args_count = 0; |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 227 | while (mr_conv->HasNext()) { |
Shih-wei Liao | 82da44b | 2011-09-01 00:38:04 -0700 | [diff] [blame] | 228 | args_count++; |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 229 | mr_conv->Next(); |
Carl Shapiro | e2d373e | 2011-07-25 15:20:06 -0700 | [diff] [blame] | 230 | } |
Shih-wei Liao | 82da44b | 2011-09-01 00:38:04 -0700 | [diff] [blame] | 231 | |
| 232 | // Do a backward pass over arguments, so that the generated code will be "mov |
| 233 | // R2, R3; mov R1, R2" instead of "mov R1, R2; mov R2, R3." |
| 234 | // TODO: A reverse iterator to improve readability. |
| 235 | for (uint32_t i = 0; i < args_count; ++i) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 236 | mr_conv->ResetIterator(FrameOffset(frame_size + out_arg_size)); |
| 237 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
| 238 | jni_conv->Next(); // Skip JNIEnv* |
Shih-wei Liao | 82da44b | 2011-09-01 00:38:04 -0700 | [diff] [blame] | 239 | if (is_static) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 240 | jni_conv->Next(); // Skip Class for now |
Shih-wei Liao | 82da44b | 2011-09-01 00:38:04 -0700 | [diff] [blame] | 241 | } |
| 242 | for (uint32_t j = 0; j < args_count - i - 1; ++j) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 243 | mr_conv->Next(); |
| 244 | jni_conv->Next(); |
Shih-wei Liao | 82da44b | 2011-09-01 00:38:04 -0700 | [diff] [blame] | 245 | } |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 246 | CopyParameter(jni_asm.get(), mr_conv.get(), jni_conv.get(), frame_size, out_arg_size); |
Shih-wei Liao | 82da44b | 2011-09-01 00:38:04 -0700 | [diff] [blame] | 247 | } |
| 248 | |
Carl Shapiro | e2d373e | 2011-07-25 15:20:06 -0700 | [diff] [blame] | 249 | if (is_static) { |
| 250 | // Create argument for Class |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 251 | mr_conv->ResetIterator(FrameOffset(frame_size+out_arg_size)); |
| 252 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
| 253 | jni_conv->Next(); // Skip JNIEnv* |
| 254 | FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset(); |
| 255 | if (jni_conv->IsCurrentParamOnStack()) { |
| 256 | FrameOffset out_off = jni_conv->CurrentParamStackOffset(); |
| 257 | __ CreateSirtEntry(out_off, sirt_offset, |
| 258 | mr_conv->InterproceduralScratchRegister(), |
| 259 | false); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 260 | } else { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 261 | ManagedRegister out_reg = jni_conv->CurrentParamRegister(); |
| 262 | __ CreateSirtEntry(out_reg, sirt_offset, |
| 263 | ManagedRegister::NoRegister(), false); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 264 | } |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 265 | } |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 266 | // 8. Create 1st argument, the JNI environment ptr and save the top of the local reference table |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 267 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 268 | // Register that will hold local indirect reference table |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 269 | if (jni_conv->IsCurrentParamInRegister()) { |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 270 | ManagedRegister jni_env = jni_conv->CurrentParamRegister(); |
| 271 | DCHECK(!jni_env.Equals(jni_conv->InterproceduralScratchRegister())); |
| 272 | __ LoadRawPtrFromThread(jni_env, Thread::JniEnvOffset()); |
Ian Rogers | 5a7a74a | 2011-09-26 16:32:29 -0700 | [diff] [blame] | 273 | // Frame[saved_local_ref_cookie_offset] = env->local_ref_cookie |
| 274 | __ Copy(jni_conv->SavedLocalReferenceCookieOffset(), |
| 275 | jni_env, JNIEnvExt::LocalRefCookieOffset(), |
| 276 | jni_conv->InterproceduralScratchRegister(), 4); |
| 277 | // env->local_ref_cookie = env->locals.segment_state |
| 278 | __ Copy(jni_env, JNIEnvExt::LocalRefCookieOffset(), |
| 279 | jni_env, JNIEnvExt::SegmentStateOffset(), |
| 280 | jni_conv->InterproceduralScratchRegister(), 4); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 281 | } else { |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 282 | FrameOffset jni_env = jni_conv->CurrentParamStackOffset(); |
| 283 | __ CopyRawPtrFromThread(jni_env, Thread::JniEnvOffset(), |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 284 | jni_conv->InterproceduralScratchRegister()); |
Ian Rogers | 5a7a74a | 2011-09-26 16:32:29 -0700 | [diff] [blame] | 285 | // Frame[saved_local_ref_cookie_offset] = env->local_ref_cookie |
| 286 | __ Copy(jni_conv->SavedLocalReferenceCookieOffset(), |
| 287 | jni_env, JNIEnvExt::LocalRefCookieOffset(), |
| 288 | jni_conv->InterproceduralScratchRegister(), 4); |
| 289 | // env->local_ref_cookie = env->locals.segment_state |
| 290 | __ Copy(jni_env, JNIEnvExt::LocalRefCookieOffset(), |
| 291 | jni_env, JNIEnvExt::SegmentStateOffset(), |
| 292 | jni_conv->InterproceduralScratchRegister(), 4); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 293 | } |
| 294 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 295 | // 9. Plant call to native code associated with method |
Ian Rogers | ad42e13 | 2011-09-17 20:23:33 -0700 | [diff] [blame] | 296 | if (!jni_conv->IsMethodRegisterClobberedPreCall()) { |
Carl Shapiro | e2d373e | 2011-07-25 15:20:06 -0700 | [diff] [blame] | 297 | // Method register shouldn't have been crushed by setting up outgoing |
| 298 | // arguments |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 299 | __ Call(mr_conv->MethodRegister(), Method::NativeMethodOffset(), |
| 300 | mr_conv->InterproceduralScratchRegister()); |
Carl Shapiro | e2d373e | 2011-07-25 15:20:06 -0700 | [diff] [blame] | 301 | } else { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 302 | __ Call(jni_conv->MethodStackOffset(), Method::NativeMethodOffset(), |
| 303 | mr_conv->InterproceduralScratchRegister()); |
Carl Shapiro | e2d373e | 2011-07-25 15:20:06 -0700 | [diff] [blame] | 304 | } |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 305 | |
| 306 | // 10. Release lock for synchronized methods. |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 307 | if (native_method->IsSynchronized()) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 308 | mr_conv->ResetIterator(FrameOffset(frame_size+out_arg_size)); |
| 309 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
| 310 | jni_conv->Next(); // Skip JNIEnv* |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 311 | // Save return value |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 312 | FrameOffset return_save_location = jni_conv->ReturnValueSaveLocation(); |
| 313 | if (jni_conv->SizeOfReturnValue() != 0) { |
| 314 | FrameOffset return_save_location = jni_conv->ReturnValueSaveLocation(); |
Ian Rogers | 4ff5dad | 2011-09-07 13:56:27 -0700 | [diff] [blame] | 315 | CHECK_LT(return_save_location.Uint32Value(), frame_size+out_arg_size); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 316 | __ Store(return_save_location, jni_conv->ReturnRegister(), |
| 317 | jni_conv->SizeOfReturnValue()); |
Ian Rogers | 4ff5dad | 2011-09-07 13:56:27 -0700 | [diff] [blame] | 318 | } |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 319 | // Get SIRT entry for 1st argument |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 320 | if (is_static) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 321 | FrameOffset sirt_offset = jni_conv->CurrentParamSirtEntryOffset(); |
| 322 | if (jni_conv->IsCurrentParamOnStack()) { |
| 323 | FrameOffset out_off = jni_conv->CurrentParamStackOffset(); |
| 324 | __ CreateSirtEntry(out_off, sirt_offset, |
| 325 | mr_conv->InterproceduralScratchRegister(), |
| 326 | false); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 327 | } else { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 328 | ManagedRegister out_reg = jni_conv->CurrentParamRegister(); |
| 329 | __ CreateSirtEntry(out_reg, sirt_offset, |
| 330 | ManagedRegister::NoRegister(), false); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 331 | } |
| 332 | } else { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 333 | CopyParameter(jni_asm.get(), mr_conv.get(), jni_conv.get(), frame_size, |
| 334 | out_arg_size); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 335 | } |
| 336 | // Generate JNIEnv* in place and leave a copy in jni_env_register |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 337 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 338 | ManagedRegister jni_env_register = |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 339 | jni_conv->InterproceduralScratchRegister(); |
| 340 | __ LoadRawPtrFromThread(jni_env_register, Thread::JniEnvOffset()); |
| 341 | SetNativeParameter(jni_asm.get(), jni_conv.get(), jni_env_register); |
Ian Rogers | a04d397 | 2011-08-17 11:33:44 -0700 | [diff] [blame] | 342 | // Call JNIEnv->MonitorExit(object) |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 343 | __ LoadRawPtr(jni_env_register, jni_env_register, functions); |
| 344 | __ Call(jni_env_register, monitor_exit, |
| 345 | jni_conv->InterproceduralScratchRegister()); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 346 | // Reload return value |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 347 | if (jni_conv->SizeOfReturnValue() != 0) { |
| 348 | __ Load(jni_conv->ReturnRegister(), return_save_location, |
| 349 | jni_conv->SizeOfReturnValue()); |
Ian Rogers | 4ff5dad | 2011-09-07 13:56:27 -0700 | [diff] [blame] | 350 | } |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 351 | } |
| 352 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 353 | // 11. Release outgoing argument area |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 354 | __ DecreaseFrameSize(out_arg_size); |
| 355 | mr_conv->ResetIterator(FrameOffset(frame_size)); |
| 356 | jni_conv->ResetIterator(FrameOffset(0)); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 357 | |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 358 | // 12. Transition from being in native to managed code, possibly entering a |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 359 | // safepoint |
Ian Rogers | e5de95b | 2011-09-18 20:31:38 -0700 | [diff] [blame] | 360 | // Don't clobber result |
| 361 | CHECK(!jni_conv->InterproceduralScratchRegister().Equals(jni_conv->ReturnRegister())); |
Ian Rogers | 45a76cb | 2011-07-21 22:00:15 -0700 | [diff] [blame] | 362 | // Location to preserve result on slow path, ensuring its within the frame |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 363 | FrameOffset return_save_location = jni_conv->ReturnValueSaveLocation(); |
Ian Rogers | 4ff5dad | 2011-09-07 13:56:27 -0700 | [diff] [blame] | 364 | CHECK(return_save_location.Uint32Value() < frame_size || |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 365 | jni_conv->SizeOfReturnValue() == 0); |
Ian Rogers | e5de95b | 2011-09-18 20:31:38 -0700 | [diff] [blame] | 366 | ChangeThreadState(jni_asm.get(), Thread::kRunnable, |
| 367 | jni_conv->InterproceduralScratchRegister(), |
| 368 | jni_conv->ReturnRegister(), return_save_location, |
| 369 | jni_conv->SizeOfReturnValue()); |
| 370 | |
Elliott Hughes | 726079d | 2011-10-07 18:43:44 -0700 | [diff] [blame] | 371 | // 13. Place result in correct register possibly loading from indirect |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 372 | // reference table |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 373 | if (jni_conv->IsReturnAReference()) { |
| 374 | __ IncreaseFrameSize(out_arg_size); |
| 375 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 376 | |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 377 | jni_conv->Next(); // Skip Thread* argument |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 378 | // Pass result as arg2 |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 379 | SetNativeParameter(jni_asm.get(), jni_conv.get(), |
| 380 | jni_conv->ReturnRegister()); |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 381 | |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 382 | // Pass Thread* |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 383 | jni_conv->ResetIterator(FrameOffset(out_arg_size)); |
| 384 | if (jni_conv->IsCurrentParamInRegister()) { |
| 385 | __ GetCurrentThread(jni_conv->CurrentParamRegister()); |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 386 | __ Call(jni_conv->CurrentParamRegister(), |
| 387 | Offset(OFFSETOF_MEMBER(Thread, pDecodeJObjectInThread)), |
| 388 | jni_conv->InterproceduralScratchRegister()); |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 389 | } else { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 390 | __ GetCurrentThread(jni_conv->CurrentParamStackOffset(), |
| 391 | jni_conv->InterproceduralScratchRegister()); |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 392 | __ Call(ThreadOffset(OFFSETOF_MEMBER(Thread, pDecodeJObjectInThread)), |
Brian Carlstrom | 1619286 | 2011-09-12 17:50:06 -0700 | [diff] [blame] | 393 | jni_conv->InterproceduralScratchRegister()); |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 394 | } |
| 395 | |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 396 | __ DecreaseFrameSize(out_arg_size); |
| 397 | jni_conv->ResetIterator(FrameOffset(0)); |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 398 | } |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 399 | __ Move(mr_conv->ReturnRegister(), jni_conv->ReturnRegister()); |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 400 | |
Elliott Hughes | 726079d | 2011-10-07 18:43:44 -0700 | [diff] [blame] | 401 | // 14. Restore segment state and remove SIRT from thread |
Ian Rogers | 5a7a74a | 2011-09-26 16:32:29 -0700 | [diff] [blame] | 402 | { |
| 403 | ManagedRegister jni_env = jni_conv->InterproceduralScratchRegister(); |
| 404 | __ LoadRawPtrFromThread(jni_env, Thread::JniEnvOffset()); |
| 405 | // env->locals.segment_state = env->local_ref_cookie |
| 406 | __ Copy(jni_env, JNIEnvExt::SegmentStateOffset(), |
| 407 | jni_env, JNIEnvExt::LocalRefCookieOffset(), |
| 408 | jni_conv->ReturnScratchRegister(), 4); |
| 409 | // env->local_ref_cookie = Frame[saved_local_ref_cookie_offset] |
| 410 | __ Copy(jni_env, JNIEnvExt::LocalRefCookieOffset(), |
| 411 | jni_conv->SavedLocalReferenceCookieOffset(), |
| 412 | jni_conv->ReturnScratchRegister(), 4); |
| 413 | } |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 414 | __ CopyRawPtrToThread(Thread::TopSirtOffset(), jni_conv->SirtLinkOffset(), |
| 415 | jni_conv->InterproceduralScratchRegister()); |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 416 | |
Elliott Hughes | 726079d | 2011-10-07 18:43:44 -0700 | [diff] [blame] | 417 | // 15. Check for pending exception and forward if there |
| 418 | __ ExceptionPoll(jni_conv->InterproceduralScratchRegister()); |
| 419 | |
Ian Rogers | e5de95b | 2011-09-18 20:31:38 -0700 | [diff] [blame] | 420 | // 16. Remove activation |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 421 | if (native_method->IsSynchronized()) { |
| 422 | __ RemoveFrame(frame_size, callee_save_regs); |
| 423 | } else { |
Elliott Hughes | 726079d | 2011-10-07 18:43:44 -0700 | [diff] [blame] | 424 | // no need to restore callee save registers because we didn't |
| 425 | // clobber them while locking the monitor. |
Ian Rogers | bdb0391 | 2011-09-14 00:55:44 -0700 | [diff] [blame] | 426 | __ RemoveFrame(frame_size, std::vector<ManagedRegister>()); |
| 427 | } |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 428 | |
Ian Rogers | e5de95b | 2011-09-18 20:31:38 -0700 | [diff] [blame] | 429 | // 17. Finalize code generation |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 430 | __ EmitSlowPaths(); |
| 431 | size_t cs = __ CodeSize(); |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 432 | std::vector<uint8_t> managed_code(cs); |
| 433 | MemoryRegion code(&managed_code[0], managed_code.size()); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 434 | __ FinalizeInstructions(code); |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 435 | return new CompiledMethod(instruction_set_, |
| 436 | managed_code, |
| 437 | frame_size, |
| 438 | jni_conv->ReturnPcOffset(), |
| 439 | jni_conv->CoreSpillMask(), |
| 440 | jni_conv->FpSpillMask()); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 441 | #undef __ |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 442 | } |
| 443 | |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 444 | void JniCompiler::SetNativeParameter(Assembler* jni_asm, |
| 445 | JniCallingConvention* jni_conv, |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 446 | ManagedRegister in_reg) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 447 | #define __ jni_asm-> |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 448 | if (jni_conv->IsCurrentParamOnStack()) { |
| 449 | FrameOffset dest = jni_conv->CurrentParamStackOffset(); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 450 | __ StoreRawPtr(dest, in_reg); |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 451 | } else { |
| 452 | if (!jni_conv->CurrentParamRegister().Equals(in_reg)) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 453 | __ Move(jni_conv->CurrentParamRegister(), in_reg); |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 454 | } |
| 455 | } |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 456 | #undef __ |
Shih-wei Liao | 668512a | 2011-09-01 14:18:34 -0700 | [diff] [blame] | 457 | } |
| 458 | |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 459 | // Copy a single parameter from the managed to the JNI calling convention |
| 460 | void JniCompiler::CopyParameter(Assembler* jni_asm, |
| 461 | ManagedRuntimeCallingConvention* mr_conv, |
| 462 | JniCallingConvention* jni_conv, |
| 463 | size_t frame_size, size_t out_arg_size) { |
| 464 | bool input_in_reg = mr_conv->IsCurrentParamInRegister(); |
| 465 | bool output_in_reg = jni_conv->IsCurrentParamInRegister(); |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 466 | FrameOffset sirt_offset(0); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 467 | bool null_allowed = false; |
| 468 | bool ref_param = jni_conv->IsCurrentParamAReference(); |
| 469 | CHECK(!ref_param || mr_conv->IsCurrentParamAReference()); |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 470 | // input may be in register, on stack or both - but not none! |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 471 | CHECK(input_in_reg || mr_conv->IsCurrentParamOnStack()); |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 472 | if (output_in_reg) { // output shouldn't straddle registers and stack |
| 473 | CHECK(!jni_conv->IsCurrentParamOnStack()); |
| 474 | } else { |
| 475 | CHECK(jni_conv->IsCurrentParamOnStack()); |
| 476 | } |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 477 | // References need placing in SIRT and the entry address passing |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 478 | if (ref_param) { |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 479 | null_allowed = mr_conv->IsCurrentArgPossiblyNull(); |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 480 | // Compute SIRT offset. Note null is placed in the SIRT but the jobject |
| 481 | // passed to the native code must be null (not a pointer into the SIRT |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 482 | // as with regular references). |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 483 | sirt_offset = jni_conv->CurrentParamSirtEntryOffset(); |
| 484 | // Check SIRT offset is within frame. |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 485 | CHECK_LT(sirt_offset.Uint32Value(), (frame_size + out_arg_size)); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 486 | } |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 487 | #define __ jni_asm-> |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 488 | if (input_in_reg && output_in_reg) { |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 489 | ManagedRegister in_reg = mr_conv->CurrentParamRegister(); |
| 490 | ManagedRegister out_reg = jni_conv->CurrentParamRegister(); |
| 491 | if (ref_param) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 492 | __ CreateSirtEntry(out_reg, sirt_offset, in_reg, null_allowed); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 493 | } else { |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 494 | if (!mr_conv->IsCurrentParamOnStack()) { |
| 495 | // regular non-straddling move |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 496 | __ Move(out_reg, in_reg); |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 497 | } else { |
| 498 | UNIMPLEMENTED(FATAL); // we currently don't expect to see this case |
| 499 | } |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 500 | } |
| 501 | } else if (!input_in_reg && !output_in_reg) { |
| 502 | FrameOffset out_off = jni_conv->CurrentParamStackOffset(); |
| 503 | if (ref_param) { |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 504 | __ CreateSirtEntry(out_off, sirt_offset, mr_conv->InterproceduralScratchRegister(), |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 505 | null_allowed); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 506 | } else { |
| 507 | FrameOffset in_off = mr_conv->CurrentParamStackOffset(); |
| 508 | size_t param_size = mr_conv->CurrentParamSize(); |
| 509 | CHECK_EQ(param_size, jni_conv->CurrentParamSize()); |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 510 | __ Copy(out_off, in_off, mr_conv->InterproceduralScratchRegister(), param_size); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 511 | } |
| 512 | } else if (!input_in_reg && output_in_reg) { |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 513 | FrameOffset in_off = mr_conv->CurrentParamStackOffset(); |
| 514 | ManagedRegister out_reg = jni_conv->CurrentParamRegister(); |
| 515 | // Check that incoming stack arguments are above the current stack frame. |
| 516 | CHECK_GT(in_off.Uint32Value(), frame_size); |
| 517 | if (ref_param) { |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 518 | __ CreateSirtEntry(out_reg, sirt_offset, ManagedRegister::NoRegister(), null_allowed); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 519 | } else { |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 520 | size_t param_size = mr_conv->CurrentParamSize(); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 521 | CHECK_EQ(param_size, jni_conv->CurrentParamSize()); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 522 | __ Load(out_reg, in_off, param_size); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 523 | } |
| 524 | } else { |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 525 | CHECK(input_in_reg && !output_in_reg); |
| 526 | ManagedRegister in_reg = mr_conv->CurrentParamRegister(); |
| 527 | FrameOffset out_off = jni_conv->CurrentParamStackOffset(); |
| 528 | // Check outgoing argument is within frame |
| 529 | CHECK_LT(out_off.Uint32Value(), frame_size); |
| 530 | if (ref_param) { |
Ian Rogers | 408f79a | 2011-08-23 18:22:33 -0700 | [diff] [blame] | 531 | // TODO: recycle value in in_reg rather than reload from SIRT |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 532 | __ CreateSirtEntry(out_off, sirt_offset, mr_conv->InterproceduralScratchRegister(), |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 533 | null_allowed); |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 534 | } else { |
| 535 | size_t param_size = mr_conv->CurrentParamSize(); |
| 536 | CHECK_EQ(param_size, jni_conv->CurrentParamSize()); |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 537 | if (!mr_conv->IsCurrentParamOnStack()) { |
| 538 | // regular non-straddling store |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 539 | __ Store(out_off, in_reg, param_size); |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 540 | } else { |
| 541 | // store where input straddles registers and stack |
| 542 | CHECK_EQ(param_size, 8u); |
| 543 | FrameOffset in_off = mr_conv->CurrentParamStackOffset(); |
Ian Rogers | dc51b79 | 2011-09-22 20:41:37 -0700 | [diff] [blame] | 544 | __ StoreSpanning(out_off, in_reg, in_off, mr_conv->InterproceduralScratchRegister()); |
Ian Rogers | 7a99c11 | 2011-09-07 12:48:27 -0700 | [diff] [blame] | 545 | } |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 546 | } |
| 547 | } |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 548 | #undef __ |
Ian Rogers | df20fe0 | 2011-07-20 20:34:16 -0700 | [diff] [blame] | 549 | } |
| 550 | |
Ian Rogers | e5de95b | 2011-09-18 20:31:38 -0700 | [diff] [blame] | 551 | void JniCompiler::ChangeThreadState(Assembler* jni_asm, Thread::State new_state, |
| 552 | ManagedRegister scratch, ManagedRegister return_reg, |
| 553 | FrameOffset return_save_location, |
| 554 | size_t return_size) { |
| 555 | /* |
| 556 | * This code mirrors that of Thread::SetState where detail is given on why |
| 557 | * barriers occur when they do. |
| 558 | */ |
| 559 | #define __ jni_asm-> |
| 560 | if (new_state == Thread::kRunnable) { |
| 561 | /* |
| 562 | * Change our status to Thread::kRunnable. The transition requires |
| 563 | * that we check for pending suspension, because the VM considers |
| 564 | * us to be "asleep" in all other states, and another thread could |
| 565 | * be performing a GC now. |
| 566 | */ |
| 567 | __ StoreImmediateToThread(Thread::StateOffset(), Thread::kRunnable, scratch); |
| 568 | __ MemoryBarrier(scratch); |
| 569 | __ SuspendPoll(scratch, return_reg, return_save_location, return_size); |
| 570 | } else { |
| 571 | /* |
| 572 | * Not changing to Thread::kRunnable. No additional work required. |
| 573 | */ |
| 574 | __ MemoryBarrier(scratch); |
| 575 | __ StoreImmediateToThread(Thread::StateOffset(), new_state, scratch); |
| 576 | } |
| 577 | #undef __ |
| 578 | } |
| 579 | |
Ian Rogers | b033c75 | 2011-07-20 12:22:35 -0700 | [diff] [blame] | 580 | } // namespace art |