Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 1 | // Copyright 2011 Google Inc. All Rights Reserved. |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 2 | |
| 3 | #include "jni_internal.h" |
| 4 | |
| 5 | #include <algorithm> |
| 6 | |
Ian Rogers | 4a510d8 | 2011-10-09 14:30:24 -0700 | [diff] [blame] | 7 | #include "asm_support.h" |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 8 | #include "assembler.h" |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 9 | #include "compiled_method.h" |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 10 | #include "object.h" |
| 11 | |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 12 | namespace art { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 13 | namespace arm { |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 14 | |
| 15 | // Creates a function which invokes a managed method with an array of |
| 16 | // arguments. |
| 17 | // |
| 18 | // At the time of call, the environment looks something like this: |
| 19 | // |
| 20 | // R0 = method pointer |
| 21 | // R1 = receiver pointer or NULL for static methods |
| 22 | // R2 = (managed) thread pointer |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 23 | // R3 = argument array or NULL for no argument methods |
| 24 | // [SP] = JValue* result or NULL for void returns |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 25 | // |
| 26 | // As the JNI call has already transitioned the thread into the |
| 27 | // "running" state the remaining responsibilities of this routine are |
| 28 | // to save the native register value and restore the managed thread |
| 29 | // register and transfer arguments from the array into register and on |
| 30 | // the stack, if needed. On return, the thread register must be |
| 31 | // shuffled and the return value must be store into the result JValue. |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 32 | CompiledInvokeStub* ArmCreateInvokeStub(const Method* method) { |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 33 | UniquePtr<ArmAssembler> assembler( |
| 34 | down_cast<ArmAssembler*>(Assembler::Create(kArm))); |
| 35 | #define __ assembler-> |
buzbee | c1f4504 | 2011-09-21 16:03:19 -0700 | [diff] [blame] | 36 | // Size of frame - spill of R4,R9/LR + Method* + possible receiver + arg array |
| 37 | size_t unpadded_frame_size = (4 * kPointerSize) + |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 38 | (method->IsStatic() ? 0 : kPointerSize) + |
| 39 | method->NumArgArrayBytes(); |
| 40 | size_t frame_size = RoundUp(unpadded_frame_size, kStackAlignment); |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 41 | |
buzbee | c1f4504 | 2011-09-21 16:03:19 -0700 | [diff] [blame] | 42 | // Spill R4,R9 and LR |
| 43 | RegList save = (1 << R9) | (1 << R4); |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 44 | __ PushList(save | (1 << LR)); |
| 45 | |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 46 | // Move the managed thread pointer into R9. |
| 47 | __ mov(R9, ShifterOperand(R2)); |
| 48 | |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 49 | // Reset R4 to suspend check interval |
Ian Rogers | 4a510d8 | 2011-10-09 14:30:24 -0700 | [diff] [blame] | 50 | __ LoadImmediate(R4, SUSPEND_CHECK_INTERVAL); |
| 51 | |
buzbee | c1f4504 | 2011-09-21 16:03:19 -0700 | [diff] [blame] | 52 | // Move frame down for arguments less 3 pushed values above |
| 53 | __ AddConstant(SP, -frame_size + (3 * kPointerSize)); |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 54 | |
| 55 | // Can either get 3 or 2 arguments into registers |
| 56 | size_t reg_bytes = (method->IsStatic() ? 3 : 2) * kPointerSize; |
| 57 | // Bytes passed by stack |
| 58 | size_t stack_bytes; |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 59 | if (method->NumArgArrayBytes() > reg_bytes) { |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 60 | stack_bytes = method->NumArgArrayBytes() - reg_bytes; |
| 61 | } else { |
| 62 | stack_bytes = 0; |
| 63 | reg_bytes = method->NumArgArrayBytes(); |
| 64 | } |
| 65 | |
Ian Rogers | ed8952f | 2011-08-19 17:11:22 -0700 | [diff] [blame] | 66 | // Method* at bottom of frame is null thereby terminating managed stack crawls |
| 67 | __ LoadImmediate(IP, 0, AL); |
| 68 | __ StoreToOffset(kStoreWord, IP, SP, 0); |
| 69 | |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 70 | // Copy values by stack |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 71 | for (size_t off = 0; off < stack_bytes; off += kPointerSize) { |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 72 | // we're displaced off of r3 by bytes that'll go in registers |
| 73 | int r3_offset = reg_bytes + off; |
| 74 | __ LoadFromOffset(kLoadWord, IP, R3, r3_offset); |
| 75 | |
| 76 | // we're displaced off of the arguments by the spill space for the incoming |
Shih-wei Liao | 7d2b141 | 2011-09-05 19:29:47 -0700 | [diff] [blame] | 77 | // arguments, the Method* and possibly the receiver |
| 78 | int sp_offset = reg_bytes + (method->IsStatic() ? 1 : 2) * kPointerSize + off; |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 79 | __ StoreToOffset(kStoreWord, IP, SP, sp_offset); |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 80 | } |
| 81 | |
| 82 | // Move all the register arguments into place. |
| 83 | if (method->IsStatic()) { |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 84 | if (reg_bytes > 0) { |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 85 | __ LoadFromOffset(kLoadWord, R1, R3, 0); |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 86 | if (reg_bytes > 4) { |
| 87 | __ LoadFromOffset(kLoadWord, R2, R3, 4); |
| 88 | if (reg_bytes > 8) { |
| 89 | __ LoadFromOffset(kLoadWord, R3, R3, 8); |
| 90 | } |
| 91 | } |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 92 | } |
| 93 | } else { |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 94 | if (reg_bytes > 0) { |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 95 | __ LoadFromOffset(kLoadWord, R2, R3, 0); |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 96 | if (reg_bytes > 4) { |
| 97 | __ LoadFromOffset(kLoadWord, R3, R3, 4); |
| 98 | } |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 99 | } |
| 100 | } |
| 101 | |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 102 | // Load the code pointer we are about to call. |
Ian Rogers | 0cfe1fb | 2011-08-26 03:29:44 -0700 | [diff] [blame] | 103 | __ LoadFromOffset(kLoadWord, IP, R0, method->GetCodeOffset().Int32Value()); |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 104 | |
| 105 | // Do the call. |
| 106 | __ blx(IP); |
| 107 | |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 108 | // If the method returns a value, store it to the result pointer. |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 109 | if (!method->IsReturnVoid()) { |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 110 | // Load the result JValue pointer of the stub caller's out args. |
| 111 | __ LoadFromOffset(kLoadWord, IP, SP, frame_size); |
Ian Rogers | ae67599 | 2011-10-09 17:10:22 -0700 | [diff] [blame] | 112 | __ StoreToOffset(method->IsReturnALongOrDouble() ? kStoreWordPair : kStoreWord, R0, IP, 0); |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 113 | } |
| 114 | |
buzbee | c1f4504 | 2011-09-21 16:03:19 -0700 | [diff] [blame] | 115 | // Remove the frame less the spilled R4, R9 and LR |
| 116 | __ AddConstant(SP, frame_size - (3 * kPointerSize)); |
Ian Rogers | cdd1d2d | 2011-08-18 09:58:17 -0700 | [diff] [blame] | 117 | |
buzbee | c1f4504 | 2011-09-21 16:03:19 -0700 | [diff] [blame] | 118 | // Pop R4, R9 and the LR into PC |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 119 | __ PopList(save | (1 << PC)); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 120 | // TODO: store native_entry in the stub table |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 121 | std::vector<uint8_t> code(assembler->CodeSize()); |
| 122 | MemoryRegion region(&code[0], code.size()); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 123 | assembler->FinalizeInstructions(region); |
Brian Carlstrom | 3320cf4 | 2011-10-04 14:58:28 -0700 | [diff] [blame] | 124 | return new CompiledInvokeStub(code); |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 125 | #undef __ |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 126 | } |
| 127 | |
Ian Rogers | 2c8f653 | 2011-09-02 17:16:34 -0700 | [diff] [blame] | 128 | } // namespace arm |
Carl Shapiro | 9b9ba28 | 2011-08-14 15:30:39 -0700 | [diff] [blame] | 129 | } // namespace art |