[turbofan] Introduce dedicated BitcastWordToTagged machine operator.

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"
 
 namespace v8 {
 namespace internal {
 
@@ skipping 325 matching lines @@
   Node* runtime_result = CallRuntime(Runtime::kAllocateInTargetSpace, context,
                                      SmiTag(size_in_bytes), runtime_flags);
   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,
                       IntPtrAdd(top, size_in_bytes));
-  no_runtime_result =
-      IntPtrAdd(no_runtime_result, IntPtrConstant(kHeapObjectTag));
+  no_runtime_result = BitcastWordToTagged(
+      IntPtrAdd(no_runtime_result, IntPtrConstant(kHeapObjectTag)));
   result.Bind(no_runtime_result);
   Goto(&merge_runtime);
 
   Bind(&merge_runtime);
   return result.value();
 }
 
 Node* CodeStubAssembler::AllocateRawAligned(Node* size_in_bytes,
                                             AllocationFlags flags,
                                             Node* top_address,
@@ skipping 27 matching lines @@
       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,
                       LoadRoot(Heap::kOnePointerFillerMapRootIndex));
-  address.Bind(IntPtrAdd(address.value(), IntPtrConstant(kPointerSize)));
+  address.Bind(BitcastWordToTagged(
+      IntPtrAdd(address.value(), IntPtrConstant(kPointerSize))));
   Goto(&merge_address);
 
   Bind(&doesnt_need_filler);
   Goto(&merge_address);
 
   Bind(&merge_address);
   // Update the top.
   StoreNoWriteBarrier(MachineType::PointerRepresentation(), top_address,
                       IntPtrAdd(top, adjusted_size.value()));
   return address.value();
@@ skipping 15 matching lines @@
     return AllocateRawAligned(IntPtrConstant(size_in_bytes), flags, top_address,
                               limit_address);
   }
 #endif
 
   return AllocateRawUnaligned(IntPtrConstant(size_in_bytes), flags, top_address,
                               limit_address);
 }
 
 Node* CodeStubAssembler::InnerAllocate(Node* previous, int offset) {
-  return IntPtrAdd(previous, IntPtrConstant(offset));
+  return BitcastWordToTagged(IntPtrAdd(previous, IntPtrConstant(offset)));
 }
 
 Node* CodeStubAssembler::LoadBufferObject(Node* buffer, int offset,
                                           MachineType rep) {
   return Load(rep, buffer, IntPtrConstant(offset));
 }
 
 Node* CodeStubAssembler::LoadObjectField(Node* object, int offset,
                                          MachineType rep) {
   return Load(rep, object, IntPtrConstant(offset - kHeapObjectTag));
@@ skipping 681 matching lines @@
 }
 
 Node* CodeStubAssembler::BitFieldDecode(Node* word32, uint32_t shift,
                                         uint32_t mask) {
   return Word32Shr(Word32And(word32, Int32Constant(mask)),
                    Int32Constant(shift));
 }
 
 }  // namespace internal
 }  // namespace v8