Allow uint32 value on optimized frames if they are consumed by safe operations.

src/deoptimizer.h

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Redistribution and use in source and binary forms, with or without
 // modification, are permitted provided that the following conditions are
 // met:
 //
 //     * Redistributions of source code must retain the above copyright
 //       notice, this list of conditions and the following disclaimer.
 //     * Redistributions in binary form must reproduce the above
 //       copyright notice, this list of conditions and the following
 //       disclaimer in the documentation and/or other materials provided
@@ skipping 544 matching lines @@
 
 class Translation BASE_EMBEDDED {
  public:
   enum Opcode {
     BEGIN,
     JS_FRAME,
     CONSTRUCT_STUB_FRAME,
     ARGUMENTS_ADAPTOR_FRAME,
     REGISTER,
     INT32_REGISTER,
+    UINT32_REGISTER,
     DOUBLE_REGISTER,
     STACK_SLOT,
     INT32_STACK_SLOT,
+    UINT32_STACK_SLOT,
     DOUBLE_STACK_SLOT,
     LITERAL,
     ARGUMENTS_OBJECT,
 
     // A prefix indicating that the next command is a duplicate of the one
     // that follows it.
     DUPLICATE
   };
 
   Translation(TranslationBuffer* buffer, int frame_count, int jsframe_count,
               Zone* zone)
       : buffer_(buffer),
         index_(buffer->CurrentIndex()),
         zone_(zone) {
     buffer_->Add(BEGIN, zone);
     buffer_->Add(frame_count, zone);
     buffer_->Add(jsframe_count, zone);
   }
 
   int index() const { return index_; }
 
   // Commands.
   void BeginJSFrame(BailoutId node_id, int literal_id, unsigned height);
   void BeginArgumentsAdaptorFrame(int literal_id, unsigned height);
   void BeginConstructStubFrame(int literal_id, unsigned height);
   void StoreRegister(Register reg);
   void StoreInt32Register(Register reg);
+  void StoreUint32Register(Register reg);
   void StoreDoubleRegister(DoubleRegister reg);
   void StoreStackSlot(int index);
   void StoreInt32StackSlot(int index);
+  void StoreUint32StackSlot(int index);
   void StoreDoubleStackSlot(int index);
   void StoreLiteral(int literal_id);
   void StoreArgumentsObject();
   void MarkDuplicate();
 
   Zone* zone() const { return zone_; }
 
   static int NumberOfOperandsFor(Opcode opcode);
 
 #if defined(OBJECT_PRINT) || defined(ENABLE_DISASSEMBLER)
@@ skipping 29 matching lines @@
   DeoptimizingCodeListNode* next_;
 };
 
 
 class SlotRef BASE_EMBEDDED {
  public:
   enum SlotRepresentation {
     UNKNOWN,
     TAGGED,
     INT32,
+    UINT32,
     DOUBLE,
     LITERAL
   };
 
   SlotRef()
       : addr_(NULL), representation_(UNKNOWN) { }
 
   SlotRef(Address addr, SlotRepresentation representation)
       : addr_(addr), representation_(representation) { }
 
   explicit SlotRef(Object* literal)
       : literal_(literal), representation_(LITERAL) { }
 
   Handle<Object> GetValue() {
     switch (representation_) {
       case TAGGED:
         return Handle<Object>(Memory::Object_at(addr_));
 
       case INT32: {
         int value = Memory::int32_at(addr_);
         if (Smi::IsValid(value)) {
           return Handle<Object>(Smi::FromInt(value));
         } else {
           return Isolate::Current()->factory()->NewNumberFromInt(value);
         }
       }
 
+      case UINT32: {
+        uint32_t value = Memory::uint32_at(addr_);
+        if (value <= static_cast<uint32_t>(Smi::kMaxValue)) {

[Massi, 2012/08/16 13:57:55]

Maybe having a Smi::IsValidUint(uint32_t value) method to mirror the existing
Smi::IsValid and a Factory::NewNumberFromUInt method mirroring
Factory::NewNumberFromInt would make the code a bit more readable (the INT32 and
UINT32 cases would be coded in a similar way but calling different methods).

+          return Handle<Object>(Smi::FromInt(static_cast<int>(value)));
+        } else {
+          return Isolate::Current()->factory()->NewNumber(
+            static_cast<double>(value));
+        }
+      }
+
       case DOUBLE: {
         double value = Memory::double_at(addr_);
         return Isolate::Current()->factory()->NewNumber(value);
       }
 
       case LITERAL:
         return literal_;
 
       default:
         UNREACHABLE();
@@ skipping 105 matching lines @@
   Object** expression_stack_;
   int source_position_;
 
   friend class Deoptimizer;
 };
 #endif
 
 } }  // namespace v8::internal
 
 #endif  // V8_DEOPTIMIZER_H_