Change compiler to safely write unsafe smis when they are spilled from...

src/virtual-frame-ia32.cc

 // Copyright 2008 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 61 matching lines @@
         // There was an early bailout for invalid and synced elements
         // (memory elements are always synced).
         UNREACHABLE();
         break;
 
       case FrameElement::REGISTER:
         __ mov(Operand(ebp, fp_relative(index)), element.reg());
         break;
 
       case FrameElement::CONSTANT:
-        __ Set(Operand(ebp, fp_relative(index)), Immediate(element.handle()));
+        if (cgen_->IsUnsafeSmi(element.handle())) {
+          Result temp = cgen_->allocator()->Allocate();
+          ASSERT(temp.is_valid());
+          cgen_->LoadUnsafeSmi(temp.reg(), element.handle());
+          __ mov(Operand(ebp, fp_relative(index)), temp.reg());
+        } else {
+          __ Set(Operand(ebp, fp_relative(index)),
+                 Immediate(element.handle()));
+        }
         break;
 
       case FrameElement::COPY: {
         int backing_index = element.index();
         FrameElement backing_element = elements_[backing_index];
         if (backing_element.is_memory()) {
           Result temp = cgen_->allocator()->Allocate();
           ASSERT(temp.is_valid());
           __ mov(temp.reg(), Operand(ebp, fp_relative(backing_index)));
           __ mov(Operand(ebp, fp_relative(index)), temp.reg());
@@ skipping 17 matching lines @@
         // There was an early bailout for invalid and synced elements
         // (memory elements are always synced).
         UNREACHABLE();
         break;
 
       case FrameElement::REGISTER:
         __ push(element.reg());
         break;
 
       case FrameElement::CONSTANT:
-        __ push(Immediate(element.handle()));
+        if (cgen_->IsUnsafeSmi(element.handle())) {
+          Result temp = cgen_->allocator()->Allocate();
+          ASSERT(temp.is_valid());
+          cgen_->LoadUnsafeSmi(temp.reg(), element.handle());
+          __ push(temp.reg());
+        } else {
+          __ push(Immediate(element.handle()));
+        }
         break;
 
       case FrameElement::COPY: {
         int backing_index = element.index();
         FrameElement backing = elements_[backing_index];
         ASSERT(backing.is_memory() || backing.is_register());
         if (backing.is_memory()) {
           __ push(Operand(ebp, fp_relative(backing_index)));
         } else {
           __ push(backing.reg());
@@ skipping 79 matching lines @@
 
         case FrameElement::REGISTER:
           Unuse(source.reg());
           if (!source.is_synced()) {
             __ mov(Operand(ebp, fp_relative(i)), source.reg());
           }
           break;
 
         case FrameElement::CONSTANT:
           if (!source.is_synced()) {
-            __ Set(Operand(ebp, fp_relative(i)), Immediate(source.handle()));
+            if (cgen_->IsUnsafeSmi(source.handle())) {
+              esi_caches = i;
+              cgen_->LoadUnsafeSmi(esi, source.handle());
+              __ mov(Operand(ebp, fp_relative(i)), esi);
+            } else {
+              __ Set(Operand(ebp, fp_relative(i)), Immediate(source.handle()));
+            }
           }
           break;
 
         case FrameElement::COPY:
           if (!source.is_synced()) {
             int backing_index = source.index();
             FrameElement backing_element = elements_[backing_index];
             if (backing_element.is_memory()) {
               // If we have to spill a register, we spill esi.
               if (esi_caches != backing_index) {
@@ skipping 97 matching lines @@
         case FrameElement::REGISTER:
           UNREACHABLE();
           break;
 
         case FrameElement::MEMORY:
           ASSERT(i <= stack_pointer_);
           __ mov(target.reg(), Operand(ebp, fp_relative(i)));
           break;
 
         case FrameElement::CONSTANT:
-          __ Set(target.reg(), Immediate(source.handle()));
+          if (cgen_->IsUnsafeSmi(source.handle())) {
+            cgen_->LoadUnsafeSmi(target.reg(), source.handle());
+          } else {
+           __ Set(target.reg(), Immediate(source.handle()));
+          }
           break;
 
         case FrameElement::COPY: {
           FrameElement backing = elements_[source.index()];
           ASSERT(backing.is_memory() || backing.is_register());
           if (backing.is_memory()) {
             ASSERT(source.index() <= stack_pointer_);
             __ mov(target.reg(), Operand(ebp, fp_relative(source.index())));
           } else {
             __ mov(target.reg(), backing.reg());
@@ skipping 594 matching lines @@
   ASSERT(stack_pointer_ == elements_.length() - 1);
   elements_.Add(FrameElement::MemoryElement());
   stack_pointer_++;
   __ push(immediate);
 }
 
 
 #undef __
 
 } }  // namespace v8::internal