Provide a tagged allocation top pointer.

src/code-stub-assembler.cc

 // Copyright 2016 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 "src/code-stub-assembler.h"
 #include "src/code-factory.h"
 #include "src/frames-inl.h"
 #include "src/frames.h"
 #include "src/ic/stub-cache.h"
 
@@ skipping 360 matching lines @@
                                  SmiTag(size_in_bytes));
   }
   result.Bind(runtime_result);
   Goto(&merge_runtime);
 
   // When there is enough space, return `top' and bump it up.
   Bind(&no_runtime_call);
   Node* no_runtime_result = top;
   StoreNoWriteBarrier(MachineType::PointerRepresentation(), top_address,
                       new_top);
-  no_runtime_result = BitcastWordToTagged(
-      IntPtrAdd(no_runtime_result, IntPtrConstant(kHeapObjectTag)));
-  result.Bind(no_runtime_result);
+  result.Bind(BitcastWordToTagged(no_runtime_result));
   Goto(&merge_runtime);
 
   Bind(&merge_runtime);
   return result.value();
 }
 
 Node* CodeStubAssembler::AllocateRawAligned(Node* size_in_bytes,
                                             AllocationFlags flags,
                                             Node* top_address,
                                             Node* limit_address) {
   Node* top = Load(MachineType::Pointer(), top_address);
   Node* limit = Load(MachineType::Pointer(), limit_address);
   Variable adjusted_size(this, MachineType::PointerRepresentation());
   adjusted_size.Bind(size_in_bytes);
   if (flags & kDoubleAlignment) {
     // TODO(epertoso): Simd128 alignment.
     Label aligned(this), not_aligned(this), merge(this, &adjusted_size);
-    Branch(WordAnd(top, IntPtrConstant(kDoubleAlignmentMask)), &not_aligned,
-           &aligned);
+    Branch(WordAnd(IntPtrSub(top, IntPtrConstant(kHeapObjectTag)),
+                   IntPtrConstant(kDoubleAlignmentMask)),
+           &not_aligned, &aligned);
 
     Bind(&not_aligned);
     Node* not_aligned_size =
         IntPtrAdd(size_in_bytes, IntPtrConstant(kPointerSize));
     adjusted_size.Bind(not_aligned_size);
     Goto(&merge);
 
     Bind(&aligned);
     Goto(&merge);
 
     Bind(&merge);
   }
 
   Variable address(this, MachineRepresentation::kTagged);
   address.Bind(AllocateRawUnaligned(adjusted_size.value(), kNone, top, limit));
 
   Label needs_filler(this), doesnt_need_filler(this),
       merge_address(this, &address);
   Branch(IntPtrEqual(adjusted_size.value(), size_in_bytes), &doesnt_need_filler,
          &needs_filler);
 
   Bind(&needs_filler);
   // Store a filler and increase the address by kPointerSize.
   // TODO(epertoso): this code assumes that we only align to kDoubleSize. Change
   // it when Simd128 alignment is supported.
-  StoreNoWriteBarrier(MachineType::PointerRepresentation(), top,
+  StoreNoWriteBarrier(MachineType::PointerRepresentation(),
+                      IntPtrSub(top, IntPtrConstant(1)),
                       LoadRoot(Heap::kOnePointerFillerMapRootIndex));
   address.Bind(BitcastWordToTagged(
       IntPtrAdd(address.value(), IntPtrConstant(kPointerSize))));
   Goto(&merge_address);
 
   Bind(&doesnt_need_filler);
   Goto(&merge_address);
 
   Bind(&merge_address);
   // Update the top.
@@ skipping 1864 matching lines @@
     Code::Flags code_flags =
         Code::RemoveHolderFromFlags(Code::ComputeHandlerFlags(Code::LOAD_IC));
 
     TryProbeStubCache(isolate()->stub_cache(), code_flags, p->receiver, p->name,
                       &if_handler, &var_handler, if_miss);
   }
 }
 
 }  // namespace internal
 }  // namespace v8