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).
214 lines
8.4 KiB
C
214 lines
8.4 KiB
C
// RUN: %clang_cc1 -std=c23 -triple x86_64-gnu-linux -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK64,LIN64
|
|
// RUN: %clang_cc1 -std=c23 -triple x86_64-windows-pc -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,CHECK64,WIN64
|
|
// RUN: %clang_cc1 -std=c23 -triple i386-gnu-linux -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,LIN32
|
|
// RUN: %clang_cc1 -std=c23 -triple i386-windows-pc -O3 -disable-llvm-passes -emit-llvm -o - %s | FileCheck %s --check-prefixes=CHECK,WIN32
|
|
|
|
// CHECK64: %struct.S1 = type { i32, [4 x i8], [24 x i8] }
|
|
// WIN32: %struct.S1 = type { i32, [4 x i8], [24 x i8] }
|
|
// LIN32: %struct.S1 = type { i32, [20 x i8] }
|
|
// CHECK64: %struct.S2 = type { [40 x i8], i32, [4 x i8] }
|
|
// WIN32: %struct.S2 = type { [40 x i8], i32, [4 x i8] }
|
|
// LIN32: %struct.S2 = type { [36 x i8], i32 }
|
|
// LIN64: %struct.S3 = type { [17 x i8], [7 x i8] }
|
|
// WIN64: %struct.S3 = type { [24 x i8] }
|
|
|
|
//GH62207
|
|
unsigned _BitInt(1) GlobSize1 = 0;
|
|
// CHECK: @GlobSize1 = {{.*}}global i8 0
|
|
|
|
// CHECK64: @__const.foo.A = private unnamed_addr constant { i32, [4 x i8], <{ i8, [23 x i8] }> } { i32 1, [4 x i8] zeroinitializer, <{ i8, [23 x i8] }> <{ i8 -86, [23 x i8] zeroinitializer }> }, align 8
|
|
// @BigGlob = global [40 x i8] c"\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF\FF", align 8
|
|
// CHECK64: @f.p = internal global <{ i8, i8, [22 x i8] }> <{ i8 16, i8 39, [22 x i8] zeroinitializer }>, align 8
|
|
|
|
void GenericTest(_BitInt(3) a, unsigned _BitInt(3) b, _BitInt(4) c) {
|
|
// CHECK: define {{.*}}void @GenericTest
|
|
int which = _Generic(a, _BitInt(3): 1, unsigned _BitInt(3) : 2, _BitInt(4) : 3);
|
|
// CHECK: store i32 1
|
|
int which2 = _Generic(b, _BitInt(3): 1, unsigned _BitInt(3) : 2, _BitInt(4) : 3);
|
|
// CHECK: store i32 2
|
|
int which3 = _Generic(c, _BitInt(3): 1, unsigned _BitInt(3) : 2, _BitInt(4) : 3);
|
|
// CHECK: store i32 3
|
|
}
|
|
|
|
void VLATest(_BitInt(3) A, _BitInt(99) B, _BitInt(123) C) {
|
|
// CHECK: define {{.*}}void @VLATest
|
|
int AR1[A];
|
|
// CHECK: %[[A:.+]] = zext i3 %{{.+}} to i[[INDXSIZE:[0-9]+]]
|
|
// CHECK: %[[VLA1:.+]] = alloca i32, i[[INDXSIZE]] %[[A]]
|
|
int AR2[B];
|
|
// CHECK: %[[B:.+]] = trunc i99 %{{.+}} to i[[INDXSIZE]]
|
|
// CHECK: %[[VLA2:.+]] = alloca i32, i[[INDXSIZE]] %[[B]]
|
|
int AR3[C];
|
|
// CHECK: %[[C:.+]] = trunc i123 %{{.+}} to i[[INDXSIZE]]
|
|
// CHECK: %[[VLA3:.+]] = alloca i32, i[[INDXSIZE]] %[[C]]
|
|
}
|
|
|
|
struct S {
|
|
_BitInt(17) A;
|
|
_BitInt(128) B;
|
|
_BitInt(17) C;
|
|
};
|
|
|
|
void OffsetOfTest(void) {
|
|
// CHECK: define {{.*}}void @OffsetOfTest
|
|
int A = __builtin_offsetof(struct S,A);
|
|
// CHECK: store i32 0, ptr %{{.+}}
|
|
int B = __builtin_offsetof(struct S,B);
|
|
// CHECK64: store i32 8, ptr %{{.+}}
|
|
// LIN32: store i32 4, ptr %{{.+}}
|
|
// WIN32: store i32 8, ptr %{{.+}}
|
|
int C = __builtin_offsetof(struct S,C);
|
|
// CHECK64: store i32 24, ptr %{{.+}}
|
|
// LIN32: store i32 20, ptr %{{.+}}
|
|
// WIN32: store i32 24, ptr %{{.+}}
|
|
}
|
|
|
|
void Size1ExtIntParam(unsigned _BitInt(1) A) {
|
|
// CHECK: define {{.*}}void @Size1ExtIntParam(i1{{.*}} %[[PARAM:.+]])
|
|
// CHECK: %[[PARAM_ADDR:.+]] = alloca i8
|
|
// CHECK: %[[B:.+]] = alloca [5 x i8]
|
|
// CHECK: %[[STOREDV:.+]] = zext i1 %[[PARAM]] to i8
|
|
// CHECK: store i8 %[[STOREDV]], ptr %[[PARAM_ADDR]]
|
|
unsigned _BitInt(1) B[5];
|
|
|
|
// CHECK: %[[PARAM_LOAD:.+]] = load i8, ptr %[[PARAM_ADDR]]
|
|
// CHECK: %[[LOADEDV:.+]] = trunc i8 %0 to i1
|
|
// CHECK: %[[IDX:.+]] = getelementptr inbounds [5 x i8], ptr %[[B]]
|
|
// CHECK: %[[STOREDV1:.+]] = zext i1 %[[LOADEDV]] to i8
|
|
// CHECK: store i8 %[[STOREDV1]], ptr %[[IDX]]
|
|
B[2] = A;
|
|
}
|
|
|
|
#if __BITINT_MAXWIDTH__ > 128
|
|
struct S1 {
|
|
_BitInt(17) A;
|
|
_BitInt(129) B;
|
|
};
|
|
|
|
int foo(int a) {
|
|
// CHECK: %A1 = getelementptr inbounds nuw %struct.S1, ptr %B, i32 0, i32 0
|
|
// CHECK: store i32 1, ptr %A1
|
|
// CHECK64: %B2 = getelementptr inbounds nuw %struct.S1, ptr %B, i32 0, i32 2
|
|
// WIN32: %B2 = getelementptr inbounds nuw %struct.S1, ptr %B, i32 0, i32 2
|
|
// LIN32: %B2 = getelementptr inbounds nuw %struct.S1, ptr %B, i32 0, i32 1
|
|
// CHECK: %[[V1:.+]] = load i32, ptr %a.addr, align 4
|
|
// CHECK: %conv = sext i32 %[[V1]] to i129
|
|
// CHECK64: storedv = sext i129 %conv to i192
|
|
// WIN32: storedv = sext i129 %conv to i192
|
|
// LIN32: storedv = sext i129 %conv to i160
|
|
// CHECK64: store i192 %storedv, ptr %B2, align 8
|
|
// WIN32: store i192 %storedv, ptr %B2, align 8
|
|
// LIN32: store i160 %storedv, ptr %B2, align 4
|
|
// CHECK64: %B3 = getelementptr inbounds nuw %struct.S1, ptr %A, i32 0, i32 2
|
|
// WIN32: %B3 = getelementptr inbounds nuw %struct.S1, ptr %A, i32 0, i32 2
|
|
// LIN32: %B3 = getelementptr inbounds nuw %struct.S1, ptr %A, i32 0, i32 1
|
|
// CHECK64: %[[V2:.+]] = load i192, ptr %B3, align 8
|
|
// WIN32: %[[V2:.+]] = load i192, ptr %B3, align 8
|
|
// LIN32: %[[V2:.+]] = load i160, ptr %B3, align 4
|
|
// CHECK64: %loadedv = trunc i192 %[[V2]] to i129
|
|
// WIN32: %loadedv = trunc i192 %[[V2]] to i129
|
|
// LIN32: %loadedv = trunc i160 %[[V2]] to i129
|
|
// CHECK: %conv4 = trunc i129 %loadedv to i32
|
|
struct S1 A = {1, 170};
|
|
struct S1 B = {1, a};
|
|
return (int)A.B + (int)B.B;
|
|
}
|
|
|
|
struct S2 {
|
|
_BitInt(257) A;
|
|
int B;
|
|
};
|
|
|
|
_BitInt(257) bar() {
|
|
// CHECK64: define {{.*}}void @bar(ptr {{.*}} sret([40 x i8]) align 8 %[[RET:.+]])
|
|
// CHECK64: %A = alloca %struct.S2, align 8
|
|
// CHECK64: %0 = getelementptr inbounds { <{ i8, [39 x i8] }>, i32, [4 x i8] }, ptr %A, i32 0, i32 0
|
|
// CHECK64: %1 = getelementptr inbounds <{ i8, [39 x i8] }>, ptr %0, i32 0, i32 0
|
|
// CHECK64: store i8 1, ptr %1, align 8
|
|
// CHECK64: %2 = getelementptr inbounds { <{ i8, [39 x i8] }>, i32, [4 x i8] }, ptr %A, i32 0, i32 1
|
|
// CHECK64: store i32 10000, ptr %2, align 8
|
|
// CHECK64: %A1 = getelementptr inbounds nuw %struct.S2, ptr %A, i32 0, i32 0
|
|
// CHECK64: %3 = load i320, ptr %A1, align 8
|
|
// CHECK64: %loadedv = trunc i320 %3 to i257
|
|
// CHECK64: %storedv = sext i257 %loadedv to i320
|
|
// CHECK64: store i320 %storedv, ptr %[[RET]], align 8
|
|
struct S2 A = {1, 10000};
|
|
return A.A;
|
|
}
|
|
|
|
void TakesVarargs(int i, ...) {
|
|
// CHECK64: define{{.*}} void @TakesVarargs(i32
|
|
__builtin_va_list args;
|
|
__builtin_va_start(args, i);
|
|
|
|
_BitInt(160) A = __builtin_va_arg(args, _BitInt(160));
|
|
// CHECK64: %[[ARG:.+]] = load i192
|
|
// CHECK64: %[[TRUNC:.+]] = trunc i192 %[[ARG]] to i160
|
|
// CHECK64: %[[SEXT:.+]] = sext i160 %[[TRUNC]] to i192
|
|
// CHECK64: store i192 %[[SEXT]], ptr %A, align 8
|
|
}
|
|
|
|
_BitInt(129) *f1(_BitInt(129) *p) {
|
|
// CHECK64: getelementptr inbounds [24 x i8], {{.*}} i64 1
|
|
return p + 1;
|
|
}
|
|
|
|
char *f2(char *p) {
|
|
// CHECK64: getelementptr inbounds nuw i8, {{.*}} i64 24
|
|
return p + sizeof(_BitInt(129));
|
|
}
|
|
|
|
auto BigGlob = (_BitInt(257))-1;
|
|
// CHECK64: define {{.*}}void @foobar(ptr {{.*}} sret([40 x i8]) align 8 %[[RET1:.+]])
|
|
_BitInt(257) foobar() {
|
|
// CHECK64: %A = alloca [40 x i8], align 8
|
|
// CHECK64: %0 = load i320, ptr @BigGlob, align 8
|
|
// CHECK64: %loadedv = trunc i320 %0 to i257
|
|
// CHECK64: %add = add nsw i257 %loadedv, 1
|
|
// CHECK64: %storedv = sext i257 %add to i320
|
|
// CHECK64: store i320 %storedv, ptr %A, align 8
|
|
// CHECK64: %1 = load i320, ptr %A, align 8
|
|
// CHECK64: %loadedv1 = trunc i320 %1 to i257
|
|
// CHECK64: %storedv2 = sext i257 %loadedv1 to i320
|
|
// CHECK64: store i320 %storedv2, ptr %[[RET1]], align 8
|
|
_BitInt(257) A = BigGlob + 1;
|
|
return A;
|
|
}
|
|
|
|
void f() {
|
|
static _BitInt(130) p = {10000};
|
|
}
|
|
|
|
struct S3 {
|
|
_BitInt (136) A : 129;
|
|
};
|
|
|
|
void bitField() {
|
|
struct S3 s = {1};
|
|
struct {
|
|
_BitInt (136) A : 48;
|
|
int a;
|
|
} s1 = {s.A};
|
|
s1.A = 36;
|
|
// LIN64: %s = alloca %struct.S3, align 8
|
|
// LIN64: %s1 = alloca %struct.anon, align 8
|
|
// LIN64: call void @llvm.memcpy.p0.p0.i64(ptr align 8 %s, ptr align 8 @__const.bitField.s, i64 24, i1 false)
|
|
// LIN64: %bf.load = load i136, ptr %s, align 8
|
|
// LIN64: %bf.shl = shl i136 %bf.load, 7
|
|
// LIN64: %bf.ashr = ashr i136 %bf.shl, 7
|
|
// LIN64: %0 = trunc i136 %bf.ashr to i64
|
|
// LIN64: %bf.load1 = load i64, ptr %s1, align 8
|
|
// LIN64: %bf.value = and i64 %0, 281474976710655
|
|
// LIN64: %bf.clear = and i64 %bf.load1, -281474976710656
|
|
// LIN64: %bf.set = or i64 %bf.clear, %bf.value
|
|
// LIN64: store i64 %bf.set, ptr %s1, align 8
|
|
// LIN64: %a = getelementptr inbounds nuw %struct.anon, ptr %s1, i32 0, i32 1
|
|
// LIN64: store i32 0, ptr %a, align 8
|
|
// LIN64: %bf.load2 = load i64, ptr %s1, align 8
|
|
// LIN64: %bf.clear3 = and i64 %bf.load2, -281474976710656
|
|
// LIN64: %bf.set4 = or i64 %bf.clear3, 36
|
|
// LIN64: store i64 %bf.set4, ptr %s1, align 8
|
|
}
|
|
|
|
#endif
|