Cleanups.

runtime/vm/intermediate_language.h

 // Copyright (c) 2012, 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 1922 matching lines @@
 
 
 class ForwardInstructionIterator : public ValueObject {
  public:
   explicit ForwardInstructionIterator(BlockEntryInstr* block_entry)
       : block_entry_(block_entry), current_(block_entry) {
     Advance();
   }
 
   void Advance() {
-    if (!Done()) current_ = current_->next();
+    ASSERT(!Done());
+    current_ = current_->next();
   }
 
   bool Done() const {
     return current_ == block_entry_->last_instruction()->next();
   }
 
-  void RemoveCurrentFromGraph() {
-    ASSERT(!current_->IsBlockEntry());
-    ASSERT(!current_->IsBranch());
-    ASSERT(!current_->IsThrow());
-    ASSERT(!current_->IsReturn());
-    ASSERT(!current_->IsReThrow());
-    ASSERT(current_->previous() != NULL);
-    Instruction* prev = current_->previous();
-    Instruction* next = current_->next();
-    prev->set_next(next);
-    ASSERT(next != NULL);
-    if (current_ != block_entry_->last_instruction()) {
-      ASSERT(!next->IsBlockEntry());
-      next->set_previous(prev);
-    } else {
-      ASSERT(current_->IsBind());
-      // Removing the last instruction of a block.
-      // Update last_instruction of the current basic block.
-      block_entry_->set_last_instruction(prev);
-    }
-    // Reset successor and previous instruction to indicate
-    // that the instruction is removed from the graph.
-    current_->set_previous(NULL);
-    current_->set_next(NULL);
-    current_ = prev;
-  }
+  // Removes 'current_' from graph and sets 'current_' to previous instruction.
+  void RemoveCurrentFromGraph();
 
   Instruction* Current() const { return current_; }
 
  private:
   BlockEntryInstr* block_entry_;
   Instruction* current_;
 };
 
 
 class GraphEntryInstr : public BlockEntryInstr {
@@ skipping 173 matching lines @@
   virtual void RecordAssignedVars(BitVector* assigned_vars);
 
   virtual LocationSummary* locs() {
     return computation()->locs();
   }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
  private:
   Computation* computation_;
-  bool is_used_;
+  const bool is_used_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
-class PhiInstr: public Definition {
+class PhiInstr : public Definition {
  public:
   explicit PhiInstr(intptr_t num_inputs) : inputs_(num_inputs) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
   DECLARE_INSTRUCTION(Phi)
 
  private:
   GrowableArray<Value*> inputs_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
-class ParameterInstr: public Definition {
+class ParameterInstr : public Definition {
  public:
   explicit ParameterInstr(intptr_t index) : index_(index) { }
 
   intptr_t index() const { return index_; }
 
   DECLARE_INSTRUCTION(Parameter)
 
  private:
-  intptr_t index_;
+  const intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class ReturnInstr : public InstructionWithInputs {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : InstructionWithInputs(), token_pos_(token_pos), value_(value) {
     ASSERT(value_ != NULL);
@@ skipping 223 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_