PPC: Get rid of AllocationFlags::TAG_OBJECT

src/ppc/code-stubs-ppc.cc

 // Copyright 2014 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_PPC
 
 #include "src/code-stubs.h"
 #include "src/api-arguments.h"
 #include "src/base/bits.h"
 #include "src/bootstrapper.h"
@@ skipping 4680 matching lines @@
   __ cmp(r3, r4);
   __ bne(&new_object);
 
   // Allocate the JSObject on the heap.
   Label allocate, done_allocate;
   __ lbz(r7, FieldMemOperand(r5, Map::kInstanceSizeOffset));
   __ Allocate(r7, r3, r8, r9, &allocate, SIZE_IN_WORDS);
   __ bind(&done_allocate);
 
   // Initialize the JSObject fields.
-  __ StoreP(r5, MemOperand(r3, JSObject::kMapOffset));
+  __ StoreP(r5, FieldMemOperand(r3, JSObject::kMapOffset), r0);
   __ LoadRoot(r6, Heap::kEmptyFixedArrayRootIndex);
-  __ StoreP(r6, MemOperand(r3, JSObject::kPropertiesOffset));
-  __ StoreP(r6, MemOperand(r3, JSObject::kElementsOffset));
+  __ StoreP(r6, FieldMemOperand(r3, JSObject::kPropertiesOffset), r0);
+  __ StoreP(r6, FieldMemOperand(r3, JSObject::kElementsOffset), r0);
   STATIC_ASSERT(JSObject::kHeaderSize == 3 * kPointerSize);
-  __ addi(r4, r3, Operand(JSObject::kHeaderSize));
+  __ addi(r4, r3, Operand(JSObject::kHeaderSize - kHeapObjectTag));
 
   // ----------- S t a t e -------------
-  //  -- r3 : result (untagged)
+  //  -- r3 : result (tagged)
   //  -- r4 : result fields (untagged)
   //  -- r8 : result end (untagged)
   //  -- r5 : initial map
   //  -- cp : context
   //  -- lr : return address
   // -----------------------------------
 
   // Perform in-object slack tracking if requested.
   Label slack_tracking;
   STATIC_ASSERT(Map::kNoSlackTracking == 0);
   __ LoadRoot(r9, Heap::kUndefinedValueRootIndex);
   __ lwz(r6, FieldMemOperand(r5, Map::kBitField3Offset));
   __ DecodeField<Map::ConstructionCounter>(r10, r6, SetRC);
   __ bne(&slack_tracking, cr0);
   {
     // Initialize all in-object fields with undefined.
     __ InitializeFieldsWithFiller(r4, r8, r9);
-
-    // Add the object tag to make the JSObject real.
-    __ addi(r3, r3, Operand(kHeapObjectTag));
     __ Ret();
   }
   __ bind(&slack_tracking);
   {
     // Decrease generous allocation count.
     STATIC_ASSERT(Map::ConstructionCounter::kNext == 32);
     __ Add(r6, r6, -(1 << Map::ConstructionCounter::kShift), r0);
     __ stw(r6, FieldMemOperand(r5, Map::kBitField3Offset));
 
     // Initialize the in-object fields with undefined.
     __ lbz(r7, FieldMemOperand(r5, Map::kUnusedPropertyFieldsOffset));
     __ ShiftLeftImm(r7, r7, Operand(kPointerSizeLog2));
     __ sub(r7, r8, r7);
     __ InitializeFieldsWithFiller(r4, r7, r9);
 
     // Initialize the remaining (reserved) fields with one pointer filler map.
     __ LoadRoot(r9, Heap::kOnePointerFillerMapRootIndex);
     __ InitializeFieldsWithFiller(r4, r8, r9);
 
-    // Add the object tag to make the JSObject real.
-    __ addi(r3, r3, Operand(kHeapObjectTag));
-
     // Check if we can finalize the instance size.
     __ cmpi(r10, Operand(Map::kSlackTrackingCounterEnd));
     __ Ret(ne);
 
     // Finalize the instance size.
     {
       FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
       __ Push(r3, r5);
       __ CallRuntime(Runtime::kFinalizeInstanceSize);
       __ Pop(r3);
     }
     __ Ret();
   }
 
   // Fall back to %AllocateInNewSpace.
   __ bind(&allocate);
   {
     FrameAndConstantPoolScope scope(masm, StackFrame::INTERNAL);
     STATIC_ASSERT(kSmiTag == 0);
     __ ShiftLeftImm(r7, r7,
                     Operand(kPointerSizeLog2 + kSmiTagSize + kSmiShiftSize));
     __ Push(r5, r7);
     __ CallRuntime(Runtime::kAllocateInNewSpace);
     __ Pop(r5);
   }
-  __ subi(r3, r3, Operand(kHeapObjectTag));
   __ lbz(r8, FieldMemOperand(r5, Map::kInstanceSizeOffset));
   __ ShiftLeftImm(r8, r8, Operand(kPointerSizeLog2));
   __ add(r8, r3, r8);
+  __ subi(r8, r8, Operand(kHeapObjectTag));
   __ b(&done_allocate);
 
   // Fall back to %NewObject.
   __ bind(&new_object);
   __ Push(r4, r6);
   __ TailCallRuntime(Runtime::kNewObject);
 }
 
 void FastNewRestParameterStub::Generate(MacroAssembler* masm) {
   // ----------- S t a t e -------------
@@ skipping 44 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, r3, r4, r5, &allocate, TAG_OBJECT);
+    __ Allocate(JSArray::kSize, r3, r4, r5, &allocate, NO_ALLOCATION_FLAGS);
     __ bind(&done_allocate);
 
     // Setup the rest parameter array in r0.
     __ LoadNativeContextSlot(Context::JS_ARRAY_FAST_ELEMENTS_MAP_INDEX, r4);
     __ StoreP(r4, FieldMemOperand(r3, JSArray::kMapOffset), r0);
     __ LoadRoot(r4, Heap::kEmptyFixedArrayRootIndex);
     __ StoreP(r4, FieldMemOperand(r3, JSArray::kPropertiesOffset), r0);
     __ StoreP(r4, FieldMemOperand(r3, JSArray::kElementsOffset), r0);
     __ li(r4, Operand::Zero());
     __ StoreP(r4, FieldMemOperand(r3, JSArray::kLengthOffset), r0);
@@ skipping 22 matching lines @@
     //  -- r3 : number of rest parameters (tagged)
     //  -- r5 : pointer just past first rest parameters
     //  -- r9 : size of rest parameters
     //  -- lr : return address
     // -----------------------------------
 
     // Allocate space for the rest parameter array plus the backing store.
     Label allocate, done_allocate;
     __ mov(r4, Operand(JSArray::kSize + FixedArray::kHeaderSize));
     __ add(r4, r4, r9);
-    __ Allocate(r4, r6, r7, r8, &allocate, TAG_OBJECT);
+    __ Allocate(r4, r6, r7, r8, &allocate, NO_ALLOCATION_FLAGS);
     __ bind(&done_allocate);
 
     // Setup the elements array in r6.
     __ LoadRoot(r4, Heap::kFixedArrayMapRootIndex);
     __ StoreP(r4, FieldMemOperand(r6, FixedArray::kMapOffset), r0);
     __ StoreP(r3, FieldMemOperand(r6, FixedArray::kLengthOffset), r0);
     __ addi(r7, r6,
             Operand(FixedArray::kHeaderSize - kHeapObjectTag - kPointerSize));
     {
       Label loop;
@@ skipping 134 matching lines @@
 
   // 2. Backing store.
   __ SmiToPtrArrayOffset(r7, r8);
   __ add(r11, r11, r7);
   __ addi(r11, r11, Operand(FixedArray::kHeaderSize));
 
   // 3. Arguments object.
   __ addi(r11, r11, Operand(JSSloppyArgumentsObject::kSize));
 
   // Do the allocation of all three objects in one go.
-  __ Allocate(r11, r3, r11, r7, &runtime, TAG_OBJECT);
+  __ Allocate(r11, r3, r11, r7, &runtime, NO_ALLOCATION_FLAGS);
 
   // r3 = address of new object(s) (tagged)
   // r5 = argument count (smi-tagged)
   // Get the arguments boilerplate from the current native context into r4.
   const int kNormalOffset =
       Context::SlotOffset(Context::SLOPPY_ARGUMENTS_MAP_INDEX);
   const int kAliasedOffset =
       Context::SlotOffset(Context::FAST_ALIASED_ARGUMENTS_MAP_INDEX);
 
   __ LoadP(r7, NativeContextMemOperand());
@@ skipping 203 matching lines @@
   //  -- r3 : number of rest parameters (tagged)
   //  -- r5 : pointer just past first rest parameters
   //  -- r9 : size of rest parameters
   //  -- lr : return address
   // -----------------------------------
 
   // Allocate space for the strict arguments object plus the backing store.
   Label allocate, done_allocate;
   __ mov(r4, Operand(JSStrictArgumentsObject::kSize + FixedArray::kHeaderSize));
   __ add(r4, r4, r9);
-  __ Allocate(r4, r6, r7, r8, &allocate, TAG_OBJECT);
+  __ Allocate(r4, r6, r7, r8, &allocate, NO_ALLOCATION_FLAGS);
   __ bind(&done_allocate);
 
   // Setup the elements array in r6.
   __ LoadRoot(r4, Heap::kFixedArrayMapRootIndex);
   __ StoreP(r4, FieldMemOperand(r6, FixedArray::kMapOffset), r0);
   __ StoreP(r3, FieldMemOperand(r6, FixedArray::kLengthOffset), r0);
   __ addi(r7, r6,
           Operand(FixedArray::kHeaderSize - kHeapObjectTag - kPointerSize));
   {
     Label loop, done_loop;
@@ skipping 541 matching lines @@
       fp, (PropertyCallbackArguments::kReturnValueOffset + 3) * kPointerSize);
   CallApiFunctionAndReturn(masm, api_function_address, thunk_ref,
                            kStackUnwindSpace, NULL, return_value_operand, NULL);
 }
 
 #undef __
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_PPC