0f1c1be196
We have a new policy in place making links to private resources something we try to avoid in source and test files. Normally, we'd organically switch to the new policy rather than make a sweeping change across a project. However, Clang is in a somewhat special circumstance currently: recently, I've had several new contributors run into rdar links around test code which their patch was changing the behavior of. This turns out to be a surprisingly bad experience, especially for newer folks, for a handful of reasons: not understanding what the link is and feeling intimidated by it, wondering whether their changes are actually breaking something important to a downstream in some way, having to hunt down strangers not involved with the patch to impose on them for help, accidental pressure from asking for potentially private IP to be made public, etc. Because folks run into these links entirely by chance (through fixing bugs or working on new features), there's not really a set of problematic links to focus on -- all of the links have basically the same potential for causing these problems. As a result, this is an omnibus patch to remove all such links. This was not a mechanical change; it was done by manually searching for rdar, radar, radr, and other variants to find all the various problematic links. From there, I tried to retain or reword the surrounding comments so that we would lose as little context as possible. However, because most links were just a plain link with no supporting context, the majority of the changes are simple removals. Differential Review: https://reviews.llvm.org/D158071
362 lines
15 KiB
C
362 lines
15 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 can't 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 {{bad type for named register variable}}
|
|
register float baz asm("esp"); // expected-error {{bad 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;
|
|
}
|
|
|
|
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: can't 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'}}
|
|
}
|