OLD | NEW |
---|---|
1 // Copyright 2011 the V8 project authors. All rights reserved. | 1 // Copyright 2011 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 17 matching lines...) Expand all Loading... | |
28 #include "x64/lithium-codegen-x64.h" | 28 #include "x64/lithium-codegen-x64.h" |
29 #include "code-stubs.h" | 29 #include "code-stubs.h" |
30 #include "stub-cache.h" | 30 #include "stub-cache.h" |
31 | 31 |
32 namespace v8 { | 32 namespace v8 { |
33 namespace internal { | 33 namespace internal { |
34 | 34 |
35 | 35 |
36 #define __ masm()-> | 36 #define __ masm()-> |
37 | 37 |
38 bool LCodeGen::GenerateCode() { | |
39 HPhase phase("Code generation", chunk()); | |
40 ASSERT(is_unused()); | |
41 status_ = GENERATING; | |
42 return GeneratePrologue() && | |
43 GenerateBody() && | |
44 GenerateDeferredCode() && | |
45 GenerateSafepointTable(); | |
46 } | |
47 | |
48 | |
49 void LCodeGen::FinishCode(Handle<Code> code) { | |
50 ASSERT(is_done()); | |
51 code->set_stack_slots(StackSlotCount()); | |
52 code->set_safepoint_table_start(safepoints_.GetCodeOffset()); | |
53 PopulateDeoptimizationData(code); | |
54 } | |
55 | |
56 | |
57 void LCodeGen::Abort(const char* format, ...) { | |
58 if (FLAG_trace_bailout) { | |
59 SmartPointer<char> debug_name = graph()->debug_name()->ToCString(); | |
60 PrintF("Aborting LCodeGen in @\"%s\": ", *debug_name); | |
61 va_list arguments; | |
62 va_start(arguments, format); | |
63 OS::VPrint(format, arguments); | |
64 va_end(arguments); | |
65 PrintF("\n"); | |
66 } | |
67 status_ = ABORTED; | |
68 } | |
69 | |
70 | |
71 void LCodeGen::Comment(const char* format, ...) { | |
72 Abort("Unimplemented: %s", "Comment"); | |
73 } | |
74 | |
75 | |
76 bool LCodeGen::GeneratePrologue() { | |
77 Abort("Unimplemented: %s", "GeneratePrologue"); | |
78 return !is_aborted(); | |
79 } | |
80 | |
81 | |
82 bool LCodeGen::GenerateBody() { | |
83 ASSERT(is_generating()); | |
84 bool emit_instructions = true; | |
85 for (current_instruction_ = 0; | |
86 !is_aborted() && current_instruction_ < instructions_->length(); | |
87 current_instruction_++) { | |
88 LInstruction* instr = instructions_->at(current_instruction_); | |
89 if (instr->IsLabel()) { | |
90 LLabel* label = LLabel::cast(instr); | |
91 emit_instructions = !label->HasReplacement(); | |
92 } | |
93 | |
94 if (emit_instructions) { | |
95 Comment(";;; @%d: %s.", current_instruction_, instr->Mnemonic()); | |
96 instr->CompileToNative(this); | |
97 } | |
98 } | |
99 return !is_aborted(); | |
100 } | |
101 | |
102 | |
103 LInstruction* LCodeGen::GetNextInstruction() { | |
104 if (current_instruction_ < instructions_->length() - 1) { | |
105 return instructions_->at(current_instruction_ + 1); | |
106 } else { | |
107 return NULL; | |
108 } | |
109 } | |
110 | |
111 | |
112 bool LCodeGen::GenerateDeferredCode() { | |
113 ASSERT(is_generating()); | |
114 for (int i = 0; !is_aborted() && i < deferred_.length(); i++) { | |
115 LDeferredCode* code = deferred_[i]; | |
116 __ bind(code->entry()); | |
117 code->Generate(); | |
118 __ jmp(code->exit()); | |
119 } | |
120 | |
121 // Deferred code is the last part of the instruction sequence. Mark | |
122 // the generated code as done unless we bailed out. | |
123 if (!is_aborted()) status_ = DONE; | |
124 return !is_aborted(); | |
125 } | |
126 | |
127 | |
128 bool LCodeGen::GenerateSafepointTable() { | |
129 Abort("Unimplemented: %s", "GeneratePrologue"); | |
130 return !is_aborted(); | |
131 } | |
132 | |
133 | |
134 Register LCodeGen::ToRegister(int index) const { | |
135 return Register::FromAllocationIndex(index); | |
136 } | |
137 | |
138 | |
139 XMMRegister LCodeGen::ToDoubleRegister(int index) const { | |
140 return XMMRegister::FromAllocationIndex(index); | |
141 } | |
142 | |
143 | |
144 Register LCodeGen::ToRegister(LOperand* op) const { | |
145 ASSERT(op->IsRegister()); | |
146 return ToRegister(op->index()); | |
147 } | |
148 | |
149 | |
150 XMMRegister LCodeGen::ToDoubleRegister(LOperand* op) const { | |
151 ASSERT(op->IsDoubleRegister()); | |
152 return ToDoubleRegister(op->index()); | |
153 } | |
154 | |
155 | |
156 int LCodeGen::ToInteger32(LConstantOperand* op) const { | |
157 Handle<Object> value = chunk_->LookupLiteral(op); | |
158 ASSERT(chunk_->LookupLiteralRepresentation(op).IsInteger32()); | |
159 ASSERT(static_cast<double>(static_cast<int32_t>(value->Number())) == | |
160 value->Number()); | |
161 return static_cast<int32_t>(value->Number()); | |
162 } | |
163 | |
164 | |
165 Operand LCodeGen::ToOperand(LOperand* op) const { | |
166 // Does not handle registers. In X64 assembler, plain registers are not | |
167 // representable as an Operand. | |
168 ASSERT(op->IsStackSlot() || op->IsDoubleStackSlot()); | |
169 int index = op->index(); | |
170 if (index >= 0) { | |
171 // Local or spill slot. Skip the frame pointer, function, and | |
172 // context in the fixed part of the frame. | |
173 return Operand(rbp, -(index + 3) * kPointerSize); | |
174 } else { | |
175 // Incoming parameter. Skip the return address. | |
176 return Operand(rbp, -(index - 1) * kPointerSize); | |
177 } | |
178 } | |
179 | |
38 | 180 |
39 void LCodeGen::WriteTranslation(LEnvironment* environment, | 181 void LCodeGen::WriteTranslation(LEnvironment* environment, |
40 Translation* translation) { | 182 Translation* translation) { |
41 if (environment == NULL) return; | 183 if (environment == NULL) return; |
42 | 184 |
43 // The translation includes one command per value in the environment. | 185 // The translation includes one command per value in the environment. |
44 int translation_size = environment->values()->length(); | 186 int translation_size = environment->values()->length(); |
45 // The output frame height does not include the parameters. | 187 // The output frame height does not include the parameters. |
46 int height = translation_size - environment->parameter_count(); | 188 int height = translation_size - environment->parameter_count(); |
47 | 189 |
(...skipping 20 matching lines...) Expand all Loading... | |
68 environment->spilled_double_registers()[value->index()], | 210 environment->spilled_double_registers()[value->index()], |
69 false); | 211 false); |
70 } | 212 } |
71 } | 213 } |
72 | 214 |
73 AddToTranslation(translation, value, environment->HasTaggedValueAt(i)); | 215 AddToTranslation(translation, value, environment->HasTaggedValueAt(i)); |
74 } | 216 } |
75 } | 217 } |
76 | 218 |
77 | 219 |
220 void LCodeGen::AddToTranslation(Translation* translation, | |
221 LOperand* op, | |
222 bool is_tagged) { | |
223 if (op == NULL) { | |
224 // TODO(twuerthinger): Introduce marker operands to indicate that this value | |
Rico
2011/01/12 20:06:25
Lets file a bug for this if it needs to be fixed-
| |
225 // is not present and must be reconstructed from the deoptimizer. Currently | |
226 // this is only used for the arguments object. | |
227 translation->StoreArgumentsObject(); | |
228 } else if (op->IsStackSlot()) { | |
229 if (is_tagged) { | |
230 translation->StoreStackSlot(op->index()); | |
231 } else { | |
232 translation->StoreInt32StackSlot(op->index()); | |
233 } | |
234 } else if (op->IsDoubleStackSlot()) { | |
235 translation->StoreDoubleStackSlot(op->index()); | |
236 } else if (op->IsArgument()) { | |
237 ASSERT(is_tagged); | |
238 int src_index = StackSlotCount() + op->index(); | |
239 translation->StoreStackSlot(src_index); | |
240 } else if (op->IsRegister()) { | |
241 Register reg = ToRegister(op); | |
242 if (is_tagged) { | |
243 translation->StoreRegister(reg); | |
244 } else { | |
245 translation->StoreInt32Register(reg); | |
246 } | |
247 } else if (op->IsDoubleRegister()) { | |
248 XMMRegister reg = ToDoubleRegister(op); | |
249 translation->StoreDoubleRegister(reg); | |
250 } else if (op->IsConstantOperand()) { | |
251 Handle<Object> literal = chunk()->LookupLiteral(LConstantOperand::cast(op)); | |
252 int src_index = DefineDeoptimizationLiteral(literal); | |
253 translation->StoreLiteral(src_index); | |
254 } else { | |
255 UNREACHABLE(); | |
256 } | |
257 } | |
258 | |
259 | |
260 void LCodeGen::CallCode(Handle<Code> code, | |
261 RelocInfo::Mode mode, | |
262 LInstruction* instr) { | |
263 Abort("Unimplemented: %s", "CallCode"); | |
264 } | |
265 | |
266 | |
267 void LCodeGen::CallRuntime(Runtime::Function* function, | |
268 int num_arguments, | |
269 LInstruction* instr) { | |
270 Abort("Unimplemented: %s", "CallRuntime"); | |
271 } | |
272 | |
273 | |
274 void LCodeGen::RegisterLazyDeoptimization(LInstruction* instr) { | |
275 // Create the environment to bailout to. If the call has side effects | |
276 // execution has to continue after the call otherwise execution can continue | |
277 // from a previous bailout point repeating the call. | |
278 LEnvironment* deoptimization_environment; | |
279 if (instr->HasDeoptimizationEnvironment()) { | |
280 deoptimization_environment = instr->deoptimization_environment(); | |
281 } else { | |
282 deoptimization_environment = instr->environment(); | |
283 } | |
284 | |
285 RegisterEnvironmentForDeoptimization(deoptimization_environment); | |
286 RecordSafepoint(instr->pointer_map(), | |
287 deoptimization_environment->deoptimization_index()); | |
288 } | |
289 | |
290 | |
291 void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment) { | |
292 Abort("Unimplemented: %s", "RegisterEnvironmentForDeoptimization"); | |
293 } | |
294 | |
295 | |
296 void LCodeGen::DeoptimizeIf(Condition cc, LEnvironment* environment) { | |
297 Abort("Unimplemented: %s", "Deoptimiz"); | |
298 } | |
299 | |
300 | |
301 void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) { | |
302 int length = deoptimizations_.length(); | |
303 if (length == 0) return; | |
304 ASSERT(FLAG_deopt); | |
305 Handle<DeoptimizationInputData> data = | |
306 Factory::NewDeoptimizationInputData(length, TENURED); | |
307 | |
308 data->SetTranslationByteArray(*translations_.CreateByteArray()); | |
309 data->SetInlinedFunctionCount(Smi::FromInt(inlined_function_count_)); | |
310 | |
311 Handle<FixedArray> literals = | |
312 Factory::NewFixedArray(deoptimization_literals_.length(), TENURED); | |
313 for (int i = 0; i < deoptimization_literals_.length(); i++) { | |
314 literals->set(i, *deoptimization_literals_[i]); | |
315 } | |
316 data->SetLiteralArray(*literals); | |
317 | |
318 data->SetOsrAstId(Smi::FromInt(info_->osr_ast_id())); | |
319 data->SetOsrPcOffset(Smi::FromInt(osr_pc_offset_)); | |
320 | |
321 // Populate the deoptimization entries. | |
322 for (int i = 0; i < length; i++) { | |
323 LEnvironment* env = deoptimizations_[i]; | |
324 data->SetAstId(i, Smi::FromInt(env->ast_id())); | |
325 data->SetTranslationIndex(i, Smi::FromInt(env->translation_index())); | |
326 data->SetArgumentsStackHeight(i, | |
327 Smi::FromInt(env->arguments_stack_height())); | |
328 } | |
329 code->set_deoptimization_data(*data); | |
330 } | |
331 | |
332 | |
333 int LCodeGen::DefineDeoptimizationLiteral(Handle<Object> literal) { | |
334 int result = deoptimization_literals_.length(); | |
335 for (int i = 0; i < deoptimization_literals_.length(); ++i) { | |
336 if (deoptimization_literals_[i].is_identical_to(literal)) return i; | |
337 } | |
338 deoptimization_literals_.Add(literal); | |
339 return result; | |
340 } | |
341 | |
342 | |
343 void LCodeGen::PopulateDeoptimizationLiteralsWithInlinedFunctions() { | |
344 ASSERT(deoptimization_literals_.length() == 0); | |
345 | |
346 const ZoneList<Handle<JSFunction> >* inlined_closures = | |
347 chunk()->inlined_closures(); | |
348 | |
349 for (int i = 0, length = inlined_closures->length(); | |
350 i < length; | |
351 i++) { | |
352 DefineDeoptimizationLiteral(inlined_closures->at(i)); | |
353 } | |
354 | |
355 inlined_function_count_ = deoptimization_literals_.length(); | |
356 } | |
357 | |
358 | |
359 void LCodeGen::RecordSafepoint(LPointerMap* pointers, | |
360 int deoptimization_index) { | |
361 const ZoneList<LOperand*>* operands = pointers->operands(); | |
362 Safepoint safepoint = safepoints_.DefineSafepoint(masm(), | |
363 deoptimization_index); | |
364 for (int i = 0; i < operands->length(); i++) { | |
365 LOperand* pointer = operands->at(i); | |
366 if (pointer->IsStackSlot()) { | |
367 safepoint.DefinePointerSlot(pointer->index()); | |
368 } | |
369 } | |
370 } | |
371 | |
372 | |
373 void LCodeGen::RecordSafepointWithRegisters(LPointerMap* pointers, | |
374 int arguments, | |
375 int deoptimization_index) { | |
376 const ZoneList<LOperand*>* operands = pointers->operands(); | |
377 Safepoint safepoint = | |
378 safepoints_.DefineSafepointWithRegisters( | |
379 masm(), arguments, deoptimization_index); | |
380 for (int i = 0; i < operands->length(); i++) { | |
381 LOperand* pointer = operands->at(i); | |
382 if (pointer->IsStackSlot()) { | |
383 safepoint.DefinePointerSlot(pointer->index()); | |
384 } else if (pointer->IsRegister()) { | |
385 safepoint.DefinePointerRegister(ToRegister(pointer)); | |
386 } | |
387 } | |
388 // Register rsi always contains a pointer to the context. | |
389 safepoint.DefinePointerRegister(rsi); | |
390 } | |
391 | |
392 | |
393 void LCodeGen::RecordPosition(int position) { | |
394 if (!FLAG_debug_info || position == RelocInfo::kNoPosition) return; | |
395 masm()->positions_recorder()->RecordPosition(position); | |
396 } | |
397 | |
398 | |
399 void LCodeGen::DoLabel(LLabel* label) { | |
400 if (label->is_loop_header()) { | |
401 Comment(";;; B%d - LOOP entry", label->block_id()); | |
402 } else { | |
403 Comment(";;; B%d", label->block_id()); | |
404 } | |
405 __ bind(label->label()); | |
406 current_block_ = label->block_id(); | |
407 LCodeGen::DoGap(label); | |
408 } | |
409 | |
410 | |
411 void LCodeGen::DoParallelMove(LParallelMove* move) { | |
412 Abort("Unimplemented: %s", "DoParallelMove"); | |
413 } | |
414 | |
415 | |
416 void LCodeGen::DoGap(LGap* gap) { | |
417 for (int i = LGap::FIRST_INNER_POSITION; | |
418 i <= LGap::LAST_INNER_POSITION; | |
419 i++) { | |
420 LGap::InnerPosition inner_pos = static_cast<LGap::InnerPosition>(i); | |
421 LParallelMove* move = gap->GetParallelMove(inner_pos); | |
422 if (move != NULL) DoParallelMove(move); | |
423 } | |
424 | |
425 LInstruction* next = GetNextInstruction(); | |
426 if (next != NULL && next->IsLazyBailout()) { | |
427 int pc = masm()->pc_offset(); | |
428 safepoints_.SetPcAfterGap(pc); | |
429 } | |
430 } | |
431 | |
432 | |
433 void LCodeGen::DoParameter(LParameter* instr) { | |
434 // Nothing to do. | |
435 } | |
436 | |
437 | |
438 void LCodeGen::DoCallStub(LCallStub* instr) { | |
439 Abort("Unimplemented: %s", "DoCallStub"); | |
440 } | |
441 | |
442 | |
443 void LCodeGen::DoUnknownOSRValue(LUnknownOSRValue* instr) { | |
444 // Nothing to do. | |
445 } | |
446 | |
447 | |
448 void LCodeGen::DoModI(LModI* instr) { | |
449 Abort("Unimplemented: %s", "DoModI"); | |
450 } | |
451 | |
452 | |
453 void LCodeGen::DoDivI(LDivI* instr) { | |
454 Abort("Unimplemented: %s", "DoDivI");} | |
455 | |
456 | |
457 void LCodeGen::DoMulI(LMulI* instr) { | |
458 Abort("Unimplemented: %s", "DoMultI");} | |
459 | |
460 | |
461 void LCodeGen::DoBitI(LBitI* instr) { | |
462 Abort("Unimplemented: %s", "DoBitI");} | |
463 | |
464 | |
465 void LCodeGen::DoShiftI(LShiftI* instr) { | |
466 Abort("Unimplemented: %s", "DoShiftI"); | |
467 } | |
468 | |
469 | |
470 void LCodeGen::DoSubI(LSubI* instr) { | |
471 Abort("Unimplemented: %s", "DoSubI"); | |
472 } | |
473 | |
474 | |
475 void LCodeGen::DoConstantI(LConstantI* instr) { | |
476 Abort("Unimplemented: %s", "DoConstantI"); | |
477 } | |
478 | |
479 | |
480 void LCodeGen::DoConstantD(LConstantD* instr) { | |
481 Abort("Unimplemented: %s", "DoConstantI"); | |
482 } | |
483 | |
484 | |
485 void LCodeGen::DoConstantT(LConstantT* instr) { | |
486 Abort("Unimplemented: %s", "DoConstantT"); | |
487 } | |
488 | |
489 | |
490 void LCodeGen::DoJSArrayLength(LJSArrayLength* instr) { | |
491 Abort("Unimplemented: %s", "DoJSArrayLength"); | |
492 } | |
493 | |
494 | |
495 void LCodeGen::DoFixedArrayLength(LFixedArrayLength* instr) { | |
496 Abort("Unimplemented: %s", "DoFixedArrayLength"); | |
497 } | |
498 | |
499 | |
500 void LCodeGen::DoValueOf(LValueOf* instr) { | |
501 Abort("Unimplemented: %s", "DoValueOf"); | |
502 } | |
503 | |
504 | |
505 void LCodeGen::DoBitNotI(LBitNotI* instr) { | |
506 Abort("Unimplemented: %s", "DoBitNotI"); | |
507 } | |
508 | |
509 | |
510 void LCodeGen::DoThrow(LThrow* instr) { | |
511 Abort("Unimplemented: %s", "DoThrow"); | |
512 } | |
513 | |
514 | |
515 void LCodeGen::DoAddI(LAddI* instr) { | |
516 Abort("Unimplemented: %s", "DoAddI"); | |
517 } | |
518 | |
519 | |
520 void LCodeGen::DoArithmeticD(LArithmeticD* instr) { | |
521 Abort("Unimplemented: %s", "DoArithmeticD"); | |
522 } | |
523 | |
524 | |
525 void LCodeGen::DoArithmeticT(LArithmeticT* instr) { | |
526 Abort("Unimplemented: %s", "DoArithmeticT"); | |
527 } | |
528 | |
529 | |
530 int LCodeGen::GetNextEmittedBlock(int block) { | |
531 for (int i = block + 1; i < graph()->blocks()->length(); ++i) { | |
532 LLabel* label = chunk_->GetLabel(i); | |
533 if (!label->HasReplacement()) return i; | |
534 } | |
535 return -1; | |
536 } | |
537 | |
538 | |
539 void LCodeGen::EmitBranch(int left_block, int right_block, Condition cc) { | |
540 Abort("Unimplemented: %s", "EmitBranch"); | |
541 } | |
542 | |
543 | |
544 void LCodeGen::DoBranch(LBranch* instr) { | |
545 Abort("Unimplemented: %s", "DoBranch"); | |
546 } | |
547 | |
548 | |
549 void LCodeGen::EmitGoto(int block, LDeferredCode* deferred_stack_check) { | |
550 Abort("Unimplemented: %s", "EmitGoto"); | |
551 } | |
552 | |
553 | |
554 void LCodeGen::DoDeferredStackCheck(LGoto* instr) { | |
555 Abort("Unimplemented: %s", "DoDeferredStackCheck"); | |
556 } | |
557 | |
Rico
2011/01/12 20:06:25
add line
| |
558 void LCodeGen::DoGoto(LGoto* instr) { | |
559 Abort("Unimplemented: %s", "DoGoto"); | |
560 } | |
561 | |
562 | |
563 Condition LCodeGen::TokenToCondition(Token::Value op, bool is_unsigned) { | |
564 Condition cond = no_condition; | |
565 switch (op) { | |
566 case Token::EQ: | |
567 case Token::EQ_STRICT: | |
568 cond = equal; | |
569 break; | |
570 case Token::LT: | |
571 cond = is_unsigned ? below : less; | |
572 break; | |
573 case Token::GT: | |
574 cond = is_unsigned ? above : greater; | |
575 break; | |
576 case Token::LTE: | |
577 cond = is_unsigned ? below_equal : less_equal; | |
578 break; | |
579 case Token::GTE: | |
580 cond = is_unsigned ? above_equal : greater_equal; | |
581 break; | |
582 case Token::IN: | |
583 case Token::INSTANCEOF: | |
584 default: | |
585 UNREACHABLE(); | |
586 } | |
587 return cond; | |
588 } | |
589 | |
590 | |
591 void LCodeGen::EmitCmpI(LOperand* left, LOperand* right) { | |
592 Abort("Unimplemented: %s", "EmitCmpI"); | |
593 } | |
594 | |
595 | |
596 void LCodeGen::DoCmpID(LCmpID* instr) { | |
597 Abort("Unimplemented: %s", "DoCmpID"); | |
598 } | |
599 | |
600 | |
601 void LCodeGen::DoCmpIDAndBranch(LCmpIDAndBranch* instr) { | |
602 Abort("Unimplemented: %s", "DoCmpIDAndBranch"); | |
603 } | |
604 | |
605 | |
606 void LCodeGen::DoCmpJSObjectEq(LCmpJSObjectEq* instr) { | |
607 Abort("Unimplemented: %s", "DoCmpJSObjectEq"); | |
608 } | |
609 | |
610 | |
611 void LCodeGen::DoCmpJSObjectEqAndBranch(LCmpJSObjectEqAndBranch* instr) { | |
612 Abort("Unimplemented: %s", "DoCmpJSObjectAndBranch"); | |
613 } | |
614 | |
615 | |
616 void LCodeGen::DoIsNull(LIsNull* instr) { | |
617 Abort("Unimplemented: %s", "DoIsNull"); | |
618 } | |
619 | |
620 | |
621 void LCodeGen::DoIsNullAndBranch(LIsNullAndBranch* instr) { | |
622 Abort("Unimplemented: %s", "DoIsNullAndBranch"); | |
623 } | |
624 | |
625 | |
626 Condition LCodeGen::EmitIsObject(Register input, | |
627 Register temp1, | |
628 Register temp2, | |
629 Label* is_not_object, | |
630 Label* is_object) { | |
631 Abort("Unimplemented: %s", "EmitIsObject"); | |
632 return below_equal; | |
633 } | |
634 | |
635 | |
636 void LCodeGen::DoIsObject(LIsObject* instr) { | |
637 Abort("Unimplemented: %s", "DoIsObject"); | |
638 } | |
639 | |
640 | |
641 void LCodeGen::DoIsObjectAndBranch(LIsObjectAndBranch* instr) { | |
642 Abort("Unimplemented: %s", "DoIsObjectAndBranch"); | |
643 } | |
644 | |
645 | |
646 void LCodeGen::DoIsSmi(LIsSmi* instr) { | |
647 Abort("Unimplemented: %s", "DoIsSmi"); | |
648 } | |
649 | |
650 | |
651 void LCodeGen::DoIsSmiAndBranch(LIsSmiAndBranch* instr) { | |
652 Abort("Unimplemented: %s", "DoIsSmiAndBranch"); | |
653 } | |
654 | |
655 | |
656 InstanceType LHasInstanceType::TestType() { | |
657 InstanceType from = hydrogen()->from(); | |
658 InstanceType to = hydrogen()->to(); | |
659 if (from == FIRST_TYPE) return to; | |
660 ASSERT(from == to || to == LAST_TYPE); | |
661 return from; | |
662 } | |
663 | |
664 | |
Rico
2011/01/12 20:06:25
extra blank line
| |
665 | |
666 Condition LHasInstanceType::BranchCondition() { | |
667 InstanceType from = hydrogen()->from(); | |
668 InstanceType to = hydrogen()->to(); | |
669 if (from == to) return equal; | |
670 if (to == LAST_TYPE) return above_equal; | |
671 if (from == FIRST_TYPE) return below_equal; | |
672 UNREACHABLE(); | |
673 return equal; | |
674 } | |
675 | |
676 | |
677 void LCodeGen::DoHasInstanceType(LHasInstanceType* instr) { | |
678 Abort("Unimplemented: %s", "DoHasInstanceType"); | |
679 } | |
680 | |
681 | |
682 void LCodeGen::DoHasInstanceTypeAndBranch(LHasInstanceTypeAndBranch* instr) { | |
683 Abort("Unimplemented: %s", "DoHasInstanceTypeAndBranch"); | |
684 } | |
685 | |
686 | |
687 void LCodeGen::DoHasCachedArrayIndex(LHasCachedArrayIndex* instr) { | |
688 Abort("Unimplemented: %s", "DoHasCachedArrayIndex"); | |
689 } | |
690 | |
691 | |
692 void LCodeGen::DoHasCachedArrayIndexAndBranch( | |
693 LHasCachedArrayIndexAndBranch* instr) { | |
694 Abort("Unimplemented: %s", "DoHasCachedArrayIndexAndBranch"); | |
695 } | |
696 | |
697 | |
698 // Branches to a label or falls through with the answer in the z flag. Trashes | |
699 // the temp registers, but not the input. Only input and temp2 may alias. | |
700 void LCodeGen::EmitClassOfTest(Label* is_true, | |
701 Label* is_false, | |
702 Handle<String>class_name, | |
703 Register input, | |
704 Register temp, | |
705 Register temp2) { | |
706 Abort("Unimplemented: %s", "EmitClassOfTest"); | |
707 } | |
708 | |
709 | |
710 void LCodeGen::DoClassOfTest(LClassOfTest* instr) { | |
711 Abort("Unimplemented: %s", "DoClassOfTest"); | |
712 } | |
713 | |
714 | |
715 void LCodeGen::DoClassOfTestAndBranch(LClassOfTestAndBranch* instr) { | |
716 Abort("Unimplemented: %s", "DoClassOfTestAndBranch"); | |
717 } | |
718 | |
719 | |
720 void LCodeGen::DoCmpMapAndBranch(LCmpMapAndBranch* instr) { | |
721 Abort("Unimplemented: %s", "DoCmpMapAndBranch"); | |
722 } | |
723 | |
724 | |
725 void LCodeGen::DoInstanceOf(LInstanceOf* instr) { | |
726 Abort("Unimplemented: %s", "DoInstanceOf"); | |
727 } | |
728 | |
729 | |
730 void LCodeGen::DoInstanceOfAndBranch(LInstanceOfAndBranch* instr) { | |
731 Abort("Unimplemented: %s", "DoInstanceOfAndBranch"); | |
732 } | |
733 | |
734 | |
735 void LCodeGen::DoInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr) { | |
736 Abort("Unimplemented: %s", "DoInstanceOfKnowGLobal"); | |
737 } | |
738 | |
739 | |
740 void LCodeGen::DoDeferredLInstanceOfKnownGlobal(LInstanceOfKnownGlobal* instr, | |
741 Label* map_check) { | |
742 Abort("Unimplemented: %s", "DoDeferredLInstanceOfKnownGlobakl"); | |
743 } | |
744 | |
745 | |
746 void LCodeGen::DoCmpT(LCmpT* instr) { | |
747 Abort("Unimplemented: %s", "DoCmpT"); | |
748 } | |
749 | |
750 | |
751 void LCodeGen::DoCmpTAndBranch(LCmpTAndBranch* instr) { | |
752 Abort("Unimplemented: %s", "DoCmpTAndBranch"); | |
753 } | |
754 | |
755 | |
756 void LCodeGen::DoReturn(LReturn* instr) { | |
757 Abort("Unimplemented: %s", "DoReturn"); | |
758 } | |
759 | |
760 | |
761 void LCodeGen::DoLoadGlobal(LLoadGlobal* instr) { | |
762 Abort("Unimplemented: %s", "DoLoadGlobal"); | |
763 } | |
764 | |
765 | |
766 void LCodeGen::DoStoreGlobal(LStoreGlobal* instr) { | |
767 Abort("Unimplemented: %s", "DoStoreGlobal"); | |
768 } | |
769 | |
770 | |
771 void LCodeGen::DoLoadNamedField(LLoadNamedField* instr) { | |
772 Abort("Unimplemented: %s", "DoLoadNamedField"); | |
773 } | |
774 | |
775 | |
776 void LCodeGen::DoLoadNamedGeneric(LLoadNamedGeneric* instr) { | |
777 Abort("Unimplemented: %s", "DoLoadNamedGeneric"); | |
778 } | |
779 | |
780 | |
781 void LCodeGen::DoLoadFunctionPrototype(LLoadFunctionPrototype* instr) { | |
782 Abort("Unimplemented: %s", "DoLoadFunctionPrototype"); | |
783 } | |
784 | |
785 | |
786 void LCodeGen::DoLoadElements(LLoadElements* instr) { | |
787 Abort("Unimplemented: %s", "DoLoadElements"); | |
788 } | |
789 | |
790 | |
791 void LCodeGen::DoAccessArgumentsAt(LAccessArgumentsAt* instr) { | |
792 Abort("Unimplemented: %s", "DoAccessArgumentsAt"); | |
793 } | |
794 | |
795 | |
796 void LCodeGen::DoLoadKeyedFastElement(LLoadKeyedFastElement* instr) { | |
797 Abort("Unimplemented: %s", "DoLoadKeyedFastElement"); | |
798 } | |
799 | |
800 | |
801 void LCodeGen::DoLoadKeyedGeneric(LLoadKeyedGeneric* instr) { | |
802 Abort("Unimplemented: %s", "DoLoadKeyedGeneric"); | |
803 } | |
804 | |
805 | |
806 void LCodeGen::DoArgumentsElements(LArgumentsElements* instr) { | |
807 Abort("Unimplemented: %s", "DoArgumentsElements"); | |
808 } | |
809 | |
810 | |
811 void LCodeGen::DoArgumentsLength(LArgumentsLength* instr) { | |
812 Abort("Unimplemented: %s", "DoArgumentsLength"); | |
813 } | |
814 | |
815 | |
816 void LCodeGen::DoApplyArguments(LApplyArguments* instr) { | |
817 Abort("Unimplemented: %s", "DoApplyArguments"); | |
818 } | |
819 | |
820 | |
821 void LCodeGen::DoPushArgument(LPushArgument* instr) { | |
822 Abort("Unimplemented: %s", "DoPushArgument"); | |
823 } | |
824 | |
825 | |
826 void LCodeGen::DoGlobalObject(LGlobalObject* instr) { | |
827 Abort("Unimplemented: %s", "DoGlobalObject"); | |
828 } | |
829 | |
830 | |
831 void LCodeGen::DoGlobalReceiver(LGlobalReceiver* instr) { | |
832 Abort("Unimplemented: %s", "DoGlobalReceiver"); | |
833 } | |
834 | |
835 | |
836 void LCodeGen::CallKnownFunction(Handle<JSFunction> function, | |
837 int arity, | |
838 LInstruction* instr) { | |
839 Abort("Unimplemented: %s", "CallKnownFunction"); | |
840 } | |
841 | |
842 | |
843 void LCodeGen::DoCallConstantFunction(LCallConstantFunction* instr) { | |
844 Abort("Unimplemented: %s", "DoCallConstantFunction"); | |
845 } | |
846 | |
847 | |
848 void LCodeGen::DoDeferredMathAbsTaggedHeapNumber(LUnaryMathOperation* instr) { | |
849 Abort("Unimplemented: %s", "DoDeferredMathAbsTaggedHeapNumber"); | |
850 } | |
851 | |
852 | |
853 void LCodeGen::DoMathAbs(LUnaryMathOperation* instr) { | |
854 Abort("Unimplemented: %s", "DoMathAbs"); | |
855 } | |
856 | |
857 | |
858 void LCodeGen::DoMathFloor(LUnaryMathOperation* instr) { | |
859 Abort("Unimplemented: %s", "DoMathFloor"); | |
860 } | |
861 | |
862 | |
863 void LCodeGen::DoMathRound(LUnaryMathOperation* instr) { | |
864 Abort("Unimplemented: %s", "DoMathRound"); | |
865 } | |
866 | |
867 | |
868 void LCodeGen::DoMathSqrt(LUnaryMathOperation* instr) { | |
869 Abort("Unimplemented: %s", "DoMathSqrt"); | |
870 } | |
871 | |
872 | |
873 void LCodeGen::DoMathPowHalf(LUnaryMathOperation* instr) { | |
874 Abort("Unimplemented: %s", "DoMathPowHalf"); | |
875 } | |
876 | |
877 | |
878 void LCodeGen::DoPower(LPower* instr) { | |
879 Abort("Unimplemented: %s", "DoPower"); | |
880 } | |
881 | |
882 | |
883 void LCodeGen::DoMathLog(LUnaryMathOperation* instr) { | |
884 Abort("Unimplemented: %s", "DoMathLog"); | |
885 } | |
886 | |
887 | |
888 void LCodeGen::DoMathCos(LUnaryMathOperation* instr) { | |
889 Abort("Unimplemented: %s", "DoMathCos"); | |
890 } | |
891 | |
892 | |
893 void LCodeGen::DoMathSin(LUnaryMathOperation* instr) { | |
894 Abort("Unimplemented: %s", "DoMathSin"); | |
895 } | |
896 | |
897 | |
898 void LCodeGen::DoUnaryMathOperation(LUnaryMathOperation* instr) { | |
899 Abort("Unimplemented: %s", "DoUnaryMathOperation"); | |
900 } | |
901 | |
902 | |
903 void LCodeGen::DoCallKeyed(LCallKeyed* instr) { | |
904 Abort("Unimplemented: %s", "DoCallKeyed"); | |
905 } | |
906 | |
907 | |
908 void LCodeGen::DoCallNamed(LCallNamed* instr) { | |
909 Abort("Unimplemented: %s", "DoCallNamed"); | |
910 } | |
911 | |
912 | |
913 void LCodeGen::DoCallFunction(LCallFunction* instr) { | |
914 Abort("Unimplemented: %s", "DoCallFunction"); | |
915 } | |
916 | |
917 | |
918 void LCodeGen::DoCallGlobal(LCallGlobal* instr) { | |
919 Abort("Unimplemented: %s", "DoCallGlobal"); | |
920 } | |
921 | |
922 | |
923 void LCodeGen::DoCallKnownGlobal(LCallKnownGlobal* instr) { | |
924 Abort("Unimplemented: %s", "DoCallKnownGlobal"); | |
925 } | |
926 | |
927 | |
928 void LCodeGen::DoCallNew(LCallNew* instr) { | |
929 Abort("Unimplemented: %s", "DoCallNew"); | |
930 } | |
931 | |
932 | |
933 void LCodeGen::DoCallRuntime(LCallRuntime* instr) { | |
934 Abort("Unimplemented: %s", "DoCallRuntime"); | |
935 } | |
936 | |
937 | |
938 void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) { | |
939 Abort("Unimplemented: %s", "DoStoreNamedField"); | |
940 } | |
941 | |
942 | |
943 void LCodeGen::DoStoreNamedGeneric(LStoreNamedGeneric* instr) { | |
944 Abort("Unimplemented: %s", "DoStoreNamedGeneric"); | |
945 } | |
946 | |
947 | |
948 void LCodeGen::DoBoundsCheck(LBoundsCheck* instr) { | |
949 Abort("Unimplemented: %s", "DoBoundsCheck"); | |
950 } | |
951 | |
952 | |
953 void LCodeGen::DoStoreKeyedFastElement(LStoreKeyedFastElement* instr) { | |
954 Abort("Unimplemented: %s", "DoStoreKeyedFastElement"); | |
955 } | |
956 | |
957 | |
958 void LCodeGen::DoStoreKeyedGeneric(LStoreKeyedGeneric* instr) { | |
959 Abort("Unimplemented: %s", "DoStoreKeyedGeneric"); | |
960 } | |
961 | |
962 | |
963 void LCodeGen::DoInteger32ToDouble(LInteger32ToDouble* instr) { | |
964 Abort("Unimplemented: %s", "DoInteger32ToDouble"); | |
965 } | |
966 | |
967 | |
968 void LCodeGen::DoNumberTagI(LNumberTagI* instr) { | |
969 Abort("Unimplemented: %s", "DoNumberTagI"); | |
970 } | |
971 | |
972 | |
973 void LCodeGen::DoDeferredNumberTagI(LNumberTagI* instr) { | |
974 Abort("Unimplemented: %s", "DoDeferredNumberTagI"); | |
975 } | |
976 | |
977 | |
978 void LCodeGen::DoNumberTagD(LNumberTagD* instr) { | |
979 Abort("Unimplemented: %s", "DoNumberTagD"); | |
980 } | |
981 | |
982 | |
983 void LCodeGen::DoDeferredNumberTagD(LNumberTagD* instr) { | |
984 Abort("Unimplemented: %s", "DoDeferredNumberTagD"); | |
985 } | |
986 | |
987 | |
988 void LCodeGen::DoSmiTag(LSmiTag* instr) { | |
989 Abort("Unimplemented: %s", "DoSmiTag"); | |
990 } | |
991 | |
992 | |
993 void LCodeGen::DoSmiUntag(LSmiUntag* instr) { | |
994 Abort("Unimplemented: %s", "DoSmiUntag"); | |
995 } | |
996 | |
997 | |
998 void LCodeGen::EmitNumberUntagD(Register input_reg, | |
999 XMMRegister result_reg, | |
1000 LEnvironment* env) { | |
1001 Abort("Unimplemented: %s", "EmitNumberUntagD"); | |
1002 } | |
1003 | |
1004 | |
1005 void LCodeGen::DoDeferredTaggedToI(LTaggedToI* instr) { | |
1006 Abort("Unimplemented: %s", "DoDeferredTaggedToI"); | |
1007 } | |
1008 | |
1009 | |
1010 void LCodeGen::DoTaggedToI(LTaggedToI* instr) { | |
1011 Abort("Unimplemented: %s", "DoTaggedToI"); | |
1012 } | |
1013 | |
1014 | |
1015 void LCodeGen::DoNumberUntagD(LNumberUntagD* instr) { | |
1016 Abort("Unimplemented: %s", "DoNumberUntagD"); | |
1017 } | |
1018 | |
1019 | |
1020 void LCodeGen::DoDoubleToI(LDoubleToI* instr) { | |
1021 Abort("Unimplemented: %s", "DoDoubleToI"); | |
1022 } | |
1023 | |
1024 | |
1025 void LCodeGen::DoCheckSmi(LCheckSmi* instr) { | |
1026 Abort("Unimplemented: %s", "DoCheckSmi"); | |
1027 } | |
1028 | |
1029 | |
1030 void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) { | |
1031 Abort("Unimplemented: %s", "DoCheckInstanceType"); | |
1032 } | |
1033 | |
1034 | |
1035 void LCodeGen::DoCheckFunction(LCheckFunction* instr) { | |
1036 Abort("Unimplemented: %s", "DoCheckFunction"); | |
1037 } | |
1038 | |
1039 | |
1040 void LCodeGen::DoCheckMap(LCheckMap* instr) { | |
1041 Abort("Unimplemented: %s", "DoCheckMap"); | |
1042 } | |
1043 | |
1044 | |
1045 void LCodeGen::LoadPrototype(Register result, Handle<JSObject> prototype) { | |
1046 Abort("Unimplemented: %s", "LoadPrototype"); | |
1047 } | |
1048 | |
1049 | |
1050 void LCodeGen::DoCheckPrototypeMaps(LCheckPrototypeMaps* instr) { | |
1051 Abort("Unimplemented: %s", "DoCheckPrototypeMaps"); | |
1052 } | |
1053 | |
1054 | |
1055 void LCodeGen::DoArrayLiteral(LArrayLiteral* instr) { | |
1056 Abort("Unimplemented: %s", "DoArrayLiteral"); | |
1057 } | |
1058 | |
1059 | |
1060 void LCodeGen::DoObjectLiteral(LObjectLiteral* instr) { | |
1061 Abort("Unimplemented: %s", "DoObjectLiteral"); | |
1062 } | |
1063 | |
1064 | |
1065 void LCodeGen::DoRegExpLiteral(LRegExpLiteral* instr) { | |
1066 Abort("Unimplemented: %s", "DoRegExpLiteral"); | |
1067 } | |
1068 | |
1069 | |
1070 void LCodeGen::DoFunctionLiteral(LFunctionLiteral* instr) { | |
1071 Abort("Unimplemented: %s", "DoFunctionLiteral"); | |
1072 } | |
1073 | |
1074 | |
1075 void LCodeGen::DoTypeof(LTypeof* instr) { | |
1076 Abort("Unimplemented: %s", "DoTypeof"); | |
1077 } | |
1078 | |
1079 | |
1080 void LCodeGen::DoTypeofIs(LTypeofIs* instr) { | |
1081 Abort("Unimplemented: %s", "DoTypeofIs"); | |
1082 } | |
1083 | |
1084 | |
1085 void LCodeGen::DoTypeofIsAndBranch(LTypeofIsAndBranch* instr) { | |
1086 Abort("Unimplemented: %s", "DoTypeofIsAndBranch"); | |
1087 } | |
1088 | |
1089 | |
1090 Condition LCodeGen::EmitTypeofIs(Label* true_label, | |
1091 Label* false_label, | |
1092 Register input, | |
1093 Handle<String> type_name) { | |
1094 Abort("Unimplemented: %s", "EmitTypeofIs"); | |
1095 return no_condition; | |
1096 } | |
1097 | |
1098 | |
78 void LCodeGen::DoLazyBailout(LLazyBailout* instr) { | 1099 void LCodeGen::DoLazyBailout(LLazyBailout* instr) { |
79 // No code for lazy bailout instruction. Used to capture environment after a | 1100 // No code for lazy bailout instruction. Used to capture environment after a |
80 // call for populating the safepoint data with deoptimization data. | 1101 // call for populating the safepoint data with deoptimization data. |
81 } | 1102 } |
82 | 1103 |
83 | 1104 |
84 void LCodeGen::DoDeoptimize(LDeoptimize* instr) { | 1105 void LCodeGen::DoDeoptimize(LDeoptimize* instr) { |
85 DeoptimizeIf(no_condition, instr->environment()); | 1106 DeoptimizeIf(no_condition, instr->environment()); |
86 } | 1107 } |
87 | 1108 |
88 | 1109 |
1110 void LCodeGen::DoDeleteProperty(LDeleteProperty* instr) { | |
1111 Abort("Unimplemented: %s", "DoDeleteProperty"); | |
1112 } | |
1113 | |
1114 | |
1115 void LCodeGen::DoStackCheck(LStackCheck* instr) { | |
1116 Abort("Unimplemented: %s", "DoStackCheck"); | |
1117 } | |
1118 | |
1119 | |
89 void LCodeGen::DoOsrEntry(LOsrEntry* instr) { | 1120 void LCodeGen::DoOsrEntry(LOsrEntry* instr) { |
90 UNIMPLEMENTED(); | 1121 Abort("Unimplemented: %s", "DoOsrEntry");} |
Rico
2011/01/12 20:06:25
Move } to its own line
| |
91 } | |
92 | 1122 |
93 | 1123 |
94 #undef __ | 1124 #undef __ |
95 | 1125 |
96 } } // namespace v8::internal | 1126 } } // namespace v8::internal |
OLD | NEW |