First step towards making JumpTarget work on ARM. Instead...

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 333 matching lines @@
   // Type testing & conversion.
   virtual BreakableStatement* AsBreakableStatement() { return this; }
 
   // Code generation
   BreakTarget* break_target() { return &break_target_; }
 
   // Testers.
   bool is_target_for_anonymous() const { return type_ == TARGET_FOR_ANONYMOUS; }
 
  protected:
-  BreakableStatement(ZoneStringList* labels, Type type)
-      : labels_(labels), type_(type) {
-    ASSERT(labels == NULL || labels->length() > 0);
-  }
+  inline BreakableStatement(ZoneStringList* labels, Type type);
 
   explicit BreakableStatement(BreakableStatement* other);
 
  private:
   ZoneStringList* labels_;
   Type type_;
   BreakTarget break_target_;
 };
 
 
 class Block: public BreakableStatement {
  public:
-  Block(ZoneStringList* labels, int capacity, bool is_initializer_block)
-      : BreakableStatement(labels, TARGET_FOR_NAMED_ONLY),
-        statements_(capacity),
-        is_initializer_block_(is_initializer_block) { }
+  inline Block(ZoneStringList* labels, int capacity, bool is_initializer_block);
 
   // Construct a clone initialized from the original block and
   // a deep copy of all statements of the original block.
   Block(Block* other, ZoneList<Statement*>* statements);
 
   virtual void Accept(AstVisitor* v);
 
   virtual Block* AsBlock() { return this; }
 
   virtual Assignment* StatementAsSimpleAssignment() {
@@ skipping 46 matching lines @@
   // Type testing & conversion.
   virtual IterationStatement* AsIterationStatement() { return this; }
 
   Statement* body() const { return body_; }
   void set_body(Statement* stmt) { body_ = stmt; }
 
   // Code generation
   BreakTarget* continue_target()  { return &continue_target_; }
 
  protected:
-  explicit IterationStatement(ZoneStringList* labels)
-      : BreakableStatement(labels, TARGET_FOR_ANONYMOUS), body_(NULL) { }
+  explicit inline IterationStatement(ZoneStringList* labels);
 
   // Construct a clone initialized from  original and
   // a deep copy of the original body.
   IterationStatement(IterationStatement* other, Statement* body);
 
   void Initialize(Statement* body) {
     body_ = body;
   }
 
  private:
   Statement* body_;
   BreakTarget continue_target_;
 };
 
 
 class DoWhileStatement: public IterationStatement {
  public:
-  explicit DoWhileStatement(ZoneStringList* labels)
-      : IterationStatement(labels), cond_(NULL), condition_position_(-1) {
-  }
+  explicit inline DoWhileStatement(ZoneStringList* labels);
 
   void Initialize(Expression* cond, Statement* body) {
     IterationStatement::Initialize(body);
     cond_ = cond;
   }
 
   virtual void Accept(AstVisitor* v);
 
   Expression* cond() const { return cond_; }
 
   // Position where condition expression starts. We need it to make
   // the loop's condition a breakable location.
   int condition_position() { return condition_position_; }
   void set_condition_position(int pos) { condition_position_ = pos; }
 
  private:
   Expression* cond_;
   int condition_position_;
 };
 
 
 class WhileStatement: public IterationStatement {
  public:
-  explicit WhileStatement(ZoneStringList* labels)
-      : IterationStatement(labels),
-        cond_(NULL),
-        may_have_function_literal_(true) {
-  }
+  explicit WhileStatement(ZoneStringList* labels);
 
   void Initialize(Expression* cond, Statement* body) {
     IterationStatement::Initialize(body);
     cond_ = cond;
   }
 
   virtual void Accept(AstVisitor* v);
 
   Expression* cond() const { return cond_; }
   bool may_have_function_literal() const {
     return may_have_function_literal_;
   }
 
  private:
   Expression* cond_;
   // True if there is a function literal subexpression in the condition.
   bool may_have_function_literal_;
 
   friend class AstOptimizer;
 };
 
 
 class ForStatement: public IterationStatement {
  public:
-  explicit ForStatement(ZoneStringList* labels)
-      : IterationStatement(labels),
-        init_(NULL),
-        cond_(NULL),
-        next_(NULL),
-        may_have_function_literal_(true),
-        loop_variable_(NULL),
-        peel_this_loop_(false) {}
+  explicit inline ForStatement(ZoneStringList* labels);
 
   // Construct a for-statement initialized from another for-statement
   // and deep copies of all parts of the original statement.
   ForStatement(ForStatement* other,
                Statement* init,
                Expression* cond,
                Statement* next,
                Statement* body);
 
   virtual ForStatement* AsForStatement() { return this; }
@@ skipping 35 matching lines @@
   bool may_have_function_literal_;
   Variable* loop_variable_;
   bool peel_this_loop_;
 
   friend class AstOptimizer;
 };
 
 
 class ForInStatement: public IterationStatement {
  public:
-  explicit ForInStatement(ZoneStringList* labels)
-      : IterationStatement(labels), each_(NULL), enumerable_(NULL) { }
+  explicit inline ForInStatement(ZoneStringList* labels);
 
   void Initialize(Expression* each, Expression* enumerable, Statement* body) {
     IterationStatement::Initialize(body);
     each_ = each;
     enumerable_ = enumerable;
   }
 
   virtual void Accept(AstVisitor* v);
 
   Expression* each() const { return each_; }
@@ skipping 95 matching lines @@
 class WithExitStatement: public Statement {
  public:
   WithExitStatement() { }
 
   virtual void Accept(AstVisitor* v);
 };
 
 
 class CaseClause: public ZoneObject {
  public:
-  CaseClause(Expression* label, ZoneList<Statement*>* statements)
-      : label_(label), statements_(statements) { }
+  CaseClause(Expression* label, ZoneList<Statement*>* statements);
 
   bool is_default() const  { return label_ == NULL; }
   Expression* label() const  {
     CHECK(!is_default());
     return label_;
   }
   JumpTarget* body_target() { return &body_target_; }
   ZoneList<Statement*>* statements() const  { return statements_; }
 
  private:
   Expression* label_;
   JumpTarget body_target_;
   ZoneList<Statement*>* statements_;
 };
 
 
 class SwitchStatement: public BreakableStatement {
  public:
-  explicit SwitchStatement(ZoneStringList* labels)
-      : BreakableStatement(labels, TARGET_FOR_ANONYMOUS),
-        tag_(NULL), cases_(NULL) { }
+  explicit inline SwitchStatement(ZoneStringList* labels);
 
   void Initialize(Expression* tag, ZoneList<CaseClause*>* cases) {
     tag_ = tag;
     cases_ = cases;
   }
 
   virtual void Accept(AstVisitor* v);
 
   Expression* tag() const  { return tag_; }
   ZoneList<CaseClause*>* cases() const  { return cases_; }
@@ skipping 1385 matching lines @@
 
   // Holds the result of copying an expression.
   Expression* expr_;
   // Holds the result of copying a statement.
   Statement* stmt_;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_AST_H_