Get rid of AllocationFlags::TAG_OBJECT

src/arm64/code-stubs-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/code-stubs.h"
 #include "src/api-arguments.h"
 #include "src/bootstrapper.h"
 #include "src/codegen.h"
@@ skipping 4806 matching lines @@
   __ Ldr(x0, FieldMemOperand(x2, Map::kConstructorOrBackPointerOffset));
   __ CompareAndBranch(x0, x1, ne, &new_object);
 
   // Allocate the JSObject on the heap.
   Label allocate, done_allocate;
   __ Ldrb(x4, FieldMemOperand(x2, Map::kInstanceSizeOffset));
   __ Allocate(x4, x0, x5, x6, &allocate, SIZE_IN_WORDS);
   __ Bind(&done_allocate);
 
   // Initialize the JSObject fields.
-  __ Mov(x1, x0);
   STATIC_ASSERT(JSObject::kMapOffset == 0 * kPointerSize);
-  __ Str(x2, MemOperand(x1, kPointerSize, PostIndex));
+  __ Str(x2, FieldMemOperand(x0, JSObject::kMapOffset));
   __ LoadRoot(x3, Heap::kEmptyFixedArrayRootIndex);
   STATIC_ASSERT(JSObject::kPropertiesOffset == 1 * kPointerSize);
   STATIC_ASSERT(JSObject::kElementsOffset == 2 * kPointerSize);
-  __ Stp(x3, x3, MemOperand(x1, 2 * kPointerSize, PostIndex));
+  __ Str(x3, FieldMemOperand(x0, JSObject::kPropertiesOffset));
+  __ Str(x3, FieldMemOperand(x0, JSObject::kElementsOffset));
   STATIC_ASSERT(JSObject::kHeaderSize == 3 * kPointerSize);
+  __ Add(x1, x0, Operand(JSObject::kHeaderSize - kHeapObjectTag));
 
   // ----------- S t a t e -------------
-  //  -- x0 : result (untagged)
+  //  -- x0 : result (tagged)
   //  -- x1 : result fields (untagged)
   //  -- x5 : result end (untagged)
   //  -- x2 : initial map
   //  -- cp : context
   //  -- lr : return address
   // -----------------------------------
 
   // Perform in-object slack tracking if requested.
   Label slack_tracking;
   STATIC_ASSERT(Map::kNoSlackTracking == 0);
   __ LoadRoot(x6, Heap::kUndefinedValueRootIndex);
   __ Ldr(w3, FieldMemOperand(x2, Map::kBitField3Offset));
   __ TestAndBranchIfAnySet(w3, Map::ConstructionCounter::kMask,
                            &slack_tracking);
   {
     // Initialize all in-object fields with undefined.
     __ InitializeFieldsWithFiller(x1, x5, x6);
-
-    // Add the object tag to make the JSObject real.
-    STATIC_ASSERT(kHeapObjectTag == 1);
-    __ Add(x0, x0, kHeapObjectTag);
     __ Ret();
   }
   __ Bind(&slack_tracking);
   {
     // Decrease generous allocation count.
     STATIC_ASSERT(Map::ConstructionCounter::kNext == 32);
     __ Sub(w3, w3, 1 << Map::ConstructionCounter::kShift);
     __ Str(w3, FieldMemOperand(x2, Map::kBitField3Offset));
 
     // Initialize the in-object fields with undefined.
     __ Ldrb(x4, FieldMemOperand(x2, Map::kUnusedPropertyFieldsOffset));
     __ Sub(x4, x5, Operand(x4, LSL, kPointerSizeLog2));
     __ InitializeFieldsWithFiller(x1, x4, x6);
 
     // Initialize the remaining (reserved) fields with one pointer filler map.
     __ LoadRoot(x6, Heap::kOnePointerFillerMapRootIndex);
     __ InitializeFieldsWithFiller(x1, x5, x6);
 
-    // Add the object tag to make the JSObject real.
-    STATIC_ASSERT(kHeapObjectTag == 1);
-    __ Add(x0, x0, kHeapObjectTag);
-
     // Check if we can finalize the instance size.
     Label finalize;
     STATIC_ASSERT(Map::kSlackTrackingCounterEnd == 1);
     __ TestAndBranchIfAllClear(w3, Map::ConstructionCounter::kMask, &finalize);
     __ Ret();
 
     // Finalize the instance size.
     __ Bind(&finalize);
     {
       FrameScope scope(masm, StackFrame::INTERNAL);
       __ Push(x0, x2);
       __ CallRuntime(Runtime::kFinalizeInstanceSize);
       __ Pop(x0);
     }
     __ Ret();
   }
 
   // Fall back to %AllocateInNewSpace.
   __ Bind(&allocate);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     STATIC_ASSERT(kSmiTag == 0);
     STATIC_ASSERT(kSmiTagSize == 1);
     __ Mov(x4,
            Operand(x4, LSL, kPointerSizeLog2 + kSmiTagSize + kSmiShiftSize));
     __ Push(x2, x4);
     __ CallRuntime(Runtime::kAllocateInNewSpace);
     __ Pop(x2);
   }
-  STATIC_ASSERT(kHeapObjectTag == 1);
-  __ Sub(x0, x0, kHeapObjectTag);
   __ Ldrb(x5, FieldMemOperand(x2, Map::kInstanceSizeOffset));
   __ Add(x5, x0, Operand(x5, LSL, kPointerSizeLog2));
+  STATIC_ASSERT(kHeapObjectTag == 1);
+  __ Sub(x5, x5, kHeapObjectTag);  // Subtract the tag from end.
   __ B(&done_allocate);
 
   // Fall back to %NewObject.
   __ Bind(&new_object);
   __ Push(x1, x3);
   __ TailCallRuntime(Runtime::kNewObject);
 }
 
 
 void FastNewRestParameterStub::Generate(MacroAssembler* masm) {
@@ skipping 43 matching lines @@
   // Return an empty rest parameter array.
   __ Bind(&no_rest_parameters);
   {
     // ----------- S t a t e -------------
     //  -- cp : context
     //  -- lr : return address
     // -----------------------------------
 
     // Allocate an empty rest parameter array.
     Label allocate, done_allocate;
-    __ Allocate(JSArray::kSize, x0, x1, x2, &allocate, TAG_OBJECT);
+    __ Allocate(JSArray::kSize, x0, x1, x2, &allocate, NO_ALLOCATION_FLAGS);
     __ Bind(&done_allocate);
 
     // Setup the rest parameter array in x0.
     __ LoadNativeContextSlot(Context::JS_ARRAY_FAST_ELEMENTS_MAP_INDEX, x1);
     __ Str(x1, FieldMemOperand(x0, JSArray::kMapOffset));
     __ LoadRoot(x1, Heap::kEmptyFixedArrayRootIndex);
     __ Str(x1, FieldMemOperand(x0, JSArray::kPropertiesOffset));
     __ Str(x1, FieldMemOperand(x0, JSArray::kElementsOffset));
     __ Mov(x1, Smi::FromInt(0));
     __ Str(x1, FieldMemOperand(x0, JSArray::kLengthOffset));
@@ skipping 20 matching lines @@
     //  -- cp : context
     //  -- x0 : number of rest parameters
     //  -- x2 : pointer to first rest parameters
     //  -- lr : return address
     // -----------------------------------
 
     // Allocate space for the rest parameter array plus the backing store.
     Label allocate, done_allocate;
     __ Mov(x1, JSArray::kSize + FixedArray::kHeaderSize);
     __ Add(x1, x1, Operand(x0, LSL, kPointerSizeLog2));
-    __ Allocate(x1, x3, x4, x5, &allocate, TAG_OBJECT);
+    __ Allocate(x1, x3, x4, x5, &allocate, NO_ALLOCATION_FLAGS);
     __ Bind(&done_allocate);
 
     // Compute arguments.length in x6.
     __ SmiTag(x6, x0);
 
     // Setup the elements array in x3.
     __ LoadRoot(x1, Heap::kFixedArrayMapRootIndex);
     __ Str(x1, FieldMemOperand(x3, FixedArray::kMapOffset));
     __ Str(x6, FieldMemOperand(x3, FixedArray::kLengthOffset));
     __ Add(x4, x3, FixedArray::kHeaderSize);
@@ skipping 156 matching lines @@
   __ Cmp(mapped_params, 0);
   __ CzeroX(size, eq);
 
   // 2. Add the size of the backing store and arguments object.
   __ Add(size, size, Operand(arg_count, LSL, kPointerSizeLog2));
   __ Add(size, size, FixedArray::kHeaderSize + JSSloppyArgumentsObject::kSize);
 
   // Do the allocation of all three objects in one go. Assign this to x0, as it
   // will be returned to the caller.
   Register alloc_obj = x0;
-  __ Allocate(size, alloc_obj, x11, x12, &runtime, TAG_OBJECT);
+  __ Allocate(size, alloc_obj, x11, x12, &runtime, NO_ALLOCATION_FLAGS);
 
   // Get the arguments boilerplate from the current (global) context.
 
   //   x0   alloc_obj       pointer to allocated objects (param map, backing
   //                        store, arguments)
   //   x1   function        function pointer
   //   x2   arg_count_smi   number of function arguments (smi)
   //   x3   recv_arg        pointer to receiver arguments
   //   x4   mapped_params   number of mapped parameters, min(params, args)
   //   x7   param_count     number of function parameters
@@ skipping 213 matching lines @@
   //  -- cp : context
   //  -- x0 : number of rest parameters
   //  -- x2 : pointer to first rest parameters
   //  -- lr : return address
   // -----------------------------------
 
   // Allocate space for the strict arguments object plus the backing store.
   Label allocate, done_allocate;
   __ Mov(x1, JSStrictArgumentsObject::kSize + FixedArray::kHeaderSize);
   __ Add(x1, x1, Operand(x0, LSL, kPointerSizeLog2));
-  __ Allocate(x1, x3, x4, x5, &allocate, TAG_OBJECT);
+  __ Allocate(x1, x3, x4, x5, &allocate, NO_ALLOCATION_FLAGS);
   __ Bind(&done_allocate);
 
   // Compute arguments.length in x6.
   __ SmiTag(x6, x0);
 
   // Setup the elements array in x3.
   __ LoadRoot(x1, Heap::kFixedArrayMapRootIndex);
   __ Str(x1, FieldMemOperand(x3, FixedArray::kMapOffset));
   __ Str(x6, FieldMemOperand(x3, FixedArray::kLengthOffset));
   __ Add(x4, x3, FixedArray::kHeaderSize);
@@ skipping 522 matching lines @@
                            kStackUnwindSpace, NULL, spill_offset,
                            return_value_operand, NULL);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_ARM64