Revert change 6468: X64 Crankshaft functions added.

src/x64/lithium-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 1009 matching lines @@
 }
 
 
 LInstruction* LChunkBuilder::DoApplyArguments(HApplyArguments* instr) {
   Abort("Unimplemented: %s", "DoApplyArguments");
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoPushArgument(HPushArgument* instr) {
-  ++argument_count_;
-  LOperand* argument = UseOrConstant(instr->argument());
-  return new LPushArgument(argument);
+  Abort("Unimplemented: %s", "DoPushArgument");
+  return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoGlobalObject(HGlobalObject* instr) {
   return DefineAsRegister(new LGlobalObject);
 }
 
 
 LInstruction* LChunkBuilder::DoGlobalReceiver(HGlobalReceiver* instr) {
   Abort("Unimplemented: %s", "DoGlobalReceiver");
@@ skipping 32 matching lines @@
 }
 
 
 LInstruction* LChunkBuilder::DoCallKnownGlobal(HCallKnownGlobal* instr) {
   Abort("Unimplemented: %s", "DoCallKnownGlobal");
   return NULL;
 }
 
 
 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;
 }
 
 
 LInstruction* LChunkBuilder::DoCallFunction(HCallFunction* instr) {
   Abort("Unimplemented: %s", "DoCallFunction");
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoCallRuntime(HCallRuntime* instr) {
@@ skipping 275 matching lines @@
       ASSERT(to.IsDouble());
       return DefineAsRegister(new LInteger32ToDouble(Use(instr->value())));
     }
   }
   UNREACHABLE();
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoCheckNonSmi(HCheckNonSmi* instr) {
-  LOperand* value = UseRegisterAtStart(instr->value());
-  return AssignEnvironment(new LCheckSmi(value, zero));
+  Abort("Unimplemented: %s", "DoCheckNonSmi");
+  return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoCheckInstanceType(HCheckInstanceType* instr) {
   Abort("Unimplemented: %s", "DoCheckInstanceType");
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoCheckPrototypeMaps(HCheckPrototypeMaps* instr) {
   Abort("Unimplemented: %s", "DoCheckPrototypeMaps");
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoCheckSmi(HCheckSmi* instr) {
-  LOperand* value = UseRegisterAtStart(instr->value());
-  return AssignEnvironment(new LCheckSmi(value, not_zero));
+  Abort("Unimplemented: %s", "DoCheckSmi");
+  return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoCheckFunction(HCheckFunction* instr) {
   Abort("Unimplemented: %s", "DoCheckFunction");
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoCheckMap(HCheckMap* instr) {
-  LOperand* value = UseRegisterAtStart(instr->value());
-  LCheckMap* result = new LCheckMap(value);
-  return AssignEnvironment(result);
+  Abort("Unimplemented: %s", "DoCheckMap");
+  return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoReturn(HReturn* instr) {
   return new LReturn(UseFixed(instr->value(), rax));
 }
 
 
 LInstruction* LChunkBuilder::DoConstant(HConstant* instr) {
   Representation r = instr->representation();
   if (r.IsInteger32()) {
     int32_t value = instr->Integer32Value();
     return DefineAsRegister(new LConstantI(value));
   } else if (r.IsDouble()) {
     double value = instr->DoubleValue();
     LOperand* temp = TempRegister();
     return DefineAsRegister(new LConstantD(value, temp));
   } else if (r.IsTagged()) {
     return DefineAsRegister(new LConstantT(instr->handle()));
   } else {
     UNREACHABLE();
     return NULL;
   }
 }
 
 
 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;
 }
 
 
 LInstruction* LChunkBuilder::DoStoreGlobal(HStoreGlobal* instr) {
   Abort("Unimplemented: %s", "DoStoreGlobal");
   return NULL;
 }
 
 
 LInstruction* LChunkBuilder::DoLoadContextSlot(HLoadContextSlot* instr) {
@@ skipping 197 matching lines @@
 
 
 LInstruction* LChunkBuilder::DoLeaveInlined(HLeaveInlined* instr) {
   Abort("Unimplemented: %s", "DoLeaveInlined");
   return NULL;
 }
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_X64