// Note: This test requires compiler support for DWARF entry values.

int dummy;
volatile int global = 0;

template <typename... T> __attribute__((optnone)) void use(T...) {}

struct S1 {
  int field1 = 123;
  int *field2 = &field1;
};

__attribute__((noinline)) void func1(int &sink) {
  // First use works around a compiler "bug" where an unused variable gets
  // no location descriptions. The second use overwrites the function arguments
  // with other values.
  use<int &>(sink);
  use<int &>(dummy);

  ++global;
  //% prefix = "FUNC1-GNU" if "GNU" in self.name else "FUNC1-V5"
  //% self.filecheck("image lookup -v -a $pc", "main.cpp", "-check-prefix="+prefix)
  // FUNC1-GNU: name = "sink", type = "int &", valid ranges = {{.*}}, location = {{.*}} DW_OP_GNU_entry_value
  // FUNC1-V5: name = "sink", type = "int &", valid ranges = {{.*}}, location = {{.*}} DW_OP_entry_value
}

__attribute__((noinline)) void func2(int &sink, int x) {
  use<int &, int>(sink, x);
  use<int &, int>(dummy, 0);

  ++global;
  //% self.filecheck("expr x", "main.cpp", "-check-prefix=FUNC2-EXPR1")
  //% self.filecheck("expr sink", "main.cpp", "-check-prefix=FUNC2-EXPR2")
  // FUNC2-EXPR1: ${{.*}} = 123
  // FUNC2-EXPR2: ${{.*}} = 2
}

__attribute__((noinline)) void func3(int &sink, int *p) {
  use<int &, int *>(sink, p);
  use<int &, int *>(dummy, nullptr);

  //% self.filecheck("expr *p", "main.cpp", "-check-prefix=FUNC3-EXPR")
  // FUNC3-EXPR: (int) ${{.*}} = 123
}

__attribute__((noinline)) void func4_amb(int &sink, int x) {
  use<int &, int>(sink, x);
  use<int &, int>(dummy, 0);

  ++global;
  //% self.filecheck("expr x", "main.cpp", "-check-prefix=FUNC4-EXPR-FAIL",
  //%     expect_cmd_failure=True)
  //% self.filecheck("expr sink", "main.cpp","-check-prefix=FUNC4-EXPR",
  //%     expect_cmd_failure=True)
  // clang-format off
  // FUNC4-EXPR-FAIL: couldn't get the value of variable x: could not evaluate DW_OP_entry_value: no matching call site param found
  // FUNC4-EXPR: couldn't get the value of variable sink: could not evaluate DW_OP_entry_value: no matching call site param found
  // clang-format on
}

__attribute__((noinline)) void func5_amb() {}

__attribute__((noinline)) void func6(int &sink, int x) {
  if (sink > 0)
    func4_amb(sink, x); /* tail (taken) */
  else
    func5_amb(); /* tail */
}

__attribute__((noinline)) void func7(int &sink, int x) {
  //% self.filecheck("bt", "main.cpp", "-check-prefix=FUNC7-BT")
  // FUNC7-BT: func7
  // FUNC7-BT-NEXT: [inlined] func8_inlined
  // FUNC7-BT-NEXT: [inlined] func9_inlined
  // FUNC7-BT-NEXT: func10
  use<int &, int>(sink, x);
  use<int &, int>(dummy, 0);

  ++global;
  //% self.filecheck("expr x", "main.cpp", "-check-prefix=FUNC7-EXPR1")
  //% self.filecheck("expr sink", "main.cpp", "-check-prefix=FUNC7-EXPR2")
  // FUNC7-EXPR1: ${{.*}} = 123
  // FUNC7-EXPR2: ${{.*}} = 5
}

__attribute__((always_inline)) void func8_inlined(int &sink, int x) {
  func7(sink, x);
}

__attribute__((always_inline)) void func9_inlined(int &sink, int x) {
  func8_inlined(sink, x);
}

__attribute__((noinline, disable_tail_calls)) void func10(int &sink, int x) {
  func9_inlined(sink, x);
}

__attribute__((noinline)) void func11_tailcalled(int &sink, int x) {
  //% self.filecheck("bt", "main.cpp", "-check-prefix=FUNC11-BT")
  // FUNC11-BT: func11_tailcalled{{.*}}
  // FUNC11-BT-NEXT: func12{{.*}} [artificial]
  use<int &, int>(sink, x);
  use<int &, int>(dummy, 0);

  ++global;
  //% self.filecheck("expr x", "main.cpp", "-check-prefix=FUNC11-EXPR1")
  //% self.filecheck("expr sink", "main.cpp", "-check-prefix=FUNC11-EXPR2")
  // FUNC11-EXPR1: ${{.*}} = 123
  // FUNC11-EXPR2: ${{.*}} = 5
}

__attribute__((noinline)) void func12(int &sink, int x) {
  func11_tailcalled(sink, x);
}

__attribute__((noinline)) void func13(int &sink, int x) {
  //% self.filecheck("bt", "main.cpp", "-check-prefix=FUNC13-BT")
  // FUNC13-BT: func13{{.*}}
  // FUNC13-BT-NEXT: func14{{.*}}
  use<int &, int>(sink, x);
  use<int &, int>(dummy, 0);

  ++global;

  //% self.filecheck("expr x", "main.cpp", "-check-prefix=FUNC13-EXPR1")
  //% self.filecheck("expr sink", "main.cpp", "-check-prefix=FUNC13-EXPR2")
  // FUNC13-EXPR1: ${{.*}} = 123
  // FUNC13-EXPR2: ${{.*}} = 5
}

__attribute__((noinline, disable_tail_calls)) void
func14(int &sink, void (*target_no_tailcall)(int &, int)) {
  // Move the call target into a register that won't get clobbered. Do this
  // by calling the same indirect target twice, and hoping that regalloc is
  // 'smart' enough to stash the call target in a non-clobbered register.
  //
  // llvm.org/PR43926 tracks work in the compiler to emit call targets which
  // describe non-clobbered values.
  target_no_tailcall(sink, 123);
  target_no_tailcall(sink, 123);
}

/// A structure that is guaranteed -- when passed to a callee by value -- to be
/// passed via a pointer to a temporary copy in the caller. On x86_64 & aarch64
/// only.
struct StructPassedViaPointerToTemporaryCopy {
  // Under the 64-bit AAPCS, a struct larger than 16 bytes is not SROA'd, and
  // is instead passed via pointer to a temporary copy.
  long a, b, c;
  StructPassedViaPointerToTemporaryCopy() : a(1), b(2), c(3) {}

  // Failing that, a virtual method forces passing via pointer to a temporary
  // copy under the common calling conventions (e.g. 32/64-bit x86, Linux/Win,
  // according to https://www.agner.org/optimize/calling_conventions.pdf).
  virtual void add_vtable() {}
};

__attribute__((noinline)) void func15(StructPassedViaPointerToTemporaryCopy S) {
  use<StructPassedViaPointerToTemporaryCopy &>(S);
  use<int &>(dummy);

  ++global;
  //% self.filecheck("expr S", "main.cpp", "-check-prefix=FUNC15-EXPR")
  // FUNC15-EXPR: (a = 1, b = 2, c = 3)
}

__attribute__((disable_tail_calls)) int main() {
  int sink = 0;
  S1 s1;

  // Test location dumping for DW_OP_entry_value.
  func1(sink);

  sink = 2;
  // Test evaluation of "DW_OP_constu" in the parent frame.
  func2(sink, 123);

  // Test evaluation of "DW_OP_fbreg -24, DW_OP_deref" in the parent frame.
  // Disabled for now, see: llvm.org/PR43343
#if 0
  func3(sink, s1.field2);
#endif

  // The sequences `main -> func4 -> func{5,6}_amb -> sink` are both plausible.
  // Test that lldb doesn't attempt to guess which one occurred: entry value
  // evaluation should fail.
  func6(sink, 123);

  sink = 5;
  // Test that evaluation can "see through" inlining.
  func10(sink, 123);

  // Test that evaluation can "see through" tail calls.
  func12(sink, 123);

  // Test that evaluation can "see through" an indirect tail call.
  func14(sink, func13);

  // Test evaluation of an entry value that dereferences a temporary stack
  // slot set up by the caller for a StructPassedViaPointerToTemporaryCopy.
  func15(StructPassedViaPointerToTemporaryCopy());

  return 0;
}
