OLD | NEW |
---|---|
1 // Copyright 2009 the V8 project authors. All rights reserved. | 1 // Copyright 2009 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 16 matching lines...) Expand all Loading... | |
27 | 27 |
28 #include "v8.h" | 28 #include "v8.h" |
29 | 29 |
30 #include "macro-assembler.h" | 30 #include "macro-assembler.h" |
31 | 31 |
32 namespace v8 { namespace internal { | 32 namespace v8 { namespace internal { |
33 | 33 |
34 Register no_reg = { -1 }; | 34 Register no_reg = { -1 }; |
35 | 35 |
36 | 36 |
37 } } // namespace v8::internal | 37 // Safe default is no features. |
38 uint64_t CpuFeatures::supported_ = 0; | |
39 uint64_t CpuFeatures::enabled_ = 0; | |
38 | 40 |
39 | 41 void CpuFeatures::Probe() { |
40 // TODO(x64): Implement and move these to their correct cc-files: | 42 // TODO(X64): UNIMPLEMENTED |
41 #include "assembler.h" | |
42 #include "ast.h" | |
43 #include "bootstrapper.h" | |
44 #include "codegen-inl.h" | |
45 #include "cpu.h" | |
46 #include "debug.h" | |
47 #include "disasm.h" | |
48 #include "disassembler.h" | |
49 #include "frames-inl.h" | |
50 #include "x64/macro-assembler-x64.h" | |
51 #include "x64/regexp-macro-assembler-x64.h" | |
52 #include "ic-inl.h" | |
53 #include "log.h" | |
54 #include "macro-assembler.h" | |
55 #include "parser.h" | |
56 #include "regexp-macro-assembler.h" | |
57 #include "regexp-stack.h" | |
58 #include "register-allocator-inl.h" | |
59 #include "register-allocator.h" | |
60 #include "runtime.h" | |
61 #include "scopes.h" | |
62 #include "serialize.h" | |
63 #include "stub-cache.h" | |
64 #include "unicode.h" | |
65 | |
66 namespace v8 { namespace internal { | |
67 | |
68 void ArgumentsAccessStub::GenerateNewObject(MacroAssembler* a) { | |
69 UNIMPLEMENTED(); | |
70 } | |
71 | |
72 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* a) { | |
73 UNIMPLEMENTED(); | |
74 } | |
75 | |
76 void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* a) { | |
77 UNIMPLEMENTED(); | |
78 } | 43 } |
79 | 44 |
80 // ----------------------------------------------------------------------------- | 45 // ----------------------------------------------------------------------------- |
81 // Implementation of Assembler | 46 // Implementation of Assembler |
47 | |
48 // Emit a single byte. Must always be inlined. | |
49 #define EMIT(x) \ | |
50 *pc_++ = (x) | |
Dean McNamee
2009/05/20 13:09:42
really needs to be 2 lines?
| |
51 | |
52 #ifdef GENERATED_CODE_COVERAGE | |
53 static void InitCoverageLog(); | |
54 #endif | |
55 | |
56 // ----------------------------------------------------------------------------- | |
57 // Implementation of Assembler | |
82 | 58 |
83 byte* Assembler::spare_buffer_ = NULL; | 59 byte* Assembler::spare_buffer_ = NULL; |
84 | 60 |
85 Assembler::Assembler(void* buffer, int buffer_size) { | 61 Assembler::Assembler(void* buffer, int buffer_size) { |
86 if (buffer == NULL) { | 62 if (buffer == NULL) { |
87 // do our own buffer management | 63 // do our own buffer management |
88 if (buffer_size <= kMinimalBufferSize) { | 64 if (buffer_size <= kMinimalBufferSize) { |
89 buffer_size = kMinimalBufferSize; | 65 buffer_size = kMinimalBufferSize; |
90 | 66 |
91 if (spare_buffer_ != NULL) { | 67 if (spare_buffer_ != NULL) { |
(...skipping 68 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
160 } | 136 } |
161 | 137 |
162 | 138 |
163 void Assembler::Align(int m) { | 139 void Assembler::Align(int m) { |
164 ASSERT(IsPowerOf2(m)); | 140 ASSERT(IsPowerOf2(m)); |
165 while ((pc_offset() & (m - 1)) != 0) { | 141 while ((pc_offset() & (m - 1)) != 0) { |
166 nop(); | 142 nop(); |
167 } | 143 } |
168 } | 144 } |
169 | 145 |
170 | |
171 void Assembler::RecordComment(char const* a) { | 146 void Assembler::RecordComment(char const* a) { |
172 UNIMPLEMENTED(); | 147 UNIMPLEMENTED(); |
173 } | 148 } |
174 | 149 |
175 void Assembler::RecordPosition(int a) { | 150 void Assembler::RecordPosition(int a) { |
176 UNIMPLEMENTED(); | 151 UNIMPLEMENTED(); |
177 } | 152 } |
178 | 153 |
179 void Assembler::RecordStatementPosition(int a) { | 154 void Assembler::RecordStatementPosition(int a) { |
180 UNIMPLEMENTED(); | 155 UNIMPLEMENTED(); |
181 } | 156 } |
182 | 157 |
183 void Assembler::bind(Label* a) { | 158 void Assembler::bind(Label* a) { |
184 UNIMPLEMENTED(); | 159 UNIMPLEMENTED(); |
185 } | 160 } |
186 | 161 |
162 void Assembler::nop() { | |
163 UNIMPLEMENTED(); | |
164 } | |
187 | 165 |
188 void Assembler::nop() { | 166 void Assembler::GrowBuffer() { |
167 ASSERT(overflow()); // should not call this otherwise | |
168 if (!own_buffer_) FATAL("external code buffer is too small"); | |
169 | |
170 // compute new buffer size | |
171 CodeDesc desc; // the new buffer | |
172 if (buffer_size_ < 4*KB) { | |
173 desc.buffer_size = 4*KB; | |
174 } else { | |
175 desc.buffer_size = 2*buffer_size_; | |
176 } | |
177 // Some internal data structures overflow for very large buffers, | |
178 // they must ensure that kMaximalBufferSize is not too large. | |
179 if ((desc.buffer_size > kMaximalBufferSize) || | |
180 (desc.buffer_size > Heap::OldGenerationSize())) { | |
181 V8::FatalProcessOutOfMemory("Assembler::GrowBuffer"); | |
182 } | |
183 | |
184 // setup new buffer | |
185 desc.buffer = NewArray<byte>(desc.buffer_size); | |
186 desc.instr_size = pc_offset(); | |
187 desc.reloc_size = (buffer_ + buffer_size_) - (reloc_info_writer.pos()); | |
188 | |
189 // Clear the buffer in debug mode. Use 'int3' instructions to make | |
190 // sure to get into problems if we ever run uninitialized code. | |
191 #ifdef DEBUG | |
192 memset(desc.buffer, 0xCC, desc.buffer_size); | |
193 #endif | |
194 | |
195 // copy the data | |
196 int pc_delta = desc.buffer - buffer_; | |
197 int rc_delta = (desc.buffer + desc.buffer_size) - (buffer_ + buffer_size_); | |
198 memmove(desc.buffer, buffer_, desc.instr_size); | |
199 memmove(rc_delta + reloc_info_writer.pos(), | |
200 reloc_info_writer.pos(), desc.reloc_size); | |
201 | |
202 // switch buffers | |
203 if (spare_buffer_ == NULL && buffer_size_ == kMinimalBufferSize) { | |
204 spare_buffer_ = buffer_; | |
205 } else { | |
206 DeleteArray(buffer_); | |
207 } | |
208 buffer_ = desc.buffer; | |
209 buffer_size_ = desc.buffer_size; | |
210 pc_ += pc_delta; | |
211 if (last_pc_ != NULL) { | |
212 last_pc_ += pc_delta; | |
213 } | |
214 reloc_info_writer.Reposition(reloc_info_writer.pos() + rc_delta, | |
215 reloc_info_writer.last_pc() + pc_delta); | |
216 | |
217 // relocate runtime entries | |
218 for (RelocIterator it(desc); !it.done(); it.next()) { | |
219 RelocInfo::Mode rmode = it.rinfo()->rmode(); | |
220 if (rmode == RelocInfo::RUNTIME_ENTRY) { | |
221 int32_t* p = reinterpret_cast<int32_t*>(it.rinfo()->pc()); | |
William Hesse
2009/05/20 13:13:48
pc() is a byte*. If you want to manipulate it as
Lasse Reichstein
2009/05/20 14:25:42
Actually, it's not the pointer that is treated as
| |
222 *p -= pc_delta; // relocate entry | |
223 } else if (rmode == RelocInfo::INTERNAL_REFERENCE) { | |
224 int32_t* p = reinterpret_cast<int32_t*>(it.rinfo()->pc()); | |
225 if (*p != 0) { // 0 means uninitialized. | |
226 *p += pc_delta; | |
227 } | |
228 } | |
229 } | |
230 | |
231 ASSERT(!overflow()); | |
232 } | |
233 | |
234 | |
235 void Assembler::int3() { | |
236 EnsureSpace ensure_space(this); | |
237 last_pc_ = pc_; | |
238 EMIT(0xCC); | |
239 } | |
240 | |
241 } } // namespace v8::internal | |
242 | |
243 | |
244 // TODO(x64): Implement and move these to their correct cc-files: | |
245 #include "ast.h" | |
246 #include "bootstrapper.h" | |
247 #include "codegen-inl.h" | |
248 #include "cpu.h" | |
249 #include "debug.h" | |
250 #include "disasm.h" | |
251 #include "disassembler.h" | |
252 #include "frames-inl.h" | |
253 #include "x64/macro-assembler-x64.h" | |
254 #include "x64/regexp-macro-assembler-x64.h" | |
255 #include "ic-inl.h" | |
256 #include "log.h" | |
257 #include "macro-assembler.h" | |
258 #include "parser.h" | |
259 #include "regexp-macro-assembler.h" | |
260 #include "regexp-stack.h" | |
261 #include "register-allocator-inl.h" | |
262 #include "register-allocator.h" | |
263 #include "runtime.h" | |
264 #include "scopes.h" | |
265 #include "serialize.h" | |
266 #include "stub-cache.h" | |
267 #include "unicode.h" | |
268 | |
269 namespace v8 { namespace internal { | |
270 | |
271 void ArgumentsAccessStub::GenerateNewObject(MacroAssembler* a) { | |
272 UNIMPLEMENTED(); | |
273 } | |
274 | |
275 void ArgumentsAccessStub::GenerateReadElement(MacroAssembler* a) { | |
276 UNIMPLEMENTED(); | |
277 } | |
278 | |
279 void ArgumentsAccessStub::GenerateReadLength(MacroAssembler* a) { | |
189 UNIMPLEMENTED(); | 280 UNIMPLEMENTED(); |
190 } | 281 } |
191 | 282 |
192 | 283 |
193 void BreakLocationIterator::ClearDebugBreakAtReturn() { | 284 void BreakLocationIterator::ClearDebugBreakAtReturn() { |
194 UNIMPLEMENTED(); | 285 UNIMPLEMENTED(); |
195 } | 286 } |
196 | 287 |
197 bool BreakLocationIterator::IsDebugBreakAtReturn() { | 288 bool BreakLocationIterator::IsDebugBreakAtReturn() { |
198 UNIMPLEMENTED(); | 289 UNIMPLEMENTED(); |
199 return false; | 290 return false; |
200 } | 291 } |
201 | 292 |
202 void BreakLocationIterator::SetDebugBreakAtReturn() { | 293 void BreakLocationIterator::SetDebugBreakAtReturn() { |
203 UNIMPLEMENTED(); | 294 UNIMPLEMENTED(); |
204 } | 295 } |
205 | 296 |
206 void CEntryStub::GenerateBody(MacroAssembler* a, bool b) { | |
207 UNIMPLEMENTED(); | |
208 } | |
209 | |
210 void CallIC::Generate(MacroAssembler* a, int b, ExternalReference const& c) { | 297 void CallIC::Generate(MacroAssembler* a, int b, ExternalReference const& c) { |
211 UNIMPLEMENTED(); | 298 UNIMPLEMENTED(); |
212 } | 299 } |
213 | 300 |
214 void CallIC::GenerateMegamorphic(MacroAssembler* a, int b) { | 301 void CallIC::GenerateMegamorphic(MacroAssembler* a, int b) { |
215 UNIMPLEMENTED(); | 302 UNIMPLEMENTED(); |
216 } | 303 } |
217 | 304 |
218 void CallIC::GenerateNormal(MacroAssembler* a, int b) { | 305 void CallIC::GenerateNormal(MacroAssembler* a, int b) { |
219 UNIMPLEMENTED(); | 306 UNIMPLEMENTED(); |
(...skipping 15 matching lines...) Expand all Loading... | |
235 return NULL; | 322 return NULL; |
236 } | 323 } |
237 | 324 |
238 Object* CallStubCompiler::CompileCallInterceptor(Object* a, | 325 Object* CallStubCompiler::CompileCallInterceptor(Object* a, |
239 JSObject* b, | 326 JSObject* b, |
240 String* c) { | 327 String* c) { |
241 UNIMPLEMENTED(); | 328 UNIMPLEMENTED(); |
242 return NULL; | 329 return NULL; |
243 } | 330 } |
244 | 331 |
245 CodeGenerator::CodeGenerator(int buffer_size, | |
246 Handle<Script> script, | |
247 bool is_eval) | |
248 : is_eval_(is_eval), | |
249 script_(script), | |
250 deferred_(8), | |
251 masm_(new MacroAssembler(NULL, buffer_size)), | |
252 scope_(NULL), | |
253 frame_(NULL), | |
254 allocator_(NULL), | |
255 state_(NULL), | |
256 loop_nesting_(0), | |
257 function_return_is_shadowed_(false), | |
258 in_spilled_code_(false) { | |
259 UNIMPLEMENTED(); | |
260 } | |
261 | |
262 void CodeGenerator::DeclareGlobals(Handle<FixedArray> a) { | |
263 UNIMPLEMENTED(); | |
264 } | |
265 | |
266 void CodeGenerator::GenCode(FunctionLiteral* a) { | |
267 UNIMPLEMENTED(); | |
268 } | |
269 | |
270 void CodeGenerator::GenerateFastCaseSwitchJumpTable(SwitchStatement* a, | |
271 int b, | |
272 int c, | |
273 Label* d, | |
274 Vector<Label*> e, | |
275 Vector<Label> f) { | |
276 UNIMPLEMENTED(); | |
277 } | |
278 | |
279 void CodeGenerator::VisitStatements(ZoneList<Statement*>* a) { | |
280 UNIMPLEMENTED(); | |
281 } | |
282 | |
283 void CodeGenerator::VisitBlock(Block* a) { | |
284 UNIMPLEMENTED(); | |
285 } | |
286 | |
287 void CodeGenerator::VisitDeclaration(Declaration* a) { | |
288 UNIMPLEMENTED(); | |
289 } | |
290 | |
291 void CodeGenerator::VisitExpressionStatement(ExpressionStatement* a) { | |
292 UNIMPLEMENTED(); | |
293 } | |
294 | |
295 void CodeGenerator::VisitEmptyStatement(EmptyStatement* a) { | |
296 UNIMPLEMENTED(); | |
297 } | |
298 | |
299 void CodeGenerator::VisitIfStatement(IfStatement* a) { | |
300 UNIMPLEMENTED(); | |
301 } | |
302 | |
303 void CodeGenerator::VisitContinueStatement(ContinueStatement* a) { | |
304 UNIMPLEMENTED(); | |
305 } | |
306 | |
307 void CodeGenerator::VisitBreakStatement(BreakStatement* a) { | |
308 UNIMPLEMENTED(); | |
309 } | |
310 | |
311 void CodeGenerator::VisitReturnStatement(ReturnStatement* a) { | |
312 UNIMPLEMENTED(); | |
313 } | |
314 | |
315 void CodeGenerator::VisitWithEnterStatement(WithEnterStatement* a) { | |
316 UNIMPLEMENTED(); | |
317 } | |
318 | |
319 void CodeGenerator::VisitWithExitStatement(WithExitStatement* a) { | |
320 UNIMPLEMENTED(); | |
321 } | |
322 | |
323 void CodeGenerator::VisitSwitchStatement(SwitchStatement* a) { | |
324 UNIMPLEMENTED(); | |
325 } | |
326 | |
327 void CodeGenerator::VisitLoopStatement(LoopStatement* a) { | |
328 UNIMPLEMENTED(); | |
329 } | |
330 | |
331 void CodeGenerator::VisitForInStatement(ForInStatement* a) { | |
332 UNIMPLEMENTED(); | |
333 } | |
334 | |
335 void CodeGenerator::VisitTryCatch(TryCatch* a) { | |
336 UNIMPLEMENTED(); | |
337 } | |
338 | |
339 void CodeGenerator::VisitTryFinally(TryFinally* a) { | |
340 UNIMPLEMENTED(); | |
341 } | |
342 | |
343 void CodeGenerator::VisitDebuggerStatement(DebuggerStatement* a) { | |
344 UNIMPLEMENTED(); | |
345 } | |
346 | |
347 void CodeGenerator::VisitFunctionLiteral(FunctionLiteral* a) { | |
348 UNIMPLEMENTED(); | |
349 } | |
350 | |
351 void CodeGenerator::VisitFunctionBoilerplateLiteral( | |
352 FunctionBoilerplateLiteral* a) { | |
353 UNIMPLEMENTED(); | |
354 } | |
355 | |
356 void CodeGenerator::VisitConditional(Conditional* a) { | |
357 UNIMPLEMENTED(); | |
358 } | |
359 | |
360 void CodeGenerator::VisitSlot(Slot* a) { | |
361 UNIMPLEMENTED(); | |
362 } | |
363 | |
364 void CodeGenerator::VisitVariableProxy(VariableProxy* a) { | |
365 UNIMPLEMENTED(); | |
366 } | |
367 | |
368 void CodeGenerator::VisitLiteral(Literal* a) { | |
369 UNIMPLEMENTED(); | |
370 } | |
371 | |
372 void CodeGenerator::VisitRegExpLiteral(RegExpLiteral* a) { | |
373 UNIMPLEMENTED(); | |
374 } | |
375 | |
376 void CodeGenerator::VisitObjectLiteral(ObjectLiteral* a) { | |
377 UNIMPLEMENTED(); | |
378 } | |
379 | |
380 void CodeGenerator::VisitArrayLiteral(ArrayLiteral* a) { | |
381 UNIMPLEMENTED(); | |
382 } | |
383 | |
384 void CodeGenerator::VisitCatchExtensionObject(CatchExtensionObject* a) { | |
385 UNIMPLEMENTED(); | |
386 } | |
387 | |
388 void CodeGenerator::VisitAssignment(Assignment* a) { | |
389 UNIMPLEMENTED(); | |
390 } | |
391 | |
392 void CodeGenerator::VisitThrow(Throw* a) { | |
393 UNIMPLEMENTED(); | |
394 } | |
395 | |
396 void CodeGenerator::VisitProperty(Property* a) { | |
397 UNIMPLEMENTED(); | |
398 } | |
399 | |
400 void CodeGenerator::VisitCall(Call* a) { | |
401 UNIMPLEMENTED(); | |
402 } | |
403 | |
404 void CodeGenerator::VisitCallEval(CallEval* a) { | |
405 UNIMPLEMENTED(); | |
406 } | |
407 | |
408 void CodeGenerator::VisitCallNew(CallNew* a) { | |
409 UNIMPLEMENTED(); | |
410 } | |
411 | |
412 void CodeGenerator::VisitCallRuntime(CallRuntime* a) { | |
413 UNIMPLEMENTED(); | |
414 } | |
415 | |
416 void CodeGenerator::VisitUnaryOperation(UnaryOperation* a) { | |
417 UNIMPLEMENTED(); | |
418 } | |
419 | |
420 void CodeGenerator::VisitCountOperation(CountOperation* a) { | |
421 UNIMPLEMENTED(); | |
422 } | |
423 | |
424 void CodeGenerator::VisitBinaryOperation(BinaryOperation* a) { | |
425 UNIMPLEMENTED(); | |
426 } | |
427 | |
428 void CodeGenerator::VisitCompareOperation(CompareOperation* a) { | |
429 UNIMPLEMENTED(); | |
430 } | |
431 | |
432 void CodeGenerator::VisitThisFunction(ThisFunction* a) { | |
433 UNIMPLEMENTED(); | |
434 } | |
435 | |
436 void CpuFeatures::Probe() { | |
437 UNIMPLEMENTED(); | |
438 } | |
439 | |
440 | |
441 bool Debug::IsDebugBreakAtReturn(v8::internal::RelocInfo*) { | |
442 UNIMPLEMENTED(); | |
443 return false; | |
444 } | |
445 | |
446 void Debug::GenerateCallICDebugBreak(MacroAssembler* a) { | |
447 UNIMPLEMENTED(); | |
448 } | |
449 | |
450 void Debug::GenerateConstructCallDebugBreak(MacroAssembler* a) { | |
451 UNIMPLEMENTED(); | |
452 } | |
453 | |
454 void Debug::GenerateKeyedLoadICDebugBreak(MacroAssembler* a) { | |
455 UNIMPLEMENTED(); | |
456 } | |
457 | |
458 void Debug::GenerateKeyedStoreICDebugBreak(MacroAssembler* a) { | |
459 UNIMPLEMENTED(); | |
460 } | |
461 | |
462 void Debug::GenerateLoadICDebugBreak(MacroAssembler* a) { | |
463 UNIMPLEMENTED(); | |
464 } | |
465 | |
466 void Debug::GenerateReturnDebugBreak(MacroAssembler* a) { | |
467 UNIMPLEMENTED(); | |
468 } | |
469 | |
470 void Debug::GenerateReturnDebugBreakEntry(MacroAssembler* a) { | |
471 UNIMPLEMENTED(); | |
472 } | |
473 | |
474 void Debug::GenerateStoreICDebugBreak(MacroAssembler* a) { | |
475 UNIMPLEMENTED(); | |
476 } | |
477 | |
478 void Debug::GenerateStubNoRegistersDebugBreak(MacroAssembler* a) { | |
479 UNIMPLEMENTED(); | |
480 } | |
481 | 332 |
482 StackFrame::Type ExitFrame::GetStateForFramePointer(unsigned char* a, | 333 StackFrame::Type ExitFrame::GetStateForFramePointer(unsigned char* a, |
483 StackFrame::State* b) { | 334 StackFrame::State* b) { |
484 UNIMPLEMENTED(); | 335 // TODO(X64): UNIMPLEMENTED |
485 return NONE; | 336 return NONE; |
486 } | 337 } |
487 | 338 |
488 void JSEntryStub::GenerateBody(MacroAssembler* a, bool b) { | |
489 UNIMPLEMENTED(); | |
490 } | |
491 | |
492 int JavaScriptFrame::GetProvidedParametersCount() const { | 339 int JavaScriptFrame::GetProvidedParametersCount() const { |
493 UNIMPLEMENTED(); | 340 UNIMPLEMENTED(); |
494 return 0; | 341 return 0; |
495 } | 342 } |
496 | 343 |
497 void JumpTarget::DoBind(int a) { | 344 void JumpTarget::DoBind(int a) { |
498 UNIMPLEMENTED(); | 345 UNIMPLEMENTED(); |
499 } | 346 } |
500 | 347 |
501 void JumpTarget::DoBranch(Condition a, Hint b) { | 348 void JumpTarget::DoBranch(Condition a, Hint b) { |
502 UNIMPLEMENTED(); | 349 UNIMPLEMENTED(); |
503 } | 350 } |
504 | 351 |
505 void JumpTarget::DoJump() { | 352 void JumpTarget::DoJump() { |
506 UNIMPLEMENTED(); | 353 UNIMPLEMENTED(); |
507 } | 354 } |
508 | 355 |
509 void KeyedLoadIC::ClearInlinedVersion(unsigned char* a) { | |
510 UNIMPLEMENTED(); | |
511 } | |
512 | |
513 void KeyedLoadIC::Generate(MacroAssembler* a, ExternalReference const& b) { | |
514 UNIMPLEMENTED(); | |
515 } | |
516 | |
517 void KeyedLoadIC::GenerateGeneric(MacroAssembler* a) { | |
518 UNIMPLEMENTED(); | |
519 } | |
520 | |
521 void KeyedLoadIC::GenerateMiss(MacroAssembler* a) { | |
522 UNIMPLEMENTED(); | |
523 } | |
524 | |
525 bool KeyedLoadIC::PatchInlinedLoad(unsigned char* a, Object* b) { | |
526 UNIMPLEMENTED(); | |
527 return false; | |
528 } | |
529 | |
530 Object* KeyedLoadStubCompiler::CompileLoadArrayLength(String* a) { | |
531 UNIMPLEMENTED(); | |
532 return NULL; | |
533 } | |
534 | |
535 Object* KeyedLoadStubCompiler::CompileLoadCallback(String* a, | |
536 JSObject* b, | |
537 JSObject* c, | |
538 AccessorInfo* d) { | |
539 UNIMPLEMENTED(); | |
540 return NULL; | |
541 } | |
542 | |
543 Object* KeyedLoadStubCompiler::CompileLoadConstant(String* a, | |
544 JSObject* b, | |
545 JSObject* c, | |
546 Object* d) { | |
547 UNIMPLEMENTED(); | |
548 return NULL; | |
549 } | |
550 | |
551 Object* KeyedLoadStubCompiler::CompileLoadField(String* a, | |
552 JSObject* b, | |
553 JSObject* c, | |
554 int d) { | |
555 UNIMPLEMENTED(); | |
556 return NULL; | |
557 } | |
558 | |
559 Object* KeyedLoadStubCompiler::CompileLoadFunctionPrototype(String* a) { | |
560 UNIMPLEMENTED(); | |
561 return NULL; | |
562 } | |
563 | |
564 Object* KeyedLoadStubCompiler::CompileLoadInterceptor(JSObject* a, | |
565 JSObject* b, | |
566 String* c) { | |
567 UNIMPLEMENTED(); | |
568 return NULL; | |
569 } | |
570 | |
571 Object* KeyedLoadStubCompiler::CompileLoadStringLength(String* a) { | |
572 UNIMPLEMENTED(); | |
573 return NULL; | |
574 } | |
575 | |
576 void KeyedStoreIC::Generate(MacroAssembler* a, ExternalReference const& b) { | |
577 UNIMPLEMENTED(); | |
578 } | |
579 | |
580 void KeyedStoreIC::GenerateExtendStorage(MacroAssembler* a) { | |
581 UNIMPLEMENTED(); | |
582 } | |
583 | |
584 void KeyedStoreIC::GenerateGeneric(MacroAssembler*a) { | |
585 UNIMPLEMENTED(); | |
586 } | |
587 | |
588 Object* KeyedStoreStubCompiler::CompileStoreField(JSObject* a, | |
589 int b, | |
590 Map* c, | |
591 String* d) { | |
592 UNIMPLEMENTED(); | |
593 return NULL; | |
594 } | |
595 | |
596 void LoadIC::ClearInlinedVersion(unsigned char* a) { | |
597 UNIMPLEMENTED(); | |
598 } | |
599 | |
600 void LoadIC::Generate(MacroAssembler* a, ExternalReference const& b) { | |
601 UNIMPLEMENTED(); | |
602 } | |
603 | |
604 void LoadIC::GenerateArrayLength(MacroAssembler* a) { | |
605 UNIMPLEMENTED(); | |
606 } | |
607 | |
608 void LoadIC::GenerateFunctionPrototype(MacroAssembler* a) { | |
609 UNIMPLEMENTED(); | |
610 } | |
611 | |
612 void LoadIC::GenerateMegamorphic(MacroAssembler* a) { | |
613 UNIMPLEMENTED(); | |
614 } | |
615 | |
616 void LoadIC::GenerateMiss(MacroAssembler* a) { | |
617 UNIMPLEMENTED(); | |
618 } | |
619 | |
620 void LoadIC::GenerateNormal(MacroAssembler* a) { | |
621 UNIMPLEMENTED(); | |
622 } | |
623 | |
624 void LoadIC::GenerateStringLength(MacroAssembler* a) { | |
625 UNIMPLEMENTED(); | |
626 } | |
627 | |
628 bool LoadIC::PatchInlinedLoad(unsigned char* a, Object* b, int c) { | |
629 UNIMPLEMENTED(); | |
630 return false; | |
631 } | |
632 | 356 |
633 Object* LoadStubCompiler::CompileLoadCallback(JSObject* a, | 357 Object* LoadStubCompiler::CompileLoadCallback(JSObject* a, |
634 JSObject* b, | 358 JSObject* b, |
635 AccessorInfo* c, | 359 AccessorInfo* c, |
636 String* d) { | 360 String* d) { |
637 UNIMPLEMENTED(); | 361 UNIMPLEMENTED(); |
638 return NULL; | 362 return NULL; |
639 } | 363 } |
640 | 364 |
641 Object* LoadStubCompiler::CompileLoadConstant(JSObject* a, | 365 Object* LoadStubCompiler::CompileLoadConstant(JSObject* a, |
(...skipping 12 matching lines...) Expand all Loading... | |
654 return NULL; | 378 return NULL; |
655 } | 379 } |
656 | 380 |
657 Object* LoadStubCompiler::CompileLoadInterceptor(JSObject* a, | 381 Object* LoadStubCompiler::CompileLoadInterceptor(JSObject* a, |
658 JSObject* b, | 382 JSObject* b, |
659 String* c) { | 383 String* c) { |
660 UNIMPLEMENTED(); | 384 UNIMPLEMENTED(); |
661 return NULL; | 385 return NULL; |
662 } | 386 } |
663 | 387 |
664 MacroAssembler::MacroAssembler(void* buffer, int size) | |
665 : Assembler(buffer, size), | |
666 unresolved_(0), | |
667 generating_stub_(false), | |
668 allow_stub_calls_(true), | |
669 code_object_(Heap::undefined_value()) { | |
670 UNIMPLEMENTED(); | |
671 } | |
672 | |
673 void MacroAssembler::TailCallRuntime(ExternalReference const& a, int b) { | |
674 UNIMPLEMENTED(); | |
675 } | |
676 | |
677 bool RegisterAllocator::IsReserved(int a) { | 388 bool RegisterAllocator::IsReserved(int a) { |
678 UNIMPLEMENTED(); | 389 UNIMPLEMENTED(); |
679 return false; | 390 return false; |
680 } | 391 } |
681 | 392 |
682 RegisterFile RegisterAllocator::Reserved() { | 393 RegisterFile RegisterAllocator::Reserved() { |
683 UNIMPLEMENTED(); | 394 UNIMPLEMENTED(); |
684 return RegisterFile(); | 395 return RegisterFile(); |
685 } | 396 } |
686 | 397 |
687 const int RelocInfo::kApplyMask = -1; | 398 const int RelocInfo::kApplyMask = -1; |
688 | 399 |
689 StackFrame::Type StackFrame::ComputeType(StackFrame::State* a) { | 400 StackFrame::Type StackFrame::ComputeType(StackFrame::State* a) { |
690 UNIMPLEMENTED(); | 401 UNIMPLEMENTED(); |
691 return NONE; | 402 return NONE; |
692 } | 403 } |
693 | 404 |
694 void StoreIC::Generate(MacroAssembler* a, ExternalReference const& b) { | |
695 UNIMPLEMENTED(); | |
696 } | |
697 | |
698 void StoreIC::GenerateExtendStorage(MacroAssembler* a) { | |
699 UNIMPLEMENTED(); | |
700 } | |
701 | |
702 void StoreIC::GenerateMegamorphic(MacroAssembler* a) { | |
703 UNIMPLEMENTED(); | |
704 } | |
705 | |
706 Object* StoreStubCompiler::CompileStoreCallback(JSObject* a, | 405 Object* StoreStubCompiler::CompileStoreCallback(JSObject* a, |
707 AccessorInfo* b, | 406 AccessorInfo* b, |
708 String* c) { | 407 String* c) { |
709 UNIMPLEMENTED(); | 408 UNIMPLEMENTED(); |
710 return NULL; | 409 return NULL; |
711 } | 410 } |
712 | 411 |
713 Object* StoreStubCompiler::CompileStoreField(JSObject* a, | 412 Object* StoreStubCompiler::CompileStoreField(JSObject* a, |
714 int b, | 413 int b, |
715 Map* c, | 414 Map* c, |
(...skipping 49 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
765 | 464 |
766 VirtualFrame::VirtualFrame() : elements_(0) { | 465 VirtualFrame::VirtualFrame() : elements_(0) { |
767 UNIMPLEMENTED(); | 466 UNIMPLEMENTED(); |
768 } | 467 } |
769 | 468 |
770 byte* ArgumentsAdaptorFrame::GetCallerStackPointer() const { | 469 byte* ArgumentsAdaptorFrame::GetCallerStackPointer() const { |
771 UNIMPLEMENTED(); | 470 UNIMPLEMENTED(); |
772 return NULL; | 471 return NULL; |
773 } | 472 } |
774 | 473 |
775 void Builtins::Generate_Adaptor(MacroAssembler* a, Builtins::CFunctionId b) { | |
776 UNIMPLEMENTED(); | |
777 } | |
778 | |
779 void Builtins::Generate_ArgumentsAdaptorTrampoline(MacroAssembler* a) { | |
780 UNIMPLEMENTED(); | |
781 } | |
782 | |
783 void Builtins::Generate_FunctionApply(MacroAssembler* a) { | |
784 UNIMPLEMENTED(); | |
785 } | |
786 | |
787 void Builtins::Generate_FunctionCall(MacroAssembler* a) { | |
788 UNIMPLEMENTED(); | |
789 } | |
790 | |
791 void Builtins::Generate_JSConstructCall(MacroAssembler* a) { | |
792 UNIMPLEMENTED(); | |
793 } | |
794 | |
795 void Builtins::Generate_JSConstructEntryTrampoline(MacroAssembler* a) { | |
796 UNIMPLEMENTED(); | |
797 } | |
798 | |
799 void Builtins::Generate_JSEntryTrampoline(MacroAssembler* a) { | |
800 UNIMPLEMENTED(); | |
801 } | |
802 | |
803 void CodeGenerator::GenerateArgumentsAccess(ZoneList<Expression*>* a) { | 474 void CodeGenerator::GenerateArgumentsAccess(ZoneList<Expression*>* a) { |
804 UNIMPLEMENTED(); | 475 UNIMPLEMENTED(); |
805 } | 476 } |
806 | 477 |
807 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* a) { | 478 void CodeGenerator::GenerateArgumentsLength(ZoneList<Expression*>* a) { |
808 UNIMPLEMENTED(); | 479 UNIMPLEMENTED(); |
809 } | 480 } |
810 | 481 |
811 void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* a) { | 482 void CodeGenerator::GenerateFastCharCodeAt(ZoneList<Expression*>* a) { |
812 UNIMPLEMENTED(); | 483 UNIMPLEMENTED(); |
(...skipping 35 matching lines...) Expand 10 before | Expand all | Expand 10 after Loading... | |
848 UNIMPLEMENTED(); | 519 UNIMPLEMENTED(); |
849 return NULL; | 520 return NULL; |
850 } | 521 } |
851 | 522 |
852 byte* JavaScriptFrame::GetCallerStackPointer() const { | 523 byte* JavaScriptFrame::GetCallerStackPointer() const { |
853 UNIMPLEMENTED(); | 524 UNIMPLEMENTED(); |
854 return NULL; | 525 return NULL; |
855 } | 526 } |
856 | 527 |
857 } } // namespace v8::internal | 528 } } // namespace v8::internal |
OLD | NEW |