| /minix3/external/bsd/llvm/dist/llvm/test/CodeGen/Generic/ |
| H A D | i128-addsub.ll | 5 %tmp1 = zext i64 %AL to i128 ; <i128> [#uses=1]
6 %tmp23 = zext i64 %AH to i128 ; <i128> [#uses=1]
7 %tmp4 = shl i128 %tmp23, 64 ; <i128> [#uses=1]
8 %tmp5 = or i128 %tmp4, %tmp1 ; <i128> [#uses=1]
9 %tmp67 = zext i64 %BL to i128 ; <i128> [#uses=1]
10 %tmp89 = zext i64 %BH to i128 ; <i128> [#uses=1]
11 %tmp11 = shl i128 %tmp89, 64 ; <i128> [#uses=1]
12 %tmp12 = or i128 %tmp11, %tmp67 ; <i128> [#uses=1]
13 %tmp15 = add i128 %tmp12, %tmp5 ; <i128> [#uses=2]
14 %tmp1617 = trunc i128 %tmp15 to i64 ; <i64> [#uses=1]
[all …]
|
| /minix3/external/bsd/llvm/dist/llvm/test/CodeGen/X86/ |
| H A D | cmpxchg-i128-i1.ll | 3 define i1 @try_cmpxchg(i128* %addr, i128 %desired, i128 %new) {
9 %pair = cmpxchg i128* %addr, i128 %desired, i128 %new seq_cst seq_cst
10 %success = extractvalue { i128, i1 } %pair, 1
14 define void @cmpxchg_flow(i128* %addr, i128 %desired, i128 %new) {
20 %pair = cmpxchg i128* %addr, i128 %desired, i128 %new seq_cst seq_cst
21 %success = extractvalue { i128, i1 } %pair, 1
34 define i1 @cmpxchg_arithcmp(i128* %addr, i128 %desired, i128 %new) {
39 %pair = cmpxchg i128* %addr, i128 %desired, i128 %new seq_cst seq_cst
40 %oldval = extractvalue { i128, i1 } %pair, 0
41 %success = icmp sge i128 %oldval, %desired
[all …]
|
| H A D | muloti.ll | 3 %1 = type { i128, i1 }
8 %tmp16 = zext i64 %a.coerce0 to i128
9 %tmp11 = zext i64 %a.coerce1 to i128
10 %tmp12 = shl nuw i128 %tmp11, 64
11 %ins14 = or i128 %tmp12, %tmp16
12 %tmp6 = zext i64 %b.coerce0 to i128
13 %tmp3 = zext i64 %b.coerce1 to i128
14 %tmp4 = shl nuw i128 %tmp3, 64
15 %ins = or i128 %tmp4, %tmp6
16 %0 = tail call %1 @llvm.smul.with.overflow.i128(i128 %ins14, i128 %ins)
[all …]
|
| H A D | nocx16.ll | 2 define void @test(i128* %a) nounwind {
5 %0 = cmpxchg i128* %a, i128 1, i128 1 seq_cst seq_cst
7 %1 = atomicrmw xchg i128* %a, i128 1 seq_cst
9 %2 = atomicrmw add i128* %a, i128 1 seq_cst
11 %3 = atomicrmw sub i128* %a, i128 1 seq_cst
13 %4 = atomicrmw and i128* %a, i128 1 seq_cst
15 %5 = atomicrmw nand i128* %a, i128 1 seq_cst
17 %6 = atomicrmw or i128* %a, i128 1 seq_cst
19 %7 = atomicrmw xor i128* %a, i128 1 seq_cst
|
| H A D | atomic128.ll | 3 @var = global i128 0
5 define i128 @val_compare_and_swap(i128* %p, i128 %oldval, i128 %newval) {
13 %pair = cmpxchg i128* %p, i128 %oldval, i128 %newval acquire acquire
14 %val = extractvalue { i128, i1 } %pair, 0
15 ret i128 %val
18 define void @fetch_and_nand(i128* %p, i128 %bits) {
38 %val = atomicrmw nand i128* %p, i128 %bits release
39 store i128 %val, i128* @var, align 16
43 define void @fetch_and_or(i128* %p, i128 %bits) {
62 %val = atomicrmw or i128* %p, i128 %bits seq_cst
[all …]
|
| H A D | 2009-03-09-APIntCrash.ll | 10 %srcval18 = load i128* null, align 8 ; <i128> [#uses=1]
11 %tmp15 = lshr i128 %srcval18, 64 ; <i128> [#uses=1]
12 %tmp9 = mul i128 %tmp15, 18446744073709551616000 ; <i128> [#uses=1]
16 %retval.0 = phi i128 [ %tmp9, %if.then ], [ undef, %entry ] ; <i128> [#uses=0]
20 define i128 @test(i128 %arg) nounwind {
21 %A = shl i128 1, 92
22 %B = sub i128 0, %A
23 %C = mul i128 %arg, %B
24 ret i128 %C ;; should codegen to neg(shift)
|
| H A D | i128-sdiv.ll | 5 define i128 @test1(i128 %x) {
8 %tmp = sdiv i128 %x, 73786976294838206464
9 ret i128 %tmp
12 define i128 @test2(i128 %x) {
15 %tmp = sdiv i128 %x, -73786976294838206464
16 ret i128 %tmp
19 define i128 @test3(i128 %x) {
22 %tmp = sdiv i128 %x, -73786976294838206467
23 ret i128 %tmp
|
| H A D | extmul128.ll | 3 define i128 @i64_sext_i128(i64 %a, i64 %b) {
4 %aa = sext i64 %a to i128
5 %bb = sext i64 %b to i128
6 %cc = mul i128 %aa, %bb
7 ret i128 %cc
9 define i128 @i64_zext_i128(i64 %a, i64 %b) {
10 %aa = zext i64 %a to i128
11 %bb = zext i64 %b to i128
12 %cc = mul i128 %aa, %bb
13 ret i128 %cc
|
| /minix3/external/bsd/llvm/dist/llvm/test/CodeGen/SystemZ/ |
| H A D | int-sub-05.ll | 6 declare i128 *@foo()
9 define void @f1(i128 *%ptr, i64 %high, i64 %low) {
14 %a = load i128 *%ptr
15 %highx = zext i64 %high to i128
16 %lowx = zext i64 %low to i128
17 %bhigh = shl i128 %highx, 64
18 %b = or i128 %bhigh, %lowx
19 %sub = sub i128 %a, %b
20 store i128 %sub, i128 *%ptr
30 %bptr = inttoptr i64 %addr to i128 *
[all …]
|
| H A D | int-add-08.ll | 6 declare i128 *@foo()
9 define void @f1(i128 *%ptr) {
14 %value = load i128 *%ptr
15 %add = add i128 %value, %value
16 store i128 %add, i128 *%ptr
22 define void @f2(i128 *%aptr, i64 %addr) {
27 %bptr = inttoptr i64 %addr to i128 *
28 %a = load volatile i128 *%aptr
29 %b = load i128 *%bptr
30 %add = add i128 %a, %b
[all …]
|
| H A D | int-add-10.ll | 7 define void @f1(i128 *%aptr, i32 %b) {
12 %a = load i128 *%aptr
13 %xor = xor i128 %a, 127
14 %bext = zext i32 %b to i128
15 %add = add i128 %xor, %bext
16 store i128 %add, i128 *%aptr
21 define void @f2(i128 *%aptr, i64 %b) {
26 %a = load i128 *%aptr
27 %xor = xor i128 %a, 127
29 %bext = zext i32 %trunc to i128
[all …]
|
| H A D | int-sub-06.ll | 7 define void @f1(i128 *%aptr, i32 %b) {
12 %a = load i128 *%aptr
13 %xor = xor i128 %a, 127
14 %bext = zext i32 %b to i128
15 %sub = sub i128 %xor, %bext
16 store i128 %sub, i128 *%aptr
21 define void @f2(i128 *%aptr, i64 %b) {
26 %a = load i128 *%aptr
27 %xor = xor i128 %a, 127
29 %bext = zext i32 %trunc to i128
[all …]
|
| H A D | int-mul-08.ll | 1 ; Test high-part i64->i128 multiplications.
13 %ax = zext i64 %a to i128
14 %bx = zext i64 %b to i128
15 %mulx = mul i128 %ax, %bx
16 %highx = lshr i128 %mulx, 64
17 %high = trunc i128 %highx to i64
33 %ax = sext i64 %a to i128
34 %bx = sext i64 %b to i128
35 %mulx = mul i128 %ax, %bx
36 %highx = lshr i128 %mulx, 64
[all …]
|
| H A D | int-add-09.ll | 7 define void @f1(i128 *%aptr) {
12 %a = load i128 *%aptr
13 %xor = xor i128 %a, 128
14 %add = add i128 %xor, 1
15 store i128 %add, i128 *%aptr
20 define void @f2(i128 *%aptr) {
25 %a = load i128 *%aptr
26 %xor = xor i128 %a, 128
27 %add = add i128 %xor, 4294967295
28 store i128 %add, i128 *%aptr
[all …]
|
| H A D | int-add-16.ll | 13 %x = bitcast <2 x i64> %x2 to i128
15 %y = bitcast <2 x i64> %y2 to i128
16 %add = add i128 %x, %y
17 %addv = bitcast i128 %add to <2 x i64>
25 define void @f2(i64 %a, i64 %b, i128 *%ptr) {
32 %x = bitcast <2 x i64> %x2 to i128
33 %add = add i128 %x, 1
34 store i128 %add, i128 *%ptr
39 define void @f3(i64 %a, i64 %b, i128 *%ptr) {
46 %x = bitcast <2 x i64> %x2 to i128
[all …]
|
| /minix3/external/bsd/llvm/dist/llvm/test/CodeGen/PowerPC/ |
| H A D | shift128.ll | 3 define i128 @foo_lshr(i128 %x, i128 %y) {
4 %r = lshr i128 %x, %y
5 ret i128 %r
7 define i128 @foo_ashr(i128 %x, i128 %y) {
8 %r = ashr i128 %x, %y
9 ret i128 %r
11 define i128 @foo_shl(i128 %x, i128 %y) {
12 %r = shl i128 %x, %y
13 ret i128 %r
|
| H A D | return-val-i128.ll | 3 define i128 @__fixsfdi(float %a) {
6 %retval = alloca i128, align 16 ; <i128*> [#uses=2]
7 %tmp = alloca i128, align 16 ; <i128*> [#uses=3]
18 %tmp6 = call i128 @__fixunssfDI( float %tmp5 ) nounwind ; <i128> [#uses=1]
19 %tmp7 = sub i128 0, %tmp6 ; <i128> [#uses=1]
20 store i128 %tmp7, i128* %tmp, align 16
24 %tmp10 = call i128 @__fixunssfDI( float %tmp9 ) nounwind ; <i128> [#uses=1]
25 store i128 %tmp10, i128* %tmp, align 16
28 %tmp12 = load i128* %tmp, align 16 ; <i128> [#uses=1]
29 store i128 %tmp12, i128* %retval, align 16
[all …]
|
| H A D | ctrloop-sh.ll | 2 target datalayout = "E-m:e-p:32:32-i128:64-n32"
6 define void @foo1(i128* %a, i128* readonly %b, i128* readonly %c) #0 {
12 %0 = load i128* %b, align 16
13 %1 = load i128* %c, align 16
14 %shl = shl i128 %0, %1
15 store i128 %shl, i128* %a, align 16
28 define void @foo2(i128* %a, i128* readonly %b, i128* readonly %c) #0 {
34 %0 = load i128* %b, align 16
35 %1 = load i128* %c, align 16
36 %shl = ashr i128 %0, %1
[all …]
|
| /minix3/external/bsd/llvm/dist/llvm/test/CodeGen/AArch64/ |
| H A D | arm64-atomic-128.ll | 3 @var = global i128 0
5 define i128 @val_compare_and_swap(i128* %p, i128 %oldval, i128 %newval) {
16 %pair = cmpxchg i128* %p, i128 %oldval, i128 %newval acquire acquire
17 %val = extractvalue { i128, i1 } %pair, 0
18 ret i128 %val
21 define void @fetch_and_nand(i128* %p, i128 %bits) {
33 %val = atomicrmw nand i128* %p, i128 %bits release
34 store i128 %val, i128* @var, align 16
38 define void @fetch_and_or(i128* %p, i128 %bits) {
48 %val = atomicrmw or i128* %p, i128 %bits seq_cst
[all …]
|
| H A D | adc.ll | 4 define i128 @test_simple(i128 %a, i128 %b, i128 %c) {
7 %valadd = add i128 %a, %b
13 %valsub = sub i128 %valadd, %c
19 ret i128 %valsub
23 define i128 @test_imm(i128 %a) {
26 %val = add i128 %a, 12
32 ret i128 %val
36 define i128 @test_shifted(i128 %a, i128 %b) {
39 %rhs = shl i128 %b, 45
41 %val = add i128 %a, %rhs
[all …]
|
| /minix3/external/bsd/llvm/dist/llvm/test/Transforms/InstCombine/ |
| H A D | sdiv-2.ll | 7 %iftmp.13.0 = select i1 %0, i128 0, i128 200000000 ; <i128> [#uses=2]
8 %1 = sdiv i128 %iftmp.13.0, 10 ; <i128> [#uses=1]
12 %v.0 = phi i128 [ 0, %entry ], [ %6, %bb8 ] ; <i128> [#uses=2]
13 %2 = icmp sgt i128 %v.0, %1 ; <i1> [#uses=1]
17 %3 = mul i128 %v.0, 10 ; <i128> [#uses=2]
18 %4 = sub i128 %iftmp.13.0, 0 ; <i128> [#uses=1]
19 %5 = icmp slt i128 %4, %3 ; <i1> [#uses=1]
23 %6 = add i128 0, %3 ; <i128> [#uses=1]
|
| /minix3/external/bsd/llvm/dist/llvm/test/Transforms/LoopStrengthReduce/ |
| H A D | pr2537.ll | 9 %y.0 = phi i128 [ 0, %entry ], [ %add, %dobody ]
10 %x.0 = phi i128 [ 0, %entry ], [ %add2, %dobody ]
11 %add = add i128 %y.0, shl (i128 1, i128 64)
12 %add2 = add i128 %x.0, shl (i128 1, i128 48)
13 call void @b( i128 %add )
14 %cmp = icmp ult i128 %add2, shl (i128 1, i128 64)
21 declare void @b(i128 %add)
|
| /minix3/external/bsd/llvm/dist/llvm/test/CodeGen/NVPTX/ |
| H A D | shift-parts.ll | 4 define void @shift_parts_left_128(i128* %val, i128* %amtptr) {
15 %amt = load i128* %amtptr
16 %a = load i128* %val
17 %val0 = shl i128 %a, %amt
18 store i128 %val0, i128* %val
23 define void @shift_parts_right_128(i128* %val, i128* %amtptr) {
33 %amt = load i128* %amtptr
34 %a = load i128* %val
35 %val0 = ashr i128 %a, %amt
36 store i128 %val0, i128* %val
|
| /minix3/external/bsd/llvm/dist/clang/test/Sema/ |
| H A D | 128bitint.c | 5 typedef int i128 __attribute__((__mode__(TI))); typedef
8 int a[((i128)-1 ^ (i128)-2) == 1 ? 1 : -1];
20 __int128_t Signed128 = 123456789012345678901234567890i128;
21 long long Signed64 = 123456789012345678901234567890i128; // expected-warning {{implicit conversion …
23 __uint128_t Unsigned128 = 123456789012345678901234567890Ui128;
24 unsigned long long Unsigned64 = 123456789012345678901234567890Ui128; // expected-warning {{implicit…
29 …__attribute__(( pointer_with_type_tag(mpi,0x10000000000000001i128,1) )); // expected-error {{attri…
32 …__attribute__(( pointer_with_type_tag(mpi,1,0x10000000000000001i128) )); // expected-error {{attri…
36 …ng __attribute__(( type_tag_for_datatype(mpi,int) )) = 0x10000000000000001i128; // expected-error …
41 …MPI_Send(buf, 0x10000000000000001i128); // expected-warning {{implicit conversion from '__int128' … in test()
|
| /minix3/external/bsd/llvm/dist/llvm/test/Instrumentation/ThreadSanitizer/ |
| H A D | atomic.ll | 1541 define i128 @atomic128_load_unordered(i128* %a) nounwind uwtable {
1543 %0 = load atomic i128* %a unordered, align 16
1544 ret i128 %0
1547 ; CHECK: call i128 @__tsan_atomic128_load(i128* %a, i32 0)
1549 define i128 @atomic128_load_monotonic(i128* %a) nounwind uwtable {
1551 %0 = load atomic i128* %a monotonic, align 16
1552 ret i128 %0
1555 ; CHECK: call i128 @__tsan_atomic128_load(i128* %a, i32 0)
1557 define i128 @atomic128_load_acquire(i128* %a) nounwind uwtable {
1559 %0 = load atomic i128* %a acquire, align 16
[all …]
|