[wasm] fix TestInterruptLoop for Big Endian platform

test/cctest/wasm/test-run-wasm-module.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 <stdlib.h>
 #include <string.h>
 
 #include "src/snapshot/code-serializer.h"
 #include "src/version.h"
 #include "src/wasm/module-decoder.h"
@@ skipping 401 matching lines @@
 class InterruptThread : public v8::base::Thread {
  public:
   explicit InterruptThread(Isolate* isolate, int32_t* memory)
       : Thread(Options("TestInterruptLoop")),
         isolate_(isolate),
         memory_(memory) {}
 
   static void OnInterrupt(v8::Isolate* isolate, void* data) {
     int32_t* m = reinterpret_cast<int32_t*>(data);
     // Set the interrupt location to 0 to break the loop in {TestInterruptLoop}.
-    m[interrupt_location_] = interrupt_value_;
+    int32_t* ptr = &m[interrupt_location_];
+    WriteLittleEndianValue<int32_t>(ptr, interrupt_value_);
   }
 
   virtual void Run() {
     // Wait for the main thread to write the signal value.
-    while (memory_[0] != signal_value_) {
-    }
+    int32_t val = 0;
+    do {
+      val = memory_[0];
+      val = ReadLittleEndianValue<int32_t>(&val);
+    } while (val != signal_value_);
     isolate_->RequestInterrupt(&OnInterrupt, const_cast<int32_t*>(memory_));
   }
 
   Isolate* isolate_;
   volatile int32_t* memory_;
   static const int32_t interrupt_location_ = 10;
   static const int32_t interrupt_value_ = 154;
   static const int32_t signal_value_ = 1221;
 };
 
@@ skipping 43 matching lines @@
 
   MaybeHandle<JSArrayBuffer> maybe_memory =
       GetInstanceMemory(isolate, instance);
   Handle<JSArrayBuffer> memory = maybe_memory.ToHandleChecked();
   int32_t* memory_array = reinterpret_cast<int32_t*>(memory->backing_store());
 
   InterruptThread thread(isolate, memory_array);
   thread.Start();
   testing::RunWasmModuleForTesting(isolate, instance, 0, nullptr,
                                    ModuleOrigin::kWasmOrigin);
+  int32_t val = memory_array[InterruptThread::interrupt_location_];
   CHECK_EQ(InterruptThread::interrupt_value_,
-           memory_array[InterruptThread::interrupt_location_]);
+           ReadLittleEndianValue<int32_t>(&val));
 }
 
 TEST(Run_WasmModule_GrowMemoryInIf) {
   TestSignatures sigs;
   v8::internal::AccountingAllocator allocator;
   Zone zone(&allocator, ZONE_NAME);
   WasmModuleBuilder* builder = new (&zone) WasmModuleBuilder(&zone);
   WasmFunctionBuilder* f = builder->AddFunction(sigs.i_v());
   ExportAsMain(f);
   byte code[] = {WASM_IF_ELSE_I(WASM_I32V(0), WASM_GROW_MEMORY(WASM_I32V(1)),
@@ skipping 208 matching lines @@
 
 TEST(Run_WasmModule_Global_f32) {
   RunWasmModuleGlobalInitTest<float>(kAstF32, -983.9f);
   RunWasmModuleGlobalInitTest<float>(kAstF32, 1122.99f);
 }
 
 TEST(Run_WasmModule_Global_f64) {
   RunWasmModuleGlobalInitTest<double>(kAstF64, -833.9);
   RunWasmModuleGlobalInitTest<double>(kAstF64, 86374.25);
 }