Revert change 6468: X64 Crankshaft functions added.

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 1371 matching lines @@
     __ push(rax);
     __ CallRuntime(Runtime::kTraceExit, 1);
   }
   __ movq(rsp, rbp);
   __ pop(rbp);
   __ ret((ParameterCount() + 1) * kPointerSize);
 }
 
 
 void LCodeGen::DoLoadGlobal(LLoadGlobal* instr) {
-  Register result = ToRegister(instr->result());
-  if (result.is(rax)) {
-    __ load_rax(instr->hydrogen()->cell().location(),
-                RelocInfo::GLOBAL_PROPERTY_CELL);
-  } else {
-    __ movq(result, instr->hydrogen()->cell().location(),
-            RelocInfo::GLOBAL_PROPERTY_CELL);
-    __ movq(result, Operand(result, 0));
-  }
-  if (instr->hydrogen()->check_hole_value()) {
-    __ CompareRoot(result, Heap::kTheHoleValueRootIndex);
-    DeoptimizeIf(equal, instr->environment());
-  }
+  Abort("Unimplemented: %s", "DoLoadGlobal");
 }
 
 
 void LCodeGen::DoStoreGlobal(LStoreGlobal* instr) {
   Abort("Unimplemented: %s", "DoStoreGlobal");
 }
 
 
 void LCodeGen::DoLoadContextSlot(LLoadContextSlot* instr) {
   Abort("Unimplemented: %s", "DoLoadContextSlot");
@@ skipping 44 matching lines @@
   Abort("Unimplemented: %s", "DoArgumentsLength");
 }
 
 
 void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
   Abort("Unimplemented: %s", "DoApplyArguments");
 }
 
 
 void LCodeGen::DoPushArgument(LPushArgument* instr) {
-  LOperand* argument = instr->InputAt(0);
-  if (argument->IsConstantOperand()) {
-    LConstantOperand* const_op = LConstantOperand::cast(argument);
-    Handle<Object> literal = chunk_->LookupLiteral(const_op);
-    Representation r = chunk_->LookupLiteralRepresentation(const_op);
-    if (r.IsInteger32()) {
-      ASSERT(literal->IsNumber());
-      __ push(Immediate(static_cast<int32_t>(literal->Number())));
-    } else if (r.IsDouble()) {
-      Abort("unsupported double immediate");
-    } else {
-      ASSERT(r.IsTagged());
-      __ Push(literal);
-    }
-  } else if (argument->IsRegister()) {
-    __ push(ToRegister(argument));
-  } else {
-    ASSERT(!argument->IsDoubleRegister());
-    __ push(ToOperand(argument));
-  }
+  Abort("Unimplemented: %s", "DoPushArgument");
 }
 
 
 void LCodeGen::DoGlobalObject(LGlobalObject* instr) {
   Register result = ToRegister(instr->result());
   __ movq(result, GlobalObjectOperand());
 }
 
 
 void LCodeGen::DoGlobalReceiver(LGlobalReceiver* instr) {
@@ skipping 87 matching lines @@
   Abort("Unimplemented: %s", "DoCallGlobal");
 }
 
 
 void LCodeGen::DoCallKnownGlobal(LCallKnownGlobal* instr) {
   Abort("Unimplemented: %s", "DoCallKnownGlobal");
 }
 
 
 void LCodeGen::DoCallNew(LCallNew* instr) {
-  ASSERT(ToRegister(instr->InputAt(0)).is(rdi));
-  ASSERT(ToRegister(instr->result()).is(rax));
-
-  Handle<Code> builtin(Builtins::builtin(Builtins::JSConstructCall));
-  __ Set(rax, instr->arity());
-  CallCode(builtin, RelocInfo::CONSTRUCT_CALL, instr);
+  Abort("Unimplemented: %s", "DoCallNew");
 }
 
 
 void LCodeGen::DoCallRuntime(LCallRuntime* instr) {
   Abort("Unimplemented: %s", "DoCallRuntime");
 }
 
 
 void LCodeGen::DoStoreNamedField(LStoreNamedField* instr) {
   Abort("Unimplemented: %s", "DoStoreNamedField");
@@ skipping 139 matching lines @@
   Abort("Unimplemented: %s", "DoNumberUntagD");
 }
 
 
 void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
   Abort("Unimplemented: %s", "DoDoubleToI");
 }
 
 
 void LCodeGen::DoCheckSmi(LCheckSmi* instr) {
-  LOperand* input = instr->InputAt(0);
-  ASSERT(input->IsRegister());
-  Condition cc = masm()->CheckSmi(ToRegister(input));
-  if (instr->condition() != equal) {
-    cc = NegateCondition(cc);
-  }
-  DeoptimizeIf(cc, instr->environment());
+  Abort("Unimplemented: %s", "DoCheckSmi");
 }
 
 
 void LCodeGen::DoCheckInstanceType(LCheckInstanceType* instr) {
   Abort("Unimplemented: %s", "DoCheckInstanceType");
 }
 
 
 void LCodeGen::DoCheckFunction(LCheckFunction* instr) {
   Abort("Unimplemented: %s", "DoCheckFunction");
 }
 
 
 void LCodeGen::DoCheckMap(LCheckMap* instr) {
-  LOperand* input = instr->InputAt(0);
-  ASSERT(input->IsRegister());
-  Register reg = ToRegister(input);
-  __ Cmp(FieldOperand(reg, HeapObject::kMapOffset),
-         instr->hydrogen()->map());
-  DeoptimizeIf(not_equal, instr->environment());
+  Abort("Unimplemented: %s", "DoCheckMap");
 }
 
 
 void LCodeGen::LoadHeapObject(Register result, Handle<HeapObject> object) {
   Abort("Unimplemented: %s", "LoadHeapObject");
 }
 
 
 void LCodeGen::DoCheckPrototypeMaps(LCheckPrototypeMaps* instr) {
   Abort("Unimplemented: %s", "DoCheckPrototypeMaps");
@@ skipping 141 matching lines @@
 
 void LCodeGen::DoOsrEntry(LOsrEntry* instr) {
   Abort("Unimplemented: %s", "DoOsrEntry");
 }
 
 #undef __
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64