Eliminate phis that do not reach any non-environment uses.

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 2198 matching lines @@
   }
 
   // Returns -1 if pred is not in the list.
   intptr_t IndexOfPredecessor(BlockEntryInstr* pred) const;
 
   ZoneGrowableArray<PhiInstr*>* phis() const { return phis_; }
 
   virtual void PrepareEntry(FlowGraphCompiler* compiler);
 
   void InsertPhi(intptr_t var_index, intptr_t var_count);
+  void RemoveDeadPhis();
 
   intptr_t phi_count() const { return phi_count_; }
 
  private:
   GrowableArray<BlockEntryInstr*> predecessors_;
   ZoneGrowableArray<PhiInstr*>* phis_;
   intptr_t phi_count_;
 
   DISALLOW_COPY_AND_ASSIGN(JoinEntryInstr);
 };
@@ skipping 126 matching lines @@
  private:
   Computation* computation_;
   const bool is_used_;
 
   DISALLOW_COPY_AND_ASSIGN(BindInstr);
 };
 
 
 class PhiInstr : public Definition {
  public:
-  explicit PhiInstr(intptr_t num_inputs) : inputs_(num_inputs) {
+  explicit PhiInstr(intptr_t num_inputs)
+    : inputs_(num_inputs), is_alive_(false) {
     for (intptr_t i = 0; i < num_inputs; ++i) {
       inputs_.Add(NULL);
     }
   }
 
   // Least upper bound of the static types of the inputs.
   virtual RawAbstractType* StaticType() const;
 
   virtual intptr_t ArgumentCount() const { return 0; }
 
   intptr_t InputCount() const { return inputs_.length(); }
 
   Value* InputAt(intptr_t i) const { return inputs_[i]; }
 
   void SetInputAt(intptr_t i, Value* value) { inputs_[i] = value; }
 
   virtual bool CanDeoptimize() const { return false; }
 
+  // Phi is alive if it reaches a non-environment use.
+  bool is_alive() const { return is_alive_; }
+  void mark_alive() { is_alive_ = true; }
+
   DECLARE_INSTRUCTION(Phi)
 
  private:
   GrowableArray<Value*> inputs_;
+  bool is_alive_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
 class ParameterInstr : public Definition {
  public:
   explicit ParameterInstr(intptr_t index) : index_(index) { }
 
   DECLARE_INSTRUCTION(Parameter)
@@ skipping 285 matching lines @@
         location_count_(0),
         locations_(NULL),
         fixed_parameter_count_(fixed_parameter_count) {
     values_.AddArray(values);
   }
 
   const GrowableArray<Value*>& values() const {
     return values_;
   }
 
+  GrowableArray<Value*>* values_ptr() {
+    return &values_;
+  }
+
   void InitializeLocations() {
     location_count_ = values_.length();
     if (location_count_ > 0) {
       locations_ =
           Isolate::Current()->current_zone()->Alloc<Location>(location_count_);
     }
   }
 
   Location LocationAt(intptr_t ix) const {
     ASSERT((ix >= 0) && (ix < location_count_));
@@ skipping 51 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_