[arm64][Liftoff] Start Liftoff implementation.

First version which can compile a very basic code.

Change-Id: I3b98412a5ca39a28f8fe5b60516b82c6981dd187
Reviewed-on: https://chromium-review.googlesource.com/993232
Commit-Queue: Vincent Belliard <vincent.belliard@arm.com>
Reviewed-by: Clemens Hammacher <clemensh@chromium.org>
Cr-Commit-Position: refs/heads/master@{#52622}

src/arm64/assembler-arm64.cc

@@ -5007,6 +5007,15 @@ void PatchingAssembler::PatchAdrFar(int64_t target_offset) {
   add(rd, rd, scratch);
 }
 
+void PatchingAssembler::PatchSubSp(uint32_t immediate) {
+  // The code at the current instruction should be:
+  //   sub sp, sp, #0
+
+  // Verify the expected code.
+  Instruction* expected_adr = InstructionAt(0);
+  CHECK(expected_adr->IsAddSubImmediate());
+  sub(sp, sp, immediate);
+}
 
 }  // namespace internal
 }  // namespace v8

src/arm64/assembler-arm64.h

@@ -3666,6 +3666,7 @@ class PatchingAssembler : public Assembler {
   static constexpr int kAdrFarPatchableNNops = 2;
   static constexpr int kAdrFarPatchableNInstrs = kAdrFarPatchableNNops + 2;
   void PatchAdrFar(int64_t target_offset);
+  void PatchSubSp(uint32_t immediate);
 };
 
 

src/compiler/int64-lowering.cc

@@ -13,6 +13,7 @@
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node.h"
 #include "src/compiler/wasm-compiler.h"
+#include "src/macro-assembler-inl.h"
 #include "src/zone/zone.h"
 
 namespace v8 {

src/compiler/simd-scalar-lowering.cc

@@ -10,6 +10,7 @@
 #include "src/compiler/node-properties.h"
 #include "src/compiler/node.h"
 #include "src/compiler/wasm-compiler.h"
+#include "src/macro-assembler-inl.h"
 
 namespace v8 {
 namespace internal {

src/compiler/wasm-compiler.cc

@@ -33,6 +33,7 @@
 #include "src/heap/factory.h"
 #include "src/isolate-inl.h"
 #include "src/log-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "src/trap-handler/trap-handler.h"
 #include "src/wasm/function-body-decoder.h"
 #include "src/wasm/memory-tracing.h"

src/compiler/wasm-linkage.cc

@@ -4,6 +4,7 @@
 
 #include "src/assembler-inl.h"
 #include "src/base/lazy-instance.h"
+#include "src/macro-assembler-inl.h"
 #include "src/macro-assembler.h"
 #include "src/register-configuration.h"
 

src/runtime/runtime-wasm.cc

@@ -11,6 +11,7 @@
 #include "src/debug/debug.h"
 #include "src/frame-constants.h"
 #include "src/heap/factory.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/objects/frame-array-inl.h"
 #include "src/trap-handler/trap-handler.h"

src/wasm/baseline/arm/liftoff-assembler-arm.h

@@ -23,6 +23,8 @@ void LiftoffAssembler::PatchPrepareStackFrame(uint32_t offset,
   BAILOUT("PatchPrepareStackFrame");
 }
 
+void LiftoffAssembler::FinishCode() { CheckConstPool(true, false); }
+
 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
                                     RelocInfo::Mode rmode) {
   BAILOUT("LoadConstant");

src/wasm/baseline/arm64/liftoff-assembler-arm64.h

@@ -13,16 +13,116 @@ namespace v8 {
 namespace internal {
 namespace wasm {
 
+namespace liftoff {
+
+// Liftoff Frames.
+//
+//  slot      Frame
+//       +--------------------+---------------------------
+//  n+4  | optional padding slot to keep the stack 16 byte aligned.
+//  n+3  |   parameter n      |
+//  ...  |       ...          |
+//   4   |   parameter 1      | or parameter 2
+//   3   |   parameter 0      | or parameter 1
+//   2   |  (result address)  | or parameter 0
+//  -----+--------------------+---------------------------
+//   1   | return addr (lr)   |
+//   0   | previous frame (fp)|
+//  -----+--------------------+  <-- frame ptr (fp)
+//  -1   | 0xa: WASM_COMPILED |
+//  -2   |     instance       |
+//  -----+--------------------+---------------------------
+//  -3   |     slot 0         |   ^
+//  -4   |     slot 1         |   |
+//       |                    | Frame slots
+//       |                    |   |
+//       |                    |   v
+//       | optional padding slot to keep the stack 16 byte aligned.
+//  -----+--------------------+  <-- stack ptr (sp)
+//
+
+constexpr int32_t kInstanceOffset = 2 * kPointerSize;
+constexpr int32_t kFirstStackSlotOffset = kInstanceOffset + kPointerSize;
+constexpr int32_t kConstantStackSpace = 0;
+
+inline MemOperand GetStackSlot(uint32_t index) {
+  int32_t offset =
+      kFirstStackSlotOffset + index * LiftoffAssembler::kStackSlotSize;
+  return MemOperand(fp, -offset);
+}
+
+inline MemOperand GetInstanceOperand() {
+  return MemOperand(fp, -kInstanceOffset);
+}
+
+inline CPURegister GetRegFromType(const LiftoffRegister& reg, ValueType type) {
+  switch (type) {
+    case kWasmI32:
+      return reg.gp().W();
+    case kWasmI64:
+      return reg.gp().X();
+    case kWasmF32:
+      return reg.fp().S();
+    case kWasmF64:
+      return reg.fp().D();
+    default:
+      UNREACHABLE();
+  }
+}
+
+inline CPURegList PadRegList(RegList list) {
+  if ((base::bits::CountPopulation(list) & 1) != 0) list |= padreg.bit();
+  return CPURegList(CPURegister::kRegister, kXRegSizeInBits, list);
+}
+
+inline CPURegList PadVRegList(RegList list) {
+  if ((base::bits::CountPopulation(list) & 1) != 0) list |= fp_scratch.bit();
+  return CPURegList(CPURegister::kVRegister, kDRegSizeInBits, list);
+}
+
+}  // namespace liftoff
+
 uint32_t LiftoffAssembler::PrepareStackFrame() {
-  BAILOUT("PrepareStackFrame");
-  return 0;
+  uint32_t offset = static_cast<uint32_t>(pc_offset());
+  InstructionAccurateScope scope(this, 1);
+  sub(sp, sp, 0);
+  return offset;
 }
 
 void LiftoffAssembler::PatchPrepareStackFrame(uint32_t offset,
                                               uint32_t stack_slots) {
-  BAILOUT("PatchPrepareStackFrame");
+  static_assert(kStackSlotSize == kXRegSize,
+                "kStackSlotSize must equal kXRegSize");
+  uint32_t bytes = liftoff::kConstantStackSpace + kStackSlotSize * stack_slots;
+  // The stack pointer is required to be quadword aligned.
+  // Misalignment will cause a stack alignment fault.
+  bytes = RoundUp(bytes, kQuadWordSizeInBytes);
+  if (!IsImmAddSub(bytes)) {
+    // Round the stack to a page to try to fit a add/sub immediate.
+    bytes = RoundUp(bytes, 0x1000);
+    if (!IsImmAddSub(bytes)) {
+      // Stack greater than 4M! Because this is a quite improbable case, we
+      // just fallback to Turbofan.
+      BAILOUT("Stack too big");
+      return;
+    }
+  }
+#ifdef USE_SIMULATOR
+  // When using the simulator, deal with Liftoff which allocates the stack
+  // before checking it.
+  // TODO(arm): Remove this when the stack check mechanism will be updated.
+  if (bytes > KB / 2) {
+    BAILOUT("Stack limited to 512 bytes to avoid a bug in StackCheck");
+    return;
+  }
+#endif
+  PatchingAssembler patching_assembler(IsolateData(isolate()), buffer_ + offset,
+                                       1);
+  patching_assembler.PatchSubSp(bytes);
 }
 
+void LiftoffAssembler::FinishCode() { CheckConstPool(true, false); }
+
 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
                                     RelocInfo::Mode rmode) {
   BAILOUT("LoadConstant");
@@ -34,7 +134,7 @@ void LiftoffAssembler::LoadFromInstance(Register dst, uint32_t offset,
 }
 
 void LiftoffAssembler::SpillInstance(Register instance) {
-  BAILOUT("SpillInstance");
+  Str(instance, liftoff::GetInstanceOperand());
 }
 
 void LiftoffAssembler::FillInstanceInto(Register dst) {
@@ -79,21 +179,37 @@ void LiftoffAssembler::MoveStackValue(uint32_t dst_index, uint32_t src_index,
 
 void LiftoffAssembler::MoveToReturnRegister(LiftoffRegister reg,
                                             ValueType type) {
-  BAILOUT("MoveToReturnRegister");
+  if (reg.is_gp()) {
+    Move(x0, reg.gp(), type);
+  } else {
+    Move(d0, reg.fp(), type);
+  }
 }
 
 void LiftoffAssembler::Move(Register dst, Register src, ValueType type) {
-  BAILOUT("Move Register");
+  if (type == kWasmI32) {
+    Mov(dst.W(), src.W());
+  } else {
+    DCHECK_EQ(kWasmI64, type);
+    Mov(dst.X(), src.X());
+  }
 }
 
 void LiftoffAssembler::Move(DoubleRegister dst, DoubleRegister src,
                             ValueType type) {
-  BAILOUT("Move DoubleRegister");
+  if (type == kWasmF32) {
+    Fmov(dst.S(), src.S());
+  } else {
+    DCHECK_EQ(kWasmF64, type);
+    Fmov(dst.D(), src.D());
+  }
 }
 
 void LiftoffAssembler::Spill(uint32_t index, LiftoffRegister reg,
                              ValueType type) {
-  BAILOUT("Spill register");
+  RecordUsedSpillSlot(index);
+  MemOperand dst = liftoff::GetStackSlot(index);
+  Str(liftoff::GetRegFromType(reg, type), dst);
 }
 
 void LiftoffAssembler::Spill(uint32_t index, WasmValue value) {
@@ -203,7 +319,7 @@ bool LiftoffAssembler::emit_type_conversion(WasmOpcode opcode,
   return true;
 }
 
-void LiftoffAssembler::emit_jump(Label* label) { BAILOUT("emit_jump"); }
+void LiftoffAssembler::emit_jump(Label* label) { B(label); }
 
 void LiftoffAssembler::emit_jump(Register target) { BAILOUT("emit_jump"); }
 
@@ -214,12 +330,14 @@ void LiftoffAssembler::emit_cond_jump(Condition cond, Label* label,
 }
 
 void LiftoffAssembler::emit_i32_eqz(Register dst, Register src) {
-  BAILOUT("emit_i32_eqz");
+  Cmp(src.W(), wzr);
+  Cset(dst.W(), eq);
 }
 
 void LiftoffAssembler::emit_i32_set_cond(Condition cond, Register dst,
                                          Register lhs, Register rhs) {
-  BAILOUT("emit_i32_set_cond");
+  Cmp(lhs.W(), rhs.W());
+  Cset(dst.W(), cond);
 }
 
 void LiftoffAssembler::emit_i64_eqz(Register dst, LiftoffRegister src) {
@@ -244,7 +362,16 @@ void LiftoffAssembler::emit_f64_set_cond(Condition cond, Register dst,
   BAILOUT("emit_f64_set_cond");
 }
 
-void LiftoffAssembler::StackCheck(Label* ool_code) { BAILOUT("StackCheck"); }
+void LiftoffAssembler::StackCheck(Label* ool_code) {
+  ExternalReference stack_limit =
+      ExternalReference::address_of_stack_limit(isolate());
+  UseScratchRegisterScope temps(this);
+  Register scratch = temps.AcquireX();
+  Mov(scratch, Operand(stack_limit));
+  Ldr(scratch, MemOperand(scratch));
+  Cmp(sp, scratch);
+  B(ool_code, ls);
+}
 
 void LiftoffAssembler::CallTrapCallbackForTesting() {
   BAILOUT("CallTrapCallbackForTesting");
@@ -266,15 +393,18 @@ void LiftoffAssembler::PushCallerFrameSlot(LiftoffRegister reg,
 }
 
 void LiftoffAssembler::PushRegisters(LiftoffRegList regs) {
-  BAILOUT("PushRegisters");
+  PushCPURegList(liftoff::PadRegList(regs.GetGpList()));
+  PushCPURegList(liftoff::PadVRegList(regs.GetFpList()));
 }
 
 void LiftoffAssembler::PopRegisters(LiftoffRegList regs) {
-  BAILOUT("PopRegisters");
+  PopCPURegList(liftoff::PadVRegList(regs.GetFpList()));
+  PopCPURegList(liftoff::PadRegList(regs.GetGpList()));
 }
 
 void LiftoffAssembler::DropStackSlotsAndRet(uint32_t num_stack_slots) {
-  BAILOUT("DropStackSlotsAndRet");
+  DropSlots(num_stack_slots);
+  Ret();
 }
 
 void LiftoffAssembler::PrepareCCall(wasm::FunctionSig* sig,

src/wasm/baseline/ia32/liftoff-assembler-ia32.h

@@ -110,6 +110,8 @@ void LiftoffAssembler::PatchPrepareStackFrame(uint32_t offset,
   patching_assembler.sub_sp_32(bytes);
 }
 
+void LiftoffAssembler::FinishCode() {}
+
 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
                                     RelocInfo::Mode rmode) {
   switch (value.type()) {

src/wasm/baseline/liftoff-assembler-defs.h

@@ -64,6 +64,22 @@ constexpr RegList kLiftoffAssemblerFpCacheRegs =
 
 constexpr Register kNoParamRegister = t0;
 
+#elif V8_TARGET_ARCH_ARM64
+
+// x16: ip0, x17: ip1, x26: root, x29: fp, x30: lr, x31: xzr.
+constexpr RegList kLiftoffAssemblerGpCacheRegs =
+    CPURegister::ListOf<x0, x1, x2, x3, x4, x5, x6, x7, x8, x9, x10, x11, x12,
+                        x13, x14, x15, x18, x19, x20, x21, x22, x23, x24, x25,
+                        x27, x28>();
+
+// d15: fp_zero, d30-d31: macro-assembler scratch V Registers.
+constexpr RegList kLiftoffAssemblerFpCacheRegs =
+    CPURegister::ListOf<d0, d1, d2, d3, d4, d5, d6, d7, d8, d9, d10, d11, d12,
+                        d13, d14, d16, d17, d18, d19, d20, d21, d22, d23, d24,
+                        d25, d26, d27, d28, d29>();
+
+constexpr Register kNoParamRegister = x28;
+
 #else
 
 constexpr RegList kLiftoffAssemblerGpCacheRegs = 0xff;
@@ -102,6 +118,19 @@ constexpr Condition kUnsignedLessEqual = ule;
 constexpr Condition kUnsignedGreaterThan = ugt;
 constexpr Condition kUnsignedGreaterEqual = uge;
 
+#elif V8_TARGET_ARCH_ARM || V8_TARGET_ARCH_ARM64
+
+constexpr Condition kEqual = eq;
+constexpr Condition kUnequal = ne;
+constexpr Condition kSignedLessThan = lt;
+constexpr Condition kSignedLessEqual = le;
+constexpr Condition kSignedGreaterThan = gt;
+constexpr Condition kSignedGreaterEqual = ge;
+constexpr Condition kUnsignedLessThan = lo;
+constexpr Condition kUnsignedLessEqual = ls;
+constexpr Condition kUnsignedGreaterThan = hi;
+constexpr Condition kUnsignedGreaterEqual = hs;
+
 #else
 
 // On unimplemented platforms, just make this compile.

src/wasm/baseline/liftoff-assembler.h

@@ -349,6 +349,7 @@ class LiftoffAssembler : public TurboAssembler {
   // the frame is known.
   inline uint32_t PrepareStackFrame();
   inline void PatchPrepareStackFrame(uint32_t offset, uint32_t stack_slots);
+  inline void FinishCode();
 
   inline void LoadConstant(LiftoffRegister, WasmValue,
                            RelocInfo::Mode rmode = RelocInfo::NONE);

src/wasm/baseline/liftoff-compiler.cc

@@ -51,15 +51,10 @@ constexpr LoadType::LoadTypeValue kPointerLoadType =
 class MovableLabel {
  public:
   Label* get() { return label_.get(); }
-  MovableLabel() : MovableLabel(new Label()) {}
-
-  operator bool() const { return label_ != nullptr; }
-
-  static MovableLabel None() { return MovableLabel(nullptr); }
+  MovableLabel() : label_(new Label()) {}
 
  private:
   std::unique_ptr<Label> label_;
-  explicit MovableLabel(Label* label) : label_(label) {}
 };
 #else
 // On all other platforms, just store the Label directly.
@@ -67,10 +62,6 @@ class MovableLabel {
  public:
   Label* get() { return &label_; }
 
-  operator bool() const { return true; }
-
-  static MovableLabel None() { return MovableLabel(); }
-
  private:
   Label label_;
 };
@@ -125,8 +116,7 @@ class LiftoffCompiler {
     }
     static OutOfLineCode StackCheck(wasm::WasmCodePosition pos,
                                     LiftoffRegList regs) {
-      return {{}, MovableLabel::None(), Builtins::kWasmStackGuard, pos, regs,
-              0};
+      return {{}, {}, Builtins::kWasmStackGuard, pos, regs, 0};
     }
   };
 
@@ -297,7 +287,7 @@ class LiftoffCompiler {
         OutOfLineCode::StackCheck(position, __ cache_state()->used_registers));
     OutOfLineCode& ool = out_of_line_code_.back();
     __ StackCheck(ool.label.get());
-    if (ool.continuation) __ bind(ool.continuation.get());
+    __ bind(ool.continuation.get());
   }
 
   // Inserts a check whether the optimized version of this code already exists.
@@ -488,9 +478,12 @@ class LiftoffCompiler {
     for (OutOfLineCode& ool : out_of_line_code_) {
       GenerateOutOfLineCode(ool);
     }
+    __ FinishCode();
     safepoint_table_builder_.Emit(asm_, __ GetTotalFrameSlotCount());
     __ PatchPrepareStackFrame(pc_offset_stack_frame_construction_,
                               __ GetTotalFrameSlotCount());
+    // The previous calls may have also generated a bailout.
+    DidAssemblerBailout(decoder);
   }
 
   void OnFirstError(Decoder* decoder) {

src/wasm/baseline/liftoff-register.h

@@ -296,6 +296,9 @@ class LiftoffRegList {
     return list;
   }
 
+  RegList GetGpList() { return regs_ & kGpMask; }
+  RegList GetFpList() { return (regs_ & kFpMask) >> kAfterMaxLiftoffGpRegCode; }
+
  private:
   storage_t regs_ = 0;
 

src/wasm/baseline/mips/liftoff-assembler-mips.h

@@ -104,6 +104,8 @@ void LiftoffAssembler::PatchPrepareStackFrame(uint32_t offset,
   patching_assembler.Addu(sp, sp, Operand(-bytes));
 }
 
+void LiftoffAssembler::FinishCode() {}
+
 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
                                     RelocInfo::Mode rmode) {
   switch (value.type()) {

src/wasm/baseline/mips64/liftoff-assembler-mips64.h

@@ -100,6 +100,8 @@ void LiftoffAssembler::PatchPrepareStackFrame(uint32_t offset,
   patching_assembler.Daddu(sp, sp, Operand(-bytes));
 }
 
+void LiftoffAssembler::FinishCode() {}
+
 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
                                     RelocInfo::Mode rmode) {
   switch (value.type()) {

src/wasm/baseline/ppc/liftoff-assembler-ppc.h

@@ -23,6 +23,8 @@ void LiftoffAssembler::PatchPrepareStackFrame(uint32_t offset,
   BAILOUT("PatchPrepareStackFrame");
 }
 
+void LiftoffAssembler::FinishCode() { EmitConstantPool(); }
+
 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
                                     RelocInfo::Mode rmode) {
   BAILOUT("LoadConstant");

src/wasm/baseline/s390/liftoff-assembler-s390.h

@@ -23,6 +23,8 @@ void LiftoffAssembler::PatchPrepareStackFrame(uint32_t offset,
   BAILOUT("PatchPrepareStackFrame");
 }
 
+void LiftoffAssembler::FinishCode() {}
+
 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
                                     RelocInfo::Mode rmode) {
   BAILOUT("LoadConstant");

src/wasm/baseline/x64/liftoff-assembler-x64.h

@@ -107,6 +107,8 @@ void LiftoffAssembler::PatchPrepareStackFrame(uint32_t offset,
   patching_assembler.sub_sp_32(bytes);
 }
 
+void LiftoffAssembler::FinishCode() {}
+
 void LiftoffAssembler::LoadConstant(LiftoffRegister reg, WasmValue value,
                                     RelocInfo::Mode rmode) {
   switch (value.type()) {

src/wasm/function-body-decoder.cc

@@ -7,6 +7,7 @@
 #include "src/base/platform/elapsed-timer.h"
 #include "src/flags.h"
 #include "src/handles.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/zone/zone-containers.h"
 

src/wasm/module-compiler.cc

@@ -14,6 +14,7 @@
 #include "src/compiler/wasm-compiler.h"
 #include "src/counters.h"
 #include "src/identity-map.h"
+#include "src/macro-assembler-inl.h"
 #include "src/property-descriptor.h"
 #include "src/trap-handler/trap-handler.h"
 #include "src/wasm/compilation-manager.h"

src/wasm/wasm-debug.cc

@@ -14,6 +14,7 @@
 #include "src/heap/factory.h"
 #include "src/identity-map.h"
 #include "src/isolate.h"
+#include "src/macro-assembler-inl.h"
 #include "src/wasm/module-decoder.h"
 #include "src/wasm/wasm-code-manager.h"
 #include "src/wasm/wasm-interpreter.h"

src/wasm/wasm-interpreter.cc

@@ -12,6 +12,7 @@
 #include "src/compiler/wasm-compiler.h"
 #include "src/conversions.h"
 #include "src/identity-map.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/trap-handler/trap-handler.h"
 #include "src/utils.h"

src/wasm/wasm-module.cc

@@ -11,6 +11,7 @@
 #include "src/compiler/wasm-compiler.h"
 #include "src/debug/interface-types.h"
 #include "src/frames-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects.h"
 #include "src/property-descriptor.h"
 #include "src/simulator.h"

src/wasm/wasm-objects.cc

@@ -9,6 +9,7 @@
 #include "src/base/iterator.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/debug/debug-interface.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/objects/debug-objects-inl.h"
 #include "src/trap-handler/trap-handler.h"

test/cctest/compiler/test-multiple-return.cc

@@ -14,6 +14,7 @@
 #include "src/compiler/linkage.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/machine-type.h"
+#include "src/macro-assembler-inl.h"
 #include "src/macro-assembler.h"
 #include "src/objects-inl.h"
 #include "src/wasm/wasm-engine.h"

test/cctest/wasm/test-c-wasm-entry.cc

@@ -5,6 +5,7 @@
 #include <cstdint>
 
 #include "src/assembler-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/wasm/wasm-objects.h"
 #include "test/cctest/cctest.h"

test/cctest/wasm/test-run-wasm-64.cc

@@ -8,6 +8,7 @@
 
 #include "src/assembler-inl.h"
 #include "src/base/bits.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 
 #include "test/cctest/cctest.h"

test/cctest/wasm/test-run-wasm-asmjs.cc

@@ -8,6 +8,7 @@
 
 #include "src/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
+#include "src/macro-assembler-inl.h"
 
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"

test/cctest/wasm/test-run-wasm-atomics.cc

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/macro-assembler-inl.h"
 #include "test/cctest/wasm/wasm-atomics-utils.h"
 #include "test/common/wasm/wasm-macro-gen.h"
 

test/cctest/wasm/test-run-wasm-atomics64.cc

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/macro-assembler-inl.h"
 #include "test/cctest/wasm/wasm-atomics-utils.h"
 #include "test/common/wasm/wasm-macro-gen.h"
 

test/cctest/wasm/test-run-wasm-interpreter.cc

@@ -9,6 +9,7 @@
 #include <memory>
 
 #include "src/assembler-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "src/wasm/wasm-interpreter.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"

test/cctest/wasm/test-run-wasm-js.cc

@@ -9,6 +9,7 @@
 
 #include "src/api.h"
 #include "src/assembler-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/wasm-run-utils.h"

test/cctest/wasm/test-run-wasm-sign-extension.cc

@@ -2,6 +2,7 @@
 // Use of this source code is governed by a BSD-style license that can be
 // found in the LICENSE file.
 
+#include "src/macro-assembler-inl.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/wasm/wasm-run-utils.h"
 #include "test/common/wasm/wasm-macro-gen.h"

test/cctest/wasm/test-run-wasm-simd.cc

@@ -3,6 +3,7 @@
 // found in the LICENSE file.
 
 #include "src/assembler-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/wasm-run-utils.h"

test/cctest/wasm/test-run-wasm.cc

@@ -8,6 +8,7 @@
 
 #include "src/assembler-inl.h"
 #include "src/base/platform/elapsed-timer.h"
+#include "src/macro-assembler-inl.h"
 #include "src/utils.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"

test/cctest/wasm/test-wasm-breakpoints.cc

@@ -5,6 +5,7 @@
 #include "src/assembler-inl.h"
 #include "src/debug/debug-interface.h"
 #include "src/frames-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "src/property-descriptor.h"
 #include "src/utils.h"
 #include "src/wasm/wasm-objects-inl.h"

test/cctest/wasm/test-wasm-interpreter-entry.cc

@@ -5,6 +5,7 @@
 #include <cstdint>
 
 #include "src/assembler-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/wasm/wasm-objects.h"
 #include "test/cctest/cctest.h"

test/cctest/wasm/test-wasm-stack.cc

@@ -4,6 +4,7 @@
 
 #include "src/api.h"
 #include "src/assembler-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"
 #include "test/cctest/wasm/wasm-run-utils.h"

test/cctest/wasm/test-wasm-trap-position.cc

@@ -4,6 +4,7 @@
 
 #include "src/api.h"
 #include "src/assembler-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "src/trap-handler/trap-handler.h"
 #include "test/cctest/cctest.h"
 #include "test/cctest/compiler/value-helper.h"

test/cctest/wasm/wasm-run-utils.cc

@@ -5,6 +5,7 @@
 #include "test/cctest/wasm/wasm-run-utils.h"
 
 #include "src/assembler-inl.h"
+#include "src/macro-assembler-inl.h"
 #include "src/wasm/wasm-memory.h"
 #include "src/wasm/wasm-objects-inl.h"
 

test/fuzzer/multi-return.cc

@@ -14,6 +14,7 @@
 #include "src/compiler/raw-machine-assembler.h"
 #include "src/compiler/wasm-compiler.h"
 #include "src/machine-type.h"
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/objects.h"
 #include "src/optimized-compilation-info.h"

test/unittests/compiler/int64-lowering-unittest.cc

@@ -11,6 +11,7 @@
 
 #include "src/compiler/node-properties.h"
 
+#include "src/macro-assembler-inl.h"
 #include "src/objects-inl.h"
 #include "src/signature.h"