Revert "Track field types."

src/hydrogen.cc

 // Copyright 2013 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 5352 matching lines @@
   if (access.representation().IsDouble()) {
     // Load the heap number.
     checked_object = Add<HLoadNamedField>(
         checked_object, static_cast<HValue*>(NULL),
         access.WithRepresentation(Representation::Tagged()));
     checked_object->set_type(HType::HeapNumber());
     // Load the double value from it.
     access = HObjectAccess::ForHeapNumberValue();
   }
   return New<HLoadNamedField>(
-      checked_object, static_cast<HValue*>(NULL), access, info->field_map());
+      checked_object, static_cast<HValue*>(NULL), access);
 }
 
 
 HInstruction* HOptimizedGraphBuilder::BuildStoreNamedField(
     PropertyAccessInfo* info,
     HValue* checked_object,
     HValue* value) {
   bool transition_to_field = info->lookup()->IsTransition();
   // TODO(verwaest): Move this logic into PropertyAccessInfo.
   HObjectAccess field_access = HObjectAccess::ForField(
@@ skipping 24 matching lines @@
     } else {
       // Already holds a HeapNumber; load the box and write its value field.
       HInstruction* heap_number = Add<HLoadNamedField>(
           checked_object, static_cast<HValue*>(NULL), heap_number_access);
       heap_number->set_type(HType::HeapNumber());
       instr = New<HStoreNamedField>(heap_number,
                                     HObjectAccess::ForHeapNumberValue(),
                                     value, STORE_TO_INITIALIZED_ENTRY);
     }
   } else {
-    if (!info->field_map().is_null()) {
-      ASSERT(field_access.representation().IsHeapObject());
-      BuildCheckHeapObject(value);
-      value = BuildCheckMap(value, info->field_map());
-    }
-
     // This is a normal store.
     instr = New<HStoreNamedField>(
         checked_object->ActualValue(), field_access, value,
         transition_to_field ? INITIALIZING_STORE : STORE_TO_INITIALIZED_ENTRY);
   }
 
   if (transition_to_field) {
     HConstant* transition_constant = Add<HConstant>(info->transition());
     instr->SetTransition(transition_constant, top_info());
     instr->SetChangesFlag(kMaps);
@@ skipping 43 matching lines @@
   if (!info->lookup_.IsField()) return false;
 
   Representation r = access_.representation();
   if (IsLoad()) {
     if (!info->access_.representation().IsCompatibleForLoad(r)) return false;
   } else {
     if (!info->access_.representation().IsCompatibleForStore(r)) return false;
   }
   if (info->access_.offset() != access_.offset()) return false;
   if (info->access_.IsInobject() != access_.IsInobject()) return false;
-  if (!field_map_.is_identical_to(info->field_map_)) {
-    if (!IsLoad()) return false;
-
-    // Throw away type information for merging polymorphic loads.
-    field_map_ = info->field_map_ = Handle<Map>();
-  }
   info->GeneralizeRepresentation(r);
   return true;
 }
 
 
 bool HOptimizedGraphBuilder::PropertyAccessInfo::LookupDescriptor() {
   if (!type_->IsClass()) return true;
   map()->LookupDescriptor(NULL, *name_, &lookup_);
   return LoadResult(map());
 }
 
 
 bool HOptimizedGraphBuilder::PropertyAccessInfo::LoadResult(Handle<Map> map) {
   if (!IsLoad() && lookup_.IsProperty() &&
       (lookup_.IsReadOnly() || !lookup_.IsCacheable())) {
     return false;
   }
 
   if (lookup_.IsField()) {
-    // Construct the object field access.
     access_ = HObjectAccess::ForField(map, &lookup_, name_);
-
-    if (access_.representation().IsHeapObject()) {
-      // Figure out the field type from the accessor map.
-      HeapType* field_type = lookup_.GetFieldTypeFromMap(*map);
-      if (field_type->IsClass()) {
-        Handle<Map> field_map = field_type->AsClass();
-        if (field_map->is_stable()) {  // TODO(bmeurer)
-          field_map_ = field_map;
-          field_map_->AddDependentCompilationInfo(
-              DependentCode::kPrototypeCheckGroup, top_info());
-
-          // Add dependency on the map that introduced the field.
-          Handle<Map> field_owner = handle(lookup_.GetFieldOwnerFromMap(*map));
-          field_owner->AddDependentCompilationInfo(
-              DependentCode::kFieldTypeGroup, top_info());
-        }
-      }
-    }
   } else if (lookup_.IsPropertyCallbacks()) {
     Handle<Object> callback(lookup_.GetValueFromMap(*map), isolate());
     if (!callback->IsAccessorPair()) return false;
     Object* raw_accessor = IsLoad()
         ? Handle<AccessorPair>::cast(callback)->getter()
         : Handle<AccessorPair>::cast(callback)->setter();
     if (!raw_accessor->IsJSFunction()) return false;
     Handle<JSFunction> accessor = handle(JSFunction::cast(raw_accessor));
     if (accessor->shared()->IsApiFunction()) {
       CallOptimization call_optimization(accessor);
@@ skipping 6045 matching lines @@
   if (ShouldProduceTraceOutput()) {
     isolate()->GetHTracer()->TraceHydrogen(name(), graph_);
   }
 
 #ifdef DEBUG
   graph_->Verify(false);  // No full verify.
 #endif
 }
 
 } }  // namespace v8::internal