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 #if V8_TARGET_ARCH_MIPS64 6 7 #include "src/interface-descriptors.h" 8 9 namespace v8 { 10 namespace internal { 11 12 const Register CallInterfaceDescriptor::ContextRegister() { return cp; } 13 14 void CallInterfaceDescriptor::DefaultInitializePlatformSpecific( 15 CallInterfaceDescriptorData* data, int register_parameter_count) { 16 const Register default_stub_registers[] = {a0, a1, a2, a3, a4}; 17 CHECK_LE(static_cast<size_t>(register_parameter_count), 18 arraysize(default_stub_registers)); 19 data->InitializePlatformSpecific(register_parameter_count, 20 default_stub_registers); 21 } 22 23 const Register LoadDescriptor::ReceiverRegister() { return a1; } 24 const Register LoadDescriptor::NameRegister() { return a2; } 25 const Register LoadDescriptor::SlotRegister() { return a0; } 26 27 28 const Register LoadWithVectorDescriptor::VectorRegister() { return a3; } 29 30 31 const Register StoreDescriptor::ReceiverRegister() { return a1; } 32 const Register StoreDescriptor::NameRegister() { return a2; } 33 const Register StoreDescriptor::ValueRegister() { return a0; } 34 35 36 const Register VectorStoreICTrampolineDescriptor::SlotRegister() { return a4; } 37 38 39 const Register VectorStoreICDescriptor::VectorRegister() { return a3; } 40 41 42 const Register VectorStoreTransitionDescriptor::SlotRegister() { return a4; } 43 const Register VectorStoreTransitionDescriptor::VectorRegister() { return a3; } 44 const Register VectorStoreTransitionDescriptor::MapRegister() { return a5; } 45 46 47 const Register StoreTransitionDescriptor::MapRegister() { return a3; } 48 49 50 const Register StoreGlobalViaContextDescriptor::SlotRegister() { return a2; } 51 const Register StoreGlobalViaContextDescriptor::ValueRegister() { return a0; } 52 53 54 const Register StringCompareDescriptor::LeftRegister() { return a1; } 55 const Register StringCompareDescriptor::RightRegister() { return a0; } 56 57 const Register ApiGetterDescriptor::HolderRegister() { return a0; } 58 const Register ApiGetterDescriptor::CallbackRegister() { return a3; } 59 60 const Register MathPowTaggedDescriptor::exponent() { return a2; } 61 62 63 const Register MathPowIntegerDescriptor::exponent() { 64 return MathPowTaggedDescriptor::exponent(); 65 } 66 67 68 const Register GrowArrayElementsDescriptor::ObjectRegister() { return a0; } 69 const Register GrowArrayElementsDescriptor::KeyRegister() { return a3; } 70 71 72 void FastNewClosureDescriptor::InitializePlatformSpecific( 73 CallInterfaceDescriptorData* data) { 74 Register registers[] = {a2}; 75 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 76 } 77 78 79 void FastNewContextDescriptor::InitializePlatformSpecific( 80 CallInterfaceDescriptorData* data) { 81 Register registers[] = {a1}; 82 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 83 } 84 85 void FastNewObjectDescriptor::InitializePlatformSpecific( 86 CallInterfaceDescriptorData* data) { 87 Register registers[] = {a1, a3}; 88 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 89 } 90 91 void FastNewRestParameterDescriptor::InitializePlatformSpecific( 92 CallInterfaceDescriptorData* data) { 93 Register registers[] = {a1}; 94 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 95 } 96 97 98 void FastNewSloppyArgumentsDescriptor::InitializePlatformSpecific( 99 CallInterfaceDescriptorData* data) { 100 Register registers[] = {a1}; 101 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 102 } 103 104 105 void FastNewStrictArgumentsDescriptor::InitializePlatformSpecific( 106 CallInterfaceDescriptorData* data) { 107 Register registers[] = {a1}; 108 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 109 } 110 111 112 // static 113 const Register TypeConversionDescriptor::ArgumentRegister() { return a0; } 114 115 void TypeofDescriptor::InitializePlatformSpecific( 116 CallInterfaceDescriptorData* data) { 117 Register registers[] = {a3}; 118 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 119 } 120 121 122 void FastCloneRegExpDescriptor::InitializePlatformSpecific( 123 CallInterfaceDescriptorData* data) { 124 Register registers[] = {a3, a2, a1, a0}; 125 data->InitializePlatformSpecific(arraysize(registers), registers); 126 } 127 128 129 void FastCloneShallowArrayDescriptor::InitializePlatformSpecific( 130 CallInterfaceDescriptorData* data) { 131 Register registers[] = {a3, a2, a1}; 132 data->InitializePlatformSpecific(arraysize(registers), registers); 133 } 134 135 136 void FastCloneShallowObjectDescriptor::InitializePlatformSpecific( 137 CallInterfaceDescriptorData* data) { 138 Register registers[] = {a3, a2, a1, a0}; 139 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 140 } 141 142 143 void CreateAllocationSiteDescriptor::InitializePlatformSpecific( 144 CallInterfaceDescriptorData* data) { 145 Register registers[] = {a2, a3}; 146 data->InitializePlatformSpecific(arraysize(registers), registers); 147 } 148 149 150 void CreateWeakCellDescriptor::InitializePlatformSpecific( 151 CallInterfaceDescriptorData* data) { 152 Register registers[] = {a2, a3, a1}; 153 data->InitializePlatformSpecific(arraysize(registers), registers); 154 } 155 156 157 void CallFunctionWithFeedbackDescriptor::InitializePlatformSpecific( 158 CallInterfaceDescriptorData* data) { 159 Register registers[] = {a1, a3}; 160 data->InitializePlatformSpecific(arraysize(registers), registers); 161 } 162 163 164 void CallFunctionWithFeedbackAndVectorDescriptor::InitializePlatformSpecific( 165 CallInterfaceDescriptorData* data) { 166 Register registers[] = {a1, a3, a2}; 167 data->InitializePlatformSpecific(arraysize(registers), registers); 168 } 169 170 171 void CallFunctionDescriptor::InitializePlatformSpecific( 172 CallInterfaceDescriptorData* data) { 173 Register registers[] = {a1}; 174 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 175 } 176 177 178 void CallConstructDescriptor::InitializePlatformSpecific( 179 CallInterfaceDescriptorData* data) { 180 // a0 : number of arguments 181 // a1 : the function to call 182 // a2 : feedback vector 183 // a3 : slot in feedback vector (Smi, for RecordCallTarget) 184 // a4 : new target (for IsSuperConstructorCall) 185 // TODO(turbofan): So far we don't gather type feedback and hence skip the 186 // slot parameter, but ArrayConstructStub needs the vector to be undefined. 187 Register registers[] = {a0, a1, a4, a2}; 188 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 189 } 190 191 192 void CallTrampolineDescriptor::InitializePlatformSpecific( 193 CallInterfaceDescriptorData* data) { 194 // a1: target 195 // a0: number of arguments 196 Register registers[] = {a1, a0}; 197 data->InitializePlatformSpecific(arraysize(registers), registers); 198 } 199 200 201 void ConstructStubDescriptor::InitializePlatformSpecific( 202 CallInterfaceDescriptorData* data) { 203 // a1: target 204 // a3: new target 205 // a0: number of arguments 206 // a2: allocation site or undefined 207 Register registers[] = {a1, a3, a0, a2}; 208 data->InitializePlatformSpecific(arraysize(registers), registers); 209 } 210 211 212 void ConstructTrampolineDescriptor::InitializePlatformSpecific( 213 CallInterfaceDescriptorData* data) { 214 // a1: target 215 // a3: new target 216 // a0: number of arguments 217 Register registers[] = {a1, a3, a0}; 218 data->InitializePlatformSpecific(arraysize(registers), registers); 219 } 220 221 222 void RegExpConstructResultDescriptor::InitializePlatformSpecific( 223 CallInterfaceDescriptorData* data) { 224 Register registers[] = {a2, a1, a0}; 225 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 226 } 227 228 229 void TransitionElementsKindDescriptor::InitializePlatformSpecific( 230 CallInterfaceDescriptorData* data) { 231 Register registers[] = {a0, a1}; 232 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 233 } 234 235 236 void AllocateHeapNumberDescriptor::InitializePlatformSpecific( 237 CallInterfaceDescriptorData* data) { 238 // register state 239 data->InitializePlatformSpecific(0, nullptr, nullptr); 240 } 241 242 #define SIMD128_ALLOC_DESC(TYPE, Type, type, lane_count, lane_type) \ 243 void Allocate##Type##Descriptor::InitializePlatformSpecific( \ 244 CallInterfaceDescriptorData* data) { \ 245 data->InitializePlatformSpecific(0, nullptr, nullptr); \ 246 } 247 SIMD128_TYPES(SIMD128_ALLOC_DESC) 248 #undef SIMD128_ALLOC_DESC 249 250 void ArrayNoArgumentConstructorDescriptor::InitializePlatformSpecific( 251 CallInterfaceDescriptorData* data) { 252 // register state 253 // a0 -- number of arguments 254 // a1 -- function 255 // a2 -- allocation site with elements kind 256 Register registers[] = {a1, a2, a0}; 257 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 258 } 259 260 void ArraySingleArgumentConstructorDescriptor::InitializePlatformSpecific( 261 CallInterfaceDescriptorData* data) { 262 // register state 263 // a0 -- number of arguments 264 // a1 -- function 265 // a2 -- allocation site with elements kind 266 Register registers[] = {a1, a2, a0}; 267 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 268 } 269 270 void ArrayNArgumentsConstructorDescriptor::InitializePlatformSpecific( 271 CallInterfaceDescriptorData* data) { 272 // stack param count needs (constructor pointer, and single argument) 273 Register registers[] = {a1, a2, a0}; 274 data->InitializePlatformSpecific(arraysize(registers), registers); 275 } 276 277 void VarArgFunctionDescriptor::InitializePlatformSpecific( 278 CallInterfaceDescriptorData* data) { 279 // stack param count needs (arg count) 280 Register registers[] = {a0}; 281 data->InitializePlatformSpecific(arraysize(registers), registers); 282 } 283 void CompareDescriptor::InitializePlatformSpecific( 284 CallInterfaceDescriptorData* data) { 285 Register registers[] = {a1, a0}; 286 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 287 } 288 289 290 void BinaryOpDescriptor::InitializePlatformSpecific( 291 CallInterfaceDescriptorData* data) { 292 Register registers[] = {a1, a0}; 293 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 294 } 295 296 297 void BinaryOpWithAllocationSiteDescriptor::InitializePlatformSpecific( 298 CallInterfaceDescriptorData* data) { 299 Register registers[] = {a2, a1, a0}; 300 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 301 } 302 303 void CountOpDescriptor::InitializePlatformSpecific( 304 CallInterfaceDescriptorData* data) { 305 Register registers[] = {a1}; 306 data->InitializePlatformSpecific(arraysize(registers), registers); 307 } 308 309 void StringAddDescriptor::InitializePlatformSpecific( 310 CallInterfaceDescriptorData* data) { 311 Register registers[] = {a1, a0}; 312 data->InitializePlatformSpecific(arraysize(registers), registers, NULL); 313 } 314 315 316 void KeyedDescriptor::InitializePlatformSpecific( 317 CallInterfaceDescriptorData* data) { 318 Register registers[] = { 319 a2, // key 320 }; 321 data->InitializePlatformSpecific(arraysize(registers), registers); 322 } 323 324 325 void NamedDescriptor::InitializePlatformSpecific( 326 CallInterfaceDescriptorData* data) { 327 Register registers[] = { 328 a2, // name 329 }; 330 data->InitializePlatformSpecific(arraysize(registers), registers); 331 } 332 333 334 void CallHandlerDescriptor::InitializePlatformSpecific( 335 CallInterfaceDescriptorData* data) { 336 Register registers[] = { 337 a0, // receiver 338 }; 339 data->InitializePlatformSpecific(arraysize(registers), registers); 340 } 341 342 343 void ArgumentAdaptorDescriptor::InitializePlatformSpecific( 344 CallInterfaceDescriptorData* data) { 345 Register registers[] = { 346 a1, // JSFunction 347 a3, // the new target 348 a0, // actual number of arguments 349 a2, // expected number of arguments 350 }; 351 data->InitializePlatformSpecific(arraysize(registers), registers); 352 } 353 354 void ApiCallbackDescriptorBase::InitializePlatformSpecific( 355 CallInterfaceDescriptorData* data) { 356 Register registers[] = { 357 a0, // callee 358 a4, // call_data 359 a2, // holder 360 a1, // api_function_address 361 }; 362 data->InitializePlatformSpecific(arraysize(registers), registers); 363 } 364 365 void InterpreterDispatchDescriptor::InitializePlatformSpecific( 366 CallInterfaceDescriptorData* data) { 367 Register registers[] = { 368 kInterpreterAccumulatorRegister, kInterpreterBytecodeOffsetRegister, 369 kInterpreterBytecodeArrayRegister, kInterpreterDispatchTableRegister}; 370 data->InitializePlatformSpecific(arraysize(registers), registers); 371 } 372 373 void InterpreterPushArgsAndCallDescriptor::InitializePlatformSpecific( 374 CallInterfaceDescriptorData* data) { 375 Register registers[] = { 376 a0, // argument count (not including receiver) 377 a2, // address of first argument 378 a1 // the target callable to be call 379 }; 380 data->InitializePlatformSpecific(arraysize(registers), registers); 381 } 382 383 void InterpreterPushArgsAndConstructDescriptor::InitializePlatformSpecific( 384 CallInterfaceDescriptorData* data) { 385 Register registers[] = { 386 a0, // argument count (not including receiver) 387 a3, // new target 388 a1, // constructor to call 389 a2 // address of the first argument 390 }; 391 data->InitializePlatformSpecific(arraysize(registers), registers); 392 } 393 394 void InterpreterCEntryDescriptor::InitializePlatformSpecific( 395 CallInterfaceDescriptorData* data) { 396 Register registers[] = { 397 a0, // argument count (argc) 398 a2, // address of first argument (argv) 399 a1 // the runtime function to call 400 }; 401 data->InitializePlatformSpecific(arraysize(registers), registers); 402 } 403 404 void ResumeGeneratorDescriptor::InitializePlatformSpecific( 405 CallInterfaceDescriptorData* data) { 406 Register registers[] = { 407 v0, // the value to pass to the generator 408 a1, // the JSGeneratorObject to resume 409 a2 // the resume mode (tagged) 410 }; 411 data->InitializePlatformSpecific(arraysize(registers), registers); 412 } 413 414 } // namespace internal 415 } // namespace v8 416 417 #endif // V8_TARGET_ARCH_MIPS64 418
