Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 1 | // Copyright 2012 the V8 project authors. All rights reserved. |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 2 | // Use of this source code is governed by a BSD-style license that can be |
| 3 | // found in the LICENSE file. |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 4 | |
| 5 | #ifndef V8_ARM_FRAMES_ARM_H_ |
| 6 | #define V8_ARM_FRAMES_ARM_H_ |
| 7 | |
| 8 | namespace v8 { |
| 9 | namespace internal { |
| 10 | |
| 11 | |
| 12 | // The ARM ABI does not specify the usage of register r9, which may be reserved |
| 13 | // as the static base or thread register on some platforms, in which case we |
| 14 | // leave it alone. Adjust the value of kR9Available accordingly: |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 15 | const int kR9Available = 1; // 1 if available to us, 0 if reserved |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 16 | |
| 17 | |
| 18 | // Register list in load/store instructions |
| 19 | // Note that the bit values must match those used in actual instruction encoding |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 20 | const int kNumRegs = 16; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 21 | |
| 22 | |
| 23 | // Caller-saved/arguments registers |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 24 | const RegList kJSCallerSaved = |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 25 | 1 << 0 | // r0 a1 |
| 26 | 1 << 1 | // r1 a2 |
| 27 | 1 << 2 | // r2 a3 |
| 28 | 1 << 3; // r3 a4 |
| 29 | |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 30 | const int kNumJSCallerSaved = 4; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 31 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 32 | // Return the code of the n-th caller-saved register available to JavaScript |
| 33 | // e.g. JSCallerSavedReg(0) returns r0.code() == 0 |
| 34 | int JSCallerSavedCode(int n); |
| 35 | |
| 36 | |
| 37 | // Callee-saved registers preserved when switching from C to JavaScript |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 38 | const RegList kCalleeSaved = |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 39 | 1 << 4 | // r4 v1 |
| 40 | 1 << 5 | // r5 v2 |
| 41 | 1 << 6 | // r6 v3 |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 42 | 1 << 7 | // r7 v4 (cp in JavaScript code) |
| 43 | 1 << 8 | // r8 v5 (pp in JavaScript code) |
Steve Block | 1e0659c | 2011-05-24 12:43:12 +0100 | [diff] [blame] | 44 | kR9Available << 9 | // r9 v6 |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 45 | 1 << 10 | // r10 v7 |
| 46 | 1 << 11; // r11 v8 (fp in JavaScript code) |
| 47 | |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 48 | // When calling into C++ (only for C++ calls that can't cause a GC). |
| 49 | // The call code will take care of lr, fp, etc. |
| 50 | const RegList kCallerSaved = |
| 51 | 1 << 0 | // r0 |
| 52 | 1 << 1 | // r1 |
| 53 | 1 << 2 | // r2 |
| 54 | 1 << 3 | // r3 |
| 55 | 1 << 9; // r9 |
| 56 | |
| 57 | |
| 58 | const int kNumCalleeSaved = 7 + kR9Available; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 59 | |
Ben Murdoch | 7d3e7fc | 2011-07-12 16:37:06 +0100 | [diff] [blame] | 60 | // Double registers d8 to d15 are callee-saved. |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 61 | const int kNumDoubleCalleeSaved = 8; |
Ben Murdoch | 7d3e7fc | 2011-07-12 16:37:06 +0100 | [diff] [blame] | 62 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 63 | |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 64 | // Number of registers for which space is reserved in safepoints. Must be a |
| 65 | // multiple of 8. |
| 66 | // TODO(regis): Only 8 registers may actually be sufficient. Revisit. |
Ben Murdoch | 3ef787d | 2012-04-12 10:51:47 +0100 | [diff] [blame] | 67 | const int kNumSafepointRegisters = 16; |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 68 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 69 | // The embedded constant pool pointer (r8/pp) is not included in the safepoint |
| 70 | // since it is not tagged. This register is preserved in the stack frame where |
| 71 | // its value will be updated if GC code movement occurs. Including it in the |
| 72 | // safepoint (where it will not be relocated) would cause a stale value to be |
| 73 | // restored. |
| 74 | const RegList kConstantPointerRegMask = |
| 75 | FLAG_enable_embedded_constant_pool ? (1 << 8) : 0; |
| 76 | const int kNumConstantPoolPointerReg = |
| 77 | FLAG_enable_embedded_constant_pool ? 1 : 0; |
| 78 | |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 79 | // Define the list of registers actually saved at safepoints. |
| 80 | // Note that the number of saved registers may be smaller than the reserved |
| 81 | // space, i.e. kNumSafepointSavedRegisters <= kNumSafepointRegisters. |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 82 | const RegList kSafepointSavedRegisters = |
| 83 | kJSCallerSaved | (kCalleeSaved & ~kConstantPointerRegMask); |
| 84 | const int kNumSafepointSavedRegisters = |
| 85 | kNumJSCallerSaved + kNumCalleeSaved - kNumConstantPoolPointerReg; |
Ben Murdoch | b0fe162 | 2011-05-05 13:52:32 +0100 | [diff] [blame] | 86 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 87 | // ---------------------------------------------------- |
| 88 | |
| 89 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 90 | class EntryFrameConstants : public AllStatic { |
| 91 | public: |
Ben Murdoch | b8a8cc1 | 2014-11-26 15:28:44 +0000 | [diff] [blame] | 92 | static const int kCallerFPOffset = |
| 93 | -(StandardFrameConstants::kFixedFrameSizeFromFp + kPointerSize); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 94 | }; |
| 95 | |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 96 | class ExitFrameConstants : public TypedFrameConstants { |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 97 | public: |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 98 | static const int kSPOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(0); |
| 99 | static const int kCodeOffset = TYPED_FRAME_PUSHED_VALUE_OFFSET(1); |
| 100 | DEFINE_TYPED_FRAME_SIZES(2); |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 101 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 102 | // The caller fields are below the frame pointer on the stack. |
Steve Block | 1e0659c | 2011-05-24 12:43:12 +0100 | [diff] [blame] | 103 | static const int kCallerFPOffset = 0 * kPointerSize; |
| 104 | // The calling JS function is below FP. |
| 105 | static const int kCallerPCOffset = 1 * kPointerSize; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 106 | |
| 107 | // FP-relative displacement of the caller's SP. It points just |
| 108 | // below the saved PC. |
Steve Block | 1e0659c | 2011-05-24 12:43:12 +0100 | [diff] [blame] | 109 | static const int kCallerSPDisplacement = 2 * kPointerSize; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 110 | }; |
| 111 | |
| 112 | |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 113 | class JavaScriptFrameConstants : public AllStatic { |
| 114 | public: |
| 115 | // FP-relative. |
| 116 | static const int kLocal0Offset = StandardFrameConstants::kExpressionsOffset; |
Ben Murdoch | 8b112d2 | 2011-06-08 16:22:53 +0100 | [diff] [blame] | 117 | static const int kLastParameterOffset = +2 * kPointerSize; |
Ben Murdoch | da12d29 | 2016-06-02 14:46:10 +0100 | [diff] [blame] | 118 | static const int kFunctionOffset = StandardFrameConstants::kFunctionOffset; |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 119 | |
| 120 | // Caller SP-relative. |
| 121 | static const int kParam0Offset = -2 * kPointerSize; |
| 122 | static const int kReceiverOffset = -1 * kPointerSize; |
| 123 | }; |
| 124 | |
| 125 | |
Ben Murdoch | 4a90d5f | 2016-03-22 12:00:34 +0000 | [diff] [blame] | 126 | } // namespace internal |
| 127 | } // namespace v8 |
Steve Block | a7e24c1 | 2009-10-30 11:49:00 +0000 | [diff] [blame] | 128 | |
| 129 | #endif // V8_ARM_FRAMES_ARM_H_ |