Convert some compiler passes to preserve valid def-use chains.

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 348 matching lines @@
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
   // Remove all inputs (including in the environment) from their
   // definition's use lists.
   void UnuseAllInputs();
 
   // Call instructions override this function and return the number of
   // pushed arguments.
   virtual intptr_t ArgumentCount() const = 0;
-  virtual PushArgumentInstr* ArgumentAt(intptr_t index) const {
+  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
-  };
+  }
+  inline Definition* ArgumentAt(intptr_t index) const;

[Vyacheslav Egorov (Google), 2013/02/08 16:44:49]

I like the naming cleanup.

 
   // Returns true, if this instruction can deoptimize.
   virtual bool CanDeoptimize() const = 0;
 
   // Returns true if the instruction may have side effects.
   virtual bool HasSideEffect() const  = 0;
 
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor) = 0;
 
@@ skipping 1018 matching lines @@
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   Value* value_;
   LocationSummary* locs_;
 
   DISALLOW_COPY_AND_ASSIGN(PushArgumentInstr);
 };
 
 
+inline Definition* Instruction::ArgumentAt(intptr_t index) const {
+  return PushArgumentAt(index)->value()->definition();
+}
+
+
 class ReturnInstr : public TemplateInstruction<1> {
  public:
   ReturnInstr(intptr_t token_pos, Value* value)
       : token_pos_(token_pos) {
     ASSERT(value != NULL);
     inputs_[0] = value;
   }
 
   DECLARE_INSTRUCTION(Return)
 
@@ skipping 647 matching lines @@
       : ast_node_(*node),
         arguments_(arguments) { }
 
   DECLARE_INSTRUCTION(ClosureCall)
   virtual RawAbstractType* CompileType() const;
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
-  PushArgumentInstr* ArgumentAt(intptr_t index) const {
+  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
   virtual intptr_t ResultCid() const { return kDynamicCid; }
@@ skipping 41 matching lines @@
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
   // ICData can be replaced by optimizer.
   void set_ic_data(const ICData* value) { ic_data_ = value; }
 
   intptr_t token_pos() const { return token_pos_; }
   const String& function_name() const { return function_name_; }
   Token::Kind token_kind() const { return token_kind_; }
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
-  PushArgumentInstr* ArgumentAt(intptr_t index) const {
+  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
   const Array& argument_names() const { return argument_names_; }
   intptr_t checked_argument_count() const { return checked_argument_count_; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
@@ skipping 27 matching lines @@
         with_checks_(with_checks) {
     ASSERT(instance_call_ != NULL);
   }
 
   InstanceCallInstr* instance_call() const { return instance_call_; }
   bool with_checks() const { return with_checks_; }
 
   virtual intptr_t ArgumentCount() const {
     return instance_call()->ArgumentCount();
   }
-  PushArgumentInstr* ArgumentAt(intptr_t index) const {
-    return instance_call()->ArgumentAt(index);
+  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
+    return instance_call()->PushArgumentAt(index);
   }
 
   DECLARE_INSTRUCTION(PolymorphicInstanceCall)
   virtual RawAbstractType* CompileType() const;
 
   const ICData& ic_data() const { return ic_data_; }
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
@@ skipping 283 matching lines @@
 
   DECLARE_INSTRUCTION(StaticCall)
   virtual RawAbstractType* CompileType() const;
 
   // Accessors forwarded to the AST node.
   const Function& function() const { return function_; }
   const Array& argument_names() const { return argument_names_; }
   intptr_t token_pos() const { return token_pos_; }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
-  PushArgumentInstr* ArgumentAt(intptr_t index) const {
+  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return true; }
 
   virtual bool HasSideEffect() const { return true; }
 
   virtual intptr_t ResultCid() const { return result_cid_; }
@@ skipping 439 matching lines @@
         arguments_(arguments),
         cid_(Class::Handle(node->constructor().Owner()).id()) {
     // Either no arguments or one type-argument and one instantiator.
     ASSERT(arguments->is_empty() || (arguments->length() == 2));
   }
 
   DECLARE_INSTRUCTION(AllocateObject)
   virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
-  PushArgumentInstr* ArgumentAt(intptr_t index) const {
+  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   const Function& constructor() const { return ast_node_.constructor(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
@@ skipping 47 matching lines @@
  public:
   CreateArrayInstr(intptr_t token_pos,
                    ZoneGrowableArray<PushArgumentInstr*>* arguments,
                    const AbstractType& type,
                    Value* element_type)
       : token_pos_(token_pos),
         arguments_(arguments),
         type_(type) {
 #if defined(DEBUG)
     for (int i = 0; i < ArgumentCount(); ++i) {
-      ASSERT(ArgumentAt(i) != NULL);
+      ASSERT(PushArgumentAt(i) != NULL);
     }
     ASSERT(element_type != NULL);
     ASSERT(type_.IsZoneHandle());
     ASSERT(!type_.IsNull());
     ASSERT(type_.IsFinalized());
 #endif
     inputs_[0] = element_type;
   }
 
   DECLARE_INSTRUCTION(CreateArray)
   virtual RawAbstractType* CompileType() const;
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
+  virtual PushArgumentInstr* PushArgumentAt(intptr_t i) const {
+    return (*arguments_)[i];
+  }
 
   intptr_t token_pos() const { return token_pos_; }
-  PushArgumentInstr* ArgumentAt(intptr_t i) const { return (*arguments_)[i]; }
   const AbstractType& type() const { return type_; }
   Value* element_type() const { return inputs_[0]; }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
   virtual intptr_t ResultCid() const { return kArrayCid; }
@@ skipping 16 matching lines @@
         arguments_(arguments),
         token_pos_(token_pos) { }
 
   DECLARE_INSTRUCTION(CreateClosure)
   virtual RawAbstractType* CompileType() const;
 
   intptr_t token_pos() const { return token_pos_; }
   const Function& function() const { return function_; }
 
   virtual intptr_t ArgumentCount() const { return arguments_->length(); }
-  PushArgumentInstr* ArgumentAt(intptr_t index) const {
+  virtual PushArgumentInstr* PushArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
   virtual bool CanDeoptimize() const { return false; }
 
   virtual bool HasSideEffect() const { return true; }
 
   virtual intptr_t ResultCid() const { return kDynamicCid; }
@@ skipping 1429 matching lines @@
   ForwardInstructionIterator* current_iterator_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_