|
120
|
1 ; NOTE: Assertions have been autogenerated by utils/update_test_checks.py
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
2 target datalayout = "e-p:64:64:64-p1:16:16:16-i1:8:8-i8:8:8-i16:16:16-i32:32:32-i64:64:64-f32:32:32-f64:64:64-v64:64:64-v128:128:128-a0:0:64-s0:64:64-f80:128:128"
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
3
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
4 ; Optimize subtracts.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
5 ;
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
6 ; RUN: opt < %s -instcombine -S | FileCheck %s
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
7
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
8 define i32 @test1(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
9 ; CHECK-LABEL: @test1(
|
|
120
|
10 ; CHECK-NEXT: ret i32 0
|
|
|
11 ;
|
|
|
12 %B = sub i32 %A, %A
|
|
|
13 ret i32 %B
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
14 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
15
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
16 define i32 @test2(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
17 ; CHECK-LABEL: @test2(
|
|
121
|
18 ; CHECK-NEXT: ret i32 [[A:%.*]]
|
|
120
|
19 ;
|
|
|
20 %B = sub i32 %A, 0
|
|
|
21 ret i32 %B
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
22 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
23
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
24 define i32 @test3(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
25 ; CHECK-LABEL: @test3(
|
|
121
|
26 ; CHECK-NEXT: ret i32 [[A:%.*]]
|
|
120
|
27 ;
|
|
|
28 %B = sub i32 0, %A
|
|
|
29 %C = sub i32 0, %B
|
|
|
30 ret i32 %C
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
31 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
32
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
33 define i32 @test4(i32 %A, i32 %x) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
34 ; CHECK-LABEL: @test4(
|
|
121
|
35 ; CHECK-NEXT: [[C:%.*]] = add i32 [[X:%.*]], [[A:%.*]]
|
|
120
|
36 ; CHECK-NEXT: ret i32 [[C]]
|
|
|
37 ;
|
|
|
38 %B = sub i32 0, %A
|
|
|
39 %C = sub i32 %x, %B
|
|
|
40 ret i32 %C
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
41 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
42
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
43 define i32 @test5(i32 %A, i32 %B, i32 %C) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
44 ; CHECK-LABEL: @test5(
|
|
121
|
45 ; CHECK-NEXT: [[D1:%.*]] = sub i32 [[C:%.*]], [[B:%.*]]
|
|
|
46 ; CHECK-NEXT: [[E:%.*]] = add i32 [[D1]], [[A:%.*]]
|
|
120
|
47 ; CHECK-NEXT: ret i32 [[E]]
|
|
|
48 ;
|
|
|
49 %D = sub i32 %B, %C
|
|
|
50 %E = sub i32 %A, %D
|
|
|
51 ret i32 %E
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
52 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
53
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
54 define i32 @test6(i32 %A, i32 %B) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
55 ; CHECK-LABEL: @test6(
|
|
121
|
56 ; CHECK-NEXT: [[B_NOT:%.*]] = xor i32 [[B:%.*]], -1
|
|
|
57 ; CHECK-NEXT: [[D:%.*]] = and i32 [[B_NOT]], [[A:%.*]]
|
|
120
|
58 ; CHECK-NEXT: ret i32 [[D]]
|
|
|
59 ;
|
|
|
60 %C = and i32 %A, %B
|
|
|
61 %D = sub i32 %A, %C
|
|
|
62 ret i32 %D
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
63 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
64
|
|
121
|
65 define i32 @test6commuted(i32 %A, i32 %B) {
|
|
|
66 ; CHECK-LABEL: @test6commuted(
|
|
|
67 ; CHECK-NEXT: [[B_NOT:%.*]] = xor i32 [[B:%.*]], -1
|
|
|
68 ; CHECK-NEXT: [[D:%.*]] = and i32 [[B_NOT]], [[A:%.*]]
|
|
|
69 ; CHECK-NEXT: ret i32 [[D]]
|
|
|
70 ;
|
|
|
71 %C = and i32 %B, %A
|
|
|
72 %D = sub i32 %A, %C
|
|
|
73 ret i32 %D
|
|
|
74 }
|
|
|
75
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
76 define i32 @test7(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
77 ; CHECK-LABEL: @test7(
|
|
121
|
78 ; CHECK-NEXT: [[B:%.*]] = xor i32 [[A:%.*]], -1
|
|
120
|
79 ; CHECK-NEXT: ret i32 [[B]]
|
|
|
80 ;
|
|
|
81 %B = sub i32 -1, %A
|
|
|
82 ret i32 %B
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
83 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
84
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
85 define i32 @test8(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
86 ; CHECK-LABEL: @test8(
|
|
121
|
87 ; CHECK-NEXT: [[C:%.*]] = shl i32 [[A:%.*]], 3
|
|
120
|
88 ; CHECK-NEXT: ret i32 [[C]]
|
|
|
89 ;
|
|
|
90 %B = mul i32 9, %A
|
|
|
91 %C = sub i32 %B, %A
|
|
|
92 ret i32 %C
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
93 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
94
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
95 define i32 @test9(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
96 ; CHECK-LABEL: @test9(
|
|
121
|
97 ; CHECK-NEXT: [[C:%.*]] = mul i32 [[A:%.*]], -2
|
|
120
|
98 ; CHECK-NEXT: ret i32 [[C]]
|
|
|
99 ;
|
|
|
100 %B = mul i32 3, %A
|
|
|
101 %C = sub i32 %A, %B
|
|
|
102 ret i32 %C
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
103 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
104
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
105 define i32 @test10(i32 %A, i32 %B) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
106 ; CHECK-LABEL: @test10(
|
|
121
|
107 ; CHECK-NEXT: [[E:%.*]] = mul i32 [[A:%.*]], [[B:%.*]]
|
|
120
|
108 ; CHECK-NEXT: ret i32 [[E]]
|
|
|
109 ;
|
|
|
110 %C = sub i32 0, %A
|
|
|
111 %D = sub i32 0, %B
|
|
|
112 %E = mul i32 %C, %D
|
|
|
113 ret i32 %E
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
114 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
115
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
116 define i32 @test10a(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
117 ; CHECK-LABEL: @test10a(
|
|
121
|
118 ; CHECK-NEXT: [[E:%.*]] = mul i32 [[A:%.*]], -7
|
|
120
|
119 ; CHECK-NEXT: ret i32 [[E]]
|
|
|
120 ;
|
|
|
121 %C = sub i32 0, %A
|
|
|
122 %E = mul i32 %C, 7
|
|
|
123 ret i32 %E
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
124 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
125
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
126 define i1 @test11(i8 %A, i8 %B) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
127 ; CHECK-LABEL: @test11(
|
|
121
|
128 ; CHECK-NEXT: [[D:%.*]] = icmp ne i8 [[A:%.*]], [[B:%.*]]
|
|
120
|
129 ; CHECK-NEXT: ret i1 [[D]]
|
|
|
130 ;
|
|
|
131 %C = sub i8 %A, %B
|
|
|
132 %D = icmp ne i8 %C, 0
|
|
|
133 ret i1 %D
|
|
|
134 }
|
|
|
135
|
|
|
136 define <2 x i1> @test11vec(<2 x i8> %A, <2 x i8> %B) {
|
|
|
137 ; CHECK-LABEL: @test11vec(
|
|
121
|
138 ; CHECK-NEXT: [[D:%.*]] = icmp ne <2 x i8> [[A:%.*]], [[B:%.*]]
|
|
120
|
139 ; CHECK-NEXT: ret <2 x i1> [[D]]
|
|
|
140 ;
|
|
|
141 %C = sub <2 x i8> %A, %B
|
|
|
142 %D = icmp ne <2 x i8> %C, zeroinitializer
|
|
|
143 ret <2 x i1> %D
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
144 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
145
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
146 define i32 @test12(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
147 ; CHECK-LABEL: @test12(
|
|
121
|
148 ; CHECK-NEXT: [[C:%.*]] = lshr i32 [[A:%.*]], 31
|
|
120
|
149 ; CHECK-NEXT: ret i32 [[C]]
|
|
|
150 ;
|
|
|
151 %B = ashr i32 %A, 31
|
|
|
152 %C = sub i32 0, %B
|
|
|
153 ret i32 %C
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
154 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
155
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
156 define i32 @test13(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
157 ; CHECK-LABEL: @test13(
|
|
121
|
158 ; CHECK-NEXT: [[C:%.*]] = ashr i32 [[A:%.*]], 31
|
|
120
|
159 ; CHECK-NEXT: ret i32 [[C]]
|
|
|
160 ;
|
|
|
161 %B = lshr i32 %A, 31
|
|
|
162 %C = sub i32 0, %B
|
|
|
163 ret i32 %C
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
164 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
165
|
|
120
|
166 define <2 x i32> @test12vec(<2 x i32> %A) {
|
|
|
167 ; CHECK-LABEL: @test12vec(
|
|
121
|
168 ; CHECK-NEXT: [[C:%.*]] = lshr <2 x i32> [[A:%.*]], <i32 31, i32 31>
|
|
120
|
169 ; CHECK-NEXT: ret <2 x i32> [[C]]
|
|
|
170 ;
|
|
|
171 %B = ashr <2 x i32> %A, <i32 31, i32 31>
|
|
|
172 %C = sub <2 x i32> zeroinitializer, %B
|
|
|
173 ret <2 x i32> %C
|
|
|
174 }
|
|
|
175
|
|
|
176 define <2 x i32> @test13vec(<2 x i32> %A) {
|
|
|
177 ; CHECK-LABEL: @test13vec(
|
|
121
|
178 ; CHECK-NEXT: [[C:%.*]] = ashr <2 x i32> [[A:%.*]], <i32 31, i32 31>
|
|
120
|
179 ; CHECK-NEXT: ret <2 x i32> [[C]]
|
|
|
180 ;
|
|
|
181 %B = lshr <2 x i32> %A, <i32 31, i32 31>
|
|
|
182 %C = sub <2 x i32> zeroinitializer, %B
|
|
|
183 ret <2 x i32> %C
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
184 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
185
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
186 define i32 @test15(i32 %A, i32 %B) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
187 ; CHECK-LABEL: @test15(
|
|
121
|
188 ; CHECK-NEXT: [[C:%.*]] = sub i32 0, [[A:%.*]]
|
|
|
189 ; CHECK-NEXT: [[D:%.*]] = srem i32 [[B:%.*]], [[C]]
|
|
120
|
190 ; CHECK-NEXT: ret i32 [[D]]
|
|
|
191 ;
|
|
|
192 %C = sub i32 0, %A
|
|
|
193 %D = srem i32 %B, %C
|
|
|
194 ret i32 %D
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
195 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
196
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
197 define i32 @test16(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
198 ; CHECK-LABEL: @test16(
|
|
121
|
199 ; CHECK-NEXT: [[Y:%.*]] = sdiv i32 [[A:%.*]], -1123
|
|
120
|
200 ; CHECK-NEXT: ret i32 [[Y]]
|
|
|
201 ;
|
|
|
202 %X = sdiv i32 %A, 1123
|
|
|
203 %Y = sub i32 0, %X
|
|
|
204 ret i32 %Y
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
205 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
206
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
207 ; Can't fold subtract here because negation it might oveflow.
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
208 ; PR3142
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
209 define i32 @test17(i32 %A) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
210 ; CHECK-LABEL: @test17(
|
|
121
|
211 ; CHECK-NEXT: [[B:%.*]] = sub i32 0, [[A:%.*]]
|
|
120
|
212 ; CHECK-NEXT: [[C:%.*]] = sdiv i32 [[B]], 1234
|
|
|
213 ; CHECK-NEXT: ret i32 [[C]]
|
|
|
214 ;
|
|
|
215 %B = sub i32 0, %A
|
|
|
216 %C = sdiv i32 %B, 1234
|
|
|
217 ret i32 %C
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
218 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
219
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
220 define i64 @test18(i64 %Y) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
221 ; CHECK-LABEL: @test18(
|
|
120
|
222 ; CHECK-NEXT: ret i64 0
|
|
|
223 ;
|
|
|
224 %tmp.4 = shl i64 %Y, 2
|
|
|
225 %tmp.12 = shl i64 %Y, 2
|
|
|
226 %tmp.8 = sub i64 %tmp.4, %tmp.12
|
|
|
227 ret i64 %tmp.8
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
228 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
229
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
230 define i32 @test19(i32 %X, i32 %Y) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
231 ; CHECK-LABEL: @test19(
|
|
121
|
232 ; CHECK-NEXT: ret i32 [[X:%.*]]
|
|
120
|
233 ;
|
|
|
234 %Z = sub i32 %X, %Y
|
|
|
235 %Q = add i32 %Z, %Y
|
|
|
236 ret i32 %Q
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
237 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
238
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
239 define i1 @test20(i32 %g, i32 %h) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
240 ; CHECK-LABEL: @test20(
|
|
121
|
241 ; CHECK-NEXT: [[TMP_4:%.*]] = icmp ne i32 [[H:%.*]], 0
|
|
120
|
242 ; CHECK-NEXT: ret i1 [[TMP_4]]
|
|
|
243 ;
|
|
|
244 %tmp.2 = sub i32 %g, %h
|
|
|
245 %tmp.4 = icmp ne i32 %tmp.2, %g
|
|
|
246 ret i1 %tmp.4
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
247 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
248
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
249 define i1 @test21(i32 %g, i32 %h) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
250 ; CHECK-LABEL: @test21(
|
|
121
|
251 ; CHECK-NEXT: [[TMP_4:%.*]] = icmp ne i32 [[H:%.*]], 0
|
|
120
|
252 ; CHECK-NEXT: ret i1 [[TMP_4]]
|
|
|
253 ;
|
|
|
254 %tmp.2 = sub i32 %g, %h
|
|
|
255 %tmp.4 = icmp ne i32 %tmp.2, %g
|
|
|
256 ret i1 %tmp.4
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
257 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
258
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
259 ; PR2298
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
260 define zeroext i1 @test22(i32 %a, i32 %b) nounwind {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
261 ; CHECK-LABEL: @test22(
|
|
121
|
262 ; CHECK-NEXT: [[TMP5:%.*]] = icmp eq i32 [[B:%.*]], [[A:%.*]]
|
|
120
|
263 ; CHECK-NEXT: ret i1 [[TMP5]]
|
|
|
264 ;
|
|
|
265 %tmp2 = sub i32 0, %a
|
|
|
266 %tmp4 = sub i32 0, %b
|
|
|
267 %tmp5 = icmp eq i32 %tmp2, %tmp4
|
|
|
268 ret i1 %tmp5
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
269 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
270
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
271 ; rdar://7362831
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
272 define i32 @test23(i8* %P, i64 %A){
|
|
120
|
273 ; CHECK-LABEL: @test23(
|
|
121
|
274 ; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 [[A:%.*]] to i32
|
|
120
|
275 ; CHECK-NEXT: ret i32 [[TMP1]]
|
|
|
276 ;
|
|
95
|
277 %B = getelementptr inbounds i8, i8* %P, i64 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
278 %C = ptrtoint i8* %B to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
279 %D = trunc i64 %C to i32
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
280 %E = ptrtoint i8* %P to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
281 %F = trunc i64 %E to i32
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
282 %G = sub i32 %D, %F
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
283 ret i32 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
284 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
285
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
286 define i8 @test23_as1(i8 addrspace(1)* %P, i16 %A) {
|
|
120
|
287 ; CHECK-LABEL: @test23_as1(
|
|
121
|
288 ; CHECK-NEXT: [[TMP1:%.*]] = trunc i16 [[A:%.*]] to i8
|
|
120
|
289 ; CHECK-NEXT: ret i8 [[TMP1]]
|
|
|
290 ;
|
|
95
|
291 %B = getelementptr inbounds i8, i8 addrspace(1)* %P, i16 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
292 %C = ptrtoint i8 addrspace(1)* %B to i16
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
293 %D = trunc i16 %C to i8
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
294 %E = ptrtoint i8 addrspace(1)* %P to i16
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
295 %F = trunc i16 %E to i8
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
296 %G = sub i8 %D, %F
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
297 ret i8 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
298 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
299
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
300 define i64 @test24(i8* %P, i64 %A){
|
|
120
|
301 ; CHECK-LABEL: @test24(
|
|
121
|
302 ; CHECK-NEXT: ret i64 [[A:%.*]]
|
|
120
|
303 ;
|
|
95
|
304 %B = getelementptr inbounds i8, i8* %P, i64 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
305 %C = ptrtoint i8* %B to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
306 %E = ptrtoint i8* %P to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
307 %G = sub i64 %C, %E
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
308 ret i64 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
309 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
310
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
311 define i16 @test24_as1(i8 addrspace(1)* %P, i16 %A) {
|
|
120
|
312 ; CHECK-LABEL: @test24_as1(
|
|
121
|
313 ; CHECK-NEXT: ret i16 [[A:%.*]]
|
|
120
|
314 ;
|
|
95
|
315 %B = getelementptr inbounds i8, i8 addrspace(1)* %P, i16 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
316 %C = ptrtoint i8 addrspace(1)* %B to i16
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
317 %E = ptrtoint i8 addrspace(1)* %P to i16
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
318 %G = sub i16 %C, %E
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
319 ret i16 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
320 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
321
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
322 define i64 @test24a(i8* %P, i64 %A){
|
|
120
|
323 ; CHECK-LABEL: @test24a(
|
|
121
|
324 ; CHECK-NEXT: [[DIFF_NEG:%.*]] = sub i64 0, [[A:%.*]]
|
|
120
|
325 ; CHECK-NEXT: ret i64 [[DIFF_NEG]]
|
|
|
326 ;
|
|
95
|
327 %B = getelementptr inbounds i8, i8* %P, i64 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
328 %C = ptrtoint i8* %B to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
329 %E = ptrtoint i8* %P to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
330 %G = sub i64 %E, %C
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
331 ret i64 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
332 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
333
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
334 define i16 @test24a_as1(i8 addrspace(1)* %P, i16 %A) {
|
|
120
|
335 ; CHECK-LABEL: @test24a_as1(
|
|
121
|
336 ; CHECK-NEXT: [[DIFF_NEG:%.*]] = sub i16 0, [[A:%.*]]
|
|
120
|
337 ; CHECK-NEXT: ret i16 [[DIFF_NEG]]
|
|
|
338 ;
|
|
95
|
339 %B = getelementptr inbounds i8, i8 addrspace(1)* %P, i16 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
340 %C = ptrtoint i8 addrspace(1)* %B to i16
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
341 %E = ptrtoint i8 addrspace(1)* %P to i16
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
342 %G = sub i16 %E, %C
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
343 ret i16 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
344 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
345
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
346
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
347 @Arr = external global [42 x i16]
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
348
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
349 define i64 @test24b(i8* %P, i64 %A){
|
|
120
|
350 ; CHECK-LABEL: @test24b(
|
|
121
|
351 ; CHECK-NEXT: [[B_IDX:%.*]] = shl nuw i64 [[A:%.*]], 1
|
|
120
|
352 ; CHECK-NEXT: ret i64 [[B_IDX]]
|
|
|
353 ;
|
|
95
|
354 %B = getelementptr inbounds [42 x i16], [42 x i16]* @Arr, i64 0, i64 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
355 %C = ptrtoint i16* %B to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
356 %G = sub i64 %C, ptrtoint ([42 x i16]* @Arr to i64)
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
357 ret i64 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
358 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
359
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
360
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
361 define i64 @test25(i8* %P, i64 %A){
|
|
120
|
362 ; CHECK-LABEL: @test25(
|
|
121
|
363 ; CHECK-NEXT: [[B_IDX:%.*]] = shl nuw i64 [[A:%.*]], 1
|
|
120
|
364 ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[B_IDX]], -84
|
|
|
365 ; CHECK-NEXT: ret i64 [[TMP1]]
|
|
|
366 ;
|
|
95
|
367 %B = getelementptr inbounds [42 x i16], [42 x i16]* @Arr, i64 0, i64 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
368 %C = ptrtoint i16* %B to i64
|
|
95
|
369 %G = sub i64 %C, ptrtoint (i16* getelementptr ([42 x i16], [42 x i16]* @Arr, i64 1, i64 0) to i64)
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
370 ret i64 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
371 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
372
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
373 @Arr_as1 = external addrspace(1) global [42 x i16]
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
374
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
375 define i16 @test25_as1(i8 addrspace(1)* %P, i64 %A) {
|
|
120
|
376 ; CHECK-LABEL: @test25_as1(
|
|
121
|
377 ; CHECK-NEXT: [[TMP1:%.*]] = trunc i64 [[A:%.*]] to i16
|
|
120
|
378 ; CHECK-NEXT: [[B_IDX:%.*]] = shl nuw i16 [[TMP1]], 1
|
|
|
379 ; CHECK-NEXT: [[TMP2:%.*]] = add i16 [[B_IDX]], -84
|
|
|
380 ; CHECK-NEXT: ret i16 [[TMP2]]
|
|
|
381 ;
|
|
95
|
382 %B = getelementptr inbounds [42 x i16], [42 x i16] addrspace(1)* @Arr_as1, i64 0, i64 %A
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
383 %C = ptrtoint i16 addrspace(1)* %B to i16
|
|
95
|
384 %G = sub i16 %C, ptrtoint (i16 addrspace(1)* getelementptr ([42 x i16], [42 x i16] addrspace(1)* @Arr_as1, i64 1, i64 0) to i16)
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
385 ret i16 %G
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
386 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
387
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
388 define i32 @test26(i32 %x) {
|
|
120
|
389 ; CHECK-LABEL: @test26(
|
|
121
|
390 ; CHECK-NEXT: [[NEG:%.*]] = shl i32 -3, [[X:%.*]]
|
|
120
|
391 ; CHECK-NEXT: ret i32 [[NEG]]
|
|
|
392 ;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
393 %shl = shl i32 3, %x
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
394 %neg = sub i32 0, %shl
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
395 ret i32 %neg
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
396 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
397
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
398 define i32 @test27(i32 %x, i32 %y) {
|
|
120
|
399 ; CHECK-LABEL: @test27(
|
|
121
|
400 ; CHECK-NEXT: [[TMP1:%.*]] = shl i32 [[Y:%.*]], 3
|
|
|
401 ; CHECK-NEXT: [[SUB:%.*]] = add i32 [[TMP1]], [[X:%.*]]
|
|
120
|
402 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
403 ;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
404 %mul = mul i32 %y, -8
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
405 %sub = sub i32 %x, %mul
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
406 ret i32 %sub
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
407 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
408
|
|
121
|
409 define <2 x i32> @test27vec(<2 x i32> %x, <2 x i32> %y) {
|
|
|
410 ; CHECK-LABEL: @test27vec(
|
|
|
411 ; CHECK-NEXT: [[TMP1:%.*]] = mul <2 x i32> [[Y:%.*]], <i32 8, i32 6>
|
|
|
412 ; CHECK-NEXT: [[SUB:%.*]] = add <2 x i32> [[TMP1]], [[X:%.*]]
|
|
|
413 ; CHECK-NEXT: ret <2 x i32> [[SUB]]
|
|
|
414 ;
|
|
|
415 %mul = mul <2 x i32> %y, <i32 -8, i32 -6>
|
|
|
416 %sub = sub <2 x i32> %x, %mul
|
|
|
417 ret <2 x i32> %sub
|
|
|
418 }
|
|
|
419
|
|
|
420 define <2 x i32> @test27vecsplat(<2 x i32> %x, <2 x i32> %y) {
|
|
|
421 ; CHECK-LABEL: @test27vecsplat(
|
|
|
422 ; CHECK-NEXT: [[TMP1:%.*]] = shl <2 x i32> [[Y:%.*]], <i32 3, i32 3>
|
|
|
423 ; CHECK-NEXT: [[SUB:%.*]] = add <2 x i32> [[TMP1]], [[X:%.*]]
|
|
|
424 ; CHECK-NEXT: ret <2 x i32> [[SUB]]
|
|
|
425 ;
|
|
|
426 %mul = mul <2 x i32> %y, <i32 -8, i32 -8>
|
|
|
427 %sub = sub <2 x i32> %x, %mul
|
|
|
428 ret <2 x i32> %sub
|
|
|
429 }
|
|
|
430
|
|
|
431 define <2 x i32> @test27vecmixed(<2 x i32> %x, <2 x i32> %y) {
|
|
|
432 ; CHECK-LABEL: @test27vecmixed(
|
|
|
433 ; CHECK-NEXT: [[TMP1:%.*]] = mul <2 x i32> [[Y:%.*]], <i32 8, i32 -8>
|
|
|
434 ; CHECK-NEXT: [[SUB:%.*]] = add <2 x i32> [[TMP1]], [[X:%.*]]
|
|
|
435 ; CHECK-NEXT: ret <2 x i32> [[SUB]]
|
|
|
436 ;
|
|
|
437 %mul = mul <2 x i32> %y, <i32 -8, i32 8>
|
|
|
438 %sub = sub <2 x i32> %x, %mul
|
|
|
439 ret <2 x i32> %sub
|
|
|
440 }
|
|
|
441
|
|
|
442 define i32 @test27commuted(i32 %x, i32 %y) {
|
|
|
443 ; CHECK-LABEL: @test27commuted(
|
|
|
444 ; CHECK-NEXT: [[TMP1:%.*]] = shl i32 [[Y:%.*]], 3
|
|
|
445 ; CHECK-NEXT: [[SUB:%.*]] = add i32 [[TMP1]], [[X:%.*]]
|
|
|
446 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
447 ;
|
|
|
448 %mul = mul i32 -8, %y
|
|
|
449 %sub = sub i32 %x, %mul
|
|
|
450 ret i32 %sub
|
|
|
451 }
|
|
|
452
|
|
|
453 define <2 x i32> @test27commutedvec(<2 x i32> %x, <2 x i32> %y) {
|
|
|
454 ; CHECK-LABEL: @test27commutedvec(
|
|
|
455 ; CHECK-NEXT: [[TMP1:%.*]] = mul <2 x i32> [[Y:%.*]], <i32 8, i32 6>
|
|
|
456 ; CHECK-NEXT: [[SUB:%.*]] = add <2 x i32> [[TMP1]], [[X:%.*]]
|
|
|
457 ; CHECK-NEXT: ret <2 x i32> [[SUB]]
|
|
|
458 ;
|
|
|
459 %mul = mul <2 x i32> <i32 -8, i32 -6>, %y
|
|
|
460 %sub = sub <2 x i32> %x, %mul
|
|
|
461 ret <2 x i32> %sub
|
|
|
462 }
|
|
|
463
|
|
|
464 define <2 x i32> @test27commutedvecsplat(<2 x i32> %x, <2 x i32> %y) {
|
|
|
465 ; CHECK-LABEL: @test27commutedvecsplat(
|
|
|
466 ; CHECK-NEXT: [[TMP1:%.*]] = shl <2 x i32> [[Y:%.*]], <i32 3, i32 3>
|
|
|
467 ; CHECK-NEXT: [[SUB:%.*]] = add <2 x i32> [[TMP1]], [[X:%.*]]
|
|
|
468 ; CHECK-NEXT: ret <2 x i32> [[SUB]]
|
|
|
469 ;
|
|
|
470 %mul = mul <2 x i32> <i32 -8, i32 -8>, %y
|
|
|
471 %sub = sub <2 x i32> %x, %mul
|
|
|
472 ret <2 x i32> %sub
|
|
|
473 }
|
|
|
474
|
|
|
475 define <2 x i32> @test27commutedvecmixed(<2 x i32> %x, <2 x i32> %y) {
|
|
|
476 ; CHECK-LABEL: @test27commutedvecmixed(
|
|
|
477 ; CHECK-NEXT: [[TMP1:%.*]] = mul <2 x i32> [[Y:%.*]], <i32 8, i32 -8>
|
|
|
478 ; CHECK-NEXT: [[SUB:%.*]] = add <2 x i32> [[TMP1]], [[X:%.*]]
|
|
|
479 ; CHECK-NEXT: ret <2 x i32> [[SUB]]
|
|
|
480 ;
|
|
|
481 %mul = mul <2 x i32> <i32 -8, i32 8>, %y
|
|
|
482 %sub = sub <2 x i32> %x, %mul
|
|
|
483 ret <2 x i32> %sub
|
|
|
484 }
|
|
|
485
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
486 define i32 @test28(i32 %x, i32 %y, i32 %z) {
|
|
120
|
487 ; CHECK-LABEL: @test28(
|
|
121
|
488 ; CHECK-NEXT: [[TMP1:%.*]] = mul i32 [[Z:%.*]], [[Y:%.*]]
|
|
|
489 ; CHECK-NEXT: [[SUB:%.*]] = add i32 [[TMP1]], [[X:%.*]]
|
|
120
|
490 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
491 ;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
492 %neg = sub i32 0, %z
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
493 %mul = mul i32 %neg, %y
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
494 %sub = sub i32 %x, %mul
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
495 ret i32 %sub
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
496 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
497
|
|
121
|
498 define i32 @test28commuted(i32 %x, i32 %y, i32 %z) {
|
|
|
499 ; CHECK-LABEL: @test28commuted(
|
|
|
500 ; CHECK-NEXT: [[TMP1:%.*]] = mul i32 [[Y:%.*]], [[Z:%.*]]
|
|
|
501 ; CHECK-NEXT: [[SUB:%.*]] = add i32 [[TMP1]], [[X:%.*]]
|
|
|
502 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
503 ;
|
|
|
504 %neg = sub i32 0, %z
|
|
|
505 %mul = mul i32 %y, %neg
|
|
|
506 %sub = sub i32 %x, %mul
|
|
|
507 ret i32 %sub
|
|
|
508 }
|
|
|
509
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
510 define i64 @test29(i8* %foo, i64 %i, i64 %j) {
|
|
120
|
511 ; CHECK-LABEL: @test29(
|
|
121
|
512 ; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[I:%.*]], [[J:%.*]]
|
|
120
|
513 ; CHECK-NEXT: ret i64 [[TMP1]]
|
|
|
514 ;
|
|
95
|
515 %gep1 = getelementptr inbounds i8, i8* %foo, i64 %i
|
|
|
516 %gep2 = getelementptr inbounds i8, i8* %foo, i64 %j
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
517 %cast1 = ptrtoint i8* %gep1 to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
518 %cast2 = ptrtoint i8* %gep2 to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
519 %sub = sub i64 %cast1, %cast2
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
520 ret i64 %sub
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
521 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
522
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
523 define i64 @test30(i8* %foo, i64 %i, i64 %j) {
|
|
120
|
524 ; CHECK-LABEL: @test30(
|
|
121
|
525 ; CHECK-NEXT: [[GEP1_IDX:%.*]] = shl nuw i64 [[I:%.*]], 2
|
|
|
526 ; CHECK-NEXT: [[TMP1:%.*]] = sub i64 [[GEP1_IDX]], [[J:%.*]]
|
|
120
|
527 ; CHECK-NEXT: ret i64 [[TMP1]]
|
|
|
528 ;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
529 %bit = bitcast i8* %foo to i32*
|
|
95
|
530 %gep1 = getelementptr inbounds i32, i32* %bit, i64 %i
|
|
|
531 %gep2 = getelementptr inbounds i8, i8* %foo, i64 %j
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
532 %cast1 = ptrtoint i32* %gep1 to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
533 %cast2 = ptrtoint i8* %gep2 to i64
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
534 %sub = sub i64 %cast1, %cast2
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
535 ret i64 %sub
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
536 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
537
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
538 define i16 @test30_as1(i8 addrspace(1)* %foo, i16 %i, i16 %j) {
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
539 ; CHECK-LABEL: @test30_as1(
|
|
121
|
540 ; CHECK-NEXT: [[GEP1_IDX:%.*]] = shl nuw i16 [[I:%.*]], 2
|
|
|
541 ; CHECK-NEXT: [[TMP1:%.*]] = sub i16 [[GEP1_IDX]], [[J:%.*]]
|
|
120
|
542 ; CHECK-NEXT: ret i16 [[TMP1]]
|
|
|
543 ;
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
544 %bit = bitcast i8 addrspace(1)* %foo to i32 addrspace(1)*
|
|
95
|
545 %gep1 = getelementptr inbounds i32, i32 addrspace(1)* %bit, i16 %i
|
|
|
546 %gep2 = getelementptr inbounds i8, i8 addrspace(1)* %foo, i16 %j
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
547 %cast1 = ptrtoint i32 addrspace(1)* %gep1 to i16
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
548 %cast2 = ptrtoint i8 addrspace(1)* %gep2 to i16
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
549 %sub = sub i16 %cast1, %cast2
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
550 ret i16 %sub
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
551 }
|
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
552
|
|
77
|
553 define <2 x i64> @test31(<2 x i64> %A) {
|
|
120
|
554 ; CHECK-LABEL: @test31(
|
|
121
|
555 ; CHECK-NEXT: [[SUB:%.*]] = add <2 x i64> [[A:%.*]], <i64 3, i64 4>
|
|
120
|
556 ; CHECK-NEXT: ret <2 x i64> [[SUB]]
|
|
|
557 ;
|
|
77
|
558 %xor = xor <2 x i64> %A, <i64 -1, i64 -1>
|
|
|
559 %sub = sub <2 x i64> <i64 2, i64 3>, %xor
|
|
|
560 ret <2 x i64> %sub
|
|
|
561 }
|
0
Kaito Tokumori <e105711@ie.u-ryukyu.ac.jp>
parents:
diff
changeset
|
562
|
|
77
|
563 define <2 x i64> @test32(<2 x i64> %A) {
|
|
120
|
564 ; CHECK-LABEL: @test32(
|
|
121
|
565 ; CHECK-NEXT: [[SUB:%.*]] = sub <2 x i64> <i64 3, i64 4>, [[A:%.*]]
|
|
120
|
566 ; CHECK-NEXT: ret <2 x i64> [[SUB]]
|
|
|
567 ;
|
|
77
|
568 %add = add <2 x i64> %A, <i64 -1, i64 -1>
|
|
|
569 %sub = sub <2 x i64> <i64 2, i64 3>, %add
|
|
|
570 ret <2 x i64> %sub
|
|
|
571 }
|
|
|
572
|
|
|
573 define <2 x i64> @test33(<2 x i1> %A) {
|
|
120
|
574 ; CHECK-LABEL: @test33(
|
|
121
|
575 ; CHECK-NEXT: [[SUB:%.*]] = sext <2 x i1> [[A:%.*]] to <2 x i64>
|
|
120
|
576 ; CHECK-NEXT: ret <2 x i64> [[SUB]]
|
|
|
577 ;
|
|
77
|
578 %ext = zext <2 x i1> %A to <2 x i64>
|
|
|
579 %sub = sub <2 x i64> zeroinitializer, %ext
|
|
|
580 ret <2 x i64> %sub
|
|
|
581 }
|
|
|
582
|
|
|
583 define <2 x i64> @test34(<2 x i1> %A) {
|
|
120
|
584 ; CHECK-LABEL: @test34(
|
|
121
|
585 ; CHECK-NEXT: [[SUB:%.*]] = zext <2 x i1> [[A:%.*]] to <2 x i64>
|
|
120
|
586 ; CHECK-NEXT: ret <2 x i64> [[SUB]]
|
|
|
587 ;
|
|
77
|
588 %ext = sext <2 x i1> %A to <2 x i64>
|
|
|
589 %sub = sub <2 x i64> zeroinitializer, %ext
|
|
|
590 ret <2 x i64> %sub
|
|
|
591 }
|
|
|
592
|
|
|
593 define <2 x i64> @test35(<2 x i64> %A) {
|
|
120
|
594 ; CHECK-LABEL: @test35(
|
|
121
|
595 ; CHECK-NEXT: [[SUB:%.*]] = mul <2 x i64> [[A:%.*]], <i64 -2, i64 -3>
|
|
120
|
596 ; CHECK-NEXT: ret <2 x i64> [[SUB]]
|
|
|
597 ;
|
|
77
|
598 %mul = mul <2 x i64> %A, <i64 3, i64 4>
|
|
|
599 %sub = sub <2 x i64> %A, %mul
|
|
|
600 ret <2 x i64> %sub
|
|
|
601 }
|
|
|
602
|
|
|
603 define <2 x i64> @test36(<2 x i64> %A) {
|
|
120
|
604 ; CHECK-LABEL: @test36(
|
|
121
|
605 ; CHECK-NEXT: [[SUB:%.*]] = mul <2 x i64> [[A:%.*]], <i64 7, i64 15>
|
|
120
|
606 ; CHECK-NEXT: ret <2 x i64> [[SUB]]
|
|
|
607 ;
|
|
77
|
608 %shl = shl <2 x i64> %A, <i64 3, i64 4>
|
|
|
609 %sub = sub <2 x i64> %shl, %A
|
|
|
610 ret <2 x i64> %sub
|
|
|
611 }
|
|
|
612
|
|
|
613 define <2 x i32> @test37(<2 x i32> %A) {
|
|
120
|
614 ; CHECK-LABEL: @test37(
|
|
121
|
615 ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq <2 x i32> [[A:%.*]], <i32 -2147483648, i32 -2147483648>
|
|
120
|
616 ; CHECK-NEXT: [[SUB:%.*]] = sext <2 x i1> [[TMP1]] to <2 x i32>
|
|
|
617 ; CHECK-NEXT: ret <2 x i32> [[SUB]]
|
|
|
618 ;
|
|
77
|
619 %div = sdiv <2 x i32> %A, <i32 -2147483648, i32 -2147483648>
|
|
|
620 %sub = sub nsw <2 x i32> zeroinitializer, %div
|
|
|
621 ret <2 x i32> %sub
|
|
|
622 }
|
|
|
623
|
|
|
624 define i32 @test38(i32 %A) {
|
|
120
|
625 ; CHECK-LABEL: @test38(
|
|
121
|
626 ; CHECK-NEXT: [[TMP1:%.*]] = icmp eq i32 [[A:%.*]], -2147483648
|
|
120
|
627 ; CHECK-NEXT: [[SUB:%.*]] = sext i1 [[TMP1]] to i32
|
|
|
628 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
629 ;
|
|
77
|
630 %div = sdiv i32 %A, -2147483648
|
|
|
631 %sub = sub nsw i32 0, %div
|
|
|
632 ret i32 %sub
|
|
|
633 }
|
|
|
634
|
|
|
635 define i32 @test39(i32 %A, i32 %x) {
|
|
120
|
636 ; CHECK-LABEL: @test39(
|
|
121
|
637 ; CHECK-NEXT: [[C:%.*]] = add i32 [[X:%.*]], [[A:%.*]]
|
|
120
|
638 ; CHECK-NEXT: ret i32 [[C]]
|
|
|
639 ;
|
|
77
|
640 %B = sub i32 0, %A
|
|
|
641 %C = sub nsw i32 %x, %B
|
|
|
642 ret i32 %C
|
|
|
643 }
|
|
|
644
|
|
|
645 define i16 @test40(i16 %a, i16 %b) {
|
|
120
|
646 ; CHECK-LABEL: @test40(
|
|
121
|
647 ; CHECK-NEXT: [[ASHR:%.*]] = ashr i16 [[A:%.*]], 1
|
|
|
648 ; CHECK-NEXT: [[ASHR1:%.*]] = ashr i16 [[B:%.*]], 1
|
|
120
|
649 ; CHECK-NEXT: [[SUB:%.*]] = sub nsw i16 [[ASHR]], [[ASHR1]]
|
|
|
650 ; CHECK-NEXT: ret i16 [[SUB]]
|
|
|
651 ;
|
|
77
|
652 %ashr = ashr i16 %a, 1
|
|
|
653 %ashr1 = ashr i16 %b, 1
|
|
|
654 %sub = sub i16 %ashr, %ashr1
|
|
|
655 ret i16 %sub
|
|
|
656 }
|
|
|
657
|
|
|
658 define i32 @test41(i16 %a, i16 %b) {
|
|
120
|
659 ; CHECK-LABEL: @test41(
|
|
121
|
660 ; CHECK-NEXT: [[CONV:%.*]] = sext i16 [[A:%.*]] to i32
|
|
|
661 ; CHECK-NEXT: [[CONV1:%.*]] = sext i16 [[B:%.*]] to i32
|
|
120
|
662 ; CHECK-NEXT: [[SUB:%.*]] = sub nsw i32 [[CONV]], [[CONV1]]
|
|
|
663 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
664 ;
|
|
77
|
665 %conv = sext i16 %a to i32
|
|
|
666 %conv1 = sext i16 %b to i32
|
|
|
667 %sub = sub i32 %conv, %conv1
|
|
|
668 ret i32 %sub
|
|
|
669 }
|
|
|
670
|
|
|
671 define i4 @test42(i4 %x, i4 %y) {
|
|
120
|
672 ; CHECK-LABEL: @test42(
|
|
121
|
673 ; CHECK-NEXT: [[A:%.*]] = and i4 [[Y:%.*]], 7
|
|
|
674 ; CHECK-NEXT: [[B:%.*]] = and i4 [[X:%.*]], 7
|
|
120
|
675 ; CHECK-NEXT: [[C:%.*]] = sub nsw i4 [[A]], [[B]]
|
|
|
676 ; CHECK-NEXT: ret i4 [[C]]
|
|
|
677 ;
|
|
77
|
678 %a = and i4 %y, 7
|
|
|
679 %b = and i4 %x, 7
|
|
|
680 %c = sub i4 %a, %b
|
|
|
681 ret i4 %c
|
|
|
682 }
|
|
|
683
|
|
|
684 define i4 @test43(i4 %x, i4 %y) {
|
|
120
|
685 ; CHECK-LABEL: @test43(
|
|
121
|
686 ; CHECK-NEXT: [[A:%.*]] = or i4 [[X:%.*]], -8
|
|
|
687 ; CHECK-NEXT: [[B:%.*]] = and i4 [[Y:%.*]], 7
|
|
120
|
688 ; CHECK-NEXT: [[C:%.*]] = sub nuw i4 [[A]], [[B]]
|
|
|
689 ; CHECK-NEXT: ret i4 [[C]]
|
|
|
690 ;
|
|
77
|
691 %a = or i4 %x, -8
|
|
|
692 %b = and i4 %y, 7
|
|
|
693 %c = sub i4 %a, %b
|
|
|
694 ret i4 %c
|
|
|
695 }
|
|
|
696
|
|
|
697 define i32 @test44(i32 %x) {
|
|
120
|
698 ; CHECK-LABEL: @test44(
|
|
121
|
699 ; CHECK-NEXT: [[SUB:%.*]] = add nsw i32 [[X:%.*]], -32768
|
|
120
|
700 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
701 ;
|
|
77
|
702 %sub = sub nsw i32 %x, 32768
|
|
|
703 ret i32 %sub
|
|
|
704 }
|
|
83
|
705
|
|
|
706 define i32 @test45(i32 %x, i32 %y) {
|
|
120
|
707 ; CHECK-LABEL: @test45(
|
|
121
|
708 ; CHECK-NEXT: [[SUB:%.*]] = and i32 [[X:%.*]], [[Y:%.*]]
|
|
120
|
709 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
710 ;
|
|
83
|
711 %or = or i32 %x, %y
|
|
|
712 %xor = xor i32 %x, %y
|
|
|
713 %sub = sub i32 %or, %xor
|
|
|
714 ret i32 %sub
|
|
|
715 }
|
|
|
716
|
|
121
|
717 define i32 @test45commuted(i32 %x, i32 %y) {
|
|
|
718 ; CHECK-LABEL: @test45commuted(
|
|
|
719 ; CHECK-NEXT: [[SUB:%.*]] = and i32 [[Y:%.*]], [[X:%.*]]
|
|
|
720 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
721 ;
|
|
|
722 %or = or i32 %x, %y
|
|
|
723 %xor = xor i32 %y, %x
|
|
|
724 %sub = sub i32 %or, %xor
|
|
|
725 ret i32 %sub
|
|
|
726 }
|
|
|
727
|
|
83
|
728 define i32 @test46(i32 %x, i32 %y) {
|
|
|
729 ; CHECK-LABEL: @test46(
|
|
121
|
730 ; CHECK-NEXT: [[X_NOT:%.*]] = xor i32 [[X:%.*]], -1
|
|
|
731 ; CHECK-NEXT: [[SUB:%.*]] = and i32 [[X_NOT]], [[Y:%.*]]
|
|
120
|
732 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
733 ;
|
|
|
734 %or = or i32 %x, %y
|
|
|
735 %sub = sub i32 %or, %x
|
|
|
736 ret i32 %sub
|
|
83
|
737 }
|
|
95
|
738
|
|
121
|
739 define i32 @test46commuted(i32 %x, i32 %y) {
|
|
|
740 ; CHECK-LABEL: @test46commuted(
|
|
|
741 ; CHECK-NEXT: [[X_NOT:%.*]] = xor i32 [[X:%.*]], -1
|
|
|
742 ; CHECK-NEXT: [[SUB:%.*]] = and i32 [[X_NOT]], [[Y:%.*]]
|
|
|
743 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
744 ;
|
|
|
745 %or = or i32 %y, %x
|
|
|
746 %sub = sub i32 %or, %x
|
|
|
747 ret i32 %sub
|
|
|
748 }
|
|
|
749
|
|
95
|
750 define i32 @test47(i1 %A, i32 %B, i32 %C, i32 %D) {
|
|
120
|
751 ; CHECK-LABEL: @test47(
|
|
121
|
752 ; CHECK-NEXT: [[TMP1:%.*]] = sub i32 [[D:%.*]], [[C:%.*]]
|
|
|
753 ; CHECK-NEXT: [[SUB:%.*]] = select i1 [[A:%.*]], i32 [[TMP1]], i32 0
|
|
120
|
754 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
755 ;
|
|
95
|
756 %sel0 = select i1 %A, i32 %D, i32 %B
|
|
|
757 %sel1 = select i1 %A, i32 %C, i32 %B
|
|
|
758 %sub = sub i32 %sel0, %sel1
|
|
|
759 ret i32 %sub
|
|
|
760 }
|
|
|
761
|
|
|
762 define i32 @test48(i1 %A, i32 %B, i32 %C, i32 %D) {
|
|
120
|
763 ; CHECK-LABEL: @test48(
|
|
121
|
764 ; CHECK-NEXT: [[TMP1:%.*]] = sub i32 [[D:%.*]], [[C:%.*]]
|
|
|
765 ; CHECK-NEXT: [[SUB:%.*]] = select i1 [[A:%.*]], i32 0, i32 [[TMP1]]
|
|
120
|
766 ; CHECK-NEXT: ret i32 [[SUB]]
|
|
|
767 ;
|
|
95
|
768 %sel0 = select i1 %A, i32 %B, i32 %D
|
|
|
769 %sel1 = select i1 %A, i32 %B, i32 %C
|
|
|
770 %sub = sub i32 %sel0, %sel1
|
|
|
771 ret i32 %sub
|
|
120
|
772 }
|
|
|
773
|
|
|
774 ; Zext+add is more canonical than sext+sub.
|
|
|
775
|
|
|
776 define i8 @bool_sext_sub(i8 %x, i1 %y) {
|
|
|
777 ; CHECK-LABEL: @bool_sext_sub(
|
|
121
|
778 ; CHECK-NEXT: [[TMP1:%.*]] = zext i1 [[Y:%.*]] to i8
|
|
|
779 ; CHECK-NEXT: [[SUB:%.*]] = add i8 [[TMP1]], [[X:%.*]]
|
|
120
|
780 ; CHECK-NEXT: ret i8 [[SUB]]
|
|
|
781 ;
|
|
|
782 %sext = sext i1 %y to i8
|
|
|
783 %sub = sub i8 %x, %sext
|
|
|
784 ret i8 %sub
|
|
|
785 }
|
|
|
786
|
|
|
787 ; Vectors get the same transform.
|
|
|
788
|
|
|
789 define <2 x i8> @bool_sext_sub_vec(<2 x i8> %x, <2 x i1> %y) {
|
|
|
790 ; CHECK-LABEL: @bool_sext_sub_vec(
|
|
121
|
791 ; CHECK-NEXT: [[TMP1:%.*]] = zext <2 x i1> [[Y:%.*]] to <2 x i8>
|
|
|
792 ; CHECK-NEXT: [[SUB:%.*]] = add <2 x i8> [[TMP1]], [[X:%.*]]
|
|
120
|
793 ; CHECK-NEXT: ret <2 x i8> [[SUB]]
|
|
|
794 ;
|
|
|
795 %sext = sext <2 x i1> %y to <2 x i8>
|
|
|
796 %sub = sub <2 x i8> %x, %sext
|
|
|
797 ret <2 x i8> %sub
|
|
95
|
798 }
|
|
120
|
799
|
|
|
800 ; NSW is preserved.
|
|
|
801
|
|
|
802 define <2 x i8> @bool_sext_sub_vec_nsw(<2 x i8> %x, <2 x i1> %y) {
|
|
|
803 ; CHECK-LABEL: @bool_sext_sub_vec_nsw(
|
|
121
|
804 ; CHECK-NEXT: [[TMP1:%.*]] = zext <2 x i1> [[Y:%.*]] to <2 x i8>
|
|
|
805 ; CHECK-NEXT: [[SUB:%.*]] = add nsw <2 x i8> [[TMP1]], [[X:%.*]]
|
|
120
|
806 ; CHECK-NEXT: ret <2 x i8> [[SUB]]
|
|
|
807 ;
|
|
|
808 %sext = sext <2 x i1> %y to <2 x i8>
|
|
|
809 %sub = sub nsw <2 x i8> %x, %sext
|
|
|
810 ret <2 x i8> %sub
|
|
|
811 }
|
|
|
812
|
|
|
813 ; We favor the canonical zext+add over keeping the NUW.
|
|
|
814
|
|
|
815 define i8 @bool_sext_sub_nuw(i8 %x, i1 %y) {
|
|
|
816 ; CHECK-LABEL: @bool_sext_sub_nuw(
|
|
121
|
817 ; CHECK-NEXT: [[TMP1:%.*]] = zext i1 [[Y:%.*]] to i8
|
|
|
818 ; CHECK-NEXT: [[SUB:%.*]] = add i8 [[TMP1]], [[X:%.*]]
|
|
120
|
819 ; CHECK-NEXT: ret i8 [[SUB]]
|
|
|
820 ;
|
|
|
821 %sext = sext i1 %y to i8
|
|
|
822 %sub = sub nuw i8 %x, %sext
|
|
|
823 ret i8 %sub
|
|
|
824 }
|
|
|
825
|
|
121
|
826 define i32 @test49(i32 %X) {
|
|
|
827 ; CHECK-LABEL: @test49(
|
|
|
828 ; CHECK-NEXT: [[SUB:%.*]] = sub i32 1, [[X:%.*]]
|
|
|
829 ; CHECK-NEXT: [[RES:%.*]] = and i32 [[SUB]], 64
|
|
|
830 ; CHECK-NEXT: ret i32 [[RES]]
|
|
|
831 ;
|
|
|
832 %sub = sub i32 129, %X
|
|
|
833 %res = and i32 %sub, 64
|
|
|
834 ret i32 %res
|
|
|
835 }
|
|
|
836
|
|
|
837 define i32 @test50(i32 %X) {
|
|
|
838 ; CHECK-LABEL: @test50(
|
|
|
839 ; CHECK-NEXT: [[SUB:%.*]] = sub i32 1, [[X:%.*]]
|
|
|
840 ; CHECK-NEXT: [[RES:%.*]] = and i32 [[SUB]], 127
|
|
|
841 ; CHECK-NEXT: ret i32 [[RES]]
|
|
|
842 ;
|
|
|
843 %sub = sub i32 129, %X
|
|
|
844 %res = and i32 %sub, 127
|
|
|
845 ret i32 %res
|
|
|
846 }
|
|
|
847
|
|
|
848 define i32 @test51(i32 %X) {
|
|
|
849 ; CHECK-LABEL: @test51(
|
|
|
850 ; CHECK-NEXT: [[SUB:%.*]] = sub i32 126, [[X:%.*]]
|
|
|
851 ; CHECK-NEXT: [[RES:%.*]] = and i32 [[SUB]], 64
|
|
|
852 ; CHECK-NEXT: ret i32 [[RES]]
|
|
|
853 ;
|
|
|
854 %sub = sub i32 254, %X
|
|
|
855 %res = and i32 %sub, 64
|
|
|
856 ret i32 %res
|
|
|
857 }
|
|
|
858
|
|
|
859 define i32 @test52(i32 %X) {
|
|
|
860 ; CHECK-LABEL: @test52(
|
|
|
861 ; CHECK-NEXT: [[SUB:%.*]] = sub i32 126, [[X:%.*]]
|
|
|
862 ; CHECK-NEXT: [[RES:%.*]] = and i32 [[SUB]], 127
|
|
|
863 ; CHECK-NEXT: ret i32 [[RES]]
|
|
|
864 ;
|
|
|
865 %sub = sub i32 254, %X
|
|
|
866 %res = and i32 %sub, 127
|
|
|
867 ret i32 %res
|
|
|
868 }
|
|
|
869
|
|
|
870 define <2 x i1> @test53(<2 x i1> %A, <2 x i1> %B) {
|
|
|
871 ; CHECK-LABEL: @test53(
|
|
|
872 ; CHECK-NEXT: [[SUB:%.*]] = xor <2 x i1> [[A:%.*]], [[B:%.*]]
|
|
|
873 ; CHECK-NEXT: ret <2 x i1> [[SUB]]
|
|
|
874 ;
|
|
|
875 %sub = sub <2 x i1> %A, %B
|
|
|
876 ret <2 x i1> %sub
|
|
|
877 }
|
|
|
878
|
|
|
879 define i32 @test54(i1 %C) {
|
|
|
880 ; CHECK-LABEL: @test54(
|
|
|
881 ; CHECK-NEXT: [[V:%.*]] = select i1 [[C:%.*]], i32 -877, i32 113
|
|
|
882 ; CHECK-NEXT: ret i32 [[V]]
|
|
|
883 ;
|
|
|
884 %A = select i1 %C, i32 1000, i32 10
|
|
|
885 %V = sub i32 123, %A
|
|
|
886 ret i32 %V
|
|
|
887 }
|
|
|
888
|
|
|
889 define <2 x i32> @test54vec(i1 %C) {
|
|
|
890 ; CHECK-LABEL: @test54vec(
|
|
|
891 ; CHECK-NEXT: [[V:%.*]] = select i1 [[C:%.*]], <2 x i32> <i32 -877, i32 -877>, <2 x i32> <i32 113, i32 113>
|
|
|
892 ; CHECK-NEXT: ret <2 x i32> [[V]]
|
|
|
893 ;
|
|
|
894 %A = select i1 %C, <2 x i32> <i32 1000, i32 1000>, <2 x i32> <i32 10, i32 10>
|
|
|
895 %V = sub <2 x i32> <i32 123, i32 123>, %A
|
|
|
896 ret <2 x i32> %V
|
|
|
897 }
|
|
|
898
|
|
|
899 define <2 x i32> @test54vec2(i1 %C) {
|
|
|
900 ; CHECK-LABEL: @test54vec2(
|
|
|
901 ; CHECK-NEXT: [[V:%.*]] = select i1 [[C:%.*]], <2 x i32> <i32 -877, i32 -2167>, <2 x i32> <i32 113, i32 303>
|
|
|
902 ; CHECK-NEXT: ret <2 x i32> [[V]]
|
|
|
903 ;
|
|
|
904 %A = select i1 %C, <2 x i32> <i32 1000, i32 2500>, <2 x i32> <i32 10, i32 30>
|
|
|
905 %V = sub <2 x i32> <i32 123, i32 333>, %A
|
|
|
906 ret <2 x i32> %V
|
|
|
907 }
|
|
|
908
|
|
|
909 define i32 @test55(i1 %which) {
|
|
|
910 ; CHECK-LABEL: @test55(
|
|
|
911 ; CHECK-NEXT: entry:
|
|
|
912 ; CHECK-NEXT: br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
|
|
|
913 ; CHECK: delay:
|
|
|
914 ; CHECK-NEXT: br label [[FINAL]]
|
|
|
915 ; CHECK: final:
|
|
|
916 ; CHECK-NEXT: [[A:%.*]] = phi i32 [ -877, [[ENTRY:%.*]] ], [ 113, [[DELAY]] ]
|
|
|
917 ; CHECK-NEXT: ret i32 [[A]]
|
|
|
918 ;
|
|
|
919 entry:
|
|
|
920 br i1 %which, label %final, label %delay
|
|
|
921
|
|
|
922 delay:
|
|
|
923 br label %final
|
|
|
924
|
|
|
925 final:
|
|
|
926 %A = phi i32 [ 1000, %entry ], [ 10, %delay ]
|
|
|
927 %value = sub i32 123, %A
|
|
|
928 ret i32 %value
|
|
|
929 }
|
|
|
930
|
|
|
931 define <2 x i32> @test55vec(i1 %which) {
|
|
|
932 ; CHECK-LABEL: @test55vec(
|
|
|
933 ; CHECK-NEXT: entry:
|
|
|
934 ; CHECK-NEXT: br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
|
|
|
935 ; CHECK: delay:
|
|
|
936 ; CHECK-NEXT: br label [[FINAL]]
|
|
|
937 ; CHECK: final:
|
|
|
938 ; CHECK-NEXT: [[A:%.*]] = phi <2 x i32> [ <i32 -877, i32 -877>, [[ENTRY:%.*]] ], [ <i32 113, i32 113>, [[DELAY]] ]
|
|
|
939 ; CHECK-NEXT: ret <2 x i32> [[A]]
|
|
|
940 ;
|
|
|
941 entry:
|
|
|
942 br i1 %which, label %final, label %delay
|
|
|
943
|
|
|
944 delay:
|
|
|
945 br label %final
|
|
|
946
|
|
|
947 final:
|
|
|
948 %A = phi <2 x i32> [ <i32 1000, i32 1000>, %entry ], [ <i32 10, i32 10>, %delay ]
|
|
|
949 %value = sub <2 x i32> <i32 123, i32 123>, %A
|
|
|
950 ret <2 x i32> %value
|
|
|
951 }
|
|
|
952
|
|
|
953 define <2 x i32> @test55vec2(i1 %which) {
|
|
|
954 ; CHECK-LABEL: @test55vec2(
|
|
|
955 ; CHECK-NEXT: entry:
|
|
|
956 ; CHECK-NEXT: br i1 [[WHICH:%.*]], label [[FINAL:%.*]], label [[DELAY:%.*]]
|
|
|
957 ; CHECK: delay:
|
|
|
958 ; CHECK-NEXT: br label [[FINAL]]
|
|
|
959 ; CHECK: final:
|
|
|
960 ; CHECK-NEXT: [[A:%.*]] = phi <2 x i32> [ <i32 -877, i32 -2167>, [[ENTRY:%.*]] ], [ <i32 113, i32 303>, [[DELAY]] ]
|
|
|
961 ; CHECK-NEXT: ret <2 x i32> [[A]]
|
|
|
962 ;
|
|
|
963 entry:
|
|
|
964 br i1 %which, label %final, label %delay
|
|
|
965
|
|
|
966 delay:
|
|
|
967 br label %final
|
|
|
968
|
|
|
969 final:
|
|
|
970 %A = phi <2 x i32> [ <i32 1000, i32 2500>, %entry ], [ <i32 10, i32 30>, %delay ]
|
|
|
971 %value = sub <2 x i32> <i32 123, i32 333>, %A
|
|
|
972 ret <2 x i32> %value
|
|
|
973 }
|
|
|
974
|
|
|
975 define i32 @test56(i32 %A, i32 %B) {
|
|
|
976 ; CHECK-LABEL: @test56(
|
|
|
977 ; CHECK-NEXT: [[Y:%.*]] = sub i32 0, [[B:%.*]]
|
|
|
978 ; CHECK-NEXT: ret i32 [[Y]]
|
|
|
979 ;
|
|
|
980 %X = add i32 %A, %B
|
|
|
981 %Y = sub i32 %A, %X
|
|
|
982 ret i32 %Y }
|
|
|
983
|
|
|
984 define i32 @test57(i32 %A, i32 %B) {
|
|
|
985 ; CHECK-LABEL: @test57(
|
|
|
986 ; CHECK-NEXT: [[Y:%.*]] = sub i32 0, [[B:%.*]]
|
|
|
987 ; CHECK-NEXT: ret i32 [[Y]]
|
|
|
988 ;
|
|
|
989 %X = add i32 %B, %A
|
|
|
990 %Y = sub i32 %A, %X
|
|
|
991 ret i32 %Y }
|
|
|
992
|
|
|
993 @dummy_global1 = external global i8*
|
|
|
994 @dummy_global2 = external global i8*
|
|
|
995
|
|
|
996 define i64 @test58([100 x [100 x i8]]* %foo, i64 %i, i64 %j) {
|
|
|
997 ; CHECK-LABEL: @test58(
|
|
|
998 ; CHECK-NEXT: [[TMP1:%.*]] = add i64 [[J:%.*]], 4200
|
|
|
999 ; CHECK-NEXT: [[TMP2:%.*]] = add i64 [[I:%.*]], 4200
|
|
|
1000 ; CHECK-NEXT: [[TMP3:%.*]] = sub i64 [[TMP2:%.*]] [[TMP1:%.*]]
|
|
|
1001 ; CHECK-NEXT: ret i64 [[TMP3]]
|
|
|
1002 ;
|
|
|
1003 ; Note the reassociate pass and another instcombine pass will further optimize this to
|
|
|
1004 ; "%sub = i64 %i, %j, ret i64 %sub"
|
|
|
1005 ;
|
|
|
1006 ; gep1 and gep2 have only one use
|
|
|
1007 %gep1 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 %i
|
|
|
1008 %gep2 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 %j
|
|
|
1009 %cast1 = ptrtoint i8* %gep1 to i64
|
|
|
1010 %cast2 = ptrtoint i8* %gep2 to i64
|
|
|
1011 %sub = sub i64 %cast1, %cast2
|
|
|
1012 ret i64 %sub
|
|
|
1013 }
|
|
|
1014
|
|
|
1015 define i64 @test59([100 x [100 x i8]]* %foo, i64 %i) {
|
|
|
1016 ; CHECK-LABEL: @test59(
|
|
|
1017 ; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 %i
|
|
|
1018 ; CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 0
|
|
|
1019 ; CHECK-NEXT: store i8* [[GEP1]], i8** @dummy_global1, align 8
|
|
|
1020 ; CHECK-NEXT: store i8* [[GEP2]], i8** @dummy_global2, align 8
|
|
|
1021 ; CHECK-NEXT: ret i64 %i
|
|
|
1022 ;
|
|
|
1023 ; gep1 and gep2 have more than one uses
|
|
|
1024 %gep1 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 %i
|
|
|
1025 %gep2 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 0
|
|
|
1026 %cast1 = ptrtoint i8* %gep1 to i64
|
|
|
1027 %cast2 = ptrtoint i8* %gep2 to i64
|
|
|
1028 %sub = sub i64 %cast1, %cast2
|
|
|
1029 store i8* %gep1, i8** @dummy_global1
|
|
|
1030 store i8* %gep2, i8** @dummy_global2
|
|
|
1031 ret i64 %sub
|
|
|
1032 }
|
|
|
1033
|
|
|
1034 define i64 @test60([100 x [100 x i8]]* %foo, i64 %i, i64 %j) {
|
|
|
1035 ; CHECK-LABEL: @test60(
|
|
|
1036 ; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 %j, i64 %i
|
|
|
1037 ; CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 0
|
|
|
1038 ; CHECK-NEXT: [[CAST1:%.*]] = ptrtoint i8* [[GEP1]] to i64
|
|
|
1039 ; CHECK-NEXT: [[CAST2:%.*]] = ptrtoint i8* [[GEP2]] to i64
|
|
|
1040 ; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[CAST1]], [[CAST2]]
|
|
|
1041 ; CHECK-NEXT: store i8* [[GEP1]], i8** @dummy_global1, align 8
|
|
|
1042 ; CHECK-NEXT: ret i64 [[SUB]]
|
|
|
1043 ;
|
|
|
1044 ; gep1 has a non-constant index and more than one uses. Shouldn't duplicate the arithmetic.
|
|
|
1045 %gep1 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 %j, i64 %i
|
|
|
1046 %gep2 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 0
|
|
|
1047 %cast1 = ptrtoint i8* %gep1 to i64
|
|
|
1048 %cast2 = ptrtoint i8* %gep2 to i64
|
|
|
1049 %sub = sub i64 %cast1, %cast2
|
|
|
1050 store i8* %gep1, i8** @dummy_global1
|
|
|
1051 ret i64 %sub
|
|
|
1052 }
|
|
|
1053
|
|
|
1054 define i64 @test61([100 x [100 x i8]]* %foo, i64 %i, i64 %j) {
|
|
|
1055 ; CHECK-LABEL: @test61(
|
|
|
1056 ; CHECK-NEXT: [[GEP1:%.*]] = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 0
|
|
|
1057 ; CHECK-NEXT: [[GEP2:%.*]] = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 %j, i64 %i
|
|
|
1058 ; CHECK-NEXT: [[CAST1:%.*]] = ptrtoint i8* [[GEP1]] to i64
|
|
|
1059 ; CHECK-NEXT: [[CAST2:%.*]] = ptrtoint i8* [[GEP2]] to i64
|
|
|
1060 ; CHECK-NEXT: [[SUB:%.*]] = sub i64 [[CAST1]], [[CAST2]]
|
|
|
1061 ; CHECK-NEXT: store i8* [[GEP2]], i8** @dummy_global2, align 8
|
|
|
1062 ; CHECK-NEXT: ret i64 [[SUB]]
|
|
|
1063 ;
|
|
|
1064 ; gep2 has a non-constant index and more than one uses. Shouldn't duplicate the arithmetic.
|
|
|
1065 %gep1 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 42, i64 0
|
|
|
1066 %gep2 = getelementptr inbounds [100 x [100 x i8]], [100 x [100 x i8]]* %foo, i64 0, i64 %j, i64 %i
|
|
|
1067 %cast1 = ptrtoint i8* %gep1 to i64
|
|
|
1068 %cast2 = ptrtoint i8* %gep2 to i64
|
|
|
1069 %sub = sub i64 %cast1, %cast2
|
|
|
1070 store i8* %gep2, i8** @dummy_global2
|
|
|
1071 ret i64 %sub
|
|
|
1072 }
|
|
|
1073
|
|
|
1074 define i32 @test62(i32 %A) {
|
|
|
1075 ; CHECK-LABEL: @test62(
|
|
|
1076 ; CHECK-NEXT: [[B:%.*]] = shl i32 [[A:%.*]], 1
|
|
|
1077 ; CHECK-NEXT: [[C:%.*]] = sub i32 2, [[B]]
|
|
|
1078 ; CHECK-NEXT: ret i32 [[C]]
|
|
|
1079 ;
|
|
|
1080 %B = sub i32 1, %A
|
|
|
1081 %C = shl i32 %B, 1
|
|
|
1082 ret i32 %C
|
|
|
1083 }
|
|
|
1084
|
|
|
1085 define <2 x i32> @test62vec(<2 x i32> %A) {
|
|
|
1086 ; CHECK-LABEL: @test62vec(
|
|
|
1087 ; CHECK-NEXT: [[B:%.*]] = shl <2 x i32> [[A:%.*]], <i32 1, i32 1>
|
|
|
1088 ; CHECK-NEXT: [[C:%.*]] = sub <2 x i32> <i32 2, i32 2>, [[B]]
|
|
|
1089 ; CHECK-NEXT: ret <2 x i32> [[C]]
|
|
|
1090 ;
|
|
|
1091 %B = sub <2 x i32> <i32 1, i32 1>, %A
|
|
|
1092 %C = shl <2 x i32> %B, <i32 1, i32 1>
|
|
|
1093 ret <2 x i32> %C
|
|
|
1094 }
|
|
|
1095
|
|
|
1096 define i32 @test63(i32 %A) {
|
|
|
1097 ; CHECK-LABEL: @test63(
|
|
|
1098 ; CHECK-NEXT: [[B:%.*]] = shl i32 [[A:%.*]], 1
|
|
|
1099 ; CHECK-NEXT: ret i32 [[B]]
|
|
|
1100 ;
|
|
|
1101 %B = sub i32 1, %A
|
|
|
1102 %C = shl i32 %B, 1
|
|
|
1103 %D = sub i32 2, %C
|
|
|
1104 ret i32 %D
|
|
|
1105 }
|
|
|
1106
|
|
|
1107 define <2 x i32> @test63vec(<2 x i32> %A) {
|
|
|
1108 ; CHECK-LABEL: @test63vec(
|
|
|
1109 ; CHECK-NEXT: [[B:%.*]] = shl <2 x i32> [[A:%.*]], <i32 1, i32 1>
|
|
|
1110 ; CHECK-NEXT: ret <2 x i32> [[B]]
|
|
|
1111 ;
|
|
|
1112 %B = sub <2 x i32> <i32 1, i32 1>, %A
|
|
|
1113 %C = shl <2 x i32> %B, <i32 1, i32 1>
|
|
|
1114 %D = sub <2 x i32> <i32 2, i32 2>, %C
|
|
|
1115 ret <2 x i32> %D
|
|
|
1116 }
|
