Limit the amount of memory that can be folded together.

src/hydrogen-instructions.cc

Index: src/hydrogen-instructions.cc
diff --git a/src/hydrogen-instructions.cc b/src/hydrogen-instructions.cc
index 880de29aca1eec220efa59a8e806600713fe237a..f8cb5ec5561bbacf82625c0c085a4ed2129cfa8b 100644
--- a/src/hydrogen-instructions.cc
+++ b/src/hydrogen-instructions.cc
@@ -3229,12 +3229,21 @@ void HAllocate::HandleSideEffectDominator(GVNFlag side_effect,
       HConstant::cast(dominator_size)->GetInteger32Constant();
   int32_t current_size_constant =
       HConstant::cast(current_size)->GetInteger32Constant();
+  int32_t new_dominator_size = dominator_size_constant + current_size_constant;
+  if (new_dominator_size > Page::kMaxNonCodeHeapObjectSize) {

[Michael Starzinger, 2013/07/22 08:46:07]

Can we add an assert here like the following? This makes sure that we are not
statically exceeding the limit for neither new-space nor pretenured allocations.

ASSERT_LE(Page::kMaxNonCodeHeapObjectSize, Page::kMaxObjectSizeInNewSpace);

Also on top of that, could we add asserts to MacroAssembler::Allocate (the one
that takes a static object size) that check we are not exceeding the same limit
through other call-sites? I know it's not part of this change but such an assert
would have caught this violation earlier.

[Michael Starzinger, 2013/07/22 12:28:04]

As discussed offline: This is a can of worms and we will clean it up in a
followup CL where we'll try to unify those two constant.

+    if (FLAG_trace_allocation_folding) {
+      PrintF("#%d (%s) cannot fold into #%d (%s) due to size: %d\n",
+          id(), Mnemonic(), dominator->id(), dominator->Mnemonic(),
+          new_dominator_size);
+    }
+    return;
+  }
   HBasicBlock* block = dominator->block();
   Zone* zone = block->zone();
-  HInstruction* new_dominator_size = new(zone) HConstant(
-      dominator_size_constant + current_size_constant);
-  new_dominator_size->InsertBefore(dominator_allocate_instr);
-  dominator_allocate_instr->UpdateSize(new_dominator_size);
+  HInstruction* new_dominator_size_constant = new(zone) HConstant(
+      new_dominator_size);
+  new_dominator_size_constant->InsertBefore(dominator_allocate_instr);
+  dominator_allocate_instr->UpdateSize(new_dominator_size_constant);
 
 #ifdef VERIFY_HEAP
   HInstruction* free_space_instr =