Add support for fixed parameters in the register allocator.

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 90 matching lines @@
   M(NumberNegate, NumberNegateComp)                                            \
   M(CheckStackOverflow, CheckStackOverflowComp)                                \
   M(ToDouble, ToDoubleComp)                                                    \
 
 
 #define FORWARD_DECLARATION(ShortName, ClassName) class ClassName;
 FOR_EACH_COMPUTATION(FORWARD_DECLARATION)
 #undef FORWARD_DECLARATION
 
 // Forward declarations.
+class AssignedVarsCollector;

[Kevin Millikin (Google), 2012/07/26 09:29:08]

Huh?

[Vyacheslav Egorov (Google), 2012/07/26 11:33:53]

Artifacts :-). Removed.

 class BindInstr;
 class BranchInstr;
 class BufferFormatter;
 class ComparisonComp;
 class Instruction;
 class Value;
 
 class Computation : public ZoneAllocated {
  public:
   static const int kNoCid = -1;
@@ skipping 18 matching lines @@
 
   virtual intptr_t InputCount() const = 0;
   virtual Value* InputAt(intptr_t i) const = 0;
   virtual void SetInputAt(intptr_t i, Value* value) = 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);
+  virtual void RecordAssignedVars(BitVector* assigned_vars,
+                                  intptr_t fixed_param_count);
 
   virtual const char* DebugName() const = 0;
 
   // 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;
 
   // Returns structure describing location constraints required
   // to emit native code for this computation.
@@ skipping 605 matching lines @@
         context_level_(context_level) {
     inputs_[0] = value;
   }
 
   DECLARE_COMPUTATION(StoreLocal)
 
   const LocalVariable& local() const { return local_; }
   Value* value() const { return inputs_[0]; }
   intptr_t context_level() const { return context_level_; }
 
-  virtual void RecordAssignedVars(BitVector* assigned_vars);
+  virtual void RecordAssignedVars(BitVector* assigned_vars,
+                                  intptr_t fixed_param_count);
 
   virtual void PrintOperandsTo(BufferFormatter* f) const;
 
  private:
   const LocalVariable& local_;
   const intptr_t context_level_;
 
   DISALLOW_COPY_AND_ASSIGN(StoreLocalComp);
 };
 
@@ skipping 1001 matching lines @@
   // 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.
   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 variable_count,
+      intptr_t fixed_param_count) {
     // Never called for instructions except block entries and branches.
     UNREACHABLE();
   }
 
   // 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);
+  virtual void RecordAssignedVars(BitVector* assigned_vars,
+                                  intptr_t fixed_param_count);
 
   // Printing support.
   virtual void PrintTo(BufferFormatter* f) const = 0;
   virtual void PrintToVisualizer(BufferFormatter* f) const = 0;
 
 #define INSTRUCTION_TYPE_CHECK(type)                                           \
   virtual bool Is##type() const { return false; }                              \
   virtual type##Instr* As##type() { return NULL; }
 FOR_EACH_INSTRUCTION(INSTRUCTION_TYPE_CHECK)
 #undef INSTRUCTION_TYPE_CHECK
@@ skipping 96 matching lines @@
 
   Instruction* last_instruction() const { return last_instruction_; }
   void set_last_instruction(Instruction* instr) { last_instruction_ = instr; }
 
   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 variable_count,
+      intptr_t fixed_param_count);
 
  protected:
   BlockEntryInstr()
       : preorder_number_(-1),
         postorder_number_(-1),
         block_id_(-1),
         dominator_(NULL),
         dominated_blocks_(1),
         last_instruction_(NULL) { }
 
@@ skipping 61 matching lines @@
   Instruction* current_;
 };
 
 
 class GraphEntryInstr : public BlockEntryInstr {
  public:
   explicit GraphEntryInstr(TargetEntryInstr* normal_entry)
       : BlockEntryInstr(),
         normal_entry_(normal_entry),
         catch_entries_(),
-        start_env_(NULL) { }
+        start_env_(NULL),
+        spill_slot_count_(0) { }
 
   DECLARE_INSTRUCTION(GraphEntry)
 
   virtual intptr_t PredecessorCount() const { return 0; }
   virtual BlockEntryInstr* PredecessorAt(intptr_t index) const {
     UNREACHABLE();
     return NULL;
   }
   virtual void AddPredecessor(BlockEntryInstr* predecessor) { UNREACHABLE(); }
 
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   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 variable_count,
+      intptr_t fixed_param_count);
 
   void AddCatchEntry(TargetEntryInstr* entry) { catch_entries_.Add(entry); }
 
   virtual void PrepareEntry(FlowGraphCompiler* compiler);
 
   Environment* start_env() const { return start_env_; }
   void set_start_env(Environment* env) { start_env_ = env; }
 
+  intptr_t spill_slot_count() const { return spill_slot_count_; }
+  void set_spill_slot_count(intptr_t count) {

[srdjan, 2012/07/26 00:33:56]

ASSERT(count >= 0)

[Vyacheslav Egorov (Google), 2012/07/26 11:33:53]

Done.

+    spill_slot_count_ = count;
+  }
+
  private:
   TargetEntryInstr* normal_entry_;
   GrowableArray<TargetEntryInstr*> catch_entries_;
   Environment* start_env_;
+  intptr_t spill_slot_count_;
 
   DISALLOW_COPY_AND_ASSIGN(GraphEntryInstr);
 };
 
 
 class JoinEntryInstr : public BlockEntryInstr {
  public:
   JoinEntryInstr()
       : BlockEntryInstr(),
         predecessors_(2),  // Two is the assumed to be the common case.
@@ skipping 122 matching lines @@
 
   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);
+  virtual void RecordAssignedVars(BitVector* assigned_vars,
+                                  intptr_t fixed_param_count);
 
   virtual LocationSummary* locs() {
     return computation()->locs();
   }
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
  private:
   Computation* computation_;
   const bool is_used_;
@@ skipping 189 matching lines @@
 
   virtual intptr_t SuccessorCount() const;
   virtual BlockEntryInstr* SuccessorAt(intptr_t index) const;
 
   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 variable_count,
+      intptr_t fixed_param_count);
 
   virtual LocationSummary* MakeLocationSummary() const;
 
   virtual void EmitNativeCode(FlowGraphCompiler* compiler);
 
   void EmitBranchOnCondition(FlowGraphCompiler* compiler,
                              Condition true_condition);
 
  private:
   const intptr_t token_pos_;
@@ skipping 94 matching lines @@
 
 #undef DECLARE_INSTRUCTION
 
 
 class Environment : public ZoneAllocated {
  public:
   // Construct an environment by copying from an array of values.
   // TODO(vegorov): it's absolutely crucial that locations_ backing store
   // is preallocated and never reallocated.  We use pointers into it
   // during register allocation.
-  explicit Environment(const GrowableArray<Value*>& values)
-      : values_(values.length()), locations_(values.length()) {
+  explicit Environment(const GrowableArray<Value*>& values,
+                       intptr_t fixed_param_count)
+      : values_(values.length()),
+        locations_(values.length()),
+        fixed_param_count_(fixed_param_count) {
     values_.AddArray(values);
   }
 
   const GrowableArray<Value*>& values() const {
     return values_;
   }
 
   void AddLocation(Location value) {
     locations_.Add(value);
   }
 
   Location LocationAt(intptr_t ix) const {
     return locations_[ix];
   }
 
   Location* LocationSlotAt(intptr_t ix) const {
     return & locations_[ix];
   }
 
+  intptr_t fixed_param_count() const {
+    return fixed_param_count_;
+  }
+
   void PrintTo(BufferFormatter* f) const;
 
  private:
   GrowableArray<Value*> values_;
   GrowableArray<Location> locations_;
+  const intptr_t fixed_param_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 {
  public:
   explicit FlowGraphVisitor(const GrowableArray<BlockEntryInstr*>& block_order)
       : block_order_(block_order) { }
@@ skipping 21 matching lines @@
   const GrowableArray<BlockEntryInstr*>& block_order_;
 
  private:
   DISALLOW_COPY_AND_ASSIGN(FlowGraphVisitor);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_INTERMEDIATE_LANGUAGE_H_