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

src/frame-element.h

 // 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 36 matching lines @@
 
 class FrameElement BASE_EMBEDDED {
  public:
   enum SyncFlag {
     NOT_SYNCED,
     SYNCED
   };
 
   // The default constructor creates an invalid frame element.
   FrameElement() {
-    value_ = StaticTypeField::encode(StaticType::UNKNOWN_TYPE)
-        | TypeField::encode(INVALID)
+    value_ = TypeField::encode(INVALID)
         | CopiedField::encode(false)
         | SyncedField::encode(false)
         | DataField::encode(0);
   }
 
   // Factory function to construct an invalid frame element.
   static FrameElement InvalidElement() {
     FrameElement result;
     return result;
   }
 
   // Factory function to construct an in-memory frame element.
   static FrameElement MemoryElement() {
     FrameElement result(MEMORY, no_reg, SYNCED);
     return result;
   }
 
   // Factory function to construct an in-register frame element.
   static FrameElement RegisterElement(Register reg,
-                                      SyncFlag is_synced,
-                                      StaticType static_type = StaticType()) {
-    return FrameElement(REGISTER, reg, is_synced, static_type);
+                                      SyncFlag is_synced) {
+    return FrameElement(REGISTER, reg, is_synced);
   }
 
   // Factory function to construct a frame element whose value is known at
   // compile time.
   static FrameElement ConstantElement(Handle<Object> value,
                                       SyncFlag is_synced) {
     FrameElement result(value, is_synced);
     return result;
   }
 
@@ skipping 45 matching lines @@
   Handle<Object> handle() const {
     ASSERT(is_constant());
     return ConstantList()->at(DataField::decode(value_));
   }
 
   int index() const {
     ASSERT(is_copy());
     return DataField::decode(value_);
   }
 
-  StaticType static_type() {
-    return StaticType(StaticTypeField::decode(value_));
-  }
-
-  void set_static_type(StaticType static_type) {
-    value_ = value_ & ~StaticTypeField::mask();
-    value_ = value_ | StaticTypeField::encode(static_type.static_type_);
-  }
-
   bool Equals(FrameElement other) {
     uint32_t masked_difference = (value_ ^ other.value_) & ~CopiedField::mask();
     if (!masked_difference) {
       // The elements are equal if they agree exactly except on copied field.
       return true;
     } else {
       // If two constants have the same value, and agree otherwise, return true.
        return !(masked_difference & ~DataField::mask()) &&
               is_constant() &&
               handle().is_identical_to(other.handle());
@@ skipping 12 matching lines @@
   }
 
   // Given a pair of non-null frame element pointers, return one of them
   // as an entry frame candidate or null if they are incompatible.
   FrameElement* Combine(FrameElement* other) {
     // If either is invalid, the result is.
     if (!is_valid()) return this;
     if (!other->is_valid()) return other;
 
     if (!SameLocation(other)) return NULL;
-    // If either is unsynced, the result is.  The result static type is
-    // the merge of the static types.  It's safe to set it on one of the
-    // frame elements, and harmless too (because we are only going to
-    // merge the reaching frames and will ensure that the types are
-    // coherent, and changing the static type does not emit code).
+    // If either is unsynced, the result is.
     FrameElement* result = is_synced() ? other : this;
-    result->set_static_type(static_type().merge(other->static_type()));
     return result;
   }
 
  private:
   enum Type {
     INVALID,
     MEMORY,
     REGISTER,
     CONSTANT,
     COPY
   };
 
   // Used to construct memory and register elements.
   FrameElement(Type type, Register reg, SyncFlag is_synced) {
-    value_ = StaticTypeField::encode(StaticType::UNKNOWN_TYPE)
-        | TypeField::encode(type)
+    value_ = TypeField::encode(type)
         | CopiedField::encode(false)
         | SyncedField::encode(is_synced != NOT_SYNCED)
         | DataField::encode(reg.code_ > 0 ? reg.code_ : 0);
-  }
-
-  FrameElement(Type type, Register reg, SyncFlag is_synced, StaticType stype) {
-    value_ = StaticTypeField::encode(stype.static_type_)
-        | TypeField::encode(type)
-        | CopiedField::encode(false)
-        | SyncedField::encode(is_synced != NOT_SYNCED)
-        | DataField::encode(reg.code_ > 0 ? reg.code_ : 0);
   }
 
   // Used to construct constant elements.
   FrameElement(Handle<Object> value, SyncFlag is_synced) {
-    value_ = StaticTypeField::encode(StaticType::TypeOf(*value).static_type_)
-        | TypeField::encode(CONSTANT)
+    value_ = TypeField::encode(CONSTANT)
         | CopiedField::encode(false)
         | SyncedField::encode(is_synced != NOT_SYNCED)
         | DataField::encode(ConstantList()->length());
     ConstantList()->Add(value);
   }
 
   Type type() const { return TypeField::decode(value_); }
   void set_type(Type type) {
     value_ = value_ & ~TypeField::mask();
     value_ = value_ | TypeField::encode(type);
   }
 
   void set_index(int new_index) {
     ASSERT(is_copy());
     value_ = value_ & ~DataField::mask();
     value_ = value_ | DataField::encode(new_index);
   }
 
   void set_reg(Register new_reg) {
     ASSERT(is_register());
     value_ = value_ & ~DataField::mask();
     value_ = value_ | DataField::encode(new_reg.code_);
   }
 
-  // Encode static type, type, copied, synced and data in one 32 bit integer.
+  // Encode type, copied, synced and data in one 32 bit integer.
   uint32_t value_;
 
-  class StaticTypeField: public BitField<StaticType::StaticTypeEnum, 0, 3> {};
-  class TypeField: public BitField<Type, 3, 3> {};
-  class CopiedField: public BitField<uint32_t, 6, 1> {};
-  class SyncedField: public BitField<uint32_t, 7, 1> {};
-  class DataField: public BitField<uint32_t, 8, 32 - 9> {};
+  class TypeField: public BitField<Type, 0, 3> {};
+  class CopiedField: public BitField<uint32_t, 3, 1> {};
+  class SyncedField: public BitField<uint32_t, 4, 1> {};
+  class DataField: public BitField<uint32_t, 5, 32 - 6> {};
 
   friend class VirtualFrame;
 };
 
 } }  // namespace v8::internal
 
 #endif  // V8_FRAME_ELEMENT_H_