scsi: esp: check buffer length before reading scsi command
[qemu.git] / target-alpha / int_helper.c
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_ctpop(uint64_t arg)
28 {
29 return ctpop64(arg);
30 }
31
32 uint64_t helper_ctlz(uint64_t arg)
33 {
34 return clz64(arg);
35 }
36
37 uint64_t helper_cttz(uint64_t arg)
38 {
39 return ctz64(arg);
40 }
41
42 uint64_t helper_zapnot(uint64_t val, uint64_t mskb)
43 {
44 uint64_t mask;
45
46 mask = -(mskb & 0x01) & 0x00000000000000ffull;
47 mask |= -(mskb & 0x02) & 0x000000000000ff00ull;
48 mask |= -(mskb & 0x04) & 0x0000000000ff0000ull;
49 mask |= -(mskb & 0x08) & 0x00000000ff000000ull;
50 mask |= -(mskb & 0x10) & 0x000000ff00000000ull;
51 mask |= -(mskb & 0x20) & 0x0000ff0000000000ull;
52 mask |= -(mskb & 0x40) & 0x00ff000000000000ull;
53 mask |= -(mskb & 0x80) & 0xff00000000000000ull;
54
55 return val & mask;
56 }
57
58 uint64_t helper_zap(uint64_t val, uint64_t mask)
59 {
60 return helper_zapnot(val, ~mask);
61 }
62
63 uint64_t helper_cmpbe0(uint64_t a)
64 {
65 uint64_t m = 0x7f7f7f7f7f7f7f7fULL;
66 uint64_t c = ~(((a & m) + m) | a | m);
67 /* a.......b.......c.......d.......e.......f.......g.......h....... */
68 c |= c << 7;
69 /* ab......bc......cd......de......ef......fg......gh......h....... */
70 c |= c << 14;
71 /* abcd....bcde....cdef....defg....efgh....fgh.....gh......h....... */
72 c |= c << 28;
73 /* abcdefghbcdefgh.cdefgh..defgh...efgh....fgh.....gh......h....... */
74 return c >> 56;
75 }
76
77 uint64_t helper_cmpbge(uint64_t a, uint64_t b)
78 {
79 uint64_t mask = 0x00ff00ff00ff00ffULL;
80 uint64_t test = 0x0100010001000100ULL;
81 uint64_t al, ah, bl, bh, cl, ch;
82
83 /* Separate the bytes to avoid false positives. */
84 al = a & mask;
85 bl = b & mask;
86 ah = (a >> 8) & mask;
87 bh = (b >> 8) & mask;
88
89 /* "Compare". If a byte in B is greater than a byte in A,
90 it will clear the test bit. */
91 cl = ((al | test) - bl) & test;
92 ch = ((ah | test) - bh) & test;
93
94 /* Fold all of the test bits into a contiguous set. */
95 /* ch=.......a...............c...............e...............g........ */
96 /* cl=.......b...............d...............f...............h........ */
97 cl += ch << 1;
98 /* cl=......ab..............cd..............ef..............gh........ */
99 cl |= cl << 14;
100 /* cl=......abcd............cdef............efgh............gh........ */
101 cl |= cl << 28;
102 /* cl=......abcdefgh........cdefgh..........efgh............gh........ */
103 return cl >> 50;
104 }
105
106 uint64_t helper_minub8(uint64_t op1, uint64_t op2)
107 {
108 uint64_t res = 0;
109 uint8_t opa, opb, 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
121 uint64_t helper_minsb8(uint64_t op1, uint64_t op2)
122 {
123 uint64_t res = 0;
124 int8_t opa, opb;
125 uint8_t opr;
126 int i;
127
128 for (i = 0; i < 8; ++i) {
129 opa = op1 >> (i * 8);
130 opb = op2 >> (i * 8);
131 opr = opa < opb ? opa : opb;
132 res |= (uint64_t)opr << (i * 8);
133 }
134 return res;
135 }
136
137 uint64_t helper_minuw4(uint64_t op1, uint64_t op2)
138 {
139 uint64_t res = 0;
140 uint16_t opa, opb, 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
152 uint64_t helper_minsw4(uint64_t op1, uint64_t op2)
153 {
154 uint64_t res = 0;
155 int16_t opa, opb;
156 uint16_t opr;
157 int i;
158
159 for (i = 0; i < 4; ++i) {
160 opa = op1 >> (i * 16);
161 opb = op2 >> (i * 16);
162 opr = opa < opb ? opa : opb;
163 res |= (uint64_t)opr << (i * 16);
164 }
165 return res;
166 }
167
168 uint64_t helper_maxub8(uint64_t op1, uint64_t op2)
169 {
170 uint64_t res = 0;
171 uint8_t opa, opb, 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
183 uint64_t helper_maxsb8(uint64_t op1, uint64_t op2)
184 {
185 uint64_t res = 0;
186 int8_t opa, opb;
187 uint8_t opr;
188 int i;
189
190 for (i = 0; i < 8; ++i) {
191 opa = op1 >> (i * 8);
192 opb = op2 >> (i * 8);
193 opr = opa > opb ? opa : opb;
194 res |= (uint64_t)opr << (i * 8);
195 }
196 return res;
197 }
198
199 uint64_t helper_maxuw4(uint64_t op1, uint64_t op2)
200 {
201 uint64_t res = 0;
202 uint16_t opa, opb, 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
214 uint64_t helper_maxsw4(uint64_t op1, uint64_t op2)
215 {
216 uint64_t res = 0;
217 int16_t opa, opb;
218 uint16_t opr;
219 int i;
220
221 for (i = 0; i < 4; ++i) {
222 opa = op1 >> (i * 16);
223 opb = op2 >> (i * 16);
224 opr = opa > opb ? opa : opb;
225 res |= (uint64_t)opr << (i * 16);
226 }
227 return res;
228 }
229
230 uint64_t helper_perr(uint64_t op1, uint64_t op2)
231 {
232 uint64_t res = 0;
233 uint8_t opa, opb, opr;
234 int i;
235
236 for (i = 0; i < 8; ++i) {
237 opa = op1 >> (i * 8);
238 opb = op2 >> (i * 8);
239 if (opa >= opb) {
240 opr = opa - opb;
241 } else {
242 opr = opb - opa;
243 }
244 res += opr;
245 }
246 return res;
247 }
248
249 uint64_t helper_pklb(uint64_t op1)
250 {
251 return (op1 & 0xff) | ((op1 >> 24) & 0xff00);
252 }
253
254 uint64_t helper_pkwb(uint64_t op1)
255 {
256 return ((op1 & 0xff)
257 | ((op1 >> 8) & 0xff00)
258 | ((op1 >> 16) & 0xff0000)
259 | ((op1 >> 24) & 0xff000000));
260 }
261
262 uint64_t helper_unpkbl(uint64_t op1)
263 {
264 return (op1 & 0xff) | ((op1 & 0xff00) << 24);
265 }
266
267 uint64_t helper_unpkbw(uint64_t op1)
268 {
269 return ((op1 & 0xff)
270 | ((op1 & 0xff00) << 8)
271 | ((op1 & 0xff0000) << 16)
272 | ((op1 & 0xff000000) << 24));
273 }
274
275 void helper_check_overflow(CPUAlphaState *env, uint64_t op1, uint64_t op2)
276 {
277 if (unlikely(op1 != op2)) {
278 arith_excp(env, GETPC(), EXC_M_IOV, 0);
279 }
280 }