OLD | NEW |
(Empty) | |
| 1 ; This tests parsing NaCl intrinsics not related to atomic operations. |
| 2 |
| 3 ; RUN: llvm-as < %s | pnacl-freeze -allow-local-symbol-tables \ |
| 4 ; RUN: | %llvm2ice -notranslate -verbose=inst -build-on-read \ |
| 5 ; RUN: -allow-pnacl-reader-error-recovery \ |
| 6 ; RUN: -allow-local-symbol-tables \ |
| 7 ; RUN: | FileCheck %s |
| 8 |
| 9 declare i8* @llvm.nacl.read.tp() |
| 10 declare void @llvm.memcpy.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1) |
| 11 declare void @llvm.memmove.p0i8.p0i8.i32(i8*, i8*, i32, i32, i1) |
| 12 declare void @llvm.memset.p0i8.i32(i8*, i8, i32, i32, i1) |
| 13 declare void @llvm.nacl.longjmp(i8*, i32) |
| 14 declare i32 @llvm.nacl.setjmp(i8*) |
| 15 declare float @llvm.sqrt.f32(float) |
| 16 declare double @llvm.sqrt.f64(double) |
| 17 declare void @llvm.trap() |
| 18 declare i16 @llvm.bswap.i16(i16) |
| 19 declare i32 @llvm.bswap.i32(i32) |
| 20 declare i64 @llvm.bswap.i64(i64) |
| 21 declare i32 @llvm.ctlz.i32(i32, i1) |
| 22 declare i64 @llvm.ctlz.i64(i64, i1) |
| 23 declare i32 @llvm.cttz.i32(i32, i1) |
| 24 declare i64 @llvm.cttz.i64(i64, i1) |
| 25 declare i32 @llvm.ctpop.i32(i32) |
| 26 declare i64 @llvm.ctpop.i64(i64) |
| 27 declare i8* @llvm.stacksave() |
| 28 declare void @llvm.stackrestore(i8*) |
| 29 |
| 30 define i32 @test_nacl_read_tp() { |
| 31 entry: |
| 32 %ptr = call i8* @llvm.nacl.read.tp() |
| 33 %__1 = ptrtoint i8* %ptr to i32 |
| 34 ret i32 %__1 |
| 35 } |
| 36 |
| 37 ; CHECK: define i32 @test_nacl_read_tp() { |
| 38 ; CHECK-NEXT: entry: |
| 39 ; CHECK-NEXT: %ptr = call i32 @llvm.nacl.read.tp() |
| 40 ; CHECK-NEXT: ret i32 %ptr |
| 41 ; CHECK-NEXT: } |
| 42 |
| 43 define void @test_memcpy(i32 %iptr_dst, i32 %iptr_src, i32 %len) { |
| 44 entry: |
| 45 %dst = inttoptr i32 %iptr_dst to i8* |
| 46 %src = inttoptr i32 %iptr_src to i8* |
| 47 call void @llvm.memcpy.p0i8.p0i8.i32(i8* %dst, i8* %src, |
| 48 i32 %len, i32 1, i1 false) |
| 49 ret void |
| 50 } |
| 51 |
| 52 ; CHECK-NEXT: define void @test_memcpy(i32 %iptr_dst, i32 %iptr_src, i32 %len) { |
| 53 ; CHECK-NEXT: entry: |
| 54 ; CHECK-NEXT: call void @llvm.memcpy.p0i8.p0i8.i32(i32 %iptr_dst, i32 %iptr_sr
c, i32 %len, i32 1, i1 false) |
| 55 ; CHECK-NEXT: ret void |
| 56 ; CHECK-NEXT: } |
| 57 |
| 58 define void @test_memmove(i32 %iptr_dst, i32 %iptr_src, i32 %len) { |
| 59 entry: |
| 60 %dst = inttoptr i32 %iptr_dst to i8* |
| 61 %src = inttoptr i32 %iptr_src to i8* |
| 62 call void @llvm.memmove.p0i8.p0i8.i32(i8* %dst, i8* %src, |
| 63 i32 %len, i32 1, i1 false) |
| 64 ret void |
| 65 } |
| 66 |
| 67 ; CHECK-NEXT: define void @test_memmove(i32 %iptr_dst, i32 %iptr_src, i32 %len)
{ |
| 68 ; CHECK-NEXT: entry: |
| 69 ; CHECK-NEXT: call void @llvm.memmove.p0i8.p0i8.i32(i32 %iptr_dst, i32 %iptr_s
rc, i32 %len, i32 1, i1 false) |
| 70 ; CHECK-NEXT: ret void |
| 71 ; CHECK-NEXT: } |
| 72 |
| 73 define void @test_memset(i32 %iptr_dst, i32 %wide_val, i32 %len) { |
| 74 entry: |
| 75 %val = trunc i32 %wide_val to i8 |
| 76 %dst = inttoptr i32 %iptr_dst to i8* |
| 77 call void @llvm.memset.p0i8.i32(i8* %dst, i8 %val, |
| 78 i32 %len, i32 1, i1 false) |
| 79 ret void |
| 80 } |
| 81 |
| 82 ; CHECK-NEXT: define void @test_memset(i32 %iptr_dst, i32 %wide_val, i32 %len) { |
| 83 ; CHECK-NEXT: entry: |
| 84 ; CHECK-NEXT: %val = trunc i32 %wide_val to i8 |
| 85 ; CHECK-NEXT: call void @llvm.memset.p0i8.i32(i32 %iptr_dst, i8 %val, i32 %len
, i32 1, i1 false) |
| 86 ; CHECK-NEXT: ret void |
| 87 ; CHECK-NEXT: } |
| 88 |
| 89 define i32 @test_setjmplongjmp(i32 %iptr_env) { |
| 90 entry: |
| 91 %env = inttoptr i32 %iptr_env to i8* |
| 92 %i = call i32 @llvm.nacl.setjmp(i8* %env) |
| 93 %r1 = icmp eq i32 %i, 0 |
| 94 br i1 %r1, label %Zero, label %NonZero |
| 95 Zero: |
| 96 ; Redundant inttoptr, to make --pnacl cast-eliding/re-insertion happy. |
| 97 %env2 = inttoptr i32 %iptr_env to i8* |
| 98 call void @llvm.nacl.longjmp(i8* %env2, i32 1) |
| 99 ret i32 0 |
| 100 NonZero: |
| 101 ret i32 1 |
| 102 } |
| 103 |
| 104 ; CHECK-NEXT: define i32 @test_setjmplongjmp(i32 %iptr_env) { |
| 105 ; CHECK-NEXT: entry: |
| 106 ; CHECK-NEXT: %i = call i32 @llvm.nacl.setjmp(i32 %iptr_env) |
| 107 ; CHECK-NEXT: %r1 = icmp eq i32 %i, 0 |
| 108 ; CHECK-NEXT: br i1 %r1, label %Zero, label %NonZero |
| 109 ; CHECK-NEXT: Zero: |
| 110 ; CHECK-NEXT: call void @llvm.nacl.longjmp(i32 %iptr_env, i32 1) |
| 111 ; CHECK-NEXT: ret i32 0 |
| 112 ; CHECK-NEXT: NonZero: |
| 113 ; CHECK-NEXT: ret i32 1 |
| 114 ; CHECK-NEXT: } |
| 115 |
| 116 define float @test_sqrt_float(float %x, i32 %iptr) { |
| 117 entry: |
| 118 %r = call float @llvm.sqrt.f32(float %x) |
| 119 %r2 = call float @llvm.sqrt.f32(float %r) |
| 120 %r3 = call float @llvm.sqrt.f32(float -0.0) |
| 121 %r4 = fadd float %r2, %r3 |
| 122 ret float %r4 |
| 123 } |
| 124 |
| 125 ; CHECK-NEXT: define float @test_sqrt_float(float %x, i32 %iptr) { |
| 126 ; CHECK-NEXT: entry: |
| 127 ; CHECK-NEXT: %r = call float @llvm.sqrt.f32(float %x) |
| 128 ; CHECK-NEXT: %r2 = call float @llvm.sqrt.f32(float %r) |
| 129 ; CHECK-NEXT: %r3 = call float @llvm.sqrt.f32(float -0.000000e+00) |
| 130 ; CHECK-NEXT: %r4 = fadd float %r2, %r3 |
| 131 ; CHECK-NEXT: ret float %r4 |
| 132 ; CHECK-NEXT: } |
| 133 |
| 134 define double @test_sqrt_double(double %x, i32 %iptr) { |
| 135 entry: |
| 136 %r = call double @llvm.sqrt.f64(double %x) |
| 137 %r2 = call double @llvm.sqrt.f64(double %r) |
| 138 %r3 = call double @llvm.sqrt.f64(double -0.0) |
| 139 %r4 = fadd double %r2, %r3 |
| 140 ret double %r4 |
| 141 } |
| 142 |
| 143 ; CHECK-NEXT: define double @test_sqrt_double(double %x, i32 %iptr) { |
| 144 ; CHECK-NEXT: entry: |
| 145 ; CHECK-NEXT: %r = call double @llvm.sqrt.f64(double %x) |
| 146 ; CHECK-NEXT: %r2 = call double @llvm.sqrt.f64(double %r) |
| 147 ; CHECK-NEXT: %r3 = call double @llvm.sqrt.f64(double -0.000000e+00) |
| 148 ; CHECK-NEXT: %r4 = fadd double %r2, %r3 |
| 149 ; CHECK-NEXT: ret double %r4 |
| 150 ; CHECK-NEXT: } |
| 151 |
| 152 define i32 @test_trap(i32 %br) { |
| 153 entry: |
| 154 %r1 = icmp eq i32 %br, 0 |
| 155 br i1 %r1, label %Zero, label %NonZero |
| 156 Zero: |
| 157 call void @llvm.trap() |
| 158 unreachable |
| 159 NonZero: |
| 160 ret i32 1 |
| 161 } |
| 162 |
| 163 ; CHECK-NEXT: define i32 @test_trap(i32 %br) { |
| 164 ; CHECK-NEXT: entry: |
| 165 ; CHECK-NEXT: %r1 = icmp eq i32 %br, 0 |
| 166 ; CHECK-NEXT: br i1 %r1, label %Zero, label %NonZero |
| 167 ; CHECK-NEXT: Zero: |
| 168 ; CHECK-NEXT: call void @llvm.trap() |
| 169 ; CHECK-NEXT: unreachable |
| 170 ; CHECK-NEXT: NonZero: |
| 171 ; CHECK-NEXT: ret i32 1 |
| 172 ; CHECK-NEXT: } |
| 173 |
| 174 define i32 @test_bswap_16(i32 %x) { |
| 175 entry: |
| 176 %x_trunc = trunc i32 %x to i16 |
| 177 %r = call i16 @llvm.bswap.i16(i16 %x_trunc) |
| 178 %r_zext = zext i16 %r to i32 |
| 179 ret i32 %r_zext |
| 180 } |
| 181 |
| 182 ; CHECK-NEXT: define i32 @test_bswap_16(i32 %x) { |
| 183 ; CHECK-NEXT: entry: |
| 184 ; CHECK-NEXT: %x_trunc = trunc i32 %x to i16 |
| 185 ; CHECK-NEXT: %r = call i16 @llvm.bswap.i16(i16 %x_trunc) |
| 186 ; CHECK-NEXT: %r_zext = zext i16 %r to i32 |
| 187 ; CHECK-NEXT: ret i32 %r_zext |
| 188 ; CHECK-NEXT: } |
| 189 |
| 190 define i32 @test_bswap_32(i32 %x) { |
| 191 entry: |
| 192 %r = call i32 @llvm.bswap.i32(i32 %x) |
| 193 ret i32 %r |
| 194 } |
| 195 |
| 196 ; CHECK-NEXT: define i32 @test_bswap_32(i32 %x) { |
| 197 ; CHECK-NEXT: entry: |
| 198 ; CHECK-NEXT: %r = call i32 @llvm.bswap.i32(i32 %x) |
| 199 ; CHECK-NEXT: ret i32 %r |
| 200 ; CHECK-NEXT: } |
| 201 |
| 202 define i64 @test_bswap_64(i64 %x) { |
| 203 entry: |
| 204 %r = call i64 @llvm.bswap.i64(i64 %x) |
| 205 ret i64 %r |
| 206 } |
| 207 |
| 208 ; CHECK-NEXT: define i64 @test_bswap_64(i64 %x) { |
| 209 ; CHECK-NEXT: entry: |
| 210 ; CHECK-NEXT: %r = call i64 @llvm.bswap.i64(i64 %x) |
| 211 ; CHECK-NEXT: ret i64 %r |
| 212 ; CHECK-NEXT: } |
| 213 |
| 214 define i32 @test_ctlz_32(i32 %x) { |
| 215 entry: |
| 216 %r = call i32 @llvm.ctlz.i32(i32 %x, i1 false) |
| 217 ret i32 %r |
| 218 } |
| 219 |
| 220 ; CHECK-NEXT: define i32 @test_ctlz_32(i32 %x) { |
| 221 ; CHECK-NEXT: entry: |
| 222 ; CHECK-NEXT: %r = call i32 @llvm.ctlz.i32(i32 %x, i1 false) |
| 223 ; CHECK-NEXT: ret i32 %r |
| 224 ; CHECK-NEXT: } |
| 225 |
| 226 define i64 @test_ctlz_64(i64 %x) { |
| 227 entry: |
| 228 %r = call i64 @llvm.ctlz.i64(i64 %x, i1 false) |
| 229 ret i64 %r |
| 230 } |
| 231 |
| 232 ; CHECK-NEXT: define i64 @test_ctlz_64(i64 %x) { |
| 233 ; CHECK-NEXT: entry: |
| 234 ; CHECK-NEXT: %r = call i64 @llvm.ctlz.i64(i64 %x, i1 false) |
| 235 ; CHECK-NEXT: ret i64 %r |
| 236 ; CHECK-NEXT: } |
| 237 |
| 238 define i32 @test_cttz_32(i32 %x) { |
| 239 entry: |
| 240 %r = call i32 @llvm.cttz.i32(i32 %x, i1 false) |
| 241 ret i32 %r |
| 242 } |
| 243 |
| 244 ; CHECK-NEXT: define i32 @test_cttz_32(i32 %x) { |
| 245 ; CHECK-NEXT: entry: |
| 246 ; CHECK-NEXT: %r = call i32 @llvm.cttz.i32(i32 %x, i1 false) |
| 247 ; CHECK-NEXT: ret i32 %r |
| 248 ; CHECK-NEXT: } |
| 249 |
| 250 define i64 @test_cttz_64(i64 %x) { |
| 251 entry: |
| 252 %r = call i64 @llvm.cttz.i64(i64 %x, i1 false) |
| 253 ret i64 %r |
| 254 } |
| 255 |
| 256 ; CHECK-NEXT: define i64 @test_cttz_64(i64 %x) { |
| 257 ; CHECK-NEXT: entry: |
| 258 ; CHECK-NEXT: %r = call i64 @llvm.cttz.i64(i64 %x, i1 false) |
| 259 ; CHECK-NEXT: ret i64 %r |
| 260 ; CHECK-NEXT: } |
| 261 |
| 262 define i32 @test_popcount_32(i32 %x) { |
| 263 entry: |
| 264 %r = call i32 @llvm.ctpop.i32(i32 %x) |
| 265 ret i32 %r |
| 266 } |
| 267 |
| 268 ; CHECK-NEXT: define i32 @test_popcount_32(i32 %x) { |
| 269 ; CHECK-NEXT: entry: |
| 270 ; CHECK-NEXT: %r = call i32 @llvm.ctpop.i32(i32 %x) |
| 271 ; CHECK-NEXT: ret i32 %r |
| 272 ; CHECK-NEXT: } |
| 273 |
| 274 define i64 @test_popcount_64(i64 %x) { |
| 275 entry: |
| 276 %r = call i64 @llvm.ctpop.i64(i64 %x) |
| 277 ret i64 %r |
| 278 } |
| 279 |
| 280 ; CHECK-NEXT: define i64 @test_popcount_64(i64 %x) { |
| 281 ; CHECK-NEXT: entry: |
| 282 ; CHECK-NEXT: %r = call i64 @llvm.ctpop.i64(i64 %x) |
| 283 ; CHECK-NEXT: ret i64 %r |
| 284 ; CHECK-NEXT: } |
| 285 |
| 286 define void @test_stacksave_noalloca() { |
| 287 entry: |
| 288 %sp = call i8* @llvm.stacksave() |
| 289 call void @llvm.stackrestore(i8* %sp) |
| 290 ret void |
| 291 } |
| 292 |
| 293 ; CHECK-NEXT: define void @test_stacksave_noalloca() { |
| 294 ; CHECK-NEXT: entry: |
| 295 ; CHECK-NEXT: %sp = call i32 @llvm.stacksave() |
| 296 ; CHECK-NEXT: call void @llvm.stackrestore(i32 %sp) |
| 297 ; CHECK-NEXT: ret void |
| 298 ; CHECK-NEXT: } |
| 299 |
| 300 declare i32 @foo(i32 %x) |
| 301 |
| 302 define void @test_stacksave_multiple(i32 %x) { |
| 303 entry: |
| 304 %x_4 = mul i32 %x, 4 |
| 305 %sp1 = call i8* @llvm.stacksave() |
| 306 %tmp1 = alloca i8, i32 %x_4, align 4 |
| 307 |
| 308 %sp2 = call i8* @llvm.stacksave() |
| 309 %tmp2 = alloca i8, i32 %x_4, align 4 |
| 310 |
| 311 %y = call i32 @foo(i32 %x) |
| 312 |
| 313 %sp3 = call i8* @llvm.stacksave() |
| 314 %tmp3 = alloca i8, i32 %x_4, align 4 |
| 315 |
| 316 %__9 = bitcast i8* %tmp1 to i32* |
| 317 store i32 %y, i32* %__9, align 1 |
| 318 |
| 319 %__10 = bitcast i8* %tmp2 to i32* |
| 320 store i32 %x, i32* %__10, align 1 |
| 321 |
| 322 %__11 = bitcast i8* %tmp3 to i32* |
| 323 store i32 %x, i32* %__11, align 1 |
| 324 |
| 325 call void @llvm.stackrestore(i8* %sp1) |
| 326 ret void |
| 327 } |
| 328 |
| 329 ; CHECK-NEXT: define void @test_stacksave_multiple(i32 %x) { |
| 330 ; CHECK-NEXT: entry: |
| 331 ; CHECK-NEXT: %x_4 = mul i32 %x, 4 |
| 332 ; CHECK-NEXT: %sp1 = call i32 @llvm.stacksave() |
| 333 ; CHECK-NEXT: %tmp1 = alloca i8, i32 %x_4, align 4 |
| 334 ; CHECK-NEXT: %sp2 = call i32 @llvm.stacksave() |
| 335 ; CHECK-NEXT: %tmp2 = alloca i8, i32 %x_4, align 4 |
| 336 ; CHECK-NEXT: %y = call i32 @foo(i32 %x) |
| 337 ; CHECK-NEXT: %sp3 = call i32 @llvm.stacksave() |
| 338 ; CHECK-NEXT: %tmp3 = alloca i8, i32 %x_4, align 4 |
| 339 ; CHECK-NEXT: store i32 %y, i32* %tmp1, align 1 |
| 340 ; CHECK-NEXT: store i32 %x, i32* %tmp2, align 1 |
| 341 ; CHECK-NEXT: store i32 %x, i32* %tmp3, align 1 |
| 342 ; CHECK-NEXT: call void @llvm.stackrestore(i32 %sp1) |
| 343 ; CHECK-NEXT: ret void |
| 344 ; CHECK-NEXT: } |
| 345 |
OLD | NEW |