Refactor building arguments for InstanceCall and fix deoptimization environment for pushed argument…

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 124 matching lines @@
     return (ic_data() != NULL) && !ic_data()->IsNull();
   }
 
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr) = 0;
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
+  // Call computations override this function and return the
+  // number of pushed arguments.
+  virtual intptr_t ArgumentCount() const = 0;
+
   // Static type of the computation.
   virtual RawAbstractType* StaticType() const = 0;
 
   // Mutate assigned_vars to add the local variable index for all
   // frame-allocated locals assigned to by the computation.
   virtual void RecordAssignedVars(BitVector* assigned_vars,
                                   intptr_t fixed_parameter_count);
 
   virtual const char* DebugName() const = 0;
 
@@ skipping 142 matching lines @@
   DISALLOW_COPY_AND_ASSIGN(Value);
 };
 
 
 // Functions defined in all concrete computation classes.
 #define DECLARE_COMPUTATION(ShortName)                                         \
   virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr);            \
   virtual ComputationType computation_type() const {                           \
     return Computation::k##ShortName;                                          \
   }                                                                            \
+  virtual intptr_t ArgumentCount() const { return 0; }                         \
   virtual const char* DebugName() const { return #ShortName; }                 \
   virtual RawAbstractType* StaticType() const;                                 \
   virtual LocationSummary* MakeLocationSummary() const;                        \
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
 // Functions defined in all concrete value classes.
 #define DECLARE_VALUE(ShortName)                                               \
   DECLARE_COMPUTATION(ShortName)                                               \
   virtual void PrintTo(BufferFormatter* f) const;
 
 
+// Function defined in all call computation classes.
+#define DECLARE_CALL_COMPUTATION(ShortName)                                    \
+  virtual void Accept(FlowGraphVisitor* visitor, BindInstr* instr);            \
+  virtual ComputationType computation_type() const {                           \
+    return Computation::k##ShortName;                                          \
+  }                                                                            \
+  virtual intptr_t InputCount() const { return 0; }                            \
+  virtual Value* InputAt(intptr_t i) const {                                   \
+    UNREACHABLE();                                                             \
+    return NULL;                                                               \
+  }                                                                            \
+  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }         \
+  virtual const char* DebugName() const { return #ShortName; }                 \
+  virtual RawAbstractType* StaticType() const;                                 \
+  virtual LocationSummary* MakeLocationSummary() const;                        \
+  virtual void EmitNativeCode(FlowGraphCompiler* compiler);
+
+
 class Definition;
 class PhiInstr;
 
 class UseVal : public Value {
  public:
   explicit UseVal(Definition* definition) : definition_(definition) {}
 
   DECLARE_VALUE(Use)
 
   inline Definition* definition() const;
@@ skipping 131 matching lines @@
 
 class ClosureCallComp : public Computation {
  public:
   ClosureCallComp(ClosureCallNode* node,
                   intptr_t try_index,
                   ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         try_index_(try_index),
         arguments_(arguments) { }
 
-  DECLARE_COMPUTATION(ClosureCall)
+  DECLARE_CALL_COMPUTATION(ClosureCall)
 
   const Array& argument_names() const { return ast_node_.arguments()->names(); }
   intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t try_index() const { return try_index_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
-  virtual intptr_t InputCount() const { return 0; }
-  virtual Value* InputAt(intptr_t i) const {
-    UNREACHABLE();
-    return NULL;
-  }
-  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
-
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const ClosureCallNode& ast_node_;
   const intptr_t try_index_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
 
   DISALLOW_COPY_AND_ASSIGN(ClosureCallComp);
 };
 
 
 class InstanceCallComp : public Computation {
  public:
   InstanceCallComp(intptr_t token_pos,
                    intptr_t try_index,
                    const String& function_name,
                    Token::Kind token_kind,
-                   ZoneGrowableArray<Value*>* arguments,
+                   ZoneGrowableArray<PushArgumentInstr*>* arguments,
                    const Array& argument_names,
                    intptr_t checked_argument_count)
       : token_pos_(token_pos),
         try_index_(try_index),
         function_name_(function_name),
         token_kind_(token_kind),
         arguments_(arguments),
         argument_names_(argument_names),
         checked_argument_count_(checked_argument_count) {
     ASSERT(function_name.IsZoneHandle());
     ASSERT(!arguments->is_empty());
     ASSERT(argument_names.IsZoneHandle());
     ASSERT(Token::IsBinaryToken(token_kind) ||
            Token::IsUnaryToken(token_kind) ||
            token_kind == Token::kGET ||
            token_kind == Token::kILLEGAL);
   }
 
-  DECLARE_COMPUTATION(InstanceCall)
+  DECLARE_CALL_COMPUTATION(InstanceCall)
 
   intptr_t token_pos() const { return token_pos_; }
   intptr_t try_index() const { return try_index_; }
   const String& function_name() const { return function_name_; }
   Token::Kind token_kind() const { return token_kind_; }
   intptr_t ArgumentCount() const { return arguments_->length(); }
-  Value* ArgumentAt(intptr_t index) const { return (*arguments_)[index]; }
+  PushArgumentInstr* ArgumentAt(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 intptr_t InputCount() const;
-  virtual Value* InputAt(intptr_t i) const { return ArgumentAt(i); }
-  virtual void SetInputAt(intptr_t i, Value* value) {
-    (*arguments_)[i] = value;
-  }
-
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
-  bool VerifyComputation();
-
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const String& function_name_;
   const Token::Kind token_kind_;  // Binary op, unary op, kGET or kILLEGAL.
-  ZoneGrowableArray<Value*>* const arguments_;
+  ZoneGrowableArray<PushArgumentInstr*>* const arguments_;
   const Array& argument_names_;
   const intptr_t checked_argument_count_;
 
   DISALLOW_COPY_AND_ASSIGN(InstanceCallComp);
 };
 
 
 class PolymorphicInstanceCallComp : public Computation {
  public:
   explicit PolymorphicInstanceCallComp(InstanceCallComp* comp)
       : instance_call_(comp) {
     ASSERT(instance_call_ != NULL);
   }
 
   InstanceCallComp* instance_call() const { return instance_call_; }
 
-  virtual intptr_t InputCount() const { return instance_call()->InputCount(); }
+  virtual intptr_t InputCount() const { return 0; }
   virtual Value* InputAt(intptr_t i) const {
-    return instance_call()->ArgumentAt(i);
+    UNREACHABLE();
+    return NULL;
   }
-  virtual void SetInputAt(intptr_t index, Value* value) {
-    instance_call()->SetInputAt(index, value);
-  }
+  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
 
   void PrintTo(BufferFormatter* f) const;
 
   DECLARE_COMPUTATION(PolymorphicInstanceCall)
 
  private:
   InstanceCallComp* instance_call_;
 
   DISALLOW_COPY_AND_ASSIGN(PolymorphicInstanceCallComp);
 };
@@ skipping 116 matching lines @@
       : token_pos_(token_pos),
         try_index_(try_index),
         function_(function),
         argument_names_(argument_names),
         arguments_(arguments),
         recognized_(MethodRecognizer::kUnknown) {
     ASSERT(function.IsZoneHandle());
     ASSERT(argument_names.IsZoneHandle());
   }
 
-  DECLARE_COMPUTATION(StaticCall)
+  DECLARE_CALL_COMPUTATION(StaticCall)
 
   // 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_; }
   intptr_t try_index() const { return try_index_; }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
   MethodRecognizer::Kind recognized() const { return recognized_; }
   void set_recognized(MethodRecognizer::Kind kind) { recognized_ = kind; }
 
-  virtual intptr_t InputCount() const { return 0; }
-  virtual Value* InputAt(intptr_t i) const {
-    UNREACHABLE();
-    return NULL;
-  }
-  virtual void SetInputAt(intptr_t i, Value* value) { UNREACHABLE(); }
-
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   const Function& function_;
   const Array& argument_names_;
   ZoneGrowableArray<PushArgumentInstr*>* arguments_;
   MethodRecognizer::Kind recognized_;
 
@@ skipping 495 matching lines @@
 
  private:
   const intptr_t token_pos_;
   const intptr_t try_index_;
   ZoneGrowableArray<Value*>* const elements_;
 
   DISALLOW_COPY_AND_ASSIGN(CreateArrayComp);
 };
 
 
-class CreateClosureComp : public TemplateComputation<0> {
+class CreateClosureComp : public Computation {
  public:
   CreateClosureComp(ClosureNode* node,
                     intptr_t try_index,
                     ZoneGrowableArray<PushArgumentInstr*>* arguments)
       : ast_node_(*node),
         try_index_(try_index),
         arguments_(arguments) { }
 
-  DECLARE_COMPUTATION(CreateClosure)
+  DECLARE_CALL_COMPUTATION(CreateClosure)
 
   intptr_t token_pos() const { return ast_node_.token_pos(); }
   intptr_t try_index() const { return try_index_; }
   const Function& function() const { return ast_node_.function(); }
 
   intptr_t ArgumentCount() const { return arguments_->length(); }
   PushArgumentInstr* ArgumentAt(intptr_t index) const {
     return (*arguments_)[index];
   }
 
@@ skipping 479 matching lines @@
   BlockEntryInstr* AsBlockEntry() {
     return IsBlockEntry() ? reinterpret_cast<BlockEntryInstr*>(this) : NULL;
   }
   virtual bool IsDefinition() const { return false; }
   virtual Definition* AsDefinition() { return NULL; }
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 0;
 
+  // Call instructions override this function and return the
+  // number of pushed arguments.
+  virtual intptr_t ArgumentCount() const = 0;
+
   // Visiting support.
   virtual void Accept(FlowGraphVisitor* visitor) = 0;
 
   Instruction* previous() const { return previous_; }
   void set_previous(Instruction* instr) {
     ASSERT(!IsBlockEntry());
     previous_ = instr;
   }
 
   Instruction* next() const { return next_; }
   void set_next(Instruction* instr) {
     ASSERT(!IsGraphEntry());
     ASSERT(!IsReturn());
     ASSERT(!IsBranch());
     ASSERT(!IsPhi());
     ASSERT(instr == NULL || !instr->IsBlockEntry());
     // TODO(fschneider): Also add Throw and ReThrow to the list of instructions
     // that do not have a successor. Currently, the graph builder will continue
     // to append instruction in case of a Throw inside an expression. This
     // condition should be handled in the graph builder
     next_ = instr;
   }
 
+  // Removed this instruction from the graph.
+  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);
 
   // Discover basic-block structure by performing a recursive depth first
   // traversal of the instruction graph reachable from this instruction.  As
@@ skipping 64 matching lines @@
   Instruction* next_;
   Environment* env_;
   DISALLOW_COPY_AND_ASSIGN(Instruction);
 };
 
 
 class InstructionWithInputs : public Instruction {
  public:
   InstructionWithInputs() : locs_(NULL) { }
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   virtual LocationSummary* locs() {
     if (locs_ == NULL) {
       locs_ = MakeLocationSummary();
     }
     return locs_;
   }
 
   virtual LocationSummary* MakeLocationSummary() const = 0;
 
  private:
@@ skipping 46 matching lines @@
 
   virtual void DiscoverBlocks(
       BlockEntryInstr* current_block,
       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 ArgumentCount() const { return 0; }
+
  protected:
   BlockEntryInstr()
       : preorder_number_(-1),
         postorder_number_(-1),
         block_id_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL) { }
 
  private:
@@ skipping 238 matching lines @@
  public:
   enum UseKind { kUnused, kUsed };
 
   BindInstr(UseKind used, Computation* computation)
       : computation_(computation), is_used_(used != kUnused) {
     ASSERT(computation != NULL);
   }
 
   DECLARE_INSTRUCTION(Bind)
 
+  virtual intptr_t ArgumentCount() const {
+    return computation()->ArgumentCount();
+  }
+
   Computation* computation() const { return computation_; }
   void set_computation(Computation* value) { computation_ = value; }
   bool is_used() const { return is_used_; }
 
   // Static type of the underlying computation.
   virtual RawAbstractType* StaticType() const {
     return computation()->StaticType();
   }
 
   virtual void RecordAssignedVars(BitVector* assigned_vars,
@@ skipping 17 matching lines @@
  public:
   explicit PhiInstr(intptr_t num_inputs) : inputs_(num_inputs) {
     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; }
+
   DECLARE_INSTRUCTION(Phi)
 
  private:
   GrowableArray<Value*> inputs_;
 
   DISALLOW_COPY_AND_ASSIGN(PhiInstr);
 };
 
 
 class ParameterInstr : public Definition {
  public:
   explicit ParameterInstr(intptr_t index) : index_(index) { }
 
   intptr_t index() const { return index_; }
 
   // Static type of the passed-in parameter.
   virtual RawAbstractType* StaticType() const;
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   DECLARE_INSTRUCTION(Parameter)
 
  private:
   const intptr_t index_;
 
   DISALLOW_COPY_AND_ASSIGN(ParameterInstr);
 };
 
 
 class PushArgumentInstr : public InstructionWithInputs {
@@ skipping 258 matching lines @@
 };
 
 
 class ParallelMoveInstr : public Instruction {
  public:
   ParallelMoveInstr() : moves_(4) {
   }
 
   DECLARE_INSTRUCTION(ParallelMove)
 
+  virtual intptr_t ArgumentCount() const { return 0; }
+
   MoveOperands* AddMove(Location dest, Location src) {
     MoveOperands* move = new MoveOperands(dest, src);
     moves_.Add(move);
     return move;
   }
 
   MoveOperands* MoveOperandsAt(intptr_t index) const { return moves_[index]; }
 
   void SetSrcSlotAt(intptr_t index, const Location& loc);
   void SetDestSlotAt(intptr_t index, const Location& loc);
@@ skipping 84 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_