From 948265619bce113a5c608099b42bcdd7c4f0c8d4 Mon Sep 17 00:00:00 2001
From: "whesse@chromium.org"
 <whesse@chromium.org@ce2b1a6d-e550-0410-aec6-3dcde31c8c00>
Date: Tue, 25 Jan 2011 16:37:18 +0000
Subject: [PATCH] Revert change 6468: X64 Crankshaft functions added. Review
 URL: http://codereview.chromium.org/6260018

git-svn-id: http://v8.googlecode.com/svn/branches/bleeding_edge@6473 ce2b1a6d-e550-0410-aec6-3dcde31c8c00
---
 src/x64/lithium-codegen-x64.cc | 57 ++++--------------------------------------
 src/x64/lithium-x64.cc         | 30 +++++++++-------------
 2 files changed, 17 insertions(+), 70 deletions(-)

diff --git a/src/x64/lithium-codegen-x64.cc b/src/x64/lithium-codegen-x64.cc
index a0fa73b..0a04f03 100644
--- a/src/x64/lithium-codegen-x64.cc
+++ b/src/x64/lithium-codegen-x64.cc
@@ -1389,19 +1389,7 @@ void LCodeGen::DoReturn(LReturn* instr) {
 
 
 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");
 }
 
 
@@ -1466,26 +1454,7 @@ void LCodeGen::DoApplyArguments(LApplyArguments* instr) {
 
 
 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");
 }
 
 
@@ -1593,12 +1562,7 @@ void LCodeGen::DoCallKnownGlobal(LCallKnownGlobal* instr) {
 
 
 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");
 }
 
 
@@ -1758,13 +1722,7 @@ void LCodeGen::DoDoubleToI(LDoubleToI* instr) {
 
 
 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");
 }
 
 
@@ -1779,12 +1737,7 @@ void LCodeGen::DoCheckFunction(LCheckFunction* instr) {
 
 
 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");
 }
 
 
diff --git a/src/x64/lithium-x64.cc b/src/x64/lithium-x64.cc
index f0610d4..5b7169b 100644
--- a/src/x64/lithium-x64.cc
+++ b/src/x64/lithium-x64.cc
@@ -1027,9 +1027,8 @@ LInstruction* LChunkBuilder::DoApplyArguments(HApplyArguments* instr) {
 
 
 LInstruction* LChunkBuilder::DoPushArgument(HPushArgument* instr) {
-  ++argument_count_;
-  LOperand* argument = UseOrConstant(instr->argument());
-  return new LPushArgument(argument);
+  Abort("Unimplemented: %s", "DoPushArgument");
+  return NULL;
 }
 
 
@@ -1082,10 +1081,8 @@ LInstruction* LChunkBuilder::DoCallKnownGlobal(HCallKnownGlobal* instr) {
 
 
 LInstruction* LChunkBuilder::DoCallNew(HCallNew* instr) {
-  LOperand* constructor = UseFixed(instr->constructor(), rdi);
-  argument_count_ -= instr->argument_count();
-  LCallNew* result = new LCallNew(constructor);
-  return MarkAsCall(DefineFixed(result, rax), instr);
+  Abort("Unimplemented: %s", "DoCallNew");
+  return NULL;
 }
 
 
@@ -1381,8 +1378,8 @@ LInstruction* LChunkBuilder::DoChange(HChange* instr) {
 
 
 LInstruction* LChunkBuilder::DoCheckNonSmi(HCheckNonSmi* instr) {
-  LOperand* value = UseRegisterAtStart(instr->value());
-  return AssignEnvironment(new LCheckSmi(value, zero));
+  Abort("Unimplemented: %s", "DoCheckNonSmi");
+  return NULL;
 }
 
 
@@ -1399,8 +1396,8 @@ LInstruction* LChunkBuilder::DoCheckPrototypeMaps(HCheckPrototypeMaps* instr) {
 
 
 LInstruction* LChunkBuilder::DoCheckSmi(HCheckSmi* instr) {
-  LOperand* value = UseRegisterAtStart(instr->value());
-  return AssignEnvironment(new LCheckSmi(value, not_zero));
+  Abort("Unimplemented: %s", "DoCheckSmi");
+  return NULL;
 }
 
 
@@ -1411,9 +1408,8 @@ LInstruction* LChunkBuilder::DoCheckFunction(HCheckFunction* instr) {
 
 
 LInstruction* LChunkBuilder::DoCheckMap(HCheckMap* instr) {
-  LOperand* value = UseRegisterAtStart(instr->value());
-  LCheckMap* result = new LCheckMap(value);
-  return AssignEnvironment(result);
+  Abort("Unimplemented: %s", "DoCheckMap");
+  return NULL;
 }
 
 
@@ -1441,10 +1437,8 @@ LInstruction* LChunkBuilder::DoConstant(HConstant* instr) {
 
 
 LInstruction* LChunkBuilder::DoLoadGlobal(HLoadGlobal* instr) {
-  LLoadGlobal* result = new LLoadGlobal;
-  return instr->check_hole_value()
-      ? AssignEnvironment(DefineAsRegister(result))
-      : DefineAsRegister(result);
+  Abort("Unimplemented: %s", "DoLoadGlobal");
+  return NULL;
 }
 
 
-- 
2.7.4