Added support for property loads to the CFG builder and fast-mode

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 25 matching lines @@
 class ExitNode;
 class Location;
 
 // Translate a source AST into a control-flow graph (CFG).  The CFG contains
 // single-entry, single-exit blocks of straight-line instructions and
 // administrative nodes.
 //
 // Instructions are described by the following grammar.
 //
 // <Instruction> ::=
-//     MoveInstr <Location> <Value>
-//   | BinaryOpInstr <Location> Token::Value <Value> <Value>
-//   | ReturnInstr Nowhere <Value>
-//   | PositionInstr <Int>
+//     Move <Location> <Value>
+//   | PropRef <Location> <Value> <Value>
+//   | BinaryOp <Location> Token::Value <Value> <Value>
+//   | Return Nowhere <Value>
+//   | Position <Int>
 //
 // Values are trivial expressions:
 //
 // <Value> ::= Constant | <Location>
 //
 // Locations are storable values ('lvalues').  They can be slots,
 // compiler-generated temporaries, or the special location 'Nowhere'
 // indicating that no value is needed.
 //
 // <Location> ::=
@@ skipping 64 matching lines @@
 class SlotLocation;
 
 // Values represent trivial source expressions: ones with no side effects
 // and that do not require code to be generated.
 class Value : public ZoneObject {
  public:
   virtual ~Value() {}
 
   // Predicates:
 
+  virtual bool is_temporary() { return false; }
+  virtual bool is_slot() { return false; }
+  virtual bool is_constant() { return false; }
+
   // True if the value is a temporary allocated to the stack in
   // fast-compilation mode.
   virtual bool is_on_stack() { return false; }
 
-  // True if the value is a compiler-generated temporary location.
-  virtual bool is_temporary() { return false; }
-
-  // True if the value is a slot location.
-  virtual bool is_slot() { return false; }
-
   // Support for fast-compilation mode:
 
   // Move the value into a register.
   virtual void Get(MacroAssembler* masm, Register reg) = 0;
 
   // Push the value on the stack.
   virtual void Push(MacroAssembler* masm) = 0;
 
   // Move the value into a slot location.
   virtual void MoveToSlot(MacroAssembler* masm, SlotLocation* loc) = 0;
 
 #ifdef DEBUG
   virtual void Print() = 0;
 #endif
 };
 
 
 // A compile-time constant that appeared as a literal in the source AST.
 class Constant : public Value {
  public:
   explicit Constant(Handle<Object> handle) : handle_(handle) {}
 
-  virtual ~Constant() {}
+  // Cast accessor.
+  static Constant* cast(Value* value) {
+    ASSERT(value->is_constant());
+    return reinterpret_cast<Constant*>(value);
+  }
+
+  // Accessors.
+  Handle<Object> handle() { return handle_; }
+
+  // Predicates.
+  bool is_constant() { return true; }
 
   // Support for fast-compilation mode.
   void Get(MacroAssembler* masm, Register reg);
   void Push(MacroAssembler* masm);
   void MoveToSlot(MacroAssembler* masm, SlotLocation* loc);
 
 #ifdef DEBUG
   void Print();
 #endif
 
@@ skipping 226 matching lines @@
 
 #ifdef DEBUG
   void Print();
 #endif
 
  private:
   Value* value_;
 };
 
 
+// Load a property from a receiver, leaving the result in a location.

[William Hesse, 2009/08/07 12:50:26]

I like PropertyLoad better.  A PropertyRef to me means the EcmaScript standard
Reference internal type.

[Kevin Millikin (Chromium), 2009/08/07 13:25:33]

Going with PropLoad.

+class PropRefInstr : public Instruction {
+ public:
+  PropRefInstr(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 {
  public:
-  BinaryOpInstr(Location* loc, Token::Value op, Value* value0, Value* value1)
-      : Instruction(loc), op_(op), value0_(value0), value1_(value1) {
+  BinaryOpInstr(Location* loc, Token::Value op, Value* left, Value* right)
+      : Instruction(loc), op_(op), left_(left), right_(right) {
   }
 
   // Accessors.
   Token::Value op() { return op_; }
-  Value* value0() { return value0_; }
-  Value* value1() { return value1_; }
+  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* value0_;
-  Value* value1_;
+  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 {
  public:
   explicit ReturnInstr(Value* value) : value_(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_;
@@ skipping 311 matching lines @@
 
  private:
   // State for the visitor.  Input/output parameter:
   Cfg* graph_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_CFG_H_