Revert of Provide a tagged allocation top pointer.

src/arm64/macro-assembler-arm64.cc

 // Copyright 2013 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_ARM64
 
 #include "src/base/bits.h"
 #include "src/base/division-by-constant.h"
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
@@ skipping 3079 matching lines @@
 
   // Calculate new top and bail out if new space is exhausted.
   Adds(result_end, result, object_size);
   Ccmp(result_end, alloc_limit, NoFlag, cc);
   B(hi, gc_required);
 
   if ((flags & ALLOCATION_FOLDING_DOMINATOR) == 0) {
     // The top pointer is not updated for allocation folding dominators.
     Str(result_end, MemOperand(top_address));
   }
+
+  // Tag the object.
+  ObjectTag(result, result);
 }
 
 
 void MacroAssembler::Allocate(Register object_size, Register result,
                               Register result_end, Register scratch,
                               Label* gc_required, AllocationFlags flags) {
   if (!FLAG_inline_new) {
     if (emit_debug_code()) {
       // Trash the registers to simulate an allocation failure.
       // We apply salt to the original zap value to easily spot the values.
@@ skipping 49 matching lines @@
 
   // Calculate new top and bail out if new space is exhausted
   if ((flags & SIZE_IN_WORDS) != 0) {
     Adds(result_end, result, Operand(object_size, LSL, kPointerSizeLog2));
   } else {
     Adds(result_end, result, object_size);
   }
 
   if (emit_debug_code()) {
     Tst(result_end, kObjectAlignmentMask);
-    Check(ne, kUnalignedAllocationInNewSpace);
+    Check(eq, kUnalignedAllocationInNewSpace);
   }
 
   Ccmp(result_end, alloc_limit, NoFlag, cc);
   B(hi, gc_required);
 
   if ((flags & ALLOCATION_FOLDING_DOMINATOR) == 0) {
     // The top pointer is not updated for allocation folding dominators.
     Str(result_end, MemOperand(top_address));
   }
+
+  // Tag the object.
+  ObjectTag(result, result);
 }
 
 void MacroAssembler::FastAllocate(int object_size, Register result,
                                   Register scratch1, Register scratch2,
                                   AllocationFlags flags) {
   DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
 
   DCHECK(!AreAliased(result, scratch1, scratch2));
   DCHECK(result.Is64Bits() && scratch1.Is64Bits() && scratch2.Is64Bits());
 
@@ skipping 12 matching lines @@
   Mov(top_address, Operand(heap_allocation_top));
   Ldr(result, MemOperand(top_address));
 
   // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
   // the same alignment on ARM64.
   STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
 
   // Calculate new top and write it back.
   Adds(result_end, result, object_size);
   Str(result_end, MemOperand(top_address));
+
+  ObjectTag(result, result);
 }
 
 void MacroAssembler::FastAllocate(Register object_size, Register result,
                                   Register result_end, Register scratch,
                                   AllocationFlags flags) {
   // |object_size| and |result_end| may overlap, other registers must not.
   DCHECK(!AreAliased(object_size, result, scratch));
   DCHECK(!AreAliased(result_end, result, scratch));
   DCHECK(object_size.Is64Bits() && result.Is64Bits() && scratch.Is64Bits() &&
          result_end.Is64Bits());
@@ skipping 13 matching lines @@
   // Calculate new top and write it back.
   if ((flags & SIZE_IN_WORDS) != 0) {
     Adds(result_end, result, Operand(object_size, LSL, kPointerSizeLog2));
   } else {
     Adds(result_end, result, object_size);
   }
   Str(result_end, MemOperand(top_address));
 
   if (emit_debug_code()) {
     Tst(result_end, kObjectAlignmentMask);
-    Check(ne, kUnalignedAllocationInNewSpace);
+    Check(eq, kUnalignedAllocationInNewSpace);
   }
+
+  ObjectTag(result, result);
 }
 
 void MacroAssembler::AllocateTwoByteString(Register result,
                                            Register length,
                                            Register scratch1,
                                            Register scratch2,
                                            Register scratch3,
                                            Label* gc_required) {
   DCHECK(!AreAliased(result, length, scratch1, scratch2, scratch3));
   // Calculate the number of bytes needed for the characters in the string while
@@ skipping 1878 matching lines @@
 }
 
 
 #undef __
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM64