[wasm] Fix CFI failures due to Wasm threads.

test/cctest/wasm/test-run-wasm-interpreter.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 <stdint.h>
 #include <stdlib.h>
 #include <string.h>
 
 #include "src/wasm/wasm-macro-gen.h"
 
@@ skipping 158 matching lines @@
   SmartArrayPointer<int> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprGetLocal, kExprGetLocal,
            kExprI32Add);
 
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
                         MachineType::Uint32());
 
   r.Build(code, code + arraysize(code));
 
   WasmInterpreter* interpreter = r.interpreter();
-  WasmInterpreter::Thread& thread = interpreter->GetThread(0);
+  WasmInterpreter::Thread* thread = interpreter->GetThread(0);
   for (int i = 0; i < kNumBreakpoints; i++) {
     interpreter->SetBreakpoint(r.function(), kLocalsDeclSize + offsets[i],
                                true);
   }
 
   FOR_UINT32_INPUTS(a) {
     for (uint32_t b = 11; b < 3000000000u; b += 1000000000u) {
-      thread.Reset();
+      thread->Reset();
       WasmVal args[] = {WasmVal(*a), WasmVal(b)};
-      thread.PushFrame(r.function(), args);
+      thread->PushFrame(r.function(), args);
 
       for (int i = 0; i < kNumBreakpoints; i++) {
-        thread.Run();  // run to next breakpoint
+        thread->Run();  // run to next breakpoint
         // Check the thread stopped at the right pc.
-        CHECK_EQ(WasmInterpreter::PAUSED, thread.state());
-        CHECK_EQ(kLocalsDeclSize + offsets[i], thread.GetBreakpointPc());
+        CHECK_EQ(WasmInterpreter::PAUSED, thread->state());
+        CHECK_EQ(kLocalsDeclSize + offsets[i], thread->GetBreakpointPc());
       }
 
-      thread.Run();  // run to completion
+      thread->Run();  // run to completion
 
       // Check the thread finished with the right value.
-      CHECK_EQ(WasmInterpreter::FINISHED, thread.state());
+      CHECK_EQ(WasmInterpreter::FINISHED, thread->state());
       uint32_t expected = (*a) + (b);
-      CHECK_EQ(expected, thread.GetReturnValue().to<uint32_t>());
+      CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
     }
   }
 }
 
 TEST(Step_I32Mul) {
   static const int kTraceLength = 4;
   byte code[] = {WASM_I32_MUL(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
 
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
                         MachineType::Uint32());
 
   r.Build(code, code + arraysize(code));
 
   WasmInterpreter* interpreter = r.interpreter();
-  WasmInterpreter::Thread& thread = interpreter->GetThread(0);
+  WasmInterpreter::Thread* thread = interpreter->GetThread(0);
 
   FOR_UINT32_INPUTS(a) {
     for (uint32_t b = 33; b < 3000000000u; b += 1000000000u) {
-      thread.Reset();
+      thread->Reset();
       WasmVal args[] = {WasmVal(*a), WasmVal(b)};
-      thread.PushFrame(r.function(), args);
+      thread->PushFrame(r.function(), args);
 
       // Run instructions one by one.
       for (int i = 0; i < kTraceLength - 1; i++) {
-        thread.Step();
+        thread->Step();
         // Check the thread stopped.
-        CHECK_EQ(WasmInterpreter::PAUSED, thread.state());
+        CHECK_EQ(WasmInterpreter::PAUSED, thread->state());
       }
 
       // Run last instruction.
-      thread.Step();
+      thread->Step();
 
       // Check the thread finished with the right value.
-      CHECK_EQ(WasmInterpreter::FINISHED, thread.state());
+      CHECK_EQ(WasmInterpreter::FINISHED, thread->state());
       uint32_t expected = (*a) * (b);
-      CHECK_EQ(expected, thread.GetReturnValue().to<uint32_t>());
+      CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
     }
   }
 }
 
 TEST(Breakpoint_I32And_disable) {
   static const int kLocalsDeclSize = 1;
   static const int kNumBreakpoints = 1;
   byte code[] = {WASM_I32_AND(WASM_GET_LOCAL(0), WASM_GET_LOCAL(1))};
   SmartArrayPointer<int> offsets =
       Find(code, sizeof(code), kNumBreakpoints, kExprI32And);
 
   WasmRunner<int32_t> r(kExecuteInterpreted, MachineType::Uint32(),
                         MachineType::Uint32());
 
   r.Build(code, code + arraysize(code));
 
   WasmInterpreter* interpreter = r.interpreter();
-  WasmInterpreter::Thread& thread = interpreter->GetThread(0);
+  WasmInterpreter::Thread* thread = interpreter->GetThread(0);
 
   FOR_UINT32_INPUTS(a) {
     for (uint32_t b = 11; b < 3000000000u; b += 1000000000u) {
       // Run with and without breakpoints.
       for (int do_break = 0; do_break < 2; do_break++) {
         interpreter->SetBreakpoint(r.function(), kLocalsDeclSize + offsets[0],
                                    do_break);
-        thread.Reset();
+        thread->Reset();
         WasmVal args[] = {WasmVal(*a), WasmVal(b)};
-        thread.PushFrame(r.function(), args);
+        thread->PushFrame(r.function(), args);
 
         if (do_break) {
-          thread.Run();  // run to next breakpoint
+          thread->Run();  // run to next breakpoint
           // Check the thread stopped at the right pc.
-          CHECK_EQ(WasmInterpreter::PAUSED, thread.state());
-          CHECK_EQ(kLocalsDeclSize + offsets[0], thread.GetBreakpointPc());
+          CHECK_EQ(WasmInterpreter::PAUSED, thread->state());
+          CHECK_EQ(kLocalsDeclSize + offsets[0], thread->GetBreakpointPc());
         }
 
-        thread.Run();  // run to completion
+        thread->Run();  // run to completion
 
         // Check the thread finished with the right value.
-        CHECK_EQ(WasmInterpreter::FINISHED, thread.state());
+        CHECK_EQ(WasmInterpreter::FINISHED, thread->state());
         uint32_t expected = (*a) & (b);
-        CHECK_EQ(expected, thread.GetReturnValue().to<uint32_t>());
+        CHECK_EQ(expected, thread->GetReturnValue().to<uint32_t>());
       }
     }
   }
 }
 
 }  // namespace wasm
 }  // namespace internal
 }  // namespace v8