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

src/wasm/wasm-debug.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/assembler-inl.h"
 #include "src/assert-scope.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/debug/debug.h"
 #include "src/factory.h"
 #include "src/frames-inl.h"
@@ skipping 115 matching lines @@
   }
 
   bool Execute(uint32_t func_index, uint8_t* arg_buffer) {
     DCHECK_GE(module()->functions.size(), func_index);
     FunctionSig* sig = module()->functions[func_index].sig;
     DCHECK_GE(kMaxInt, sig->parameter_count());
     int num_params = static_cast<int>(sig->parameter_count());
     ScopedVector<WasmVal> wasm_args(num_params);
     uint8_t* arg_buf_ptr = arg_buffer;
     for (int i = 0; i < num_params; ++i) {
-      int param_size = 1 << ElementSizeLog2Of(sig->GetParam(i));
+      uint32_t param_size = 1 << ElementSizeLog2Of(sig->GetParam(i));
 #define CASE_ARG_TYPE(type, ctype)                                  \
   case type:                                                        \
     DCHECK_EQ(param_size, sizeof(ctype));                           \
-    wasm_args[i] = WasmVal(*reinterpret_cast<ctype*>(arg_buf_ptr)); \
+    wasm_args[i] = WasmVal(ReadUnalignedValue<ctype>(arg_buf_ptr)); \
     break;
       switch (sig->GetParam(i)) {
         CASE_ARG_TYPE(kWasmI32, uint32_t)
         CASE_ARG_TYPE(kWasmI64, uint64_t)
         CASE_ARG_TYPE(kWasmF32, float)
         CASE_ARG_TYPE(kWasmF64, double)
 #undef CASE_ARG_TYPE
         default:
           UNREACHABLE();
       }
-      arg_buf_ptr += RoundUpToMultipleOfPowOf2(param_size, 8);
+      arg_buf_ptr += param_size;
     }
 
     WasmInterpreter::Thread* thread = interpreter_.GetThread(0);
     // We do not support reentering an already running interpreter at the moment
     // (like INTERPRETER -> JS -> WASM -> INTERPRETER).
     DCHECK(thread->state() == WasmInterpreter::STOPPED ||
            thread->state() == WasmInterpreter::FINISHED ||
            thread->state() == WasmInterpreter::TRAPPED);
     thread->Reset();
     thread->InitFrame(&module()->functions[func_index], wasm_args.start());
@@ skipping 28 matching lines @@
 
     // Copy back the return value
     DCHECK_GE(kV8MaxWasmFunctionReturns, sig->return_count());
     // TODO(wasm): Handle multi-value returns.
     DCHECK_EQ(1, kV8MaxWasmFunctionReturns);
     if (sig->return_count()) {
       WasmVal ret_val = thread->GetReturnValue(0);
 #define CASE_RET_TYPE(type, ctype)                                       \
   case type:                                                             \
     DCHECK_EQ(1 << ElementSizeLog2Of(sig->GetReturn(0)), sizeof(ctype)); \
-    *reinterpret_cast<ctype*>(arg_buffer) = ret_val.to<ctype>();         \
+    WriteUnalignedValue<ctype>(arg_buffer, ret_val.to<ctype>());         \
     break;
       switch (sig->GetReturn(0)) {
         CASE_RET_TYPE(kWasmI32, uint32_t)
         CASE_RET_TYPE(kWasmI64, uint64_t)
         CASE_RET_TYPE(kWasmF32, float)
         CASE_RET_TYPE(kWasmF64, double)
 #undef CASE_RET_TYPE
         default:
           UNREACHABLE();
       }
@@ skipping 283 matching lines @@
 
 std::unique_ptr<wasm::InterpretedFrame> WasmDebugInfo::GetInterpretedFrame(
     Address frame_pointer, int idx) {
   return GetInterpreterHandle(this)->GetInterpretedFrame(frame_pointer, idx);
 }
 
 uint64_t WasmDebugInfo::NumInterpretedCalls() {
   auto handle = GetInterpreterHandleOrNull(this);
   return handle ? handle->NumInterpretedCalls() : 0;
 }