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 #include "src/v8.h" 6 7 #if V8_TARGET_ARCH_MIPS64 8 9 #include "src/interface-descriptors.h" 10 11 namespace v8 { 12 namespace internal { 13 14 const Register CallInterfaceDescriptor::ContextRegister() { return cp; } 15 16 17 const Register LoadDescriptor::ReceiverRegister() { return a1; } 18 const Register LoadDescriptor::NameRegister() { return a2; } 19 20 21 const Register VectorLoadICTrampolineDescriptor::SlotRegister() { return a0; } 22 23 24 const Register VectorLoadICDescriptor::VectorRegister() { return a3; } 25 26 27 const Register StoreDescriptor::ReceiverRegister() { return a1; } 28 const Register StoreDescriptor::NameRegister() { return a2; } 29 const Register StoreDescriptor::ValueRegister() { return a0; } 30 31 32 const Register ElementTransitionAndStoreDescriptor::MapRegister() { return a3; } 33 34 35 const Register InstanceofDescriptor::left() { return a0; } 36 const Register InstanceofDescriptor::right() { return a1; } 37 38 39 const Register ArgumentsAccessReadDescriptor::index() { return a1; } 40 const Register ArgumentsAccessReadDescriptor::parameter_count() { return a0; } 41 42 43 const Register ApiGetterDescriptor::function_address() { return a2; } 44 45 46 const Register MathPowTaggedDescriptor::exponent() { return a2; } 47 48 49 const Register MathPowIntegerDescriptor::exponent() { 50 return MathPowTaggedDescriptor::exponent(); 51 } 52 53 54 void FastNewClosureDescriptor::Initialize(CallInterfaceDescriptorData* data) { 55 Register registers[] = {cp, a2}; 56 data->Initialize(arraysize(registers), registers, NULL); 57 } 58 59 60 void FastNewContextDescriptor::Initialize(CallInterfaceDescriptorData* data) { 61 Register registers[] = {cp, a1}; 62 data->Initialize(arraysize(registers), registers, NULL); 63 } 64 65 66 void ToNumberDescriptor::Initialize(CallInterfaceDescriptorData* data) { 67 Register registers[] = {cp, a0}; 68 data->Initialize(arraysize(registers), registers, NULL); 69 } 70 71 72 void NumberToStringDescriptor::Initialize(CallInterfaceDescriptorData* data) { 73 Register registers[] = {cp, a0}; 74 data->Initialize(arraysize(registers), registers, NULL); 75 } 76 77 78 void FastCloneShallowArrayDescriptor::Initialize( 79 CallInterfaceDescriptorData* data) { 80 Register registers[] = {cp, a3, a2, a1}; 81 Representation representations[] = { 82 Representation::Tagged(), Representation::Tagged(), Representation::Smi(), 83 Representation::Tagged()}; 84 data->Initialize(arraysize(registers), registers, representations); 85 } 86 87 88 void FastCloneShallowObjectDescriptor::Initialize( 89 CallInterfaceDescriptorData* data) { 90 Register registers[] = {cp, a3, a2, a1, a0}; 91 data->Initialize(arraysize(registers), registers, NULL); 92 } 93 94 95 void CreateAllocationSiteDescriptor::Initialize( 96 CallInterfaceDescriptorData* data) { 97 Register registers[] = {cp, a2, a3}; 98 data->Initialize(arraysize(registers), registers, NULL); 99 } 100 101 102 void StoreArrayLiteralElementDescriptor::Initialize( 103 CallInterfaceDescriptorData* data) { 104 Register registers[] = {cp, a3, a0}; 105 data->Initialize(arraysize(registers), registers, NULL); 106 } 107 108 109 void CallFunctionWithFeedbackDescriptor::Initialize( 110 CallInterfaceDescriptorData* data) { 111 Register registers[] = {cp, a1, a3}; 112 Representation representations[] = {Representation::Tagged(), 113 Representation::Tagged(), 114 Representation::Smi()}; 115 data->Initialize(arraysize(registers), registers, representations); 116 } 117 118 119 void CallFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) { 120 Register registers[] = {cp, a1}; 121 data->Initialize(arraysize(registers), registers, NULL); 122 } 123 124 125 void CallConstructDescriptor::Initialize(CallInterfaceDescriptorData* data) { 126 // a0 : number of arguments 127 // a1 : the function to call 128 // a2 : feedback vector 129 // a3 : (only if a2 is not the megamorphic symbol) slot in feedback 130 // vector (Smi) 131 // TODO(turbofan): So far we don't gather type feedback and hence skip the 132 // slot parameter, but ArrayConstructStub needs the vector to be undefined. 133 Register registers[] = {cp, a0, a1, a2}; 134 data->Initialize(arraysize(registers), registers, NULL); 135 } 136 137 138 void RegExpConstructResultDescriptor::Initialize( 139 CallInterfaceDescriptorData* data) { 140 Register registers[] = {cp, a2, a1, a0}; 141 data->Initialize(arraysize(registers), registers, NULL); 142 } 143 144 145 void TransitionElementsKindDescriptor::Initialize( 146 CallInterfaceDescriptorData* data) { 147 Register registers[] = {cp, a0, a1}; 148 data->Initialize(arraysize(registers), registers, NULL); 149 } 150 151 152 void ArrayConstructorConstantArgCountDescriptor::Initialize( 153 CallInterfaceDescriptorData* data) { 154 // register state 155 // cp -- context 156 // a0 -- number of arguments 157 // a1 -- function 158 // a2 -- allocation site with elements kind 159 Register registers[] = {cp, a1, a2}; 160 data->Initialize(arraysize(registers), registers, NULL); 161 } 162 163 164 void ArrayConstructorDescriptor::Initialize(CallInterfaceDescriptorData* data) { 165 // stack param count needs (constructor pointer, and single argument) 166 Register registers[] = {cp, a1, a2, a0}; 167 Representation representations[] = { 168 Representation::Tagged(), Representation::Tagged(), 169 Representation::Tagged(), Representation::Integer32()}; 170 data->Initialize(arraysize(registers), registers, representations); 171 } 172 173 174 void InternalArrayConstructorConstantArgCountDescriptor::Initialize( 175 CallInterfaceDescriptorData* data) { 176 // register state 177 // cp -- context 178 // a0 -- number of arguments 179 // a1 -- constructor function 180 Register registers[] = {cp, a1}; 181 data->Initialize(arraysize(registers), registers, NULL); 182 } 183 184 185 void InternalArrayConstructorDescriptor::Initialize( 186 CallInterfaceDescriptorData* data) { 187 // stack param count needs (constructor pointer, and single argument) 188 Register registers[] = {cp, a1, a0}; 189 Representation representations[] = {Representation::Tagged(), 190 Representation::Tagged(), 191 Representation::Integer32()}; 192 data->Initialize(arraysize(registers), registers, representations); 193 } 194 195 196 void CompareNilDescriptor::Initialize(CallInterfaceDescriptorData* data) { 197 Register registers[] = {cp, a0}; 198 data->Initialize(arraysize(registers), registers, NULL); 199 } 200 201 202 void ToBooleanDescriptor::Initialize(CallInterfaceDescriptorData* data) { 203 Register registers[] = {cp, a0}; 204 data->Initialize(arraysize(registers), registers, NULL); 205 } 206 207 208 void BinaryOpDescriptor::Initialize(CallInterfaceDescriptorData* data) { 209 Register registers[] = {cp, a1, a0}; 210 data->Initialize(arraysize(registers), registers, NULL); 211 } 212 213 214 void BinaryOpWithAllocationSiteDescriptor::Initialize( 215 CallInterfaceDescriptorData* data) { 216 Register registers[] = {cp, a2, a1, a0}; 217 data->Initialize(arraysize(registers), registers, NULL); 218 } 219 220 221 void StringAddDescriptor::Initialize(CallInterfaceDescriptorData* data) { 222 Register registers[] = {cp, a1, a0}; 223 data->Initialize(arraysize(registers), registers, NULL); 224 } 225 226 227 void KeyedDescriptor::Initialize(CallInterfaceDescriptorData* data) { 228 Register registers[] = { 229 cp, // context 230 a2, // key 231 }; 232 Representation representations[] = { 233 Representation::Tagged(), // context 234 Representation::Tagged(), // key 235 }; 236 data->Initialize(arraysize(registers), registers, representations); 237 } 238 239 240 void NamedDescriptor::Initialize(CallInterfaceDescriptorData* data) { 241 Register registers[] = { 242 cp, // context 243 a2, // name 244 }; 245 Representation representations[] = { 246 Representation::Tagged(), // context 247 Representation::Tagged(), // name 248 }; 249 data->Initialize(arraysize(registers), registers, representations); 250 } 251 252 253 void CallHandlerDescriptor::Initialize(CallInterfaceDescriptorData* data) { 254 Register registers[] = { 255 cp, // context 256 a0, // receiver 257 }; 258 Representation representations[] = { 259 Representation::Tagged(), // context 260 Representation::Tagged(), // receiver 261 }; 262 data->Initialize(arraysize(registers), registers, representations); 263 } 264 265 266 void ArgumentAdaptorDescriptor::Initialize(CallInterfaceDescriptorData* data) { 267 Register registers[] = { 268 cp, // context 269 a1, // JSFunction 270 a0, // actual number of arguments 271 a2, // expected number of arguments 272 }; 273 Representation representations[] = { 274 Representation::Tagged(), // context 275 Representation::Tagged(), // JSFunction 276 Representation::Integer32(), // actual number of arguments 277 Representation::Integer32(), // expected number of arguments 278 }; 279 data->Initialize(arraysize(registers), registers, representations); 280 } 281 282 283 void ApiFunctionDescriptor::Initialize(CallInterfaceDescriptorData* data) { 284 Register registers[] = { 285 cp, // context 286 a0, // callee 287 a4, // call_data 288 a2, // holder 289 a1, // api_function_address 290 }; 291 Representation representations[] = { 292 Representation::Tagged(), // context 293 Representation::Tagged(), // callee 294 Representation::Tagged(), // call_data 295 Representation::Tagged(), // holder 296 Representation::External(), // api_function_address 297 }; 298 data->Initialize(arraysize(registers), registers, representations); 299 } 300 } 301 } // namespace v8::internal 302 303 #endif // V8_TARGET_ARCH_MIPS64 304
