First step in refactoring hydrogen control instructions.

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 741 matching lines @@
   HInstruction* next_;
   HInstruction* previous_;
   int position_;
 
   friend class HBasicBlock;
 };
 
 
 class HControlInstruction: public HInstruction {
  public:
-  HControlInstruction(HBasicBlock* first, HBasicBlock* second)
-      : first_successor_(first), second_successor_(second) {
-  }
-
-  HBasicBlock* FirstSuccessor() const { return first_successor_; }
-  HBasicBlock* SecondSuccessor() const { return second_successor_; }
+  virtual HBasicBlock* SuccessorAt(int i) = 0;
+  virtual int SuccessorCount() = 0;
 
   virtual void PrintDataTo(StringStream* stream);
 
+  HBasicBlock* FirstSuccessor() {
+    return SuccessorCount() > 0 ? SuccessorAt(0) : NULL;
+  }
+  HBasicBlock* SecondSuccessor() {
+    return SuccessorCount() > 1 ? SuccessorAt(1) : NULL;
+  }
+
   DECLARE_ABSTRACT_INSTRUCTION(ControlInstruction)
-
- private:
-  HBasicBlock* first_successor_;
-  HBasicBlock* second_successor_;
 };
 
 
-template<int NumElements>
-class HOperandContainer {
+class HSuccessorIterator BASE_EMBEDDED {
  public:
-  HOperandContainer() : elems_() { }
+  explicit HSuccessorIterator(HControlInstruction* instr)
+      : instr_(instr), next_(0) { }
+
+  bool HasNext() { return next_ < instr_->SuccessorCount(); }
+  HBasicBlock* Next() { return instr_->SuccessorAt(next_); }
+  void Advance() { next_++; }
+
+ private:
+  HControlInstruction* instr_;
+  int next_;
+};
+
+
+template<typename T, int NumElements>

[Kevin Millikin (Chromium), 2011/05/25 15:50:28]

We have more or less this class "OperandContainer" in the lithium-xxx.h files,
and we also have "HOperandContainer" which is just specialized to HValue*.

You should just add an EmbeddedContainer class to utils.h, I think.

+class Container {
+ public:
+  Container() : elems_() { }
 
   int length() { return NumElements; }
-  HValue*& operator[](int i) {
+  T& operator[](int i) {
     ASSERT(i < length());
     return elems_[i];
   }
 
  private:
-  HValue* elems_[NumElements];
+  T elems_[NumElements];
 };
 
 
-template<>
-class HOperandContainer<0> {
+template<typename T>
+class Container<T, 0> {
  public:
   int length() { return 0; }
-  HValue*& operator[](int i) {
+  T& operator[](int i) {
     UNREACHABLE();
-    static HValue* t = 0;
+    static T t = 0;
     return t;
   }
 };
 
 
 template<int V>
 class HTemplateInstruction : public HInstruction {
  public:
   int OperandCount() { return V; }
   HValue* OperandAt(int i) { return inputs_[i]; }
 
  protected:
   void InternalSetOperandAt(int i, HValue* value) { inputs_[i] = value; }
 
  private:
-  HOperandContainer<V> inputs_;
+  Container<HValue*, V> inputs_;
 };
 
 
-template<int V>
+template<int S, int V>
 class HTemplateControlInstruction : public HControlInstruction {
  public:
-  HTemplateControlInstruction<V>(HBasicBlock* first, HBasicBlock* second)
-    : HControlInstruction(first, second) { }
   int OperandCount() { return V; }
   HValue* OperandAt(int i) { return inputs_[i]; }
 
+  int SuccessorCount() { return S; }
+  HBasicBlock* SuccessorAt(int i) { return successors_[i]; }
+
  protected:
   void InternalSetOperandAt(int i, HValue* value) { inputs_[i] = value; }
+  void SetSuccessorAt(int i, HBasicBlock* block) { successors_[i] = block; }
 
  private:
-  HOperandContainer<V> inputs_;
+  Container<HBasicBlock*, S> successors_;
+  Container<HValue*, V> inputs_;
 };
 
 
 class HBlockEntry: public HTemplateInstruction<0> {
  public:
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(BlockEntry)
 };
 
 
 class HDeoptimize: public HControlInstruction {
  public:
-  explicit HDeoptimize(int environment_length)
-      : HControlInstruction(NULL, NULL),
-        values_(environment_length) { }
+  explicit HDeoptimize(int environment_length) : values_(environment_length) { }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::None();
   }
 
   virtual int OperandCount() { return values_.length(); }
   virtual HValue* OperandAt(int index) { return values_[index]; }
 
+  virtual int SuccessorCount() { return 0; }
+  virtual HBasicBlock* SuccessorAt(int i) {
+    UNREACHABLE();
+    return NULL;
+  }
+
   void AddEnvironmentValue(HValue* value) {
     values_.Add(NULL);
     SetOperandAt(values_.length() - 1, value);
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Deoptimize)
 
   enum UseEnvironment {
     kNoUses,
     kUseAll
   };
 
  protected:
   virtual void InternalSetOperandAt(int index, HValue* value) {
     values_[index] = value;
   }
 
  private:
   ZoneList<HValue*> values_;
 };
 
 
-class HGoto: public HTemplateControlInstruction<0> {
+class HGoto: public HTemplateControlInstruction<1, 0> {
  public:
   explicit HGoto(HBasicBlock* target)
-      : HTemplateControlInstruction<0>(target, NULL),
-        include_stack_check_(false) { }
+      : include_stack_check_(false) {
+        SetSuccessorAt(0, target);
+      }
 
   void set_include_stack_check(bool include_stack_check) {
     include_stack_check_ = include_stack_check;
   }
   bool include_stack_check() const { return include_stack_check_; }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(Goto)
 
  private:
   bool include_stack_check_;
 };
 
 
-class HUnaryControlInstruction: public HTemplateControlInstruction<1> {
+class HUnaryControlInstruction: public HTemplateControlInstruction<2, 1> {
  public:
   explicit HUnaryControlInstruction(HValue* value,
                                     HBasicBlock* true_target,
-                                    HBasicBlock* false_target)
-      : HTemplateControlInstruction<1>(true_target, false_target) {
+                                    HBasicBlock* false_target) {
     SetOperandAt(0, value);
+    SetSuccessorAt(0, true_target);
+    SetSuccessorAt(1, false_target);
   }
 
   virtual void PrintDataTo(StringStream* stream);
 
   HValue* value() { return OperandAt(0); }
 };
 
 
 class HTest: public HUnaryControlInstruction {
  public:
@@ skipping 31 matching lines @@
     return Representation::Tagged();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(CompareMap)
 
  private:
   Handle<Map> map_;
 };
 
 
-class HReturn: public HUnaryControlInstruction {
+class HReturn: public HTemplateControlInstruction<0, 1> {
  public:
-  explicit HReturn(HValue* value)
-      : HUnaryControlInstruction(value, NULL, NULL) {
+  explicit HReturn(HValue* value) {
+    SetOperandAt(0, value);
   }
 
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::Tagged();
   }
 
+  HValue* value() { return OperandAt(0); }
+
   DECLARE_CONCRETE_INSTRUCTION(Return)
 };
 
 
-class HAbnormalExit: public HTemplateControlInstruction<0> {
+class HAbnormalExit: public HTemplateControlInstruction<0, 0> {
  public:
-  HAbnormalExit() : HTemplateControlInstruction<0>(NULL, NULL) { }
-
   virtual Representation RequiredInputRepresentation(int index) const {
     return Representation::None();
   }
 
   DECLARE_CONCRETE_INSTRUCTION(AbnormalExit)
 };
 
 
 class HUnaryOperation: public HTemplateInstruction<1> {
  public:
@@ skipping 2972 matching lines @@
 
   DECLARE_CONCRETE_INSTRUCTION(In)
 };
 
 #undef DECLARE_INSTRUCTION
 #undef DECLARE_CONCRETE_INSTRUCTION
 
 } }  // namespace v8::internal
 
 #endif  // V8_HYDROGEN_INSTRUCTIONS_H_