Improve GVN dependency tracking by adding parameters to certain flags.

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 143 matching lines @@
   V(StringLength)                              \
   V(Sub)                                       \
   V(Test)                                      \
   V(Throw)                                     \
   V(Typeof)                                    \
   V(TypeofIs)                                  \
   V(UnaryMathOperation)                        \
   V(UnknownOSRValue)                           \
   V(ValueOf)
 
+// The list of GVN flags. To improve memory usage it should start with
+// the flags that allow parameters.
 #define GVN_FLAG_LIST(V)                       \
-  V(Calls)                                     \
   V(InobjectFields)                            \
   V(BackingStoreFields)                        \
+  V(GlobalVars)                                \
+  V(ContextSlots)                              \
+  V(Calls)                                     \
   V(ArrayElements)                             \
   V(PixelArrayElements)                        \
-  V(GlobalVars)                                \
   V(Maps)                                      \
   V(ArrayLengths)                              \
-  V(ContextSlots)                              \
   V(OsrEntries)
 
 #define DECLARE_INSTRUCTION(type)                   \
   virtual bool Is##type() const { return true; }    \
   static H##type* cast(HValue* value) {             \
     ASSERT(value->Is##type());                      \
     return reinterpret_cast<H##type*>(value);       \
   }                                                 \
   Opcode opcode() const { return HValue::k##type; }
 
@@ skipping 217 matching lines @@
   // There must be one corresponding kDepends flag for every kChanges flag and
   // the order of the kChanges flags must be exactly the same as of the kDepends
   // flags.
   enum Flag {
     // Declare global value numbering flags.
   #define DECLARE_DO(type) kChanges##type, kDependsOn##type,
     GVN_FLAG_LIST(DECLARE_DO)
   #undef DECLARE_DO
     kFlexibleRepresentation,
     kUseGVN,
+    kHasGVNParameter,
     kCanOverflow,
     kBailoutOnMinusZero,
     kCanBeDivByZero,
     kIsArguments,
     kTruncatingToInt32,
+    kFirstNonGVNFlag = kFlexibleRepresentation,
     kLastFlag = kTruncatingToInt32
   };
 
   STATIC_ASSERT(kLastFlag < kBitsPerInt);
 
   static const int kChangesToDependsFlagsLeftShift = 1;
 
   static int ChangesFlagsMask() {
     int result = 0;
     // Create changes mask.
 #define DECLARE_DO(type) result |= (1 << kChanges##type);
   GVN_FLAG_LIST(DECLARE_DO)
 #undef DECLARE_DO
     return result;
   }
 
   static int DependsFlagsMask() {
     return ConvertChangesToDependsFlags(ChangesFlagsMask());
   }
 
   static int ConvertChangesToDependsFlags(int flags) {
     return flags << kChangesToDependsFlagsLeftShift;
   }
+  static int ConvertDependsToChangesFlags(int flags) {
+    return flags >> kChangesToDependsFlagsLeftShift;
+  }
 
   static HValue* cast(HValue* value) { return value; }
 
   enum Opcode {
     // Declare a unique enum value for each hydrogen instruction.
   #define DECLARE_DO(type) k##type,
     HYDROGEN_ALL_INSTRUCTION_LIST(DECLARE_DO)
   #undef DECLARE_DO
     kMaxInstructionClass
   };
@@ skipping 93 matching lines @@
   virtual HValue* Canonicalize() { return this; }
 
   // Declare virtual type testers.
 #define DECLARE_DO(type) virtual bool Is##type() const { return false; }
   HYDROGEN_ALL_INSTRUCTION_LIST(DECLARE_DO)
 #undef DECLARE_DO
 
   bool Equals(HValue* other);
   virtual intptr_t Hashcode();
 
+  virtual intptr_t GetGVNParameter() {
+    UNREACHABLE();
+    return 0;
+  }
+
   // Printing support.
   virtual void PrintTo(StringStream* stream) = 0;
   void PrintNameTo(StringStream* stream);
   static void PrintTypeTo(HType type, StringStream* stream);
 
   virtual const char* Mnemonic() const = 0;
   virtual Opcode opcode() const = 0;
 
   // Updated the inferred type of this instruction and returns true if
   // it has changed.
@@ skipping 2212 matching lines @@
 };
 
 
 class HLoadGlobal: public HTemplateInstruction<0> {
  public:
   HLoadGlobal(Handle<JSGlobalPropertyCell> cell, bool check_hole_value)
       : cell_(cell), check_hole_value_(check_hole_value) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetFlag(kDependsOnGlobalVars);
+    SetFlag(kHasGVNParameter);
+  }
+
+  virtual intptr_t GetGVNParameter() {
+    return reinterpret_cast<intptr_t>(*cell_);
   }
 
   Handle<JSGlobalPropertyCell>  cell() const { return cell_; }
   bool check_hole_value() const { return check_hole_value_; }
 
   virtual void PrintDataTo(StringStream* stream);
 
   virtual intptr_t Hashcode() {
     ASSERT(!Heap::allow_allocation(false));
     return reinterpret_cast<intptr_t>(*cell_);
@@ skipping 19 matching lines @@
 
 class HStoreGlobal: public HUnaryOperation {
  public:
   HStoreGlobal(HValue* value,
                Handle<JSGlobalPropertyCell> cell,
                bool check_hole_value)
       : HUnaryOperation(value),
         cell_(cell),
         check_hole_value_(check_hole_value) {
     SetFlag(kChangesGlobalVars);
+    SetFlag(kHasGVNParameter);
+  }
+
+  virtual intptr_t GetGVNParameter() {
+    return reinterpret_cast<intptr_t>(*cell_);
   }
 
   Handle<JSGlobalPropertyCell> cell() const { return cell_; }
   bool check_hole_value() const { return check_hole_value_; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
   virtual void PrintDataTo(StringStream* stream);
 
   DECLARE_CONCRETE_INSTRUCTION(StoreGlobal, "store_global")
 
  private:
   Handle<JSGlobalPropertyCell> cell_;
   bool check_hole_value_;
 };
 
 
 class HLoadContextSlot: public HUnaryOperation {
  public:
   HLoadContextSlot(HValue* context , int slot_index)
       : HUnaryOperation(context), slot_index_(slot_index) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     SetFlag(kDependsOnContextSlots);
+    SetFlag(kHasGVNParameter);
   }
 
+  virtual intptr_t GetGVNParameter() { return slot_index_; }
+
   int slot_index() const { return slot_index_; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
   DECLARE_CONCRETE_INSTRUCTION(LoadContextSlot, "load_context_slot")
 
@@ skipping 12 matching lines @@
   return !value->type().IsSmi() &&
       !(value->IsConstant() && HConstant::cast(value)->InOldSpace());
 }
 
 
 class HStoreContextSlot: public HBinaryOperation {
  public:
   HStoreContextSlot(HValue* context, int slot_index, HValue* value)
       : HBinaryOperation(context, value), slot_index_(slot_index) {
     SetFlag(kChangesContextSlots);
+    SetFlag(kHasGVNParameter);
   }
 
+  virtual intptr_t GetGVNParameter() { return slot_index_; }
+
   HValue* context() { return OperandAt(0); }
   HValue* value() { return OperandAt(1); }
   int slot_index() const { return slot_index_; }
 
   bool NeedsWriteBarrier() {
     return StoringValueNeedsWriteBarrier(value());
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
@@ skipping 14 matching lines @@
       : HUnaryOperation(object),
         is_in_object_(is_in_object),
         offset_(offset) {
     set_representation(Representation::Tagged());
     SetFlag(kUseGVN);
     if (is_in_object) {
       SetFlag(kDependsOnInobjectFields);
     } else {
       SetFlag(kDependsOnBackingStoreFields);
     }
+    SetFlag(kHasGVNParameter);
+  }
+
+  virtual intptr_t GetGVNParameter() {
+    return (offset_ << 1) || (is_in_object_ ? 1 : 0);

[fschneider, 2011/03/16 15:43:28]

Shouldn't be this bitwise-or "|"?

   }
 
   HValue* object() { return OperandAt(0); }
   bool is_in_object() const { return is_in_object_; }
   int offset() const { return offset_; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
   virtual void PrintDataTo(StringStream* stream);
@@ skipping 148 matching lines @@
                    int offset)
       : HBinaryOperation(obj, val),
         name_(name),
         is_in_object_(in_object),
         offset_(offset) {
     if (is_in_object_) {
       SetFlag(kChangesInobjectFields);
     } else {
       SetFlag(kChangesBackingStoreFields);
     }
+    SetFlag(kHasGVNParameter);
+  }
+
+  virtual intptr_t GetGVNParameter() {
+    return (offset_ << 1) || (is_in_object_ ? 1 : 0);

[fschneider, 2011/03/16 15:43:28]

-> use "|" here as well.

   }
 
   DECLARE_CONCRETE_INSTRUCTION(StoreNamedField, "store_named_field")
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
   virtual void PrintDataTo(StringStream* stream);
 
   HValue* object() { return OperandAt(0); }
   HValue* value() { return OperandAt(1); }
 
   Handle<String> name() const { return name_; }
   bool is_in_object() const { return is_in_object_; }
   int offset() const { return offset_; }
   Handle<Map> transition() const { return transition_; }
-  void set_transition(Handle<Map> map) { transition_ = map; }
+  void SetTransition(Handle<Map> map) {
+    transition_ = map;
+    // TODO(fschneider): Record the new map type of the object in the IR to
+    // enable elimination of redundant checks after the transition store.
+    SetFlag(kChangesMaps);
+    // TODO(vitalyr): GVN parameter is only supported for instructions
+    // that have a single GVN flag.
+    ClearFlag(kHasGVNParameter);
+  }
 
   bool NeedsWriteBarrier() {
     return StoringValueNeedsWriteBarrier(value());
   }
 
  private:
   Handle<String> name_;
   bool is_in_object_;
   int offset_;
   Handle<Map> transition_;
@@ skipping 338 matching lines @@
   HValue* object() { return left(); }
   HValue* key() { return right(); }
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_