Removed static type inference and add a dynamic test for string addition.

src/virtual-frame.cc

 // Copyright 2009 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 55 matching lines @@
     case FrameElement::COPY:
       // We do not allow copies of copies, so we follow one link to
       // the actual backing store of a copy before making a copy.
       index = target.index();
       ASSERT(elements_[index].is_memory() || elements_[index].is_register());
       // Fall through.
 
     case FrameElement::MEMORY:  // Fall through.
     case FrameElement::REGISTER:
       // All copies are backed by memory or register locations.
-      result.set_static_type(target.static_type());
       result.set_type(FrameElement::COPY);
       result.clear_copied();
       result.clear_sync();
       result.set_index(index);
       elements_[index].set_copied();
       break;
 
     case FrameElement::INVALID:
       // We should not try to copy invalid elements.
       UNREACHABLE();
@@ skipping 59 matching lines @@
 
   SyncElementAt(index);
   // The element is now in memory.  Its copied flag is preserved.
   FrameElement new_element = FrameElement::MemoryElement();
   if (elements_[index].is_copied()) {
     new_element.set_copied();
   }
   if (elements_[index].is_register()) {
     Unuse(elements_[index].reg());
   }
-  new_element.set_static_type(elements_[index].static_type());
   elements_[index] = new_element;
 }
 
 
 // Clear the dirty bit for the element at a given index.
 void VirtualFrame::SyncElementAt(int index) {
   if (index <= stack_pointer_) {
     if (!elements_[index].is_synced()) SyncElementBelowStackPointer(index);
   } else if (index == stack_pointer_ + 1) {
     SyncElementByPushing(index);
@@ skipping 37 matching lines @@
       }
       elements_[i] = target;
     } else if (target.is_register() && !target.is_synced() &&
                !source.is_memory()) {
       // If an element's target is a register that doesn't need to be
       // synced, and the element is not in memory, then the sync state
       // of the element is irrelevant.  We clear the sync bit.
       ASSERT(source.is_valid());
       elements_[i].clear_sync();
     }
-    // No code needs to be generated to change the static type of an
-    // element.
-    elements_[i].set_static_type(target.static_type());
   }
 }
 
 
 void VirtualFrame::PrepareForCall(int spilled_args, int dropped_args) {
   ASSERT(height() >= dropped_args);
   ASSERT(height() >= spilled_args);
   ASSERT(dropped_args <= spilled_args);
 
   SyncRange(0, element_count() - 1);
@@ skipping 12 matching lines @@
   }
 
   // Forget the frame elements that will be popped by the call.
   Forget(dropped_args);
 }
 
 
 void VirtualFrame::PrepareForReturn() {
   // Spill all locals. This is necessary to make sure all locals have
   // the right value when breaking at the return site in the debugger.
-  // Set their static type to unknown so that they will match the known
-  // return frame.
   for (int i = 0; i < expression_base_index(); i++) {
     SpillElementAt(i);
-    elements_[i].set_static_type(StaticType::unknown());
   }
 }
 
 
 void VirtualFrame::SetElementAt(int index, Result* value) {
   int frame_index = element_count() - index - 1;
   ASSERT(frame_index >= 0);
   ASSERT(frame_index < element_count());
   ASSERT(value->is_valid());
   FrameElement original = elements_[frame_index];
@@ skipping 12 matching lines @@
 
   InvalidateFrameSlotAt(frame_index);
 
   FrameElement new_element;
   if (value->is_register()) {
     if (is_used(value->reg())) {
       // The register already appears on the frame.  Either the existing
       // register element, or the new element at frame_index, must be made
       // a copy.
       int i = register_location(value->reg());
-      ASSERT(value->static_type() == elements_[i].static_type());
 
       if (i < frame_index) {
         // The register FrameElement is lower in the frame than the new copy.
         elements_[frame_index] = CopyElementAt(i);
       } else {
         // There was an early bailout for the case of setting a
         // register element to itself.
         ASSERT(i != frame_index);
         elements_[frame_index] = elements_[i];
         elements_[i] = CopyElementAt(frame_index);
         if (elements_[frame_index].is_synced()) {
           elements_[i].set_sync();
         }
         elements_[frame_index].clear_sync();
         set_register_location(value->reg(), frame_index);
         for (int j = i + 1; j < element_count(); j++) {
           if (elements_[j].is_copy() && elements_[j].index() == i) {
             elements_[j].set_index(frame_index);
           }
         }
       }
     } else {
       // The register value->reg() was not already used on the frame.
       Use(value->reg(), frame_index);
       elements_[frame_index] =
           FrameElement::RegisterElement(value->reg(),
-                                        FrameElement::NOT_SYNCED,
-                                        value->static_type());
+                                        FrameElement::NOT_SYNCED);
     }
   } else {
     ASSERT(value->is_constant());
     elements_[frame_index] =
         FrameElement::ConstantElement(value->handle(),
                                       FrameElement::NOT_SYNCED);
   }
   value->Unuse();
 }
 
 
 void VirtualFrame::PushFrameSlotAt(int index) {
   elements_.Add(CopyElementAt(index));
 }
 
 
-void VirtualFrame::Push(Register reg, StaticType static_type) {
+void VirtualFrame::Push(Register reg) {
   if (is_used(reg)) {
     int index = register_location(reg);
     FrameElement element = CopyElementAt(index);
-    ASSERT(static_type.merge(element.static_type()) == element.static_type());
     elements_.Add(element);
   } else {
     Use(reg, element_count());
     FrameElement element =
         FrameElement::RegisterElement(reg,
-                                      FrameElement::NOT_SYNCED,
-                                      static_type);
+                                      FrameElement::NOT_SYNCED);
     elements_.Add(element);
   }
 }
 
 
 void VirtualFrame::Push(Handle<Object> value) {
   FrameElement element =
       FrameElement::ConstantElement(value, FrameElement::NOT_SYNCED);
   elements_.Add(element);
 }
@@ skipping 31 matching lines @@
 // Specialization of List::ResizeAdd to non-inlined version for FrameElements.
 // The function ResizeAdd becomes a real function, whose implementation is the
 // inlined ResizeAddInternal.
 template <>
 void List<FrameElement,
           FreeStoreAllocationPolicy>::ResizeAdd(const FrameElement& element) {
   ResizeAddInternal(element);
 }
 
 } }  // namespace v8::internal