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).
237 lines
9.4 KiB
C++
237 lines
9.4 KiB
C++
// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s
|
|
// RUN: %clang_cc1 -std=c++20 -triple i386-unknown-unknown %s -emit-llvm -o - | FileCheck %s --check-prefix=CHECK --check-prefix=CHECKCXX20
|
|
// RUN: %clang_cc1 -std=c++11 -triple i386-unknown-unknown %s -emit-llvm -fsanitize=signed-integer-overflow -o - | FileCheck --check-prefix=SIO %s
|
|
|
|
// CHECK: @[[ABC4:.*]] = {{.*}} constant [4 x i8] c"abc\00"
|
|
// CHECK: @[[ABC15:.*]] = {{.*}} constant [15 x i8] c"abc\00\00\00\00
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z2fni
|
|
void fn(int n) {
|
|
// CHECK: icmp ult i{{32|64}} %{{[^ ]+}}, 3
|
|
// CHECK: store i32 1
|
|
// CHECK: store i32 2
|
|
// CHECK: store i32 3
|
|
// CHECK: sub {{.*}}, 12
|
|
// CHECK: call void @llvm.memset
|
|
new int[n] { 1, 2, 3 };
|
|
}
|
|
|
|
#if __cplusplus >= 202002L
|
|
// CHECKCXX20-LABEL: define{{.*}} void @_Z8fn_pareni
|
|
void fn_paren(int n) {
|
|
// CHECKCXX20: icmp ult i{{32|64}} %{{[^ ]+}}, 3
|
|
// CHECKCXX20: store i32 1
|
|
// CHECKCXX20: store i32 2
|
|
// CHECKCXX20: store i32 3
|
|
// CHECKCXX20: sub {{.*}}, 12
|
|
// CHECKCXX20: call void @llvm.memset
|
|
new int[n](1, 2, 3);
|
|
}
|
|
#endif
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z11const_exactv
|
|
void const_exact() {
|
|
// CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
|
|
// CHECK-NOT: icmp eq ptr
|
|
new int[3] { 1, 2, 3 };
|
|
}
|
|
|
|
#if __cplusplus >= 202002L
|
|
// CHECKCXX20-LABEL: define{{.*}} void @_Z17const_exact_parenv
|
|
void const_exact_paren() {
|
|
// CHECKCXX20-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
|
|
// CHECKCXX20-NOT: icmp eq ptr
|
|
new int[3](1, 2, 3);
|
|
}
|
|
#endif
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z16const_sufficientv
|
|
void const_sufficient() {
|
|
// CHECK-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
|
|
new int[4] { 1, 2, 3 };
|
|
// CHECK: ret void
|
|
}
|
|
|
|
#if __cplusplus >= 202002L
|
|
// CHECKCXX20-LABEL: define{{.*}} void @_Z22const_sufficient_parenv
|
|
void const_sufficient_paren() {
|
|
// CHECKCXX20-NOT: icmp ult i{{32|64}} %{{[^ ]+}}, 3
|
|
new int[4](1, 2, 3);
|
|
// CHECKCXX20: ret void
|
|
}
|
|
#endif
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z22check_array_value_initv
|
|
void check_array_value_init() {
|
|
struct S;
|
|
new (int S::*[3][4][5]) ();
|
|
|
|
// CHECK: call noalias noundef nonnull ptr @_Zna{{.}}(i{{32 noundef 240|64 noundef 480}})
|
|
// CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 60
|
|
|
|
// CHECK: phi
|
|
// CHECK: store i{{32|64}} -1,
|
|
// CHECK: getelementptr inbounds i{{32|64}}, ptr {{.*}}, i{{32|64}} 1
|
|
// CHECK: icmp eq
|
|
// CHECK: br i1
|
|
}
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z15string_nonconsti
|
|
void string_nonconst(int n) {
|
|
// CHECK: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
|
|
// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
|
|
// CHECK: select
|
|
// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
|
|
// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
|
|
// CHECK: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
|
|
// CHECK: %[[RESTSIZE:.*]] = sub {{.*}}, 4
|
|
// CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
|
|
new char[n] { "abc" };
|
|
}
|
|
|
|
#if __cplusplus >= 202002L
|
|
// CHECKCXX20-LABEL: define{{.*}} void @_Z21string_nonconst_pareni
|
|
void string_nonconst_paren(int n) {
|
|
// CHECKCXX20: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
|
|
// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
|
|
// CHECKCXX20: select
|
|
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
|
|
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
|
|
// CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
|
|
// CHECKCXX20: %[[RESTSIZE:.*]] = sub {{.*}}, 4
|
|
// CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
|
|
new char[n]("abc");
|
|
}
|
|
|
|
// CHECKCXX20-LABEL: define{{.*}} void @_Z33string_nonconst_paren_extra_pareni
|
|
void string_nonconst_paren_extra_paren(int n) {
|
|
// CHECKCXX20: icmp {{s|u}}lt i{{32|64}} %{{[^ ]+}}, 4
|
|
// FIXME: Conditionally throw an exception rather than passing -1 to alloc function
|
|
// CHECKCXX20: select
|
|
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}}
|
|
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
|
|
// CHECKCXX20: %[[REST:.*]] = getelementptr inbounds i8, ptr %[[PTR]], i32 4
|
|
// CHECKCXX20: %[[RESTSIZE:.*]] = sub {{.*}}, 4
|
|
// CHECKCXX20: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[REST]], i8 0, i{{32|64}} %[[RESTSIZE]],
|
|
new char[n](("abc"));
|
|
}
|
|
#endif
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z12string_exactv
|
|
void string_exact() {
|
|
// CHECK-NOT: icmp
|
|
// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
|
|
// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
|
|
// CHECK-NOT: memset
|
|
new char[4] { "abc" };
|
|
}
|
|
|
|
#if __cplusplus >= 202002L
|
|
// CHECKCXX20-LABEL: define{{.*}} void @_Z18string_exact_parenv
|
|
void string_exact_paren() {
|
|
// CHECKCXX20-NOT: icmp
|
|
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
|
|
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
|
|
// CHECKCXX20-NOT: memset
|
|
new char[4]("abc");
|
|
}
|
|
|
|
// CHECKCXX20-LABEL: define{{.*}} void @_Z28string_exact_paren_extensionv
|
|
void string_exact_paren_extension() {
|
|
// CHECKCXX20-NOT: icmp
|
|
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 4)
|
|
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC4]], i32 4,
|
|
// CHECKCXX20-NOT: memset
|
|
new char[4](__extension__ "abc");
|
|
}
|
|
#endif
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z17string_sufficientv
|
|
void string_sufficient() {
|
|
// CHECK-NOT: icmp
|
|
// CHECK: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15)
|
|
// FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
|
|
// CHECK: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
|
|
// CHECK-NOT: memset
|
|
new char[15] { "abc" };
|
|
}
|
|
|
|
#if __cplusplus >= 202002L
|
|
// CHECKCXX20-LABEL: define{{.*}} void @_Z23string_sufficient_parenv
|
|
void string_sufficient_paren() {
|
|
// CHECKCXX20-NOT: icmp
|
|
// CHECKCXX20: %[[PTR:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 15)
|
|
// FIXME: For very large arrays, it would be preferable to emit a small copy and a memset.
|
|
// CHECKCXX20: call void @llvm.memcpy{{.*}}(ptr align {{[0-9]+}} %[[PTR]], ptr align {{[0-9]+}} @[[ABC15]], i32 15,
|
|
// CHECKCXX20-NOT: memset
|
|
new char[15]("abc");
|
|
}
|
|
#endif
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z10aggr_exactv
|
|
void aggr_exact() {
|
|
// CHECK-NOT: icmp
|
|
// CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(i{{32|64}} noundef 16)
|
|
// CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}}
|
|
// CHECK: store i32 1, ptr %[[FIELD]]
|
|
// CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
|
|
// CHECK: store i32 2, ptr %[[FIELD]]
|
|
// CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
|
|
// CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
|
|
// CHECK: store i32 3, ptr %[[FIELD]]
|
|
// CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
|
|
// CHECK: store i32 0, ptr %[[FIELD]]
|
|
// CHECK-NOT: store
|
|
// CHECK-NOT: memset
|
|
struct Aggr { int a, b; };
|
|
new Aggr[2] { 1, 2, 3 };
|
|
}
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z15aggr_sufficienti
|
|
void aggr_sufficient(int n) {
|
|
// CHECK: icmp ult i32 %{{.*}}, 2
|
|
// CHECK: %[[MEM:.*]] = call noalias noundef nonnull ptr @_Zna{{.}}(
|
|
// CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR:.*]], ptr %[[MEM]], i32 0, i32 0{{$}}
|
|
// CHECK: store i32 1, ptr %[[FIELD]]
|
|
// CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[MEM]], i32 0, i32 1{{$}}
|
|
// CHECK: store i32 2, ptr %[[FIELD]]
|
|
// CHECK: %[[PTR1:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[MEM]], i32 1{{$}}
|
|
// CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[PTR1]], i32 0, i32 0{{$}}
|
|
// CHECK: store i32 3, ptr %[[FIELD]]
|
|
// CHECK: %[[FIELD:.*]] = getelementptr inbounds nuw %[[AGGR]], ptr %[[PTR1]], i32 0, i32 1{{$}}
|
|
// CHECK: store i32 0, ptr %[[FIELD]]
|
|
// CHECK: %[[PTR2:.*]] = getelementptr inbounds %[[AGGR]], ptr %[[PTR1]], i32 1{{$}}
|
|
// CHECK: %[[REMAIN:.*]] = sub i32 {{.*}}, 16
|
|
// CHECK: call void @llvm.memset{{.*}}(ptr align {{[0-9]+}} %[[PTR2]], i8 0, i32 %[[REMAIN]],
|
|
struct Aggr { int a, b; };
|
|
new Aggr[n] { 1, 2, 3 };
|
|
}
|
|
|
|
// SIO-LABEL: define{{.*}} void @_Z14constexpr_testv
|
|
void constexpr_test() {
|
|
// SIO: call noalias noundef nonnull ptr @_Zna{{.}}(i32 noundef 4)
|
|
new int[0+1]{0};
|
|
}
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z13unknown_boundv
|
|
void unknown_bound() {
|
|
struct Aggr { int x, y, z; };
|
|
new Aggr[]{1, 2, 3, 4};
|
|
// CHECK: call {{.*}}_Znaj(i32 noundef 24)
|
|
// CHECK: store i32 1
|
|
// CHECK: store i32 2
|
|
// CHECK: store i32 3
|
|
// CHECK: store i32 4
|
|
// CHECK: store i32 0
|
|
// CHECK: store i32 0
|
|
// CHECK-NOT: store
|
|
// CHECK: }
|
|
}
|
|
|
|
// CHECK-LABEL: define{{.*}} void @_Z20unknown_bound_stringv
|
|
void unknown_bound_string() {
|
|
new char[]{"hello"};
|
|
// CHECK: call {{.*}}_Znaj(i32 noundef 6)
|
|
// CHECK: memcpy{{.*}} i32 6,
|
|
}
|