1; RUN: llc -mcpu=pwr7 -mattr=+altivec -mattr=-vsx < %s | FileCheck %s
2
3target datalayout = "e-m:e-i64:64-n32:64"
4target triple = "powerpc64le-unknown-linux-gnu"
5
6@g = common global ppc_fp128 0xM00000000000000000000000000000000, align 16
7
8define void @callee(ppc_fp128 %x) {
9entry:
10  %x.addr = alloca ppc_fp128, align 16
11  store ppc_fp128 %x, ppc_fp128* %x.addr, align 16
12  %0 = load ppc_fp128, ppc_fp128* %x.addr, align 16
13  store ppc_fp128 %0, ppc_fp128* @g, align 16
14  ret void
15}
16; CHECK: @callee
17; CHECK: ld [[REG:[0-9]+]], .LC
18; CHECK: stfd 2, 8([[REG]])
19; CHECK: stfd 1, 0([[REG]])
20; CHECK: blr
21
22define void @caller() {
23entry:
24  %0 = load ppc_fp128, ppc_fp128* @g, align 16
25  call void @test(ppc_fp128 %0)
26  ret void
27}
28; CHECK: @caller
29; CHECK: ld [[REG:[0-9]+]], .LC
30; CHECK: lfd 2, 8([[REG]])
31; CHECK: lfd 1, 0([[REG]])
32; CHECK: bl test
33
34declare void @test(ppc_fp128)
35
36define void @caller_const() {
37entry:
38  call void @test(ppc_fp128 0xM3FF00000000000000000000000000000)
39  ret void
40}
41; CHECK: .LCPI[[LC:[0-9]+]]_0:
42; CHECK: .long   1065353216
43; CHECK: .LCPI[[LC]]_1:
44; CHECK: .long   0
45; CHECK: @caller_const
46; CHECK: addi [[REG0:[0-9]+]], {{[0-9]+}}, .LCPI[[LC]]_0
47; CHECK: addi [[REG1:[0-9]+]], {{[0-9]+}}, .LCPI[[LC]]_1
48; CHECK: lfs 1, 0([[REG0]])
49; CHECK: lfs 2, 0([[REG1]])
50; CHECK: bl test
51
52define ppc_fp128 @result() {
53entry:
54  %0 = load ppc_fp128, ppc_fp128* @g, align 16
55  ret ppc_fp128 %0
56}
57; CHECK: @result
58; CHECK: ld [[REG:[0-9]+]], .LC
59; CHECK: lfd 1, 0([[REG]])
60; CHECK: lfd 2, 8([[REG]])
61; CHECK: blr
62
63define void @use_result() {
64entry:
65  %call = tail call ppc_fp128 @test_result() #3
66  store ppc_fp128 %call, ppc_fp128* @g, align 16
67  ret void
68}
69; CHECK: @use_result
70; CHECK: bl test_result
71; CHECK: ld [[REG:[0-9]+]], .LC
72; CHECK: stfd 2, 8([[REG]])
73; CHECK: stfd 1, 0([[REG]])
74; CHECK: blr
75
76declare ppc_fp128 @test_result()
77
78define void @caller_result() {
79entry:
80  %call = tail call ppc_fp128 @test_result()
81  tail call void @test(ppc_fp128 %call)
82  ret void
83}
84; CHECK: @caller_result
85; CHECK: bl test_result
86; CHECK-NEXT: nop
87; CHECK-NEXT: bl test
88; CHECK-NEXT: nop
89
90define i128 @convert_from(ppc_fp128 %x) {
91entry:
92  %0 = bitcast ppc_fp128 %x to i128
93  ret i128 %0
94}
95; CHECK: @convert_from
96; CHECK: stfd 1, [[OFF1:.*]](1)
97; CHECK: stfd 2, [[OFF2:.*]](1)
98; CHECK: ld 3, [[OFF1]](1)
99; CHECK: ld 4, [[OFF2]](1)
100; CHECK: blr
101
102define ppc_fp128 @convert_to(i128 %x) {
103entry:
104  %0 = bitcast i128 %x to ppc_fp128
105  ret ppc_fp128 %0
106}
107; CHECK: @convert_to
108; CHECK: std 3, [[OFF1:.*]](1)
109; CHECK: std 4, [[OFF2:.*]](1)
110; CHECK: lfd 1, [[OFF1]](1)
111; CHECK: lfd 2, [[OFF2]](1)
112; CHECK: blr
113
114define ppc_fp128 @convert_to2(i128 %x) {
115entry:
116  %shl = shl i128 %x, 1
117  %0 = bitcast i128 %shl to ppc_fp128
118  ret ppc_fp128 %0
119}
120
121; CHECK: @convert_to
122; CHECK: std 3, [[OFF1:.*]](1)
123; CHECK: std 4, [[OFF2:.*]](1)
124; CHECK: lfd 1, [[OFF1]](1)
125; CHECK: lfd 2, [[OFF2]](1)
126; CHECK: blr
127
128define double @convert_vector(<4 x i32> %x) {
129entry:
130  %cast = bitcast <4 x i32> %x to ppc_fp128
131  %conv = fptrunc ppc_fp128 %cast to double
132  ret double %conv
133}
134; CHECK: @convert_vector
135; CHECK: addi [[REG:[0-9]+]], 1, [[OFF:.*]]
136; CHECK: stvx 2, 0, [[REG]]
137; CHECK: lfd 1, [[OFF]](1)
138; CHECK: blr
139
140declare void @llvm.va_start(i8*)
141
142define double @vararg(i32 %a, ...) {
143entry:
144  %va = alloca i8*, align 8
145  %va1 = bitcast i8** %va to i8*
146  call void @llvm.va_start(i8* %va1)
147  %arg = va_arg i8** %va, ppc_fp128
148  %conv = fptrunc ppc_fp128 %arg to double
149  ret double %conv
150}
151; CHECK: @vararg
152; CHECK: lfd 1, 0({{[0-9]+}})
153; CHECK: blr
154
155