Use GPRs for mints

runtime/vm/flow_graph_allocator.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_FLOW_GRAPH_ALLOCATOR_H_
 #define VM_FLOW_GRAPH_ALLOCATOR_H_
 
 #include "vm/flow_graph.h"
 #include "vm/growable_array.h"
 #include "vm/intermediate_language.h"
@@ skipping 95 matching lines @@
                                        BitVector* interference_set);
   void ProcessEnvironmentUses(BlockEntryInstr* block, Instruction* current);
   void ProcessMaterializationUses(BlockEntryInstr* block,
                                   const intptr_t block_start_pos,
                                   const intptr_t use_pos,
                                   MaterializeObjectInstr* mat);
   void ProcessOneInput(BlockEntryInstr* block,
                        intptr_t pos,
                        Location* in_ref,
                        Value* input,
-                       intptr_t vreg);
+                       intptr_t vreg,
+                       RegisterSet* live_registers);
   void ProcessOneOutput(BlockEntryInstr* block,
                         Instruction* current,
                         intptr_t pos,
                         Location* out,
                         Definition* def,
                         intptr_t vreg,
                         bool output_same_as_first_input,
                         Location* in_ref,
                         Definition* input,
                         intptr_t input_vreg,
@@ skipping 183 matching lines @@
 
   // List of used spill slots. Contains positions after which spill slots
   // become free and can be reused for allocation.
   GrowableArray<intptr_t> spill_slots_;
 
   // For every used spill slot contains a flag determines whether it is
   // QuadSpillSlot to ensure that indexes of quad and double spill slots
   // are disjoint.
   GrowableArray<bool> quad_spill_slots_;
 
+  // Track whether a spill slot is expected to hold a tagged or untagged value.
+  // This is used to keep tagged and untagged spill slots disjoint.

[srdjan, 2014/05/21 17:12:49]

Add a comment why we keep them disjoint

[Cutch, 2014/05/22 06:08:58]

Done.

+  GrowableArray<bool> untagged_spill_slots_;
+
   intptr_t cpu_spill_slot_count_;
 
   DISALLOW_COPY_AND_ASSIGN(FlowGraphAllocator);
 };
 
 
 // Additional information about a block that is not contained in a
 // block entry.
 class BlockInfo : public ZoneAllocated {
  public:
@@ skipping 161 matching lines @@
   void UpdateAfterSplit(intptr_t first_use_after_split_pos);
   bool Advance(intptr_t start);
 
   UseInterval* first_pending_use_interval() const {
     return first_pending_use_interval_;
   }
 
   Location FirstHint();
   UsePosition* FirstRegisterUse(intptr_t after_pos);
   UsePosition* FirstRegisterBeneficialUse(intptr_t after_pos);
+  UsePosition* FirstInterferingUse(intptr_t after_pos);
 
  private:
   UseInterval* first_pending_use_interval_;
   UsePosition* first_register_use_;
   UsePosition* first_register_beneficial_use_;
   UsePosition* first_hinted_use_;
 
   DISALLOW_COPY_AND_ASSIGN(AllocationFinger);
 };
 
@@ skipping 152 matching lines @@
 
   AllocationFinger finger_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_ALLOCATOR_H_