Initial implementation of an edge-labeled instruction flow graph.

src/ast.h

 // Copyright 2010 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 99 matching lines @@
 
 
 // Typedef only introduced to avoid unreadable code.
 // Please do appreciate the required space in "> >".
 typedef ZoneList<Handle<String> > ZoneStringList;
 typedef ZoneList<Handle<Object> > ZoneObjectList;
 
 
 class AstNode: public ZoneObject {
  public:
+  static const int kNoNumber = -1;
+
+  AstNode() : num_(kNoNumber) {}
   virtual ~AstNode() { }
   virtual void Accept(AstVisitor* v) = 0;
 
   // Type testing & conversion.
   virtual Statement* AsStatement() { return NULL; }
   virtual ExpressionStatement* AsExpressionStatement() { return NULL; }
   virtual EmptyStatement* AsEmptyStatement() { return NULL; }
   virtual Expression* AsExpression() { return NULL; }
   virtual Literal* AsLiteral() { return NULL; }
   virtual Slot* AsSlot() { return NULL; }
   virtual VariableProxy* AsVariableProxy() { return NULL; }
   virtual Property* AsProperty() { return NULL; }
   virtual Call* AsCall() { return NULL; }
   virtual TargetCollector* AsTargetCollector() { return NULL; }
   virtual BreakableStatement* AsBreakableStatement() { return NULL; }
   virtual IterationStatement* AsIterationStatement() { return NULL; }
   virtual UnaryOperation* AsUnaryOperation() { return NULL; }
   virtual BinaryOperation* AsBinaryOperation() { return NULL; }
   virtual Assignment* AsAssignment() { return NULL; }
   virtual FunctionLiteral* AsFunctionLiteral() { return NULL; }
   virtual MaterializedLiteral* AsMaterializedLiteral() { return NULL; }
   virtual ObjectLiteral* AsObjectLiteral() { return NULL; }
   virtual ArrayLiteral* AsArrayLiteral() { return NULL; }
   virtual CompareOperation* AsCompareOperation() { return NULL; }
+
+  int num() { return num_; }
+  void set_num(int n) { num_ = n; }
+
+ private:
+  // Support for ast node numbering.
+  int num_;
 };
 
 
 class Statement: public AstNode {
  public:
   Statement() : statement_pos_(RelocInfo::kNoPosition) {}
 
   virtual Statement* AsStatement()  { return this; }
   virtual ReturnStatement* AsReturnStatement() { return NULL; }
 
@@ skipping 20 matching lines @@
     // Evaluated for control flow (and side effects).
     kTest,
     // Evaluated for control flow and side effects.  Value is also
     // needed if true.
     kValueTest,
     // Evaluated for control flow and side effects.  Value is also
     // needed if false.
     kTestValue
   };
 
-  static const int kNoLabel = -1;
-
   Expression()
       : bitfields_(0),
-        num_(kNoLabel),
         def_(NULL),
         defined_vars_(NULL) {}
 
   virtual Expression* AsExpression()  { return this; }
 
   virtual bool IsValidLeftHandSide() { return false; }
 
   // Symbols that cannot be parsed as array indices are considered property
   // names.  We do not treat symbols that can be array indexes as property
   // names because [] for string objects is handled only by keyed ICs.
   virtual bool IsPropertyName() { return false; }
 
   // True if the expression does not have (evaluated) subexpressions.
   // Function literals are leaves because their subexpressions are not
   // evaluated.
   virtual bool IsLeaf() { return false; }
 
   // True if the expression has no side effects and is safe to
   // evaluate out of order.
   virtual bool IsTrivial() { return false; }
 
   // Mark the expression as being compiled as an expression
   // statement. This is used to transform postfix increments to
   // (faster) prefix increments.
   virtual void MarkAsStatement() { /* do nothing */ }
 
   // Static type information for this expression.
   StaticType* type() { return &type_; }
 
-  int num() { return num_; }
-
-  // AST node numbering ordered by evaluation order.
-  void set_num(int n) { num_ = n; }
-
   // Data flow information.
   DefinitionInfo* var_def() { return def_; }
   void set_var_def(DefinitionInfo* def) { def_ = def; }
 
   ZoneList<DefinitionInfo*>* defined_vars() { return defined_vars_; }
   void set_defined_vars(ZoneList<DefinitionInfo*>* defined_vars) {
     defined_vars_ = defined_vars;
   }
 
   // AST analysis results
@@ skipping 21 matching lines @@
   void set_stack_height(int stack_height) {
     bitfields_ &= ~StackHeightField::mask();
     bitfields_ |=
         StackHeightField::encode(Min(stack_height, StackHeightMax));
   }
 
  private:
   uint32_t bitfields_;
   StaticType type_;
 
-  int num_;
   DefinitionInfo* def_;
   ZoneList<DefinitionInfo*>* defined_vars_;
 
   static const int SideEffectFreeFieldStart = 0;
   static const int SideEffectFreeFieldLength = 1;
   class SideEffectFreeField: public BitField<bool,
                                              SideEffectFreeFieldStart,
                                              SideEffectFreeFieldLength> {
   };
 
@@ skipping 1633 matching lines @@
 #undef DEF_VISIT
 
  private:
   bool stack_overflow_;
 };
 
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_