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).
201 lines
7.5 KiB
C
201 lines
7.5 KiB
C
// RUN: %clang_cc1 -no-enable-noundef-analysis -triple x86_64-apple-darwin10 -target-cpu core2 -emit-llvm -o - %s | FileCheck %s
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -triple arm64-apple-ios9 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -triple armv7-apple-darwin9 -emit-llvm -o - %s | FileCheck %s
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -triple armv7s-apple-ios9 -emit-llvm -o - %s | FileCheck %s
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -triple armv7k-apple-ios9 -emit-llvm -o - %s | FileCheck %s
|
|
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -x c++ -triple x86_64-apple-darwin10 -target-cpu core2 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CPPONLY
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -x c++ -triple arm64-apple-ios9 -target-cpu cyclone -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CPPONLY
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -x c++ -triple armv7-apple-darwin9 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CPPONLY
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -x c++ -triple armv7s-apple-ios9 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CPPONLY
|
|
// RUN: %clang_cc1 -no-enable-noundef-analysis -x c++ -triple armv7k-apple-ios9 -emit-llvm -o - %s | FileCheck %s --check-prefix=CHECK --check-prefix=CPPONLY
|
|
|
|
// Test tail call behavior when a swiftasynccall function is called
|
|
// from another swiftasynccall function.
|
|
|
|
#define SWIFTCALL __attribute__((swiftcall))
|
|
#define SWIFTASYNCCALL __attribute__((swiftasynccall))
|
|
#define ASYNC_CONTEXT __attribute__((swift_async_context))
|
|
|
|
// CHECK-LABEL: swifttailcc void {{.*}}async_leaf1{{.*}}(ptr swiftasync
|
|
SWIFTASYNCCALL void async_leaf1(char * ASYNC_CONTEXT ctx) {
|
|
*ctx += 1;
|
|
}
|
|
|
|
// CHECK-LABEL: swifttailcc void {{.*}}async_leaf2{{.*}}(ptr swiftasync
|
|
SWIFTASYNCCALL void async_leaf2(char * ASYNC_CONTEXT ctx) {
|
|
*ctx += 2;
|
|
}
|
|
|
|
#if __cplusplus
|
|
#define MYBOOL bool
|
|
#else
|
|
#define MYBOOL _Bool
|
|
#endif
|
|
|
|
// CHECK-LABEL: swifttailcc void {{.*}}async_branch{{.*}}ptr swiftasync
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf1
|
|
// CHECK-NEXT: ret void
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf2
|
|
// CHECK-NEXT: ret void
|
|
SWIFTASYNCCALL void async_branch(MYBOOL b, char * ASYNC_CONTEXT ctx) {
|
|
if (b) {
|
|
return async_leaf1(ctx);
|
|
} else {
|
|
return async_leaf2(ctx);
|
|
}
|
|
}
|
|
|
|
// CHECK-LABEL: swifttailcc void {{.*}}async_not_all_tail
|
|
// CHECK-NOT: musttail call swifttailcc void @{{.*}}async_leaf1
|
|
// CHECK: call swifttailcc void @{{.*}}async_leaf1
|
|
// CHECK-NOT: ret void
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf2
|
|
// CHECK-NEXT: ret void
|
|
SWIFTASYNCCALL void async_not_all_tail(char * ASYNC_CONTEXT ctx) {
|
|
async_leaf1(ctx);
|
|
return async_leaf2(ctx);
|
|
}
|
|
|
|
// CHECK-LABEL: swifttailcc void {{.*}}async_loop
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf1
|
|
// CHECK-NEXT: ret void
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf2
|
|
// CHECK-NEXT: ret void
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_loop
|
|
// CHECK-NEXT: ret void
|
|
SWIFTASYNCCALL void async_loop(unsigned u, char * ASYNC_CONTEXT ctx) {
|
|
if (u == 0) {
|
|
return async_leaf1(ctx);
|
|
} else if (u == 1) {
|
|
return async_leaf2(ctx);
|
|
}
|
|
return async_loop(u - 2, ctx);
|
|
}
|
|
|
|
// Forward-declaration + mutual recursion is okay.
|
|
|
|
SWIFTASYNCCALL void async_mutual_loop2(unsigned u, char * ASYNC_CONTEXT ctx);
|
|
|
|
// CHECK-LABEL: swifttailcc void {{.*}}async_mutual_loop1
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf1
|
|
// CHECK-NEXT: ret void
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf2
|
|
// CHECK-NEXT: ret void
|
|
// There is some bugginess around FileCheck's greediness/matching,
|
|
// so skipping the check for async_mutual_loop2 here.
|
|
SWIFTASYNCCALL void async_mutual_loop1(unsigned u, char * ASYNC_CONTEXT ctx) {
|
|
if (u == 0) {
|
|
return async_leaf1(ctx);
|
|
} else if (u == 1) {
|
|
return async_leaf2(ctx);
|
|
}
|
|
return async_mutual_loop2(u - 2, ctx);
|
|
}
|
|
|
|
// CHECK-LABEL: swifttailcc void {{.*}}async_mutual_loop2
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf1
|
|
// CHECK-NEXT: ret void
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_leaf2
|
|
// CHECK-NEXT: ret void
|
|
// CHECK: musttail call swifttailcc void @{{.*}}async_mutual_loop1
|
|
// CHECK-NEXT: ret void
|
|
SWIFTASYNCCALL void async_mutual_loop2(unsigned u, char * ASYNC_CONTEXT ctx) {
|
|
if (u == 0) {
|
|
return async_leaf1(ctx);
|
|
} else if (u == 1) {
|
|
return async_leaf2(ctx);
|
|
}
|
|
return async_mutual_loop1(u - 2, ctx);
|
|
}
|
|
|
|
// When swiftasynccall functions are called by non-swiftasynccall functions,
|
|
// the call isn't marked as a tail call.
|
|
|
|
// CHECK-LABEL: swiftcc i8 {{.*}}sync_calling_async
|
|
// CHECK-NOT: tail call
|
|
// CHECK: call swifttailcc void @{{.*}}async_branch
|
|
// CHECK-NOT: tail call
|
|
// CHECK: call swifttailcc void @{{.*}}async_loop
|
|
SWIFTCALL char sync_calling_async(MYBOOL b, unsigned u) {
|
|
char x = 'a';
|
|
async_branch(b, &x);
|
|
async_loop(u, &x);
|
|
return x;
|
|
}
|
|
|
|
// CHECK-LABEL: i8 {{.*}}c_calling_async
|
|
// CHECK-NOT: tail call
|
|
// CHECK: call swifttailcc void @{{.*}}async_branch
|
|
// CHECK-NOT: tail call
|
|
// CHECK: call swifttailcc void @{{.*}}async_loop
|
|
char c_calling_async(MYBOOL b, unsigned u) {
|
|
char x = 'a';
|
|
async_branch(b, &x);
|
|
async_loop(u, &x);
|
|
return x;
|
|
}
|
|
|
|
#if __cplusplus
|
|
struct S {
|
|
SWIFTASYNCCALL void (*fptr)(char * ASYNC_CONTEXT);
|
|
|
|
SWIFTASYNCCALL void async_leaf_method(char * ASYNC_CONTEXT ctx) {
|
|
*ctx += 1;
|
|
}
|
|
SWIFTASYNCCALL void async_nonleaf_method1(char * ASYNC_CONTEXT ctx) {
|
|
return async_leaf_method(ctx);
|
|
}
|
|
SWIFTASYNCCALL void async_nonleaf_method2(char * ASYNC_CONTEXT ctx) {
|
|
return this->async_leaf_method(ctx);
|
|
}
|
|
};
|
|
|
|
SWIFTASYNCCALL void (S::*async_leaf_method_ptr)(char * ASYNC_CONTEXT) = &S::async_leaf_method;
|
|
|
|
// CPPONLY-LABEL: swifttailcc void {{.*}}async_struct_field_and_methods
|
|
// CPPONLY: musttail call swifttailcc void %{{[0-9]+}}
|
|
// CPPONLY: musttail call swifttailcc void @{{.*}}async_nonleaf_method1
|
|
// CPPONLY: musttail call swifttailcc void %{{[0-9]+}}
|
|
// CPPONLY: musttail call swifttailcc void @{{.*}}async_nonleaf_method2
|
|
// CPPONLY-NOT: musttail call swifttailcc void @{{.*}}async_leaf_method
|
|
// ^ TODO: Member pointers should also work.
|
|
SWIFTASYNCCALL void async_struct_field_and_methods(int i, S &sref, S *sptr) {
|
|
char x = 'a';
|
|
if (i == 0) {
|
|
return (*sref.fptr)(&x);
|
|
} else if (i == 1) {
|
|
return sref.async_nonleaf_method1(&x);
|
|
} else if (i == 2) {
|
|
return (*(sptr->fptr))(&x);
|
|
} else if (i == 3) {
|
|
return sptr->async_nonleaf_method2(&x);
|
|
} else if (i == 4) {
|
|
return (sref.*async_leaf_method_ptr)(&x);
|
|
}
|
|
return (sptr->*async_leaf_method_ptr)(&x);
|
|
}
|
|
|
|
// CPPONLY-LABEL: define{{.*}} swifttailcc void @{{.*}}async_nonleaf_method1
|
|
// CPPONLY: musttail call swifttailcc void @{{.*}}async_leaf_method
|
|
|
|
// CPPONLY-LABEL: define{{.*}} swifttailcc void @{{.*}}async_nonleaf_method2
|
|
// CPPONLY: musttail call swifttailcc void @{{.*}}async_leaf_method
|
|
#endif
|
|
|
|
// Passing this as an argument requires a coerce-and-expand operation,
|
|
// which requires a temporary. Make sure that cleaning up that temporary
|
|
// doesn't mess around with the musttail handling.
|
|
struct coerce_and_expand {
|
|
char a,b,c,d;
|
|
};
|
|
struct coerce_and_expand return_coerced(void);
|
|
SWIFTASYNCCALL void take_coerced_async(struct coerce_and_expand);
|
|
|
|
// CHECK-LABEL: swifttailcc void @{{.*}}test_coerced
|
|
SWIFTASYNCCALL void test_coerced() {
|
|
// CHECK: musttail call swifttailcc void @{{.*}}take_coerced_async
|
|
// CHECK-NEXT: ret void
|
|
return take_coerced_async(return_coerced());
|
|
}
|