[crankshaft] Fragmentation-free allocation folding.

src/x64/macro-assembler-x64.cc

 // Copyright 2012 the V8 project authors. All rights reserved.
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
 #if V8_TARGET_ARCH_X64
 
 #include "src/base/bits.h"
 #include "src/base/division-by-constant.h"
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
@@ skipping 4878 matching lines @@
   }
   DCHECK(!result.is(result_end));
 
   // Load address of new object into result.
   LoadAllocationTopHelper(result, scratch, flags);
 
   if ((flags & DOUBLE_ALIGNMENT) != 0) {
     MakeSureDoubleAlignedHelper(result, scratch, gc_required, flags);
   }
 
-  // Calculate new top and bail out if new space is exhausted.
-  ExternalReference allocation_limit =
-      AllocationUtils::GetAllocationLimitReference(isolate(), flags);
-
   Register top_reg = result_end.is_valid() ? result_end : result;
 
   if (!top_reg.is(result)) {

[Benedikt Meurer, 2016/04/19 07:25:39]

We can fuse this movp and the addp into a single leap for dominated allocations.

[Hannes Payer (out of office), 2016/04/19 11:03:56]

Done.

     movp(top_reg, result);
   }
   addp(top_reg, Immediate(object_size));
-  j(carry, gc_required);
-  Operand limit_operand = ExternalOperand(allocation_limit);
-  cmpp(top_reg, limit_operand);
-  j(above, gc_required);
 
-  // Update allocation top.
-  UpdateAllocationTopHelper(top_reg, scratch, flags);
+  if ((flags & ALLOCATION_FOLDING_DOMINATED) == 0) {
+    j(carry, gc_required);
+    // Calculate new top and bail out if new space is exhausted.

[Benedikt Meurer, 2016/04/19 07:25:39]

This comment is wrong here, as the calculation happens in the addp above.

[Hannes Payer (out of office), 2016/04/19 11:03:56]

Done.

+    ExternalReference allocation_limit =
+        AllocationUtils::GetAllocationLimitReference(isolate(), flags);
+    Operand limit_operand = ExternalOperand(allocation_limit);
+    cmpp(top_reg, limit_operand);
+    j(above, gc_required);
+  }
+
+  if ((flags & ALLOCATION_FOLDING_DOMINATOR) == 0) {
+    // Update allocation top.
+    UpdateAllocationTopHelper(top_reg, scratch, flags);
+  }
 
   bool tag_result = (flags & TAG_OBJECT) != 0;
   if (top_reg.is(result)) {
     if (tag_result) {
       subp(result, Immediate(object_size - kHeapObjectTag));
     } else {
       subp(result, Immediate(object_size));
     }
   } else if (tag_result) {
     // Tag the result if requested.
@@ skipping 39 matching lines @@
   }
   DCHECK(!result.is(result_end));
 
   // Load address of new object into result.
   LoadAllocationTopHelper(result, scratch, flags);
 
   if ((flags & DOUBLE_ALIGNMENT) != 0) {
     MakeSureDoubleAlignedHelper(result, scratch, gc_required, flags);
   }
 
-  // Calculate new top and bail out if new space is exhausted.
-  ExternalReference allocation_limit =
-      AllocationUtils::GetAllocationLimitReference(isolate(), flags);
   if (!object_size.is(result_end)) {

[Benedikt Meurer, 2016/04/19 07:25:38]

Same here, see comment above.

[Hannes Payer (out of office), 2016/04/19 11:03:56]

Done.

     movp(result_end, object_size);
   }
   addp(result_end, result);
-  j(carry, gc_required);
-  Operand limit_operand = ExternalOperand(allocation_limit);
-  cmpp(result_end, limit_operand);
-  j(above, gc_required);
 
-  // Update allocation top.
-  UpdateAllocationTopHelper(result_end, scratch, flags);
+  if ((flags & ALLOCATION_FOLDING_DOMINATED) == 0) {
+    j(carry, gc_required);
+    // Calculate new top and bail out if new space is exhausted.

[Benedikt Meurer, 2016/04/19 07:25:38]

Same here, see comment above.

[Hannes Payer (out of office), 2016/04/19 11:03:56]

Done.

+    ExternalReference allocation_limit =
+        AllocationUtils::GetAllocationLimitReference(isolate(), flags);
+    Operand limit_operand = ExternalOperand(allocation_limit);
+    cmpp(result_end, limit_operand);
+    j(above, gc_required);
+  }
+
+  if ((flags & ALLOCATION_FOLDING_DOMINATOR) == 0) {
+    // Update allocation top.
+    UpdateAllocationTopHelper(result_end, scratch, flags);
+  }
 
   // Tag the result if requested.
   if ((flags & TAG_OBJECT) != 0) {
     addp(result, Immediate(kHeapObjectTag));
   }
 }
 
+void MacroAssembler::SetTop(Register value, AllocationFlags flags) {
+  ExternalReference allocation_top =
+      AllocationUtils::GetAllocationTopReference(isolate(), flags);
+
+  subp(value, Immediate(kHeapObjectTag));

[Benedikt Meurer, 2016/04/19 07:25:39]

How about this one instead?

// TODO(hpayer): Change top and limit to tagged.
leap(kScratchRegister, Operand(value, -kHeapObjectTag));
Store(allocation_top, kScratchRegister);

[Hannes Payer (out of office), 2016/04/19 11:03:56]

Store already uses the scratch register.

+  Store(allocation_top, value);
+  addp(value, Immediate(kHeapObjectTag));
+}
 
 void MacroAssembler::AllocateHeapNumber(Register result,
                                         Register scratch,
                                         Label* gc_required,
                                         MutableMode mode) {
   // Allocate heap number in new space.
   Allocate(HeapNumber::kSize, result, scratch, no_reg, gc_required, TAG_OBJECT);
 
   Heap::RootListIndex map_index = mode == MUTABLE
       ? Heap::kMutableHeapNumberMapRootIndex
@@ skipping 698 matching lines @@
   movl(rax, dividend);
   shrl(rax, Immediate(31));
   addl(rdx, rax);
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_X64