Compute local variable liveness before translation to SSA.

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 601 matching lines @@
   Instruction* RemoveFromGraph(bool return_previous = true);
 
   // Normal instructions can have 0 (inside a block) or 1 (last instruction in
   // a block) successors. Branch instruction with >1 successors override this
   // function.
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   void Goto(JoinEntryInstr* entry);
 
-  // Mutate assigned_vars to add the local variable index for all
-  // frame-allocated locals assigned to by the instruction.
-  virtual void RecordAssignedVars(BitVector* assigned_vars,
-                                  intptr_t fixed_parameter_count);
-
   virtual const char* DebugName() const = 0;
 
   // Printing support.
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
 #define INSTRUCTION_TYPE_CHECK(type)                                           \
   bool Is##type() { return (As##type() != NULL); }                             \
   virtual type##Instr* As##type() { return NULL; }
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
@@ skipping 325 matching lines @@
   // The array 'assigned_vars' maps preorder block numbers to the set of
   // assigned frame-allocated local variables in the block.  As a side
   // effect of this function, the set of basic block predecessors (e.g.,
   // block entry instructions of predecessor blocks) and also the last
   // instruction in the block is recorded in each entry instruction.
   void DiscoverBlocks(
       BlockEntryInstr* predecessor,
       GrowableArray<BlockEntryInstr*>* preorder,
       GrowableArray<BlockEntryInstr*>* postorder,
       GrowableArray<intptr_t>* parent,
-      GrowableArray<BitVector*>* assigned_vars,
       intptr_t variable_count,
       intptr_t fixed_parameter_count);
 
   virtual intptr_t InputCount() const { return 0; }
   virtual Value* InputAt(intptr_t i) const {
     UNREACHABLE();
     return NULL;
   }
 
   virtual intptr_t ArgumentCount() const { return 0; }
@@ skipping 400 matching lines @@
   // Precondition: use lists must be properly calculated.
   // Postcondition: use lists and use values are still valid.
   void ReplaceUsesWith(Definition* other);
 
   // Replace this definition and all uses with another definition.  If
   // replacing during iteration, pass the iterator so that the instruction
   // can be replaced without affecting iteration order, otherwise pass a
   // NULL iterator.
   void ReplaceWith(Definition* other, ForwardInstructionIterator* iterator);
 
-  virtual void RecordAssignedVars(BitVector* assigned_vars,
-                                  intptr_t fixed_parameter_count);
-
   // Printing support. These functions are sometimes overridden for custom
   // formatting. Otherwise, it prints in the format "opcode(op1, op2, op3)".
   virtual void PrintTo(BufferFormatter* f) const;
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   // A value in the constant propagation lattice.
   //    - non-constant sentinel
   //    - a constant (any non-sentinel value)
   //    - unknown sentinel
   Object& constant_value() const { return constant_value_; }
@@ skipping 1296 matching lines @@
 
   // 'True' for recognized list constructors.
   bool is_known_list_constructor_;
 
   DISALLOW_COPY_AND_ASSIGN(StaticCallInstr);
 };
 
 
 class LoadLocalInstr : public TemplateDefinition<0> {
  public:
-  explicit LoadLocalInstr(const LocalVariable& local) : local_(local) { }
+  explicit LoadLocalInstr(const LocalVariable& local)
+      : local_(local), is_last_(false) { }
 
   DECLARE_INSTRUCTION(LoadLocal)
   virtual CompileType ComputeType() const;
 
   const LocalVariable& local() const { return local_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const {
     UNREACHABLE();
     return false;
   }
 
+  void mark_last() { is_last_ = true; }
+  bool is_last() const { return is_last_; }
+
  private:
   const LocalVariable& local_;
+  bool is_last_;
 
   DISALLOW_COPY_AND_ASSIGN(LoadLocalInstr);
 };
 
 
 class StoreLocalInstr : public TemplateDefinition<1> {
  public:
-  StoreLocalInstr(const LocalVariable& local, Value* value) : local_(local) {
+  StoreLocalInstr(const LocalVariable& local, Value* value)
+      : local_(local), is_dead_(false), is_last_(false) {
     SetInputAt(0, value);
   }
 
   DECLARE_INSTRUCTION(StoreLocal)
   virtual CompileType* ComputeInitialType() const;
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
 
-  virtual void RecordAssignedVars(BitVector* assigned_vars,
-                                  intptr_t fixed_parameter_count);
-
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const {
     UNREACHABLE();
     return false;
   }
 
+  void mark_dead() { is_dead_ = true; }
+  bool is_dead() const { return is_dead_; }
+
+  void mark_last() { is_last_ = true; }
+  bool is_last() const { return is_last_; }
+
  private:
   const LocalVariable& local_;
+  bool is_dead_;
+  bool is_last_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalInstr);
 };
 
 
 class NativeCallInstr : public TemplateDefinition<0> {
  public:
   explicit NativeCallInstr(NativeBodyNode* node)
       : ast_node_(*node) {}
 
@@ skipping 1897 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_