Constant fold math and string operations.

src/hydrogen-instructions.h

 // Copyright 2012 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 2351 matching lines @@
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 
  private:
   virtual bool IsDeletable() const { return true; }
 };
 
 
 class HUnaryMathOperation: public HTemplateInstruction<2> {
  public:
   HUnaryMathOperation(HValue* context, HValue* value, BuiltinFunctionId op)

[Jakob Kummerow, 2013/02/20 15:31:04]

Since you're introducing a factory method below, you don't want this ctor to be
used any more, right? Please move it to the "private:" section.
Same for all other HInstructions where you introduced factory methods.

       : op_(op) {
     SetOperandAt(0, context);
     SetOperandAt(1, value);
     switch (op) {
       case kMathFloor:
       case kMathRound:
       case kMathCeil:
         set_representation(Representation::Integer32());
         break;
       case kMathAbs:
@@ skipping 12 matching lines @@
         break;
       case kMathExp:
         set_representation(Representation::Double());
         break;
       default:
         UNREACHABLE();
     }
     SetFlag(kUseGVN);
   }
 
+  static HInstruction* NewHUnaryMathOperation(

[Jakob Kummerow, 2013/02/20 15:31:04]

idea: You could shorten this to just "New", as it's uniquely identified by the
enclosing class anyway (call sites would be "... =
HUnaryMathOperation::New(...);"). I don't mind either way, though.

+      Zone* zone, HValue* context, HValue* value, BuiltinFunctionId op);
+
   HValue* context() { return OperandAt(0); }
   HValue* value() { return OperandAt(1); }
 
   virtual void PrintDataTo(StringStream* stream);
 
   virtual HType CalculateInferredType();
 
   virtual HValue* EnsureAndPropagateNotMinusZero(BitVector* visited);
 
   virtual Representation RequiredInputRepresentation(int index) {
     if (index == 0) {
       return Representation::Tagged();
     } else {
       switch (op_) {
         case kMathFloor:
         case kMathRound:
-        case kMathCeil:
         case kMathSqrt:
         case kMathPowHalf:
         case kMathLog:
         case kMathExp:
         case kMathSin:
         case kMathCos:
         case kMathTan:
           return Representation::Double();
         case kMathAbs:
           return representation();
@@ skipping 625 matching lines @@
     return double_value_;
   }
   bool HasNumberValue() const { return has_double_value_; }
   int32_t NumberValueAsInteger32() const {
     ASSERT(HasNumberValue());
     // Irrespective of whether a numeric HConstant can be safely
     // represented as an int32, we store the (in some cases lossy)
     // representation of the number in int32_value_.
     return int32_value_;
   }
+  bool HasStringValue() const {
+    if (has_double_value_ || has_int32_value_) return false;
+    ASSERT(!handle_.is_null());
+    return handle_->IsString();
+  }
+  Handle<String> StringValue() const {
+    ASSERT(HasStringValue());
+    return Handle<String>::cast(handle_);
+  }
 
   bool ToBoolean();
 
   bool IsUint32() {
     return HasInteger32Value() && (Integer32Value() >= 0);
   }
 
   virtual intptr_t Hashcode() {
     ASSERT_ALLOCATION_DISABLED;
     intptr_t hash;
@@ skipping 808 matching lines @@
 class HPower: public HTemplateInstruction<2> {
  public:
   HPower(HValue* left, HValue* right) {
     SetOperandAt(0, left);
     SetOperandAt(1, right);
     set_representation(Representation::Double());
     SetFlag(kUseGVN);
     SetGVNFlag(kChangesNewSpacePromotion);
   }
 
+  static HInstruction* NewHPower(
+      Zone* zone, HValue* left, HValue* right);
+
   HValue* left() { return OperandAt(0); }
   HValue* right() const { return OperandAt(1); }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return index == 0
       ? Representation::Double()
       : Representation::None();
   }
   virtual Representation observed_input_representation(int index) {
     return RequiredInputRepresentation(index);
@@ skipping 213 matching lines @@
 
 
 class HMathMinMax: public HArithmeticBinaryOperation {
  public:
   enum Operation { kMathMin, kMathMax };
 
   HMathMinMax(HValue* context, HValue* left, HValue* right, Operation op)
       : HArithmeticBinaryOperation(context, left, right),
         operation_(op) { }
 
+  static HInstruction* NewHMathMinMax(
+      Zone* zone, HValue* context, HValue* left, HValue* right, Operation op);
+
   virtual Representation RequiredInputRepresentation(int index) {
     return index == 0 ? Representation::Tagged()
                       : representation();
   }
 
   virtual Representation observed_input_representation(int index) {
     return RequiredInputRepresentation(index);
   }
 
   virtual void InferRepresentation(HInferRepresentation* h_infer);
@@ skipping 1257 matching lines @@
 class HStringAdd: public HBinaryOperation {
  public:
   HStringAdd(HValue* context, HValue* left, HValue* right)
       : HBinaryOperation(context, left, right) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetGVNFlag(kDependsOnMaps);
     SetGVNFlag(kChangesNewSpacePromotion);
   }
 
+  static HInstruction* NewHStringAdd(Zone* zone,
+                                     HValue* context,
+                                     HValue* left,
+                                     HValue* right);
+
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
   virtual HType CalculateInferredType() {
     return HType::String();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StringAdd)
 
@@ skipping 47 matching lines @@
 class HStringCharFromCode: public HTemplateInstruction<2> {
  public:
   HStringCharFromCode(HValue* context, HValue* char_code) {
     SetOperandAt(0, context);
     SetOperandAt(1, char_code);
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetGVNFlag(kChangesNewSpacePromotion);
   }
 
+  static HInstruction* NewHStringCharFromCode(
+      Zone* zone, HValue* context, HValue* char_code);
+
   virtual Representation RequiredInputRepresentation(int index) {
     return index == 0
         ? Representation::Tagged()
         : Representation::Integer32();
   }
   virtual HType CalculateInferredType();
 
   HValue* context() { return OperandAt(0); }
   HValue* value() { return OperandAt(1); }
 
   virtual bool DataEquals(HValue* other) { return true; }
 
   DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode)
 
   // TODO(svenpanne) Might be safe, but leave it out until we know for sure.
   // private:
   //  virtual bool IsDeletable() const { return true; }
 };
 
 
 class HStringLength: public HUnaryOperation {
  public:
   explicit HStringLength(HValue* string) : HUnaryOperation(string) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetGVNFlag(kDependsOnMaps);
   }
 
+  static HInstruction* NewHStringLength(Zone* zone, HValue* string);
+
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
   virtual HType CalculateInferredType() {
     STATIC_ASSERT(String::kMaxLength <= Smi::kMaxValue);
     return HType::Smi();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StringLength)
@@ skipping 522 matching lines @@
   virtual bool IsDeletable() const { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_