Chromium Code Reviews
chromiumcodereview-hr@appspot.gserviceaccount.com (chromiumcodereview-hr) | Please choose your nickname with Settings | Help | Chromium Project | Gerrit Changes | Sign out
(574)

Side by Side Diff: src/x64/lithium-codegen-x64.cc

Issue 6201006: X64 Crankshaft: Ported lots of boilerplate code. (Closed)
Patch Set: Created 9 years, 11 months ago
Use n/p to move between diff chunks; N/P to move between comments. Draft comments are only viewable by you.
Jump to:
View unified diff | Download patch
« no previous file with comments | « src/x64/lithium-codegen-x64.h ('k') | src/x64/lithium-x64.h » ('j') | no next file with comments »
Toggle Intra-line Diffs ('i') | Expand Comments ('e') | Collapse Comments ('c') | Show Comments Hide Comments ('s')
OLDNEW
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
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
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
OLDNEW
« no previous file with comments | « src/x64/lithium-codegen-x64.h ('k') | src/x64/lithium-x64.h » ('j') | no next file with comments »

Powered by Google App Engine
This is Rietveld 408576698