vasilito
cb424d7448
verify-patch-sanity.py validates every active recipe .patch has internally- consistent hunk line counts — catching the 'malformed patch at line N' failure at commit/CI/preflight time instead of hours into a cook. This cycle hit that class three times (qtwaylandscanner, sddm, xwayland), each only discovered when cookbook tried to apply the patch. Running it across the repo found 29 latent malformed patches (validated against GNU patch: e.g. relibc/P3-sysv-ipc reproduces 'malformed patch at line 22'). They were harmless only because they sit in vendored recipes (baked, not re- applied) — but would fail on any version-bump re-derivation. --fix recounts the hunk headers (body untouched) and repaired all 29. Wired into build-preflight.sh (Phase 1.0D) and redbear-ci.yml, with a unit test (test-patch-sanity.sh). Skips archived/legacy trees and unvalidatable formats (empty placeholders, bare-@@ git hunks).
131 lines
4.8 KiB
C++
131 lines
4.8 KiB
C++
// RUN: %clang_cc1 -emit-llvm -debug-info-kind=limited -triple x86_64-apple-darwin %s -o - | FileCheck %s
|
|
|
|
// CHECK: @x ={{.*}} global %"struct.outer<foo>::inner" zeroinitializer, align 4, !dbg [[X:![0-9]+]]
|
|
|
|
struct MyClass {
|
|
template <int i> int add(int j) {
|
|
return i + j;
|
|
}
|
|
virtual void func() {
|
|
}
|
|
};
|
|
|
|
int add2(int x) {
|
|
return MyClass().add<2>(x);
|
|
}
|
|
|
|
inline int add3(int x) {
|
|
return MyClass().add<3>(x); // even though add<3> is ODR used, don't emit it since we don't codegen it
|
|
}
|
|
|
|
// The compile unit pulls in the global variables first.
|
|
// CHECK: [[X]] = !DIGlobalVariableExpression(var: [[XV:.*]], expr: !DIExpression())
|
|
// CHECK: [[XV]] = distinct !DIGlobalVariable(name: "x",
|
|
// CHECK-SAME: type: ![[OUTER_FOO_INNER_ID:[0-9]+]]
|
|
|
|
// CHECK: [[C:![0-9]*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "MyClass"
|
|
// CHECK-SAME: elements: [[C_MEM:![0-9]*]]
|
|
// CHECK-SAME: vtableHolder: [[C]]
|
|
// CHECK-SAME: identifier: "_ZTS7MyClass")
|
|
// CHECK: [[C_MEM]] = !{[[C_VPTR:![0-9]*]], [[C_FUNC:![0-9]*]]}
|
|
// CHECK: [[C_VPTR]] = !DIDerivedType(tag: DW_TAG_member, name: "_vptr$MyClass"
|
|
|
|
// CHECK: [[C_FUNC]] = !DISubprogram(name: "func",{{.*}} line: 9,
|
|
|
|
// CHECK: [[VIRT_TEMP:![0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "virt<elem>"
|
|
// CHECK-SAME: elements: [[VIRT_MEM:![0-9]*]]
|
|
// CHECK-SAME: vtableHolder: [[VIRT_TEMP]]
|
|
// CHECK-SAME: templateParams: [[VIRT_TEMP_PARAM:![0-9]*]]
|
|
// CHECK-SAME: identifier: "_ZTS4virtI4elemE"
|
|
|
|
// CHECK: [[ELEM:![0-9]+]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "elem"
|
|
// CHECK-SAME: elements: [[ELEM_MEM:![0-9]*]]
|
|
// CHECK-SAME: identifier: "_ZTS4elem"
|
|
// CHECK: [[ELEM_MEM]] = !{[[ELEM_X:![0-9]*]]}
|
|
// CHECK: [[ELEM_X]] = !DIDerivedType(tag: DW_TAG_member, name: "x", scope: [[ELEM]]
|
|
// CHECK-SAME: baseType: [[VIRT_TEMP:![0-9]+]]
|
|
|
|
// CHECK: [[VIRT_TEMP_PARAM]] = !{[[VIRT_T:![0-9]*]]}
|
|
// CHECK: [[VIRT_T]] = !DITemplateTypeParameter(name: "T", type: [[ELEM]])
|
|
|
|
// CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(
|
|
// CHECK-SAME: name: "var"
|
|
// CHECK-SAME: templateParams: {{![0-9]+}}
|
|
// CHECK: !DITemplateTypeParameter(name: "T", type: [[TY:![0-9]+]])
|
|
// CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(
|
|
// CHECK-SAME: name: "var"
|
|
// CHECK-SAME: templateParams: {{![0-9]+}}
|
|
// CHECK: !DITemplateTypeParameter(name: "T", type: {{![0-9]+}})
|
|
// CHECK: {{![0-9]+}} = distinct !DIGlobalVariable(
|
|
// CHECK-SAME: name: "varray"
|
|
// CHECK-SAME: templateParams: {{![0-9]+}}
|
|
// CHECK: !DITemplateValueParameter(name: "N", type: [[TY]], value: i32 1)
|
|
|
|
// CHECK: ![[OUTER_FOO_INNER_ID:[0-9]*]] = distinct !DICompositeType(tag: DW_TAG_structure_type, name: "inner"{{.*}}, identifier:
|
|
// CHECK: !DICompositeType(tag: DW_TAG_structure_type, name: "foo"
|
|
// CHECK-SAME: elements: [[FOO_MEM:![0-9]*]]
|
|
// CHECK-SAME: identifier: "_ZTS3foo"
|
|
// CHECK: [[FOO_MEM]] = !{[[FOO_FUNC:![0-9]*]]}
|
|
// CHECK: [[FOO_FUNC]] = !DISubprogram(name: "func", linkageName: "_ZN3foo4funcEN5outerIS_E5innerE",
|
|
// CHECK-SAME: type: [[FOO_FUNC_TYPE:![0-9]*]]
|
|
// CHECK: [[FOO_FUNC_TYPE]] = !DISubroutineType(types: [[FOO_FUNC_PARAMS:![0-9]*]])
|
|
// CHECK: [[FOO_FUNC_PARAMS]] = !{null, !{{[0-9]*}}, ![[OUTER_FOO_INNER_ID]]}
|
|
|
|
// CHECK: !DISubprogram(name: "add<2>"
|
|
// CHECK-SAME: scope: [[C]]
|
|
|
|
template<typename T>
|
|
struct outer {
|
|
struct inner {
|
|
int i;
|
|
};
|
|
};
|
|
|
|
struct foo {
|
|
void func(outer<foo>::inner);
|
|
};
|
|
|
|
inline void func() {
|
|
// require 'foo' to be complete before the emission of 'inner' so that, when
|
|
// constructing the context chain for 'x' we emit the full definition of
|
|
// 'foo', which requires the definition of 'inner' again
|
|
foo f;
|
|
}
|
|
|
|
outer<foo>::inner x;
|
|
|
|
template <typename T>
|
|
struct virt {
|
|
T* values;
|
|
virtual ~virt();
|
|
};
|
|
struct elem {
|
|
static virt<elem> x; // ensure that completing 'elem' will require/completing 'virt<elem>'
|
|
};
|
|
inline void f1() {
|
|
elem e; // ensure 'elem' is required to be complete when it is emitted as a template argument for 'virt<elem>'
|
|
};
|
|
void f2() {
|
|
virt<elem> d; // emit 'virt<elem>'
|
|
}
|
|
|
|
// Check that the member function template specialization and implicit special
|
|
// members (the default ctor) refer to their class by scope, even though they
|
|
// didn't appear in the class's member list (C_MEM). This prevents the functions
|
|
// from being added to type units, while still appearing in the type
|
|
// declaration/reference in the compile unit.
|
|
// CHECK: !DISubprogram(name: "MyClass"
|
|
// CHECK-SAME: scope: [[C]]
|
|
|
|
template <typename T>
|
|
T var = T();
|
|
template <typename P>
|
|
P var<P *> = P();
|
|
template <typename T, int N>
|
|
T varray[N];
|
|
void f3() {
|
|
var<int> = 1;
|
|
var<int *> = 1;
|
|
varray<int, 1>[0] = 1;
|
|
}
|