interface-descriptors-ppc.cc 10.2 KB
Newer Older
1 2 3 4 5 6
// Copyright 2014 the V8 project authors. All rights reserved.
// Use of this source code is governed by a BSD-style license that can be
// found in the LICENSE file.

#if V8_TARGET_ARCH_PPC

7
#include "src/codegen/interface-descriptors.h"
8

9
#include "src/execution/frames.h"
10 11 12 13 14 15

namespace v8 {
namespace internal {

const Register CallInterfaceDescriptor::ContextRegister() { return cp; }

16 17 18 19 20 21 22 23
void CallInterfaceDescriptor::DefaultInitializePlatformSpecific(
    CallInterfaceDescriptorData* data, int register_parameter_count) {
  const Register default_stub_registers[] = {r3, r4, r5, r6, r7};
  CHECK_LE(static_cast<size_t>(register_parameter_count),
           arraysize(default_stub_registers));
  data->InitializePlatformSpecific(register_parameter_count,
                                   default_stub_registers);
}
24

25 26
void RecordWriteDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
27 28 29 30 31 32 33 34
  const Register default_stub_registers[] = {r3, r4, r5, r6, r7};

  data->RestrictAllocatableRegisters(default_stub_registers,
                                     arraysize(default_stub_registers));

  CHECK_LE(static_cast<size_t>(kParameterCount),
           arraysize(default_stub_registers));
  data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
35 36
}

37 38 39 40 41 42 43 44 45 46 47 48
void EphemeronKeyBarrierDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  const Register default_stub_registers[] = {r3, r4, r5, r6, r7};

  data->RestrictAllocatableRegisters(default_stub_registers,
                                     arraysize(default_stub_registers));

  CHECK_LE(static_cast<size_t>(kParameterCount),
           arraysize(default_stub_registers));
  data->InitializePlatformSpecific(kParameterCount, default_stub_registers);
}

49
const Register FastNewFunctionContextDescriptor::ScopeInfoRegister() {
50 51 52 53
  return r4;
}
const Register FastNewFunctionContextDescriptor::SlotsRegister() { return r3; }

54 55
const Register LoadDescriptor::ReceiverRegister() { return r4; }
const Register LoadDescriptor::NameRegister() { return r5; }
56
const Register LoadDescriptor::SlotRegister() { return r3; }
57

58
const Register LoadWithVectorDescriptor::VectorRegister() { return r6; }
59 60 61 62

const Register StoreDescriptor::ReceiverRegister() { return r4; }
const Register StoreDescriptor::NameRegister() { return r5; }
const Register StoreDescriptor::ValueRegister() { return r3; }
63
const Register StoreDescriptor::SlotRegister() { return r7; }
64

65
const Register StoreWithVectorDescriptor::VectorRegister() { return r6; }
66

67 68 69
const Register StoreTransitionDescriptor::SlotRegister() { return r7; }
const Register StoreTransitionDescriptor::VectorRegister() { return r6; }
const Register StoreTransitionDescriptor::MapRegister() { return r8; }
70

71 72
const Register ApiGetterDescriptor::HolderRegister() { return r3; }
const Register ApiGetterDescriptor::CallbackRegister() { return r6; }
73

74 75 76
const Register GrowArrayElementsDescriptor::ObjectRegister() { return r3; }
const Register GrowArrayElementsDescriptor::KeyRegister() { return r6; }

77
// static
78
const Register TypeConversionDescriptor::ArgumentRegister() { return r3; }
79

80 81
void TypeofDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
82
  Register registers[] = {r6};
83
  data->InitializePlatformSpecific(arraysize(registers), registers);
84 85
}

86 87 88 89 90 91 92 93
void CallTrampolineDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r3 : number of arguments
  // r4 : the target to call
  Register registers[] = {r4, r3};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

94 95 96 97 98
void CallVarargsDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r3 : number of arguments (on the stack, not including receiver)
  // r4 : the target to call
  // r7 : arguments list length (untagged)
99 100
  // r5 : arguments list (FixedArray)
  Register registers[] = {r4, r3, r7, r5};
101 102 103
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

104 105
void CallForwardVarargsDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
106 107 108 109 110 111 112
  // r3 : number of arguments
  // r5 : start index (to support rest parameters)
  // r4 : the target to call
  Register registers[] = {r4, r3, r5};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

113 114 115 116 117 118 119 120
void CallFunctionTemplateDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r4 : function template info
  // r5 : number of arguments (on the stack, not including receiver)
  Register registers[] = {r4, r5};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

121 122 123 124 125 126 127 128 129
void CallWithSpreadDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r3 : number of arguments (on the stack, not including receiver)
  // r4 : the target to call
  // r5 : the object to spread
  Register registers[] = {r4, r3, r5};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

130 131 132 133 134 135 136 137 138 139 140 141 142 143
void CallWithArrayLikeDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r4 : the target to call
  // r5 : the arguments list
  Register registers[] = {r4, r5};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

void ConstructVarargsDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r3 : number of arguments (on the stack, not including receiver)
  // r4 : the target to call
  // r6 : the new target
  // r7 : arguments list length (untagged)
144 145
  // r5 : arguments list (FixedArray)
  Register registers[] = {r4, r6, r3, r7, r5};
146 147 148
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

149 150 151 152
void ConstructForwardVarargsDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r3 : number of arguments
  // r6 : the new target
153 154
  // r5 : start index (to support rest parameters)
  // r4 : the target to call
155
  Register registers[] = {r4, r6, r3, r5};
156
  data->InitializePlatformSpecific(arraysize(registers), registers);
157 158
}

159 160 161 162 163 164 165 166 167 168
void ConstructWithSpreadDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r3 : number of arguments (on the stack, not including receiver)
  // r4 : the target to call
  // r6 : the new target
  // r5 : the object to spread
  Register registers[] = {r4, r6, r3, r5};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

169 170 171 172 173 174 175
void ConstructWithArrayLikeDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r4 : the target to call
  // r6 : the new target
  // r5 : the arguments list
  Register registers[] = {r4, r6, r5};
  data->InitializePlatformSpecific(arraysize(registers), registers);
176
}
177

178 179 180 181 182 183 184 185 186 187
void ConstructStubDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // r3 : number of arguments
  // r4 : the target to call
  // r6 : the new target
  // r5 : allocation site or undefined
  Register registers[] = {r4, r6, r3, r5};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

188
void AbortDescriptor::InitializePlatformSpecific(
189 190 191 192
    CallInterfaceDescriptorData* data) {
  Register registers[] = {r4};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}
193

194
void AllocateHeapNumberDescriptor::InitializePlatformSpecific(
195
    CallInterfaceDescriptorData* data) {
196
  data->InitializePlatformSpecific(0, nullptr);
197 198
}

199 200
void CompareDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
201
  Register registers[] = {r4, r3};
202
  data->InitializePlatformSpecific(arraysize(registers), registers);
203 204
}

205 206
void BinaryOpDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
207
  Register registers[] = {r4, r3};
208
  data->InitializePlatformSpecific(arraysize(registers), registers);
209 210
}

211
void ArgumentsAdaptorDescriptor::InitializePlatformSpecific(
212
    CallInterfaceDescriptorData* data) {
213 214
  Register registers[] = {
      r4,  // JSFunction
215
      r6,  // the new target
216 217 218
      r3,  // actual number of arguments
      r5,  // expected number of arguments
  };
219
  data->InitializePlatformSpecific(arraysize(registers), registers);
220 221
}

222
void ApiCallbackDescriptor::InitializePlatformSpecific(
223
    CallInterfaceDescriptorData* data) {
224
  Register registers[] = {
225 226 227 228
      r4,  // kApiFunctionAddress
      r5,  // kArgc
      r6,  // kCallData
      r3,  // kHolder
229
  };
230
  data->InitializePlatformSpecific(arraysize(registers), registers);
231
}
232

233 234 235
void InterpreterDispatchDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
236
      kInterpreterAccumulatorRegister, kInterpreterBytecodeOffsetRegister,
237
      kInterpreterBytecodeArrayRegister, kInterpreterDispatchTableRegister};
238 239
  data->InitializePlatformSpecific(arraysize(registers), registers);
}
240

241
void InterpreterPushArgsThenCallDescriptor::InitializePlatformSpecific(
242 243
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
244
      r3,  // argument count (not including receiver)
245 246 247 248 249
      r5,  // address of first argument
      r4   // the target callable to be call
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
}
250

251
void InterpreterPushArgsThenConstructDescriptor::InitializePlatformSpecific(
252 253 254
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
      r3,  // argument count (not including receiver)
255
      r7,  // address of the first argument
256
      r4,  // constructor to call
257
      r6,  // new target
258
      r5,  // allocation site feedback if available, undefined otherwise
259 260
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
261 262
}

263 264 265 266
void ResumeGeneratorDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
      r3,  // the value to pass to the generator
267
      r4   // the JSGeneratorObject to resume
268 269 270
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
}
271 272 273 274 275 276 277 278 279

void FrameDropperTrampolineDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
      r4,  // loaded new FP
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

280 281 282 283 284 285
void RunMicrotasksEntryDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {r3, r4};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

286 287
}  // namespace internal
}  // namespace v8
288 289

#endif  // V8_TARGET_ARCH_PPC