deps/v8/src/ppc/frames-ppc.h

   1 // Copyright 2014 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_PPC_FRAMES_PPC_H_
   6 #define V8_PPC_FRAMES_PPC_H_
   7
   8 namespace v8 {
   9 namespace internal {
  10
  11
  12 // Register list in load/store instructions
  13 // Note that the bit values must match those used in actual instruction encoding
  14 const int kNumRegs = 32;
  15
  16
  17 // Caller-saved/arguments registers
  18 const RegList kJSCallerSaved = 1 << 3 |   // r3  a1
  19                                1 << 4 |   // r4  a2
  20                                1 << 5 |   // r5  a3
  21                                1 << 6 |   // r6  a4
  22                                1 << 7 |   // r7  a5
  23                                1 << 8 |   // r8  a6
  24                                1 << 9 |   // r9  a7
  25                                1 << 10 |  // r10 a8
  26                                1 << 11;
  27
  28 const int kNumJSCallerSaved = 9;
  29
  30 // Return the code of the n-th caller-saved register available to JavaScript
  31 // e.g. JSCallerSavedReg(0) returns r0.code() == 0
  32 int JSCallerSavedCode(int n);
  33
  34
  35 // Callee-saved registers preserved when switching from C to JavaScript
  36 const RegList kCalleeSaved = 1 << 14 |  // r14
  37                              1 << 15 |  // r15
  38                              1 << 16 |  // r16
  39                              1 << 17 |  // r17
  40                              1 << 18 |  // r18
  41                              1 << 19 |  // r19
  42                              1 << 20 |  // r20
  43                              1 << 21 |  // r21
  44                              1 << 22 |  // r22
  45                              1 << 23 |  // r23
  46                              1 << 24 |  // r24
  47                              1 << 25 |  // r25
  48                              1 << 26 |  // r26
  49                              1 << 27 |  // r27
  50                              1 << 28 |  // r28
  51                              1 << 29 |  // r29
  52                              1 << 30 |  // r20
  53                              1 << 31;   // r31
  54
  55
  56 const int kNumCalleeSaved = 18;
  57
  58 // Number of registers for which space is reserved in safepoints. Must be a
  59 // multiple of 8.
  60 const int kNumSafepointRegisters = 32;
  61
  62 // The following constants describe the stack frame linkage area as
  63 // defined by the ABI.  Note that kNumRequiredStackFrameSlots must
  64 // satisfy alignment requirements (rounding up if required).
  65 #if V8_TARGET_ARCH_PPC64 && V8_TARGET_LITTLE_ENDIAN
  66 // [0] back chain
  67 // [1] condition register save area
  68 // [2] link register save area
  69 // [3] TOC save area
  70 // [4] Parameter1 save area
  71 // ...
  72 // [11] Parameter8 save area
  73 // [12] Parameter9 slot (if necessary)
  74 // ...
  75 const int kNumRequiredStackFrameSlots = 12;
  76 const int kStackFrameLRSlot = 2;
  77 const int kStackFrameExtraParamSlot = 12;
  78 #elif V8_OS_AIX || V8_TARGET_ARCH_PPC64
  79 // [0] back chain
  80 // [1] condition register save area
  81 // [2] link register save area
  82 // [3] reserved for compiler
  83 // [4] reserved by binder
  84 // [5] TOC save area
  85 // [6] Parameter1 save area
  86 // ...
  87 // [13] Parameter8 save area
  88 // [14] Parameter9 slot (if necessary)
  89 // ...
  90 #if V8_TARGET_ARCH_PPC64
  91 const int kNumRequiredStackFrameSlots = 14;
  92 #else
  93 const int kNumRequiredStackFrameSlots = 16;
  94 #endif
  95 const int kStackFrameLRSlot = 2;
  96 const int kStackFrameExtraParamSlot = 14;
  97 #else
  98 // [0] back chain
  99 // [1] link register save area
 100 // [2] Parameter9 slot (if necessary)
 101 // ...
 102 const int kNumRequiredStackFrameSlots = 4;
 103 const int kStackFrameLRSlot = 1;
 104 const int kStackFrameExtraParamSlot = 2;
 105 #endif
 106
 107 // ----------------------------------------------------
 108
 109
 110 class EntryFrameConstants : public AllStatic {
 111  public:
 112   static const int kCallerFPOffset =
 113       -(StandardFrameConstants::kFixedFrameSizeFromFp + kPointerSize);
 114 };
 115
 116
 117 class ExitFrameConstants : public AllStatic {
 118  public:
 119   static const int kFrameSize = 2 * kPointerSize;
 120   static const int kConstantPoolOffset = 0;  // Not used.
 121   static const int kCodeOffset = -2 * kPointerSize;
 122   static const int kSPOffset = -1 * kPointerSize;
 123
 124   // The caller fields are below the frame pointer on the stack.
 125   static const int kCallerFPOffset = 0 * kPointerSize;
 126   // The calling JS function is below FP.
 127   static const int kCallerPCOffset = 1 * kPointerSize;
 128
 129   // FP-relative displacement of the caller's SP.  It points just
 130   // below the saved PC.
 131   static const int kCallerSPDisplacement = 2 * kPointerSize;
 132 };
 133
 134
 135 class JavaScriptFrameConstants : public AllStatic {
 136  public:
 137   // FP-relative.
 138   static const int kLocal0Offset = StandardFrameConstants::kExpressionsOffset;
 139   static const int kLastParameterOffset = +2 * kPointerSize;
 140   static const int kFunctionOffset = StandardFrameConstants::kMarkerOffset;
 141
 142   // Caller SP-relative.
 143   static const int kParam0Offset = -2 * kPointerSize;
 144   static const int kReceiverOffset = -1 * kPointerSize;
 145 };
 146
 147
 148 class ArgumentsAdaptorFrameConstants : public AllStatic {
 149  public:
 150   // FP-relative.
 151   static const int kLengthOffset = StandardFrameConstants::kExpressionsOffset;
 152
 153   static const int kFrameSize =
 154       StandardFrameConstants::kFixedFrameSize + kPointerSize;
 155 };
 156
 157
 158 class ConstructFrameConstants : public AllStatic {
 159  public:
 160   // FP-relative.
 161   static const int kImplicitReceiverOffset = -6 * kPointerSize;
 162   static const int kConstructorOffset = -5 * kPointerSize;
 163   static const int kLengthOffset = -4 * kPointerSize;
 164   static const int kCodeOffset = StandardFrameConstants::kExpressionsOffset;
 165
 166   static const int kFrameSize =
 167       StandardFrameConstants::kFixedFrameSize + 4 * kPointerSize;
 168 };
 169
 170
 171 class InternalFrameConstants : public AllStatic {
 172  public:
 173   // FP-relative.
 174   static const int kCodeOffset = StandardFrameConstants::kExpressionsOffset;
 175 };
 176
 177
 178 inline Object* JavaScriptFrame::function_slot_object() const {
 179   const int offset = JavaScriptFrameConstants::kFunctionOffset;
 180   return Memory::Object_at(fp() + offset);
 181 }
 182
 183
 184 }
 185 }  // namespace v8::internal
 186
 187 #endif  // V8_PPC_FRAMES_PPC_H_