interface-descriptors-mips64.cc 12 KB
Newer Older
1 2 3 4 5 6 7 8 9 10 11
// Copyright 2012 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_MIPS64

#include "src/interface-descriptors.h"

namespace v8 {
namespace internal {

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

14 15 16 17 18 19 20 21
void CallInterfaceDescriptor::DefaultInitializePlatformSpecific(
    CallInterfaceDescriptorData* data, int register_parameter_count) {
  const Register default_stub_registers[] = {a0, a1, a2, a3, a4};
  CHECK_LE(static_cast<size_t>(register_parameter_count),
           arraysize(default_stub_registers));
  data->InitializePlatformSpecific(register_parameter_count,
                                   default_stub_registers);
}
22

23 24
void RecordWriteDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
25 26 27 28 29 30 31 32
  const Register default_stub_registers[] = {a0, a1, a2, a3, kReturnRegister0};

  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);
33 34
}

35 36 37 38 39
const Register FastNewFunctionContextDescriptor::FunctionRegister() {
  return a1;
}
const Register FastNewFunctionContextDescriptor::SlotsRegister() { return a0; }

40 41
const Register LoadDescriptor::ReceiverRegister() { return a1; }
const Register LoadDescriptor::NameRegister() { return a2; }
42
const Register LoadDescriptor::SlotRegister() { return a0; }
43

44
const Register LoadWithVectorDescriptor::VectorRegister() { return a3; }
45 46 47 48

const Register StoreDescriptor::ReceiverRegister() { return a1; }
const Register StoreDescriptor::NameRegister() { return a2; }
const Register StoreDescriptor::ValueRegister() { return a0; }
49
const Register StoreDescriptor::SlotRegister() { return a4; }
50

51
const Register StoreWithVectorDescriptor::VectorRegister() { return a3; }
52

53 54 55
const Register StoreTransitionDescriptor::SlotRegister() { return a4; }
const Register StoreTransitionDescriptor::VectorRegister() { return a3; }
const Register StoreTransitionDescriptor::MapRegister() { return a5; }
56

57 58
const Register ApiGetterDescriptor::HolderRegister() { return a0; }
const Register ApiGetterDescriptor::CallbackRegister() { return a3; }
59

60 61 62 63 64
const Register MathPowTaggedDescriptor::exponent() { return a2; }

const Register MathPowIntegerDescriptor::exponent() {
  return MathPowTaggedDescriptor::exponent();
}
65 66


67 68 69 70
const Register GrowArrayElementsDescriptor::ObjectRegister() { return a0; }
const Register GrowArrayElementsDescriptor::KeyRegister() { return a3; }


71
// static
72
const Register TypeConversionDescriptor::ArgumentRegister() { return a0; }
73

74 75
void TypeofDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
76
  Register registers[] = {a3};
77
  data->InitializePlatformSpecific(arraysize(registers), registers, nullptr);
78 79
}

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

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

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

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

113 114 115 116 117 118 119 120 121
void CallWithSpreadDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // a0 : number of arguments (on the stack, not including receiver)
  // a1 : the target to call
  // a2 : the object to spread
  Register registers[] = {a1, a0, a2};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140
void CallWithArrayLikeDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // a1 : the target to call
  // a2 : the arguments list
  Register registers[] = {a1, a2};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

void ConstructVarargsDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // a0 : number of arguments (on the stack, not including receiver)
  // a1 : the target to call
  // a3 : the new target
  // a2 : arguments list (FixedArray)
  // a4 : arguments list length (untagged)
  Register registers[] = {a1, a3, a0, a2, a4};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

141 142 143 144 145
void ConstructForwardVarargsDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // a1: the target to call
  // a3: new target
  // a0: number of arguments
146
  // a2: start index (to support rest parameters)
147
  Register registers[] = {a1, a3, a0, a2};
148
  data->InitializePlatformSpecific(arraysize(registers), registers);
149 150
}

151 152 153 154 155 156 157 158 159 160
void ConstructWithSpreadDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // a0 : number of arguments (on the stack, not including receiver)
  // a1 : the target to call
  // a3 : the new target
  // a2 : the object to spread
  Register registers[] = {a1, a3, a0, a2};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

161 162 163 164 165 166 167
void ConstructWithArrayLikeDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // a1 : the target to call
  // a3 : the new target
  // a2 : the arguments list
  Register registers[] = {a1, a3, a2};
  data->InitializePlatformSpecific(arraysize(registers), registers);
168
}
169

170 171 172 173 174 175 176 177 178 179 180
void ConstructStubDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // a1: target
  // a3: new target
  // a0: number of arguments
  // a2: allocation site or undefined
  Register registers[] = {a1, a3, a0, a2};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}


181 182 183 184 185 186 187 188 189 190
void ConstructTrampolineDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // a1: target
  // a3: new target
  // a0: number of arguments
  Register registers[] = {a1, a3, a0};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}


191
void TransitionElementsKindDescriptor::InitializePlatformSpecific(
192
    CallInterfaceDescriptorData* data) {
193
  Register registers[] = {a0, a1};
194
  data->InitializePlatformSpecific(arraysize(registers), registers, nullptr);
195 196
}

197 198 199 200 201
void AbortJSDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {a0};
  data->InitializePlatformSpecific(arraysize(registers), registers);
}
202

203
void AllocateHeapNumberDescriptor::InitializePlatformSpecific(
204 205
    CallInterfaceDescriptorData* data) {
  // register state
206
  data->InitializePlatformSpecific(0, nullptr, nullptr);
207 208
}

209 210 211 212
void ArrayConstructorDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // kTarget, kNewTarget, kActualArgumentsCount, kAllocationSite
  Register registers[] = {a1, a3, a0, a2};
213
  data->InitializePlatformSpecific(arraysize(registers), registers, nullptr);
214 215
}

216 217 218 219 220 221 222
void ArrayNoArgumentConstructorDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  // register state
  // a0 -- number of arguments
  // a1 -- function
  // a2 -- allocation site with elements kind
  Register registers[] = {a1, a2, a0};
223
  data->InitializePlatformSpecific(arraysize(registers), registers, nullptr);
224 225
}

226
void ArraySingleArgumentConstructorDescriptor::InitializePlatformSpecific(
227
    CallInterfaceDescriptorData* data) {
228 229 230 231
  // register state
  // a0 -- number of arguments
  // a1 -- function
  // a2 -- allocation site with elements kind
232
  Register registers[] = {a1, a2, a0};
233
  data->InitializePlatformSpecific(arraysize(registers), registers, nullptr);
234 235
}

236
void ArrayNArgumentsConstructorDescriptor::InitializePlatformSpecific(
237
    CallInterfaceDescriptorData* data) {
238
  // stack param count needs (constructor pointer, and single argument)
239
  Register registers[] = {a1, a2, a0};
240
  data->InitializePlatformSpecific(arraysize(registers), registers);
241 242
}

243 244
void CompareDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
245
  Register registers[] = {a1, a0};
246
  data->InitializePlatformSpecific(arraysize(registers), registers, nullptr);
247 248 249
}


250 251
void BinaryOpDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
252
  Register registers[] = {a1, a0};
253
  data->InitializePlatformSpecific(arraysize(registers), registers, nullptr);
254 255
}

256 257
void StringAddDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
258
  Register registers[] = {a1, a0};
259
  data->InitializePlatformSpecific(arraysize(registers), registers, nullptr);
260 261
}

262 263
void ArgumentAdaptorDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
264 265
  Register registers[] = {
      a1,  // JSFunction
266
      a3,  // the new target
267 268 269
      a0,  // actual number of arguments
      a2,  // expected number of arguments
  };
270
  data->InitializePlatformSpecific(arraysize(registers), registers);
271 272
}

273
void ApiCallbackDescriptor::InitializePlatformSpecific(
274
    CallInterfaceDescriptorData* data) {
275
  Register registers[] = {
276 277 278 279
      JavaScriptFrame::context_register(),  // callee context
      a4,                                   // call_data
      a2,                                   // holder
      a1,                                   // api_function_address
280
  };
281
  data->InitializePlatformSpecific(arraysize(registers), registers);
282
}
283

284 285 286
void InterpreterDispatchDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
287
      kInterpreterAccumulatorRegister, kInterpreterBytecodeOffsetRegister,
288
      kInterpreterBytecodeArrayRegister, kInterpreterDispatchTableRegister};
289 290
  data->InitializePlatformSpecific(arraysize(registers), registers);
}
291

292
void InterpreterPushArgsThenCallDescriptor::InitializePlatformSpecific(
293 294
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
295
      a0,  // argument count (not including receiver)
296 297 298 299 300 301
      a2,  // address of first argument
      a1   // the target callable to be call
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

302
void InterpreterPushArgsThenConstructDescriptor::InitializePlatformSpecific(
303 304 305
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
      a0,  // argument count (not including receiver)
306
      a3,  // new target
307
      a1,  // constructor to call
308 309
      a2,  // allocation site feedback if available, undefined otherwise.
      a4   // address of the first argument
310 311
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
312 313
}

314 315 316 317 318 319 320 321 322 323
void InterpreterCEntryDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
      a0,  // argument count (argc)
      a2,  // address of first argument (argv)
      a1   // the runtime function to call
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

324 325 326 327
void ResumeGeneratorDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
      v0,  // the value to pass to the generator
328
      a1   // the JSGeneratorObject to resume
329 330 331 332
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

333 334 335 336 337 338 339 340
void FrameDropperTrampolineDescriptor::InitializePlatformSpecific(
    CallInterfaceDescriptorData* data) {
  Register registers[] = {
      a1,  // loaded new FP
  };
  data->InitializePlatformSpecific(arraysize(registers), registers);
}

341 342
}  // namespace internal
}  // namespace v8
343 344

#endif  // V8_TARGET_ARCH_MIPS64