OLD | NEW |
1 // Copyright 2010 the V8 project authors. All rights reserved. | 1 // Copyright 2010 the V8 project authors. All rights reserved. |
2 // Redistribution and use in source and binary forms, with or without | 2 // Redistribution and use in source and binary forms, with or without |
3 // modification, are permitted provided that the following conditions are | 3 // modification, are permitted provided that the following conditions are |
4 // met: | 4 // met: |
5 // | 5 // |
6 // * Redistributions of source code must retain the above copyright | 6 // * Redistributions of source code must retain the above copyright |
7 // notice, this list of conditions and the following disclaimer. | 7 // notice, this list of conditions and the following disclaimer. |
8 // * Redistributions in binary form must reproduce the above | 8 // * Redistributions in binary form must reproduce the above |
9 // copyright notice, this list of conditions and the following | 9 // copyright notice, this list of conditions and the following |
10 // disclaimer in the documentation and/or other materials provided | 10 // disclaimer in the documentation and/or other materials provided |
(...skipping 39 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... |
50 } | 50 } |
51 | 51 |
52 | 52 |
53 void StubCompiler::GenerateLoadGlobalFunctionPrototype(MacroAssembler* masm, | 53 void StubCompiler::GenerateLoadGlobalFunctionPrototype(MacroAssembler* masm, |
54 int index, | 54 int index, |
55 Register prototype) { | 55 Register prototype) { |
56 UNIMPLEMENTED_MIPS(); | 56 UNIMPLEMENTED_MIPS(); |
57 } | 57 } |
58 | 58 |
59 | 59 |
| 60 void StubCompiler::GenerateDirectLoadGlobalFunctionPrototype( |
| 61 MacroAssembler* masm, int index, Register prototype, Label* miss) { |
| 62 UNIMPLEMENTED_MIPS(); |
| 63 } |
| 64 |
| 65 |
60 // Load a fast property out of a holder object (src). In-object properties | 66 // Load a fast property out of a holder object (src). In-object properties |
61 // are loaded directly otherwise the property is loaded from the properties | 67 // are loaded directly otherwise the property is loaded from the properties |
62 // fixed array. | 68 // fixed array. |
63 void StubCompiler::GenerateFastPropertyLoad(MacroAssembler* masm, | 69 void StubCompiler::GenerateFastPropertyLoad(MacroAssembler* masm, |
64 Register dst, Register src, | 70 Register dst, Register src, |
65 JSObject* holder, int index) { | 71 JSObject* holder, int index) { |
66 UNIMPLEMENTED_MIPS(); | 72 UNIMPLEMENTED_MIPS(); |
67 } | 73 } |
68 | 74 |
69 | 75 |
70 void StubCompiler::GenerateLoadArrayLength(MacroAssembler* masm, | 76 void StubCompiler::GenerateLoadArrayLength(MacroAssembler* masm, |
71 Register receiver, | 77 Register receiver, |
72 Register scratch, | 78 Register scratch, |
73 Label* miss_label) { | 79 Label* miss_label) { |
74 UNIMPLEMENTED_MIPS(); | 80 UNIMPLEMENTED_MIPS(); |
75 } | 81 } |
76 | 82 |
77 | 83 |
| 84 // Generate code to load the length from a string object and return the length. |
| 85 // If the receiver object is not a string or a wrapped string object the |
| 86 // execution continues at the miss label. The register containing the |
| 87 // receiver is potentially clobbered. |
| 88 void StubCompiler::GenerateLoadStringLength(MacroAssembler* masm, |
| 89 Register receiver, |
| 90 Register scratch1, |
| 91 Register scratch2, |
| 92 Label* miss, |
| 93 bool support_wrappers) { |
| 94 UNIMPLEMENTED_MIPS(); |
| 95 } |
| 96 |
| 97 |
78 void StubCompiler::GenerateLoadFunctionPrototype(MacroAssembler* masm, | 98 void StubCompiler::GenerateLoadFunctionPrototype(MacroAssembler* masm, |
79 Register receiver, | 99 Register receiver, |
80 Register scratch1, | 100 Register scratch1, |
81 Register scratch2, | 101 Register scratch2, |
82 Label* miss_label) { | 102 Label* miss_label) { |
83 UNIMPLEMENTED_MIPS(); | 103 UNIMPLEMENTED_MIPS(); |
84 } | 104 } |
85 | 105 |
86 | 106 |
87 // Generate StoreField code, value is passed in r0 register. | 107 // Generate StoreField code, value is passed in a0 register. |
88 // After executing generated code, the receiver_reg and name_reg | 108 // After executing generated code, the receiver_reg and name_reg |
89 // may be clobbered. | 109 // may be clobbered. |
90 void StubCompiler::GenerateStoreField(MacroAssembler* masm, | 110 void StubCompiler::GenerateStoreField(MacroAssembler* masm, |
91 JSObject* object, | 111 JSObject* object, |
92 int index, | 112 int index, |
93 Map* transition, | 113 Map* transition, |
94 Register receiver_reg, | 114 Register receiver_reg, |
95 Register name_reg, | 115 Register name_reg, |
96 Register scratch, | 116 Register scratch, |
97 Label* miss_label) { | 117 Label* miss_label) { |
98 UNIMPLEMENTED_MIPS(); | 118 UNIMPLEMENTED_MIPS(); |
99 } | 119 } |
100 | 120 |
101 | 121 |
102 void StubCompiler::GenerateLoadMiss(MacroAssembler* masm, Code::Kind kind) { | 122 void StubCompiler::GenerateLoadMiss(MacroAssembler* masm, Code::Kind kind) { |
103 UNIMPLEMENTED_MIPS(); | 123 UNIMPLEMENTED_MIPS(); |
104 } | 124 } |
105 | 125 |
106 | 126 |
| 127 class CallInterceptorCompiler BASE_EMBEDDED { |
| 128 public: |
| 129 CallInterceptorCompiler(StubCompiler* stub_compiler, |
| 130 const ParameterCount& arguments, |
| 131 Register name) |
| 132 : stub_compiler_(stub_compiler), |
| 133 arguments_(arguments), |
| 134 name_(name) {} |
| 135 |
| 136 void Compile(MacroAssembler* masm, |
| 137 JSObject* object, |
| 138 JSObject* holder, |
| 139 String* name, |
| 140 LookupResult* lookup, |
| 141 Register receiver, |
| 142 Register scratch1, |
| 143 Register scratch2, |
| 144 Register scratch3, |
| 145 Label* miss) { |
| 146 UNIMPLEMENTED_MIPS(); |
| 147 } |
| 148 |
| 149 private: |
| 150 void CompileCacheable(MacroAssembler* masm, |
| 151 JSObject* object, |
| 152 Register receiver, |
| 153 Register scratch1, |
| 154 Register scratch2, |
| 155 Register scratch3, |
| 156 JSObject* interceptor_holder, |
| 157 LookupResult* lookup, |
| 158 String* name, |
| 159 const CallOptimization& optimization, |
| 160 Label* miss_label) { |
| 161 UNIMPLEMENTED_MIPS(); |
| 162 } |
| 163 |
| 164 void CompileRegular(MacroAssembler* masm, |
| 165 JSObject* object, |
| 166 Register receiver, |
| 167 Register scratch1, |
| 168 Register scratch2, |
| 169 Register scratch3, |
| 170 String* name, |
| 171 JSObject* interceptor_holder, |
| 172 Label* miss_label) { |
| 173 UNIMPLEMENTED_MIPS(); |
| 174 } |
| 175 |
| 176 void LoadWithInterceptor(MacroAssembler* masm, |
| 177 Register receiver, |
| 178 Register holder, |
| 179 JSObject* holder_obj, |
| 180 Register scratch, |
| 181 Label* interceptor_succeeded) { |
| 182 UNIMPLEMENTED_MIPS(); |
| 183 } |
| 184 |
| 185 StubCompiler* stub_compiler_; |
| 186 const ParameterCount& arguments_; |
| 187 Register name_; |
| 188 }; |
| 189 |
| 190 |
107 #undef __ | 191 #undef __ |
108 #define __ ACCESS_MASM(masm()) | 192 #define __ ACCESS_MASM(masm()) |
109 | 193 |
110 | 194 |
| 195 Register StubCompiler::CheckPrototypes(JSObject* object, |
| 196 Register object_reg, |
| 197 JSObject* holder, |
| 198 Register holder_reg, |
| 199 Register scratch1, |
| 200 Register scratch2, |
| 201 String* name, |
| 202 int save_at_depth, |
| 203 Label* miss) { |
| 204 UNIMPLEMENTED_MIPS(); |
| 205 return no_reg; |
| 206 } |
| 207 |
| 208 |
111 void StubCompiler::GenerateLoadField(JSObject* object, | 209 void StubCompiler::GenerateLoadField(JSObject* object, |
112 JSObject* holder, | 210 JSObject* holder, |
113 Register receiver, | 211 Register receiver, |
114 Register scratch1, | 212 Register scratch1, |
115 Register scratch2, | 213 Register scratch2, |
| 214 Register scratch3, |
116 int index, | 215 int index, |
117 String* name, | 216 String* name, |
118 Label* miss) { | 217 Label* miss) { |
119 UNIMPLEMENTED_MIPS(); | 218 UNIMPLEMENTED_MIPS(); |
120 } | 219 } |
121 | 220 |
122 | 221 |
123 void StubCompiler::GenerateLoadConstant(JSObject* object, | 222 void StubCompiler::GenerateLoadConstant(JSObject* object, |
124 JSObject* holder, | 223 JSObject* holder, |
125 Register receiver, | 224 Register receiver, |
126 Register scratch1, | 225 Register scratch1, |
127 Register scratch2, | 226 Register scratch2, |
| 227 Register scratch3, |
128 Object* value, | 228 Object* value, |
129 String* name, | 229 String* name, |
130 Label* miss) { | 230 Label* miss) { |
131 UNIMPLEMENTED_MIPS(); | 231 UNIMPLEMENTED_MIPS(); |
132 } | 232 } |
133 | 233 |
134 | 234 |
135 bool StubCompiler::GenerateLoadCallback(JSObject* object, | 235 MaybeObject* StubCompiler::GenerateLoadCallback(JSObject* object, |
136 JSObject* holder, | 236 JSObject* holder, |
137 Register receiver, | 237 Register receiver, |
138 Register name_reg, | 238 Register name_reg, |
139 Register scratch1, | 239 Register scratch1, |
140 Register scratch2, | 240 Register scratch2, |
141 AccessorInfo* callback, | 241 Register scratch3, |
142 String* name, | 242 AccessorInfo* callback, |
143 Label* miss, | 243 String* name, |
144 Failure** failure) { | 244 Label* miss) { |
145 UNIMPLEMENTED_MIPS(); | 245 UNIMPLEMENTED_MIPS(); |
146 __ break_(0x470); | 246 return NULL; |
147 return false; // UNIMPLEMENTED RETURN | |
148 } | 247 } |
149 | 248 |
150 | 249 |
151 void StubCompiler::GenerateLoadInterceptor(JSObject* object, | 250 void StubCompiler::GenerateLoadInterceptor(JSObject* object, |
152 JSObject* holder, | 251 JSObject* interceptor_holder, |
153 LookupResult* lookup, | 252 LookupResult* lookup, |
154 Register receiver, | 253 Register receiver, |
155 Register name_reg, | 254 Register name_reg, |
156 Register scratch1, | 255 Register scratch1, |
157 Register scratch2, | 256 Register scratch2, |
| 257 Register scratch3, |
158 String* name, | 258 String* name, |
159 Label* miss) { | 259 Label* miss) { |
160 UNIMPLEMENTED_MIPS(); | 260 UNIMPLEMENTED_MIPS(); |
161 __ break_(0x505); | 261 } |
162 } | 262 |
163 | 263 |
164 | 264 void CallStubCompiler::GenerateNameCheck(String* name, Label* miss) { |
165 Object* StubCompiler::CompileLazyCompile(Code::Flags flags) { | 265 UNIMPLEMENTED_MIPS(); |
166 // Registers: | 266 } |
167 // a1: function | 267 |
168 // ra: return address | 268 |
169 | 269 void CallStubCompiler::GenerateGlobalReceiverCheck(JSObject* object, |
170 // Enter an internal frame. | 270 JSObject* holder, |
171 __ EnterInternalFrame(); | 271 String* name, |
172 // Preserve the function. | 272 Label* miss) { |
173 __ Push(a1); | 273 UNIMPLEMENTED_MIPS(); |
174 // Setup aligned call. | 274 } |
175 __ SetupAlignedCall(t0, 1); | 275 |
176 // Push the function on the stack as the argument to the runtime function. | 276 |
177 __ Push(a1); | 277 void CallStubCompiler::GenerateLoadFunctionFromCell(JSGlobalPropertyCell* cell, |
178 // Call the runtime function | 278 JSFunction* function, |
179 __ CallRuntime(Runtime::kLazyCompile, 1); | 279 Label* miss) { |
180 __ ReturnFromAlignedCall(); | 280 UNIMPLEMENTED_MIPS(); |
181 // Calculate the entry point. | 281 } |
182 __ addiu(t9, v0, Code::kHeaderSize - kHeapObjectTag); | 282 |
183 // Restore saved function. | 283 |
184 __ Pop(a1); | 284 MaybeObject* CallStubCompiler::GenerateMissBranch() { |
185 // Tear down temporary frame. | 285 UNIMPLEMENTED_MIPS(); |
186 __ LeaveInternalFrame(); | 286 return NULL; |
187 // Do a tail-call of the compiled function. | 287 } |
188 __ Jump(t9); | 288 |
189 | 289 |
190 return GetCodeWithFlags(flags, "LazyCompileStub"); | 290 MaybeObject* CallStubCompiler::CompileCallField(JSObject* object, |
191 } | 291 JSObject* holder, |
192 | 292 int index, |
193 | |
194 Object* CallStubCompiler::CompileCallField(JSObject* object, | |
195 JSObject* holder, | |
196 int index, | |
197 String* name) { | |
198 UNIMPLEMENTED_MIPS(); | |
199 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | |
200 } | |
201 | |
202 | |
203 Object* CallStubCompiler::CompileArrayPushCall(Object* object, | |
204 JSObject* holder, | |
205 JSFunction* function, | |
206 String* name, | |
207 CheckType check) { | |
208 UNIMPLEMENTED_MIPS(); | |
209 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | |
210 } | |
211 | |
212 | |
213 Object* CallStubCompiler::CompileArrayPopCall(Object* object, | |
214 JSObject* holder, | |
215 JSFunction* function, | |
216 String* name, | |
217 CheckType check) { | |
218 UNIMPLEMENTED_MIPS(); | |
219 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | |
220 } | |
221 | |
222 | |
223 Object* CallStubCompiler::CompileCallConstant(Object* object, | |
224 JSObject* holder, | |
225 JSFunction* function, | |
226 String* name, | |
227 CheckType check) { | |
228 UNIMPLEMENTED_MIPS(); | |
229 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | |
230 } | |
231 | |
232 | |
233 Object* CallStubCompiler::CompileCallInterceptor(JSObject* object, | |
234 JSObject* holder, | |
235 String* name) { | |
236 UNIMPLEMENTED_MIPS(); | |
237 __ break_(0x782); | |
238 return GetCode(INTERCEPTOR, name); | |
239 } | |
240 | |
241 | |
242 Object* CallStubCompiler::CompileCallGlobal(JSObject* object, | |
243 GlobalObject* holder, | |
244 JSGlobalPropertyCell* cell, | |
245 JSFunction* function, | |
246 String* name) { | |
247 UNIMPLEMENTED_MIPS(); | |
248 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | |
249 } | |
250 | |
251 | |
252 Object* StoreStubCompiler::CompileStoreField(JSObject* object, | |
253 int index, | |
254 Map* transition, | |
255 String* name) { | |
256 UNIMPLEMENTED_MIPS(); | |
257 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | |
258 } | |
259 | |
260 | |
261 Object* StoreStubCompiler::CompileStoreCallback(JSObject* object, | |
262 AccessorInfo* callback, | |
263 String* name) { | 293 String* name) { |
264 UNIMPLEMENTED_MIPS(); | 294 UNIMPLEMENTED_MIPS(); |
265 __ break_(0x906); | 295 return NULL; |
266 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 296 } |
267 } | 297 |
268 | 298 |
269 | 299 MaybeObject* CallStubCompiler::CompileArrayPushCall(Object* object, |
270 Object* StoreStubCompiler::CompileStoreInterceptor(JSObject* receiver, | 300 JSObject* holder, |
| 301 JSGlobalPropertyCell* cell, |
| 302 JSFunction* function, |
| 303 String* name) { |
| 304 UNIMPLEMENTED_MIPS(); |
| 305 return NULL; |
| 306 } |
| 307 |
| 308 |
| 309 MaybeObject* CallStubCompiler::CompileArrayPopCall(Object* object, |
| 310 JSObject* holder, |
| 311 JSGlobalPropertyCell* cell, |
| 312 JSFunction* function, |
271 String* name) { | 313 String* name) { |
272 UNIMPLEMENTED_MIPS(); | 314 UNIMPLEMENTED_MIPS(); |
273 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 315 return NULL; |
274 } | 316 } |
275 | 317 |
276 | 318 |
277 Object* StoreStubCompiler::CompileStoreGlobal(GlobalObject* object, | 319 MaybeObject* CallStubCompiler::CompileStringCharCodeAtCall( |
278 JSGlobalPropertyCell* cell, | 320 Object* object, |
279 String* name) { | 321 JSObject* holder, |
280 UNIMPLEMENTED_MIPS(); | 322 JSGlobalPropertyCell* cell, |
281 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 323 JSFunction* function, |
282 } | 324 String* name) { |
283 | 325 UNIMPLEMENTED_MIPS(); |
284 | 326 return NULL; |
285 Object* LoadStubCompiler::CompileLoadField(JSObject* object, | 327 } |
286 JSObject* holder, | 328 |
287 int index, | 329 |
288 String* name) { | 330 MaybeObject* CallStubCompiler::CompileStringCharAtCall( |
289 UNIMPLEMENTED_MIPS(); | 331 Object* object, |
290 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 332 JSObject* holder, |
291 } | 333 JSGlobalPropertyCell* cell, |
292 | 334 JSFunction* function, |
293 | 335 String* name) { |
294 Object* LoadStubCompiler::CompileLoadCallback(String* name, | 336 UNIMPLEMENTED_MIPS(); |
295 JSObject* object, | 337 return NULL; |
296 JSObject* holder, | 338 } |
297 AccessorInfo* callback) { | 339 |
298 UNIMPLEMENTED_MIPS(); | 340 |
299 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 341 MaybeObject* CallStubCompiler::CompileStringFromCharCodeCall( |
300 } | 342 Object* object, |
301 | 343 JSObject* holder, |
302 | 344 JSGlobalPropertyCell* cell, |
303 Object* LoadStubCompiler::CompileLoadConstant(JSObject* object, | 345 JSFunction* function, |
304 JSObject* holder, | 346 String* name) { |
305 Object* value, | 347 UNIMPLEMENTED_MIPS(); |
306 String* name) { | 348 return NULL; |
307 UNIMPLEMENTED_MIPS(); | 349 } |
308 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 350 |
309 } | 351 |
310 | 352 MaybeObject* CallStubCompiler::CompileMathFloorCall(Object* object, |
311 | 353 JSObject* holder, |
312 Object* LoadStubCompiler::CompileLoadInterceptor(JSObject* object, | 354 JSGlobalPropertyCell* cell, |
313 JSObject* holder, | 355 JSFunction* function, |
314 String* name) { | 356 String* name) { |
315 UNIMPLEMENTED_MIPS(); | 357 UNIMPLEMENTED_MIPS(); |
316 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 358 return NULL; |
317 } | 359 } |
318 | 360 |
319 | 361 |
320 Object* LoadStubCompiler::CompileLoadGlobal(JSObject* object, | 362 MaybeObject* CallStubCompiler::CompileMathAbsCall(Object* object, |
321 GlobalObject* holder, | 363 JSObject* holder, |
322 JSGlobalPropertyCell* cell, | 364 JSGlobalPropertyCell* cell, |
323 String* name, | 365 JSFunction* function, |
324 bool is_dont_delete) { | 366 String* name) { |
325 UNIMPLEMENTED_MIPS(); | 367 UNIMPLEMENTED_MIPS(); |
326 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 368 return NULL; |
327 } | 369 } |
328 | 370 |
329 | 371 |
330 Object* KeyedLoadStubCompiler::CompileLoadField(String* name, | 372 MaybeObject* CallStubCompiler::CompileFastApiCall( |
331 JSObject* receiver, | 373 const CallOptimization& optimization, |
332 JSObject* holder, | 374 Object* object, |
333 int index) { | 375 JSObject* holder, |
334 UNIMPLEMENTED_MIPS(); | 376 JSGlobalPropertyCell* cell, |
335 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 377 JSFunction* function, |
336 } | 378 String* name) { |
337 | 379 UNIMPLEMENTED_MIPS(); |
338 | 380 return NULL; |
339 Object* KeyedLoadStubCompiler::CompileLoadCallback(String* name, | 381 } |
340 JSObject* receiver, | 382 |
341 JSObject* holder, | 383 |
342 AccessorInfo* callback) { | 384 MaybeObject* CallStubCompiler::CompileCallConstant(Object* object, |
343 UNIMPLEMENTED_MIPS(); | 385 JSObject* holder, |
344 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 386 JSFunction* function, |
345 } | 387 String* name, |
346 | 388 CheckType check) { |
347 | 389 UNIMPLEMENTED_MIPS(); |
348 Object* KeyedLoadStubCompiler::CompileLoadConstant(String* name, | 390 return NULL; |
349 JSObject* receiver, | 391 } |
350 JSObject* holder, | 392 |
351 Object* value) { | 393 |
352 UNIMPLEMENTED_MIPS(); | 394 MaybeObject* CallStubCompiler::CompileCallInterceptor(JSObject* object, |
353 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | |
354 } | |
355 | |
356 | |
357 Object* KeyedLoadStubCompiler::CompileLoadInterceptor(JSObject* receiver, | |
358 JSObject* holder, | 395 JSObject* holder, |
359 String* name) { | 396 String* name) { |
360 UNIMPLEMENTED_MIPS(); | 397 UNIMPLEMENTED_MIPS(); |
361 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 398 return NULL; |
362 } | 399 } |
363 | 400 |
364 | 401 |
365 Object* KeyedLoadStubCompiler::CompileLoadArrayLength(String* name) { | 402 MaybeObject* CallStubCompiler::CompileCallGlobal(JSObject* object, |
366 UNIMPLEMENTED_MIPS(); | 403 GlobalObject* holder, |
367 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 404 JSGlobalPropertyCell* cell, |
368 } | 405 JSFunction* function, |
369 | 406 String* name) { |
370 | 407 UNIMPLEMENTED_MIPS(); |
371 Object* KeyedLoadStubCompiler::CompileLoadStringLength(String* name) { | 408 return NULL; |
372 UNIMPLEMENTED_MIPS(); | 409 } |
373 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 410 |
374 } | 411 |
375 | 412 MaybeObject* StoreStubCompiler::CompileStoreField(JSObject* object, |
376 | |
377 // TODO(1224671): implement the fast case. | |
378 Object* KeyedLoadStubCompiler::CompileLoadFunctionPrototype(String* name) { | |
379 UNIMPLEMENTED_MIPS(); | |
380 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | |
381 } | |
382 | |
383 | |
384 Object* KeyedStoreStubCompiler::CompileStoreField(JSObject* object, | |
385 int index, | 413 int index, |
386 Map* transition, | 414 Map* transition, |
387 String* name) { | 415 String* name) { |
388 UNIMPLEMENTED_MIPS(); | 416 UNIMPLEMENTED_MIPS(); |
389 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 417 return NULL; |
390 } | 418 } |
391 | 419 |
392 | 420 |
393 Object* ConstructStubCompiler::CompileConstructStub( | 421 MaybeObject* StoreStubCompiler::CompileStoreCallback(JSObject* object, |
394 SharedFunctionInfo* shared) { | 422 AccessorInfo* callback, |
395 UNIMPLEMENTED_MIPS(); | 423 String* name) { |
396 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 424 UNIMPLEMENTED_MIPS(); |
397 } | 425 return NULL; |
398 | 426 } |
399 | 427 |
400 Object* ExternalArrayStubCompiler::CompileKeyedLoadStub( | 428 |
401 ExternalArrayType array_type, Code::Flags flags) { | 429 MaybeObject* StoreStubCompiler::CompileStoreInterceptor(JSObject* receiver, |
402 UNIMPLEMENTED_MIPS(); | 430 String* name) { |
403 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 431 UNIMPLEMENTED_MIPS(); |
404 } | 432 return NULL; |
405 | 433 } |
406 | 434 |
407 Object* ExternalArrayStubCompiler::CompileKeyedStoreStub( | 435 |
408 ExternalArrayType array_type, Code::Flags flags) { | 436 MaybeObject* StoreStubCompiler::CompileStoreGlobal(GlobalObject* object, |
409 UNIMPLEMENTED_MIPS(); | 437 JSGlobalPropertyCell* cell, |
410 return reinterpret_cast<Object*>(NULL); // UNIMPLEMENTED RETURN | 438 String* name) { |
411 } | 439 UNIMPLEMENTED_MIPS(); |
412 | 440 return NULL; |
413 | 441 } |
| 442 |
| 443 |
| 444 MaybeObject* LoadStubCompiler::CompileLoadNonexistent(String* name, |
| 445 JSObject* object, |
| 446 JSObject* last) { |
| 447 UNIMPLEMENTED_MIPS(); |
| 448 return NULL; |
| 449 } |
| 450 |
| 451 |
| 452 MaybeObject* LoadStubCompiler::CompileLoadField(JSObject* object, |
| 453 JSObject* holder, |
| 454 int index, |
| 455 String* name) { |
| 456 UNIMPLEMENTED_MIPS(); |
| 457 return NULL; |
| 458 } |
| 459 |
| 460 |
| 461 MaybeObject* LoadStubCompiler::CompileLoadCallback(String* name, |
| 462 JSObject* object, |
| 463 JSObject* holder, |
| 464 AccessorInfo* callback) { |
| 465 UNIMPLEMENTED_MIPS(); |
| 466 return NULL; |
| 467 } |
| 468 |
| 469 |
| 470 MaybeObject* LoadStubCompiler::CompileLoadConstant(JSObject* object, |
| 471 JSObject* holder, |
| 472 Object* value, |
| 473 String* name) { |
| 474 UNIMPLEMENTED_MIPS(); |
| 475 return NULL; |
| 476 } |
| 477 |
| 478 |
| 479 MaybeObject* LoadStubCompiler::CompileLoadInterceptor(JSObject* object, |
| 480 JSObject* holder, |
| 481 String* name) { |
| 482 UNIMPLEMENTED_MIPS(); |
| 483 return NULL; |
| 484 } |
| 485 |
| 486 |
| 487 MaybeObject* LoadStubCompiler::CompileLoadGlobal(JSObject* object, |
| 488 GlobalObject* holder, |
| 489 JSGlobalPropertyCell* cell, |
| 490 String* name, |
| 491 bool is_dont_delete) { |
| 492 UNIMPLEMENTED_MIPS(); |
| 493 return NULL; |
| 494 } |
| 495 |
| 496 |
| 497 MaybeObject* KeyedLoadStubCompiler::CompileLoadField(String* name, |
| 498 JSObject* receiver, |
| 499 JSObject* holder, |
| 500 int index) { |
| 501 UNIMPLEMENTED_MIPS(); |
| 502 return NULL; |
| 503 } |
| 504 |
| 505 |
| 506 MaybeObject* KeyedLoadStubCompiler::CompileLoadCallback( |
| 507 String* name, |
| 508 JSObject* receiver, |
| 509 JSObject* holder, |
| 510 AccessorInfo* callback) { |
| 511 UNIMPLEMENTED_MIPS(); |
| 512 return NULL; |
| 513 } |
| 514 |
| 515 |
| 516 MaybeObject* KeyedLoadStubCompiler::CompileLoadConstant(String* name, |
| 517 JSObject* receiver, |
| 518 JSObject* holder, |
| 519 Object* value) { |
| 520 UNIMPLEMENTED_MIPS(); |
| 521 return NULL; |
| 522 } |
| 523 |
| 524 |
| 525 MaybeObject* KeyedLoadStubCompiler::CompileLoadInterceptor(JSObject* receiver, |
| 526 JSObject* holder, |
| 527 String* name) { |
| 528 UNIMPLEMENTED_MIPS(); |
| 529 return NULL; |
| 530 } |
| 531 |
| 532 |
| 533 MaybeObject* KeyedLoadStubCompiler::CompileLoadArrayLength(String* name) { |
| 534 UNIMPLEMENTED_MIPS(); |
| 535 return NULL; |
| 536 } |
| 537 |
| 538 |
| 539 MaybeObject* KeyedLoadStubCompiler::CompileLoadStringLength(String* name) { |
| 540 UNIMPLEMENTED_MIPS(); |
| 541 return NULL; |
| 542 } |
| 543 |
| 544 |
| 545 MaybeObject* KeyedLoadStubCompiler::CompileLoadFunctionPrototype(String* name) { |
| 546 UNIMPLEMENTED_MIPS(); |
| 547 return NULL; |
| 548 } |
| 549 |
| 550 |
| 551 MaybeObject* KeyedLoadStubCompiler::CompileLoadSpecialized(JSObject* receiver) { |
| 552 UNIMPLEMENTED_MIPS(); |
| 553 return NULL; |
| 554 } |
| 555 |
| 556 |
| 557 MaybeObject* KeyedStoreStubCompiler::CompileStoreField(JSObject* object, |
| 558 int index, |
| 559 Map* transition, |
| 560 String* name) { |
| 561 UNIMPLEMENTED_MIPS(); |
| 562 return NULL; |
| 563 } |
| 564 |
| 565 |
| 566 MaybeObject* KeyedStoreStubCompiler::CompileStoreSpecialized( |
| 567 JSObject* receiver) { |
| 568 UNIMPLEMENTED_MIPS(); |
| 569 return NULL; |
| 570 } |
| 571 |
| 572 |
| 573 MaybeObject* ConstructStubCompiler::CompileConstructStub(JSFunction* function) { |
| 574 UNIMPLEMENTED_MIPS(); |
| 575 return NULL; |
| 576 } |
| 577 |
| 578 |
| 579 MaybeObject* ExternalArrayStubCompiler::CompileKeyedLoadStub( |
| 580 JSObject* receiver_object, |
| 581 ExternalArrayType array_type, |
| 582 Code::Flags flags) { |
| 583 UNIMPLEMENTED_MIPS(); |
| 584 return NULL; |
| 585 } |
| 586 |
| 587 |
| 588 MaybeObject* ExternalArrayStubCompiler::CompileKeyedStoreStub( |
| 589 JSObject* receiver_object, |
| 590 ExternalArrayType array_type, |
| 591 Code::Flags flags) { |
| 592 UNIMPLEMENTED_MIPS(); |
| 593 return NULL; |
| 594 } |
| 595 |
| 596 |
414 #undef __ | 597 #undef __ |
415 | 598 |
416 } } // namespace v8::internal | 599 } } // namespace v8::internal |
417 | 600 |
418 #endif // V8_TARGET_ARCH_MIPS | 601 #endif // V8_TARGET_ARCH_MIPS |
OLD | NEW |