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

runtime/vm/locations.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_LOCATIONS_H_
 #define VM_LOCATIONS_H_
 
 #include "vm/allocation.h"
 #include "vm/assembler.h"
 #include "vm/bitfield.h"
 
 namespace dart {
 
 class BufferFormatter;
 class Value;
 
+
+enum Representation {
+  kNoRepresentation,
+  kTagged,
+  kUntagged,
+  kUnboxedDouble,
+  kUnboxedMint,
+  kNumRepresentations
+};
+
+
 // Location objects are used to connect register allocator and code generator.
 // Instruction templates used by code generator have a corresponding
 // LocationSummary object which specifies expected location for every input
 // and output.
 // Each location is encoded as a single word: for non-constant locations
 // low 3 bits denote location kind, rest is kind specific location payload
 // e.g. for REGISTER kind payload is register code (value of the Register
 // enumeration), constant locations contain a tagged (low 2 bits are set to 01)
 // Object handle
 class Location : public ValueObject {
@@ skipping 126 matching lines @@
   static Location NoLocation() {
     return Location();
   }
 
   Policy policy() const {
     ASSERT(IsUnallocated());
     return PolicyField::decode(payload());
   }
 
   // Register locations.
-  static Location RegisterLocation(Register reg) {
+  static Location RegisterLocation(Register reg, Representation rep = kTagged) {
     uword payload =
         RegisterField::encode(reg) |
-        RepresentationField::encode(kDouble);  // Unused for Register.
+        RepresentationField::encode(rep);
     return Location(kRegister, payload);
   }
 
   bool IsRegister() const {
     return kind() == kRegister;
   }
 
   Register reg() const {
     ASSERT(IsRegister());
     return RegisterField::decode(payload());
   }
 
-  // FPU registers and double spill slots can contain either doubles
-  // or 64-bit integers.
-  enum Representation {
-    kDouble,
-    kMint
-  };
-
   Representation representation() const {
-    ASSERT(IsFpuRegister() || IsDoubleStackSlot());
     return RepresentationField::decode(payload());
   }
 
   // FpuRegister locations.
   static Location FpuRegisterLocation(FpuRegister reg, Representation rep) {
     uword payload =
         FpuRegisterField::encode(reg) | RepresentationField::encode(rep);
     return Location(kFpuRegister, payload);
   }
 
@@ skipping 25 matching lines @@
     return IsMachineRegisterKind(kind());
   }
 
   intptr_t register_code() const {
     ASSERT(IsMachineRegister());
     return static_cast<intptr_t>(RegisterField::decode(payload()));
   }
 
   // Spill slots.
   static Location StackSlot(intptr_t stack_index,
-                            Representation rep = kDouble) {
+                            Representation rep = kTagged) {
     ASSERT((-kStackIndexBias <= stack_index) &&
            (stack_index < kStackIndexBias));
     uword payload =
         IndexField::encode(static_cast<uword>(kStackIndexBias + stack_index))
       | RepresentationField::encode(rep);
     Location loc(kStackSlot, payload);
     // Ensure that sign is preserved.
     ASSERT(loc.stack_index() == stack_index);
     return loc;
   }
@@ skipping 59 matching lines @@
   uword payload() const {
     return PayloadField::decode(value_);
   }
 
   typedef BitField<Kind, 0, kBitsForKind> KindField;
   typedef BitField<uword, kBitsForKind, kBitsForPayload> PayloadField;
 
   // Layout for kUnallocated locations payload.
   typedef BitField<Policy, 0, 3> PolicyField;
 
-  // Layout for register locations payload. The representation bit is only used
-  // for FpuRegister and unused for Register.
-  static const intptr_t kBitsForRepresentation = 1;
+  // Layout for register locations payload.
+  static const intptr_t kBitsForRepresentation = 3;
+  COMPILE_ASSERT(kNumRepresentations <= (1 << kBitsForRepresentation),
+                 invalid_enum);
   static const intptr_t kBitsForRegister =
       kBitsForPayload - kBitsForRepresentation;
   typedef BitField<Representation,
                    0,
                    kBitsForRepresentation> RepresentationField;
   typedef BitField<Register,
                    kBitsForRepresentation,
                    kBitsForRegister> RegisterField;
   typedef BitField<FpuRegister,
                    kBitsForRepresentation,
                    kBitsForRegister> FpuRegisterField;
 
-  // Layout for stack slots. The representation bit is only used for
-  // DoubleStackSlot and unused for StackSlot.
+  // Layout for stack slots.
   static const intptr_t kBitsForIndex =
       kBitsForPayload - kBitsForRepresentation;
   typedef BitField<uword,
                    kBitsForRepresentation,
                    kBitsForIndex> IndexField;
   static const intptr_t kStackIndexBias =
       static_cast<intptr_t>(1) << (kBitsForIndex - 1);
 
   // Location either contains kind and payload fields or a tagged handle for
   // a constant locations. Values of enumeration Kind are selected in such a
@@ skipping 148 matching lines @@
   BitmapBuilder* stack_bitmap_;
 
   const ContainsCall contains_call_;
   RegisterSet live_registers_;
 };
 
 
 }  // namespace dart
 
 #endif  // VM_LOCATIONS_H_