2 * Helpers for integer and multimedia instructions.
4 * Copyright (c) 2007 Jocelyn Mayer
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.
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.
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/>.
21 #include "exec/helper-proto.h"
22 #include "qemu/host-utils.h"
25 uint64_t helper_ctpop(uint64_t arg
)
30 uint64_t helper_ctlz(uint64_t arg
)
35 uint64_t helper_cttz(uint64_t arg
)
40 uint64_t helper_zapnot(uint64_t val
, uint64_t mskb
)
44 mask
= -(mskb
& 0x01) & 0x00000000000000ffull
;
45 mask
|= -(mskb
& 0x02) & 0x000000000000ff00ull
;
46 mask
|= -(mskb
& 0x04) & 0x0000000000ff0000ull
;
47 mask
|= -(mskb
& 0x08) & 0x00000000ff000000ull
;
48 mask
|= -(mskb
& 0x10) & 0x000000ff00000000ull
;
49 mask
|= -(mskb
& 0x20) & 0x0000ff0000000000ull
;
50 mask
|= -(mskb
& 0x40) & 0x00ff000000000000ull
;
51 mask
|= -(mskb
& 0x80) & 0xff00000000000000ull
;
56 uint64_t helper_zap(uint64_t val
, uint64_t mask
)
58 return helper_zapnot(val
, ~mask
);
61 uint64_t helper_cmpbge(uint64_t a
, uint64_t b
)
63 uint64_t mask
= 0x00ff00ff00ff00ffULL
;
64 uint64_t test
= 0x0100010001000100ULL
;
65 uint64_t al
, ah
, bl
, bh
, cl
, ch
;
67 /* Separate the bytes to avoid false positives. */
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
;
78 /* Fold all of the test bits into a contiguous set. */
79 /* ch=.......a...............c...............e...............g........ */
80 /* cl=.......b...............d...............f...............h........ */
82 /* cl=......ab..............cd..............ef..............gh........ */
84 /* cl=......abcd............cdef............efgh............gh........ */
86 /* cl=......abcdefgh........cdefgh..........efgh............gh........ */
90 uint64_t helper_minub8(uint64_t op1
, uint64_t op2
)
93 uint8_t opa
, opb
, opr
;
96 for (i
= 0; i
< 8; ++i
) {
99 opr
= opa
< opb
? opa
: opb
;
100 res
|= (uint64_t)opr
<< (i
* 8);
105 uint64_t helper_minsb8(uint64_t op1
, uint64_t op2
)
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);
121 uint64_t helper_minuw4(uint64_t op1
, uint64_t op2
)
124 uint16_t opa
, opb
, opr
;
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);
136 uint64_t helper_minsw4(uint64_t op1
, uint64_t op2
)
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);
152 uint64_t helper_maxub8(uint64_t op1
, uint64_t op2
)
155 uint8_t opa
, opb
, opr
;
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);
167 uint64_t helper_maxsb8(uint64_t op1
, uint64_t op2
)
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);
183 uint64_t helper_maxuw4(uint64_t op1
, uint64_t op2
)
186 uint16_t opa
, opb
, opr
;
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);
198 uint64_t helper_maxsw4(uint64_t op1
, uint64_t op2
)
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);
214 uint64_t helper_perr(uint64_t op1
, uint64_t op2
)
217 uint8_t opa
, opb
, opr
;
220 for (i
= 0; i
< 8; ++i
) {
221 opa
= op1
>> (i
* 8);
222 opb
= op2
>> (i
* 8);
233 uint64_t helper_pklb(uint64_t op1
)
235 return (op1
& 0xff) | ((op1
>> 24) & 0xff00);
238 uint64_t helper_pkwb(uint64_t op1
)
241 | ((op1
>> 8) & 0xff00)
242 | ((op1
>> 16) & 0xff0000)
243 | ((op1
>> 24) & 0xff000000));
246 uint64_t helper_unpkbl(uint64_t op1
)
248 return (op1
& 0xff) | ((op1
& 0xff00) << 24);
251 uint64_t helper_unpkbw(uint64_t op1
)
254 | ((op1
& 0xff00) << 8)
255 | ((op1
& 0xff0000) << 16)
256 | ((op1
& 0xff000000) << 24));
259 void helper_check_overflow(CPUAlphaState
*env
, uint64_t op1
, uint64_t op2
)
261 if (unlikely(op1
!= op2
)) {
262 arith_excp(env
, GETPC(), EXC_M_IOV
, 0);