John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 1 | // RUN: %clang_cc1 -triple i686 -emit-llvm %s -o - | FileCheck %s |
| 2 | // RUN: %clang_cc1 -triple x86_64 -emit-llvm %s -o - | FileCheck %s |
| 3 | |
| 4 | int mout0; |
| 5 | int min1; |
| 6 | int marray[2]; |
| 7 | double dout0; |
| 8 | double din1; |
| 9 | |
| 10 | // CHECK: @single_R |
| 11 | void single_R() |
| 12 | { |
| 13 | // CHECK: asm "foo $1,$0", "=R,R[[CLOBBERS:[a-zA-Z0-9@%{},~_ ]*\"]](i32 {{[a-zA-Z0-9@%]+}}) |
| 14 | asm("foo %1,%0" : "=R" (mout0) : "R" (min1)); |
| 15 | } |
| 16 | |
| 17 | // CHECK: @single_q |
| 18 | void single_q() |
| 19 | { |
| 20 | // CHECK: asm "foo $1,$0", "=q,q[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 21 | asm("foo %1,%0" : "=q" (mout0) : "q" (min1)); |
| 22 | } |
| 23 | |
| 24 | // CHECK: @single_Q |
| 25 | void single_Q() |
| 26 | { |
| 27 | // CHECK: asm "foo $1,$0", "=Q,Q[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 28 | asm("foo %1,%0" : "=Q" (mout0) : "Q" (min1)); |
| 29 | } |
| 30 | |
| 31 | // CHECK: @single_a |
| 32 | void single_a() |
| 33 | { |
| 34 | // CHECK: asm "foo $1,$0", "={ax},{ax}[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 35 | asm("foo %1,%0" : "=a" (mout0) : "a" (min1)); |
| 36 | } |
| 37 | |
| 38 | // CHECK: @single_b |
| 39 | void single_b() |
| 40 | { |
| 41 | // CHECK: asm "foo $1,$0", "={bx},{bx}[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 42 | asm("foo %1,%0" : "=b" (mout0) : "b" (min1)); |
| 43 | } |
| 44 | |
| 45 | // CHECK: @single_c |
| 46 | void single_c() |
| 47 | { |
| 48 | // CHECK: asm "foo $1,$0", "={cx},{cx}[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 49 | asm("foo %1,%0" : "=c" (mout0) : "c" (min1)); |
| 50 | } |
| 51 | |
| 52 | // CHECK: @single_d |
| 53 | void single_d() |
| 54 | { |
| 55 | // CHECK: asm "foo $1,$0", "={dx},{dx}[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 56 | asm("foo %1,%0" : "=d" (mout0) : "d" (min1)); |
| 57 | } |
| 58 | |
| 59 | // CHECK: @single_S |
| 60 | void single_S() |
| 61 | { |
| 62 | // CHECK: asm "foo $1,$0", "={si},{si}[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 63 | asm("foo %1,%0" : "=S" (mout0) : "S" (min1)); |
| 64 | } |
| 65 | |
| 66 | // CHECK: @single_D |
| 67 | void single_D() |
| 68 | { |
| 69 | // CHECK: asm "foo $1,$0", "={di},{di}[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 70 | asm("foo %1,%0" : "=D" (mout0) : "D" (min1)); |
| 71 | } |
| 72 | |
| 73 | // CHECK: @single_A |
| 74 | void single_A() |
| 75 | { |
| 76 | // CHECK: asm "foo $1,$0", "=A,A[[CLOBBERS]](i32 {{[a-zA-Z0-9@%]+}}) |
| 77 | asm("foo %1,%0" : "=A" (mout0) : "A" (min1)); |
| 78 | } |
| 79 | |
| 80 | // CHECK: @single_f |
| 81 | void single_f() |
| 82 | { |
| 83 | //FIXME: I don't know how to do an 80387 floating point stack register operation, which I think is fp80. |
| 84 | } |
| 85 | |
| 86 | // CHECK: @single_t |
| 87 | void single_t() |
| 88 | { |
| 89 | //FIXME: I don't know how to do an 80387 floating point stack register operation, which I think is fp80. |
| 90 | } |
| 91 | |
| 92 | // CHECK: @single_u |
| 93 | void single_u() |
| 94 | { |
| 95 | //FIXME: I don't know how to do an 80387 floating point stack register operation, which I think is fp80. |
| 96 | } |
| 97 | |
| 98 | // CHECK: @single_y |
| 99 | void single_y() |
| 100 | { |
| 101 | // CHECK: call double asm "foo $1,$0", "=y,y[[CLOBBERS]](double {{[a-zA-Z0-9@%]+}}) |
| 102 | asm("foo %1,%0" : "=y" (dout0) : "y" (din1)); |
| 103 | } |
| 104 | |
| 105 | // CHECK: @single_x |
| 106 | void single_x() |
| 107 | { |
| 108 | // CHECK: asm "foo $1,$0", "=x,x[[CLOBBERS]](double {{[a-zA-Z0-9@%]+}}) |
| 109 | asm("foo %1,%0" : "=x" (dout0) : "x" (din1)); |
| 110 | } |
| 111 | |
| 112 | // CHECK: @single_Y |
| 113 | void single_Y0() |
| 114 | { |
| 115 | // Y constraint currently broken. |
| 116 | //asm("foo %1,%0" : "=Y0" (mout0) : "Y0" (min1)); |
| 117 | //asm("foo %1,%0" : "=Yz" (mout0) : "Yz" (min1)); |
| 118 | //asm("foo %1,%0" : "=Yt" (mout0) : "Yt" (min1)); |
| 119 | //asm("foo %1,%0" : "=Yi" (mout0) : "Yi" (min1)); |
| 120 | //asm("foo %1,%0" : "=Ym" (mout0) : "Ym" (min1)); |
| 121 | } |
| 122 | |
| 123 | // CHECK: @single_I |
| 124 | void single_I() |
| 125 | { |
| 126 | // CHECK: asm "foo $1,$0", "=*m,I[[CLOBBERS]](i32* @mout0, i32 1) |
| 127 | asm("foo %1,%0" : "=m" (mout0) : "I" (1)); |
| 128 | } |
| 129 | |
| 130 | // CHECK: @single_J |
| 131 | void single_J() |
| 132 | { |
| 133 | // CHECK: asm "foo $1,$0", "=*m,J[[CLOBBERS]](i32* @mout0, i32 1) |
| 134 | asm("foo %1,%0" : "=m" (mout0) : "J" (1)); |
| 135 | } |
| 136 | |
| 137 | // CHECK: @single_K |
| 138 | void single_K() |
| 139 | { |
| 140 | // CHECK: asm "foo $1,$0", "=*m,K[[CLOBBERS]](i32* @mout0, i32 1) |
| 141 | asm("foo %1,%0" : "=m" (mout0) : "K" (1)); |
| 142 | } |
| 143 | |
| 144 | // CHECK: @single_L |
| 145 | void single_L() |
| 146 | { |
| 147 | // CHECK: asm "foo $1,$0", "=*m,L[[CLOBBERS]](i32* @mout0, i32 1) |
| 148 | asm("foo %1,%0" : "=m" (mout0) : "L" (1)); |
| 149 | } |
| 150 | |
| 151 | // CHECK: @single_M |
| 152 | void single_M() |
| 153 | { |
| 154 | // CHECK: asm "foo $1,$0", "=*m,M[[CLOBBERS]](i32* @mout0, i32 1) |
| 155 | asm("foo %1,%0" : "=m" (mout0) : "M" (1)); |
| 156 | } |
| 157 | |
| 158 | // CHECK: @single_N |
| 159 | void single_N() |
| 160 | { |
| 161 | // CHECK: asm "foo $1,$0", "=*m,N[[CLOBBERS]](i32* @mout0, i32 1) |
| 162 | asm("foo %1,%0" : "=m" (mout0) : "N" (1)); |
| 163 | } |
| 164 | |
| 165 | // CHECK: @single_G |
| 166 | void single_G() |
| 167 | { |
| 168 | // CHECK: asm "foo $1,$0", "=*m,G[[CLOBBERS]](i32* @mout0, double {{1.[0]+e[+]*[0]+}}) |
| 169 | asm("foo %1,%0" : "=m" (mout0) : "G" (1.0)); |
| 170 | } |
| 171 | |
| 172 | // CHECK: @single_C |
| 173 | void single_C() |
| 174 | { |
| 175 | // CHECK: asm "foo $1,$0", "=*m,C[[CLOBBERS]](i32* @mout0, double {{1.[0]+e[+]*[0]+}}) |
| 176 | asm("foo %1,%0" : "=m" (mout0) : "C" (1.0)); |
| 177 | } |
| 178 | |
| 179 | // CHECK: @single_e |
| 180 | void single_e() |
| 181 | { |
| 182 | // CHECK: asm "foo $1,$0", "=*m,e[[CLOBBERS]](i32* @mout0, i32 1) |
| 183 | asm("foo %1,%0" : "=m" (mout0) : "e" (1)); |
| 184 | } |
| 185 | |
| 186 | // CHECK: @single_Z |
| 187 | void single_Z() |
| 188 | { |
| 189 | // CHECK: asm "foo $1,$0", "=*m,Z[[CLOBBERS]](i32* @mout0, i32 1) |
| 190 | asm("foo %1,%0" : "=m" (mout0) : "Z" (1)); |
| 191 | } |
| 192 | |
| 193 | // CHECK: @multi_R |
| 194 | void multi_R() |
| 195 | { |
| 196 | // CHECK: asm "foo $1,$0", "=*r|R|m,r|R|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 197 | asm("foo %1,%0" : "=r,R,m" (mout0) : "r,R,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 198 | } |
| 199 | |
| 200 | // CHECK: @multi_q |
| 201 | void multi_q() |
| 202 | { |
| 203 | // CHECK: asm "foo $1,$0", "=*r|q|m,r|q|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 204 | asm("foo %1,%0" : "=r,q,m" (mout0) : "r,q,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 205 | } |
| 206 | |
| 207 | // CHECK: @multi_Q |
| 208 | void multi_Q() |
| 209 | { |
| 210 | // CHECK: asm "foo $1,$0", "=*r|Q|m,r|Q|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 211 | asm("foo %1,%0" : "=r,Q,m" (mout0) : "r,Q,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 212 | } |
| 213 | |
| 214 | // CHECK: @multi_a |
| 215 | void multi_a() |
| 216 | { |
| 217 | // CHECK: asm "foo $1,$0", "=*r|{ax}|m,r|{ax}|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 218 | asm("foo %1,%0" : "=r,a,m" (mout0) : "r,a,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 219 | } |
| 220 | |
| 221 | // CHECK: @multi_b |
| 222 | void multi_b() |
| 223 | { |
| 224 | // CHECK: asm "foo $1,$0", "=*r|{bx}|m,r|{bx}|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 225 | asm("foo %1,%0" : "=r,b,m" (mout0) : "r,b,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 226 | } |
| 227 | |
| 228 | // CHECK: @multi_c |
| 229 | void multi_c() |
| 230 | { |
| 231 | // CHECK: asm "foo $1,$0", "=*r|{cx}|m,r|{cx}|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 232 | asm("foo %1,%0" : "=r,c,m" (mout0) : "r,c,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 233 | } |
| 234 | |
| 235 | // CHECK: @multi_d |
| 236 | void multi_d() |
| 237 | { |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 238 | // CHECK: asm "foo $1,$0", "=*r|{dx}|m,r|{dx}|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
| 239 | asm("foo %1,%0" : "=r,d,m" (mout0) : "r,d,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 240 | } |
| 241 | |
| 242 | // CHECK: @multi_S |
| 243 | void multi_S() |
| 244 | { |
| 245 | // CHECK: asm "foo $1,$0", "=*r|{si}|m,r|{si}|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 246 | asm("foo %1,%0" : "=r,S,m" (mout0) : "r,S,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 247 | } |
| 248 | |
| 249 | // CHECK: @multi_D |
| 250 | void multi_D() |
| 251 | { |
| 252 | // CHECK: asm "foo $1,$0", "=*r|{di}|m,r|{di}|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 253 | asm("foo %1,%0" : "=r,D,m" (mout0) : "r,D,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 254 | } |
| 255 | |
| 256 | // CHECK: @multi_A |
| 257 | void multi_A() |
| 258 | { |
| 259 | // CHECK: asm "foo $1,$0", "=*r|A|m,r|A|m[[CLOBBERS]](i32* @mout0, i32 {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 260 | asm("foo %1,%0" : "=r,A,m" (mout0) : "r,A,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 261 | } |
| 262 | |
| 263 | // CHECK: @multi_f |
| 264 | void multi_f() |
| 265 | { |
| 266 | //FIXME: I don't know how to do an 80387 floating point stack register operation, which I think is fp80. |
| 267 | } |
| 268 | |
| 269 | // CHECK: @multi_t |
| 270 | void multi_t() |
| 271 | { |
| 272 | //FIXME: I don't know how to do an 80387 floating point stack register operation, which I think is fp80. |
| 273 | } |
| 274 | |
| 275 | // CHECK: @multi_u |
| 276 | void multi_u() |
| 277 | { |
| 278 | //FIXME: I don't know how to do an 80387 floating point stack register operation, which I think is fp80. |
| 279 | } |
| 280 | |
| 281 | // CHECK: @multi_y |
| 282 | void multi_y() |
| 283 | { |
| 284 | // CHECK: asm "foo $1,$0", "=*r|y|m,r|y|m[[CLOBBERS]](double* @dout0, double {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 285 | asm("foo %1,%0" : "=r,y,m" (dout0) : "r,y,m" (din1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 286 | } |
| 287 | |
| 288 | // CHECK: @multi_x |
| 289 | void multi_x() |
| 290 | { |
| 291 | // CHECK: asm "foo $1,$0", "=*r|x|m,r|x|m[[CLOBBERS]](double* @dout0, double {{[a-zA-Z0-9@%]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 292 | asm("foo %1,%0" : "=r,x,m" (dout0) : "r,x,m" (din1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 293 | } |
| 294 | |
| 295 | // CHECK: @multi_Y |
| 296 | void multi_Y0() |
| 297 | { |
| 298 | // Y constraint currently broken. |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 299 | //asm("foo %1,%0" : "=r,Y0,m" (mout0) : "r,Y0,m" (min1)); |
| 300 | //asm("foo %1,%0" : "=r,Yz,m" (mout0) : "r,Yz,m" (min1)); |
| 301 | //asm("foo %1,%0" : "=r,Yt,m" (mout0) : "r,Yt,m" (min1)); |
| 302 | //asm("foo %1,%0" : "=r,Yi,m" (mout0) : "r,Yi,m" (min1)); |
| 303 | //asm("foo %1,%0" : "=r,Ym,m" (mout0) : "r,Ym,m" (min1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 304 | } |
| 305 | |
| 306 | // CHECK: @multi_I |
| 307 | void multi_I() |
| 308 | { |
| 309 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|I|m[[CLOBBERS]](i32* @mout0, i32 1) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 310 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,I,m" (1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 311 | } |
| 312 | |
| 313 | // CHECK: @multi_J |
| 314 | void multi_J() |
| 315 | { |
| 316 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|J|m[[CLOBBERS]](i32* @mout0, i32 1) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 317 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,J,m" (1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 318 | } |
| 319 | |
| 320 | // CHECK: @multi_K |
| 321 | void multi_K() |
| 322 | { |
| 323 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|K|m[[CLOBBERS]](i32* @mout0, i32 1) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 324 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,K,m" (1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 325 | } |
| 326 | |
| 327 | // CHECK: @multi_L |
| 328 | void multi_L() |
| 329 | { |
| 330 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|L|m[[CLOBBERS]](i32* @mout0, i32 1) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 331 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,L,m" (1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 332 | } |
| 333 | |
| 334 | // CHECK: @multi_M |
| 335 | void multi_M() |
| 336 | { |
| 337 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|M|m[[CLOBBERS]](i32* @mout0, i32 1) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 338 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,M,m" (1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 339 | } |
| 340 | |
| 341 | // CHECK: @multi_N |
| 342 | void multi_N() |
| 343 | { |
| 344 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|N|m[[CLOBBERS]](i32* @mout0, i32 1) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 345 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,N,m" (1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 346 | } |
| 347 | |
| 348 | // CHECK: @multi_G |
| 349 | void multi_G() |
| 350 | { |
| 351 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|G|m[[CLOBBERS]](i32* @mout0, double {{1.[0]+e[+]*[0]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 352 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,G,m" (1.0)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 353 | } |
| 354 | |
| 355 | // CHECK: @multi_C |
| 356 | void multi_C() |
| 357 | { |
| 358 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|C|m[[CLOBBERS]](i32* @mout0, double {{1.[0]+e[+]*[0]+}}) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 359 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,C,m" (1.0)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 360 | } |
| 361 | |
| 362 | // CHECK: @multi_e |
| 363 | void multi_e() |
| 364 | { |
| 365 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|e|m[[CLOBBERS]](i32* @mout0, i32 1) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 366 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,e,m" (1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 367 | } |
| 368 | |
| 369 | // CHECK: @multi_Z |
| 370 | void multi_Z() |
| 371 | { |
| 372 | // CHECK: asm "foo $1,$0", "=*r|m|m,r|Z|m[[CLOBBERS]](i32* @mout0, i32 1) |
John Thompson | 8d8420e | 2011-03-24 18:51:57 +0000 | [diff] [blame^] | 373 | asm("foo %1,%0" : "=r,m,m" (mout0) : "r,Z,m" (1)); |
John Thompson | 926ee13 | 2010-11-02 23:03:52 +0000 | [diff] [blame] | 374 | } |