OpenE2K/qemu-e2k
13
4
Fork 0
Code Issues 4 Pull Requests Projects 2 Releases Activity
000761dc0c
qemu-e2k/target/mips/lmi_helper.c
Thomas Huth fcf5ef2ab5 Move target-* CPU file into a target/ folder 
We've currently got 18 architectures in QEMU, and thus 18 target-xxx
folders in the root folder of the QEMU source tree. More architectures
(e.g. RISC-V, AVR) are likely to be included soon, too, so the main
folder of the QEMU sources slowly gets quite overcrowded with the
target-xxx folders.
To disburden the main folder a little bit, let's move the target-xxx
folders into a dedicated target/ folder, so that target-xxx/ simply
becomes target/xxx/ instead.

Acked-by: Laurent Vivier <laurent@vivier.eu> [m68k part]
Acked-by: Bastian Koppelmann <kbastian@mail.uni-paderborn.de> [tricore part]
Acked-by: Michael Walle <michael@walle.cc> [lm32 part]
Acked-by: Cornelia Huck <cornelia.huck@de.ibm.com> [s390x part]
Reviewed-by: Christian Borntraeger <borntraeger@de.ibm.com> [s390x part]
Acked-by: Eduardo Habkost <ehabkost@redhat.com> [i386 part]
Acked-by: Artyom Tarasenko <atar4qemu@gmail.com> [sparc part]
Acked-by: Richard Henderson <rth@twiddle.net> [alpha part]
Acked-by: Max Filippov <jcmvbkbc@gmail.com> [xtensa part]
Reviewed-by: David Gibson <david@gibson.dropbear.id.au> [ppc part]
Acked-by: Edgar E. Iglesias <edgar.iglesias@xilinx.com> [cris&microblaze part]
Acked-by: Guan Xuetao <gxt@mprc.pku.edu.cn> [unicore32 part]
Signed-off-by: Thomas Huth <thuth@redhat.com>
2016-12-20 21:52:12 +01:00

746 lines
14 KiB
C
Raw Blame History

/*
* Loongson Multimedia Instruction emulation helpers for QEMU.
*
* Copyright (c) 2011 Richard Henderson <rth@twiddle.net>
*
* This library is free software; you can redistribute it and/or
* modify it under the terms of the GNU Lesser General Public
* License as published by the Free Software Foundation; either
* version 2 of the License, or (at your option) any later version.
*
* This library is distributed in the hope that it will be useful,
* but WITHOUT ANY WARRANTY; without even the implied warranty of
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
* Lesser General Public License for more details.
*
* You should have received a copy of the GNU Lesser General Public
* License along with this library; if not, see <http://www.gnu.org/licenses/>.
*/
#include "qemu/osdep.h"
#include "cpu.h"
#include "exec/helper-proto.h"
/* If the byte ordering doesn't matter, i.e. all columns are treated
identically, then this union can be used directly. If byte ordering
does matter, we generally ignore dumping to memory. */
typedef union {
uint8_t ub[8];
int8_t sb[8];
uint16_t uh[4];
int16_t sh[4];
uint32_t uw[2];
int32_t sw[2];
uint64_t d;
} LMIValue;
/* Some byte ordering issues can be mitigated by XORing in the following. */
#ifdef HOST_WORDS_BIGENDIAN
# define BYTE_ORDER_XOR(N) N
#else
# define BYTE_ORDER_XOR(N) 0
#endif
#define SATSB(x) (x < -0x80 ? -0x80 : x > 0x7f ? 0x7f : x)
#define SATUB(x) (x > 0xff ? 0xff : x)
#define SATSH(x) (x < -0x8000 ? -0x8000 : x > 0x7fff ? 0x7fff : x)
#define SATUH(x) (x > 0xffff ? 0xffff : x)
#define SATSW(x) \
(x < -0x80000000ll ? -0x80000000ll : x > 0x7fffffff ? 0x7fffffff : x)
#define SATUW(x) (x > 0xffffffffull ? 0xffffffffull : x)
uint64_t helper_paddsb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; ++i) {
int r = vs.sb[i] + vt.sb[i];
vs.sb[i] = SATSB(r);
}
return vs.d;
}
uint64_t helper_paddusb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; ++i) {
int r = vs.ub[i] + vt.ub[i];
vs.ub[i] = SATUB(r);
}
return vs.d;
}
uint64_t helper_paddsh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
int r = vs.sh[i] + vt.sh[i];
vs.sh[i] = SATSH(r);
}
return vs.d;
}
uint64_t helper_paddush(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
int r = vs.uh[i] + vt.uh[i];
vs.uh[i] = SATUH(r);
}
return vs.d;
}
uint64_t helper_paddb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; ++i) {
vs.ub[i] += vt.ub[i];
}
return vs.d;
}
uint64_t helper_paddh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
vs.uh[i] += vt.uh[i];
}
return vs.d;
}
uint64_t helper_paddw(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 2; ++i) {
vs.uw[i] += vt.uw[i];
}
return vs.d;
}
uint64_t helper_psubsb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; ++i) {
int r = vs.sb[i] - vt.sb[i];
vs.sb[i] = SATSB(r);
}
return vs.d;
}
uint64_t helper_psubusb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; ++i) {
int r = vs.ub[i] - vt.ub[i];
vs.ub[i] = SATUB(r);
}
return vs.d;
}
uint64_t helper_psubsh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
int r = vs.sh[i] - vt.sh[i];
vs.sh[i] = SATSH(r);
}
return vs.d;
}
uint64_t helper_psubush(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
int r = vs.uh[i] - vt.uh[i];
vs.uh[i] = SATUH(r);
}
return vs.d;
}
uint64_t helper_psubb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; ++i) {
vs.ub[i] -= vt.ub[i];
}
return vs.d;
}
uint64_t helper_psubh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
vs.uh[i] -= vt.uh[i];
}
return vs.d;
}
uint64_t helper_psubw(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned int i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 2; ++i) {
vs.uw[i] -= vt.uw[i];
}
return vs.d;
}
uint64_t helper_pshufh(uint64_t fs, uint64_t ft)
{
unsigned host = BYTE_ORDER_XOR(3);
LMIValue vd, vs;
unsigned i;
vs.d = fs;
vd.d = 0;
for (i = 0; i < 4; i++, ft >>= 2) {
vd.uh[i ^ host] = vs.uh[(ft & 3) ^ host];
}
return vd.d;
}
uint64_t helper_packsswh(uint64_t fs, uint64_t ft)
{
uint64_t fd = 0;
int64_t tmp;
tmp = (int32_t)(fs >> 0);
tmp = SATSH(tmp);
fd |= (tmp & 0xffff) << 0;
tmp = (int32_t)(fs >> 32);
tmp = SATSH(tmp);
fd |= (tmp & 0xffff) << 16;
tmp = (int32_t)(ft >> 0);
tmp = SATSH(tmp);
fd |= (tmp & 0xffff) << 32;
tmp = (int32_t)(ft >> 32);
tmp = SATSH(tmp);
fd |= (tmp & 0xffff) << 48;
return fd;
}
uint64_t helper_packsshb(uint64_t fs, uint64_t ft)
{
uint64_t fd = 0;
unsigned int i;
for (i = 0; i < 4; ++i) {
int16_t tmp = fs >> (i * 16);
tmp = SATSB(tmp);
fd |= (uint64_t)(tmp & 0xff) << (i * 8);
}
for (i = 0; i < 4; ++i) {
int16_t tmp = ft >> (i * 16);
tmp = SATSB(tmp);
fd |= (uint64_t)(tmp & 0xff) << (i * 8 + 32);
}
return fd;
}
uint64_t helper_packushb(uint64_t fs, uint64_t ft)
{
uint64_t fd = 0;
unsigned int i;
for (i = 0; i < 4; ++i) {
int16_t tmp = fs >> (i * 16);
tmp = SATUB(tmp);
fd |= (uint64_t)(tmp & 0xff) << (i * 8);
}
for (i = 0; i < 4; ++i) {
int16_t tmp = ft >> (i * 16);
tmp = SATUB(tmp);
fd |= (uint64_t)(tmp & 0xff) << (i * 8 + 32);
}
return fd;
}
uint64_t helper_punpcklwd(uint64_t fs, uint64_t ft)
{
return (fs & 0xffffffff) | (ft << 32);
}
uint64_t helper_punpckhwd(uint64_t fs, uint64_t ft)
{
return (fs >> 32) | (ft & ~0xffffffffull);
}
uint64_t helper_punpcklhw(uint64_t fs, uint64_t ft)
{
unsigned host = BYTE_ORDER_XOR(3);
LMIValue vd, vs, vt;
vs.d = fs;
vt.d = ft;
vd.uh[0 ^ host] = vs.uh[0 ^ host];
vd.uh[1 ^ host] = vt.uh[0 ^ host];
vd.uh[2 ^ host] = vs.uh[1 ^ host];
vd.uh[3 ^ host] = vt.uh[1 ^ host];
return vd.d;
}
uint64_t helper_punpckhhw(uint64_t fs, uint64_t ft)
{
unsigned host = BYTE_ORDER_XOR(3);
LMIValue vd, vs, vt;
vs.d = fs;
vt.d = ft;
vd.uh[0 ^ host] = vs.uh[2 ^ host];
vd.uh[1 ^ host] = vt.uh[2 ^ host];
vd.uh[2 ^ host] = vs.uh[3 ^ host];
vd.uh[3 ^ host] = vt.uh[3 ^ host];
return vd.d;
}
uint64_t helper_punpcklbh(uint64_t fs, uint64_t ft)
{
unsigned host = BYTE_ORDER_XOR(7);
LMIValue vd, vs, vt;
vs.d = fs;
vt.d = ft;
vd.ub[0 ^ host] = vs.ub[0 ^ host];
vd.ub[1 ^ host] = vt.ub[0 ^ host];
vd.ub[2 ^ host] = vs.ub[1 ^ host];
vd.ub[3 ^ host] = vt.ub[1 ^ host];
vd.ub[4 ^ host] = vs.ub[2 ^ host];
vd.ub[5 ^ host] = vt.ub[2 ^ host];
vd.ub[6 ^ host] = vs.ub[3 ^ host];
vd.ub[7 ^ host] = vt.ub[3 ^ host];
return vd.d;
}
uint64_t helper_punpckhbh(uint64_t fs, uint64_t ft)
{
unsigned host = BYTE_ORDER_XOR(7);
LMIValue vd, vs, vt;
vs.d = fs;
vt.d = ft;
vd.ub[0 ^ host] = vs.ub[4 ^ host];
vd.ub[1 ^ host] = vt.ub[4 ^ host];
vd.ub[2 ^ host] = vs.ub[5 ^ host];
vd.ub[3 ^ host] = vt.ub[5 ^ host];
vd.ub[4 ^ host] = vs.ub[6 ^ host];
vd.ub[5 ^ host] = vt.ub[6 ^ host];
vd.ub[6 ^ host] = vs.ub[7 ^ host];
vd.ub[7 ^ host] = vt.ub[7 ^ host];
return vd.d;
}
uint64_t helper_pavgh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; i++) {
vs.uh[i] = (vs.uh[i] + vt.uh[i] + 1) >> 1;
}
return vs.d;
}
uint64_t helper_pavgb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; i++) {
vs.ub[i] = (vs.ub[i] + vt.ub[i] + 1) >> 1;
}
return vs.d;
}
uint64_t helper_pmaxsh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; i++) {
vs.sh[i] = (vs.sh[i] >= vt.sh[i] ? vs.sh[i] : vt.sh[i]);
}
return vs.d;
}
uint64_t helper_pminsh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; i++) {
vs.sh[i] = (vs.sh[i] <= vt.sh[i] ? vs.sh[i] : vt.sh[i]);
}
return vs.d;
}
uint64_t helper_pmaxub(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; i++) {
vs.ub[i] = (vs.ub[i] >= vt.ub[i] ? vs.ub[i] : vt.ub[i]);
}
return vs.d;
}
uint64_t helper_pminub(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; i++) {
vs.ub[i] = (vs.ub[i] <= vt.ub[i] ? vs.ub[i] : vt.ub[i]);
}
return vs.d;
}
uint64_t helper_pcmpeqw(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 2; i++) {
vs.uw[i] = -(vs.uw[i] == vt.uw[i]);
}
return vs.d;
}
uint64_t helper_pcmpgtw(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 2; i++) {
vs.uw[i] = -(vs.uw[i] > vt.uw[i]);
}
return vs.d;
}
uint64_t helper_pcmpeqh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; i++) {
vs.uh[i] = -(vs.uh[i] == vt.uh[i]);
}
return vs.d;
}
uint64_t helper_pcmpgth(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; i++) {
vs.uh[i] = -(vs.uh[i] > vt.uh[i]);
}
return vs.d;
}
uint64_t helper_pcmpeqb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; i++) {
vs.ub[i] = -(vs.ub[i] == vt.ub[i]);
}
return vs.d;
}
uint64_t helper_pcmpgtb(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; i++) {
vs.ub[i] = -(vs.ub[i] > vt.ub[i]);
}
return vs.d;
}
uint64_t helper_psllw(uint64_t fs, uint64_t ft)
{
LMIValue vs;
unsigned i;
ft &= 0x7f;
if (ft > 31) {
return 0;
}
vs.d = fs;
for (i = 0; i < 2; ++i) {
vs.uw[i] <<= ft;
}
return vs.d;
}
uint64_t helper_psrlw(uint64_t fs, uint64_t ft)
{
LMIValue vs;
unsigned i;
ft &= 0x7f;
if (ft > 31) {
return 0;
}
vs.d = fs;
for (i = 0; i < 2; ++i) {
vs.uw[i] >>= ft;
}
return vs.d;
}
uint64_t helper_psraw(uint64_t fs, uint64_t ft)
{
LMIValue vs;
unsigned i;
ft &= 0x7f;
if (ft > 31) {
ft = 31;
}
vs.d = fs;
for (i = 0; i < 2; ++i) {
vs.sw[i] >>= ft;
}
return vs.d;
}
uint64_t helper_psllh(uint64_t fs, uint64_t ft)
{
LMIValue vs;
unsigned i;
ft &= 0x7f;
if (ft > 15) {
return 0;
}
vs.d = fs;
for (i = 0; i < 4; ++i) {
vs.uh[i] <<= ft;
}
return vs.d;
}
uint64_t helper_psrlh(uint64_t fs, uint64_t ft)
{
LMIValue vs;
unsigned i;
ft &= 0x7f;
if (ft > 15) {
return 0;
}
vs.d = fs;
for (i = 0; i < 4; ++i) {
vs.uh[i] >>= ft;
}
return vs.d;
}
uint64_t helper_psrah(uint64_t fs, uint64_t ft)
{
LMIValue vs;
unsigned i;
ft &= 0x7f;
if (ft > 15) {
ft = 15;
}
vs.d = fs;
for (i = 0; i < 4; ++i) {
vs.sh[i] >>= ft;
}
return vs.d;
}
uint64_t helper_pmullh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
vs.sh[i] *= vt.sh[i];
}
return vs.d;
}
uint64_t helper_pmulhh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
int32_t r = vs.sh[i] * vt.sh[i];
vs.sh[i] = r >> 16;
}
return vs.d;
}
uint64_t helper_pmulhuh(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 4; ++i) {
uint32_t r = vs.uh[i] * vt.uh[i];
vs.uh[i] = r >> 16;
}
return vs.d;
}
uint64_t helper_pmaddhw(uint64_t fs, uint64_t ft)
{
unsigned host = BYTE_ORDER_XOR(3);
LMIValue vs, vt;
uint32_t p0, p1;
vs.d = fs;
vt.d = ft;
p0 = vs.sh[0 ^ host] * vt.sh[0 ^ host];
p0 += vs.sh[1 ^ host] * vt.sh[1 ^ host];
p1 = vs.sh[2 ^ host] * vt.sh[2 ^ host];
p1 += vs.sh[3 ^ host] * vt.sh[3 ^ host];
return ((uint64_t)p1 << 32) | p0;
}
uint64_t helper_pasubub(uint64_t fs, uint64_t ft)
{
LMIValue vs, vt;
unsigned i;
vs.d = fs;
vt.d = ft;
for (i = 0; i < 8; ++i) {
int r = vs.ub[i] - vt.ub[i];
vs.ub[i] = (r < 0 ? -r : r);
}
return vs.d;
}
uint64_t helper_biadd(uint64_t fs)
{
unsigned i, fd;
for (i = fd = 0; i < 8; ++i) {
fd += (fs >> (i * 8)) & 0xff;
}
return fd & 0xffff;
}
uint64_t helper_pmovmskb(uint64_t fs)
{
unsigned fd = 0;
fd |= ((fs >> 7) & 1) << 0;
fd |= ((fs >> 15) & 1) << 1;
fd |= ((fs >> 23) & 1) << 2;
fd |= ((fs >> 31) & 1) << 3;
fd |= ((fs >> 39) & 1) << 4;
fd |= ((fs >> 47) & 1) << 5;
fd |= ((fs >> 55) & 1) << 6;
fd |= ((fs >> 63) & 1) << 7;
return fd & 0xff;
}
Reference in New Issue View Git Blame Copy Permalink