Replace scalarlist optimizations and split external array loads into two IL instructions.

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/growable_array.h"
 #include "vm/intermediate_language.h"
 
@@ skipping 209 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, Location::Representation rep) {
+  Location MakeRegisterLocation(intptr_t reg, Representation rep) {
     return Location::MachineRegisterLocation(register_kind_, reg, rep);
   }
 
   void PrintLiveRanges();
 
   const FlowGraph& flow_graph_;
 
   ReachingDefs reaching_defs_;
 
   // Set of SSA values that have unboxed mint representation. Indexed
   // by SSA temp index.
-  BitVector* mint_values_;
+  GrowableArray<Representation> value_representations_;

[Vyacheslav Egorov (Google), 2013/03/18 18:42:29]

Comment above requires update.

[Florian Schneider, 2013/03/19 11:48:57]

Done.

 
   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_;
 
@@ skipping 267 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, Location::Representation rep)
+  explicit LiveRange(intptr_t vreg, 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),
       has_only_any_uses_in_loops_(0),
       is_loop_phi_(false),
       finger_() {
   }
 
   static LiveRange* MakeTemp(intptr_t pos, Location* location_slot);
 
   intptr_t vreg() const { return vreg_; }
-  Location::Representation representation() const { return representation_; }
+  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 51 matching lines @@
     }
   }
 
   bool is_loop_phi() const { return is_loop_phi_; }
   void mark_loop_phi() {
     is_loop_phi_ = true;
   }
 
  private:
   LiveRange(intptr_t vreg,
-            Location::Representation rep,
+            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),
       has_only_any_uses_in_loops_(0),
       is_loop_phi_(false),
       finger_() {
   }
 
   const intptr_t vreg_;
-  Location::Representation representation_;
+  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_;
 
   intptr_t has_only_any_uses_in_loops_;
   bool is_loop_phi_;
 
   AllocationFinger finger_;
 
   DISALLOW_COPY_AND_ASSIGN(LiveRange);
 };
 
 
 }  // namespace dart
 
 #endif  // VM_FLOW_GRAPH_ALLOCATOR_H_