Support for unboxed 64-bit integer bitwise operations and equality on ia32.

runtime/vm/flow_graph_allocator.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_FLOW_GRAPH_ALLOCATOR_H_
 #define VM_FLOW_GRAPH_ALLOCATOR_H_
 
 #include "vm/growable_array.h"
 #include "vm/intermediate_language.h"
 
@@ skipping 15 matching lines @@
 
   void AllocateRegisters();
 
   // Build live-in and live-out sets for each block.
   void AnalyzeLiveness();
 
   // Map a virtual register number to its live range.
   LiveRange* GetLiveRange(intptr_t vreg);
 
  private:
+  void CollectRepresentations();
+
   // Eliminate unnecessary environments from the IL.
   void EliminateEnvironmentUses();
 
   // Compute initial values for live-out, kill and live-in sets.
   void ComputeInitialSets();
 
   // Update live-out set for the given block: live-out should contain
   // all values that are live-in for block's successors.
   // Returns true if live-out set was changed.
   bool UpdateLiveOut(const BlockEntryInstr& instr);
@@ skipping 138 matching lines @@
   // Spill the given live range from the given position until some
   // position preceding the to position.
   void SpillBetween(LiveRange* range, intptr_t from, intptr_t to);
 
   // Mark the live range as a live object pointer at all safepoints
   // contained in the range.
   void MarkAsObjectAtSafepoints(LiveRange* range);
 
   MoveOperands* AddMoveAt(intptr_t pos, Location to, Location from);
 
-  Location MakeRegisterLocation(intptr_t reg) {
-    return Location::MachineRegisterLocation(register_kind_, reg);
+  Location MakeRegisterLocation(intptr_t reg, Location::Representation rep) {
+    return Location::MachineRegisterLocation(register_kind_, reg, rep);
   }
 
   void PrintLiveRanges();
 
   const FlowGraph& flow_graph_;
+
+  // Set of SSA values that have unboxed mint representation. Indexed
+  // by SSA temp index.
+  BitVector* mint_values_;
+
   const GrowableArray<BlockEntryInstr*>& block_order_;
   const GrowableArray<BlockEntryInstr*>& postorder_;
 
   // Mapping between lifetime positions and instructions.
   GrowableArray<Instruction*> instructions_;
 
   // Mapping between lifetime positions and blocks containing them.
   GrowableArray<BlockInfo*> block_info_;
 
   // Live-out sets for each block.  They contain indices of SSA values
@@ skipping 231 matching lines @@
   const intptr_t pos_;
   LocationSummary* const locs_;
 
   SafepointPosition* next_;
 };
 
 
 // LiveRange represents a sequence of UseIntervals for a given SSA value.
 class LiveRange : public ZoneAllocated {
  public:
-  explicit LiveRange(intptr_t vreg)
+  explicit LiveRange(intptr_t vreg, Location::Representation rep)
     : vreg_(vreg),
+      representation_(rep),
       assigned_location_(),
       spill_slot_(),
       uses_(NULL),
       first_use_interval_(NULL),
       last_use_interval_(NULL),
       first_safepoint_(NULL),
       last_safepoint_(NULL),
       next_sibling_(NULL),
       finger_() {
   }
 
   static LiveRange* MakeTemp(intptr_t pos, Location* location_slot);
 
   intptr_t vreg() const { return vreg_; }
+  Location::Representation representation() const { return representation_; }
   LiveRange* next_sibling() const { return next_sibling_; }
   UsePosition* first_use() const { return uses_; }
   void set_first_use(UsePosition* use) { uses_ = use; }
   UseInterval* first_use_interval() const { return first_use_interval_; }
   UseInterval* last_use_interval() const { return last_use_interval_; }
   Location assigned_location() const { return assigned_location_; }
   intptr_t Start() const { return first_use_interval()->start(); }
   intptr_t End() const { return last_use_interval()->end(); }
 
   SafepointPosition* first_safepoint() const { return first_safepoint_; }
@@ skipping 32 matching lines @@
 
   // True if the range contains the given position.
   bool Contains(intptr_t pos) const;
 
   Location spill_slot() const {
     return spill_slot_;
   }
 
  private:
   LiveRange(intptr_t vreg,
+            Location::Representation rep,
             UsePosition* uses,
             UseInterval* first_use_interval,
             UseInterval* last_use_interval,
             SafepointPosition* first_safepoint,
             LiveRange* next_sibling)
     : vreg_(vreg),
+      representation_(rep),
       assigned_location_(),
       uses_(uses),
       first_use_interval_(first_use_interval),
       last_use_interval_(last_use_interval),
       first_safepoint_(first_safepoint),
       last_safepoint_(NULL),
       next_sibling_(next_sibling),
       finger_() {
   }
 
   const intptr_t vreg_;
+  Location::Representation representation_;
   Location assigned_location_;
   Location spill_slot_;
 
   UsePosition* uses_;
   UseInterval* first_use_interval_;
   UseInterval* last_use_interval_;
 
   SafepointPosition* first_safepoint_;
   SafepointPosition* last_safepoint_;
 
   LiveRange* next_sibling_;
 
   AllocationFinger finger_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_ALLOCATOR_H_