Add implementations of some more x64 lithium methods....

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 55 matching lines @@
     va_start(arguments, format);
     OS::VPrint(format, arguments);
     va_end(arguments);
     PrintF("\n");
   }
   status_ = ABORTED;
 }
 
 
 void LCodeGen::Comment(const char* format, ...) {
-  Abort("Unimplemented: %s", "Comment");
+  if (!FLAG_code_comments) return;
+  char buffer[4 * KB];
+  StringBuilder builder(buffer, ARRAY_SIZE(buffer));
+  va_list arguments;
+  va_start(arguments, format);
+  builder.AddFormattedList(format, arguments);
+  va_end(arguments);
+
+  // Copy the string before recording it in the assembler to avoid
+  // issues when the stack allocated buffer goes out of scope.
+  size_t length = builder.position();
+  Vector<char> copy = Vector<char>::New(length + 1);
+  memcpy(copy.start(), builder.Finalize(), copy.length());
+  masm()->RecordComment(copy.start());
 }
 
 
 bool LCodeGen::GeneratePrologue() {
   Abort("Unimplemented: %s", "GeneratePrologue");
-  return !is_aborted();
+  return false;
 }
 
 
 bool LCodeGen::GenerateBody() {
   ASSERT(is_generating());
   bool emit_instructions = true;
   for (current_instruction_ = 0;
        !is_aborted() && current_instruction_ < instructions_->length();
        current_instruction_++) {
     LInstruction* instr = instructions_->at(current_instruction_);
@@ skipping 31 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 !is_aborted();
+  return false;
 }
 
 
 Register LCodeGen::ToRegister(int index) const {
   return Register::FromAllocationIndex(index);
 }
 
 
 XMMRegister LCodeGen::ToDoubleRegister(int index) const {
   return XMMRegister::FromAllocationIndex(index);
@@ skipping 335 matching lines @@
   Abort("Unimplemented: %s", "DoConstantI");
 }
 
 
 void LCodeGen::DoConstantD(LConstantD* instr) {
   Abort("Unimplemented: %s", "DoConstantI");
 }
 
 
 void LCodeGen::DoConstantT(LConstantT* instr) {
-  Abort("Unimplemented: %s", "DoConstantT");
+    ASSERT(instr->result()->IsRegister());
+  __ Move(ToRegister(instr->result()), instr->value());
 }
 
 
 void LCodeGen::DoJSArrayLength(LJSArrayLength* instr) {
   Abort("Unimplemented: %s", "DoJSArrayLength");
 }
 
 
 void LCodeGen::DoFixedArrayLength(LFixedArrayLength* instr) {
   Abort("Unimplemented: %s", "DoFixedArrayLength");
@@ skipping 53 matching lines @@
   Abort("Unimplemented: %s", "EmitGoto");
 }
 
 
 void LCodeGen::DoDeferredStackCheck(LGoto* instr) {
   Abort("Unimplemented: %s", "DoDeferredStackCheck");
 }
 
 
 void LCodeGen::DoGoto(LGoto* instr) {
-  Abort("Unimplemented: %s", "DoGoto");
+  class DeferredStackCheck: public LDeferredCode {
+   public:
+    DeferredStackCheck(LCodeGen* codegen, LGoto* instr)
+        : LDeferredCode(codegen), instr_(instr) { }
+    virtual void Generate() { codegen()->DoDeferredStackCheck(instr_); }
+   private:
+    LGoto* instr_;
+  };
+
+  DeferredStackCheck* deferred = NULL;
+  if (instr->include_stack_check()) {
+    deferred = new DeferredStackCheck(this, instr);
+  }
+  EmitGoto(instr->block_id(), deferred);
 }
 
 
 Condition LCodeGen::TokenToCondition(Token::Value op, bool is_unsigned) {
   Condition cond = no_condition;
   switch (op) {
     case Token::EQ:
     case Token::EQ_STRICT:
       cond = equal;
       break;
@@ skipping 177 matching lines @@
   Abort("Unimplemented: %s", "DoCmpT");
 }
 
 
 void LCodeGen::DoCmpTAndBranch(LCmpTAndBranch* instr) {
   Abort("Unimplemented: %s", "DoCmpTAndBranch");
 }
 
 
 void LCodeGen::DoReturn(LReturn* instr) {
-  Abort("Unimplemented: %s", "DoReturn");
+  if (FLAG_trace) {
+    // Preserve the return value on the stack and rely on the runtime
+    // call to return the value in the same register.
+    __ push(rax);
+    __ CallRuntime(Runtime::kTraceExit, 1);
+  }
+  __ movq(rsp, rbp);
+  __ pop(rbp);
+  __ ret((ParameterCount() + 1) * kPointerSize);
+
 }
 
 
 void LCodeGen::DoLoadGlobal(LLoadGlobal* instr) {
   Abort("Unimplemented: %s", "DoLoadGlobal");
 }
 
 
 void LCodeGen::DoStoreGlobal(LStoreGlobal* instr) {
   Abort("Unimplemented: %s", "DoStoreGlobal");
@@ skipping 351 matching lines @@
 
 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
   Abort("Unimplemented: %s", "DoOsrEntry");
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64