Chris Lattner | b992259 | 2010-03-03 21:52:23 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -triple i386-unknown-unknown -emit-llvm %s -o - | FileCheck %s |
Chris Lattner | 9f5bff0 | 2011-07-23 20:04:25 +0000 | [diff] [blame] | 2 | |
| 3 | // PR10415 |
| 4 | __asm__ ("foo1"); |
| 5 | __asm__ ("foo2"); |
| 6 | __asm__ ("foo3"); |
| 7 | // CHECK: module asm "foo1" |
| 8 | // CHECK-NEXT: module asm "foo2" |
| 9 | // CHECK-NEXT: module asm "foo3" |
| 10 | |
Chris Lattner | 10ca96a | 2009-03-10 06:33:24 +0000 | [diff] [blame] | 11 | void t1(int len) { |
Anders Carlsson | 9f2505b | 2009-01-11 21:23:27 +0000 | [diff] [blame] | 12 | __asm__ volatile("" : "=&r"(len), "+&r"(len)); |
Anders Carlsson | 2763b3a | 2009-01-11 19:46:50 +0000 | [diff] [blame] | 13 | } |
Anders Carlsson | 9f2505b | 2009-01-11 21:23:27 +0000 | [diff] [blame] | 14 | |
Chris Lattner | 10ca96a | 2009-03-10 06:33:24 +0000 | [diff] [blame] | 15 | void t2(unsigned long long t) { |
Anders Carlsson | 9f2505b | 2009-01-11 21:23:27 +0000 | [diff] [blame] | 16 | __asm__ volatile("" : "+m"(t)); |
| 17 | } |
| 18 | |
Chris Lattner | 10ca96a | 2009-03-10 06:33:24 +0000 | [diff] [blame] | 19 | void t3(unsigned char *src, unsigned long long temp) { |
Anders Carlsson | 9f2505b | 2009-01-11 21:23:27 +0000 | [diff] [blame] | 20 | __asm__ volatile("" : "+m"(temp), "+r"(src)); |
| 21 | } |
| 22 | |
Chris Lattner | 10ca96a | 2009-03-10 06:33:24 +0000 | [diff] [blame] | 23 | void t4() { |
Anders Carlsson | ebaae2a | 2009-01-12 02:22:13 +0000 | [diff] [blame] | 24 | unsigned long long a; |
| 25 | struct reg { unsigned long long a, b; } b; |
| 26 | |
Mike Stump | 1eb4433 | 2009-09-09 15:08:12 +0000 | [diff] [blame] | 27 | __asm__ volatile ("":: "m"(a), "m"(b)); |
Anders Carlsson | ebaae2a | 2009-01-12 02:22:13 +0000 | [diff] [blame] | 28 | } |
Anders Carlsson | 9f2505b | 2009-01-11 21:23:27 +0000 | [diff] [blame] | 29 | |
Anders Carlsson | 03eb543 | 2009-01-27 20:38:24 +0000 | [diff] [blame] | 30 | // PR3417 |
Chris Lattner | 10ca96a | 2009-03-10 06:33:24 +0000 | [diff] [blame] | 31 | void t5(int i) { |
Anders Carlsson | 03eb543 | 2009-01-27 20:38:24 +0000 | [diff] [blame] | 32 | asm("nop" : "=r"(i) : "0"(t5)); |
| 33 | } |
Anders Carlsson | 6032979 | 2009-02-22 02:11:23 +0000 | [diff] [blame] | 34 | |
| 35 | // PR3641 |
Chris Lattner | 10ca96a | 2009-03-10 06:33:24 +0000 | [diff] [blame] | 36 | void t6(void) { |
Anders Carlsson | 6032979 | 2009-02-22 02:11:23 +0000 | [diff] [blame] | 37 | __asm__ volatile("" : : "i" (t6)); |
| 38 | } |
Chris Lattner | 10ca96a | 2009-03-10 06:33:24 +0000 | [diff] [blame] | 39 | |
Chris Lattner | 10ca96a | 2009-03-10 06:33:24 +0000 | [diff] [blame] | 40 | void t7(int a) { |
| 41 | __asm__ volatile("T7 NAMED: %[input]" : "+r"(a): [input] "i" (4)); |
Chris Lattner | 29a4071 | 2010-03-04 00:38:16 +0000 | [diff] [blame] | 42 | // CHECK: @t7(i32 |
| 43 | // CHECK: T7 NAMED: $1 |
Chris Lattner | 02af974 | 2009-03-10 06:38:02 +0000 | [diff] [blame] | 44 | } |
| 45 | |
Chris Lattner | 02af974 | 2009-03-10 06:38:02 +0000 | [diff] [blame] | 46 | void t8() { |
| 47 | __asm__ volatile("T8 NAMED MODIFIER: %c[input]" :: [input] "i" (4)); |
Chris Lattner | 29a4071 | 2010-03-04 00:38:16 +0000 | [diff] [blame] | 48 | // CHECK: @t8() |
| 49 | // CHECK: T8 NAMED MODIFIER: ${0:c} |
Chris Lattner | 02af974 | 2009-03-10 06:38:02 +0000 | [diff] [blame] | 50 | } |
Chris Lattner | 88beebe | 2009-03-10 06:42:37 +0000 | [diff] [blame] | 51 | |
| 52 | // PR3682 |
| 53 | unsigned t9(unsigned int a) { |
| 54 | asm("bswap %0 %1" : "+r" (a)); |
| 55 | return a; |
| 56 | } |
Anders Carlsson | ec91dab | 2009-04-03 05:57:08 +0000 | [diff] [blame] | 57 | |
| 58 | // PR3908 |
Anders Carlsson | ec91dab | 2009-04-03 05:57:08 +0000 | [diff] [blame] | 59 | void t10(int r) { |
| 60 | __asm__("PR3908 %[lf] %[xx] %[li] %[r]" : [r] "+r" (r) : [lf] "mx" (0), [li] "mr" (0), [xx] "x" ((double)(0))); |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 61 | |
Chris Lattner | 29a4071 | 2010-03-04 00:38:16 +0000 | [diff] [blame] | 62 | // CHECK: @t10( |
| 63 | // CHECK:PR3908 $1 $3 $2 $0 |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 64 | } |
Chris Lattner | 4df4ee0 | 2009-05-03 07:27:51 +0000 | [diff] [blame] | 65 | |
Chris Lattner | 4df4ee0 | 2009-05-03 07:27:51 +0000 | [diff] [blame] | 66 | // PR3373 |
| 67 | unsigned t11(signed char input) { |
| 68 | unsigned output; |
| 69 | __asm__("xyz" |
| 70 | : "=a" (output) |
| 71 | : "0" (input)); |
| 72 | return output; |
| 73 | } |
Chris Lattner | ede9d90 | 2009-05-03 07:53:25 +0000 | [diff] [blame] | 74 | |
Chris Lattner | a077b5c | 2009-05-03 08:21:20 +0000 | [diff] [blame] | 75 | // PR3373 |
| 76 | unsigned char t12(unsigned input) { |
| 77 | unsigned char output; |
| 78 | __asm__("xyz" |
| 79 | : "=a" (output) |
| 80 | : "0" (input)); |
| 81 | return output; |
| 82 | } |
Chris Lattner | ede9d90 | 2009-05-03 07:53:25 +0000 | [diff] [blame] | 83 | |
Chris Lattner | 3351f11 | 2009-05-03 08:32:32 +0000 | [diff] [blame] | 84 | unsigned char t13(unsigned input) { |
| 85 | unsigned char output; |
| 86 | __asm__("xyz %1" |
| 87 | : "=a" (output) |
| 88 | : "0" (input)); |
| 89 | return output; |
| 90 | } |
Chris Lattner | ede9d90 | 2009-05-03 07:53:25 +0000 | [diff] [blame] | 91 | |
Chris Lattner | 0bdaa5b | 2009-05-03 09:05:53 +0000 | [diff] [blame] | 92 | struct large { |
| 93 | int x[1000]; |
| 94 | }; |
| 95 | |
| 96 | unsigned long t15(int x, struct large *P) { |
| 97 | __asm__("xyz " |
| 98 | : "=r" (x) |
| 99 | : "m" (*P), "0" (x)); |
| 100 | return x; |
| 101 | } |
| 102 | |
Chris Lattner | 3351f11 | 2009-05-03 08:32:32 +0000 | [diff] [blame] | 103 | // bitfield destination of an asm. |
Chris Lattner | ede9d90 | 2009-05-03 07:53:25 +0000 | [diff] [blame] | 104 | struct S { |
| 105 | int a : 4; |
| 106 | }; |
| 107 | |
Chris Lattner | 3351f11 | 2009-05-03 08:32:32 +0000 | [diff] [blame] | 108 | void t14(struct S *P) { |
Chris Lattner | ede9d90 | 2009-05-03 07:53:25 +0000 | [diff] [blame] | 109 | __asm__("abc %0" : "=r"(P->a) ); |
| 110 | } |
Chris Lattner | 3351f11 | 2009-05-03 08:32:32 +0000 | [diff] [blame] | 111 | |
Chris Lattner | 4053983 | 2009-10-13 04:32:07 +0000 | [diff] [blame] | 112 | // PR4938 |
| 113 | int t16() { |
| 114 | int a,b; |
| 115 | asm ( "nop;" |
| 116 | :"=%c" (a) |
| 117 | : "r" (b) |
| 118 | ); |
| 119 | return 0; |
| 120 | } |
Chris Lattner | b992259 | 2010-03-03 21:52:23 +0000 | [diff] [blame] | 121 | |
| 122 | // PR6475 |
| 123 | void t17() { |
| 124 | int i; |
| 125 | __asm__ ( "nop": "=m"(i)); |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 126 | |
Chris Lattner | b992259 | 2010-03-03 21:52:23 +0000 | [diff] [blame] | 127 | // CHECK: @t17() |
| 128 | // CHECK: call void asm "nop", "=*m, |
| 129 | } |
| 130 | |
Chris Lattner | eeeb49a | 2010-03-03 21:56:57 +0000 | [diff] [blame] | 131 | // <rdar://problem/6841383> |
| 132 | int t18(unsigned data) { |
| 133 | int a, b; |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 134 | |
Chris Lattner | eeeb49a | 2010-03-03 21:56:57 +0000 | [diff] [blame] | 135 | asm("xyz" :"=a"(a), "=d"(b) : "a"(data)); |
| 136 | return a + b; |
| 137 | // CHECK: t18(i32 |
| 138 | // CHECK: = call {{.*}}asm "xyz" |
| 139 | // CHECK-NEXT: extractvalue |
| 140 | // CHECK-NEXT: extractvalue |
| 141 | } |
Chris Lattner | 018b54e | 2010-04-05 18:44:00 +0000 | [diff] [blame] | 142 | |
Chris Lattner | 018b54e | 2010-04-05 18:44:00 +0000 | [diff] [blame] | 143 | // PR6780 |
| 144 | int t19(unsigned data) { |
| 145 | int a, b; |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 146 | |
Chris Lattner | 018b54e | 2010-04-05 18:44:00 +0000 | [diff] [blame] | 147 | asm("x{abc|def|ghi}z" :"=r"(a): "r"(data)); |
| 148 | return a + b; |
| 149 | // CHECK: t19(i32 |
| 150 | // CHECK: = call {{.*}}asm "x$(abc$|def$|ghi$)z" |
| 151 | } |
| 152 | |
Chris Lattner | aab64d0 | 2010-04-23 17:27:29 +0000 | [diff] [blame] | 153 | // PR6845 - Mismatching source/dest fp types. |
| 154 | double t20(double x) { |
| 155 | register long double result; |
| 156 | __asm __volatile ("frndint" : "=t" (result) : "0" (x)); |
| 157 | return result; |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 158 | |
Chris Lattner | aab64d0 | 2010-04-23 17:27:29 +0000 | [diff] [blame] | 159 | // CHECK: @t20 |
| 160 | // CHECK: fpext double {{.*}} to x86_fp80 |
| 161 | // CHECK-NEXT: call x86_fp80 asm sideeffect "frndint" |
| 162 | // CHECK: fptrunc x86_fp80 {{.*}} to double |
| 163 | } |
| 164 | |
| 165 | float t21(long double x) { |
| 166 | register float result; |
| 167 | __asm __volatile ("frndint" : "=t" (result) : "0" (x)); |
| 168 | return result; |
| 169 | // CHECK: @t21 |
| 170 | // CHECK: call x86_fp80 asm sideeffect "frndint" |
| 171 | // CHECK-NEXT: fptrunc x86_fp80 {{.*}} to float |
| 172 | } |
Dale Johannesen | 545be51 | 2010-08-24 22:33:12 +0000 | [diff] [blame] | 173 | |
| 174 | // <rdar://problem/8348447> - accept 'l' constraint |
| 175 | unsigned char t22(unsigned char a, unsigned char b) { |
| 176 | unsigned int la = a; |
| 177 | unsigned int lb = b; |
| 178 | unsigned int bigres; |
| 179 | unsigned char res; |
| 180 | __asm__ ("0:\n1:\n" : [bigres] "=la"(bigres) : [la] "0"(la), [lb] "c"(lb) : |
| 181 | "edx", "cc"); |
| 182 | res = bigres; |
| 183 | return res; |
| 184 | } |
| 185 | |
| 186 | // <rdar://problem/8348447> - accept 'l' constraint |
| 187 | unsigned char t23(unsigned char a, unsigned char b) { |
| 188 | unsigned int la = a; |
| 189 | unsigned int lb = b; |
| 190 | unsigned char res; |
| 191 | __asm__ ("0:\n1:\n" : [res] "=la"(res) : [la] "0"(la), [lb] "c"(lb) : |
| 192 | "edx", "cc"); |
| 193 | return res; |
| 194 | } |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 195 | |
Peter Collingbourne | 93f1322 | 2011-07-29 00:24:50 +0000 | [diff] [blame] | 196 | void *t24(char c) { |
| 197 | void *addr; |
| 198 | // CHECK: @t24 |
| 199 | // CHECK: zext i8 {{.*}} to i32 |
| 200 | // CHECK-NEXT: call i8* asm "foobar" |
| 201 | __asm__ ("foobar" : "=a" (addr) : "0" (c)); |
| 202 | return addr; |
| 203 | } |
| 204 | |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 205 | // PR10299 - fpsr, fpcr |
Eric Christopher | 867a379 | 2011-12-02 02:12:09 +0000 | [diff] [blame] | 206 | void t25(void) |
Eric Christopher | 78b9291 | 2011-07-07 23:11:01 +0000 | [diff] [blame] | 207 | { |
| 208 | __asm__ __volatile__( \ |
| 209 | "finit" \ |
| 210 | : \ |
| 211 | : \ |
| 212 | :"st","st(1)","st(2)","st(3)", \ |
| 213 | "st(4)","st(5)","st(6)","st(7)", \ |
| 214 | "fpsr","fpcr" \ |
| 215 | ); |
| 216 | } |
Eric Christopher | c5f9a01 | 2011-12-02 02:12:16 +0000 | [diff] [blame] | 217 | |
| 218 | // rdar://10510405 - AVX registers |
| 219 | typedef long long __m256i __attribute__((__vector_size__(32))); |
| 220 | void t26 (__m256i *p) { |
| 221 | __asm__ volatile("vmovaps %0, %%ymm0" :: "m" (*(__m256i*)p) : "ymm0"); |
| 222 | } |