[CIR][Tests] Add 10 minimal crash test cases from LLVM/Clang builds

Added crash reproducers from building LLVM/Clang with ClangIR, reduced using creduce.

Tests covering various C++ features and CIR implementation gaps:

Control flow and destructors:
- conditional-return-destructors.cpp: Multiple destructors with conditional return
- static-local-destructor.cpp: Static local with non-trivial destructor

Template metaprogramming:
- constexpr-complex-template-metaprog.cpp: Complex template metaprogramming with __builtin_is_constant_evaluated
- dyncast-assertion.cpp: Aggregate member initialization with template parameters

Static locals and globals:
- static-local-used-attribute.cpp: Static local with __used__ attribute
- static-init-recursion.cpp: Static local with recursive initialization
- virtual-method-global-dtor.cpp: Global with virtual method and destructor

Inheritance:
- virtual-base-constructor.cpp: Virtual base class constructor calls

Function types:
- function-ref-pointer-params.cpp: Function reference with multi-level pointer indirection

Creduce artifacts:
- template-syntax-error.cpp: Malformed creduce artifact documenting reduction process limitations

All tests use XFAIL except template-syntax-error.cpp which uses FileCheck.

These are minimal reproductions from creduce processing of crash reproducers collected
during LLVM/Clang toolchain builds with ClangIR enabled.

Author: lanza

clang/test/CIR/crashes/conditional-return-destructors.cpp

@@ -0,0 +1,28 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Issue: Conditional return with multiple destructors in different scopes
+//
+// When a function has:
+// - Multiple local variables with destructors in different scopes
+// - A conditional return statement
+// - Return value containing a member with a destructor
+// CIR fails to properly manage the cleanup scope stack for all destructors
+// that need to run on each exit path.
+
+class a {
+public:
+  ~a();
+};
+struct b {
+  a c;
+};
+b fn1(bool e) {
+  a d;
+  b f;
+  if (e) {
+    a d;
+    return f;
+  }
+}

clang/test/CIR/crashes/constexpr-complex-template-metaprog.cpp

@@ -0,0 +1,69 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Issue: Complex template metaprogramming with __builtin_is_constant_evaluated
+//
+// When using advanced template metaprogramming involving:
+// - Template aliases with variadic templates
+// - decltype expressions in template parameters
+// - __builtin_is_constant_evaluated() in constexpr context
+// - Complex member function template instantiation chains
+// CIR fails during constant expression evaluation or template instantiation.
+
+template <typename a> struct b {
+  typedef a c;
+};
+template <typename a> class d {
+public:
+  typedef a c;
+};
+template <typename a> using ad = d<a>::c;
+template <typename...> struct g;
+struct i {
+  template <typename, typename e> using f = decltype(e());
+  template <typename a, typename e> static b<ad<f<a, e>>> k(int);
+};
+template <typename h> struct l : i {
+  using c = decltype(k<int, h>(0));
+};
+template <typename j, typename h> struct g<j, h> : l<h>::c {};
+template <typename... a> using ah = g<a...>::c;
+class m;
+class n {
+  void o(m &) const;
+};
+template <typename = void> struct al;
+template <typename a> struct al<a *> {
+  void operator()(a *, a *) {
+    if (__builtin_is_constant_evaluated())
+      ;
+  }
+};
+template <> struct al<> {
+  template <typename a, typename e> void operator()(a p, e *p2) {
+    al<ah<a, e *>>{}(p, p2);
+  }
+};
+class q {
+  void *aq;
+  void *ar;
+  template <class au> void r(au, int, long) {
+    al a;
+    a(aq, ar);
+  }
+};
+template <typename> class s : q {
+  int az;
+  long ba;
+
+public:
+  void t() { r(this, az, ba); }
+};
+class m {
+  s<int> bd;
+
+public:
+  void m_fn5() { bd.t(); }
+};
+void n::o(m &p) const { p.m_fn5(); }

clang/test/CIR/crashes/dyncast-assertion.cpp

@@ -0,0 +1,23 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Crash from LLVM build with ClangIR. Creduced from llvm::formLCSSAForInstructions
+//
+// Issue: dyn_cast assertion failure
+// Location: Casting.h:644
+// Error: Assertion `isa<X>(Val) && "cast<Ty>() argument of incompatible type!"`
+//
+// When initializing aggregate members in a constructor with template parameters,
+// CIR attempts an invalid cast operation.
+
+struct a {
+  template <typename b, typename c> a(b, c);
+};
+class d {
+  a e;
+
+public:
+  d(int) : e(0, 0) {}
+};
+void f() { static d g(0); }

clang/test/CIR/crashes/function-ref-pointer-params.cpp

@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Issue: Function reference parameter with multiple pointer indirections
+//
+// When passing a reference to a function type as a parameter, where the function
+// signature contains multiple levels of pointer indirection in its parameters,
+// CIR fails during type lowering or function call code generation.
+
+const char *a;
+unsigned b;
+unsigned char c;
+void d(int (&e)(unsigned char *, unsigned *, char, const char **)) {
+  e(&c, &b, 0, &a);
+}

clang/test/CIR/crashes/static-init-recursion.cpp

@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Issue: Static local variable with recursive initialization
+//
+// When a static local variable is initialized by calling the function that
+// contains it, CIR fails during initialization code generation. This pattern
+// requires special guard variable handling to prevent infinite recursion at
+// runtime and detect the recursion during initialization.
+
+int a() { static int b = a(); }

clang/test/CIR/crashes/static-local-destructor.cpp

@@ -0,0 +1,18 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Crash from LLVM build with ClangIR
+//
+// Issue: Static local variable with destructor
+// Location: CIRGenDecl.cpp:616
+// Error: UNREACHABLE: NYI
+//
+// When a static local variable has a non-trivial destructor, CIR must
+// register the destructor to run at program exit. This is not yet implemented.
+
+class a {
+public:
+  ~a();
+};
+void b() { static a c; }

clang/test/CIR/crashes/static-local-used-attribute.cpp

@@ -0,0 +1,12 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Issue: Static local variable with __used__ attribute
+//
+// When a function contains a static local variable with the __used__ attribute,
+// CIR fails to properly handle the attribute during code generation.
+// The __used__ attribute prevents the variable from being optimized away even
+// if it appears unused.
+
+void a() { __attribute__((__used__)) static void *b; }

clang/test/CIR/crashes/template-syntax-error.cpp

@@ -0,0 +1,15 @@
+// RUN: not %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir 2>&1 | FileCheck %s
+//
+// This test captures malformed C++ that creduce generated.
+// It documents that our crash reproducer reduction process needs improvement.
+//
+// CHECK: error: expected
+//
+// Issue: Creduce produced syntactically invalid C++ during reduction
+//
+// This is a creduce artifact showing incomplete template syntax.
+// The original crash involved template metaprogramming, but creduce
+// reduced it too aggressively, producing invalid syntax.
+
+template <a> b() struct c {
+  c::b::

clang/test/CIR/crashes/virtual-base-constructor.cpp

@@ -0,0 +1,17 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Issue: Virtual base class constructor call
+//
+// When a derived class constructor explicitly calls a virtual base class constructor,
+// CIR fails during code generation. Virtual base class constructors require special
+// handling as they are initialized by the most derived class, not intermediate classes.
+
+class a {};
+class b : virtual a {};
+class c : b {
+public:
+  c() : b() {}
+};
+void d() { c e; }

clang/test/CIR/crashes/virtual-method-global-dtor.cpp

@@ -0,0 +1,16 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-cir %s -o %t.cir
+//
+// XFAIL: *
+//
+// Issue: Global variable with virtual method and destructor
+//
+// When a global variable has both:
+// - A non-trivial destructor requiring registration for cleanup at program exit
+// - A virtual method requiring vtable generation
+// CIR fails to properly coordinate the vtable setup with destructor registration.
+
+class a {
+public:
+  ~a();
+  virtual char b();
+} c;