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