Cleanup unused lithium instructions.

src/ia32/lithium-ia32.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 1033 matching lines @@
   LGoto* result = new LGoto(instr->FirstSuccessor()->block_id(),
                             instr->include_stack_check());
   return (instr->include_stack_check())
       ? AssignPointerMap(result)
       : result;
 }
 
 
 LInstruction* LChunkBuilder::DoTest(HTest* instr) {
   HValue* v = instr->value();
-  if (!v->EmitAtUses()) {
-    return new LBranch(UseRegisterAtStart(v));
-  } else if (v->IsClassOfTest()) {
+  if (!v->EmitAtUses()) return new LBranch(UseRegisterAtStart(v));
+  ASSERT(!v->HasSideEffects());
+  if (v->IsClassOfTest()) {
     HClassOfTest* compare = HClassOfTest::cast(v);
     ASSERT(compare->value()->representation().IsTagged());
     return new LClassOfTestAndBranch(UseTempRegister(compare->value()),
                                      TempRegister(),
                                      TempRegister());
   } else if (v->IsCompare()) {
     HCompare* compare = HCompare::cast(v);
-    Token::Value op = compare->token();
     HValue* left = compare->left();
     HValue* right = compare->right();
     Representation r = compare->GetInputRepresentation();
     if (r.IsInteger32()) {
       ASSERT(left->representation().IsInteger32());
       ASSERT(right->representation().IsInteger32());
       return new LCmpIDAndBranch(UseRegisterAtStart(left),
                                  UseOrConstantAtStart(right));
-    } else if (r.IsDouble()) {
+    } else {
+      ASSERT(r.IsDouble());
       ASSERT(left->representation().IsDouble());
       ASSERT(right->representation().IsDouble());
       return new LCmpIDAndBranch(UseRegisterAtStart(left),
                                  UseRegisterAtStart(right));
-    } else {
-      ASSERT(left->representation().IsTagged());
-      ASSERT(right->representation().IsTagged());
-      bool reversed = op == Token::GT || op == Token::LTE;
-      LOperand* left_operand = UseFixed(left, reversed ? eax : edx);
-      LOperand* right_operand = UseFixed(right, reversed ? edx : eax);
-      LCmpTAndBranch* result = new LCmpTAndBranch(left_operand, right_operand);
-      return MarkAsCall(result, instr);
     }
   } else if (v->IsIsSmi()) {
     HIsSmi* compare = HIsSmi::cast(v);
     ASSERT(compare->value()->representation().IsTagged());
     return new LIsSmiAndBranch(Use(compare->value()));
   } else if (v->IsIsUndetectable()) {
     HIsUndetectable* compare = HIsUndetectable::cast(v);
     ASSERT(compare->value()->representation().IsTagged());
     return new LIsUndetectableAndBranch(UseRegisterAtStart(compare->value()),
                                         TempRegister());
@@ skipping 22 matching lines @@
                                   temp1,
                                   temp2);
   } else if (v->IsCompareJSObjectEq()) {
     HCompareJSObjectEq* compare = HCompareJSObjectEq::cast(v);
     return new LCmpJSObjectEqAndBranch(UseRegisterAtStart(compare->left()),
                                        UseRegisterAtStart(compare->right()));
   } else if (v->IsCompareSymbolEq()) {
     HCompareSymbolEq* compare = HCompareSymbolEq::cast(v);
     return new LCmpSymbolEqAndBranch(UseRegisterAtStart(compare->left()),
                                      UseRegisterAtStart(compare->right()));
-  } else if (v->IsInstanceOf()) {
-    HInstanceOf* instance_of = HInstanceOf::cast(v);
-    LOperand* left = UseFixed(instance_of->left(), InstanceofStub::left());
-    LOperand* right = UseFixed(instance_of->right(), InstanceofStub::right());
-    LOperand* context = UseFixed(instance_of->context(), esi);
-    LInstanceOfAndBranch* result =
-        new LInstanceOfAndBranch(context, left, right);
-    return MarkAsCall(result, instr);
   } else if (v->IsTypeofIs()) {
     HTypeofIs* typeof_is = HTypeofIs::cast(v);
     return new LTypeofIsAndBranch(UseTempRegister(typeof_is->value()));
   } else if (v->IsIsConstructCall()) {
     return new LIsConstructCallAndBranch(TempRegister());
   } else if (v->IsConstant()) {
     HBasicBlock* successor = HConstant::cast(v)->ToBoolean()
         ? instr->FirstSuccessor()
         : instr->SecondSuccessor();
     return new LGoto(successor->block_id());
@@ skipping 1150 matching lines @@
   LOperand* key = UseOrConstantAtStart(instr->key());
   LOperand* object = UseOrConstantAtStart(instr->object());
   LIn* result = new LIn(key, object);
   return MarkAsCall(DefineFixed(result, eax), instr);
 }
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_TARGET_ARCH_IA32