MIPS: Fix `[builtins] Reland of Port TypedArrayInitialize to CodeStubAssembler.`

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"
 
 namespace v8 {
 namespace internal {
@@ skipping 662 matching lines @@
   // Bailout if receiver has slow elements.
   GotoIfNot(IsFastElementsKind(elements_kind), if_false);
 
   // Check prototype chain if receiver does not have packed elements.
   if (mode == FastJSArrayAccessMode::INBOUNDS_READ) {
     GotoIfNot(IsHoleyFastElementsKind(elements_kind), if_true);
   }
   BranchIfPrototypesHaveNoElements(map, if_true, if_false);
 }
 
-Node* CodeStubAssembler::AllocateRawUnaligned(Node* size_in_bytes,
-                                              AllocationFlags flags,
-                                              Node* top_address,
-                                              Node* limit_address) {
+Node* CodeStubAssembler::AllocateRaw(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);
 
   // If there's not enough space, call the runtime.
   Variable result(this, MachineRepresentation::kTagged);
   Label runtime_call(this, Label::kDeferred), no_runtime_call(this);
   Label merge_runtime(this, &result);
 
+  bool needs_double_alignment = flags & kDoubleAlignment;
+
   if (flags & kAllowLargeObjectAllocation) {
     Label next(this);
     GotoIf(IsRegularHeapObjectSize(size_in_bytes), &next);
 
     Node* runtime_flags = SmiConstant(
-        Smi::FromInt(AllocateDoubleAlignFlag::encode(false) |
+        Smi::FromInt(AllocateDoubleAlignFlag::encode(needs_double_alignment) |
                      AllocateTargetSpace::encode(AllocationSpace::LO_SPACE)));
     Node* const runtime_result =
         CallRuntime(Runtime::kAllocateInTargetSpace, NoContextConstant(),
                     SmiTag(size_in_bytes), runtime_flags);
     result.Bind(runtime_result);
     Goto(&merge_runtime);
 
     Bind(&next);
   }
 
-  Node* new_top = IntPtrAdd(top, size_in_bytes);
+  Variable adjusted_size(this, MachineType::PointerRepresentation(),
+                         size_in_bytes);
+
+  if (needs_double_alignment) {
+    Label not_aligned(this), done_alignment(this, &adjusted_size);
+
+    Branch(WordAnd(top, IntPtrConstant(kDoubleAlignmentMask)), &not_aligned,
+           &done_alignment);
+
+    Bind(&not_aligned);
+    Node* not_aligned_size = IntPtrAdd(size_in_bytes, IntPtrConstant(4));
+    adjusted_size.Bind(not_aligned_size);
+    Goto(&done_alignment);
+
+    Bind(&done_alignment);
+  }
+
+  Node* new_top = IntPtrAdd(top, adjusted_size.value());
+
   Branch(UintPtrGreaterThanOrEqual(new_top, limit), &runtime_call,
          &no_runtime_call);
 
   Bind(&runtime_call);
   Node* runtime_result;
   if (flags & kPretenured) {
     Node* runtime_flags = SmiConstant(
-        Smi::FromInt(AllocateDoubleAlignFlag::encode(false) |
+        Smi::FromInt(AllocateDoubleAlignFlag::encode(needs_double_alignment) |
                      AllocateTargetSpace::encode(AllocationSpace::OLD_SPACE)));
     runtime_result =
         CallRuntime(Runtime::kAllocateInTargetSpace, NoContextConstant(),
                     SmiTag(size_in_bytes), runtime_flags);
   } else {
     runtime_result = CallRuntime(Runtime::kAllocateInNewSpace,
                                  NoContextConstant(), 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);
+
+  Variable address(this, MachineType::PointerRepresentation(),
+                   no_runtime_result);
+
+  if (needs_double_alignment) {
+    Label needs_filler(this), done_filling(this, &address);
+    Branch(IntPtrEqual(adjusted_size.value(), size_in_bytes), &done_filling,
+           &needs_filler);
+
+    Bind(&needs_filler);
+    // Store a filler and increase the address by kPointerSize.
+    StoreNoWriteBarrier(MachineRepresentation::kTagged, top,
+                        LoadRoot(Heap::kOnePointerFillerMapRootIndex));
+    address.Bind(IntPtrAdd(no_runtime_result, IntPtrConstant(4)));
+
+    Goto(&done_filling);
+
+    Bind(&done_filling);
+  }
+
   no_runtime_result = BitcastWordToTagged(
-      IntPtrAdd(no_runtime_result, IntPtrConstant(kHeapObjectTag)));
+      IntPtrAdd(address.value(), 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,
-                                            Node* limit_address) {
-  Node* top = Load(MachineType::Pointer(), top_address);
-  Variable adjusted_size(this, MachineType::PointerRepresentation(),
-                         size_in_bytes);
-  if (flags & kDoubleAlignment) {
-    Label not_aligned(this), done_alignment(this, &adjusted_size);
-    Branch(WordAnd(top, IntPtrConstant(kDoubleAlignmentMask)), &not_aligned,
-           &done_alignment);
+Node* CodeStubAssembler::AllocateRawUnaligned(Node* size_in_bytes,
+                                              AllocationFlags flags,
+                                              Node* top_address,
+                                              Node* limit_address) {
+  DCHECK((flags & kDoubleAlignment) == 0);
+  return AllocateRaw(size_in_bytes, flags, top_address, limit_address);
+}
 
-    Bind(&not_aligned);
-    Node* not_aligned_size =
-        IntPtrAdd(size_in_bytes, IntPtrConstant(kPointerSize));
-    adjusted_size.Bind(not_aligned_size);
-    Goto(&done_alignment);
-
-    Bind(&done_alignment);
-  }
-
-  Variable address(this, MachineRepresentation::kTagged,
-                   AllocateRawUnaligned(adjusted_size.value(), kNone,
-                                        top_address, limit_address));
-
-  Label needs_filler(this), done_filling(this, &address);
-  Branch(IntPtrEqual(adjusted_size.value(), size_in_bytes), &done_filling,
-         &needs_filler);
-
-  Bind(&needs_filler);
-  // Store a filler and increase the address by kPointerSize.
-  StoreNoWriteBarrier(MachineType::PointerRepresentation(), top,
-                      LoadRoot(Heap::kOnePointerFillerMapRootIndex));
-  address.Bind(BitcastWordToTagged(
-      IntPtrAdd(address.value(), IntPtrConstant(kPointerSize))));
-  Goto(&done_filling);
-
-  Bind(&done_filling);
-  // Update the top.
-  StoreNoWriteBarrier(MachineType::PointerRepresentation(), top_address,
-                      IntPtrAdd(top, adjusted_size.value()));
-  return address.value();
+Node* CodeStubAssembler::AllocateRawDoubleAligned(Node* size_in_bytes,
+                                                  AllocationFlags flags,
+                                                  Node* top_address,
+                                                  Node* limit_address) {
+#if defined(V8_HOST_ARCH_32_BIT)
+  return AllocateRaw(size_in_bytes, flags | kDoubleAlignment, top_address,
+                     limit_address);
+#elif defined(V8_HOST_ARCH_64_BIT)
+  // Allocation on 64 bit machine is naturally double aligned
+  return AllocateRaw(size_in_bytes, flags & ~kDoubleAlignment, top_address,
+                     limit_address);
+#else
+#error Architecture not supported
+#endif
 }
 
 Node* CodeStubAssembler::AllocateInNewSpace(Node* size_in_bytes,
                                             AllocationFlags flags) {
   DCHECK(flags == kNone || flags == kDoubleAlignment);
   CSA_ASSERT(this, IsRegularHeapObjectSize(size_in_bytes));
   return Allocate(size_in_bytes, flags);
 }
 
 Node* CodeStubAssembler::Allocate(Node* size_in_bytes, AllocationFlags flags) {
   Comment("Allocate");
   bool const new_space = !(flags & kPretenured);
   Node* top_address = ExternalConstant(
       new_space
           ? ExternalReference::new_space_allocation_top_address(isolate())
           : ExternalReference::old_space_allocation_top_address(isolate()));
   DCHECK_EQ(kPointerSize,
             ExternalReference::new_space_allocation_limit_address(isolate())
                     .address() -
                 ExternalReference::new_space_allocation_top_address(isolate())
                     .address());
   DCHECK_EQ(kPointerSize,
             ExternalReference::old_space_allocation_limit_address(isolate())
                     .address() -
                 ExternalReference::old_space_allocation_top_address(isolate())
                     .address());
   Node* limit_address = IntPtrAdd(top_address, IntPtrConstant(kPointerSize));
 
-#ifdef V8_HOST_ARCH_32_BIT
   if (flags & kDoubleAlignment) {
-    return AllocateRawAligned(size_in_bytes, flags, top_address, limit_address);
+    return AllocateRawDoubleAligned(size_in_bytes, flags, top_address,
+                                    limit_address);
+  } else {
+    return AllocateRawUnaligned(size_in_bytes, flags, top_address,
+                                limit_address);
   }
-#endif
-
-  return AllocateRawUnaligned(size_in_bytes, flags, top_address, limit_address);
 }
 
 Node* CodeStubAssembler::AllocateInNewSpace(int size_in_bytes,
                                             AllocationFlags flags) {
   CHECK(flags == kNone || flags == kDoubleAlignment);
   DCHECK_LE(size_in_bytes, kMaxRegularHeapObjectSize);
   return CodeStubAssembler::Allocate(IntPtrConstant(size_in_bytes), flags);
 }
 
 Node* CodeStubAssembler::Allocate(int size_in_bytes, AllocationFlags flags) {
@@ skipping 7560 matching lines @@
         formatted.c_str(), TENURED);
     CallRuntime(Runtime::kGlobalPrint, NoContextConstant(),
                 HeapConstant(string));
   }
   CallRuntime(Runtime::kDebugPrint, NoContextConstant(), tagged_value);
 #endif
 }
 
 }  // namespace internal
 }  // namespace v8