Remove unnecessary BailoutIds.

src/hydrogen.cc

 // Copyright 2012 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 1267 matching lines @@
       AddInstruction(new(zone) HAllocate(context, total_size,
                                          HType::JSArray(), flags));
   return elements;
 }
 
 
 void HGraphBuilder::BuildInitializeElements(HValue* elements,
                                             ElementsKind kind,
                                             HValue* capacity) {
   Zone* zone = this->zone();
-  BailoutId ast_id = current_block()->last_environment()->previous_ast_id();
   Factory* factory = isolate()->factory();
   Handle<Map> map = IsFastDoubleElementsKind(kind)
       ? factory->fixed_double_array_map()
       : factory->fixed_array_map();
-  BuildStoreMap(elements, map, ast_id);
+  BuildStoreMap(elements, map);
 
   Handle<String> fixed_array_length_field_name = factory->length_field_string();
   HInstruction* store_length =
       new(zone) HStoreNamedField(elements, fixed_array_length_field_name,
                                  capacity, true, FixedArray::kLengthOffset);
   AddInstruction(store_length);
 }
 
 
 HValue* HGraphBuilder::BuildAllocateAndInitializeElements(HValue* context,
                                                           ElementsKind kind,
                                                           HValue* capacity) {
   HValue* new_elements =
       BuildAllocateElements(context, kind, capacity);
   BuildInitializeElements(new_elements, kind, capacity);
   return new_elements;
 }
 
 
 HInstruction* HGraphBuilder::BuildStoreMap(HValue* object,
-                                           HValue* map,
-                                           BailoutId id) {
+                                           HValue* map) {
   Zone* zone = this->zone();
   Factory* factory = isolate()->factory();
   Handle<String> map_field_name = factory->map_field_string();
   HInstruction* store_map =
       new(zone) HStoreNamedField(object, map_field_name, map,
                                  true, JSObject::kMapOffset);
   store_map->SetGVNFlag(kChangesMaps);
   AddInstruction(store_map);
   return store_map;
 }
 
 
 HInstruction* HGraphBuilder::BuildStoreMap(HValue* object,
-                                           Handle<Map> map,
-                                           BailoutId id) {
+                                           Handle<Map> map) {
   Zone* zone = this->zone();
   HValue* map_constant =
       AddInstruction(new(zone) HConstant(map, Representation::Tagged()));
-  return BuildStoreMap(object, map_constant, id);
+  return BuildStoreMap(object, map_constant);
 }
 
 
 HValue* HGraphBuilder::BuildNewElementsCapacity(HValue* context,
                                                 HValue* old_capacity) {
   Zone* zone = this->zone();
   HValue* half_old_capacity =
       AddInstruction(HShr::New(zone, context, old_capacity,
                                graph_->GetConstant1()));
   half_old_capacity->ChangeRepresentation(Representation::Integer32());
@@ skipping 128 matching lines @@
     BuildFillElementsWithHole(context, to_elements, to_elements_kind,
                               key, capacity);
   }
 }
 
 
 HValue* HGraphBuilder::BuildCloneShallowArray(HContext* context,
                                               HValue* boilerplate,
                                               AllocationSiteMode mode,
                                               ElementsKind kind,
-                                              BailoutId id,
                                               int length) {
   Zone* zone = this->zone();
   Factory* factory = isolate()->factory();
 
   NoObservableSideEffectsScope no_effects(this);
 
   // All sizes here are multiples of kPointerSize.
   int size = JSArray::kSize;
   if (mode == TRACK_ALLOCATION_SITE) {
     size += AllocationSiteInfo::kSize;
@@ skipping 25 matching lines @@
   for (int i = 0; i < JSArray::kSize; i += kPointerSize) {
     if ((i != JSArray::kElementsOffset) || (length == 0)) {
       HInstruction* value =
           AddInstruction(new(zone) HLoadNamedField(boilerplate, true, i));
       if (i != JSArray::kMapOffset) {
         AddInstruction(new(zone) HStoreNamedField(object,
                                                   factory->empty_string(),
                                                   value,
                                                   true, i));
       } else {
-        BuildStoreMap(object, value, id);
+        BuildStoreMap(object, value);
       }
     }
   }
 
   // Create an allocation site info if requested.
   if (mode == TRACK_ALLOCATION_SITE) {
     HValue* alloc_site =
         AddInstruction(new(zone) HInnerAllocatedObject(object, JSArray::kSize));
     Handle<Map> alloc_site_map(isolate()->heap()->allocation_site_info_map());
-    BuildStoreMap(alloc_site, alloc_site_map, id);
+    BuildStoreMap(alloc_site, alloc_site_map);
     int alloc_payload_offset = AllocationSiteInfo::kPayloadOffset;
     AddInstruction(new(zone) HStoreNamedField(alloc_site,
                                               factory->empty_string(),
                                               boilerplate,
                                               true, alloc_payload_offset));
   }
 
   if (length > 0) {
     // Get hold of the elements array of the boilerplate and setup the
     // elements pointer in the resulting object.
@@ skipping 4638 matching lines @@
                     &total_size)) {
     Handle<JSObject> original_boilerplate_object =
         Handle<JSObject>::cast(original_boilerplate);
     Handle<JSObject> boilerplate_object =
         DeepCopy(original_boilerplate_object);
 
     literal = BuildFastLiteral(context,
                                boilerplate_object,
                                original_boilerplate_object,
                                total_size,
-                               DONT_TRACK_ALLOCATION_SITE,
-                               environment()->previous_ast_id());
+                               DONT_TRACK_ALLOCATION_SITE);
   } else {
     literal = AddInstruction(
         new(zone()) HObjectLiteral(context,
                                    expr->constant_properties(),
                                    expr->fast_elements(),
                                    expr->literal_index(),
                                    expr->depth(),
                                    expr->has_function()));
   }
 
@@ skipping 116 matching lines @@
                     &total_size)) {
     if (mode == TRACK_ALLOCATION_SITE) {
       total_size += AllocationSiteInfo::kSize;
     }
 
     Handle<JSObject> boilerplate_object = DeepCopy(original_boilerplate_object);
     literal = BuildFastLiteral(context,
                                boilerplate_object,
                                original_boilerplate_object,
                                total_size,
-                               mode,
-                               environment()->previous_ast_id());
+                               mode);
   } else {
     literal = AddInstruction(
                   new(zone()) HArrayLiteral(context,
                                             original_boilerplate_object,
                                             length,
                                             expr->literal_index(),
                                             expr->depth(),
                                             mode));
   }
 
@@ skipping 3736 matching lines @@
       return new(zone()) HThisFunction;
   }
 }
 
 
 HInstruction* HOptimizedGraphBuilder::BuildFastLiteral(
     HValue* context,
     Handle<JSObject> boilerplate_object,
     Handle<JSObject> original_boilerplate_object,
     int size,
-    AllocationSiteMode mode,
-    BailoutId id) {
+    AllocationSiteMode mode) {
   Zone* zone = this->zone();
 
   NoObservableSideEffectsScope no_effects(this);
 
   HValue* size_in_bytes =
       AddInstruction(new(zone) HConstant(size, Representation::Integer32()));
   HInstruction* result =
       AddInstruction(new(zone) HAllocate(context,
                                          size_in_bytes,
                                          HType::JSObject(),
                                          HAllocate::CAN_ALLOCATE_IN_NEW_SPACE));
   int offset = 0;
   BuildEmitDeepCopy(boilerplate_object, original_boilerplate_object, result,
-                    &offset, mode, id);
+                    &offset, mode);
   ASSERT_EQ(size, offset);
   return result;
 }
 
 
 void HOptimizedGraphBuilder::BuildEmitDeepCopy(
     Handle<JSObject> boilerplate_object,
     Handle<JSObject> original_boilerplate_object,
     HInstruction* target,
     int* offset,
-    AllocationSiteMode mode,
-    BailoutId id) {
+    AllocationSiteMode mode) {
   Zone* zone = this->zone();
   Factory* factory = isolate()->factory();
 
   HInstruction* original_boilerplate = AddInstruction(new(zone) HConstant(
       original_boilerplate_object, Representation::Tagged()));
 
   bool create_allocation_site_info = mode == TRACK_ALLOCATION_SITE &&
       boilerplate_object->map()->CanTrackAllocationSite();
 
   // Only elements backing stores for non-COW arrays need to be copied.
@@ skipping 12 matching lines @@
   int elements_offset = *offset + object_size;
   int inobject_properties = boilerplate_object->map()->inobject_properties();
   if (create_allocation_site_info) {
     elements_offset += AllocationSiteInfo::kSize;
     *offset += AllocationSiteInfo::kSize;
   }
 
   *offset += object_size + elements_size;
 
   HValue* object_elements = BuildCopyObjectHeader(boilerplate_object, target,
-      object_offset, elements_offset, elements_size, id);
+      object_offset, elements_offset, elements_size);
 
   // Copy in-object properties.
   HValue* object_properties =
       AddInstruction(new(zone) HInnerAllocatedObject(target, object_offset));
   for (int i = 0; i < inobject_properties; i++) {
     Handle<Object> value =
         Handle<Object>(boilerplate_object->InObjectPropertyAt(i),
         isolate());
     if (value->IsJSObject()) {
       Handle<JSObject> value_object = Handle<JSObject>::cast(value);
       Handle<JSObject> original_value_object = Handle<JSObject>::cast(
           Handle<Object>(original_boilerplate_object->InObjectPropertyAt(i),
               isolate()));
       HInstruction* value_instruction =
           AddInstruction(new(zone) HInnerAllocatedObject(target, *offset));
       AddInstruction(new(zone) HStoreNamedField(
           object_properties, factory->unknown_field_string(), value_instruction,
           true, boilerplate_object->GetInObjectPropertyOffset(i)));
       BuildEmitDeepCopy(value_object, original_value_object, target,
-                        offset, DONT_TRACK_ALLOCATION_SITE, id);
+                        offset, DONT_TRACK_ALLOCATION_SITE);
     } else {
       HInstruction* value_instruction = AddInstruction(new(zone) HConstant(
           value, Representation::Tagged()));
       AddInstruction(new(zone) HStoreNamedField(
           object_properties, factory->unknown_field_string(), value_instruction,
           true, boilerplate_object->GetInObjectPropertyOffset(i)));
     }
   }
 
   // Build Allocation Site Info if desired
   if (create_allocation_site_info) {
     HValue* alloc_site =
         AddInstruction(new(zone) HInnerAllocatedObject(target, JSArray::kSize));
     Handle<Map> alloc_site_map(isolate()->heap()->allocation_site_info_map());
-    BuildStoreMap(alloc_site, alloc_site_map, id);
+    BuildStoreMap(alloc_site, alloc_site_map);
     int alloc_payload_offset = AllocationSiteInfo::kPayloadOffset;
     AddInstruction(new(zone) HStoreNamedField(alloc_site,
                                               factory->payload_string(),
                                               original_boilerplate,
                                               true, alloc_payload_offset));
   }
 
   if (object_elements != NULL) {
     HInstruction* boilerplate_elements = AddInstruction(new(zone) HConstant(
         elements, Representation::Tagged()));
@@ skipping 26 matching lines @@
             AddInstruction(new(zone) HConstant(i, Representation::Integer32()));
         if (value->IsJSObject()) {
           Handle<JSObject> value_object = Handle<JSObject>::cast(value);
           Handle<JSObject> original_value_object = Handle<JSObject>::cast(
               Handle<Object>(original_fast_elements->get(i), isolate()));
           HInstruction* value_instruction =
               AddInstruction(new(zone) HInnerAllocatedObject(target, *offset));
           AddInstruction(new(zone) HStoreKeyed(
               object_elements, key_constant, value_instruction, kind));
           BuildEmitDeepCopy(value_object, original_value_object, target,
-              offset, DONT_TRACK_ALLOCATION_SITE, id);
+              offset, DONT_TRACK_ALLOCATION_SITE);
         } else {
           HInstruction* value_instruction =
               AddInstruction(new(zone) HLoadKeyed(
                   boilerplate_elements, key_constant, NULL, kind));
           AddInstruction(new(zone) HStoreKeyed(
               object_elements, key_constant, value_instruction, kind));
         }
       }
     } else {
       UNREACHABLE();
     }
   }
 }
 
 
 HValue* HOptimizedGraphBuilder::BuildCopyObjectHeader(
     Handle<JSObject> boilerplate_object,
     HInstruction* target,
     int object_offset,
     int elements_offset,
-    int elements_size,
-    BailoutId id) {
+    int elements_size) {
   ASSERT(boilerplate_object->properties()->length() == 0);
   Zone* zone = this->zone();
   Factory* factory = isolate()->factory();
   HValue* result = NULL;
 
   HValue* object_header =
       AddInstruction(new(zone) HInnerAllocatedObject(target, object_offset));
   Handle<Map> boilerplate_object_map(boilerplate_object->map());
-  BuildStoreMap(object_header, boilerplate_object_map, id);
+  BuildStoreMap(object_header, boilerplate_object_map);
 
   HInstruction* elements;
   if (elements_size == 0) {
     Handle<Object> elements_field =
         Handle<Object>(boilerplate_object->elements(), isolate());
     elements = AddInstruction(new(zone) HConstant(
         elements_field, Representation::Tagged()));
   } else {
     elements = AddInstruction(new(zone) HInnerAllocatedObject(
         target, elements_offset));
@@ skipping 1377 matching lines @@
     }
   }
 
 #ifdef DEBUG
   if (graph_ != NULL) graph_->Verify(false);  // No full verify.
   if (allocator_ != NULL) allocator_->Verify();
 #endif
 }
 
 } }  // namespace v8::internal