Support Int32 representation for selected binary operations.

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 176 matching lines @@
     case DeoptInstr::kConstant:
     case DeoptInstr::kPp:
     case DeoptInstr::kCallerPp:
     case DeoptInstr::kMaterializedObjectRef:
     case DeoptInstr::kFloat32x4:
     case DeoptInstr::kInt32x4:
     case DeoptInstr::kFloat64x2:
     case DeoptInstr::kWord:
     case DeoptInstr::kDouble:
     case DeoptInstr::kMintPair:
+    case DeoptInstr::kInt32:
+    case DeoptInstr::kUint32:
       return true;
 
     case DeoptInstr::kRetAddress:
     case DeoptInstr::kPcMarker:
     case DeoptInstr::kCallerFp:
     case DeoptInstr::kCallerPc:
       return false;
 
     case DeoptInstr::kSuffix:
     case DeoptInstr::kMaterializeObject:
@@ skipping 322 matching lines @@
   class LoRegister : public BitField<intptr_t, 0, kFieldWidth> { };
   class HiRegister : public BitField<intptr_t, kFieldWidth, kFieldWidth> { };
 
   const CpuRegisterSource lo_;
   const CpuRegisterSource hi_;
 
   DISALLOW_COPY_AND_ASSIGN(DeoptMintPairInstr);
 };
 
 
-class DeoptUint32Instr : public DeoptIntegerInstrBase {
+template<DeoptInstr::Kind K, typename T>
+class DeoptIntInstr : public DeoptIntegerInstrBase {
  public:
-  explicit DeoptUint32Instr(intptr_t source_index)
+  explicit DeoptIntInstr(intptr_t source_index)
       : DeoptIntegerInstrBase(), source_(source_index) {
   }
 
-  explicit DeoptUint32Instr(const CpuRegisterSource& source)
+  explicit DeoptIntInstr(const CpuRegisterSource& source)
       : DeoptIntegerInstrBase(), source_(source) {
   }
 
   virtual intptr_t source_index() const { return source_.source_index(); }
-  virtual DeoptInstr::Kind kind() const { return kUint32; }
+  virtual DeoptInstr::Kind kind() const { return K; }
 
   virtual const char* ArgumentsToCString() const {
     return source_.ToCString();
   }
 
   virtual int64_t GetValue(DeoptContext* deopt_context) {
-    return static_cast<int64_t>(source_.Value<uint32_t>(deopt_context));
+    return static_cast<int64_t>(source_.Value<T>(deopt_context));
   }
 
  private:
   const CpuRegisterSource source_;
 
-  DISALLOW_COPY_AND_ASSIGN(DeoptUint32Instr);
+  DISALLOW_COPY_AND_ASSIGN(DeoptIntInstr);
 };
 
 
+typedef DeoptIntInstr<DeoptInstr::kUint32, uint32_t> DeoptUint32Instr;
+typedef DeoptIntInstr<DeoptInstr::kInt32, int32_t> DeoptInt32Instr;
+
+
 template<DeoptInstr::Kind K,
          typename Type,
          typename RawObjectType>
 class DeoptFpuInstr: public DeoptInstr {
  public:
   explicit DeoptFpuInstr(intptr_t source_index)
       : source_(source_index) {}
 
   explicit DeoptFpuInstr(const FpuRegisterSource& source)
       : source_(source) {}
@@ skipping 309 matching lines @@
 
 DeoptInstr* DeoptInstr::Create(intptr_t kind_as_int, intptr_t source_index) {
   Kind kind = static_cast<Kind>(kind_as_int);
   switch (kind) {
     case kWord:
       return new DeoptWordInstr(source_index);
     case kDouble:
       return new DeoptDoubleInstr(source_index);
     case kMintPair:
       return new DeoptMintPairInstr(source_index);
+    case kInt32:
+      return new DeoptInt32Instr(source_index);
     case kUint32:
       return new DeoptUint32Instr(source_index);
     case kFloat32x4:
       return new DeoptFloat32x4Instr(source_index);
     case kFloat64x2:
       return new DeoptFloat64x2Instr(source_index);
     case kInt32x4:
       return new DeoptInt32x4Instr(source_index);
     case kRetAddress:
       return new DeoptRetAddressInstr(source_index);
@@ skipping 22 matching lines @@
 
 
 const char* DeoptInstr::KindToCString(Kind kind) {
   switch (kind) {
     case kWord:
       return "word";
     case kDouble:
       return "double";
     case kMintPair:
       return "mint";
+    case kInt32:
+      return "int32";
     case kUint32:
       return "uint32";
     case kFloat32x4:
       return "float32x4";
     case kFloat64x2:
       return "float64x2";
     case kInt32x4:
       return "int32x4";
     case kRetAddress:
       return "retaddr";
@@ skipping 165 matching lines @@
           ToCpuRegisterSource(source_loc));
         break;
       case kUnboxedMint: {
         ASSERT(source_loc.IsPairLocation());
         PairLocation* pair = source_loc.AsPairLocation();
         deopt_instr = new(isolate()) DeoptMintPairInstr(
             ToCpuRegisterSource(pair->At(0)),
             ToCpuRegisterSource(pair->At(1)));
         break;
       }
+      case kUnboxedInt32:
+        deopt_instr = new(isolate()) DeoptInt32Instr(
+          ToCpuRegisterSource(source_loc));

[srdjan, 2014/08/27 16:17:12]

4 spaces

[Vyacheslav Egorov (Google), 2014/08/28 20:48:36]

Done.

+        break;
       case kUnboxedUint32:
         deopt_instr = new(isolate()) DeoptUint32Instr(
           ToCpuRegisterSource(source_loc));
         break;
       case kUnboxedDouble:
         deopt_instr = new(isolate()) DeoptDoubleInstr(
             ToFpuRegisterSource(source_loc, Location::kDoubleStackSlot));
         break;
       case kUnboxedFloat32x4:
         deopt_instr = new(isolate()) DeoptFloat32x4Instr(
@@ skipping 188 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