1; REQUIRES: asserts
2; RUN: opt -inline -mtriple=x86_64-unknown-unknown -S -debug-only=inline-cost < %s 2>&1 | FileCheck %s
3
4target datalayout = "e-m:e-i64:64-f80:128-n8:16:32:64-S128"
5target triple = "x86_64-unknown-unknown"
6
7define i32 @outer1(i32* %ptr, i32 %i) {
8  %C = call i32 @inner1(i32* %ptr, i32 %i)
9  ret i32 %C
10}
11
12; zext from i32 to i64 is free.
13; CHECK: Analyzing call of inner1
14; CHECK: NumInstructionsSimplified: 3
15; CHECK: NumInstructions: 4
16define i32 @inner1(i32* %ptr, i32 %i) {
17  %E = zext i32 %i to i64
18  %G = getelementptr inbounds i32, i32* %ptr, i64 %E
19  %L = load i32, i32* %G
20  ret i32 %L
21}
22
23define i16 @outer2(i8* %ptr) {
24  %C = call i16 @inner2(i8* %ptr)
25  ret i16 %C
26}
27
28; It is an ExtLoad.
29; CHECK: Analyzing call of inner2
30; CHECK: NumInstructionsSimplified: 2
31; CHECK: NumInstructions: 3
32define i16 @inner2(i8* %ptr) {
33  %L = load i8, i8* %ptr
34  %E = zext i8 %L to i16
35  ret i16 %E
36}
37
38define i16 @outer3(i8* %ptr) {
39  %C = call i16 @inner3(i8* %ptr)
40  ret i16 %C
41}
42
43; It is an ExtLoad.
44; CHECK: Analyzing call of inner3
45; CHECK: NumInstructionsSimplified: 2
46; CHECK: NumInstructions: 3
47define i16 @inner3(i8* %ptr) {
48  %L = load i8, i8* %ptr
49  %E = sext i8 %L to i16
50  ret i16 %E
51}
52
53define i32 @outer4(i8* %ptr) {
54  %C = call i32 @inner4(i8* %ptr)
55  ret i32 %C
56}
57
58; It is an ExtLoad.
59; CHECK: Analyzing call of inner4
60; CHECK: NumInstructionsSimplified: 2
61; CHECK: NumInstructions: 3
62define i32 @inner4(i8* %ptr) {
63  %L = load i8, i8* %ptr
64  %E = zext i8 %L to i32
65  ret i32 %E
66}
67
68define i32 @outer5(i8* %ptr) {
69  %C = call i32 @inner5(i8* %ptr)
70  ret i32 %C
71}
72
73; It is an ExtLoad.
74; CHECK: Analyzing call of inner5
75; CHECK: NumInstructionsSimplified: 2
76; CHECK: NumInstructions: 3
77define i32 @inner5(i8* %ptr) {
78  %L = load i8, i8* %ptr
79  %E = sext i8 %L to i32
80  ret i32 %E
81}
82
83define i32 @outer6(i16* %ptr) {
84  %C = call i32 @inner6(i16* %ptr)
85  ret i32 %C
86}
87
88; It is an ExtLoad.
89; CHECK: Analyzing call of inner6
90; CHECK: NumInstructionsSimplified: 2
91; CHECK: NumInstructions: 3
92define i32 @inner6(i16* %ptr) {
93  %L = load i16, i16* %ptr
94  %E = zext i16 %L to i32
95  ret i32 %E
96}
97
98define i32 @outer7(i16* %ptr) {
99  %C = call i32 @inner7(i16* %ptr)
100  ret i32 %C
101}
102
103; It is an ExtLoad.
104; CHECK: Analyzing call of inner7
105; CHECK: NumInstructionsSimplified: 2
106; CHECK: NumInstructions: 3
107define i32 @inner7(i16* %ptr) {
108  %L = load i16, i16* %ptr
109  %E = sext i16 %L to i32
110  ret i32 %E
111}
112
113define i64 @outer8(i8* %ptr) {
114  %C = call i64 @inner8(i8* %ptr)
115  ret i64 %C
116}
117
118; It is an ExtLoad.
119; CHECK: Analyzing call of inner8
120; CHECK: NumInstructionsSimplified: 2
121; CHECK: NumInstructions: 3
122define i64 @inner8(i8* %ptr) {
123  %L = load i8, i8* %ptr
124  %E = zext i8 %L to i64
125  ret i64 %E
126}
127
128define i64 @outer9(i8* %ptr) {
129  %C = call i64 @inner9(i8* %ptr)
130  ret i64 %C
131}
132
133; It is an ExtLoad.
134; CHECK: Analyzing call of inner9
135; CHECK: NumInstructionsSimplified: 2
136; CHECK: NumInstructions: 3
137define i64 @inner9(i8* %ptr) {
138  %L = load i8, i8* %ptr
139  %E = sext i8 %L to i64
140  ret i64 %E
141}
142
143define i64 @outer10(i16* %ptr) {
144  %C = call i64 @inner10(i16* %ptr)
145  ret i64 %C
146}
147
148; It is an ExtLoad.
149; CHECK: Analyzing call of inner10
150; CHECK: NumInstructionsSimplified: 2
151; CHECK: NumInstructions: 3
152define i64 @inner10(i16* %ptr) {
153  %L = load i16, i16* %ptr
154  %E = zext i16 %L to i64
155  ret i64 %E
156}
157
158define i64 @outer11(i16* %ptr) {
159  %C = call i64 @inner11(i16* %ptr)
160  ret i64 %C
161}
162
163; It is an ExtLoad.
164; CHECK: Analyzing call of inner11
165; CHECK: NumInstructionsSimplified: 2
166; CHECK: NumInstructions: 3
167define i64 @inner11(i16* %ptr) {
168  %L = load i16, i16* %ptr
169  %E = sext i16 %L to i64
170  ret i64 %E
171}
172
173define i64 @outer12(i32* %ptr) {
174  %C = call i64 @inner12(i32* %ptr)
175  ret i64 %C
176}
177
178; It is an ExtLoad.
179; CHECK: Analyzing call of inner12
180; CHECK: NumInstructionsSimplified: 2
181; CHECK: NumInstructions: 3
182define i64 @inner12(i32* %ptr) {
183  %L = load i32, i32* %ptr
184  %E = zext i32 %L to i64
185  ret i64 %E
186}
187
188define i64 @outer13(i32* %ptr) {
189  %C = call i64 @inner13(i32* %ptr)
190  ret i64 %C
191}
192
193; It is an ExtLoad.
194; CHECK: Analyzing call of inner13
195; CHECK: NumInstructionsSimplified: 2
196; CHECK: NumInstructions: 3
197define i64 @inner13(i32* %ptr) {
198  %L = load i32, i32* %ptr
199  %E = sext i32 %L to i64
200  ret i64 %E
201}
202