Factored out common Instruction code in the CFG builder that depends only...

src/cfg.h

 // Copyright 2009 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 289 matching lines @@
   }
 
   // Cast accessor.
   static TempLocation* cast(Value* value) {
     ASSERT(value->is_temporary());
     return reinterpret_cast<TempLocation*>(value);
   }
 
   // Accessors.
   Where where() { return where_; }
-  void set_where(Where where) { where_ = where; }
+  void set_where(Where where) {
+    ASSERT(where_ == TempLocation::NOT_ALLOCATED);
+    where_ = where;
+  }
 
   // Predicates.
   bool is_on_stack() { return where_ == STACK; }
   bool is_temporary() { return true; }
 
   // Support for fast-compilation mode.  Assume the temp has been allocated.
   void Get(MacroAssembler* masm, Register reg);
   void Set(MacroAssembler* masm, Register reg);
   void Push(MacroAssembler* masm);
   void Move(MacroAssembler* masm, Value* value);
@@ skipping 15 matching lines @@
   int number_;
 #endif
 };
 
 
 // Instructions are computations.  The represent non-trivial source
 // expressions: typically ones that have side effects and require code to
 // be generated.
 class Instruction : public ZoneObject {
  public:
-  // Every instruction has a location where its result is stored (which may
-  // be Nowhere, the default).
-  Instruction() : location_(CfgGlobals::current()->nowhere()) {}
-
-  explicit Instruction(Location* location) : location_(location) {}
-
-  virtual ~Instruction() {}
-
   // Accessors.
   Location* location() { return location_; }
   void set_location(Location* location) { location_ = location; }
 
   // Support for fast-compilation mode:
 
   // Emit code to perform the instruction.
   virtual void Compile(MacroAssembler* masm) = 0;
 
   // Allocate a temporary which is the result of the immediate predecessor
   // instruction.  It is allocated to the accumulator register if it is used
   // as an operand to this instruction, otherwise to the stack.
   virtual void FastAllocate(TempLocation* temp) = 0;
 
 #ifdef DEBUG
   virtual void Print() = 0;
 #endif
 
  protected:
+  // Every instruction has a location where its result is stored (which may
+  // be Nowhere).
+  explicit Instruction(Location* location) : location_(location) {}
+
+  virtual ~Instruction() {}
+
   Location* location_;
 };
 
 
+// Base class of instructions that have no input operands.
+class ZeroOperandInstruction : public Instruction {
+ public:
+  // Support for fast-compilation mode:
+  virtual void Compile(MacroAssembler* masm) = 0;
+  void FastAllocate(TempLocation* temp);
+
+#ifdef DEBUG
+  // Printing support: print the operands (nothing).
+  virtual void Print() {}
+#endif
+
+ protected:
+  explicit ZeroOperandInstruction(Location* loc) : Instruction(loc) {}
+};
+
+
+// Base class of instructions that have a single input operand.
+class OneOperandInstruction : public Instruction {
+ public:
+  // Support for fast-compilation mode:
+  virtual void Compile(MacroAssembler* masm) = 0;
+  void FastAllocate(TempLocation* temp);
+
+#ifdef DEBUG
+  // Printing support: print the operands.
+  virtual void Print();
+#endif
+
+ protected:
+  OneOperandInstruction(Location* loc, Value* value)
+      : Instruction(loc), value_(value) {
+  }
+
+  Value* value_;
+};
+
+
+// Base class of instructions that have two input operands.
+class TwoOperandInstruction : public Instruction {
+ protected:
+  // Support for fast-compilation mode:
+  virtual void Compile(MacroAssembler* masm) = 0;
+  void FastAllocate(TempLocation* temp);
+
+#ifdef DEBUG
+  // Printing support: print the operands.
+  virtual void Print();
+#endif
+
+ protected:
+  TwoOperandInstruction(Location* loc, Value* value0, Value* value1)
+      : Instruction(loc), value0_(value0), value1_(value1) {
+  }
+
+  Value* value0_;
+  Value* value1_;
+};
+
+
 // A phantom instruction that indicates the start of a statement.  It
 // causes the statement position to be recorded in the relocation
 // information but generates no code.
-class PositionInstr : public Instruction {
+class PositionInstr : public ZeroOperandInstruction {
  public:
-  explicit PositionInstr(int pos) : pos_(pos) {}
+  explicit PositionInstr(int pos)
+      : ZeroOperandInstruction(CfgGlobals::current()->nowhere()), pos_(pos) {
+  }
 
   // Support for fast-compilation mode.
   void Compile(MacroAssembler* masm);
 
   // This should not be called.  The last instruction of the previous
   // statement should not have a temporary as its location.
   void FastAllocate(TempLocation* temp) { UNREACHABLE(); }
 
 #ifdef DEBUG
   // Printing support.  Print nothing.
   void Print() {}
 #endif
 
  private:
   int pos_;
 };
 
 
 // Move a value to a location.
-class MoveInstr : public Instruction {
+class MoveInstr : public OneOperandInstruction {
  public:
-  MoveInstr(Location* loc, Value* value) : Instruction(loc), value_(value) {}
+  MoveInstr(Location* loc, Value* value)
+      : OneOperandInstruction(loc, value) {
+  }
 
   // Accessors.
   Value* value() { return value_; }
 
   // Support for fast-compilation mode.
   void Compile(MacroAssembler* masm);
-  void FastAllocate(TempLocation* temp);
+
+#ifdef DEBUG
+  // Printing support.
+  void Print();
+#endif
+};
+
+
+// Load a property from a receiver, leaving the result in a location.
+class PropLoadInstr : public TwoOperandInstruction {
+ public:
+  PropLoadInstr(Location* loc, Value* object, Value* key)
+      : TwoOperandInstruction(loc, object, key) {
+  }
+
+  // Accessors.
+  Value* object() { return value0_; }
+  Value* key() { return value1_; }
+
+  // Support for fast-compilation mode.
+  void Compile(MacroAssembler* masm);
 
 #ifdef DEBUG
   void Print();
 #endif
-
- private:
-  Value* value_;
-};
-
-
-// Load a property from a receiver, leaving the result in a location.
-class PropLoadInstr : public Instruction {
- public:
-  PropLoadInstr(Location* loc, Value* object, Value* key)
-      : Instruction(loc), object_(object), key_(key) {
-  }
-
-  // Accessors.
-  Value* object() { return object_; }
-  Value* key() { return key_; }
-
-  // Support for fast-compilation mode.
-  void Compile(MacroAssembler* masm);
-  void FastAllocate(TempLocation* temp);
-
-#ifdef DEBUG
-  void Print();
-#endif
-
- private:
-  Value* object_;
-  Value* key_;
 };
 
 
 // Perform a (non-short-circuited) binary operation on a pair of values,
 // leaving the result in a location.
-class BinaryOpInstr : public Instruction {
+class BinaryOpInstr : public TwoOperandInstruction {
  public:
   BinaryOpInstr(Location* loc, Token::Value op, Value* left, Value* right)
-      : Instruction(loc), op_(op), left_(left), right_(right) {
+      : TwoOperandInstruction(loc, left, right), op_(op) {
   }
 
   // Accessors.
+  Value* left() { return value0_; }
+  Value* right() { return value1_; }
   Token::Value op() { return op_; }
-  Value* left() { return left_; }
-  Value* right() { return right_; }
 
   // Support for fast-compilation mode.
   void Compile(MacroAssembler* masm);
-  void FastAllocate(TempLocation* temp);
 
 #ifdef DEBUG
   void Print();
 #endif
 
  private:
   Token::Value op_;
-  Value* left_;
-  Value* right_;
 };
 
 
 // Return a value.  Has the side effect of moving its value into the return
 // value register.  Can only occur as the last instruction in an instruction
 // block, and implies that the block is closed (cannot have instructions
 // appended or graph fragments concatenated to the end) and that the block's
 // successor is the global exit node for the current function.
-class ReturnInstr : public Instruction {
+class ReturnInstr : public OneOperandInstruction {
  public:
-  explicit ReturnInstr(Value* value) : value_(value) {}
+  explicit ReturnInstr(Value* value)
+      : OneOperandInstruction(CfgGlobals::current()->nowhere(), value) {
+  }
 
   virtual ~ReturnInstr() {}
 
   // Accessors.
   Value* value() { return value_; }
 
   // Support for fast-compilation mode.
   void Compile(MacroAssembler* masm);
-  void FastAllocate(TempLocation* temp);
 
 #ifdef DEBUG
   void Print();
 #endif
-
- private:
-  Value* value_;
 };
 
 
 // Nodes make up control-flow graphs.
 class CfgNode : public ZoneObject {
  public:
   CfgNode() : is_marked_(false) {
 #ifdef DEBUG
     number_ = -1;
 #endif
@@ skipping 301 matching lines @@
 
  private:
   // State for the visitor.  Input/output parameter:
   Cfg* graph_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_CFG_H_