| /external/llvm/test/CodeGen/SystemZ/ |
| fp-div-03.ll | 6 define void @f1(fp128 *%ptr, float %f2) {
15 %f1 = load fp128 , fp128 *%ptr
16 %f2x = fpext float %f2 to fp128
17 %sum = fdiv fp128 %f1, %f2x
18 store fp128 %sum, fp128 *%ptr
|
| fp-mul-05.ll | 6 define void @f1(fp128 *%ptr, float %f2) {
15 %f1 = load fp128 , fp128 *%ptr
16 %f2x = fpext float %f2 to fp128
17 %diff = fmul fp128 %f1, %f2x
18 store fp128 %diff, fp128 *%ptr
|
| fp-sub-03.ll | 6 define void @f1(fp128 *%ptr, float %f2) {
15 %f1 = load fp128 , fp128 *%ptr
16 %f2x = fpext float %f2 to fp128
17 %sum = fsub fp128 %f1, %f2x
18 store fp128 %sum, fp128 *%ptr
|
| fp-copysign-01.ll | 8 declare fp128 @copysignl(fp128, fp128) readnone
32 define float @f3(float %a, fp128 *%bptr) {
38 %bl = load volatile fp128 , fp128 *%bptr
39 %b = fptrunc fp128 %bl to float
66 define double @f6(double %a, fp128 *%bptr) {
72 %bl = load volatile fp128 , fp128 *%bpt
[all...] |
| fp-abs-02.ll | 31 declare fp128 @llvm.fabs.f128(fp128 %f)
32 define void @f3(fp128 *%ptr, fp128 *%ptr2) {
37 %orig = load fp128 , fp128 *%ptr
38 %abs = call fp128 @llvm.fabs.f128(fp128 %orig)
39 %negabs = fsub fp128 0xL00000000000000008000000000000000, %abs
40 %op2 = load fp128 , fp128 *%ptr
[all...] |
| fp-round-02.ll | 30 declare fp128 @llvm.rint.f128(fp128 %f)
31 define void @f3(fp128 *%ptr) {
35 %src = load fp128 , fp128 *%ptr
36 %res = call fp128 @llvm.rint.f128(fp128 %src)
37 store fp128 %res, fp128 *%ptr
62 declare fp128 @llvm.nearbyint.f128(fp128 %f
[all...] |
| fp-abs-01.ll | 29 declare fp128 @llvm.fabs.f128(fp128 %f)
30 define void @f3(fp128 *%ptr, fp128 *%ptr2) {
35 %orig = load fp128 , fp128 *%ptr
36 %abs = call fp128 @llvm.fabs.f128(fp128 %orig)
37 %op2 = load fp128 , fp128 *%ptr
[all...] |
| vec-args-error-07.ll | 5 declare void @bar(<1 x fp128>)
8 call void @bar (<1 x fp128> <fp128 0xL00000000000000000000000000000000>)
|
| fp-move-01.ll | 23 define void @f3(fp128 *%x) {
28 %val = load volatile fp128 , fp128 *%x
29 %sum = fadd fp128 %val, %val
30 store volatile fp128 %sum, fp128 *%x
31 store volatile fp128 %val, fp128 *%x
|
| fp-move-12.ll | 23 define void @f3(fp128 *%x) {
28 %val = load volatile fp128 , fp128 *%x
29 %sum = fadd fp128 %val, %val
30 store volatile fp128 %sum, fp128 *%x
31 store volatile fp128 %val, fp128 *%x
|
| /external/llvm/test/Transforms/Float2Int/ |
| toolarge.ll | 4 ; CHECK: %1 = uitofp i80 %a to fp128
5 ; CHECK: %2 = fadd fp128 %1, %1
6 ; CHECK: %3 = fptoui fp128 %2 to i80
8 ; fp128 has a 112-bit mantissa, which can hold an i80. But we only support
11 %1 = uitofp i80 %a to fp128
12 %2 = fadd fp128 %1, %1
13 %3 = fptoui fp128 %2 to i80
|
| /external/llvm/test/CodeGen/Mips/cconv/ |
| arguments-fp128.ll | 7 ; Test the fp128 arguments for all ABI's and byte orders as specified
12 @ldoubles = global [11 x fp128] zeroinitializer
14 define void @ldouble_args(fp128 %a, fp128 %b, fp128 %c, fp128 %d, fp128 %e) nounwind {
16 %0 = getelementptr [11 x fp128], [11 x fp128]* @ldoubles, i32 0, i32 1
17 store volatile fp128 %a, fp128* %
[all...] |
| arguments-hard-fp128.ll | 7 ; Test the fp128 arguments for all ABI's and byte orders as specified
12 @ldoubles = global [11 x fp128] zeroinitializer
14 define void @ldouble_args(fp128 %a, fp128 %b, fp128 %c, fp128 %d, fp128 %e) nounwind {
16 %0 = getelementptr [11 x fp128], [11 x fp128]* @ldoubles, i32 0, i32 1
17 store volatile fp128 %a, fp128* %
[all...] |
| return-hard-fp128.ll | 7 ; Test the fp128 returns for N32/N64 and all byte orders as specified by
12 @fp128 = global fp128 zeroinitializer
14 define fp128 @retldouble() nounwind {
16 %0 = load volatile fp128, fp128* @fp128
17 ret fp128 %0
21 ; N32-DAG: ld [[R2:\$[0-9]+]], %lo(fp128)([[R1:\$[0-9]+]])
22 ; N32-DAG: addiu [[R3:\$[0-9]+]], [[R1]], %lo(fp128)
[all...] |
| /external/llvm/test/CodeGen/X86/ |
| fp128-compare.ll | 4 define i32 @TestComp128GT(fp128 %d1, fp128 %d2) {
6 %cmp = fcmp ogt fp128 %d1, %d2
17 define i32 @TestComp128GE(fp128 %d1, fp128 %d2) {
19 %cmp = fcmp oge fp128 %d1, %d2
31 define i32 @TestComp128LT(fp128 %d1, fp128 %d2) {
33 %cmp = fcmp olt fp128 %d1, %d2
46 define i32 @TestComp128LE(fp128 %d1, fp128 %d2)
[all...] |
| fp128-i128.ll | 43 define void @TestUnionLD1(fp128 %s, i64 %n) #0 {
45 %0 = bitcast fp128 %s to i128
51 %2 = bitcast i128 %bf.set to fp128
52 tail call void @foo(fp128 %2) #2
77 define fp128 @TestUnionLD2(fp128 %s) #0 {
79 %0 = bitcast fp128 %s to i128
81 %1 = bitcast i128 %bf.clear to fp128
82 ret fp128 %1
100 define fp128 @TestI128_1(fp128 %x) #0
[all...] |
| fp128-load.ll | 5 @my_fp128 = global fp128 0xL00000000000000003FFF000000000000, align 16
7 define fp128 @get_fp128() {
9 %0 = load fp128, fp128* @my_fp128, align 16
10 ret fp128 %0
18 define fp128 @TestLoadExtend(fp128 %x, i32 %n) {
23 %conv = fpext float %0 to fp128
24 ret fp128 %conv
|
| fp128-store.ll | 5 @myFP128 = global fp128 0xL00000000000000003FFF000000000000, align 16
7 define void @set_FP128(fp128 %x) {
9 store fp128 %x, fp128* @myFP128, align 16
|
| /external/llvm/test/CodeGen/AArch64/ |
| arm64-reg-copy-noneon.ll | 15 define fp128 @copy_FPR128(fp128 %a, fp128 %b) {
19 ret fp128 %b;
|
| fcopysign.ll | 6 declare fp128 @llvm.copysign.f128(fp128, fp128)
17 define fp128 @copysign0() {
20 %conv = fpext double %v to fp128
21 %call = tail call fp128 @llvm.copysign.f128(fp128 0xL00000000000000007FFF000000000000, fp128 %conv) #2
22 ret fp128 %call
|
| arm64-fp128-folding.ll | 4 ; SelectionDAG used to try to fold some fp128 operations using the ppc128 type,
7 define fp128 @test_folding() {
12 %fpval = sitofp i32 %val to fp128
13 ; If the value is loaded from a constant pool into an fp128, it's been folded
16 ret fp128 %fpval
|
| fp128-folding.ll | 4 ; SelectionDAG used to try to fold some fp128 operations using the ppc128 type,
7 define fp128 @test_folding() {
12 %fpval = sitofp i32 %val to fp128
13 ; If the value is loaded from a constant pool into an fp128, it's been folded
16 ret fp128 %fpval
|
| /external/llvm/test/CodeGen/SPARC/ |
| soft-float.ll | 19 define fp128 @test_addtf3(fp128 %a, fp128 %b) #0 {
22 %add = fadd fp128 %a, %b
23 ret fp128 %add
40 define fp128 @test_multf3(fp128 %a, fp128 %b) #0 {
43 %mul = fmul fp128 %a, %b
44 ret fp128 %mu
[all...] |
| /external/llvm/test/Transforms/InstCombine/ |
| fabs.ll | 7 declare fp128 @fabsl(fp128)
29 define fp128 @square_fabs_call_f128(fp128 %x) {
30 %mul = fmul fp128 %x, %x
31 %fabsl = tail call fp128 @fabsl(fp128 %mul)
32 ret fp128 %fabsl
35 ; CHECK-NEXT: %mul = fmul fp128 %x, %x
36 ; CHECK-NEXT: ret fp128 %mu
[all...] |
| /external/clang/test/CodeGen/ |
| x86_64-longdouble.c | 11 // Android uses fp128 for long double but other x86_64 targets use x86_fp80.
14 // ANDROID: @dataLD = local_unnamed_addr global fp128 0xL00000000000000003FFF000000000000, align 16
18 // ANDROID: @dataLDC = local_unnamed_addr global { fp128, fp128 } { fp128 0xL00000000000000003FFF000000000000, fp128 0xL00000000000000003FFF000000000000 }, align 16
23 // ANDROID: define fp128 @TestLD(fp128 %x)
30 // ANDROID: define void @TestLDC({ fp128, fp128 }* {{.*}}, { fp128, fp128 }* {{.*}} %x
[all...] |
