Add GenerateSafePointTable, CallCode and EmitGoto to lithium codegen on x64...

src/x64/lithium-codegen-x64.cc

 // Copyright 2011 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 320 matching lines @@
   }
 
   // Deferred code is the last part of the instruction sequence. Mark
   // the generated code as done unless we bailed out.
   if (!is_aborted()) status_ = DONE;
   return !is_aborted();
 }
 
 
 bool LCodeGen::GenerateSafepointTable() {
-  Abort("Unimplemented: %s", "GeneratePrologue");
-  return false;
+  ASSERT(is_done());
+  safepoints_.Emit(masm(), StackSlotCount());
+  return !is_aborted();
 }
 
 
 Register LCodeGen::ToRegister(int index) const {
   return Register::FromAllocationIndex(index);
 }
 
 
 XMMRegister LCodeGen::ToDoubleRegister(int index) const {
   return XMMRegister::FromAllocationIndex(index);
@@ skipping 132 matching lines @@
     translation->StoreLiteral(src_index);
   } else {
     UNREACHABLE();
   }
 }
 
 
 void LCodeGen::CallCode(Handle<Code> code,
                         RelocInfo::Mode mode,
                         LInstruction* instr) {
-  Abort("Unimplemented: %s", "CallCode");
+  if (instr != NULL) {
+    LPointerMap* pointers = instr->pointer_map();
+    RecordPosition(pointers->position());
+    __ call(code, mode);
+    RegisterLazyDeoptimization(instr);
+  } else {
+    LPointerMap no_pointers(0);
+    RecordPosition(no_pointers.position());
+    __ call(code, mode);
+    RecordSafepoint(&no_pointers, Safepoint::kNoDeoptimizationIndex);
+  }
+
+  // Signal that we don't inline smi code before these stubs in the
+  // optimizing code generator.
+  if (code->kind() == Code::TYPE_RECORDING_BINARY_OP_IC ||
+      code->kind() == Code::COMPARE_IC) {
+    __ nop();
+  }
 }
 
 
 void LCodeGen::CallRuntime(Runtime::Function* function,
                            int num_arguments,
                            LInstruction* instr) {
   Abort("Unimplemented: %s", "CallRuntime");
 }
 
 
 void LCodeGen::RegisterLazyDeoptimization(LInstruction* instr) {
   // Create the environment to bailout to. If the call has side effects
   // execution has to continue after the call otherwise execution can continue
   // from a previous bailout point repeating the call.
   LEnvironment* deoptimization_environment;
   if (instr->HasDeoptimizationEnvironment()) {
     deoptimization_environment = instr->deoptimization_environment();
   } else {
     deoptimization_environment = instr->environment();
   }
 
   RegisterEnvironmentForDeoptimization(deoptimization_environment);
   RecordSafepoint(instr->pointer_map(),
                   deoptimization_environment->deoptimization_index());
 }
 
 
 void LCodeGen::RegisterEnvironmentForDeoptimization(LEnvironment* environment) {
+  return;

[Rico, 2011/01/17 09:36:02]

The return here is intentional to get the method compiling. With this change we
can now start implementing support for deoptimization (by actually implementing
this and dependent function + the methods in the deoptimizer-x64.cc file)

[Lasse Reichstein, 2011/01/17 09:38:56]

Put this explanation in a comment and remove the Abort.
Unreachable code is bad, m'kay.

[Rico, 2011/01/17 09:47:50]

Changed to a comment and todo added

   Abort("Unimplemented: %s", "RegisterEnvironmentForDeoptimization");
 }
 
 
 void LCodeGen::DeoptimizeIf(Condition cc, LEnvironment* environment) {
   Abort("Unimplemented: %s", "Deoptimiz");
 }
 
 
 void LCodeGen::PopulateDeoptimizationData(Handle<Code> code) {
@@ skipping 318 matching lines @@
   Abort("Unimplemented: %s", "EmitBranch");
 }
 
 
 void LCodeGen::DoBranch(LBranch* instr) {
   Abort("Unimplemented: %s", "DoBranch");
 }
 
 
 void LCodeGen::EmitGoto(int block, LDeferredCode* deferred_stack_check) {
-  Abort("Unimplemented: %s", "EmitGoto");
+  block = chunk_->LookupDestination(block);
+  int next_block = GetNextEmittedBlock(current_block_);
+  if (block != next_block) {
+    // Perform stack overflow check if this goto needs it before jumping.
+    if (deferred_stack_check != NULL) {
+      __ CompareRoot(rsp, Heap::kStackLimitRootIndex);
+      __ j(above_equal, chunk_->GetAssemblyLabel(block));
+      __ jmp(deferred_stack_check->entry());
+      deferred_stack_check->SetExit(chunk_->GetAssemblyLabel(block));
+    } else {
+      __ jmp(chunk_->GetAssemblyLabel(block));
+    }
+  }
 }
 
 
 void LCodeGen::DoDeferredStackCheck(LGoto* instr) {
   Abort("Unimplemented: %s", "DoDeferredStackCheck");
 }
 
 
 void LCodeGen::DoGoto(LGoto* instr) {
   class DeferredStackCheck: public LDeferredCode {
@@ skipping 593 matching lines @@
 
 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
   Abort("Unimplemented: %s", "DoOsrEntry");
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64