1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
|
; Tests to make sure elimination of casts is working correctly
; RUN: llvm-as < %s | opt -instcombine -disable-output &&
; RUN: llvm-as < %s | opt -instcombine | llvm-dis | grep '%c' | notcast
%inbuf = external global [32832 x ubyte]
implementation
int %test1(int %A) {
%c1 = cast int %A to uint
%c2 = cast uint %c1 to int
ret int %c2
}
ulong %test2(ubyte %A) {
%c1 = cast ubyte %A to ushort
%c2 = cast ushort %c1 to uint
%Ret = cast uint %c2 to ulong
ret ulong %Ret
}
ulong %test3(ulong %A) { ; This function should just use bitwise AND
%c1 = cast ulong %A to ubyte
%c2 = cast ubyte %c1 to ulong
ret ulong %c2
}
uint %test4(int %A, int %B) {
%COND = setlt int %A, %B
%c = cast bool %COND to ubyte ; Booleans are unsigned integrals
%result = cast ubyte %c to uint ; for the cast elim purpose
ret uint %result
}
int %test5(bool %B) {
%c = cast bool %B to ubyte ; This cast should get folded into
%result = cast ubyte %c to int ; this cast
ret int %result
}
int %test6(ulong %A) {
%c1 = cast ulong %A to uint
%res = cast uint %c1 to int
ret int %res
}
long %test7(bool %A) {
%c1 = cast bool %A to int
%res = cast int %c1 to long
ret long %res
}
long %test8(sbyte %A) {
%c1 = cast sbyte %A to ulong
%res = cast ulong %c1 to long
ret long %res
}
short %test9(short %A) {
%c1 = cast short %A to int
%c2 = cast int %c1 to short
ret short %c2
}
short %test10(short %A) {
%c1 = cast short %A to uint
%c2 = cast uint %c1 to short
ret short %c2
}
declare void %varargs(int, ...)
void %test11(int* %P) {
%c = cast int* %P to short*
call void(int, ...)* %varargs(int 5, short* %c)
ret void
}
int* %test12() {
%p = malloc [4 x sbyte]
%c = cast [4 x sbyte]* %p to int*
ret int* %c
}
ubyte *%test13(long %A) {
%c = getelementptr [0 x ubyte]* cast ([32832 x ubyte]* %inbuf to [0 x ubyte]*), long 0, long %A
ret ubyte* %c
}
bool %test14(sbyte %A) {
%c = cast sbyte %A to ubyte
%X = setlt ubyte %c, 128 ; setge %A, 0
ret bool %X
}
bool %test15(ubyte %A) {
%c = cast ubyte %A to sbyte
%X = setlt sbyte %c, 0 ; setgt %A, 127
ret bool %X
}
bool %test16(int* %P) {
%c = cast int* %P to bool ;; setne P, null
ret bool %c
}
short %test17(bool %tmp3) {
%c = cast bool %tmp3 to int
%t86 = cast int %c to short
ret short %t86
}
short %test18(sbyte %tmp3) {
%c = cast sbyte %tmp3 to int
%t86 = cast int %c to short
ret short %t86
}
bool %test19(int %X) {
%c = cast int %X to long
%Z = setlt long %c, 12345
ret bool %Z
}
bool %test20(bool %B) {
%c = cast bool %B to int
%D = setlt int %c, -1
ret bool %D ;; false
}
uint %test21(uint %X) {
%c1 = cast uint %X to sbyte
%c2 = cast sbyte %c1 to uint ;; sext -> zext -> and -> nop
%RV = and uint %c2, 255
ret uint %RV
}
uint %test22(uint %X) {
%c1 = cast uint %X to sbyte
%c2 = cast sbyte %c1 to uint ;; sext -> zext -> and -> nop
%RV = shl uint %c2, ubyte 24
ret uint %RV
}
int %test23(int %X) {
%c1 = cast int %X to ushort ;; Turn into an AND even though X
%c2 = cast ushort %c1 to int ;; and Z are signed.
ret int %c2
}
bool %test24(bool %C) {
%X = select bool %C, uint 14, uint 1234
%c = cast uint %X to bool ;; Fold cast into select
ret bool %c
}
void %test25(int** %P) {
%c = cast int** %P to float**
store float* null, float** %c ;; Fold cast into null
ret void
}
int %test26(float %F) {
%c = cast float %F to double ;; no need to cast from float->double.
%D = cast double %c to int
ret int %D
}
[4 x float]* %test27([9 x [4 x float]]* %A) {
%c = cast [9 x [4 x float]]* %A to [4 x float]*
ret [4 x float]* %c
}
float* %test28([4 x float]* %A) {
%c = cast [4 x float]* %A to float*
ret float* %c
}
uint %test29(uint %c1, uint %c2) {
%tmp1 = cast uint %c1 to ubyte
%tmp4.mask = cast uint %c2 to ubyte
%tmp = or ubyte %tmp4.mask, %tmp1
%tmp10 = cast ubyte %tmp to uint
ret uint %tmp10
}
uint %test30(uint %c1) {
%c2 = cast uint %c1 to ubyte
%c3 = xor ubyte %c2, 1
%c4 = cast ubyte %c3 to uint
ret uint %c4
}
bool %test31(ulong %A) {
%B = cast ulong %A to int
%C = and int %B, 42
%D = seteq int %C, 10
ret bool %D
}
void %test32(double** %tmp) {
%tmp8 = malloc [16 x sbyte]
%tmp8 = cast [16 x sbyte]* %tmp8 to double*
store double* %tmp8, double** %tmp
ret void
}
uint %test33(uint %c1) {
%x = bitcast uint %c1 to float
%y = bitcast float %x to uint
ret uint %y
}
ushort %test34(ushort %a) {
%c1 = zext ushort %a to int
%tmp21 = lshr int %c1, ubyte 8
%c2 = trunc int %tmp21 to ushort
ret ushort %c2
}
ushort %test35(ushort %a) {
%c1 = bitcast ushort %a to short
%tmp2 = lshr short %c1, ubyte 8
%c2 = bitcast short %tmp2 to ushort
ret ushort %c2
}
|
