Move swapping of operands for commutative binary operations to the lithium IR...

src/hydrogen-instructions.h

 // 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 1853 matching lines @@
  public:
   HBinaryOperation(HValue* left, HValue* right) {
     ASSERT(left != NULL && right != NULL);
     SetOperandAt(0, left);
     SetOperandAt(1, right);
   }
 
   HValue* left() const { return OperandAt(0); }
   HValue* right() const { return OperandAt(1); }
 
-  // TODO(kasperl): Move these helpers to the IA-32 Lithium
-  // instruction sequence builder.
-  HValue* LeastConstantOperand() const {
-    if (IsCommutative() && left()->IsConstant()) return right();
-    return left();
-  }
-  HValue* MostConstantOperand() const {
-    if (IsCommutative() && left()->IsConstant()) return left();
-    return right();
-  }
-
-  virtual bool IsCommutative() const { return false; }
-
   virtual void PrintDataTo(StringStream* stream) const;
   virtual int OperandCount() const { return operands_.length(); }
   virtual HValue* OperandAt(int index) const { return operands_[index]; }
 
   DECLARE_INSTRUCTION(BinaryOperation)
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     operands_[index] = value;
   }
@@ skipping 431 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(Power, "power")
 };
 
 
 class HAdd: public HArithmeticBinaryOperation {
  public:
   HAdd(HValue* left, HValue* right) : HArithmeticBinaryOperation(left, right) {
     SetFlag(kCanOverflow);
   }
 
-  // Add is only commutative if two integer values are added and not if two
-  // tagged values are added (because it might be a String concatenation).
-  virtual bool IsCommutative() const {
-    return !representation().IsTagged();
-  }
-
   virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
 
   virtual HType CalculateInferredType() const;
 
   DECLARE_CONCRETE_INSTRUCTION(Add, "add")
 
  protected:
   virtual Range* InferRange();
 };
 
@@ skipping 14 matching lines @@
 
 
 class HMul: public HArithmeticBinaryOperation {
  public:
   HMul(HValue* left, HValue* right) : HArithmeticBinaryOperation(left, right) {
     SetFlag(kCanOverflow);
   }
 
   virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
 
-  // Only commutative if it is certain that not two objects are multiplicated.
-  virtual bool IsCommutative() const {
-    return !representation().IsTagged();
-  }
-
   DECLARE_CONCRETE_INSTRUCTION(Mul, "mul")
 
  protected:
   virtual Range* InferRange();
 };
 
 
 class HMod: public HArithmeticBinaryOperation {
  public:
   HMod(HValue* left, HValue* right) : HArithmeticBinaryOperation(left, right) {
@@ skipping 23 matching lines @@
  protected:
   virtual Range* InferRange();
 };
 
 
 class HBitAnd: public HBitwiseBinaryOperation {
  public:
   HBitAnd(HValue* left, HValue* right)
       : HBitwiseBinaryOperation(left, right) { }
 
-  virtual bool IsCommutative() const { return true; }
   virtual HType CalculateInferredType() const;
 
   DECLARE_CONCRETE_INSTRUCTION(BitAnd, "bit_and")
 
  protected:
   virtual Range* InferRange();
 };
 
 
 class HBitXor: public HBitwiseBinaryOperation {
  public:
   HBitXor(HValue* left, HValue* right)
       : HBitwiseBinaryOperation(left, right) { }
 
-  virtual bool IsCommutative() const { return true; }
   virtual HType CalculateInferredType() const;
 
   DECLARE_CONCRETE_INSTRUCTION(BitXor, "bit_xor")
 };
 
 
 class HBitOr: public HBitwiseBinaryOperation {
  public:
   HBitOr(HValue* left, HValue* right)
       : HBitwiseBinaryOperation(left, right) { }
 
-  virtual bool IsCommutative() const { return true; }
   virtual HType CalculateInferredType() const;
 
   DECLARE_CONCRETE_INSTRUCTION(BitOr, "bit_or")
 
  protected:
   virtual Range* InferRange();
 };
 
 
 class HShl: public HBitwiseBinaryOperation {
@@ skipping 676 matching lines @@
   HValue* object() const { return left(); }
   HValue* key() const { return right(); }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_