[CIR][Test] Add comprehensive divergence and crash test suite

This commit adds 77 divergence tests and 6 crash tests documenting
current gaps between ClangIR's direct-to-LLVM lowering and standard
CodeGen. These tests serve as a systematic tracking mechanism for
correctness issues that need to be addressed for ClangIR correctness.

The test suite is organized into 12 categories:

**Calling Conventions (26 tests):**
- Struct return ABI mismatches (sret usage, struct coercion)
- Float/SSE calling convention issues
- Missing LLVM attributes (noundef, nonnull, dereferenceable)

**Member Pointers (12 tests):**
- ABI incompatibilities in member pointer handling
- Issues with virtual functions, multiple inheritance, and data members

**Templates (8 tests):**
- Missing comdat groups on template instantiations
- Specialization and variadic template issues

**Construction & Destruction (8 tests):**
- Constructor variants (delegating, copy, move, parameterized)
- Missing comdat on inline constructors/destructors

**Inheritance (6 tests):**
- Diamond inheritance, empty base optimization
- Protected/private inheritance

**Static Initialization (5 tests):**
- Thread-local storage wrapper generation
- Global and static local initialization

**Lambdas (7 tests):**
- Capture mechanisms and missing comdat groups

**RTTI & Vtables (6 tests):**
- Type info linkage issues
- Missing comdat, unnamed_addr attributes
- String constant null terminator issues

**Array Operations (1 test):**
- Array new/delete attribute and null check issues

**Crash Tests (6 tests):**
- Exception handling (NYI)
- Multi-inheritance thunks
- Virtual inheritance
- Static local guards
- Array new with default arguments
- Computed goto

All divergence tests are marked XFAIL and include:
- Detailed comments explaining the divergence
- RUN lines comparing CIR vs CodeGen output
- CHECK directives highlighting specific patterns


ghstack-source-id: c52311c
Pull-Request: #2023

Author: lanza

clang/test/CIR/crashes/array-new-default-arg.cpp

@@ -0,0 +1,37 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+//
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.og.ll
+// RUN: FileCheck --input-file=%t.og.ll %s --check-prefix=OGCG
+//
+// XFAIL: *
+//
+// CIR crashes when using array new with default constructor arguments.
+//
+// Array new requires calling the constructor for each element. When the
+// constructor has default arguments, CIR's lowering fails with:
+//   'cir.const' op operation destroyed but still has uses
+//   fatal error: error in backend: operation destroyed but still has uses
+//
+// The issue is in how CIR handles default argument values when generating
+// the loop to initialize array elements.
+//
+// This affects any array new expression where the class has a constructor
+// with default parameters.
+
+struct S {
+    int x;
+    S(int v = 0) : x(v) {}  // Default argument triggers the bug
+    ~S() {}
+};
+
+S* test_array_new() {
+    return new S[10];  // Crashes during lowering
+}
+
+// LLVM: Should generate array new
+// LLVM: define {{.*}} @_Z14test_array_newv()
+
+// OGCG: Should generate array new with cookie and element loop
+// OGCG: define {{.*}} @_Z14test_array_newv()
+// OGCG: call {{.*}} @_Znam  // operator new[]

clang/test/CIR/crashes/computed-goto-nyi.cpp

@@ -0,0 +1,45 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+//
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.og.ll
+// RUN: FileCheck --input-file=%t.og.ll %s --check-prefix=OGCG
+//
+// XFAIL: *
+//
+// CIR crashes when using computed goto (GNU extension).
+//
+// Computed goto allows taking the address of a label and jumping to it
+// dynamically. This is implemented via the AddrLabelExpr AST node.
+//
+// Currently, CIR crashes with:
+//   Assertion `0 && "NYI"' failed
+//   at CIRGenExprConst.cpp:1634 in ConstantLValueEmitter::VisitAddrLabelExpr
+//
+// The issue is that CIR's constant expression emitter doesn't handle
+// AddrLabelExpr (&&label syntax).
+//
+// This affects code using computed goto, which is common in interpreters,
+// state machines, and performance-critical dispatch code.
+
+int test_computed_goto(int x) {
+    void* labels[] = {&&label0, &&label1, &&label2};
+
+    if (x >= 0 && x <= 2)
+        goto *labels[x];
+    return -1;
+
+label0:
+    return 0;
+label1:
+    return 10;
+label2:
+    return 20;
+}
+
+// LLVM: Should generate indirectbr
+// LLVM: define {{.*}} @_Z18test_computed_gotoi({{.*}})
+
+// OGCG: Should use blockaddress and indirectbr
+// OGCG: define {{.*}} @_Z18test_computed_gotoi({{.*}})
+// OGCG: blockaddress(@_Z18test_computed_gotoi
+// OGCG: indirectbr

clang/test/CIR/crashes/exception-handling-nyi.cpp

@@ -0,0 +1,49 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm -fcxx-exceptions -fexceptions %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+//
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm -fcxx-exceptions -fexceptions %s -o %t.og.ll
+// RUN: FileCheck --input-file=%t.og.ll %s --check-prefix=OGCG
+//
+// XFAIL: *
+//
+// CIR crashes when handling C++ exceptions (try/catch blocks).
+//
+// Exception handling requires:
+// - Generating personality functions
+// - Landing pads for catch blocks
+// - Invoke instructions instead of call for functions that may throw
+// - Exception object allocation and cleanup
+//
+// Currently, CIR crashes with:
+//   NYI
+//   UNREACHABLE executed at CIRGenItaniumCXXABI.cpp:814
+//   at emitBeginCatch
+//
+// This affects any code using try/catch/throw.
+
+struct Exception {
+    int code;
+    Exception(int c) : code(c) {}
+    ~Exception() {}
+};
+
+void may_throw() {
+    throw Exception(42);
+}
+
+int catch_exception() {
+    try {
+        may_throw();
+        return 0;
+    } catch (const Exception& e) {
+        return e.code;
+    }
+}
+
+// LLVM: Should generate exception handling code
+// LLVM: define {{.*}} @_Z15catch_exceptionv()
+
+// OGCG: Should use invoke and landing pads
+// OGCG: define {{.*}} @_Z15catch_exceptionv() {{.*}} personality
+// OGCG: invoke {{.*}} @_Z9may_throwv()
+// OGCG: landingpad

clang/test/CIR/crashes/multi-inheritance-thunk-crash.cpp

@@ -0,0 +1,47 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+//
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.og.ll
+// RUN: FileCheck --input-file=%t.og.ll %s --check-prefix=OGCG
+//
+// XFAIL: *
+//
+// CIR crashes when generating thunks for multiple inheritance.
+//
+// Multiple inheritance requires generating thunks to adjust the 'this' pointer
+// when calling virtual functions through a base class pointer that is not the
+// primary base. The thunk adjusts 'this' and then calls the actual implementation.
+//
+// Currently, CIR crashes with:
+//   Assertion `isValid()' failed in Address::getPointer()
+//   at clang::CIRGen::CIRGenFunction::emitReturnOfRValue
+//
+// This affects any class using multiple inheritance with virtual functions.
+
+struct A {
+    virtual ~A() {}
+    virtual int foo() { return 1; }
+    int a;
+};
+
+struct B {
+    virtual ~B() {}
+    virtual int bar() { return 2; }
+    int b;
+};
+
+struct C : A, B {
+    int foo() override { return 3; }
+    int bar() override { return 4; }
+};
+
+C* make_c() {
+    return new C();
+}
+
+// LLVM: Should generate thunks for B's vtable in C
+// LLVM: define {{.*}} @_Z6make_cv()
+
+// OGCG: Should generate thunks for B's vtable in C
+// OGCG: define {{.*}} @_Z6make_cv()
+// OGCG: define {{.*}} @_ZThn{{[0-9]+}}_N1C3barEv

clang/test/CIR/crashes/static-local-guard-nyi.cpp

@@ -0,0 +1,45 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+//
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.og.ll
+// RUN: FileCheck --input-file=%t.og.ll %s --check-prefix=OGCG
+//
+// XFAIL: *
+//
+// CIR crashes when handling static local variables with constructors.
+//
+// Static locals with non-trivial constructors require thread-safe initialization
+// using guard variables and the __cxa_guard_acquire/__cxa_guard_release ABI.
+//
+// Per the Itanium C++ ABI:
+// - A guard variable tracks initialization state
+// - __cxa_guard_acquire checks if already initialized (returns 0 if so)
+// - Constructor runs once
+// - __cxa_guard_release marks as initialized
+//
+// Currently, CIR crashes with:
+//   NYI: thread-safe guards with __cxa_guard_acquire/release
+//   UNREACHABLE executed at LoweringPrepare.cpp:938
+//   at lowerGuardedInitOp
+//
+// This affects any function with static local variables that have constructors.
+
+struct GlobalClass {
+    int value;
+    GlobalClass(int v) : value(v) {}
+    ~GlobalClass() {}
+};
+
+// Static local with constructor
+int get_static_local() {
+    static GlobalClass local(123);
+    return local.value;
+}
+
+// LLVM: Should have function definition
+// LLVM: define {{.*}} @_Z16get_static_localv()
+
+// OGCG: Should use guard variables and cxa_guard functions
+// OGCG: define {{.*}} @_Z16get_static_localv()
+// OGCG: call {{.*}} @__cxa_guard_acquire
+// OGCG: call {{.*}} @__cxa_guard_release

clang/test/CIR/crashes/virtual-inheritance-crash.cpp

@@ -0,0 +1,49 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.ll
+// RUN: FileCheck --input-file=%t.ll %s --check-prefix=LLVM
+//
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.og.ll
+// RUN: FileCheck --input-file=%t.og.ll %s --check-prefix=OGCG
+//
+// XFAIL: *
+//
+// CIR crashes when handling virtual inheritance with thunks.
+//
+// Virtual inheritance requires:
+// - VTT (Virtual Table Table) for construction
+// - Virtual base pointer adjustments in thunks
+// - vtable offset lookups for dynamic adjustment
+//
+// Currently, CIR crashes with:
+//   Virtual adjustment NYI - requires vtable offset lookup
+//   UNREACHABLE executed at CIRGenItaniumCXXABI.cpp:2203
+//   at performTypeAdjustment during thunk generation
+//
+// This affects any class hierarchy using virtual inheritance.
+
+struct Base {
+    virtual ~Base() {}
+    int b;
+};
+
+struct A : virtual Base {
+    int a;
+};
+
+struct B : virtual Base {
+    int b;
+};
+
+struct C : A, B {
+    int c;
+};
+
+C* make_c() {
+    return new C();
+}
+
+// LLVM: Should generate class with virtual inheritance
+// LLVM: define {{.*}} @_Z6make_cv()
+
+// OGCG: Should generate VTT and virtual base thunks
+// OGCG: define {{.*}} @_Z6make_cv()
+// OGCG: @_ZTT1C = {{.*}} VTT for C

clang/test/CIR/divergences/array-new-delete-divergences.cpp

@@ -0,0 +1,55 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.cir.ll
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ll
+// RUN: diff -u %t.ll %t.cir.ll | FileCheck %s --check-prefix=DIFF
+//
+// XFAIL: *
+//
+// Array new/delete divergences:
+// 1. Missing nobuiltin attribute on operator new[] and operator delete[]
+// 2. Missing allocsize(0) attribute on operator new[]
+// 3. Missing null check before delete[]
+// 4. Missing inbounds on getelementptr
+// 5. Missing noundef/nonnull on function declarations
+//
+// CodeGen:
+//   declare noundef nonnull ptr @_Znam(i64 noundef) #1
+//   ; Function Attrs: nobuiltin allocsize(0)
+//
+//   declare void @_ZdaPv(ptr noundef) #2
+//   ; Function Attrs: nobuiltin nounwind
+//
+//   %isnull = icmp eq ptr %arr, null
+//   br i1 %isnull, label %delete.end, label %delete.notnull
+//   delete.notnull:
+//     call void @_ZdaPv(ptr noundef %arr)
+//
+//   %arrayidx = getelementptr inbounds i32, ptr %arr, i64 0
+//
+// CIR:
+//   declare ptr @_Znam(i64)  (missing noundef, nonnull, nobuiltin, allocsize)
+//   declare void @_ZdaPv(ptr)  (missing noundef, nobuiltin, nounwind)
+//
+//   call void @_ZdaPv(ptr %arr)  (no null check)
+//
+//   %arrayidx = getelementptr i32, ptr %arr, i64 0  (missing inbounds)
+
+// DIFF: -declare noundef nonnull ptr @_Znam(i64 noundef)
+// DIFF: +declare ptr @_Znam(i64)
+// DIFF: -; Function Attrs: nobuiltin allocsize(0)
+// DIFF: -declare void @_ZdaPv(ptr noundef)
+// DIFF: +declare void @_ZdaPv(ptr)
+// DIFF: -; Function Attrs: nobuiltin nounwind
+// DIFF: -%isnull = icmp eq ptr
+// DIFF: -br i1 %isnull
+// DIFF: -delete.notnull:
+// DIFF: getelementptr inbounds
+// DIFF: -getelementptr inbounds
+// DIFF: +getelementptr
+
+int test() {
+    int* arr = new int[10];
+    arr[0] = 42;
+    int result = arr[0];
+    delete[] arr;
+    return result;
+}

clang/test/CIR/divergences/calling-conv-12byte-struct.cpp

@@ -0,0 +1,33 @@
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -fclangir -emit-llvm %s -o %t.cir.ll
+// RUN: %clang_cc1 -triple x86_64-unknown-linux-gnu -emit-llvm %s -o %t.ll
+// RUN: diff -u %t.ll %t.cir.ll | FileCheck %s --check-prefix=DIFF
+//
+// XFAIL: *
+//
+// 12-byte structs (three ints) should be coerced to { i64, i32 } per x86_64 ABI.
+//
+// CodeGen coerces to two registers:
+//   define { i64, i32 } @return_three_ints()
+//
+// CIR returns the struct directly:
+//   define %struct.ThreeInts @return_three_ints()
+
+// DIFF: -define {{.*}} { i64, i32 } @{{.*}}return_three_ints
+// DIFF: +define {{.*}} %struct.ThreeInts @{{.*}}return_three_ints
+
+struct ThreeInts {
+    int a, b, c;  // 12 bytes total
+};
+
+ThreeInts return_three_ints() {
+    return {1, 2, 3};
+}
+
+int take_three_ints(ThreeInts s) {
+    return s.a + s.b + s.c;
+}
+
+int test() {
+    ThreeInts s = return_three_ints();
+    return take_three_ints(s);
+}