MIPS[64]: Fix unaligned arguments storage in Wasm-to-interpreter entry

src/compiler/wasm-compiler.cc

 // Copyright 2015 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/compiler/wasm-compiler.h"
 
 #include <memory>
 
 #include "src/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
@@ skipping 2933 matching lines @@
                         : Int64Lowering::GetParameterCountAfterLowering(sig);
 
   // Build the start and the parameter nodes.
   Node* start = Start(param_count + 3);
   *effect_ = start;
   *control_ = start;
 
   // Compute size for the argument buffer.
   int args_size_bytes = 0;
   for (int i = 0; i < wasm_count; i++) {
-    args_size_bytes += 1 << ElementSizeLog2Of(sig->GetParam(i));
+    args_size_bytes +=
+        RoundUpToMultipleOfPowOf2(1 << ElementSizeLog2Of(sig->GetParam(i)), 8);
   }
 
   // The return value is also passed via this buffer:
   DCHECK_GE(wasm::kV8MaxWasmFunctionReturns, sig->return_count());
   // TODO(wasm): Handle multi-value returns.
   DCHECK_EQ(1, wasm::kV8MaxWasmFunctionReturns);
   int return_size_bytes =
       sig->return_count() == 0 ? 0 : 1 << ElementSizeLog2Of(sig->GetReturn(0));
 
   // Get a stack slot for the arguments.
   Node* arg_buffer = args_size_bytes == 0 && return_size_bytes == 0
                          ? jsgraph()->IntPtrConstant(0)
                          : graph()->NewNode(jsgraph()->machine()->StackSlot(
                                std::max(args_size_bytes, return_size_bytes)));
 
   // Now store all our arguments to the buffer.
   int param_index = 0;
   int offset = 0;
   for (int i = 0; i < wasm_count; i++) {
     Node* param = Param(param_index++);
     bool is_i64_as_two_params =
         jsgraph()->machine()->Is32() && sig->GetParam(i) == wasm::kWasmI64;
     MachineRepresentation param_rep =
         is_i64_as_two_params ? wasm::kWasmI32 : sig->GetParam(i);
     StoreRepresentation store_rep(param_rep, WriteBarrierKind::kNoWriteBarrier);
     *effect_ =
         graph()->NewNode(jsgraph()->machine()->Store(store_rep), arg_buffer,
                          Int32Constant(offset), param, *effect_, *control_);
-    offset += 1 << ElementSizeLog2Of(param_rep);
+
+    if (is_i64_as_two_params) {
+      offset += 1 << ElementSizeLog2Of(wasm::kWasmI32);
+    } else {
+      offset += RoundUpToMultipleOfPowOf2(1 << ElementSizeLog2Of(param_rep), 8);
+    }
+
     // TODO(clemensh): Respect endianess here. Might need to swap upper and
     // lower word.
     if (is_i64_as_two_params) {
       // Also store the upper half.
       param = Param(param_index++);
       StoreRepresentation store_rep(wasm::kWasmI32,
                                     WriteBarrierKind::kNoWriteBarrier);
       *effect_ =
           graph()->NewNode(jsgraph()->machine()->Store(store_rep), arg_buffer,
                            Int32Constant(offset), param, *effect_, *control_);
       offset += 1 << ElementSizeLog2Of(wasm::kWasmI32);
     }
+
+    DCHECK(IsAligned(offset, 8));
   }
   DCHECK_EQ(param_count, param_index);
   DCHECK_EQ(args_size_bytes, offset);
 
   // We are passing the raw arg_buffer here. To the GC and other parts, it looks
   // like a Smi (lowest bit not set). In the runtime function however, don't
   // call Smi::value on it, but just cast it to a byte pointer.
   Node* parameters[] = {
       jsgraph()->HeapConstant(instance),       // wasm instance
       jsgraph()->SmiConstant(function_index),  // function index
@@ skipping 881 matching lines @@
 
 Handle<Code> CompileWasmInterpreterEntry(Isolate* isolate, uint32_t func_index,
                                          wasm::FunctionSig* sig,
                                          Handle<WasmInstanceObject> instance) {
   //----------------------------------------------------------------------------
   // Create the Graph
   //----------------------------------------------------------------------------
   Zone zone(isolate->allocator(), ZONE_NAME);
   Graph graph(&zone);
   CommonOperatorBuilder common(&zone);
-  MachineOperatorBuilder machine(&zone);
+  MachineOperatorBuilder machine(
+      &zone, MachineType::PointerRepresentation(),
+      InstructionSelector::SupportedMachineOperatorFlags(),
+      InstructionSelector::AlignmentRequirements());
   JSGraph jsgraph(isolate, &graph, &common, nullptr, nullptr, &machine);
 
   Node* control = nullptr;
   Node* effect = nullptr;
 
   WasmGraphBuilder builder(nullptr, &zone, &jsgraph, sig);
   builder.set_control_ptr(&control);
   builder.set_effect_ptr(&effect);
   builder.BuildWasmInterpreterEntry(func_index, sig, instance);
 
@@ skipping 235 matching lines @@
                             function_->code_start_offset),
            compile_ms);
   }
 
   return code;
 }
 
 }  // namespace compiler
 }  // namespace internal
 }  // namespace v8