1// Copyright 2012 the V8 project authors. All rights reserved. 2// Use of this source code is governed by a BSD-style license that can be 3// found in the LICENSE file. 4 5#ifndef V8_ARM_FRAMES_ARM_H_ 6#define V8_ARM_FRAMES_ARM_H_ 7 8namespace v8 { 9namespace 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: 15const int kR9Available = 1; // 1 if available to us, 0 if reserved 16 17 18// Register list in load/store instructions 19// Note that the bit values must match those used in actual instruction encoding 20const int kNumRegs = 16; 21 22 23// Caller-saved/arguments registers 24const RegList kJSCallerSaved = 25 1 << 0 | // r0 a1 26 1 << 1 | // r1 a2 27 1 << 2 | // r2 a3 28 1 << 3; // r3 a4 29 30const int kNumJSCallerSaved = 4; 31 32// Return the code of the n-th caller-saved register available to JavaScript 33// e.g. JSCallerSavedReg(0) returns r0.code() == 0 34int JSCallerSavedCode(int n); 35 36 37// Callee-saved registers preserved when switching from C to JavaScript 38const RegList kCalleeSaved = 39 1 << 4 | // r4 v1 40 1 << 5 | // r5 v2 41 1 << 6 | // r6 v3 42 1 << 7 | // r7 v4 (cp in JavaScript code) 43 1 << 8 | // r8 v5 (pp in JavaScript code) 44 kR9Available << 9 | // r9 v6 45 1 << 10 | // r10 v7 46 1 << 11; // r11 v8 (fp in JavaScript code) 47 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. 50const RegList kCallerSaved = 51 1 << 0 | // r0 52 1 << 1 | // r1 53 1 << 2 | // r2 54 1 << 3 | // r3 55 1 << 9; // r9 56 57 58const int kNumCalleeSaved = 7 + kR9Available; 59 60// Double registers d8 to d15 are callee-saved. 61const int kNumDoubleCalleeSaved = 8; 62 63 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. 67const int kNumSafepointRegisters = 16; 68 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. 74const RegList kConstantPointerRegMask = 75 FLAG_enable_embedded_constant_pool ? (1 << 8) : 0; 76const int kNumConstantPoolPointerReg = 77 FLAG_enable_embedded_constant_pool ? 1 : 0; 78 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. 82const RegList kSafepointSavedRegisters = 83 kJSCallerSaved | (kCalleeSaved & ~kConstantPointerRegMask); 84const int kNumSafepointSavedRegisters = 85 kNumJSCallerSaved + kNumCalleeSaved - kNumConstantPoolPointerReg; 86 87// ---------------------------------------------------- 88 89 90class EntryFrameConstants : public AllStatic { 91 public: 92 static const int kCallerFPOffset = 93 -(StandardFrameConstants::kFixedFrameSizeFromFp + kPointerSize); 94}; 95 96class ExitFrameConstants : public TypedFrameConstants { 97 public: 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); 101 102 // The caller fields are below the frame pointer on the stack. 103 static const int kCallerFPOffset = 0 * kPointerSize; 104 // The calling JS function is below FP. 105 static const int kCallerPCOffset = 1 * kPointerSize; 106 107 // FP-relative displacement of the caller's SP. It points just 108 // below the saved PC. 109 static const int kCallerSPDisplacement = 2 * kPointerSize; 110}; 111 112 113class JavaScriptFrameConstants : public AllStatic { 114 public: 115 // FP-relative. 116 static const int kLocal0Offset = StandardFrameConstants::kExpressionsOffset; 117 static const int kLastParameterOffset = +2 * kPointerSize; 118 static const int kFunctionOffset = StandardFrameConstants::kFunctionOffset; 119 120 // Caller SP-relative. 121 static const int kParam0Offset = -2 * kPointerSize; 122 static const int kReceiverOffset = -1 * kPointerSize; 123}; 124 125 126} // namespace internal 127} // namespace v8 128 129#endif // V8_ARM_FRAMES_ARM_H_ 130