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).
389 lines
16 KiB
C
389 lines
16 KiB
C
// RUN: %clang_cc1 %s -Wno-private-extern -triple i386-pc-linux-gnu -verify -fsyntax-only
|
|
|
|
void f(void) {
|
|
int i;
|
|
|
|
asm ("foo\n" : : "a" (i + 2));
|
|
asm ("foo\n" : : "a" (f())); // expected-error {{invalid type 'void' in asm input}}
|
|
|
|
asm ("foo\n" : "=a" (f())); // expected-error {{invalid lvalue in asm output}}
|
|
asm ("foo\n" : "=a" (i + 2)); // expected-error {{invalid lvalue in asm output}}
|
|
|
|
asm ("foo\n" : [symbolic_name] "=a" (i) : "[symbolic_name]" (i));
|
|
asm ("foo\n" : "=a" (i) : "[" (i)); // expected-error {{invalid input constraint '[' in asm}}
|
|
asm ("foo\n" : "=a" (i) : "[foo" (i)); // expected-error {{invalid input constraint '[foo' in asm}}
|
|
asm ("foo\n" : "=a" (i) : "[symbolic_name]" (i)); // expected-error {{invalid input constraint '[symbolic_name]' in asm}}
|
|
|
|
asm ("foo\n" : : "" (i)); // expected-error {{invalid input constraint '' in asm}}
|
|
asm ("foo\n" : "=a" (i) : "" (i)); // expected-error {{invalid input constraint '' in asm}}
|
|
}
|
|
|
|
void clobbers(void) {
|
|
asm ("nop" : : : "ax", "#ax", "%ax");
|
|
asm ("nop" : : : "eax", "rax", "ah", "al");
|
|
asm ("nop" : : : "0", "%0", "#0");
|
|
asm ("nop" : : : "foo"); // expected-error {{unknown register name 'foo' in asm}}
|
|
asm ("nop" : : : "52");
|
|
asm ("nop" : : : "204"); // expected-error {{unknown register name '204' in asm}}
|
|
asm ("nop" : : : "-1"); // expected-error {{unknown register name '-1' in asm}}
|
|
asm ("nop" : : : "+1"); // expected-error {{unknown register name '+1' in asm}}
|
|
register void *clobber_conflict asm ("%rcx");
|
|
register void *no_clobber_conflict asm ("%rax");
|
|
int a,b,c;
|
|
asm ("nop" : "=r" (no_clobber_conflict) : "r" (clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
|
|
asm ("nop" : "=r" (clobber_conflict) : "r" (no_clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
|
|
asm ("nop" : "=r" (clobber_conflict) : "r" (clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
|
|
asm ("nop" : "=c" (a) : "r" (no_clobber_conflict) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
|
|
asm ("nop" : "=r" (no_clobber_conflict) : "c" (c) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
|
|
asm ("nop" : "=r" (clobber_conflict) : "c" (c) : "%rcx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
|
|
asm ("nop" : "=a" (a) : "b" (b) : "%rcx", "%rbx"); // expected-error {{asm-specifier for input or output variable conflicts with asm clobber list}}
|
|
}
|
|
|
|
void test3(void) {
|
|
int x;
|
|
asm(L"foo" : "=r"(x)); // expected-error {{wide string}}
|
|
asm("foo" : L"=r"(x)); // expected-error {{wide string}}
|
|
}
|
|
|
|
void test4(const volatile void *addr)
|
|
{
|
|
asm ("nop" : : "r"(*addr)); /* expected-error {{invalid type 'const volatile void' in asm input for constraint 'r'}}
|
|
expected-warning {{ISO C does not allow indirection on operand of type 'const volatile void *'}} */
|
|
asm ("nop" : : "m"(*addr)); // expected-warning {{ISO C does not allow indirection on operand of type 'const volatile void *'}}
|
|
|
|
asm ("nop" : : "r"(test4(addr))); // expected-error {{invalid type 'void' in asm input for constraint 'r'}}
|
|
asm ("nop" : : "m"(test4(addr))); // expected-error {{invalid lvalue in asm input for constraint 'm'}}
|
|
|
|
asm ("nop" : : "m"(f())); // expected-error {{invalid lvalue in asm input for constraint 'm'}}
|
|
}
|
|
|
|
void test5(void) {
|
|
asm("nop" : : "X" (8));
|
|
}
|
|
|
|
// PR3385
|
|
void test6(long i) {
|
|
asm("nop" : : "er"(i));
|
|
}
|
|
|
|
void asm_string_tests(int i) {
|
|
asm("%!"); // simple asm string, %! is not an error.
|
|
asm("%!" : ); // expected-error {{invalid % escape in inline assembly string}}
|
|
asm("xyz %" : ); // expected-error {{invalid % escape in inline assembly string}}
|
|
|
|
asm ("%[somename]" :: [somename] "i"(4)); // ok
|
|
asm ("%[somename]" :: "i"(4)); // expected-error {{unknown symbolic operand name in inline assembly string}}
|
|
asm ("%[somename" :: "i"(4)); // expected-error {{unterminated symbolic operand name in inline assembly string}}
|
|
asm ("%[]" :: "i"(4)); // expected-error {{empty symbolic operand name in inline assembly string}}
|
|
|
|
// PR3258
|
|
asm("%9" :: "i"(4)); // expected-error {{invalid operand number in inline asm string}}
|
|
asm("%1" : "+r"(i)); // ok, referring to input.
|
|
}
|
|
|
|
// PR4077
|
|
int test7(unsigned long long b) {
|
|
int a;
|
|
asm volatile("foo %0 %1" : "=a" (a) :"0" (b)); // expected-error {{input with type 'unsigned long long' matching output with type 'int'}}
|
|
return a;
|
|
}
|
|
|
|
// PR3904
|
|
void test8(int i) {
|
|
// A number in an input constraint cannot point to a read-write constraint.
|
|
asm("" : "+r" (i), "=r"(i) : "0" (i)); // expected-error{{invalid input constraint '0' in asm}}
|
|
}
|
|
|
|
// PR3905
|
|
void test9(int i) {
|
|
asm("" : [foo] "=r" (i), "=r"(i) : "1[foo]"(i)); // expected-error{{invalid input constraint '1[foo]' in asm}}
|
|
asm("" : [foo] "=r" (i), "=r"(i) : "[foo]1"(i)); // expected-error{{invalid input constraint '[foo]1' in asm}}
|
|
}
|
|
|
|
void test10(void){
|
|
static int g asm ("g_asm") = 0;
|
|
extern int gg asm ("gg_asm");
|
|
__private_extern__ int ggg asm ("ggg_asm");
|
|
|
|
int a asm ("a_asm"); // expected-warning{{ignored asm label 'a_asm' on automatic variable}}
|
|
auto int aa asm ("aa_asm"); // expected-warning{{ignored asm label 'aa_asm' on automatic variable}}
|
|
|
|
register int r asm ("cx");
|
|
register int rr asm ("rr_asm"); // expected-error{{unknown register name 'rr_asm' in asm}}
|
|
register int rrr asm ("%"); // expected-error{{unknown register name '%' in asm}}
|
|
}
|
|
|
|
// This is just an assert because of the boolean conversion.
|
|
// Feel free to change the assembly to something sensible if it causes a problem.
|
|
void test11(void) {
|
|
_Bool b;
|
|
asm volatile ("movb %%gs:%P2,%b0" : "=q"(b) : "0"(0), "i"(5L));
|
|
}
|
|
|
|
void test12(void) {
|
|
register int cc __asm ("cc"); // expected-error{{unknown register name 'cc' in asm}}
|
|
}
|
|
|
|
// PR10223
|
|
void test13(void) {
|
|
void *esp;
|
|
__asm__ volatile ("mov %%esp, %o" : "=r"(esp) : : ); // expected-error {{invalid % escape in inline assembly string}}
|
|
}
|
|
|
|
struct S; // expected-note 2 {{forward declaration of 'struct S'}}
|
|
void test14(struct S *s) {
|
|
__asm("": : "a"(*s)); // expected-error {{dereference of pointer to incomplete type 'struct S'}}
|
|
__asm("": "=a" (*s) :); // expected-error {{dereference of pointer to incomplete type 'struct S'}}
|
|
}
|
|
|
|
// PR15759.
|
|
double test15(void) {
|
|
double ret = 0;
|
|
__asm("0.0":"="(ret)); // expected-error {{invalid output constraint '=' in asm}}
|
|
__asm("0.0":"=&"(ret)); // expected-error {{invalid output constraint '=&' in asm}}
|
|
__asm("0.0":"+?"(ret)); // expected-error {{invalid output constraint '+?' in asm}}
|
|
__asm("0.0":"+!"(ret)); // expected-error {{invalid output constraint '+!' in asm}}
|
|
__asm("0.0":"+#"(ret)); // expected-error {{invalid output constraint '+#' in asm}}
|
|
__asm("0.0":"+*"(ret)); // expected-error {{invalid output constraint '+*' in asm}}
|
|
__asm("0.0":"=%"(ret)); // expected-error {{invalid output constraint '=%' in asm}}
|
|
__asm("0.0":"=,="(ret)); // expected-error {{invalid output constraint '=,=' in asm}}
|
|
__asm("0.0":"=,g"(ret)); // no-error
|
|
__asm("0.0":"=g"(ret)); // no-error
|
|
return ret;
|
|
}
|
|
|
|
void iOutputConstraint(int x){
|
|
__asm ("nop" : "=ir" (x) : :); // no-error
|
|
__asm ("nop" : "=ri" (x) : :); // no-error
|
|
__asm ("nop" : "=ig" (x) : :); // no-error
|
|
__asm ("nop" : "=im" (x) : :); // no-error
|
|
__asm ("nop" : "=imr" (x) : :); // no-error
|
|
__asm ("nop" : "=i" (x) : :); // expected-error{{invalid output constraint '=i' in asm}}
|
|
__asm ("nop" : "+i" (x) : :); // expected-error{{invalid output constraint '+i' in asm}}
|
|
__asm ("nop" : "=ii" (x) : :); // expected-error{{invalid output constraint '=ii' in asm}}
|
|
__asm ("nop" : "=nr" (x) : :); // no-error
|
|
__asm ("nop" : "=rn" (x) : :); // no-error
|
|
__asm ("nop" : "=ng" (x) : :); // no-error
|
|
__asm ("nop" : "=nm" (x) : :); // no-error
|
|
__asm ("nop" : "=nmr" (x) : :); // no-error
|
|
__asm ("nop" : "=n" (x) : :); // expected-error{{invalid output constraint '=n' in asm}}
|
|
__asm ("nop" : "+n" (x) : :); // expected-error{{invalid output constraint '+n' in asm}}
|
|
__asm ("nop" : "=nn" (x) : :); // expected-error{{invalid output constraint '=nn' in asm}}
|
|
__asm ("nop" : "=Fr" (x) : :); // no-error
|
|
__asm ("nop" : "=rF" (x) : :); // no-error
|
|
__asm ("nop" : "=Fg" (x) : :); // no-error
|
|
__asm ("nop" : "=Fm" (x) : :); // no-error
|
|
__asm ("nop" : "=Fmr" (x) : :); // no-error
|
|
__asm ("nop" : "=F" (x) : :); // expected-error{{invalid output constraint '=F' in asm}}
|
|
__asm ("nop" : "+F" (x) : :); // expected-error{{invalid output constraint '+F' in asm}}
|
|
__asm ("nop" : "=FF" (x) : :); // expected-error{{invalid output constraint '=FF' in asm}}
|
|
__asm ("nop" : "=Er" (x) : :); // no-error
|
|
__asm ("nop" : "=rE" (x) : :); // no-error
|
|
__asm ("nop" : "=Eg" (x) : :); // no-error
|
|
__asm ("nop" : "=Em" (x) : :); // no-error
|
|
__asm ("nop" : "=Emr" (x) : :); // no-error
|
|
__asm ("nop" : "=E" (x) : :); // expected-error{{invalid output constraint '=E' in asm}}
|
|
__asm ("nop" : "+E" (x) : :); // expected-error{{invalid output constraint '+E' in asm}}
|
|
__asm ("nop" : "=EE" (x) : :); // expected-error{{invalid output constraint '=EE' in asm}}
|
|
}
|
|
|
|
// PR19837
|
|
struct foo {
|
|
int a;
|
|
};
|
|
register struct foo bar asm("esp"); // expected-error {{unsupported type for named register variable}}
|
|
register float baz asm("esp"); // expected-error {{unsupported type for named register variable}}
|
|
|
|
register int r0 asm ("edi"); // expected-error {{register 'edi' unsuitable for global register variables on this target}}
|
|
register long long r1 asm ("esp"); // expected-error {{size of register 'esp' does not match variable size}}
|
|
register int r2 asm ("esp");
|
|
|
|
double f_output_constraint(void) {
|
|
double result;
|
|
__asm("foo1": "=f" (result)); // expected-error {{invalid output constraint '=f' in asm}}
|
|
return result;
|
|
}
|
|
|
|
double f_output_constraint_2(void) {
|
|
double result;
|
|
__asm("foo1": "+f" (result)); // expected-error {{invalid output constraint '+f' in asm}}
|
|
return result;
|
|
}
|
|
|
|
void fn1(void) {
|
|
int l;
|
|
__asm__(""
|
|
: [l] "=r"(l)
|
|
: "[l],m"(l)); // expected-error {{asm constraint has an unexpected number of alternatives: 1 vs 2}}
|
|
}
|
|
|
|
void fn2(void) {
|
|
int l;
|
|
__asm__(""
|
|
: "+&m"(l)); // expected-error {{invalid output constraint '+&m' in asm}}
|
|
}
|
|
|
|
void fn3(void) {
|
|
int l;
|
|
__asm__(""
|
|
: "+#r"(l)); // expected-error {{invalid output constraint '+#r' in asm}}
|
|
}
|
|
|
|
void fn4(void) {
|
|
int l;
|
|
__asm__(""
|
|
: "=r"(l)
|
|
: "m#"(l));
|
|
}
|
|
|
|
void fn5(void) {
|
|
int l;
|
|
__asm__(""
|
|
: [g] "+r"(l)
|
|
: "[g]"(l)); // expected-error {{invalid input constraint '[g]' in asm}}
|
|
}
|
|
|
|
void fn6(void) {
|
|
int a;
|
|
__asm__(""
|
|
: "=rm"(a), "=rm"(a)
|
|
: "11m"(a)); // expected-error {{invalid input constraint '11m' in asm}}
|
|
}
|
|
|
|
// PR14269
|
|
typedef struct test16_foo {
|
|
unsigned int field1 : 1;
|
|
unsigned int field2 : 2;
|
|
unsigned int field3 : 3;
|
|
} test16_foo;
|
|
typedef __attribute__((vector_size(16))) int test16_bar;
|
|
register int test16_baz asm("esp");
|
|
|
|
void test16(void)
|
|
{
|
|
test16_foo a;
|
|
test16_bar b;
|
|
|
|
__asm__("movl $5, %0"
|
|
: "=rm" (a.field2)); // expected-error {{reference to a bit-field in asm input with a memory constraint '=rm'}}
|
|
__asm__("movl $5, %0"
|
|
:
|
|
: "m" (a.field3)); // expected-error {{reference to a bit-field in asm output with a memory constraint 'm'}}
|
|
__asm__("movl $5, %0"
|
|
: "=rm" (b[2])); // expected-error {{reference to a vector element in asm input with a memory constraint '=rm'}}
|
|
__asm__("movl $5, %0"
|
|
:
|
|
: "m" (b[3])); // expected-error {{reference to a vector element in asm output with a memory constraint 'm'}}
|
|
__asm__("movl $5, %0"
|
|
: "=rm" (test16_baz)); // expected-error {{reference to a global register variable in asm input with a memory constraint '=rm'}}
|
|
__asm__("movl $5, %0"
|
|
:
|
|
: "m" (test16_baz)); // expected-error {{reference to a global register variable in asm output with a memory constraint 'm'}}
|
|
}
|
|
|
|
int test17(int t0)
|
|
{
|
|
int r0, r1;
|
|
__asm ("addl %2, %2\n\t"
|
|
"movl $123, %0"
|
|
: "=a" (r0),
|
|
"=&r" (r1)
|
|
: "1" (t0), // expected-note {{constraint '1' is already present here}}
|
|
"1" (t0)); // expected-error {{more than one input constraint matches the same output '1'}}
|
|
return r0 + r1;
|
|
}
|
|
|
|
void test18(void)
|
|
{
|
|
// expected-error@+2 {{duplicate use of asm operand name "lab"}}
|
|
// expected-note@+1 {{asm operand name "lab" first referenced here}}
|
|
asm goto ("" : : : : lab, lab, lab2, lab);
|
|
// expected-error@+2 {{duplicate use of asm operand name "lab"}}
|
|
// expected-note@+1 {{asm operand name "lab" first referenced here}}
|
|
asm goto ("xorw %[lab], %[lab]; je %l[lab]" : : [lab] "i" (0) : : lab);
|
|
lab:;
|
|
lab2:;
|
|
int x,x1;
|
|
// expected-error@+2 {{duplicate use of asm operand name "lab"}}
|
|
// expected-note@+1 {{asm operand name "lab" first referenced here}}
|
|
asm ("" : [lab] "=r" (x),[lab] "+r" (x) : [lab1] "r" (x));
|
|
// expected-error@+2 {{duplicate use of asm operand name "lab"}}
|
|
// expected-note@+1 {{asm operand name "lab" first referenced here}}
|
|
asm ("" : [lab] "=r" (x1) : [lab] "r" (x));
|
|
// expected-error@+1 {{invalid operand number in inline asm string}}
|
|
asm ("jne %l0":::);
|
|
asm goto ("jne %l0"::::lab);
|
|
}
|
|
|
|
typedef struct _st_size64 {
|
|
int a;
|
|
char b;
|
|
} st_size64;
|
|
|
|
typedef struct _st_size96 {
|
|
int a;
|
|
int b;
|
|
int c;
|
|
} st_size96;
|
|
|
|
typedef struct _st_size16 {
|
|
char a;
|
|
char b;
|
|
} st_size16;
|
|
|
|
typedef struct _st_size32 {
|
|
char a;
|
|
char b;
|
|
char c;
|
|
char d;
|
|
} st_size32;
|
|
|
|
typedef struct _st_size128 {
|
|
int a;
|
|
int b;
|
|
int c;
|
|
int d;
|
|
} st_size128;
|
|
|
|
void test19(long long x)
|
|
{
|
|
st_size64 a;
|
|
st_size96 b;
|
|
st_size16 c;
|
|
st_size32 d;
|
|
st_size128 e;
|
|
asm ("" : "=rm" (a): "0" (1)); // no-error
|
|
asm ("" : "=rm" (d): "0" (1)); // no-error
|
|
asm ("" : "=rm" (c): "0" (x)); // no-error
|
|
// FIXME: This case is actually supported by codegen.
|
|
asm ("" : "=rm" (x): "0" (a)); // expected-error {{unsupported inline asm: input with type 'st_size64' (aka 'struct _st_size64') matching output with type 'long long'}}
|
|
// FIXME: This case is actually supported by codegen.
|
|
asm ("" : "=rm" (a): "0" (d)); // expected-error {{unsupported inline asm: input with type 'st_size32' (aka 'struct _st_size32') matching output with type 'st_size64' (aka 'struct _st_size64')}}
|
|
asm ("" : "=rm" (b): "0" (1)); // expected-error {{impossible constraint in asm: cannot store value into a register}}
|
|
// FIXME: This case should be supported by codegen, but it fails now.
|
|
asm ("" : "=rm" (e): "0" (1)); // no-error
|
|
// FIXME: This case should be supported by codegen, but it fails now.
|
|
asm ("" : "=rm" (x): "0" (e)); // expected-error {{unsupported inline asm: input with type 'st_size128' (aka 'struct _st_size128') matching output with type 'long long'}}
|
|
}
|
|
|
|
typedef int int2 __attribute__((ext_vector_type(2)));
|
|
|
|
// GH118892
|
|
void test20(char x) {
|
|
double d;
|
|
float f;
|
|
|
|
asm ("fabs" : "=t" (d): "0" (x)); // expected-error {{unsupported inline asm: input with type 'char' matching output with type 'double'}}
|
|
asm ("fabs" : "=t" (x): "0" (d)); // expected-error {{unsupported inline asm: input with type 'double' matching output with type 'char'}}
|
|
asm ("fabs" : "=t" (f): "0" (d)); // no-error
|
|
asm ("fabs" : "=t" (d): "0" (f)); // no-error
|
|
|
|
st_size64 a;
|
|
asm ("fabs" : "=t" (d): "0" (a)); // expected-error {{unsupported inline asm: input with type 'st_size64' (aka 'struct _st_size64') matching output with type 'double'}}
|
|
asm ("fabs" : "=t" (a): "0" (d)); // expected-error {{unsupported inline asm: input with type 'double' matching output with type 'st_size64' (aka 'struct _st_size64')}}
|
|
|
|
int2 v;
|
|
asm ("fabs" : "=t" (d): "0" (v)); // expected-error {{unsupported inline asm: input with type 'int2' (vector of 2 'int' values) matching output with type 'double'}}
|
|
asm ("fabs" : "=t" (v): "0" (d)); // expected-error {{unsupported inline asm: input with type 'double' matching output with type 'int2' (vector of 2 'int' values)}}
|
|
}
|