Revert of Provide a tagged allocation top pointer.

src/mips64/macro-assembler-mips64.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.
 
 #include <limits.h>  // For LONG_MIN, LONG_MAX.
 
 #if V8_TARGET_ARCH_MIPS64
 
 #include "src/base/division-by-constant.h"
 #include "src/bootstrapper.h"
@@ skipping 4300 matching lines @@
     if (emit_debug_code()) {
       // Assert that result actually contains top on entry.
       ld(alloc_limit, MemOperand(top_address));
       Check(eq, kUnexpectedAllocationTop, result, Operand(alloc_limit));
     }
     // Load allocation limit. Result already contains allocation top.
     ld(alloc_limit, MemOperand(top_address, static_cast<int32_t>(limit - top)));
   }
 
   // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
-  // the same alignment on MIPS64.
+  // the same alignment on ARM64.
   STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
 
   if (emit_debug_code()) {
-    And(at, result, Operand(kDoubleAlignmentMaskTagged));
+    And(at, result, Operand(kDoubleAlignmentMask));
     Check(eq, kAllocationIsNotDoubleAligned, at, Operand(zero_reg));
   }
 
   // Calculate new top and bail out if new space is exhausted. Use result
   // to calculate the new top.
   Daddu(result_end, result, Operand(object_size));
   Branch(gc_required, Ugreater, result_end, Operand(alloc_limit));
 
   if ((flags & ALLOCATION_FOLDING_DOMINATOR) == 0) {
     // The top pointer is not updated for allocation folding dominators.
     sd(result_end, MemOperand(top_address));
   }
+
+  // Tag object.
+  Daddu(result, result, Operand(kHeapObjectTag));
 }
 
 
 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.
       li(result, 0x7091);
@@ skipping 33 matching lines @@
     if (emit_debug_code()) {
       // Assert that result actually contains top on entry.
       ld(alloc_limit, MemOperand(top_address));
       Check(eq, kUnexpectedAllocationTop, result, Operand(alloc_limit));
     }
     // Load allocation limit. Result already contains allocation top.
     ld(alloc_limit, MemOperand(top_address, static_cast<int32_t>(limit - top)));
   }
 
   // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
-  // the same alignment on MIPS64.
+  // the same alignment on ARM64.
   STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
 
   if (emit_debug_code()) {
-    And(at, result, Operand(kDoubleAlignmentMaskTagged));
+    And(at, result, Operand(kDoubleAlignmentMask));
     Check(eq, kAllocationIsNotDoubleAligned, at, Operand(zero_reg));
   }
 
   // Calculate new top and bail out if new space is exhausted. Use result
   // to calculate the new top. Object size may be in words so a shift is
   // required to get the number of bytes.
   if ((flags & SIZE_IN_WORDS) != 0) {
     Dlsa(result_end, result, object_size, kPointerSizeLog2);
   } else {
     Daddu(result_end, result, Operand(object_size));
   }
 
   Branch(gc_required, Ugreater, result_end, Operand(alloc_limit));
 
   // Update allocation top. result temporarily holds the new top.
   if (emit_debug_code()) {
     And(at, result_end, Operand(kObjectAlignmentMask));
-    Check(ne, kUnalignedAllocationInNewSpace, at, Operand(zero_reg));
+    Check(eq, kUnalignedAllocationInNewSpace, at, Operand(zero_reg));
   }
 
   if ((flags & ALLOCATION_FOLDING_DOMINATOR) == 0) {
     // The top pointer is not updated for allocation folding dominators.
     sd(result_end, MemOperand(top_address));
   }
+
+  // Tag object if.
+  Daddu(result, result, Operand(kHeapObjectTag));
 }
 
 void MacroAssembler::FastAllocate(int object_size, Register result,
                                   Register scratch1, Register scratch2,
                                   AllocationFlags flags) {
   DCHECK(object_size <= Page::kMaxRegularHeapObjectSize);
   DCHECK(!AreAliased(result, scratch1, scratch2, at));
 
   // Make object size into bytes.
   if ((flags & SIZE_IN_WORDS) != 0) {
     object_size *= kPointerSize;
   }
   DCHECK(0 == (object_size & kObjectAlignmentMask));
 
   ExternalReference allocation_top =
       AllocationUtils::GetAllocationTopReference(isolate(), flags);
 
   Register top_address = scratch1;
   Register result_end = scratch2;
   li(top_address, Operand(allocation_top));
   ld(result, MemOperand(top_address));
 
   // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
   // the same alignment on MIPS64.
   STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
 
   if (emit_debug_code()) {
-    And(at, result, Operand(kDoubleAlignmentMaskTagged));
+    And(at, result, Operand(kDoubleAlignmentMask));
     Check(eq, kAllocationIsNotDoubleAligned, at, Operand(zero_reg));
   }
 
   // Calculate new top and write it back.
   Daddu(result_end, result, Operand(object_size));
   sd(result_end, MemOperand(top_address));
+
+  Daddu(result, result, Operand(kHeapObjectTag));
 }
 
 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, at));
   DCHECK(!AreAliased(result_end, result, scratch, at));
 
   ExternalReference allocation_top =
       AllocationUtils::GetAllocationTopReference(isolate(), flags);
 
   // Set up allocation top address and object size registers.
   Register top_address = scratch;
   li(top_address, Operand(allocation_top));
   ld(result, MemOperand(top_address));
 
   // We can ignore DOUBLE_ALIGNMENT flags here because doubles and pointers have
   // the same alignment on MIPS64.
   STATIC_ASSERT(kPointerAlignment == kDoubleAlignment);
 
   if (emit_debug_code()) {
-    And(at, result, Operand(kDoubleAlignmentMaskTagged));
+    And(at, result, Operand(kDoubleAlignmentMask));
     Check(eq, kAllocationIsNotDoubleAligned, at, Operand(zero_reg));
   }
 
   // Calculate new top and write it back
   if ((flags & SIZE_IN_WORDS) != 0) {
     Dlsa(result_end, result, object_size, kPointerSizeLog2);
   } else {
     Daddu(result_end, result, Operand(object_size));
   }
 
   // Update allocation top. result temporarily holds the new top.
   if (emit_debug_code()) {
     And(at, result_end, Operand(kObjectAlignmentMask));
-    Check(ne, kUnalignedAllocationInNewSpace, at, Operand(zero_reg));
+    Check(eq, kUnalignedAllocationInNewSpace, at, Operand(zero_reg));
   }
+
+  Daddu(result, result, Operand(kHeapObjectTag));
 }
 
 void MacroAssembler::AllocateTwoByteString(Register result,
                                            Register length,
                                            Register scratch1,
                                            Register scratch2,
                                            Register scratch3,
                                            Label* gc_required) {
   // Calculate the number of bytes needed for the characters in the string while
   // observing object alignment.
@@ skipping 2628 matching lines @@
   if (mag.shift > 0) sra(result, result, mag.shift);
   srl(at, dividend, 31);
   Addu(result, result, Operand(at));
 }
 
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS64