Get rid of AllocationFlags::TAG_OBJECT

src/mips/code-stubs-mips.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_MIPS
 
 #include "src/code-stubs.h"
 #include "src/api-arguments.h"
 #include "src/base/bits.h"
 #include "src/bootstrapper.h"
@@ skipping 4730 matching lines @@
   __ lw(a0, FieldMemOperand(a2, Map::kConstructorOrBackPointerOffset));
   __ Branch(&new_object, ne, a0, Operand(a1));
 
   // Allocate the JSObject on the heap.
   Label allocate, done_allocate;
   __ lbu(t0, FieldMemOperand(a2, Map::kInstanceSizeOffset));
   __ Allocate(t0, v0, t1, a0, &allocate, SIZE_IN_WORDS);
   __ bind(&done_allocate);
 
   // Initialize the JSObject fields.
-  __ sw(a2, MemOperand(v0, JSObject::kMapOffset));
+  __ sw(a2, FieldMemOperand(v0, JSObject::kMapOffset));
   __ LoadRoot(a3, Heap::kEmptyFixedArrayRootIndex);
-  __ sw(a3, MemOperand(v0, JSObject::kPropertiesOffset));
-  __ sw(a3, MemOperand(v0, JSObject::kElementsOffset));
+  __ sw(a3, FieldMemOperand(v0, JSObject::kPropertiesOffset));
+  __ sw(a3, FieldMemOperand(v0, JSObject::kElementsOffset));
   STATIC_ASSERT(JSObject::kHeaderSize == 3 * kPointerSize);
-  __ Addu(a1, v0, Operand(JSObject::kHeaderSize));
+  __ Addu(a1, v0, Operand(JSObject::kHeaderSize - kHeapObjectTag));
 
   // ----------- S t a t e -------------
-  //  -- v0 : result (untagged)
+  //  -- v0 : result (tagged)
   //  -- a1 : result fields (untagged)
   //  -- t1 : result end (untagged)
   //  -- a2 : initial map
   //  -- cp : context
   //  -- ra : return address
   // -----------------------------------
 
   // Perform in-object slack tracking if requested.
   Label slack_tracking;
   STATIC_ASSERT(Map::kNoSlackTracking == 0);
   __ lw(a3, FieldMemOperand(a2, Map::kBitField3Offset));
   __ And(at, a3, Operand(Map::ConstructionCounter::kMask));
   __ Branch(USE_DELAY_SLOT, &slack_tracking, ne, at, Operand(0));
   __ LoadRoot(a0, Heap::kUndefinedValueRootIndex);  // In delay slot.
   {
     // Initialize all in-object fields with undefined.
     __ InitializeFieldsWithFiller(a1, t1, a0);
-
-    // Add the object tag to make the JSObject real.
-    STATIC_ASSERT(kHeapObjectTag == 1);
-    __ Ret(USE_DELAY_SLOT);
-    __ Addu(v0, v0, Operand(kHeapObjectTag));  // In delay slot.
+    __ Ret();
   }
   __ bind(&slack_tracking);
   {
     // Decrease generous allocation count.
     STATIC_ASSERT(Map::ConstructionCounter::kNext == 32);
     __ Subu(a3, a3, Operand(1 << Map::ConstructionCounter::kShift));
     __ sw(a3, FieldMemOperand(a2, Map::kBitField3Offset));
 
     // Initialize the in-object fields with undefined.
     __ lbu(t0, FieldMemOperand(a2, Map::kUnusedPropertyFieldsOffset));
     __ sll(t0, t0, kPointerSizeLog2);
     __ subu(t0, t1, t0);
     __ InitializeFieldsWithFiller(a1, t0, a0);
 
     // Initialize the remaining (reserved) fields with one pointer filler map.
     __ LoadRoot(a0, Heap::kOnePointerFillerMapRootIndex);
     __ InitializeFieldsWithFiller(a1, t1, a0);
 
     // Check if we can finalize the instance size.
     Label finalize;
     STATIC_ASSERT(Map::kSlackTrackingCounterEnd == 1);
     __ And(a3, a3, Operand(Map::ConstructionCounter::kMask));
-    __ Branch(USE_DELAY_SLOT, &finalize, eq, a3, Operand(zero_reg));
-    STATIC_ASSERT(kHeapObjectTag == 1);
-    __ Addu(v0, v0, Operand(kHeapObjectTag));  // In delay slot.
+    __ Branch(&finalize, eq, a3, Operand(zero_reg));
     __ Ret();
 
     // Finalize the instance size.
     __ bind(&finalize);
     {
       FrameScope scope(masm, StackFrame::INTERNAL);
       __ Push(v0, a2);
       __ CallRuntime(Runtime::kFinalizeInstanceSize);
       __ Pop(v0);
     }
     __ Ret();
   }
 
   // Fall back to %AllocateInNewSpace.
   __ bind(&allocate);
   {
     FrameScope scope(masm, StackFrame::INTERNAL);
     STATIC_ASSERT(kSmiTag == 0);
     STATIC_ASSERT(kSmiTagSize == 1);
     __ sll(t0, t0, kPointerSizeLog2 + kSmiTagSize);
     __ Push(a2, t0);
     __ CallRuntime(Runtime::kAllocateInNewSpace);
     __ Pop(a2);
   }
-  STATIC_ASSERT(kHeapObjectTag == 1);
-  __ Subu(v0, v0, Operand(kHeapObjectTag));
   __ lbu(t1, FieldMemOperand(a2, Map::kInstanceSizeOffset));
   __ Lsa(t1, v0, t1, kPointerSizeLog2);
+  STATIC_ASSERT(kHeapObjectTag == 1);
+  __ Subu(t1, t1, Operand(kHeapObjectTag));
   __ jmp(&done_allocate);
 
   // Fall back to %NewObject.
   __ bind(&new_object);
   __ Push(a1, a3);
   __ TailCallRuntime(Runtime::kNewObject);
 }
 
 
 void FastNewRestParameterStub::Generate(MacroAssembler* masm) {
@@ skipping 41 matching lines @@
   // Return an empty rest parameter array.
   __ bind(&no_rest_parameters);
   {
     // ----------- S t a t e -------------
     //  -- cp : context
     //  -- ra : return address
     // -----------------------------------
 
     // Allocate an empty rest parameter array.
     Label allocate, done_allocate;
-    __ Allocate(JSArray::kSize, v0, a0, a1, &allocate, TAG_OBJECT);
+    __ Allocate(JSArray::kSize, v0, a0, a1, &allocate, NO_ALLOCATION_FLAGS);
     __ bind(&done_allocate);
 
     // Setup the rest parameter array in v0.
     __ LoadNativeContextSlot(Context::JS_ARRAY_FAST_ELEMENTS_MAP_INDEX, a1);
     __ sw(a1, FieldMemOperand(v0, JSArray::kMapOffset));
     __ LoadRoot(a1, Heap::kEmptyFixedArrayRootIndex);
     __ sw(a1, FieldMemOperand(v0, JSArray::kPropertiesOffset));
     __ sw(a1, FieldMemOperand(v0, JSArray::kElementsOffset));
     __ Move(a1, Smi::FromInt(0));
     __ Ret(USE_DELAY_SLOT);
@@ skipping 21 matching lines @@
     //  -- cp : context
     //  -- a0 : number of rest parameters (tagged)
     //  -- a2 : pointer to first rest parameters
     //  -- ra : return address
     // -----------------------------------
 
     // Allocate space for the rest parameter array plus the backing store.
     Label allocate, done_allocate;
     __ li(a1, Operand(JSArray::kSize + FixedArray::kHeaderSize));
     __ Lsa(a1, a1, a0, kPointerSizeLog2 - 1);
-    __ Allocate(a1, v0, a3, t0, &allocate, TAG_OBJECT);
+    __ Allocate(a1, v0, a3, t0, &allocate, NO_ALLOCATION_FLAGS);
     __ bind(&done_allocate);
 
     // Setup the elements array in v0.
     __ LoadRoot(at, Heap::kFixedArrayMapRootIndex);
     __ sw(at, FieldMemOperand(v0, FixedArray::kMapOffset));
     __ sw(a0, FieldMemOperand(v0, FixedArray::kLengthOffset));
     __ Addu(a3, v0, Operand(FixedArray::kHeaderSize));
     {
       Label loop, done_loop;
       __ sll(at, a0, kPointerSizeLog2 - 1);
@@ skipping 113 matching lines @@
   __ bind(&param_map_size);
 
   // 2. Backing store.
   __ Lsa(t5, t5, t1, 1);
   __ Addu(t5, t5, Operand(FixedArray::kHeaderSize));
 
   // 3. Arguments object.
   __ Addu(t5, t5, Operand(JSSloppyArgumentsObject::kSize));
 
   // Do the allocation of all three objects in one go.
-  __ Allocate(t5, v0, t5, t0, &runtime, TAG_OBJECT);
+  __ Allocate(t5, v0, t5, t0, &runtime, NO_ALLOCATION_FLAGS);
 
   // v0 = address of new object(s) (tagged)
   // a2 = argument count (smi-tagged)
   // Get the arguments boilerplate from the current native context into t0.
   const int kNormalOffset =
       Context::SlotOffset(Context::SLOPPY_ARGUMENTS_MAP_INDEX);
   const int kAliasedOffset =
       Context::SlotOffset(Context::FAST_ALIASED_ARGUMENTS_MAP_INDEX);
 
   __ lw(t0, NativeContextMemOperand());
@@ skipping 181 matching lines @@
   //  -- cp : context
   //  -- a0 : number of rest parameters (tagged)
   //  -- a2 : pointer to first rest parameters
   //  -- ra : return address
   // -----------------------------------
 
   // Allocate space for the strict arguments object plus the backing store.
   Label allocate, done_allocate;
   __ li(a1, Operand(JSStrictArgumentsObject::kSize + FixedArray::kHeaderSize));
   __ Lsa(a1, a1, a0, kPointerSizeLog2 - 1);
-  __ Allocate(a1, v0, a3, t0, &allocate, TAG_OBJECT);
+  __ Allocate(a1, v0, a3, t0, &allocate, NO_ALLOCATION_FLAGS);
   __ bind(&done_allocate);
 
   // Setup the elements array in v0.
   __ LoadRoot(at, Heap::kFixedArrayMapRootIndex);
   __ sw(at, FieldMemOperand(v0, FixedArray::kMapOffset));
   __ sw(a0, FieldMemOperand(v0, FixedArray::kLengthOffset));
   __ Addu(a3, v0, Operand(FixedArray::kHeaderSize));
   {
     Label loop, done_loop;
     __ sll(at, a0, kPointerSizeLog2 - 1);
@@ skipping 468 matching lines @@
                            kStackUnwindSpace, kInvalidStackOffset,
                            return_value_operand, NULL);
 }
 
 #undef __
 
 }  // namespace internal
 }  // namespace v8
 
 #endif  // V8_TARGET_ARCH_MIPS