Put PushArgument into the environment instead of raw values.

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 583 matching lines @@
  public:
   explicit PolymorphicInstanceCallComp(InstanceCallComp* comp)
       : instance_call_(comp) {
     ASSERT(instance_call_ != NULL);
   }
 
   InstanceCallComp* instance_call() const { return instance_call_; }
 
   void PrintTo(BufferFormatter* f) const;
 
-  DECLARE_COMPUTATION(PolymorphicInstanceCall)
+  virtual intptr_t ArgumentCount() const {
+    return instance_call()->ArgumentCount();
+  }
+
+  DECLARE_CALL_COMPUTATION(PolymorphicInstanceCall)
 
   virtual bool CanDeoptimize() const { return true; }
 
  private:
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallComp);
 };
 
 
@@ skipping 1896 matching lines @@
 
   virtual void RemoveInputUses() { }
 
  private:
   const intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
-class PushArgumentInstr : public TemplateInstruction<1> {
+class PushArgumentInstr : public Definition {
  public:
-  explicit PushArgumentInstr(Value* value) {
+  explicit PushArgumentInstr(Value* value) : value_(value), locs_(NULL) {
     ASSERT(value != NULL);
-    inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(PushArgument)
 
+  intptr_t InputCount() const { return 1; }
+  Value* InputAt(intptr_t i) const {
+    ASSERT(i == 0);
+    return value_;
+  }
+  void SetInputAt(intptr_t i, Value* value) {
+    ASSERT(i == 0);
+    value_ = value;
+  }
+
   virtual intptr_t ArgumentCount() const { return 0; }
 
-  Value* value() const { return inputs_[0]; }
+  virtual RawAbstractType* CompileType() const;
 
-  virtual LocationSummary* MakeLocationSummary() const;
+  Value* value() const { return value_; }
+
+  virtual LocationSummary* locs() {
+    if (locs_ == NULL) {
+      locs_ = MakeLocationSummary();
+    }
+    return locs_;
+  }
+
+  LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   virtual bool CanDeoptimize() const { return false; }
 
+  bool WasEliminated() const {
+    return next() == NULL;
+  }
+
+  virtual void RemoveInputUses() { value_->RemoveFromUseList(); }
+
  private:
+  Value* value_;
+  LocationSummary* locs_;
+
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
 class ReturnInstr : public TemplateInstruction<1> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : deopt_id_(Isolate::Current()->GetNextDeoptId()),
         token_pos_(token_pos) {
     ASSERT(value != NULL);
@@ skipping 220 matching lines @@
 
 #undef DECLARE_INSTRUCTION
 
 
 class Environment : public ZoneAllocated {
  public:
   // Construct an environment by copying from an array of values.
   explicit Environment(const GrowableArray<Value*>& values,
                        intptr_t fixed_parameter_count)
       : values_(values.length()),
-        location_count_(0),
         locations_(NULL),
         fixed_parameter_count_(fixed_parameter_count) {
     values_.AddArray(values);
   }
 
+  void set_locations(Location* locations) {
+    ASSERT(locations_ == NULL);
+    locations_ = locations;
+  }
+
   const GrowableArray<Value*>& values() const {
     return values_;
   }
 
-  // Initialize locations for the environment values on behalf of the
-  // register allocator.  The initial live ranges of environment uses extend
-  // from the block start position to the environment position.
-  void InitializeLocations(FlowGraphAllocator* allocator,
-                           intptr_t block_start_pos,
-                           intptr_t environment_pos);
-
   GrowableArray<Value*>* values_ptr() {
     return &values_;
   }
 
   Location LocationAt(intptr_t ix) const {
-    ASSERT((ix >= 0) && (ix < location_count_));
+    ASSERT((ix >= 0) && (ix < values_.length()));
     return locations_[ix];
   }
 
   Location* LocationSlotAt(intptr_t ix) const {
-    ASSERT((ix >= 0) && (ix < location_count_));
+    ASSERT((ix >= 0) && (ix < values_.length()));
     return &locations_[ix];
   }
 
   intptr_t fixed_parameter_count() const {
     return fixed_parameter_count_;
   }
 
   void PrintTo(BufferFormatter* f) const;
 
  private:
   GrowableArray<Value*> values_;
-  intptr_t location_count_;
   Location* locations_;
   const intptr_t fixed_parameter_count_;
 
   DISALLOW_COPY_AND_ASSIGN(Environment);
 };
 
 
 // Visitor base class to visit each instruction and computation in a flow
 // graph as defined by a reversed list of basic blocks.
 class FlowGraphVisitor : public ValueObject {
@@ skipping 24 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_