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

src/jump-target.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 63 matching lines @@
 
   // A list of pointers to frame elements in the entry frame.  NULL
   // indicates that the element has not yet been determined.
   int length = initial_frame->element_count();
   ZoneList<FrameElement*> elements(length);
 
   // Initially populate the list of elements based on the initial
   // frame.
   for (int i = 0; i < length; i++) {
     FrameElement element = initial_frame->elements_[i];
-    // We do not allow copies or constants in bidirectional frames.  All
-    // elements above the water mark on bidirectional frames have
-    // unknown static types.
+    // We do not allow copies or constants in bidirectional frames.
     if (direction_ == BIDIRECTIONAL) {
       if (element.is_constant() || element.is_copy()) {
         elements.Add(NULL);
         continue;
       }
-      // It's safe to change the static type on the initial frame
-      // element, see comment in JumpTarget::Combine.
-      initial_frame->elements_[i].set_static_type(StaticType::unknown());
     }
     elements.Add(&initial_frame->elements_[i]);
   }
 
   // Compute elements based on the other reaching frames.
   if (reaching_frames_.length() > 1) {
     for (int i = 0; i < length; i++) {
       FrameElement* element = elements[i];
       for (int j = 1; j < reaching_frames_.length(); j++) {
         // Element computation is monotonic: new information will not
@@ skipping 30 matching lines @@
       entry_frame_->elements_.Add(*target);
       InitializeEntryElement(index, target);
     }
   }
 
   // Allocate any still-undetermined frame elements to registers or
   // memory, from the top down.
   for (int i = length - 1; i >= 0; i--) {
     if (elements[i] == NULL) {
       // Loop over all the reaching frames to check whether the element
-      // is synced on all frames, to count the registers it occupies,
-      // and to compute a merged static type.
+      // is synced on all frames and to count the registers it occupies.
       bool is_synced = true;
       RegisterFile candidate_registers;
       int best_count = kMinInt;
       int best_reg_num = RegisterAllocator::kInvalidRegister;
 
-      StaticType type;  // Initially invalid.
-      if (direction_ != BIDIRECTIONAL) {
-        type = reaching_frames_[0]->elements_[i].static_type();
-      }
-
       for (int j = 0; j < reaching_frames_.length(); j++) {
         FrameElement element = reaching_frames_[j]->elements_[i];
         is_synced = is_synced && element.is_synced();
         if (element.is_register() && !entry_frame_->is_used(element.reg())) {
           // Count the register occurrence and remember it if better
           // than the previous best.
           int num = RegisterAllocator::ToNumber(element.reg());
           candidate_registers.Use(num);
           if (candidate_registers.count(num) > best_count) {
             best_count = candidate_registers.count(num);
             best_reg_num = num;
           }
         }
-        type = type.merge(element.static_type());
       }
 
       // If the value is synced on all frames, put it in memory.  This
       // costs nothing at the merge code but will incur a
       // memory-to-register move when the value is needed later.
       if (is_synced) {
         // Already recorded as a memory element.
-        entry_frame_->elements_[i].set_static_type(type);
         continue;
       }
 
       // Try to put it in a register.  If there was no best choice
       // consider any free register.
       if (best_reg_num == RegisterAllocator::kInvalidRegister) {
         for (int j = 0; j < RegisterAllocator::kNumRegisters; j++) {
           if (!entry_frame_->is_used(j)) {
             best_reg_num = j;
             break;
           }
         }
       }
 
-      if (best_reg_num == RegisterAllocator::kInvalidRegister) {
-        // If there was no register found, the element is already
-        // recorded as in memory.
-        entry_frame_->elements_[i].set_static_type(type);
-      } else {
+      if (best_reg_num != RegisterAllocator::kInvalidRegister) {
         // If there was a register choice, use it.  Preserve the copied
-        // flag on the element.  Set the static type as computed.
+        // flag on the element.
         bool is_copied = entry_frame_->elements_[i].is_copied();
         Register reg = RegisterAllocator::ToRegister(best_reg_num);
         entry_frame_->elements_[i] =
             FrameElement::RegisterElement(reg,
                                           FrameElement::NOT_SYNCED);
         if (is_copied) entry_frame_->elements_[i].set_copied();
-        entry_frame_->elements_[i].set_static_type(type);
         entry_frame_->set_register_location(reg, i);
       }
     }
   }
 
   // The stack pointer is at the highest synced element or the base of
   // the expression stack.
   int stack_pointer = length - 1;
   while (stack_pointer >= entry_frame_->expression_base_index() &&
          !entry_frame_->elements_[stack_pointer].is_synced()) {
@@ skipping 236 matching lines @@
   temp.CopyTo(this);
   temp.Unuse();
 
 #ifdef DEBUG
   is_shadowing_ = false;
 #endif
 }
 
 
 } }  // namespace v8::internal