Move and clean up some class declarations in intermediate_language.h.

runtime/vm/intermediate_language.h

 // Copyright (c) 2013, the Dart project authors.  Please see the AUTHORS file
 // for details. All rights reserved. Use of this source code is governed by a
 // BSD-style license that can be found in the LICENSE file.
 
 #ifndef VM_INTERMEDIATE_LANGUAGE_H_
 #define VM_INTERMEDIATE_LANGUAGE_H_
 
 #include "vm/allocation.h"
 #include "vm/ast.h"
 #include "vm/growable_array.h"
@@ skipping 2110 matching lines @@
  private:
   JoinEntryInstr* successor_;
   double edge_weight_;
 
   // Parallel move that will be used by linear scan register allocator to
   // connect live ranges at the end of the block and resolve phis.
   ParallelMoveInstr* parallel_move_;
 };
 
 
+template<intptr_t N>
+class TemplateDefinition : public Definition {
+ public:
+  TemplateDefinition<N>() : locs_(NULL) { }
+
+  virtual intptr_t InputCount() const { return N; }
+  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
+
+  // Returns a structure describing the location constraints required
+  // to emit native code for this definition.
+  LocationSummary* locs() {
+    if (locs_ == NULL) {
+      locs_ = MakeLocationSummary();
+    }
+    return locs_;
+  }
+
+ protected:
+  EmbeddedArray<Value*, N> inputs_;
+
+ private:
+  friend class BranchInstr;
+
+  virtual void RawSetInputAt(intptr_t i, Value* value) {
+    inputs_[i] = value;
+  }
+
+  LocationSummary* locs_;
+};
+
+
+class ComparisonInstr : public TemplateDefinition<2> {
+ public:
+  Value* left() const { return inputs_[0]; }
+  Value* right() const { return inputs_[1]; }
+
+  virtual ComparisonInstr* AsComparison() { return this; }
+
+  intptr_t token_pos() const { return token_pos_; }
+  Token::Kind kind() const { return kind_; }
+
+  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
+                              BranchInstr* branch) = 0;
+
+  void SetDeoptId(intptr_t deopt_id) {
+    deopt_id_ = deopt_id;
+  }
+
+  // Operation class id is computed from collected ICData.
+  void set_operation_cid(intptr_t value) { operation_cid_ = value; }
+  intptr_t operation_cid() const { return operation_cid_; }
+
+  void NegateComparison() {
+    kind_ = Token::NegateComparison(kind_);
+  }
+
+ protected:
+  ComparisonInstr(intptr_t token_pos,
+                  Token::Kind kind,
+                  Value* left,
+                  Value* right)
+      : token_pos_(token_pos), kind_(kind), operation_cid_(kIllegalCid) {
+    SetInputAt(0, left);
+    SetInputAt(1, right);
+  }
+
+ private:
+  const intptr_t token_pos_;
+  Token::Kind kind_;
+  intptr_t operation_cid_;  // Set by optimizer.
+
+  DISALLOW_COPY_AND_ASSIGN(ComparisonInstr);
+};
+
+
 class BranchInstr : public Instruction {
  public:
   explicit BranchInstr(ComparisonInstr* comparison, bool is_checked = false);
 
   DECLARE_INSTRUCTION(Branch)
 
-  virtual intptr_t ArgumentCount() const;
-  intptr_t InputCount() const;
-  Value* InputAt(intptr_t i) const;
-  virtual bool CanDeoptimize() const;
-  virtual bool CanBecomeDeoptimizationTarget() const;
+  virtual intptr_t ArgumentCount() const {
+    return comparison()->ArgumentCount();
+  }
 
-  virtual EffectSet Effects() const;
+  intptr_t InputCount() const { return comparison()->InputCount(); }
+
+  Value* InputAt(intptr_t i) const { return comparison()->InputAt(i); }
+
+  virtual bool CanDeoptimize() const {
+    // Branches need a deoptimization info in checked mode if they
+    // can throw a type check error.
+    return comparison()->CanDeoptimize() || is_checked();
+  }
+
+  virtual bool CanBecomeDeoptimizationTarget() const {
+    return comparison()->CanBecomeDeoptimizationTarget();
+  }
+
+  virtual EffectSet Effects() const {
+    return comparison()->Effects();
+  }
 
   ComparisonInstr* comparison() const { return comparison_; }
   void SetComparison(ComparisonInstr* comp);
 
   bool is_checked() const { return is_checked_; }
 
-  virtual LocationSummary* locs();
-  virtual intptr_t DeoptimizationTarget() const;
-  virtual Representation RequiredInputRepresentation(intptr_t i) const;
+  virtual LocationSummary* locs() {
+    if (comparison()->locs_ == NULL) {
+      LocationSummary* summary = comparison()->MakeLocationSummary();
+      // Branches don't produce a result.
+      summary->set_out(Location::NoLocation());
+      comparison()->locs_ = summary;
+    }
+    return comparison()->locs_;
+  }
+
+  virtual intptr_t DeoptimizationTarget() const {
+    return comparison()->DeoptimizationTarget();
+  }
+
+  virtual Representation RequiredInputRepresentation(intptr_t i) const {
+    return comparison()->RequiredInputRepresentation(i);
+  }
 
   virtual Instruction* Canonicalize(FlowGraph* flow_graph);
 
   virtual void PrintTo(BufferFormatter* f) const;
 
   // Set compile type constrained by the comparison of this branch.
   // FlowGraphPropagator propagates it downwards into either true or false
   // successor.
   void set_constrained_type(ConstrainedCompileType* type) {
     constrained_type_ = type;
   }
 
   // Return compile type constrained by the comparison of this branch.
   ConstrainedCompileType* constrained_type() const {
     return constrained_type_;
   }
 
   void set_constant_target(TargetEntryInstr* target) {
     ASSERT(target == true_successor() || target == false_successor());
     constant_target_ = target;
   }
   TargetEntryInstr* constant_target() const {
     return constant_target_;
   }
 
   virtual void InheritDeoptTarget(Instruction* other);
 
-  virtual bool MayThrow() const;
+  virtual bool MayThrow() const {
+    return comparison()->MayThrow();
+  }
 
   TargetEntryInstr* true_successor() const { return true_successor_; }
   TargetEntryInstr* false_successor() const { return false_successor_; }
 
   TargetEntryInstr** true_successor_address() { return &true_successor_; }
   TargetEntryInstr** false_successor_address() { return &false_successor_; }
 
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
@@ skipping 31 matching lines @@
 
   virtual EffectSet Effects() const { return EffectSet::None(); }
 
   virtual bool MayThrow() const { return false; }
 
  private:
   DISALLOW_COPY_AND_ASSIGN(StoreContextInstr);
 };
 
 
-template<intptr_t N>
-class TemplateDefinition : public Definition {
- public:
-  TemplateDefinition<N>() : locs_(NULL) { }
-
-  virtual intptr_t InputCount() const { return N; }
-  virtual Value* InputAt(intptr_t i) const { return inputs_[i]; }
-
-  // Returns a structure describing the location constraints required
-  // to emit native code for this definition.
-  LocationSummary* locs() {
-    if (locs_ == NULL) {
-      locs_ = MakeLocationSummary();
-    }
-    return locs_;
-  }
-
- protected:
-  EmbeddedArray<Value*, N> inputs_;
-
- private:
-  friend class BranchInstr;
-
-  virtual void RawSetInputAt(intptr_t i, Value* value) {
-    inputs_[i] = value;
-  }
-
-  LocationSummary* locs_;
-};
-
-
 class RedefinitionInstr : public TemplateDefinition<1> {
  public:
   explicit RedefinitionInstr(Value* value) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(Redefinition)
 
   Value* value() const { return inputs_[0]; }
 
@@ skipping 527 matching lines @@
 
  private:
   InstanceCallInstr* instance_call_;
   const ICData& ic_data_;
   const bool with_checks_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallInstr);
 };
 
 
-class ComparisonInstr : public TemplateDefinition<2> {
- public:
-  Value* left() const { return inputs_[0]; }
-  Value* right() const { return inputs_[1]; }
-
-  virtual ComparisonInstr* AsComparison() { return this; }
-
-  intptr_t token_pos() const { return token_pos_; }
-  Token::Kind kind() const { return kind_; }
-
-  virtual void EmitBranchCode(FlowGraphCompiler* compiler,
-                              BranchInstr* branch) = 0;
-
-  void SetDeoptId(intptr_t deopt_id) {
-    deopt_id_ = deopt_id;
-  }
-
-  // Operation class id is computed from collected ICData.
-  void set_operation_cid(intptr_t value) { operation_cid_ = value; }
-  intptr_t operation_cid() const { return operation_cid_; }
-
-  void NegateComparison() {
-    kind_ = Token::NegateComparison(kind_);
-  }
-
- protected:
-  ComparisonInstr(intptr_t token_pos,
-                  Token::Kind kind,
-                  Value* left,
-                  Value* right)
-      : token_pos_(token_pos), kind_(kind), operation_cid_(kIllegalCid) {
-    SetInputAt(0, left);
-    SetInputAt(1, right);
-  }
-
- private:
-  const intptr_t token_pos_;
-  Token::Kind kind_;
-  intptr_t operation_cid_;  // Set by optimizer.
-
-  DISALLOW_COPY_AND_ASSIGN(ComparisonInstr);
-};
-
-
-// Inlined functions from class BranchInstr that forward to their comparison.
-inline intptr_t BranchInstr::ArgumentCount() const {
-  return comparison()->ArgumentCount();
-}
-
-
-inline intptr_t BranchInstr::InputCount() const {
-  return comparison()->InputCount();
-}
-
-
-inline Value* BranchInstr::InputAt(intptr_t i) const {
-  return comparison()->InputAt(i);
-}
-
-
-inline bool BranchInstr::CanDeoptimize() const {
-  // Branches need a deoptimization info in checked mode if they
-  // can throw a type check error.
-  return comparison()->CanDeoptimize() || is_checked();
-}
-
-
-inline bool BranchInstr::CanBecomeDeoptimizationTarget() const {
-  return comparison()->CanBecomeDeoptimizationTarget();
-}
-
-
-inline EffectSet BranchInstr::Effects() const {
-  return comparison()->Effects();
-}
-
-
-inline LocationSummary* BranchInstr::locs() {
-  if (comparison()->locs_ == NULL) {
-    LocationSummary* summary = comparison()->MakeLocationSummary();
-    // Branches don't produce a result.
-    summary->set_out(Location::NoLocation());
-    comparison()->locs_ = summary;
-  }
-  return comparison()->locs_;
-}
-
-
-inline intptr_t BranchInstr::DeoptimizationTarget() const {
-  return comparison()->DeoptimizationTarget();
-}
-
-
-inline Representation BranchInstr::RequiredInputRepresentation(
-    intptr_t i) const {
-  return comparison()->RequiredInputRepresentation(i);
-}
-
-
-inline bool BranchInstr::MayThrow() const {
-  return comparison()->MayThrow();
-}
-
-
 class StrictCompareInstr : public ComparisonInstr {
  public:
   StrictCompareInstr(intptr_t token_pos,
                      Token::Kind kind,
                      Value* left,
                      Value* right);
 
   DECLARE_INSTRUCTION(StrictCompare)
   virtual CompileType ComputeType() const;
 
@@ skipping 3999 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_