Avoid the use of set_type() in instruction constructors.

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 1434 matching lines @@
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(BlockEntry)
 };
 
 
 class HDummyUse: public HTemplateInstruction<1> {
  public:
-  explicit HDummyUse(HValue* value) {
+  explicit HDummyUse(HValue* value)
+      : HTemplateInstruction<1>(HType::Smi()) {
     SetOperandAt(0, value);
     // Pretend to be a Smi so that the HChange instructions inserted
     // before any use generate as little code as possible.
     set_representation(Representation::Tagged());
-    set_type(HType::Smi());
   }
 
   HValue* value() { return OperandAt(0); }
 
   virtual bool HasEscapingOperandAt(int index) { return false; }
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::None();
   }
 
   virtual void PrintDataTo(StringStream* stream);
@@ skipping 188 matching lines @@
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(AbnormalExit)
 };
 
 
 class HUnaryOperation: public HTemplateInstruction<1> {
  public:
-  explicit HUnaryOperation(HValue* value) {
+  HUnaryOperation(HValue* value, HType type = HType::Tagged())
+      : HTemplateInstruction<1>(type) {
     SetOperandAt(0, value);
   }
 
   static HUnaryOperation* cast(HValue* value) {
     return reinterpret_cast<HUnaryOperation*>(value);
   }
 
   HValue* value() const { return OperandAt(0); }
   virtual void PrintDataTo(StringStream* stream);
 };
@@ skipping 824 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(CallRuntime)
 
  private:
   const Runtime::Function* c_function_;
   Handle<String> name_;
 };
 
 
 class HMapEnumLength: public HUnaryOperation {
  public:
-  explicit HMapEnumLength(HValue* value) : HUnaryOperation(value) {
-    set_type(HType::Smi());
+  explicit HMapEnumLength(HValue* value)
+      : HUnaryOperation(value, HType::Smi()) {
     set_representation(Representation::Smi());
     SetFlag(kUseGVN);
     SetGVNFlag(kDependsOnMaps);
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(MapEnumLength)
@@ skipping 23 matching lines @@
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 
  private:
   virtual bool IsDeletable() const { return true; }
 };
 
 
 class HBitNot: public HUnaryOperation {
  public:
-  explicit HBitNot(HValue* value) : HUnaryOperation(value) {
+  explicit HBitNot(HValue* value)
+      : HUnaryOperation(value, HType::TaggedNumber()) {
     set_representation(Representation::Integer32());
     SetFlag(kUseGVN);
     SetFlag(kTruncatingToInt32);
     SetFlag(kAllowUndefinedAsNaN);
-    set_type(HType::TaggedNumber());
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Integer32();
   }
   virtual Representation observed_input_representation(int index) {
     return Representation::Integer32();
   }
 
   virtual HValue* Canonicalize();
@@ skipping 57 matching lines @@
   DECLARE_CONCRETE_INSTRUCTION(UnaryMathOperation)
 
  protected:
   virtual bool DataEquals(HValue* other) {
     HUnaryMathOperation* b = HUnaryMathOperation::cast(other);
     return op_ == b->op();
   }
 
  private:
   HUnaryMathOperation(HValue* context, HValue* value, BuiltinFunctionId op)
-      : op_(op) {
+      : HTemplateInstruction<2>(HType::TaggedNumber()), op_(op) {
     SetOperandAt(0, context);
     SetOperandAt(1, value);
     switch (op) {
       case kMathFloor:
       case kMathRound:
         // TODO(verwaest): Set representation to flexible int starting as smi.
         set_representation(Representation::Integer32());
         break;
       case kMathAbs:
         // Not setting representation here: it is None intentionally.
@@ skipping 13 matching lines @@
       case kMathExp:
       case kMathSqrt:
       case kMathPowHalf:
         set_representation(Representation::Double());
         break;
       default:
         UNREACHABLE();
     }
     SetFlag(kUseGVN);
     SetFlag(kAllowUndefinedAsNaN);
-    set_type(HType::TaggedNumber());
   }
 
   virtual bool IsDeletable() const { return true; }
 
   BuiltinFunctionId op_;
 };
 
 
 class HLoadExternalArrayPointer: public HUnaryOperation {
  public:
@@ skipping 71 matching lines @@
       if (map_unique_ids_.at(i) != b->map_unique_ids_.at(i)) {
         return false;
       }
     }
     return true;
   }
 
  private:
   // Clients should use one of the static New* methods above.
   HCheckMaps(HValue* value, Zone *zone, HValue* typecheck)
-      : omit_(false), map_unique_ids_(0, zone) {
+      : HTemplateInstruction<2>(value->type()),
+        omit_(false), map_unique_ids_(0, zone) {
     SetOperandAt(0, value);
     // Use the object value for the dependency if NULL is passed.
     // TODO(titzer): do GVN flags already express this dependency?
     SetOperandAt(1, typecheck != NULL ? typecheck : value);
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetFlag(kTrackSideEffectDominators);
     SetGVNFlag(kDependsOnMaps);
     SetGVNFlag(kDependsOnElementsKind);
-    set_type(value->type());
   }
 
   void omit(CompilationInfo* info) {
     omit_ = true;
     for (int i = 0; i < map_set_.length(); i++) {
       Handle<Map> map = map_set_.at(i);
       map->AddDependentCompilationInfo(DependentCode::kPrototypeCheckGroup,
                                        info);
     }
   }
 
   bool omit_;
   SmallMapList map_set_;
   ZoneList<UniqueValueId> map_unique_ids_;
 };
 
 
 class HCheckFunction: public HUnaryOperation {
  public:
   HCheckFunction(HValue* value, Handle<JSFunction> function)
-      : HUnaryOperation(value), target_(function), target_unique_id_() {
+      : HUnaryOperation(value, value->type()),
+        target_(function), target_unique_id_() {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     target_in_new_space_ = Isolate::Current()->heap()->InNewSpace(*function);
-    set_type(value->type());
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
   virtual void PrintDataTo(StringStream* stream);
 
   virtual HValue* Canonicalize();
 
 #ifdef DEBUG
@@ skipping 77 matching lines @@
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
   }
 
   const Check check_;
 };
 
 
 class HCheckSmi: public HUnaryOperation {
  public:
-  explicit HCheckSmi(HValue* value) : HUnaryOperation(value) {
+  explicit HCheckSmi(HValue* value) : HUnaryOperation(value, HType::Smi()) {
     set_representation(Representation::Smi());
     SetFlag(kUseGVN);
-    set_type(HType::Smi());
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
   virtual HValue* Canonicalize() {
     HType value_type = value()->type();
     if (value_type.IsSmi()) {
       return NULL;
@@ skipping 18 matching lines @@
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(IsNumberAndBranch)
 };
 
 
 class HCheckHeapObject: public HUnaryOperation {
  public:
-  explicit HCheckHeapObject(HValue* value) : HUnaryOperation(value) {
+  explicit HCheckHeapObject(HValue* value)
+      : HUnaryOperation(value, HType::NonPrimitive()) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
-    set_type(HType::NonPrimitive());
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
 #ifdef DEBUG
   virtual void Verify();
 #endif
 
@@ skipping 734 matching lines @@
   bool is_cell_ : 1;
   bool boolean_value_ : 1;
   int32_t int32_value_;
   double double_value_;
   ExternalReference external_reference_value_;
 };
 
 
 class HBinaryOperation: public HTemplateInstruction<3> {
  public:
-  HBinaryOperation(HValue* context, HValue* left, HValue* right)
-      : observed_output_representation_(Representation::None()) {
+  HBinaryOperation(HValue* context, HValue* left, HValue* right,
+                   HType type = HType::Tagged())
+      : HTemplateInstruction<3>(type),
+        observed_output_representation_(Representation::None()) {
     ASSERT(left != NULL && right != NULL);
     SetOperandAt(0, context);
     SetOperandAt(1, left);
     SetOperandAt(2, right);
     observed_input_representation_[0] = Representation::None();
     observed_input_representation_[1] = Representation::None();
   }
 
   HValue* context() const { return OperandAt(0); }
   HValue* left() const { return OperandAt(1); }
@@ skipping 330 matching lines @@
     bounds_check()->SetResponsibilityForRange(direction);
   }
   virtual void TryGuaranteeRangeChanging(RangeEvaluationContext* context) {
     bounds_check()->TryGuaranteeRangeChanging(context);
   }
 };
 
 
 class HBitwiseBinaryOperation: public HBinaryOperation {
  public:
-  HBitwiseBinaryOperation(HValue* context, HValue* left, HValue* right)
-      : HBinaryOperation(context, left, right) {
+  HBitwiseBinaryOperation(HValue* context, HValue* left, HValue* right,
+                          HType type = HType::Tagged())
+      : HBinaryOperation(context, left, right, type) {
     SetFlag(kFlexibleRepresentation);
     SetFlag(kTruncatingToInt32);
     SetFlag(kAllowUndefinedAsNaN);
     SetAllSideEffects();
   }
 
   virtual void RepresentationChanged(Representation to) {
     if (!to.IsTagged()) {
       ASSERT(to.IsSmiOrInteger32());
       ClearAllSideEffects();
@@ skipping 55 matching lines @@
   virtual bool DataEquals(HValue* other) { return true; }
 
  private:
   virtual bool IsDeletable() const { return true; }
 };
 
 
 class HArithmeticBinaryOperation: public HBinaryOperation {
  public:
   HArithmeticBinaryOperation(HValue* context, HValue* left, HValue* right)
-      : HBinaryOperation(context, left, right) {
+      : HBinaryOperation(context, left, right, HType::TaggedNumber()) {
     SetAllSideEffects();
     SetFlag(kFlexibleRepresentation);
     SetFlag(kAllowUndefinedAsNaN);
-    set_type(HType::TaggedNumber());
   }
 
   virtual void RepresentationChanged(Representation to) {
     if (to.IsTagged()) {
       SetAllSideEffects();
       ClearFlag(kUseGVN);
     } else {
       ClearAllSideEffects();
       SetFlag(kUseGVN);
     }
   }
 
   DECLARE_ABSTRACT_INSTRUCTION(ArithmeticBinaryOperation)
 
  private:
   virtual bool IsDeletable() const { return true; }
 };
 
 
 class HCompareGeneric: public HBinaryOperation {
  public:
   HCompareGeneric(HValue* context,
                   HValue* left,
                   HValue* right,
                   Token::Value token)
-      : HBinaryOperation(context, left, right), token_(token) {
+      : HBinaryOperation(context, left, right, HType::Boolean()),
+        token_(token) {
     ASSERT(Token::IsCompareOp(token));
     set_representation(Representation::Tagged());
-    set_type(HType::Boolean());
     SetAllSideEffects();
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return index == 0
         ? Representation::Tagged()
         : representation();
   }
 
   Token::Value token() const { return token_; }
@@ skipping 267 matching lines @@
   }
 
  private:
   Handle<String> type_literal_;
 };
 
 
 class HInstanceOf: public HBinaryOperation {
  public:
   HInstanceOf(HValue* context, HValue* left, HValue* right)
-      : HBinaryOperation(context, left, right) {
+      : HBinaryOperation(context, left, right, HType::Boolean()) {
     set_representation(Representation::Tagged());
-    set_type(HType::Boolean());
     SetAllSideEffects();
   }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
   DECLARE_CONCRETE_INSTRUCTION(InstanceOf)
 };
 
 
 class HInstanceOfKnownGlobal: public HTemplateInstruction<2> {
  public:
   HInstanceOfKnownGlobal(HValue* context,
                          HValue* left,
                          Handle<JSFunction> right)
-      : function_(right) {
+      : HTemplateInstruction<2>(HType::Boolean()), function_(right) {
     SetOperandAt(0, context);
     SetOperandAt(1, left);
-    set_type(HType::Boolean());
     set_representation(Representation::Tagged());
     SetAllSideEffects();
   }
 
   HValue* context() { return OperandAt(0); }
   HValue* left() { return OperandAt(1); }
   Handle<JSFunction> function() { return function_; }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
@@ skipping 380 matching lines @@
 
  protected:
   virtual bool DataEquals(HValue* other) {
     return op() == HBitwise::cast(other)->op();
   }
 
   virtual Range* InferRange(Zone* zone);
 
  private:
   HBitwise(Token::Value op, HValue* context, HValue* left, HValue* right)
-      : HBitwiseBinaryOperation(context, left, right), op_(op) {
+      : HBitwiseBinaryOperation(context, left, right, HType::TaggedNumber()),
+        op_(op) {
     ASSERT(op == Token::BIT_AND || op == Token::BIT_OR || op == Token::BIT_XOR);
     // BIT_AND with a smi-range positive value will always unset the
     // entire sign-extension of the smi-sign.
     if (op == Token::BIT_AND &&
         ((left->IsConstant() &&
           left->representation().IsSmi() &&
           HConstant::cast(left)->Integer32Value() >= 0) ||
          (right->IsConstant() &&
           right->representation().IsSmi() &&
           HConstant::cast(right)->Integer32Value() >= 0))) {
       SetFlag(kTruncatingToSmi);
     // BIT_OR with a smi-range negative value will always set the entire
     // sign-extension of the smi-sign.
     } else if (op == Token::BIT_OR &&
         ((left->IsConstant() &&
           left->representation().IsSmi() &&
           HConstant::cast(left)->Integer32Value() < 0) ||
          (right->IsConstant() &&
           right->representation().IsSmi() &&
           HConstant::cast(right)->Integer32Value() < 0))) {
       SetFlag(kTruncatingToSmi);
     }
-    set_type(HType::TaggedNumber());
   }
 
   Token::Value op_;
 };
 
 
 class HShl: public HBitwiseBinaryOperation {
  public:
   static HInstruction* New(Zone* zone,
                            HValue* context,
@@ skipping 321 matching lines @@
   bool for_typeof_;
 };
 
 
 class HAllocate: public HTemplateInstruction<2> {
  public:
   HAllocate(HValue* context,
             HValue* size,
             HType type,
             bool pretenure,
-            ElementsKind kind = FAST_ELEMENTS) {
+            ElementsKind kind = FAST_ELEMENTS)
+      : HTemplateInstruction<2>(type) {
     SetOperandAt(0, context);
     SetOperandAt(1, size);
-    set_type(type);
     set_representation(Representation::Tagged());
     SetFlag(kTrackSideEffectDominators);
     SetGVNFlag(kChangesNewSpacePromotion);
     SetGVNFlag(kDependsOnNewSpacePromotion);
     if (pretenure) {
       if (IsFastDoubleElementsKind(kind)) {
         flags_ = static_cast<HAllocate::Flags>(ALLOCATE_IN_OLD_DATA_SPACE |
              ALLOCATE_DOUBLE_ALIGNED);
       } else {
         flags_ = ALLOCATE_IN_OLD_POINTER_SPACE;
@@ skipping 78 matching lines @@
   };
 
   Flags flags_;
   Handle<Map> known_initial_map_;
 };
 
 
 class HInnerAllocatedObject: public HTemplateInstruction<1> {
  public:
   HInnerAllocatedObject(HValue* value, int offset, HType type = HType::Tagged())
-      : offset_(offset) {
+      : HTemplateInstruction<1>(type), offset_(offset) {
     ASSERT(value->IsAllocate());
     SetOperandAt(0, value);
-    set_type(type);
     set_representation(Representation::Tagged());
   }
 
   HValue* base_object() { return OperandAt(0); }
   int offset() { return offset_; }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
@@ skipping 1145 matching lines @@
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StringAdd)
 
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 
  private:
   HStringAdd(HValue* context, HValue* left, HValue* right, StringAddFlags flags)
-      : HBinaryOperation(context, left, right), flags_(flags) {
+      : HBinaryOperation(context, left, right, HType::String()), flags_(flags) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetGVNFlag(kDependsOnMaps);
     SetGVNFlag(kChangesNewSpacePromotion);
-    set_type(HType::String());
   }
 
   // No side-effects except possible allocation.
   // NOTE: this instruction _does not_ call ToString() on its inputs.
   virtual bool IsDeletable() const { return true; }
 
   const StringAddFlags flags_;
 };
 
 
@@ skipping 48 matching lines @@
   }
 
   HValue* context() const { return OperandAt(0); }
   HValue* value() const { return OperandAt(1); }
 
   virtual bool DataEquals(HValue* other) { return true; }
 
   DECLARE_CONCRETE_INSTRUCTION(StringCharFromCode)
 
  private:
-  HStringCharFromCode(HValue* context, HValue* char_code) {
+  HStringCharFromCode(HValue* context, HValue* char_code)
+      : HTemplateInstruction<2>(HType::String()) {
     SetOperandAt(0, context);
     SetOperandAt(1, char_code);
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetGVNFlag(kChangesNewSpacePromotion);
-    set_type(HType::String());
   }
 
   virtual bool IsDeletable() const {
     return !value()->ToNumberCanBeObserved();
   }
 };
 
 
 class HStringLength: public HUnaryOperation {
  public:
   static HInstruction* New(Zone* zone, HValue* string);
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(StringLength)
 
  protected:
   virtual bool DataEquals(HValue* other) { return true; }
 
   virtual Range* InferRange(Zone* zone) {
     return new(zone) Range(0, String::kMaxLength);
   }
 
  private:
-  explicit HStringLength(HValue* string) : HUnaryOperation(string) {
+  explicit HStringLength(HValue* string)
+      : HUnaryOperation(string, HType::Smi()) {
     STATIC_ASSERT(String::kMaxLength <= Smi::kMaxValue);
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetGVNFlag(kDependsOnMaps);
-    set_type(HType::Smi());
   }
 
   virtual bool IsDeletable() const { return true; }
 };
 
 
 template <int V>
 class HMaterializedLiteral: public HTemplateInstruction<V> {
  public:
   HMaterializedLiteral<V>(int index, int depth, AllocationSiteMode mode)
@@ skipping 54 matching lines @@
   Handle<String> pattern_;
   Handle<String> flags_;
 };
 
 
 class HFunctionLiteral: public HTemplateInstruction<1> {
  public:
   HFunctionLiteral(HValue* context,
                    Handle<SharedFunctionInfo> shared,
                    bool pretenure)
-      : shared_info_(shared),
+      : HTemplateInstruction<1>(HType::JSObject()),
+        shared_info_(shared),
         pretenure_(pretenure),
         has_no_literals_(shared->num_literals() == 0),
         is_generator_(shared->is_generator()),
         language_mode_(shared->language_mode()) {
     SetOperandAt(0, context);
-    set_type(HType::JSObject());
     set_representation(Representation::Tagged());
     SetGVNFlag(kChangesNewSpacePromotion);
   }
 
   HValue* context() { return OperandAt(0); }
 
   virtual Representation RequiredInputRepresentation(int index) {
     return Representation::Tagged();
   }
 
@@ skipping 277 matching lines @@
   virtual bool IsDeletable() const { return true; }
 };
 
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_