Allocation folding integrated into the GVN phase.

src/hydrogen-instructions.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 1636 matching lines @@
     case IS_INTERNALIZED_STRING:
       *mask = kIsInternalizedMask;
       *tag = kInternalizedTag;
       return;
     default:
       UNREACHABLE();
   }
 }
 
 
-void HCheckMaps::SetSideEffectDominator(GVNFlag side_effect,
+void HCheckMaps::HandleSideEffectDominator(GVNFlag side_effect,
                                         HValue* dominator) {

[Michael Starzinger, 2013/07/08 12:44:06]

nit: Indentation if off.

[Hannes Payer (out of office), 2013/07/08 13:43:48]

Done.

   ASSERT(side_effect == kChangesMaps);
   // TODO(mstarzinger): For now we specialize on HStoreNamedField, but once
   // type information is rich enough we should generalize this to any HType
   // for which the map is known.
   if (HasNoUses() && dominator->IsStoreNamedField()) {
     HStoreNamedField* store = HStoreNamedField::cast(dominator);
     UniqueValueId map_unique_id = store->transition_unique_id();
     if (!map_unique_id.IsInitialized() || store->object() != value()) return;
     for (int i = 0; i < map_set()->length(); i++) {
       if (map_unique_id == map_unique_ids_.at(i)) {
@@ skipping 1364 matching lines @@
   }
   return false;
 }
 
 
 void HLoadGlobalGeneric::PrintDataTo(StringStream* stream) {
   stream->Add("%o ", *name());
 }
 
 
+HType HInnerAllocatedObject::CalculateInferredType() {
+  return type_;
+}
+
+
 void HInnerAllocatedObject::PrintDataTo(StringStream* stream) {
   base_object()->PrintNameTo(stream);
   stream->Add(" offset %d", offset());
 }
 
 
 void HStoreGlobalCell::PrintDataTo(StringStream* stream) {
   stream->Add("[%p] = ", *cell());
   value()->PrintNameTo(stream);
   if (!details_.IsDontDelete()) stream->Add(" (deleteable)");
@@ skipping 137 matching lines @@
 HType HAllocateObject::CalculateInferredType() {
   return HType::JSObject();
 }
 
 
 HType HAllocate::CalculateInferredType() {
   return type_;
 }
 
 
+void HAllocate::HandleSideEffectDominator(GVNFlag side_effect,
+                                       HValue* dominator) {

[Michael Starzinger, 2013/07/08 12:44:06]

nit: Indentation is off.

[Hannes Payer (out of office), 2013/07/08 13:43:48]

Done.

+  ASSERT(side_effect == kChangesNewSpacePromotion);
+  if (FLAG_use_allocation_folding) {

[titzer, 2013/07/08 12:40:14]

if (!FLAG_...) return;
if (!...) return;

Can remove two levels of nesting here.

[Michael Starzinger, 2013/07/08 12:44:06]

Can we do early returns here instead of indenting the whole block, that makes
this whole method easier to read.

[Hannes Payer (out of office), 2013/07/08 13:43:48]

Done.

+    if (dominator->IsAllocate()) {
+      HAllocate* dominator_allocate_instr = HAllocate::cast(dominator);
+      // We can just fold allocations that are guaranteed in new space.
+      // TODO(hpayer): Support double aligned allocations.
+      if (GuaranteedInNewSpace() && !MustAllocateDoubleAligned() &&
+          dominator_allocate_instr->GuaranteedInNewSpace() &&
+          !dominator_allocate_instr->MustAllocateDoubleAligned()) {
+        HValue* dominator_size = dominator_allocate_instr->size();
+        HValue* current_size = size();
+        // TODO(hpayer): Add support for non-constant allocation in dominator.
+        if (current_size->IsInteger32Constant() &&
+            dominator_size->IsInteger32Constant()) {
+          // First update the size of the dominator allocate instruction.
+          int32_t dominator_size_constant =
+              HConstant::cast(dominator_size)->GetInteger32Constant();
+          int32_t current_size_constant =
+              HConstant::cast(current_size)->GetInteger32Constant();
+          HBasicBlock* block = dominator->block();
+          Zone* zone = block->zone();
+          HInstruction* new_dominator_size = new(zone) HConstant(
+              dominator_size_constant + current_size_constant);
+          HInstruction* dominator_instr = HInstruction::cast(dominator);

[titzer, 2013/07/08 12:40:14]

You already have dominator as dominator_allocate_instr.

[Hannes Payer (out of office), 2013/07/08 13:43:48]

Done.

+          new_dominator_size->InsertBefore(dominator_instr);
+          dominator_allocate_instr->UpdateSize(new_dominator_size);
+
+          // TODO(hpayer): Remove filler map but make sure new space is valid.
+          HInstruction* free_space_instr =
+              new(zone) HInnerAllocatedObject(dominator_instr,
+                  dominator_size_constant,
+                  type());
+          free_space_instr->InsertAfter(dominator_instr);
+          HConstant* filler_map = block->graph()->GetConstantFreeSpaceMap();

[titzer, 2013/07/08 12:40:14]

Don't make this a global constant in the graph. That increases its live range,
thus register pressure and spilling. It's fine to create this constant at each
allocation site, IMO. Maybe if you have multiple folded allocations you can
insert this constant after the intial HAllocate and reuse the same one, but
making it global is probably not worth it.

[Michael Starzinger, 2013/07/08 12:44:06]

I don't think this is an issue as the HConstant will not get a live range. It
will be embedded as a constant at every use-site.

[Hannes Payer (out of office), 2013/07/08 13:43:48]

OK.

I am leaving this code since it will disappear anyway after fixing the new space
iterator. 

[titzer, 2013/07/08 13:49:38]

Why? If it is not so important, then please do not pollute HGraph with another
global constant.

[Michael Starzinger, 2013/07/08 14:02:43]

I kind of see Ben's point here. If it is possible to come up with a more local
temporary workaround (aka. hack) that would definitely be preferable. Especially
since one of Danno's upcoming changes will actually track live-ranges for
constants with more than one use (which renders my original comment moot). So +1
on this comments as well.

+          HInstruction* store_map = new(zone) HStoreNamedField(
+              free_space_instr, HObjectAccess::ForMap(), filler_map,
+                  Representation::Tagged(), true);
+          store_map->InsertAfter(free_space_instr);
+
+          HInstruction* free_space_size =
+              new(zone) HConstant(current_size_constant);
+          free_space_size->InsertAfter(store_map);
+          HObjectAccess access =
+              HObjectAccess::ForJSObjectOffset(FreeSpace::kSizeOffset);
+          HInstruction* store_size = new(zone) HStoreNamedField(
+              free_space_instr, access, free_space_size,
+                  Representation::Tagged(), true);
+          store_size->InsertAfter(free_space_size);
+
+          // After that replace the dominated allocate instruction.
+          HInstruction* dominated_allocate_instr =
+              new(zone) HInnerAllocatedObject(dominator_instr,
+                  dominator_size_constant,
+                  type());
+          dominated_allocate_instr->InsertBefore(this);
+          DeleteAndReplaceWith(dominated_allocate_instr);
+          if (FLAG_trace_allocation_folding) {
+            PrintF("#%d (%s) folded into #%d (%s)\n",
+                id(), Mnemonic(), dominator->id(), dominator->Mnemonic());
+          }
+        }
+      }
+    }
+  }
+}
+
+
 void HAllocate::PrintDataTo(StringStream* stream) {
   size()->PrintNameTo(stream);
   if (!GuaranteedInNewSpace()) stream->Add(" (pretenure)");
 }
 
 
 HType HRegExpLiteral::CalculateInferredType() {
   return HType::JSObject();
 }
 
@@ skipping 706 matching lines @@
     case kBackingStore:
       if (!name_.is_null()) stream->Add(*String::cast(*name_)->ToCString());
       stream->Add("[backing-store]");
       break;
   }
 
   stream->Add("@%d", offset());
 }
 
 } }  // namespace v8::internal