1 | /* |
2 | * Helpers for integer and multimedia instructions. |
3 | * |
4 | * Copyright (c) 2007 Jocelyn Mayer |
5 | * |
6 | * This library is free software; you can redistribute it and/or |
7 | * modify it under the terms of the GNU Lesser General Public |
8 | * License as published by the Free Software Foundation; either |
9 | * version 2 of the License, or (at your option) any later version. |
10 | * |
11 | * This library is distributed in the hope that it will be useful, |
12 | * but WITHOUT ANY WARRANTY; without even the implied warranty of |
13 | * MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU |
14 | * Lesser General Public License for more details. |
15 | * |
16 | * You should have received a copy of the GNU Lesser General Public |
17 | * License along with this library; if not, see <http://www.gnu.org/licenses/>. |
18 | */ |
19 | |
20 | #include "qemu/osdep.h" |
21 | #include "cpu.h" |
22 | #include "exec/exec-all.h" |
23 | #include "exec/helper-proto.h" |
24 | #include "qemu/host-utils.h" |
25 | |
26 | |
27 | uint64_t helper_zapnot(uint64_t val, uint64_t mskb) |
28 | { |
29 | uint64_t mask; |
30 | |
31 | mask = -(mskb & 0x01) & 0x00000000000000ffull; |
32 | mask |= -(mskb & 0x02) & 0x000000000000ff00ull; |
33 | mask |= -(mskb & 0x04) & 0x0000000000ff0000ull; |
34 | mask |= -(mskb & 0x08) & 0x00000000ff000000ull; |
35 | mask |= -(mskb & 0x10) & 0x000000ff00000000ull; |
36 | mask |= -(mskb & 0x20) & 0x0000ff0000000000ull; |
37 | mask |= -(mskb & 0x40) & 0x00ff000000000000ull; |
38 | mask |= -(mskb & 0x80) & 0xff00000000000000ull; |
39 | |
40 | return val & mask; |
41 | } |
42 | |
43 | uint64_t helper_zap(uint64_t val, uint64_t mask) |
44 | { |
45 | return helper_zapnot(val, ~mask); |
46 | } |
47 | |
48 | uint64_t helper_cmpbe0(uint64_t a) |
49 | { |
50 | uint64_t m = 0x7f7f7f7f7f7f7f7fULL; |
51 | uint64_t c = ~(((a & m) + m) | a | m); |
52 | /* a.......b.......c.......d.......e.......f.......g.......h....... */ |
53 | c |= c << 7; |
54 | /* ab......bc......cd......de......ef......fg......gh......h....... */ |
55 | c |= c << 14; |
56 | /* abcd....bcde....cdef....defg....efgh....fgh.....gh......h....... */ |
57 | c |= c << 28; |
58 | /* abcdefghbcdefgh.cdefgh..defgh...efgh....fgh.....gh......h....... */ |
59 | return c >> 56; |
60 | } |
61 | |
62 | uint64_t helper_cmpbge(uint64_t a, uint64_t b) |
63 | { |
64 | uint64_t mask = 0x00ff00ff00ff00ffULL; |
65 | uint64_t test = 0x0100010001000100ULL; |
66 | uint64_t al, ah, bl, bh, cl, ch; |
67 | |
68 | /* Separate the bytes to avoid false positives. */ |
69 | al = a & mask; |
70 | bl = b & mask; |
71 | ah = (a >> 8) & mask; |
72 | bh = (b >> 8) & mask; |
73 | |
74 | /* "Compare". If a byte in B is greater than a byte in A, |
75 | it will clear the test bit. */ |
76 | cl = ((al | test) - bl) & test; |
77 | ch = ((ah | test) - bh) & test; |
78 | |
79 | /* Fold all of the test bits into a contiguous set. */ |
80 | /* ch=.......a...............c...............e...............g........ */ |
81 | /* cl=.......b...............d...............f...............h........ */ |
82 | cl += ch << 1; |
83 | /* cl=......ab..............cd..............ef..............gh........ */ |
84 | cl |= cl << 14; |
85 | /* cl=......abcd............cdef............efgh............gh........ */ |
86 | cl |= cl << 28; |
87 | /* cl=......abcdefgh........cdefgh..........efgh............gh........ */ |
88 | return cl >> 50; |
89 | } |
90 | |
91 | uint64_t helper_minub8(uint64_t op1, uint64_t op2) |
92 | { |
93 | uint64_t res = 0; |
94 | uint8_t opa, opb, opr; |
95 | int i; |
96 | |
97 | for (i = 0; i < 8; ++i) { |
98 | opa = op1 >> (i * 8); |
99 | opb = op2 >> (i * 8); |
100 | opr = opa < opb ? opa : opb; |
101 | res |= (uint64_t)opr << (i * 8); |
102 | } |
103 | return res; |
104 | } |
105 | |
106 | uint64_t helper_minsb8(uint64_t op1, uint64_t op2) |
107 | { |
108 | uint64_t res = 0; |
109 | int8_t opa, opb; |
110 | uint8_t opr; |
111 | int i; |
112 | |
113 | for (i = 0; i < 8; ++i) { |
114 | opa = op1 >> (i * 8); |
115 | opb = op2 >> (i * 8); |
116 | opr = opa < opb ? opa : opb; |
117 | res |= (uint64_t)opr << (i * 8); |
118 | } |
119 | return res; |
120 | } |
121 | |
122 | uint64_t helper_minuw4(uint64_t op1, uint64_t op2) |
123 | { |
124 | uint64_t res = 0; |
125 | uint16_t opa, opb, opr; |
126 | int i; |
127 | |
128 | for (i = 0; i < 4; ++i) { |
129 | opa = op1 >> (i * 16); |
130 | opb = op2 >> (i * 16); |
131 | opr = opa < opb ? opa : opb; |
132 | res |= (uint64_t)opr << (i * 16); |
133 | } |
134 | return res; |
135 | } |
136 | |
137 | uint64_t helper_minsw4(uint64_t op1, uint64_t op2) |
138 | { |
139 | uint64_t res = 0; |
140 | int16_t opa, opb; |
141 | uint16_t opr; |
142 | int i; |
143 | |
144 | for (i = 0; i < 4; ++i) { |
145 | opa = op1 >> (i * 16); |
146 | opb = op2 >> (i * 16); |
147 | opr = opa < opb ? opa : opb; |
148 | res |= (uint64_t)opr << (i * 16); |
149 | } |
150 | return res; |
151 | } |
152 | |
153 | uint64_t helper_maxub8(uint64_t op1, uint64_t op2) |
154 | { |
155 | uint64_t res = 0; |
156 | uint8_t opa, opb, opr; |
157 | int i; |
158 | |
159 | for (i = 0; i < 8; ++i) { |
160 | opa = op1 >> (i * 8); |
161 | opb = op2 >> (i * 8); |
162 | opr = opa > opb ? opa : opb; |
163 | res |= (uint64_t)opr << (i * 8); |
164 | } |
165 | return res; |
166 | } |
167 | |
168 | uint64_t helper_maxsb8(uint64_t op1, uint64_t op2) |
169 | { |
170 | uint64_t res = 0; |
171 | int8_t opa, opb; |
172 | uint8_t opr; |
173 | int i; |
174 | |
175 | for (i = 0; i < 8; ++i) { |
176 | opa = op1 >> (i * 8); |
177 | opb = op2 >> (i * 8); |
178 | opr = opa > opb ? opa : opb; |
179 | res |= (uint64_t)opr << (i * 8); |
180 | } |
181 | return res; |
182 | } |
183 | |
184 | uint64_t helper_maxuw4(uint64_t op1, uint64_t op2) |
185 | { |
186 | uint64_t res = 0; |
187 | uint16_t opa, opb, opr; |
188 | int i; |
189 | |
190 | for (i = 0; i < 4; ++i) { |
191 | opa = op1 >> (i * 16); |
192 | opb = op2 >> (i * 16); |
193 | opr = opa > opb ? opa : opb; |
194 | res |= (uint64_t)opr << (i * 16); |
195 | } |
196 | return res; |
197 | } |
198 | |
199 | uint64_t helper_maxsw4(uint64_t op1, uint64_t op2) |
200 | { |
201 | uint64_t res = 0; |
202 | int16_t opa, opb; |
203 | uint16_t opr; |
204 | int i; |
205 | |
206 | for (i = 0; i < 4; ++i) { |
207 | opa = op1 >> (i * 16); |
208 | opb = op2 >> (i * 16); |
209 | opr = opa > opb ? opa : opb; |
210 | res |= (uint64_t)opr << (i * 16); |
211 | } |
212 | return res; |
213 | } |
214 | |
215 | uint64_t helper_perr(uint64_t op1, uint64_t op2) |
216 | { |
217 | uint64_t res = 0; |
218 | uint8_t opa, opb, opr; |
219 | int i; |
220 | |
221 | for (i = 0; i < 8; ++i) { |
222 | opa = op1 >> (i * 8); |
223 | opb = op2 >> (i * 8); |
224 | if (opa >= opb) { |
225 | opr = opa - opb; |
226 | } else { |
227 | opr = opb - opa; |
228 | } |
229 | res += opr; |
230 | } |
231 | return res; |
232 | } |
233 | |
234 | uint64_t helper_pklb(uint64_t op1) |
235 | { |
236 | return (op1 & 0xff) | ((op1 >> 24) & 0xff00); |
237 | } |
238 | |
239 | uint64_t helper_pkwb(uint64_t op1) |
240 | { |
241 | return ((op1 & 0xff) |
242 | | ((op1 >> 8) & 0xff00) |
243 | | ((op1 >> 16) & 0xff0000) |
244 | | ((op1 >> 24) & 0xff000000)); |
245 | } |
246 | |
247 | uint64_t helper_unpkbl(uint64_t op1) |
248 | { |
249 | return (op1 & 0xff) | ((op1 & 0xff00) << 24); |
250 | } |
251 | |
252 | uint64_t helper_unpkbw(uint64_t op1) |
253 | { |
254 | return ((op1 & 0xff) |
255 | | ((op1 & 0xff00) << 8) |
256 | | ((op1 & 0xff0000) << 16) |
257 | | ((op1 & 0xff000000) << 24)); |
258 | } |
259 | |
260 | void helper_check_overflow(CPUAlphaState *env, uint64_t op1, uint64_t op2) |
261 | { |
262 | if (unlikely(op1 != op2)) { |
263 | arith_excp(env, GETPC(), EXC_M_IOV, 0); |
264 | } |
265 | } |
266 | |