| /external/llvm/test/CodeGen/SystemZ/ |
| 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 | 24 define void @f3(fp128 *%x) {
29 %val = load volatile fp128 , fp128 *%x
30 %sum = fadd fp128 %val, %val
31 store volatile fp128 %sum, fp128 *%x
32 store volatile fp128 %val, fp128 *%x
|
| fp-cmp-03.ll | 7 define i64 @f1(i64 %a, i64 %b, fp128 *%ptr, float %f2) {
16 %f2x = fpext float %f2 to fp128
17 %f1 = load fp128 , fp128 *%ptr
18 %cond = fcmp oeq fp128 %f1, %f2x
24 define i64 @f2(i64 %a, i64 %b, fp128 *%ptr) {
32 %f = load fp128 , fp128 *%ptr
33 %cond = fcmp oeq fp128 %f, 0xL00000000000000000000000000000000
|
| fp-sincos-01.ll | 36 define fp128 @f3(fp128 %x) {
44 %tmp1 = call fp128 @sinl(fp128 %x)
45 %tmp2 = call fp128 @cosl(fp128 %x)
46 %add = fadd fp128 %tmp1, %tmp2
47 ret fp128 %add
52 declare fp128 @sinl(fp128) readonl
[all...] |
| fp-conv-01.ll | 19 define float @f2(fp128 *%ptr) {
23 %val = load fp128 , fp128 *%ptr
24 %res = fptrunc fp128 %val to float
30 define void @f3(float *%dst, fp128 *%ptr, float %d1, float %d2) {
36 %val = load fp128 , fp128 *%ptr
37 %conv = fptrunc fp128 %val to float
44 define double @f4(fp128 *%ptr) {
48 %val = load fp128 , fp128 *%pt
[all...] |
| vec-args-error-08.ll | 5 declare <1 x fp128> @bar()
8 %res = call <1 x fp128> @bar ()
|
| /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
16 define i32 @TestComp128GE(fp128 %d1, fp128 %d2) {
18 %cmp = fcmp oge fp128 %d1, %d2
29 define i32 @TestComp128LT(fp128 %d1, fp128 %d2) {
31 %cmp = fcmp olt fp128 %d1, %d2
44 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
|
| fp128-cast.ll | 12 @vf128 = common global fp128 0xL00000000000000000000000000000000, align 16
17 %conv = fpext float %0 to fp128
18 store fp128 %conv, fp128* @vf128, align 16
30 %conv = fpext double %0 to fp128
31 store fp128 %conv, fp128* @vf128, align 16
42 %0 = load fp128, fp128* @vf128, align 16
43 %conv = fptosi fp128 %0 to i3
[all...] |
| /external/llvm/test/CodeGen/AArch64/ |
| arm64-reg-copy-noneon.ll | 15 define fp128 @copy_FPR128(fp128 %a, fp128 %b) {
19 ret fp128 %b;
|
| 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/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 = global fp128 0xL00000000000000003FFF000000000000, align 16
18 // ANDROID: @dataLDC = 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...] |
