Add Uint32 representation

runtime/vm/deopt_instructions.cc

 // 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.
 
 #include "vm/deopt_instructions.h"
 
 #include "vm/assembler.h"
 #include "vm/code_patcher.h"
 #include "vm/intermediate_language.h"
 #include "vm/locations.h"
@@ skipping 872 matching lines @@
   }
 
  private:
   const intptr_t slot_;
   const Register reg_;
   const bool flip_;
   DISALLOW_COPY_AND_ASSIGN(DeoptMintStackSlotRegisterInstr);
 };
 
 
+class DeoptUint32RegisterInstr: public DeoptInstr {
+ public:
+  explicit DeoptUint32RegisterInstr(intptr_t reg_as_int)
+      : reg_(static_cast<Register>(reg_as_int)) {}
+
+  virtual intptr_t source_index() const { return static_cast<intptr_t>(reg_); }
+  virtual DeoptInstr::Kind kind() const { return kUint32Register; }
+
+  virtual const char* ToCString() const {
+    return Isolate::Current()->current_zone()->PrintToString(
+        "uint32 %s", Assembler::RegisterName(reg_));
+  }
+
+  void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
+    uint32_t low = static_cast<uint32_t>(deopt_context->RegisterValue(reg_));
+    int64_t value = Utils::LowHighTo64Bits(low, 0);
+    if (Smi::IsValid(value)) {
+      *dest_addr = reinterpret_cast<intptr_t>(
+          Smi::New(static_cast<intptr_t>(value)));
+    } else {
+      *reinterpret_cast<RawSmi**>(dest_addr) = Smi::New(0);
+      deopt_context->DeferMintMaterialization(
+          value, reinterpret_cast<RawMint**>(dest_addr));
+    }
+  }
+
+ private:
+  const Register reg_;
+
+  DISALLOW_COPY_AND_ASSIGN(DeoptUint32RegisterInstr);
+};
+
+
+class DeoptUint32StackSlotInstr : public DeoptInstr {
+ public:
+  explicit DeoptUint32StackSlotInstr(intptr_t source_index)
+      : stack_slot_index_(source_index) {
+    ASSERT(stack_slot_index_ >= 0);
+  }
+
+  virtual intptr_t source_index() const { return stack_slot_index_; }
+  virtual DeoptInstr::Kind kind() const { return kUint32StackSlot; }
+
+  virtual const char* ToCString() const {
+    return Isolate::Current()->current_zone()->PrintToString(
+        "uint32 s%" Pd "", stack_slot_index_);
+  }
+
+  void Execute(DeoptContext* deopt_context, intptr_t* dest_addr) {
+    intptr_t source_index =
+       deopt_context->source_frame_size() - stack_slot_index_ - 1;
+    intptr_t* source_addr =

[Florian Schneider, 2014/07/08 12:24:28]

maybe uint32_t*?

[Cutch, 2014/07/09 17:48:25]

Done.

+        deopt_context->GetSourceFrameAddressAt(source_index);
+    int64_t value = Utils::LowHighTo64Bits(*source_addr, 0);
+    if (Smi::IsValid(value)) {
+      *dest_addr = reinterpret_cast<intptr_t>(
+          Smi::New(static_cast<intptr_t>(value)));
+    } else {
+      *reinterpret_cast<RawSmi**>(dest_addr) = Smi::New(0);
+      deopt_context->DeferMintMaterialization(
+          value, reinterpret_cast<RawMint**>(dest_addr));
+    }
+  }
+
+ private:
+  const intptr_t stack_slot_index_;  // First argument is 0, always >= 0.
+
+  DISALLOW_COPY_AND_ASSIGN(DeoptUint32StackSlotInstr);
+};
+
+
 // Deoptimization instruction moving an XMM register.
 class DeoptFloat32x4FpuRegisterInstr: public DeoptInstr {
  public:
   explicit DeoptFloat32x4FpuRegisterInstr(intptr_t reg_as_int)
       : reg_(static_cast<FpuRegister>(reg_as_int)) {}
 
   virtual intptr_t source_index() const { return static_cast<intptr_t>(reg_); }
   virtual DeoptInstr::Kind kind() const { return kFloat32x4FpuRegister; }
 
   virtual const char* ToCString() const {
@@ skipping 389 matching lines @@
       return new DeoptMintStackSlotPairInstr(lo_slot, hi_slot);
     }
     case kMintStackSlotRegister: {
       intptr_t slot =
           DeoptMintStackSlotRegisterInstr::Slot::decode(source_index);
       intptr_t reg_as_int =
           DeoptMintStackSlotRegisterInstr::Reg::decode(source_index);
       bool flip = DeoptMintStackSlotRegisterInstr::Flip::decode(source_index);
       return new DeoptMintStackSlotRegisterInstr(slot, reg_as_int, flip);
     }
+    case kUint32Register:
+      return new DeoptUint32RegisterInstr(source_index);
+    case kUint32StackSlot:
+      return new DeoptUint32StackSlotInstr(source_index);
     case kFloat32x4FpuRegister:
         return new DeoptFloat32x4FpuRegisterInstr(source_index);
     case kFloat64x2FpuRegister:
         return new DeoptFloat64x2FpuRegisterInstr(source_index);
     case kInt32x4FpuRegister:
         return new DeoptInt32x4FpuRegisterInstr(source_index);
     case kPcMarker: return new DeoptPcMarkerInstr(source_index);
     case kPp: return new DeoptPpInstr(source_index);
     case kCallerFp: return new DeoptCallerFpInstr();
     case kCallerPp: return new DeoptCallerPpInstr();
@@ skipping 108 matching lines @@
 
 
 void DeoptInfoBuilder::AddCopy(Value* value,
                                const Location& source_loc,
                                const intptr_t dest_index) {
   DeoptInstr* deopt_instr = NULL;
   if (source_loc.IsConstant()) {
     intptr_t object_table_index = FindOrAddObjectInTable(source_loc.constant());
     deopt_instr = new(isolate()) DeoptConstantInstr(object_table_index);
   } else if (source_loc.IsRegister()) {
-    ASSERT(value->definition()->representation() == kTagged);
-    deopt_instr = new(isolate()) DeoptRegisterInstr(source_loc.reg());
+    if (value->definition()->representation() == kUnboxedUint32) {
+      deopt_instr = new(isolate()) DeoptUint32RegisterInstr(source_loc.reg());
+    } else {
+      ASSERT(value->definition()->representation() == kTagged);
+      deopt_instr = new(isolate()) DeoptRegisterInstr(source_loc.reg());
+    }
   } else if (source_loc.IsFpuRegister()) {
     if (value->definition()->representation() == kUnboxedDouble) {
       deopt_instr = new(isolate()) DeoptFpuRegisterInstr(source_loc.fpu_reg());
     } else if (value->definition()->representation() == kUnboxedFloat32x4) {
       deopt_instr =
           new(isolate()) DeoptFloat32x4FpuRegisterInstr(source_loc.fpu_reg());
     } else if (value->definition()->representation() == kUnboxedInt32x4) {
       deopt_instr =
           new(isolate()) DeoptInt32x4FpuRegisterInstr(source_loc.fpu_reg());
     } else {
       ASSERT(value->definition()->representation() == kUnboxedFloat64x2);
       deopt_instr =
           new(isolate()) DeoptFloat64x2FpuRegisterInstr(source_loc.fpu_reg());
     }
   } else if (source_loc.IsStackSlot()) {
-    ASSERT(value->definition()->representation() == kTagged);
-    intptr_t source_index = CalculateStackIndex(source_loc);
-    deopt_instr = new(isolate()) DeoptStackSlotInstr(source_index);
+    if (value->definition()->representation() == kUnboxedUint32) {
+      intptr_t source_index = CalculateStackIndex(source_loc);
+      deopt_instr = new(isolate()) DeoptUint32StackSlotInstr(source_index);
+    } else {
+      ASSERT(value->definition()->representation() == kTagged);
+      intptr_t source_index = CalculateStackIndex(source_loc);
+      deopt_instr = new(isolate()) DeoptStackSlotInstr(source_index);
+    }
   } else if (source_loc.IsDoubleStackSlot()) {
     ASSERT(value->definition()->representation() == kUnboxedDouble);
     intptr_t source_index = CalculateStackIndex(source_loc);
     deopt_instr = new(isolate()) DeoptDoubleStackSlotInstr(source_index);
   } else if (source_loc.IsQuadStackSlot()) {
     intptr_t source_index = CalculateStackIndex(source_loc);
     if (value->definition()->representation() == kUnboxedFloat32x4) {
       deopt_instr = new(isolate()) DeoptFloat32x4StackSlotInstr(source_index);
     } else if (value->definition()->representation() == kUnboxedInt32x4) {
       deopt_instr = new(isolate()) DeoptInt32x4StackSlotInstr(source_index);
@@ skipping 207 matching lines @@
                           Smi* offset,
                           DeoptInfo* info,
                           Smi* reason) {
   intptr_t i = index * kEntrySize;
   *offset ^= table.At(i);
   *info ^= table.At(i + 1);
   *reason ^= table.At(i + 2);
 }
 
 }  // namespace dart