Add a backward instruction iterator and use it in the liveness analysis.

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 1932 matching lines @@
   Instruction* last_instruction_;
 
   DISALLOW_COPY_AND_ASSIGN(BlockEntryInstr);
 };
 
 
 class ForwardInstructionIterator : public ValueObject {
  public:
   explicit ForwardInstructionIterator(BlockEntryInstr* block_entry)
       : block_entry_(block_entry), current_(block_entry) {
+    ASSERT(block_entry_->last_instruction()->next() == NULL);
     Advance();
   }
 
   void Advance() {
     ASSERT(!Done());
     current_ = current_->next();
   }
 
-  bool Done() const {
-    return current_ == block_entry_->last_instruction()->next();
-  }
+  bool Done() const { return current_ == NULL; }
 
   // Removes 'current_' from graph and sets 'current_' to previous instruction.
   void RemoveCurrentFromGraph();
 
   Instruction* Current() const { return current_; }
 
  private:
   BlockEntryInstr* block_entry_;
   Instruction* current_;
 };
 
 
+class BackwardInstructionIterator : public ValueObject {
+ public:
+  explicit BackwardInstructionIterator(BlockEntryInstr* block_entry)
+      : block_entry_(block_entry), current_(block_entry->last_instruction()) {
+    ASSERT(block_entry_->previous() == NULL);
+  }
+
+  void Advance() {
+    ASSERT(!Done());
+    current_ = current_->previous();
+  }
+
+  bool Done() const { return current_ == block_entry_; }
+
+  Instruction* Current() const { return current_; }

[srdjan, 2012/07/24 15:49:30]

s/Current/current/   (also for ForwardInstructionIterator)

[Florian Schneider, 2012/07/25 08:31:29]

I leave it as is to be consistent with the names of the other functions in the
iterator interface (either all lower- or all upper-case)

[srdjan, 2012/07/25 15:19:30]

Yes, the consistency argument is valid.
Since lower-casing is is used to denote calling short inlined functions, the
best will be to change Advance, Done, and Current  to lower case. See C++ style
guide:
http://www.corp.google.com/eng/doc/cppguide.xml?showone=Function_Names#Functi...

+
+ private:
+  BlockEntryInstr* block_entry_;
+  Instruction* current_;
+};
+
+
 class GraphEntryInstr : public BlockEntryInstr {
  public:
   explicit GraphEntryInstr(TargetEntryInstr* normal_entry)
       : BlockEntryInstr(),
         normal_entry_(normal_entry),
         catch_entries_(),
         start_env_(NULL) { }
 
   DECLARE_INSTRUCTION(GraphEntry)
 
@@ skipping 547 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_