ppc patch queue for 2016-Sep-7
This is my first pull request for the newly opened qemu-2.8 tree. It contains a heap of things that were too late for 2.7 and have been queued for a while. In particular: * A number of preliminary patches for the powernv machine type * A substantial cleanup of exception handling which will be necessary to support running a TCG with hypervisor facilities * A start on support for POWER9 * Some TCG implementations for new POWER9 instructions * Some TCG and related cleanups in preparation for POWER9 * Some assorted TCG optimizations * An implementation of the H_CHANGE_LOGICAL_LAN_MAC hypercall which allows the MAC address to be changed on the PAPR virtual NIC. * Add some extra test cases for several machines (this isn't strictly in the ppc code, but is most value to ppc) NOTE: This pull request supersedes ppc-for-2.8-20160906, which had some problems. Changes: * Dropped BenH's lmw/stmw speedups, which break for qemu-system-ppc64 on BE hosts * A small fix to Thomas' serial output test to avoid a warning on the isapc machine type. * Some trivial checkpatch fixes Note that some of the patches in this series still have large numbers of checkpatch warnings. This is because they're moving existing code that predates most of the checkpatch style conventions. -----BEGIN PGP SIGNATURE----- iQIcBAABAgAGBQJXz68XAAoJEGw4ysog2bOS4TgQAObm4jNLFSbYEWyy3ZEY9p7Y K98+l3UAtzjDRirv5msBIdtH4j0DDRqUmCCHKKwHSIf6CAgC9z00Yjd2KZy6DFiO 5gHIQnJbvSqB/0HrDmpvOCSBboSm3CW0ZRex6pvTD/7OFHGd5KzhZ8Q+KxITePEi aYjD6qubYWr22GwXiip+a7EgJ46vtEh/R6WS0Cp1FGQmtJeMCFtsyHtZaZy8t73f UXzUktMjoMV7RT74EcLdkbl672MWJ6tTQRJAg4C5YCW9yclioXQqk9ARZyWkFpXB cgJyEC3l4sjFU5VLYVxm0OLqS4QpMb2B3Cg2HtUuBdUnBsZ4NH4oKcI9GH/EVj5t rt5Xx1u04H/tZVJkCXc6/QKrUh82MnYPylbHXDsv8Xo3Bdy7h8bgQYLscA6w7r53 PAgVfrdIWbXmbz7VjpPmZsuk0d2B5CiA2jhDRwv0LTv2LZxwd+AxymwaaSbZiMCP A6U7aMt4fjBFnK5FsTFMwGz/8wr4QfPvmtPUSVBJhvPfeq6CrieK8xaqR/RuQgcm lwGDo9RCk66MoM325+1xzQnzzrOubn4RGIMCoCJAIMWQ4n4eYBp04y0FB4UAkjSU h2c0SnnMoyUnb/BICezGTnA8St9EDYDx5/e2HLo9wkXJAvlV3C+RRtFOvuPDpmDq 3qSELiaINaNhJWGdMFHt =T1rz -----END PGP SIGNATURE----- Merge remote-tracking branch 'remotes/dgibson/tags/ppc-for-2.8-20160907' into staging ppc patch queue for 2016-Sep-7 This is my first pull request for the newly opened qemu-2.8 tree. It contains a heap of things that were too late for 2.7 and have been queued for a while. In particular: * A number of preliminary patches for the powernv machine type * A substantial cleanup of exception handling which will be necessary to support running a TCG with hypervisor facilities * A start on support for POWER9 * Some TCG implementations for new POWER9 instructions * Some TCG and related cleanups in preparation for POWER9 * Some assorted TCG optimizations * An implementation of the H_CHANGE_LOGICAL_LAN_MAC hypercall which allows the MAC address to be changed on the PAPR virtual NIC. * Add some extra test cases for several machines (this isn't strictly in the ppc code, but is most value to ppc) NOTE: This pull request supersedes ppc-for-2.8-20160906, which had some problems. Changes: * Dropped BenH's lmw/stmw speedups, which break for qemu-system-ppc64 on BE hosts * A small fix to Thomas' serial output test to avoid a warning on the isapc machine type. * Some trivial checkpatch fixes Note that some of the patches in this series still have large numbers of checkpatch warnings. This is because they're moving existing code that predates most of the checkpatch style conventions. # gpg: Signature made Wed 07 Sep 2016 07:09:27 BST # gpg: using RSA key 0x6C38CACA20D9B392 # gpg: Good signature from "David Gibson <david@gibson.dropbear.id.au>" # gpg: aka "David Gibson (Red Hat) <dgibson@redhat.com>" # gpg: aka "David Gibson (ozlabs.org) <dgibson@ozlabs.org>" # gpg: aka "David Gibson (kernel.org) <dwg@kernel.org>" # Primary key fingerprint: 75F4 6586 AE61 A66C C44E 87DC 6C38 CACA 20D9 B392 * remotes/dgibson/tags/ppc-for-2.8-20160907: (64 commits) tests: Check serial output of firmware boot of some machines tests: Resort check-qtest entries in Makefile.include spapr: implement H_CHANGE_LOGICAL_LAN_MAC h_call ppc: Improve a few more helper flags ppc: Improve the exception helpers flags ppc: Improve flags for helpers loading/writing the time facilities ppc: Don't generate dead code on unconditional branches ppc: Stop dumping state on all exceptions in linux-user ppc: Fix catching some segfaults in user mode ppc: Fix macio ESCC legacy mapping hw/ppc: add a ppc_create_page_sizes_prop() helper routine hw/ppc: use error_report instead of fprintf ppc: Rename #include'd .c files to .inc.c target-ppc: add extswsli[.] instruction target-ppc: add vsrv instruction target-ppc: add vslv instruction target-ppc: add vcmpnez[b,h,w][.] instructions target-ppc: add vabsdu[b,h,w] instructions target-ppc: add dtstsfi[q] instructions target-ppc: implement branch-less divd[o][.] ... Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
commit
59351d9b40
|
@ -329,6 +329,7 @@ static void xics_kvm_cpu_setup(XICSState *xics, PowerPCCPU *cpu)
|
|||
CPUState *cs;
|
||||
ICPState *ss;
|
||||
KVMXICSState *xicskvm = XICS_SPAPR_KVM(xics);
|
||||
int ret;
|
||||
|
||||
cs = CPU(cpu);
|
||||
ss = &xics->ss[cs->cpu_index];
|
||||
|
@ -347,19 +348,14 @@ static void xics_kvm_cpu_setup(XICSState *xics, PowerPCCPU *cpu)
|
|||
return;
|
||||
}
|
||||
|
||||
if (xicskvm->kernel_xics_fd != -1) {
|
||||
int ret;
|
||||
|
||||
ret = kvm_vcpu_enable_cap(cs, KVM_CAP_IRQ_XICS, 0,
|
||||
xicskvm->kernel_xics_fd,
|
||||
kvm_arch_vcpu_id(cs));
|
||||
if (ret < 0) {
|
||||
error_report("Unable to connect CPU%ld to kernel XICS: %s",
|
||||
kvm_arch_vcpu_id(cs), strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
ss->cap_irq_xics_enabled = true;
|
||||
ret = kvm_vcpu_enable_cap(cs, KVM_CAP_IRQ_XICS, 0, xicskvm->kernel_xics_fd,
|
||||
kvm_arch_vcpu_id(cs));
|
||||
if (ret < 0) {
|
||||
error_report("Unable to connect CPU%ld to kernel XICS: %s",
|
||||
kvm_arch_vcpu_id(cs), strerror(errno));
|
||||
exit(1);
|
||||
}
|
||||
ss->cap_irq_xics_enabled = true;
|
||||
}
|
||||
|
||||
static void xics_kvm_set_nr_irqs(XICSState *xics, uint32_t nr_irqs,
|
||||
|
|
|
@ -89,22 +89,16 @@ static void macio_escc_legacy_setup(MacIOState *macio_state)
|
|||
MemoryRegion *bar = &macio_state->bar;
|
||||
int i;
|
||||
static const int maps[] = {
|
||||
0x00, 0x00,
|
||||
0x02, 0x20,
|
||||
0x04, 0x10,
|
||||
0x06, 0x30,
|
||||
0x08, 0x40,
|
||||
0x0A, 0x50,
|
||||
0x60, 0x60,
|
||||
0x70, 0x70,
|
||||
0x80, 0x70,
|
||||
0x90, 0x80,
|
||||
0xA0, 0x90,
|
||||
0xB0, 0xA0,
|
||||
0xC0, 0xB0,
|
||||
0xD0, 0xC0,
|
||||
0xE0, 0xD0,
|
||||
0xF0, 0xE0,
|
||||
0x00, 0x00, /* Command B */
|
||||
0x02, 0x20, /* Command A */
|
||||
0x04, 0x10, /* Data B */
|
||||
0x06, 0x30, /* Data A */
|
||||
0x08, 0x40, /* Enhancement B */
|
||||
0x0A, 0x50, /* Enhancement A */
|
||||
0x80, 0x80, /* Recovery count */
|
||||
0x90, 0x90, /* Start A */
|
||||
0xa0, 0xa0, /* Start B */
|
||||
0xb0, 0xb0, /* Detect AB */
|
||||
};
|
||||
|
||||
memory_region_init(escc_legacy, OBJECT(macio_state), "escc-legacy", 256);
|
||||
|
|
|
@ -106,6 +106,7 @@ typedef struct VIOsPAPRVLANDevice {
|
|||
VIOsPAPRDevice sdev;
|
||||
NICConf nicconf;
|
||||
NICState *nic;
|
||||
MACAddr perm_mac;
|
||||
bool isopen;
|
||||
hwaddr buf_list;
|
||||
uint32_t add_buf_ptr, use_buf_ptr, rx_bufs;
|
||||
|
@ -316,6 +317,10 @@ static void spapr_vlan_reset(VIOsPAPRDevice *sdev)
|
|||
spapr_vlan_reset_rx_pool(dev->rx_pool[i]);
|
||||
}
|
||||
}
|
||||
|
||||
memcpy(&dev->nicconf.macaddr.a, &dev->perm_mac.a,
|
||||
sizeof(dev->nicconf.macaddr.a));
|
||||
qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
|
||||
}
|
||||
|
||||
static void spapr_vlan_realize(VIOsPAPRDevice *sdev, Error **errp)
|
||||
|
@ -324,6 +329,8 @@ static void spapr_vlan_realize(VIOsPAPRDevice *sdev, Error **errp)
|
|||
|
||||
qemu_macaddr_default_if_unset(&dev->nicconf.macaddr);
|
||||
|
||||
memcpy(&dev->perm_mac.a, &dev->nicconf.macaddr.a, sizeof(dev->perm_mac.a));
|
||||
|
||||
dev->nic = qemu_new_nic(&net_spapr_vlan_info, &dev->nicconf,
|
||||
object_get_typename(OBJECT(sdev)), sdev->qdev.id, dev);
|
||||
qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
|
||||
|
@ -756,6 +763,27 @@ static target_ulong h_multicast_ctrl(PowerPCCPU *cpu, sPAPRMachineState *spapr,
|
|||
return H_SUCCESS;
|
||||
}
|
||||
|
||||
static target_ulong h_change_logical_lan_mac(PowerPCCPU *cpu,
|
||||
sPAPRMachineState *spapr,
|
||||
target_ulong opcode,
|
||||
target_ulong *args)
|
||||
{
|
||||
target_ulong reg = args[0];
|
||||
target_ulong macaddr = args[1];
|
||||
VIOsPAPRDevice *sdev = spapr_vio_find_by_reg(spapr->vio_bus, reg);
|
||||
VIOsPAPRVLANDevice *dev = VIO_SPAPR_VLAN_DEVICE(sdev);
|
||||
int i;
|
||||
|
||||
for (i = 0; i < ETH_ALEN; i++) {
|
||||
dev->nicconf.macaddr.a[ETH_ALEN - i - 1] = macaddr & 0xff;
|
||||
macaddr >>= 8;
|
||||
}
|
||||
|
||||
qemu_format_nic_info_str(qemu_get_queue(dev->nic), dev->nicconf.macaddr.a);
|
||||
|
||||
return H_SUCCESS;
|
||||
}
|
||||
|
||||
static Property spapr_vlan_properties[] = {
|
||||
DEFINE_SPAPR_PROPERTIES(VIOsPAPRVLANDevice, sdev),
|
||||
DEFINE_NIC_PROPERTIES(VIOsPAPRVLANDevice, nicconf),
|
||||
|
@ -854,6 +882,8 @@ static void spapr_vlan_register_types(void)
|
|||
spapr_register_hypercall(H_ADD_LOGICAL_LAN_BUFFER,
|
||||
h_add_logical_lan_buffer);
|
||||
spapr_register_hypercall(H_MULTICAST_CTRL, h_multicast_ctrl);
|
||||
spapr_register_hypercall(H_CHANGE_LOGICAL_LAN_MAC,
|
||||
h_change_logical_lan_mac);
|
||||
type_register_static(&spapr_vlan_info);
|
||||
}
|
||||
|
||||
|
|
|
@ -1,5 +1,5 @@
|
|||
# shared objects
|
||||
obj-y += ppc.o ppc_booke.o
|
||||
obj-y += ppc.o ppc_booke.o fdt.o
|
||||
# IBM pSeries (sPAPR)
|
||||
obj-$(CONFIG_PSERIES) += spapr.o spapr_vio.o spapr_events.o
|
||||
obj-$(CONFIG_PSERIES) += spapr_hcall.o spapr_iommu.o spapr_rtas.o
|
||||
|
|
49
hw/ppc/fdt.c
Normal file
49
hw/ppc/fdt.c
Normal file
|
@ -0,0 +1,49 @@
|
|||
/*
|
||||
* QEMU PowerPC helper routines for the device tree.
|
||||
*
|
||||
* Copyright (C) 2016 IBM Corp.
|
||||
*
|
||||
* This code is licensed under the GPL version 2 or later. See the
|
||||
* COPYING file in the top-level directory.
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qapi/error.h"
|
||||
#include "target-ppc/cpu.h"
|
||||
|
||||
#include "hw/ppc/fdt.h"
|
||||
|
||||
#if defined(TARGET_PPC64)
|
||||
size_t ppc_create_page_sizes_prop(CPUPPCState *env, uint32_t *prop,
|
||||
size_t maxsize)
|
||||
{
|
||||
size_t maxcells = maxsize / sizeof(uint32_t);
|
||||
int i, j, count;
|
||||
uint32_t *p = prop;
|
||||
|
||||
for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) {
|
||||
struct ppc_one_seg_page_size *sps = &env->sps.sps[i];
|
||||
|
||||
if (!sps->page_shift) {
|
||||
break;
|
||||
}
|
||||
for (count = 0; count < PPC_PAGE_SIZES_MAX_SZ; count++) {
|
||||
if (sps->enc[count].page_shift == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ((p - prop) >= (maxcells - 3 - count * 2)) {
|
||||
break;
|
||||
}
|
||||
*(p++) = cpu_to_be32(sps->page_shift);
|
||||
*(p++) = cpu_to_be32(sps->slb_enc);
|
||||
*(p++) = cpu_to_be32(count);
|
||||
for (j = 0; j < count; j++) {
|
||||
*(p++) = cpu_to_be32(sps->enc[j].page_shift);
|
||||
*(p++) = cpu_to_be32(sps->enc[j].pte_enc);
|
||||
}
|
||||
}
|
||||
|
||||
return (p - prop) * sizeof(uint32_t);
|
||||
}
|
||||
#endif
|
|
@ -47,6 +47,7 @@
|
|||
#include "hw/ppc/ppc.h"
|
||||
#include "hw/loader.h"
|
||||
|
||||
#include "hw/ppc/fdt.h"
|
||||
#include "hw/ppc/spapr.h"
|
||||
#include "hw/ppc/spapr_vio.h"
|
||||
#include "hw/pci-host/spapr.h"
|
||||
|
@ -249,40 +250,6 @@ static int spapr_fixup_cpu_dt(void *fdt, sPAPRMachineState *spapr)
|
|||
return ret;
|
||||
}
|
||||
|
||||
|
||||
static size_t create_page_sizes_prop(CPUPPCState *env, uint32_t *prop,
|
||||
size_t maxsize)
|
||||
{
|
||||
size_t maxcells = maxsize / sizeof(uint32_t);
|
||||
int i, j, count;
|
||||
uint32_t *p = prop;
|
||||
|
||||
for (i = 0; i < PPC_PAGE_SIZES_MAX_SZ; i++) {
|
||||
struct ppc_one_seg_page_size *sps = &env->sps.sps[i];
|
||||
|
||||
if (!sps->page_shift) {
|
||||
break;
|
||||
}
|
||||
for (count = 0; count < PPC_PAGE_SIZES_MAX_SZ; count++) {
|
||||
if (sps->enc[count].page_shift == 0) {
|
||||
break;
|
||||
}
|
||||
}
|
||||
if ((p - prop) >= (maxcells - 3 - count * 2)) {
|
||||
break;
|
||||
}
|
||||
*(p++) = cpu_to_be32(sps->page_shift);
|
||||
*(p++) = cpu_to_be32(sps->slb_enc);
|
||||
*(p++) = cpu_to_be32(count);
|
||||
for (j = 0; j < count; j++) {
|
||||
*(p++) = cpu_to_be32(sps->enc[j].page_shift);
|
||||
*(p++) = cpu_to_be32(sps->enc[j].pte_enc);
|
||||
}
|
||||
}
|
||||
|
||||
return (p - prop) * sizeof(uint32_t);
|
||||
}
|
||||
|
||||
static hwaddr spapr_node0_size(void)
|
||||
{
|
||||
MachineState *machine = MACHINE(qdev_get_machine());
|
||||
|
@ -299,16 +266,6 @@ static hwaddr spapr_node0_size(void)
|
|||
return machine->ram_size;
|
||||
}
|
||||
|
||||
#define _FDT(exp) \
|
||||
do { \
|
||||
int ret = (exp); \
|
||||
if (ret < 0) { \
|
||||
fprintf(stderr, "qemu: error creating device tree: %s: %s\n", \
|
||||
#exp, fdt_strerror(ret)); \
|
||||
exit(1); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
static void add_str(GString *s, const gchar *s1)
|
||||
{
|
||||
g_string_append_len(s, s1, strlen(s1) + 1);
|
||||
|
@ -656,13 +613,13 @@ static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset,
|
|||
_FDT((fdt_setprop_cell(fdt, offset, "d-cache-size",
|
||||
pcc->l1_dcache_size)));
|
||||
} else {
|
||||
fprintf(stderr, "Warning: Unknown L1 dcache size for cpu\n");
|
||||
error_report("Warning: Unknown L1 dcache size for cpu");
|
||||
}
|
||||
if (pcc->l1_icache_size) {
|
||||
_FDT((fdt_setprop_cell(fdt, offset, "i-cache-size",
|
||||
pcc->l1_icache_size)));
|
||||
} else {
|
||||
fprintf(stderr, "Warning: Unknown L1 icache size for cpu\n");
|
||||
error_report("Warning: Unknown L1 icache size for cpu");
|
||||
}
|
||||
|
||||
_FDT((fdt_setprop_cell(fdt, offset, "timebase-frequency", tbfreq)));
|
||||
|
@ -698,7 +655,7 @@ static void spapr_populate_cpu_dt(CPUState *cs, void *fdt, int offset,
|
|||
_FDT((fdt_setprop_cell(fdt, offset, "ibm,dfp", 1)));
|
||||
}
|
||||
|
||||
page_sizes_prop_size = create_page_sizes_prop(env, page_sizes_prop,
|
||||
page_sizes_prop_size = ppc_create_page_sizes_prop(env, page_sizes_prop,
|
||||
sizeof(page_sizes_prop));
|
||||
if (page_sizes_prop_size) {
|
||||
_FDT((fdt_setprop(fdt, offset, "ibm,segment-page-sizes",
|
||||
|
@ -954,20 +911,20 @@ static void spapr_finalize_fdt(sPAPRMachineState *spapr,
|
|||
|
||||
ret = spapr_populate_memory(spapr, fdt);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "couldn't setup memory nodes in fdt\n");
|
||||
error_report("couldn't setup memory nodes in fdt");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
ret = spapr_populate_vdevice(spapr->vio_bus, fdt);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "couldn't setup vio devices in fdt\n");
|
||||
error_report("couldn't setup vio devices in fdt");
|
||||
exit(1);
|
||||
}
|
||||
|
||||
if (object_resolve_path_type("", TYPE_SPAPR_RNG, NULL)) {
|
||||
ret = spapr_rng_populate_dt(fdt);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "could not set up rng device in the fdt\n");
|
||||
error_report("could not set up rng device in the fdt");
|
||||
exit(1);
|
||||
}
|
||||
}
|
||||
|
@ -983,7 +940,7 @@ static void spapr_finalize_fdt(sPAPRMachineState *spapr,
|
|||
/* RTAS */
|
||||
ret = spapr_rtas_device_tree_setup(fdt, rtas_addr, rtas_size);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Couldn't set up RTAS device tree properties\n");
|
||||
error_report("Couldn't set up RTAS device tree properties");
|
||||
}
|
||||
|
||||
/* cpus */
|
||||
|
|
|
@ -816,7 +816,7 @@ int spapr_drc_populate_dt(void *fdt, int fdt_offset, Object *owner,
|
|||
drc_indexes->data,
|
||||
drc_indexes->len * sizeof(uint32_t));
|
||||
if (ret) {
|
||||
fprintf(stderr, "Couldn't create ibm,drc-indexes property\n");
|
||||
error_report("Couldn't create ibm,drc-indexes property");
|
||||
goto out;
|
||||
}
|
||||
|
||||
|
@ -824,21 +824,21 @@ int spapr_drc_populate_dt(void *fdt, int fdt_offset, Object *owner,
|
|||
drc_power_domains->data,
|
||||
drc_power_domains->len * sizeof(uint32_t));
|
||||
if (ret) {
|
||||
fprintf(stderr, "Couldn't finalize ibm,drc-power-domains property\n");
|
||||
error_report("Couldn't finalize ibm,drc-power-domains property");
|
||||
goto out;
|
||||
}
|
||||
|
||||
ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-names",
|
||||
drc_names->str, drc_names->len);
|
||||
if (ret) {
|
||||
fprintf(stderr, "Couldn't finalize ibm,drc-names property\n");
|
||||
error_report("Couldn't finalize ibm,drc-names property");
|
||||
goto out;
|
||||
}
|
||||
|
||||
ret = fdt_setprop(fdt, fdt_offset, "ibm,drc-types",
|
||||
drc_types->str, drc_types->len);
|
||||
if (ret) {
|
||||
fprintf(stderr, "Couldn't finalize ibm,drc-types property\n");
|
||||
error_report("Couldn't finalize ibm,drc-types property");
|
||||
goto out;
|
||||
}
|
||||
|
||||
|
|
|
@ -32,6 +32,7 @@
|
|||
#include "hw/qdev.h"
|
||||
#include "sysemu/device_tree.h"
|
||||
|
||||
#include "hw/ppc/fdt.h"
|
||||
#include "hw/ppc/spapr.h"
|
||||
#include "hw/ppc/spapr_vio.h"
|
||||
#include "hw/pci/pci.h"
|
||||
|
@ -210,16 +211,6 @@ struct hp_log_full {
|
|||
#define EVENT_MASK_HOTPLUG 0x10000000
|
||||
#define EVENT_MASK_IO 0x08000000
|
||||
|
||||
#define _FDT(exp) \
|
||||
do { \
|
||||
int ret = (exp); \
|
||||
if (ret < 0) { \
|
||||
fprintf(stderr, "qemu: error creating device tree: %s: %s\n", \
|
||||
#exp, fdt_strerror(ret)); \
|
||||
exit(1); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
void spapr_events_fdt_skel(void *fdt, uint32_t check_exception_irq)
|
||||
{
|
||||
uint32_t irq_ranges[] = {cpu_to_be32(check_exception_irq), cpu_to_be32(1)};
|
||||
|
|
|
@ -310,8 +310,8 @@ sPAPRTCETable *spapr_tce_new_table(DeviceState *owner, uint32_t liobn)
|
|||
char tmp[32];
|
||||
|
||||
if (spapr_tce_find_by_liobn(liobn)) {
|
||||
fprintf(stderr, "Attempted to create TCE table with duplicate"
|
||||
" LIOBN 0x%x\n", liobn);
|
||||
error_report("Attempted to create TCE table with duplicate"
|
||||
" LIOBN 0x%x", liobn);
|
||||
return NULL;
|
||||
}
|
||||
|
||||
|
|
|
@ -27,6 +27,7 @@
|
|||
#include "qemu/osdep.h"
|
||||
#include "cpu.h"
|
||||
#include "qemu/log.h"
|
||||
#include "qemu/error-report.h"
|
||||
#include "sysemu/sysemu.h"
|
||||
#include "sysemu/char.h"
|
||||
#include "hw/qdev.h"
|
||||
|
@ -716,7 +717,7 @@ int spapr_rtas_device_tree_setup(void *fdt, hwaddr rtas_addr,
|
|||
|
||||
ret = fdt_add_mem_rsv(fdt, rtas_addr, rtas_size);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Couldn't add RTAS reserve entry: %s\n",
|
||||
error_report("Couldn't add RTAS reserve entry: %s",
|
||||
fdt_strerror(ret));
|
||||
return ret;
|
||||
}
|
||||
|
@ -724,7 +725,7 @@ int spapr_rtas_device_tree_setup(void *fdt, hwaddr rtas_addr,
|
|||
ret = qemu_fdt_setprop_cell(fdt, "/rtas", "linux,rtas-base",
|
||||
rtas_addr);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Couldn't add linux,rtas-base property: %s\n",
|
||||
error_report("Couldn't add linux,rtas-base property: %s",
|
||||
fdt_strerror(ret));
|
||||
return ret;
|
||||
}
|
||||
|
@ -732,7 +733,7 @@ int spapr_rtas_device_tree_setup(void *fdt, hwaddr rtas_addr,
|
|||
ret = qemu_fdt_setprop_cell(fdt, "/rtas", "linux,rtas-entry",
|
||||
rtas_addr);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Couldn't add linux,rtas-entry property: %s\n",
|
||||
error_report("Couldn't add linux,rtas-entry property: %s",
|
||||
fdt_strerror(ret));
|
||||
return ret;
|
||||
}
|
||||
|
@ -740,7 +741,7 @@ int spapr_rtas_device_tree_setup(void *fdt, hwaddr rtas_addr,
|
|||
ret = qemu_fdt_setprop_cell(fdt, "/rtas", "rtas-size",
|
||||
rtas_size);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Couldn't add rtas-size property: %s\n",
|
||||
error_report("Couldn't add rtas-size property: %s",
|
||||
fdt_strerror(ret));
|
||||
return ret;
|
||||
}
|
||||
|
@ -755,7 +756,7 @@ int spapr_rtas_device_tree_setup(void *fdt, hwaddr rtas_addr,
|
|||
ret = qemu_fdt_setprop_cell(fdt, "/rtas", call->name,
|
||||
i + RTAS_TOKEN_BASE);
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Couldn't add rtas token for %s: %s\n",
|
||||
error_report("Couldn't add rtas token for %s: %s",
|
||||
call->name, fdt_strerror(ret));
|
||||
return ret;
|
||||
}
|
||||
|
@ -770,7 +771,7 @@ int spapr_rtas_device_tree_setup(void *fdt, hwaddr rtas_addr,
|
|||
ret = qemu_fdt_setprop(fdt, "/rtas", "ibm,lrdr-capacity", lrdr_capacity,
|
||||
sizeof(lrdr_capacity));
|
||||
if (ret < 0) {
|
||||
fprintf(stderr, "Couldn't add ibm,lrdr-capacity rtas property\n");
|
||||
error_report("Couldn't add ibm,lrdr-capacity rtas property");
|
||||
return ret;
|
||||
}
|
||||
|
||||
|
|
|
@ -20,6 +20,7 @@
|
|||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qemu/error-report.h"
|
||||
#include "qapi/error.h"
|
||||
#include "hw/hw.h"
|
||||
#include "qemu/log.h"
|
||||
|
@ -276,7 +277,7 @@ int spapr_vio_send_crq(VIOsPAPRDevice *dev, uint8_t *crq)
|
|||
uint8_t byte;
|
||||
|
||||
if (!dev->crq.qsize) {
|
||||
fprintf(stderr, "spapr_vio_send_creq on uninitialized queue\n");
|
||||
error_report("spapr_vio_send_creq on uninitialized queue");
|
||||
return -1;
|
||||
}
|
||||
|
||||
|
|
30
include/hw/ppc/fdt.h
Normal file
30
include/hw/ppc/fdt.h
Normal file
|
@ -0,0 +1,30 @@
|
|||
/*
|
||||
* QEMU PowerPC helper routines for the device tree.
|
||||
*
|
||||
* Copyright (C) 2016 IBM Corp.
|
||||
*
|
||||
* This code is licensed under the GPL version 2 or later. See the
|
||||
* COPYING file in the top-level directory.
|
||||
*/
|
||||
|
||||
#ifndef PPC_FDT_H
|
||||
#define PPC_FDT_H
|
||||
|
||||
#include "qemu/error-report.h"
|
||||
|
||||
typedef struct CPUPPCState CPUPPCState;
|
||||
|
||||
#define _FDT(exp) \
|
||||
do { \
|
||||
int ret = (exp); \
|
||||
if (ret < 0) { \
|
||||
error_report("error creating device tree: %s: %s", \
|
||||
#exp, fdt_strerror(ret)); \
|
||||
exit(1); \
|
||||
} \
|
||||
} while (0)
|
||||
|
||||
size_t ppc_create_page_sizes_prop(CPUPPCState *env, uint32_t *prop,
|
||||
size_t maxsize);
|
||||
|
||||
#endif /* PPC_FDT_H */
|
|
@ -1651,11 +1651,10 @@ void cpu_loop(CPUPPCState *env)
|
|||
"Aborting\n");
|
||||
break;
|
||||
case POWERPC_EXCP_DSI: /* Data storage exception */
|
||||
EXCP_DUMP(env, "Invalid data memory access: 0x" TARGET_FMT_lx "\n",
|
||||
env->spr[SPR_DAR]);
|
||||
/* XXX: check this. Seems bugged */
|
||||
switch (env->error_code & 0xFF000000) {
|
||||
case 0x40000000:
|
||||
case 0x42000000:
|
||||
info.si_signo = TARGET_SIGSEGV;
|
||||
info.si_errno = 0;
|
||||
info.si_code = TARGET_SEGV_MAPERR;
|
||||
|
@ -1683,8 +1682,6 @@ void cpu_loop(CPUPPCState *env)
|
|||
queue_signal(env, info.si_signo, &info);
|
||||
break;
|
||||
case POWERPC_EXCP_ISI: /* Instruction storage exception */
|
||||
EXCP_DUMP(env, "Invalid instruction fetch: 0x\n" TARGET_FMT_lx
|
||||
"\n", env->spr[SPR_SRR0]);
|
||||
/* XXX: check this */
|
||||
switch (env->error_code & 0xFF000000) {
|
||||
case 0x40000000:
|
||||
|
@ -1715,7 +1712,6 @@ void cpu_loop(CPUPPCState *env)
|
|||
"Aborting\n");
|
||||
break;
|
||||
case POWERPC_EXCP_ALIGN: /* Alignment exception */
|
||||
EXCP_DUMP(env, "Unaligned memory access\n");
|
||||
/* XXX: check this */
|
||||
info.si_signo = TARGET_SIGBUS;
|
||||
info.si_errno = 0;
|
||||
|
@ -1728,7 +1724,6 @@ void cpu_loop(CPUPPCState *env)
|
|||
/* XXX: check this */
|
||||
switch (env->error_code & ~0xF) {
|
||||
case POWERPC_EXCP_FP:
|
||||
EXCP_DUMP(env, "Floating point program exception\n");
|
||||
info.si_signo = TARGET_SIGFPE;
|
||||
info.si_errno = 0;
|
||||
switch (env->error_code & 0xF) {
|
||||
|
@ -1764,7 +1759,6 @@ void cpu_loop(CPUPPCState *env)
|
|||
}
|
||||
break;
|
||||
case POWERPC_EXCP_INVAL:
|
||||
EXCP_DUMP(env, "Invalid instruction\n");
|
||||
info.si_signo = TARGET_SIGILL;
|
||||
info.si_errno = 0;
|
||||
switch (env->error_code & 0xF) {
|
||||
|
@ -1788,7 +1782,6 @@ void cpu_loop(CPUPPCState *env)
|
|||
}
|
||||
break;
|
||||
case POWERPC_EXCP_PRIV:
|
||||
EXCP_DUMP(env, "Privilege violation\n");
|
||||
info.si_signo = TARGET_SIGILL;
|
||||
info.si_errno = 0;
|
||||
switch (env->error_code & 0xF) {
|
||||
|
@ -1814,15 +1807,14 @@ void cpu_loop(CPUPPCState *env)
|
|||
env->error_code);
|
||||
break;
|
||||
}
|
||||
info._sifields._sigfault._addr = env->nip - 4;
|
||||
info._sifields._sigfault._addr = env->nip;
|
||||
queue_signal(env, info.si_signo, &info);
|
||||
break;
|
||||
case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
|
||||
EXCP_DUMP(env, "No floating point allowed\n");
|
||||
info.si_signo = TARGET_SIGILL;
|
||||
info.si_errno = 0;
|
||||
info.si_code = TARGET_ILL_COPROC;
|
||||
info._sifields._sigfault._addr = env->nip - 4;
|
||||
info._sifields._sigfault._addr = env->nip;
|
||||
queue_signal(env, info.si_signo, &info);
|
||||
break;
|
||||
case POWERPC_EXCP_SYSCALL: /* System call exception */
|
||||
|
@ -1830,11 +1822,10 @@ void cpu_loop(CPUPPCState *env)
|
|||
"Aborting\n");
|
||||
break;
|
||||
case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */
|
||||
EXCP_DUMP(env, "No APU instruction allowed\n");
|
||||
info.si_signo = TARGET_SIGILL;
|
||||
info.si_errno = 0;
|
||||
info.si_code = TARGET_ILL_COPROC;
|
||||
info._sifields._sigfault._addr = env->nip - 4;
|
||||
info._sifields._sigfault._addr = env->nip;
|
||||
queue_signal(env, info.si_signo, &info);
|
||||
break;
|
||||
case POWERPC_EXCP_DECR: /* Decrementer exception */
|
||||
|
@ -1858,11 +1849,10 @@ void cpu_loop(CPUPPCState *env)
|
|||
"Aborting\n");
|
||||
break;
|
||||
case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavail. */
|
||||
EXCP_DUMP(env, "No SPE/floating-point instruction allowed\n");
|
||||
info.si_signo = TARGET_SIGILL;
|
||||
info.si_errno = 0;
|
||||
info.si_code = TARGET_ILL_COPROC;
|
||||
info._sifields._sigfault._addr = env->nip - 4;
|
||||
info._sifields._sigfault._addr = env->nip;
|
||||
queue_signal(env, info.si_signo, &info);
|
||||
break;
|
||||
case POWERPC_EXCP_EFPDI: /* Embedded floating-point data IRQ */
|
||||
|
@ -1922,11 +1912,10 @@ void cpu_loop(CPUPPCState *env)
|
|||
"while in user mode. Aborting\n");
|
||||
break;
|
||||
case POWERPC_EXCP_VPU: /* Vector unavailable exception */
|
||||
EXCP_DUMP(env, "No Altivec instructions allowed\n");
|
||||
info.si_signo = TARGET_SIGILL;
|
||||
info.si_errno = 0;
|
||||
info.si_code = TARGET_ILL_COPROC;
|
||||
info._sifields._sigfault._addr = env->nip - 4;
|
||||
info._sifields._sigfault._addr = env->nip;
|
||||
queue_signal(env, info.si_signo, &info);
|
||||
break;
|
||||
case POWERPC_EXCP_PIT: /* Programmable interval timer IRQ */
|
||||
|
@ -2001,9 +1990,9 @@ void cpu_loop(CPUPPCState *env)
|
|||
env->gpr[5], env->gpr[6], env->gpr[7],
|
||||
env->gpr[8], 0, 0);
|
||||
if (ret == -TARGET_ERESTARTSYS) {
|
||||
env->nip -= 4;
|
||||
break;
|
||||
}
|
||||
env->nip += 4;
|
||||
if (ret == (target_ulong)(-TARGET_QEMU_ESIGRETURN)) {
|
||||
/* Returning from a successful sigreturn syscall.
|
||||
Avoid corrupting register state. */
|
||||
|
|
|
@ -1147,6 +1147,10 @@
|
|||
"POWER8NVL v1.0")
|
||||
POWERPC_DEF("970_v2.2", CPU_POWERPC_970_v22, 970,
|
||||
"PowerPC 970 v2.2")
|
||||
|
||||
POWERPC_DEF("POWER9_v1.0", CPU_POWERPC_POWER9_BASE, POWER9,
|
||||
"POWER9 v1.0")
|
||||
|
||||
POWERPC_DEF("970fx_v1.0", CPU_POWERPC_970FX_v10, 970,
|
||||
"PowerPC 970FX v1.0 (G5)")
|
||||
POWERPC_DEF("970fx_v2.0", CPU_POWERPC_970FX_v20, 970,
|
||||
|
@ -1395,6 +1399,7 @@ PowerPCCPUAlias ppc_cpu_aliases[] = {
|
|||
{ "POWER8E", "POWER8E_v2.1" },
|
||||
{ "POWER8", "POWER8_v2.0" },
|
||||
{ "POWER8NVL", "POWER8NVL_v1.0" },
|
||||
{ "POWER9", "POWER9_v1.0" },
|
||||
{ "970", "970_v2.2" },
|
||||
{ "970fx", "970fx_v3.1" },
|
||||
{ "970mp", "970mp_v1.1" },
|
||||
|
|
|
@ -562,6 +562,7 @@ enum {
|
|||
CPU_POWERPC_POWER8_v20 = 0x004D0200,
|
||||
CPU_POWERPC_POWER8NVL_BASE = 0x004C0000,
|
||||
CPU_POWERPC_POWER8NVL_v10 = 0x004C0100,
|
||||
CPU_POWERPC_POWER9_BASE = 0x004E0000,
|
||||
CPU_POWERPC_970_v22 = 0x00390202,
|
||||
CPU_POWERPC_970FX_v10 = 0x00391100,
|
||||
CPU_POWERPC_970FX_v20 = 0x003C0200,
|
||||
|
|
|
@ -86,6 +86,7 @@ enum powerpc_mmu_t {
|
|||
POWERPC_MMU_2_07 = POWERPC_MMU_64 | POWERPC_MMU_1TSEG
|
||||
| POWERPC_MMU_64K
|
||||
| POWERPC_MMU_AMR | 0x00000004,
|
||||
/* FIXME Add POWERPC_MMU_3_OO defines */
|
||||
/* Architecture 2.07 "degraded" (no 1T segments) */
|
||||
POWERPC_MMU_2_07a = POWERPC_MMU_64 | POWERPC_MMU_AMR
|
||||
| 0x00000004,
|
||||
|
|
|
@ -1202,7 +1202,6 @@ extern const struct VMStateDescription vmstate_ppc_cpu;
|
|||
PowerPCCPU *cpu_ppc_init(const char *cpu_model);
|
||||
void ppc_translate_init(void);
|
||||
const char *ppc_cpu_lookup_alias(const char *alias);
|
||||
void gen_update_current_nip(void *opaque);
|
||||
/* you can call this signal handler from your SIGBUS and SIGSEGV
|
||||
signal handlers to inform the virtual CPU of exceptions. non zero
|
||||
is returned if the signal was handled by the virtual CPU. */
|
||||
|
@ -2095,6 +2094,8 @@ enum {
|
|||
PPC2_TM = 0x0000000000020000ULL,
|
||||
/* Server PM instructgions (ISA 2.06, Book III) */
|
||||
PPC2_PM_ISA206 = 0x0000000000040000ULL,
|
||||
/* POWER ISA 3.0 */
|
||||
PPC2_ISA300 = 0x0000000000080000ULL,
|
||||
|
||||
#define PPC_TCG_INSNS2 (PPC2_BOOKE206 | PPC2_VSX | PPC2_PRCNTL | PPC2_DBRX | \
|
||||
PPC2_ISA205 | PPC2_VSX207 | PPC2_PERM_ISA206 | \
|
||||
|
@ -2102,7 +2103,8 @@ enum {
|
|||
PPC2_FP_CVT_ISA206 | PPC2_FP_TST_ISA206 | \
|
||||
PPC2_BCTAR_ISA207 | PPC2_LSQ_ISA207 | \
|
||||
PPC2_ALTIVEC_207 | PPC2_ISA207S | PPC2_DFP | \
|
||||
PPC2_FP_CVT_S64 | PPC2_TM | PPC2_PM_ISA206)
|
||||
PPC2_FP_CVT_S64 | PPC2_TM | PPC2_PM_ISA206 | \
|
||||
PPC2_ISA300)
|
||||
};
|
||||
|
||||
/*****************************************************************************/
|
||||
|
@ -2296,6 +2298,14 @@ static inline void cpu_get_tb_cpu_state(CPUPPCState *env, target_ulong *pc,
|
|||
*flags = env->hflags;
|
||||
}
|
||||
|
||||
void QEMU_NORETURN raise_exception(CPUPPCState *env, uint32_t exception);
|
||||
void QEMU_NORETURN raise_exception_ra(CPUPPCState *env, uint32_t exception,
|
||||
uintptr_t raddr);
|
||||
void QEMU_NORETURN raise_exception_err(CPUPPCState *env, uint32_t exception,
|
||||
uint32_t error_code);
|
||||
void QEMU_NORETURN raise_exception_err_ra(CPUPPCState *env, uint32_t exception,
|
||||
uint32_t error_code, uintptr_t raddr);
|
||||
|
||||
#if !defined(CONFIG_USER_ONLY)
|
||||
static inline int booke206_tlbm_id(CPUPPCState *env, ppcmas_tlb_t *tlbm)
|
||||
{
|
||||
|
|
|
@ -647,6 +647,41 @@ uint32_t helper_##op(CPUPPCState *env, uint64_t *a, uint64_t *b) \
|
|||
DFP_HELPER_TSTSF(dtstsf, 64)
|
||||
DFP_HELPER_TSTSF(dtstsfq, 128)
|
||||
|
||||
#define DFP_HELPER_TSTSFI(op, size) \
|
||||
uint32_t helper_##op(CPUPPCState *env, uint32_t a, uint64_t *b) \
|
||||
{ \
|
||||
struct PPC_DFP dfp; \
|
||||
unsigned uim; \
|
||||
\
|
||||
dfp_prepare_decimal##size(&dfp, 0, b, env); \
|
||||
\
|
||||
uim = a & 0x3F; \
|
||||
\
|
||||
if (unlikely(decNumberIsSpecial(&dfp.b))) { \
|
||||
dfp.crbf = 1; \
|
||||
} else if (uim == 0) { \
|
||||
dfp.crbf = 4; \
|
||||
} else if (unlikely(decNumberIsZero(&dfp.b))) { \
|
||||
/* Zero has no sig digits */ \
|
||||
dfp.crbf = 4; \
|
||||
} else { \
|
||||
unsigned nsd = dfp.b.digits; \
|
||||
if (uim < nsd) { \
|
||||
dfp.crbf = 8; \
|
||||
} else if (uim > nsd) { \
|
||||
dfp.crbf = 4; \
|
||||
} else { \
|
||||
dfp.crbf = 2; \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
dfp_set_FPCC_from_CRBF(&dfp); \
|
||||
return dfp.crbf; \
|
||||
}
|
||||
|
||||
DFP_HELPER_TSTSFI(dtstsfi, 64)
|
||||
DFP_HELPER_TSTSFI(dtstsfiq, 128)
|
||||
|
||||
static void QUA_PPs(struct PPC_DFP *dfp)
|
||||
{
|
||||
dfp_set_FPRF_from_FRT(dfp);
|
||||
|
|
|
@ -198,7 +198,7 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
default:
|
||||
goto excp_invalid;
|
||||
}
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_MCHECK: /* Machine check exception */
|
||||
if (msr_me == 0) {
|
||||
/* Machine check exception is not enabled.
|
||||
|
@ -235,16 +235,16 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
default:
|
||||
break;
|
||||
}
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_DSI: /* Data storage exception */
|
||||
LOG_EXCP("DSI exception: DSISR=" TARGET_FMT_lx" DAR=" TARGET_FMT_lx
|
||||
"\n", env->spr[SPR_DSISR], env->spr[SPR_DAR]);
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_ISI: /* Instruction storage exception */
|
||||
LOG_EXCP("ISI exception: msr=" TARGET_FMT_lx ", nip=" TARGET_FMT_lx
|
||||
"\n", msr, env->nip);
|
||||
msr |= env->error_code;
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_EXTERNAL: /* External input */
|
||||
cs = CPU(cpu);
|
||||
|
||||
|
@ -258,13 +258,15 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
/* IACK the IRQ on delivery */
|
||||
env->spr[SPR_BOOKE_EPR] = ldl_phys(cs->as, env->mpic_iack);
|
||||
}
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_ALIGN: /* Alignment exception */
|
||||
/* XXX: this is false */
|
||||
/* Get rS/rD and rA from faulting opcode */
|
||||
env->spr[SPR_DSISR] |= (cpu_ldl_code(env, (env->nip - 4))
|
||||
& 0x03FF0000) >> 16;
|
||||
goto store_next;
|
||||
/* Note: the opcode fields will not be set properly for a direct
|
||||
* store load/store, but nobody cares as nobody actually uses
|
||||
* direct store segments.
|
||||
*/
|
||||
env->spr[SPR_DSISR] |= (env->error_code & 0x03FF0000) >> 16;
|
||||
break;
|
||||
case POWERPC_EXCP_PROGRAM: /* Program exception */
|
||||
switch (env->error_code & ~0xF) {
|
||||
case POWERPC_EXCP_FP:
|
||||
|
@ -274,11 +276,12 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
env->error_code = 0;
|
||||
return;
|
||||
}
|
||||
|
||||
/* FP exceptions always have NIP pointing to the faulting
|
||||
* instruction, so always use store_next and claim we are
|
||||
* precise in the MSR.
|
||||
*/
|
||||
msr |= 0x00100000;
|
||||
if (msr_fe0 == msr_fe1) {
|
||||
goto store_next;
|
||||
}
|
||||
msr |= 0x00010000;
|
||||
break;
|
||||
case POWERPC_EXCP_INVAL:
|
||||
LOG_EXCP("Invalid instruction at " TARGET_FMT_lx "\n", env->nip);
|
||||
|
@ -299,19 +302,16 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
env->error_code);
|
||||
break;
|
||||
}
|
||||
goto store_current;
|
||||
case POWERPC_EXCP_HV_EMU:
|
||||
srr0 = SPR_HSRR0;
|
||||
srr1 = SPR_HSRR1;
|
||||
new_msr |= (target_ulong)MSR_HVB;
|
||||
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
|
||||
goto store_current;
|
||||
case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
|
||||
goto store_current;
|
||||
break;
|
||||
case POWERPC_EXCP_SYSCALL: /* System call exception */
|
||||
dump_syscall(env);
|
||||
lev = env->error_code;
|
||||
|
||||
/* We need to correct the NIP which in this case is supposed
|
||||
* to point to the next instruction
|
||||
*/
|
||||
env->nip += 4;
|
||||
|
||||
/* "PAPR mode" built-in hypercall emulation */
|
||||
if ((lev == 1) && cpu_ppc_hypercall) {
|
||||
cpu_ppc_hypercall(cpu);
|
||||
|
@ -320,15 +320,15 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
if (lev == 1) {
|
||||
new_msr |= (target_ulong)MSR_HVB;
|
||||
}
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_FPU: /* Floating-point unavailable exception */
|
||||
case POWERPC_EXCP_APU: /* Auxiliary processor unavailable */
|
||||
goto store_current;
|
||||
case POWERPC_EXCP_DECR: /* Decrementer exception */
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_FIT: /* Fixed-interval timer interrupt */
|
||||
/* FIT on 4xx */
|
||||
LOG_EXCP("FIT exception\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_WDT: /* Watchdog timer interrupt */
|
||||
LOG_EXCP("WDT exception\n");
|
||||
switch (excp_model) {
|
||||
|
@ -339,11 +339,10 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
default:
|
||||
break;
|
||||
}
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_DTLB: /* Data TLB error */
|
||||
goto store_next;
|
||||
case POWERPC_EXCP_ITLB: /* Instruction TLB error */
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_DEBUG: /* Debug interrupt */
|
||||
switch (excp_model) {
|
||||
case POWERPC_EXCP_BOOKE:
|
||||
|
@ -358,33 +357,33 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
}
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "Debug exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_SPEU: /* SPE/embedded floating-point unavailable */
|
||||
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
|
||||
goto store_current;
|
||||
break;
|
||||
case POWERPC_EXCP_EFPDI: /* Embedded floating-point data interrupt */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "Embedded floating point data exception "
|
||||
"is not implemented yet !\n");
|
||||
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_EFPRI: /* Embedded floating-point round interrupt */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "Embedded floating point round exception "
|
||||
"is not implemented yet !\n");
|
||||
env->spr[SPR_BOOKE_ESR] = ESR_SPV;
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_EPERFM: /* Embedded performance monitor interrupt */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs,
|
||||
"Performance counter exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_DOORI: /* Embedded doorbell interrupt */
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_DOORCI: /* Embedded doorbell critical interrupt */
|
||||
srr0 = SPR_BOOKE_CSRR0;
|
||||
srr1 = SPR_BOOKE_CSRR1;
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_RESET: /* System reset exception */
|
||||
if (msr_pow) {
|
||||
/* indicate that we resumed from power save mode */
|
||||
|
@ -395,65 +394,42 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
|
||||
new_msr |= (target_ulong)MSR_HVB;
|
||||
ail = 0;
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_DSEG: /* Data segment exception */
|
||||
goto store_next;
|
||||
case POWERPC_EXCP_ISEG: /* Instruction segment exception */
|
||||
goto store_next;
|
||||
case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */
|
||||
srr0 = SPR_HSRR0;
|
||||
srr1 = SPR_HSRR1;
|
||||
new_msr |= (target_ulong)MSR_HVB;
|
||||
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
|
||||
goto store_next;
|
||||
case POWERPC_EXCP_TRACE: /* Trace exception */
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_HDECR: /* Hypervisor decrementer exception */
|
||||
case POWERPC_EXCP_HDSI: /* Hypervisor data storage exception */
|
||||
srr0 = SPR_HSRR0;
|
||||
srr1 = SPR_HSRR1;
|
||||
new_msr |= (target_ulong)MSR_HVB;
|
||||
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
|
||||
goto store_next;
|
||||
case POWERPC_EXCP_HISI: /* Hypervisor instruction storage exception */
|
||||
srr0 = SPR_HSRR0;
|
||||
srr1 = SPR_HSRR1;
|
||||
new_msr |= (target_ulong)MSR_HVB;
|
||||
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
|
||||
goto store_next;
|
||||
case POWERPC_EXCP_HDSEG: /* Hypervisor data segment exception */
|
||||
srr0 = SPR_HSRR0;
|
||||
srr1 = SPR_HSRR1;
|
||||
new_msr |= (target_ulong)MSR_HVB;
|
||||
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
|
||||
goto store_next;
|
||||
case POWERPC_EXCP_HISEG: /* Hypervisor instruction segment exception */
|
||||
case POWERPC_EXCP_HV_EMU:
|
||||
srr0 = SPR_HSRR0;
|
||||
srr1 = SPR_HSRR1;
|
||||
new_msr |= (target_ulong)MSR_HVB;
|
||||
new_msr |= env->msr & ((target_ulong)1 << MSR_RI);
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_VPU: /* Vector unavailable exception */
|
||||
goto store_current;
|
||||
case POWERPC_EXCP_VSXU: /* VSX unavailable exception */
|
||||
goto store_current;
|
||||
case POWERPC_EXCP_FU: /* Facility unavailable exception */
|
||||
goto store_current;
|
||||
break;
|
||||
case POWERPC_EXCP_PIT: /* Programmable interval timer interrupt */
|
||||
LOG_EXCP("PIT exception\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_IO: /* IO error exception */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "601 IO error exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_RUNM: /* Run mode exception */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "601 run mode exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_EMUL: /* Emulation trap exception */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "602 emulation trap exception "
|
||||
"is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_IFTLB: /* Instruction fetch TLB error */
|
||||
switch (excp_model) {
|
||||
case POWERPC_EXCP_602:
|
||||
|
@ -568,71 +544,67 @@ static inline void powerpc_excp(PowerPCCPU *cpu, int excp_model, int excp)
|
|||
cpu_abort(cs, "Invalid data store TLB miss exception\n");
|
||||
break;
|
||||
}
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_FPA: /* Floating-point assist exception */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "Floating point assist exception "
|
||||
"is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_DABR: /* Data address breakpoint */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "DABR exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_IABR: /* Instruction address breakpoint */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "IABR exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_SMI: /* System management interrupt */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "SMI exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_THERM: /* Thermal interrupt */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "Thermal management exception "
|
||||
"is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_PERFM: /* Embedded performance monitor interrupt */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs,
|
||||
"Performance counter exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_VPUA: /* Vector assist exception */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "VPU assist exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_SOFTP: /* Soft patch exception */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs,
|
||||
"970 soft-patch exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_MAINT: /* Maintenance exception */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs,
|
||||
"970 maintenance exception is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_MEXTBR: /* Maskable external breakpoint */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "Maskable external exception "
|
||||
"is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
case POWERPC_EXCP_NMEXTBR: /* Non maskable external breakpoint */
|
||||
/* XXX: TODO */
|
||||
cpu_abort(cs, "Non maskable external exception "
|
||||
"is not implemented yet !\n");
|
||||
goto store_next;
|
||||
break;
|
||||
default:
|
||||
excp_invalid:
|
||||
cpu_abort(cs, "Invalid PowerPC exception %d. Aborting\n", excp);
|
||||
break;
|
||||
store_current:
|
||||
/* save current instruction location */
|
||||
env->spr[srr0] = env->nip - 4;
|
||||
break;
|
||||
store_next:
|
||||
/* save next instruction location */
|
||||
env->spr[srr0] = env->nip;
|
||||
break;
|
||||
}
|
||||
|
||||
/* Save PC */
|
||||
env->spr[srr0] = env->nip;
|
||||
|
||||
/* Save MSR */
|
||||
env->spr[srr1] = msr;
|
||||
|
||||
|
@ -898,34 +870,53 @@ static void cpu_dump_rfi(target_ulong RA, target_ulong msr)
|
|||
/*****************************************************************************/
|
||||
/* Exceptions processing helpers */
|
||||
|
||||
void helper_raise_exception_err(CPUPPCState *env, uint32_t exception,
|
||||
uint32_t error_code)
|
||||
void raise_exception_err_ra(CPUPPCState *env, uint32_t exception,
|
||||
uint32_t error_code, uintptr_t raddr)
|
||||
{
|
||||
CPUState *cs = CPU(ppc_env_get_cpu(env));
|
||||
|
||||
#if 0
|
||||
printf("Raise exception %3x code : %d\n", exception, error_code);
|
||||
#endif
|
||||
cs->exception_index = exception;
|
||||
env->error_code = error_code;
|
||||
cpu_loop_exit(cs);
|
||||
cpu_loop_exit_restore(cs, raddr);
|
||||
}
|
||||
|
||||
void raise_exception_err(CPUPPCState *env, uint32_t exception,
|
||||
uint32_t error_code)
|
||||
{
|
||||
raise_exception_err_ra(env, exception, error_code, 0);
|
||||
}
|
||||
|
||||
void raise_exception(CPUPPCState *env, uint32_t exception)
|
||||
{
|
||||
raise_exception_err_ra(env, exception, 0, 0);
|
||||
}
|
||||
|
||||
void raise_exception_ra(CPUPPCState *env, uint32_t exception,
|
||||
uintptr_t raddr)
|
||||
{
|
||||
raise_exception_err_ra(env, exception, 0, raddr);
|
||||
}
|
||||
|
||||
void helper_raise_exception_err(CPUPPCState *env, uint32_t exception,
|
||||
uint32_t error_code)
|
||||
{
|
||||
raise_exception_err_ra(env, exception, error_code, 0);
|
||||
}
|
||||
|
||||
void helper_raise_exception(CPUPPCState *env, uint32_t exception)
|
||||
{
|
||||
helper_raise_exception_err(env, exception, 0);
|
||||
raise_exception_err_ra(env, exception, 0, 0);
|
||||
}
|
||||
|
||||
#if !defined(CONFIG_USER_ONLY)
|
||||
void helper_store_msr(CPUPPCState *env, target_ulong val)
|
||||
{
|
||||
CPUState *cs;
|
||||
uint32_t excp = hreg_store_msr(env, val, 0);
|
||||
|
||||
val = hreg_store_msr(env, val, 0);
|
||||
if (val != 0) {
|
||||
cs = CPU(ppc_env_get_cpu(env));
|
||||
if (excp != 0) {
|
||||
CPUState *cs = CPU(ppc_env_get_cpu(env));
|
||||
cs->interrupt_request |= CPU_INTERRUPT_EXITTB;
|
||||
helper_raise_exception(env, val);
|
||||
raise_exception(env, excp);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -951,7 +942,7 @@ void helper_pminsn(CPUPPCState *env, powerpc_pm_insn_t insn)
|
|||
* but this doesn't seem to be a problem.
|
||||
*/
|
||||
env->msr |= (1ull << MSR_EE);
|
||||
helper_raise_exception(env, EXCP_HLT);
|
||||
raise_exception(env, EXCP_HLT);
|
||||
}
|
||||
#endif /* defined(TARGET_PPC64) */
|
||||
|
||||
|
@ -1041,8 +1032,8 @@ void helper_tw(CPUPPCState *env, target_ulong arg1, target_ulong arg2,
|
|||
((int32_t)arg1 == (int32_t)arg2 && (flags & 0x04)) ||
|
||||
((uint32_t)arg1 < (uint32_t)arg2 && (flags & 0x02)) ||
|
||||
((uint32_t)arg1 > (uint32_t)arg2 && (flags & 0x01))))) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_TRAP);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_TRAP, GETPC());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1055,8 +1046,8 @@ void helper_td(CPUPPCState *env, target_ulong arg1, target_ulong arg2,
|
|||
((int64_t)arg1 == (int64_t)arg2 && (flags & 0x04)) ||
|
||||
((uint64_t)arg1 < (uint64_t)arg2 && (flags & 0x02)) ||
|
||||
((uint64_t)arg1 > (uint64_t)arg2 && (flags & 0x01))))) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_TRAP);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_TRAP, GETPC());
|
||||
}
|
||||
}
|
||||
#endif
|
||||
|
|
|
@ -19,6 +19,7 @@
|
|||
#include "qemu/osdep.h"
|
||||
#include "cpu.h"
|
||||
#include "exec/helper-proto.h"
|
||||
#include "exec/exec-all.h"
|
||||
|
||||
#define float64_snan_to_qnan(x) ((x) | 0x0008000000000000ULL)
|
||||
#define float32_snan_to_qnan(x) ((x) | 0x00400000)
|
||||
|
@ -116,8 +117,8 @@ void helper_compute_fprf(CPUPPCState *env, uint64_t arg)
|
|||
}
|
||||
|
||||
/* Floating-point invalid operations exception */
|
||||
static inline uint64_t fload_invalid_op_excp(CPUPPCState *env, int op,
|
||||
int set_fpcc)
|
||||
static inline __attribute__((__always_inline__))
|
||||
uint64_t float_invalid_op_excp(CPUPPCState *env, int op, int set_fpcc)
|
||||
{
|
||||
CPUState *cs = CPU(ppc_env_get_cpu(env));
|
||||
uint64_t ret = 0;
|
||||
|
@ -200,14 +201,15 @@ static inline uint64_t fload_invalid_op_excp(CPUPPCState *env, int op,
|
|||
/* Update the floating-point enabled exception summary */
|
||||
env->fpscr |= 1 << FPSCR_FEX;
|
||||
if (msr_fe0 != 0 || msr_fe1 != 0) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_FP | op);
|
||||
/* GETPC() works here because this is inline */
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_FP | op, GETPC());
|
||||
}
|
||||
}
|
||||
return ret;
|
||||
}
|
||||
|
||||
static inline void float_zero_divide_excp(CPUPPCState *env)
|
||||
static inline void float_zero_divide_excp(CPUPPCState *env, uintptr_t raddr)
|
||||
{
|
||||
env->fpscr |= 1 << FPSCR_ZX;
|
||||
env->fpscr &= ~((1 << FPSCR_FR) | (1 << FPSCR_FI));
|
||||
|
@ -217,8 +219,9 @@ static inline void float_zero_divide_excp(CPUPPCState *env)
|
|||
/* Update the floating-point enabled exception summary */
|
||||
env->fpscr |= 1 << FPSCR_FEX;
|
||||
if (msr_fe0 != 0 || msr_fe1 != 0) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_FP | POWERPC_EXCP_FP_ZX);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_FP | POWERPC_EXCP_FP_ZX,
|
||||
raddr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -491,13 +494,13 @@ void store_fpscr(CPUPPCState *env, uint64_t arg, uint32_t mask)
|
|||
helper_store_fpscr(env, arg, mask);
|
||||
}
|
||||
|
||||
void helper_float_check_status(CPUPPCState *env)
|
||||
static void do_float_check_status(CPUPPCState *env, uintptr_t raddr)
|
||||
{
|
||||
CPUState *cs = CPU(ppc_env_get_cpu(env));
|
||||
int status = get_float_exception_flags(&env->fp_status);
|
||||
|
||||
if (status & float_flag_divbyzero) {
|
||||
float_zero_divide_excp(env);
|
||||
float_zero_divide_excp(env, raddr);
|
||||
} else if (status & float_flag_overflow) {
|
||||
float_overflow_excp(env);
|
||||
} else if (status & float_flag_underflow) {
|
||||
|
@ -510,12 +513,24 @@ void helper_float_check_status(CPUPPCState *env)
|
|||
(env->error_code & POWERPC_EXCP_FP)) {
|
||||
/* Differred floating-point exception after target FPR update */
|
||||
if (msr_fe0 != 0 || msr_fe1 != 0) {
|
||||
helper_raise_exception_err(env, cs->exception_index,
|
||||
env->error_code);
|
||||
raise_exception_err_ra(env, cs->exception_index,
|
||||
env->error_code, raddr);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static inline __attribute__((__always_inline__))
|
||||
void float_check_status(CPUPPCState *env)
|
||||
{
|
||||
/* GETPC() works here because this is inline */
|
||||
do_float_check_status(env, GETPC());
|
||||
}
|
||||
|
||||
void helper_float_check_status(CPUPPCState *env)
|
||||
{
|
||||
do_float_check_status(env, GETPC());
|
||||
}
|
||||
|
||||
void helper_reset_fpstatus(CPUPPCState *env)
|
||||
{
|
||||
set_float_exception_flags(0, &env->fp_status);
|
||||
|
@ -532,12 +547,12 @@ uint64_t helper_fadd(CPUPPCState *env, uint64_t arg1, uint64_t arg2)
|
|||
if (unlikely(float64_is_infinity(farg1.d) && float64_is_infinity(farg2.d) &&
|
||||
float64_is_neg(farg1.d) != float64_is_neg(farg2.d))) {
|
||||
/* Magnitude subtraction of infinities */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
} else {
|
||||
if (unlikely(float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status))) {
|
||||
/* sNaN addition */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
farg1.d = float64_add(farg1.d, farg2.d, &env->fp_status);
|
||||
}
|
||||
|
@ -556,12 +571,12 @@ uint64_t helper_fsub(CPUPPCState *env, uint64_t arg1, uint64_t arg2)
|
|||
if (unlikely(float64_is_infinity(farg1.d) && float64_is_infinity(farg2.d) &&
|
||||
float64_is_neg(farg1.d) == float64_is_neg(farg2.d))) {
|
||||
/* Magnitude subtraction of infinities */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
} else {
|
||||
if (unlikely(float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status))) {
|
||||
/* sNaN subtraction */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
farg1.d = float64_sub(farg1.d, farg2.d, &env->fp_status);
|
||||
}
|
||||
|
@ -580,12 +595,12 @@ uint64_t helper_fmul(CPUPPCState *env, uint64_t arg1, uint64_t arg2)
|
|||
if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) ||
|
||||
(float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) {
|
||||
/* Multiplication of zero by infinity */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
} else {
|
||||
if (unlikely(float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status))) {
|
||||
/* sNaN multiplication */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
farg1.d = float64_mul(farg1.d, farg2.d, &env->fp_status);
|
||||
}
|
||||
|
@ -604,15 +619,15 @@ uint64_t helper_fdiv(CPUPPCState *env, uint64_t arg1, uint64_t arg2)
|
|||
if (unlikely(float64_is_infinity(farg1.d) &&
|
||||
float64_is_infinity(farg2.d))) {
|
||||
/* Division of infinity by infinity */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXIDI, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXIDI, 1);
|
||||
} else if (unlikely(float64_is_zero(farg1.d) && float64_is_zero(farg2.d))) {
|
||||
/* Division of zero by zero */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXZDZ, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXZDZ, 1);
|
||||
} else {
|
||||
if (unlikely(float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status))) {
|
||||
/* sNaN division */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
farg1.d = float64_div(farg1.d, farg2.d, &env->fp_status);
|
||||
}
|
||||
|
@ -631,16 +646,16 @@ uint64_t helper_##op(CPUPPCState *env, uint64_t arg) \
|
|||
\
|
||||
if (unlikely(env->fp_status.float_exception_flags)) { \
|
||||
if (float64_is_any_nan(arg)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI, 1); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI, 1); \
|
||||
if (float64_is_signaling_nan(arg, &env->fp_status)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1); \
|
||||
} \
|
||||
farg.ll = nanval; \
|
||||
} else if (env->fp_status.float_exception_flags & \
|
||||
float_flag_invalid) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI, 1); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI, 1); \
|
||||
} \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
} \
|
||||
return farg.ll; \
|
||||
}
|
||||
|
@ -665,7 +680,7 @@ uint64_t helper_##op(CPUPPCState *env, uint64_t arg) \
|
|||
} else { \
|
||||
farg.d = cvtr(arg, &env->fp_status); \
|
||||
} \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
return farg.ll; \
|
||||
}
|
||||
|
||||
|
@ -683,7 +698,7 @@ static inline uint64_t do_fri(CPUPPCState *env, uint64_t arg,
|
|||
|
||||
if (unlikely(float64_is_signaling_nan(farg.d, &env->fp_status))) {
|
||||
/* sNaN round */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
farg.ll = arg | 0x0008000000000000ULL;
|
||||
} else {
|
||||
int inexact = get_float_exception_flags(&env->fp_status) &
|
||||
|
@ -698,7 +713,7 @@ static inline uint64_t do_fri(CPUPPCState *env, uint64_t arg,
|
|||
env->fp_status.float_exception_flags &= ~float_flag_inexact;
|
||||
}
|
||||
}
|
||||
helper_float_check_status(env);
|
||||
float_check_status(env);
|
||||
return farg.ll;
|
||||
}
|
||||
|
||||
|
@ -735,13 +750,13 @@ uint64_t helper_fmadd(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) ||
|
||||
(float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) {
|
||||
/* Multiplication of zero by infinity */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
} else {
|
||||
if (unlikely(float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg3.d, &env->fp_status))) {
|
||||
/* sNaN operation */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
/* This is the way the PowerPC specification defines it */
|
||||
float128 ft0_128, ft1_128;
|
||||
|
@ -753,7 +768,7 @@ uint64_t helper_fmadd(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
float64_is_infinity(farg3.d) &&
|
||||
float128_is_neg(ft0_128) != float64_is_neg(farg3.d))) {
|
||||
/* Magnitude subtraction of infinities */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
} else {
|
||||
ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
|
||||
ft0_128 = float128_add(ft0_128, ft1_128, &env->fp_status);
|
||||
|
@ -778,13 +793,13 @@ uint64_t helper_fmsub(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
(float64_is_zero(farg1.d) &&
|
||||
float64_is_infinity(farg2.d)))) {
|
||||
/* Multiplication of zero by infinity */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
} else {
|
||||
if (unlikely(float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg3.d, &env->fp_status))) {
|
||||
/* sNaN operation */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
/* This is the way the PowerPC specification defines it */
|
||||
float128 ft0_128, ft1_128;
|
||||
|
@ -796,7 +811,7 @@ uint64_t helper_fmsub(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
float64_is_infinity(farg3.d) &&
|
||||
float128_is_neg(ft0_128) == float64_is_neg(farg3.d))) {
|
||||
/* Magnitude subtraction of infinities */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
} else {
|
||||
ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
|
||||
ft0_128 = float128_sub(ft0_128, ft1_128, &env->fp_status);
|
||||
|
@ -819,13 +834,13 @@ uint64_t helper_fnmadd(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
if (unlikely((float64_is_infinity(farg1.d) && float64_is_zero(farg2.d)) ||
|
||||
(float64_is_zero(farg1.d) && float64_is_infinity(farg2.d)))) {
|
||||
/* Multiplication of zero by infinity */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
} else {
|
||||
if (unlikely(float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg3.d, &env->fp_status))) {
|
||||
/* sNaN operation */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
/* This is the way the PowerPC specification defines it */
|
||||
float128 ft0_128, ft1_128;
|
||||
|
@ -837,7 +852,7 @@ uint64_t helper_fnmadd(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
float64_is_infinity(farg3.d) &&
|
||||
float128_is_neg(ft0_128) != float64_is_neg(farg3.d))) {
|
||||
/* Magnitude subtraction of infinities */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
} else {
|
||||
ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
|
||||
ft0_128 = float128_add(ft0_128, ft1_128, &env->fp_status);
|
||||
|
@ -864,13 +879,13 @@ uint64_t helper_fnmsub(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
(float64_is_zero(farg1.d) &&
|
||||
float64_is_infinity(farg2.d)))) {
|
||||
/* Multiplication of zero by infinity */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, 1);
|
||||
} else {
|
||||
if (unlikely(float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg3.d, &env->fp_status))) {
|
||||
/* sNaN operation */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
/* This is the way the PowerPC specification defines it */
|
||||
float128 ft0_128, ft1_128;
|
||||
|
@ -882,7 +897,7 @@ uint64_t helper_fnmsub(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
float64_is_infinity(farg3.d) &&
|
||||
float128_is_neg(ft0_128) == float64_is_neg(farg3.d))) {
|
||||
/* Magnitude subtraction of infinities */
|
||||
farg1.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
farg1.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, 1);
|
||||
} else {
|
||||
ft1_128 = float64_to_float128(farg3.d, &env->fp_status);
|
||||
ft0_128 = float128_sub(ft0_128, ft1_128, &env->fp_status);
|
||||
|
@ -905,7 +920,7 @@ uint64_t helper_frsp(CPUPPCState *env, uint64_t arg)
|
|||
|
||||
if (unlikely(float64_is_signaling_nan(farg.d, &env->fp_status))) {
|
||||
/* sNaN square root */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
f32 = float64_to_float32(farg.d, &env->fp_status);
|
||||
farg.d = float32_to_float64(f32, &env->fp_status);
|
||||
|
@ -923,12 +938,12 @@ uint64_t helper_fsqrt(CPUPPCState *env, uint64_t arg)
|
|||
if (unlikely(float64_is_any_nan(farg.d))) {
|
||||
if (unlikely(float64_is_signaling_nan(farg.d, &env->fp_status))) {
|
||||
/* sNaN reciprocal square root */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
farg.ll = float64_snan_to_qnan(farg.ll);
|
||||
}
|
||||
} else if (unlikely(float64_is_neg(farg.d) && !float64_is_zero(farg.d))) {
|
||||
/* Square root of a negative nonzero number */
|
||||
farg.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT, 1);
|
||||
farg.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT, 1);
|
||||
} else {
|
||||
farg.d = float64_sqrt(farg.d, &env->fp_status);
|
||||
}
|
||||
|
@ -944,7 +959,7 @@ uint64_t helper_fre(CPUPPCState *env, uint64_t arg)
|
|||
|
||||
if (unlikely(float64_is_signaling_nan(farg.d, &env->fp_status))) {
|
||||
/* sNaN reciprocal */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
farg.d = float64_div(float64_one, farg.d, &env->fp_status);
|
||||
return farg.d;
|
||||
|
@ -960,7 +975,7 @@ uint64_t helper_fres(CPUPPCState *env, uint64_t arg)
|
|||
|
||||
if (unlikely(float64_is_signaling_nan(farg.d, &env->fp_status))) {
|
||||
/* sNaN reciprocal */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
farg.d = float64_div(float64_one, farg.d, &env->fp_status);
|
||||
f32 = float64_to_float32(farg.d, &env->fp_status);
|
||||
|
@ -979,12 +994,12 @@ uint64_t helper_frsqrte(CPUPPCState *env, uint64_t arg)
|
|||
if (unlikely(float64_is_any_nan(farg.d))) {
|
||||
if (unlikely(float64_is_signaling_nan(farg.d, &env->fp_status))) {
|
||||
/* sNaN reciprocal square root */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
farg.ll = float64_snan_to_qnan(farg.ll);
|
||||
}
|
||||
} else if (unlikely(float64_is_neg(farg.d) && !float64_is_zero(farg.d))) {
|
||||
/* Reciprocal square root of a negative nonzero number */
|
||||
farg.ll = fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT, 1);
|
||||
farg.ll = float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT, 1);
|
||||
} else {
|
||||
farg.d = float64_sqrt(farg.d, &env->fp_status);
|
||||
farg.d = float64_div(float64_one, farg.d, &env->fp_status);
|
||||
|
@ -1103,7 +1118,7 @@ void helper_fcmpu(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
&& (float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status)))) {
|
||||
/* sNaN comparison */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 1);
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -1134,11 +1149,11 @@ void helper_fcmpo(CPUPPCState *env, uint64_t arg1, uint64_t arg2,
|
|||
if (float64_is_signaling_nan(farg1.d, &env->fp_status) ||
|
||||
float64_is_signaling_nan(farg2.d, &env->fp_status)) {
|
||||
/* sNaN comparison */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN |
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN |
|
||||
POWERPC_EXCP_FP_VXVC, 1);
|
||||
} else {
|
||||
/* qNaN comparison */
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXVC, 1);
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXVC, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -1838,10 +1853,10 @@ void helper_##name(CPUPPCState *env, uint32_t opcode) \
|
|||
\
|
||||
if (unlikely(tstat.float_exception_flags & float_flag_invalid)) { \
|
||||
if (tp##_is_infinity(xa.fld) && tp##_is_infinity(xb.fld)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, sfprf); \
|
||||
} else if (tp##_is_signaling_nan(xa.fld, &tstat) || \
|
||||
tp##_is_signaling_nan(xb.fld, &tstat)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
|
@ -1854,7 +1869,7 @@ void helper_##name(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
} \
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_ADD_SUB(xsadddp, add, 1, float64, VsrD(0), 1, 0)
|
||||
|
@ -1893,10 +1908,10 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
if (unlikely(tstat.float_exception_flags & float_flag_invalid)) { \
|
||||
if ((tp##_is_infinity(xa.fld) && tp##_is_zero(xb.fld)) || \
|
||||
(tp##_is_infinity(xb.fld) && tp##_is_zero(xa.fld))) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXIMZ, sfprf); \
|
||||
} else if (tp##_is_signaling_nan(xa.fld, &tstat) || \
|
||||
tp##_is_signaling_nan(xb.fld, &tstat)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
|
@ -1910,7 +1925,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_MUL(xsmuldp, 1, float64, VsrD(0), 1, 0)
|
||||
|
@ -1944,13 +1959,13 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
\
|
||||
if (unlikely(tstat.float_exception_flags & float_flag_invalid)) { \
|
||||
if (tp##_is_infinity(xa.fld) && tp##_is_infinity(xb.fld)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXIDI, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXIDI, sfprf); \
|
||||
} else if (tp##_is_zero(xa.fld) && \
|
||||
tp##_is_zero(xb.fld)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXZDZ, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXZDZ, sfprf); \
|
||||
} else if (tp##_is_signaling_nan(xa.fld, &tstat) || \
|
||||
tp##_is_signaling_nan(xb.fld, &tstat)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
|
@ -1964,7 +1979,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_DIV(xsdivdp, 1, float64, VsrD(0), 1, 0)
|
||||
|
@ -1991,7 +2006,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
\
|
||||
for (i = 0; i < nels; i++) { \
|
||||
if (unlikely(tp##_is_signaling_nan(xb.fld, &env->fp_status))) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
} \
|
||||
xt.fld = tp##_div(tp##_one, xb.fld, &env->fp_status); \
|
||||
\
|
||||
|
@ -2005,7 +2020,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_RE(xsredp, 1, float64, VsrD(0), 1, 0)
|
||||
|
@ -2038,9 +2053,9 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
\
|
||||
if (unlikely(tstat.float_exception_flags & float_flag_invalid)) { \
|
||||
if (tp##_is_neg(xb.fld) && !tp##_is_zero(xb.fld)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT, sfprf); \
|
||||
} else if (tp##_is_signaling_nan(xb.fld, &tstat)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
|
@ -2054,7 +2069,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_SQRT(xssqrtdp, 1, float64, VsrD(0), 1, 0)
|
||||
|
@ -2088,9 +2103,9 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
\
|
||||
if (unlikely(tstat.float_exception_flags & float_flag_invalid)) { \
|
||||
if (tp##_is_neg(xb.fld) && !tp##_is_zero(xb.fld)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSQRT, sfprf); \
|
||||
} else if (tp##_is_signaling_nan(xb.fld, &tstat)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
|
@ -2104,7 +2119,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_RSQRTE(xsrsqrtedp, 1, float64, VsrD(0), 1, 0)
|
||||
|
@ -2277,12 +2292,12 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
if (tp##_is_signaling_nan(xa.fld, &tstat) || \
|
||||
tp##_is_signaling_nan(b->fld, &tstat) || \
|
||||
tp##_is_signaling_nan(c->fld, &tstat)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, sfprf); \
|
||||
tstat.float_exception_flags &= ~float_flag_invalid; \
|
||||
} \
|
||||
if ((tp##_is_infinity(xa.fld) && tp##_is_zero(b->fld)) || \
|
||||
(tp##_is_zero(xa.fld) && tp##_is_infinity(b->fld))) { \
|
||||
xt_out.fld = float64_to_##tp(fload_invalid_op_excp(env, \
|
||||
xt_out.fld = float64_to_##tp(float_invalid_op_excp(env, \
|
||||
POWERPC_EXCP_FP_VXIMZ, sfprf), &env->fp_status); \
|
||||
tstat.float_exception_flags &= ~float_flag_invalid; \
|
||||
} \
|
||||
|
@ -2290,7 +2305,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
((tp##_is_infinity(xa.fld) || \
|
||||
tp##_is_infinity(b->fld)) && \
|
||||
tp##_is_infinity(c->fld))) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, sfprf); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXISI, sfprf); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
|
@ -2303,7 +2318,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
} \
|
||||
putVSR(xT(opcode), &xt_out, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
#define MADD_FLGS 0
|
||||
|
@ -2360,10 +2375,10 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
float64_is_any_nan(xb.VsrD(0)))) { \
|
||||
if (float64_is_signaling_nan(xa.VsrD(0), &env->fp_status) || \
|
||||
float64_is_signaling_nan(xb.VsrD(0), &env->fp_status)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
} \
|
||||
if (ordered) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXVC, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXVC, 0); \
|
||||
} \
|
||||
cc = 1; \
|
||||
} else { \
|
||||
|
@ -2381,7 +2396,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
env->fpscr |= cc << FPSCR_FPRF; \
|
||||
env->crf[BF(opcode)] = cc; \
|
||||
\
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_SCALAR_CMP(xscmpodp, 1)
|
||||
|
@ -2408,12 +2423,12 @@ void helper_##name(CPUPPCState *env, uint32_t opcode) \
|
|||
xt.fld = tp##_##op(xa.fld, xb.fld, &env->fp_status); \
|
||||
if (unlikely(tp##_is_signaling_nan(xa.fld, &env->fp_status) || \
|
||||
tp##_is_signaling_nan(xb.fld, &env->fp_status))) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_MAX_MIN(xsmaxdp, maxnum, 1, float64, VsrD(0))
|
||||
|
@ -2448,10 +2463,10 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
tp##_is_any_nan(xb.fld))) { \
|
||||
if (tp##_is_signaling_nan(xa.fld, &env->fp_status) || \
|
||||
tp##_is_signaling_nan(xb.fld, &env->fp_status)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
} \
|
||||
if (svxvc) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXVC, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXVC, 0); \
|
||||
} \
|
||||
xt.fld = 0; \
|
||||
all_true = 0; \
|
||||
|
@ -2470,7 +2485,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
if ((opcode >> (31-21)) & 1) { \
|
||||
env->crf[6] = (all_true ? 0x8 : 0) | (all_false ? 0x2 : 0); \
|
||||
} \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_CMP(xvcmpeqdp, 2, float64, VsrD(i), eq, 0)
|
||||
|
@ -2502,7 +2517,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
xt.tfld = stp##_to_##ttp(xb.sfld, &env->fp_status); \
|
||||
if (unlikely(stp##_is_signaling_nan(xb.sfld, \
|
||||
&env->fp_status))) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
xt.tfld = ttp##_snan_to_qnan(xt.tfld); \
|
||||
} \
|
||||
if (sfprf) { \
|
||||
|
@ -2512,7 +2527,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_CVT_FP_TO_FP(xscvdpsp, 1, float64, float32, VsrD(0), VsrW(0), 1)
|
||||
|
@ -2557,21 +2572,21 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
for (i = 0; i < nels; i++) { \
|
||||
if (unlikely(stp##_is_any_nan(xb.sfld))) { \
|
||||
if (stp##_is_signaling_nan(xb.sfld, &env->fp_status)) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
} \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI, 0); \
|
||||
xt.tfld = rnan; \
|
||||
} else { \
|
||||
xt.tfld = stp##_to_##ttp##_round_to_zero(xb.sfld, \
|
||||
&env->fp_status); \
|
||||
if (env->fp_status.float_exception_flags & float_flag_invalid) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXCVI, 0); \
|
||||
} \
|
||||
} \
|
||||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_CVT_FP_TO_INT(xscvdpsxds, 1, float64, int64, VsrD(0), VsrD(0), \
|
||||
|
@ -2622,7 +2637,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_CVT_INT_TO_FP(xscvsxddp, 1, int64, float64, VsrD(0), VsrD(0), 1, 0)
|
||||
|
@ -2667,7 +2682,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
for (i = 0; i < nels; i++) { \
|
||||
if (unlikely(tp##_is_signaling_nan(xb.fld, \
|
||||
&env->fp_status))) { \
|
||||
fload_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
float_invalid_op_excp(env, POWERPC_EXCP_FP_VXSNAN, 0); \
|
||||
xt.fld = tp##_snan_to_qnan(xb.fld); \
|
||||
} else { \
|
||||
xt.fld = tp##_round_to_int(xb.fld, &env->fp_status); \
|
||||
|
@ -2686,7 +2701,7 @@ void helper_##op(CPUPPCState *env, uint32_t opcode) \
|
|||
} \
|
||||
\
|
||||
putVSR(xT(opcode), &xt, env); \
|
||||
helper_float_check_status(env); \
|
||||
float_check_status(env); \
|
||||
}
|
||||
|
||||
VSX_ROUND(xsrdpi, 1, float64, VsrD(0), float_round_ties_away, 1)
|
||||
|
@ -2714,6 +2729,6 @@ uint64_t helper_xsrsp(CPUPPCState *env, uint64_t xb)
|
|||
uint64_t xt = helper_frsp(env, xb);
|
||||
|
||||
helper_compute_fprf(env, xt);
|
||||
helper_float_check_status(env);
|
||||
float_check_status(env);
|
||||
return xt;
|
||||
}
|
||||
|
|
|
@ -1,8 +1,8 @@
|
|||
DEF_HELPER_3(raise_exception_err, void, env, i32, i32)
|
||||
DEF_HELPER_2(raise_exception, void, env, i32)
|
||||
DEF_HELPER_4(tw, void, env, tl, tl, i32)
|
||||
DEF_HELPER_FLAGS_3(raise_exception_err, TCG_CALL_NO_WG, void, env, i32, i32)
|
||||
DEF_HELPER_FLAGS_2(raise_exception, TCG_CALL_NO_WG, void, env, i32)
|
||||
DEF_HELPER_FLAGS_4(tw, TCG_CALL_NO_WG, void, env, tl, tl, i32)
|
||||
#if defined(TARGET_PPC64)
|
||||
DEF_HELPER_4(td, void, env, tl, tl, i32)
|
||||
DEF_HELPER_FLAGS_4(td, TCG_CALL_NO_WG, void, env, tl, tl, i32)
|
||||
#endif
|
||||
#if !defined(CONFIG_USER_ONLY)
|
||||
DEF_HELPER_2(store_msr, void, env, tl)
|
||||
|
@ -22,12 +22,12 @@ DEF_HELPER_1(check_tlb_flush, void, env)
|
|||
#endif
|
||||
|
||||
DEF_HELPER_3(lmw, void, env, tl, i32)
|
||||
DEF_HELPER_3(stmw, void, env, tl, i32)
|
||||
DEF_HELPER_FLAGS_3(stmw, TCG_CALL_NO_WG, void, env, tl, i32)
|
||||
DEF_HELPER_4(lsw, void, env, tl, i32, i32)
|
||||
DEF_HELPER_5(lswx, void, env, tl, i32, i32, i32)
|
||||
DEF_HELPER_4(stsw, void, env, tl, i32, i32)
|
||||
DEF_HELPER_3(dcbz, void, env, tl, i32)
|
||||
DEF_HELPER_2(icbi, void, env, tl)
|
||||
DEF_HELPER_FLAGS_4(stsw, TCG_CALL_NO_WG, void, env, tl, i32, i32)
|
||||
DEF_HELPER_FLAGS_3(dcbz, TCG_CALL_NO_WG, void, env, tl, i32)
|
||||
DEF_HELPER_FLAGS_2(icbi, TCG_CALL_NO_WG, void, env, tl)
|
||||
DEF_HELPER_5(lscbx, tl, env, tl, i32, i32, i32)
|
||||
|
||||
#if defined(TARGET_PPC64)
|
||||
|
@ -38,12 +38,15 @@ DEF_HELPER_4(divweu, tl, env, tl, tl, i32)
|
|||
DEF_HELPER_4(divwe, tl, env, tl, tl, i32)
|
||||
|
||||
DEF_HELPER_FLAGS_1(cntlzw, TCG_CALL_NO_RWG_SE, tl, tl)
|
||||
DEF_HELPER_FLAGS_1(cnttzw, TCG_CALL_NO_RWG_SE, tl, tl)
|
||||
DEF_HELPER_FLAGS_1(popcntb, TCG_CALL_NO_RWG_SE, tl, tl)
|
||||
DEF_HELPER_FLAGS_1(popcntw, TCG_CALL_NO_RWG_SE, tl, tl)
|
||||
DEF_HELPER_FLAGS_2(cmpb, TCG_CALL_NO_RWG_SE, tl, tl, tl)
|
||||
DEF_HELPER_3(sraw, tl, env, tl, tl)
|
||||
#if defined(TARGET_PPC64)
|
||||
DEF_HELPER_FLAGS_2(cmpeqb, TCG_CALL_NO_RWG_SE, i32, tl, tl)
|
||||
DEF_HELPER_FLAGS_1(cntlzd, TCG_CALL_NO_RWG_SE, tl, tl)
|
||||
DEF_HELPER_FLAGS_1(cnttzd, TCG_CALL_NO_RWG_SE, tl, tl)
|
||||
DEF_HELPER_FLAGS_1(popcntd, TCG_CALL_NO_RWG_SE, tl, tl)
|
||||
DEF_HELPER_FLAGS_2(bpermd, TCG_CALL_NO_RWG_SE, i64, i64, i64)
|
||||
DEF_HELPER_3(srad, tl, env, tl, tl)
|
||||
|
@ -115,6 +118,9 @@ DEF_HELPER_3(vsubudm, void, avr, avr, avr)
|
|||
DEF_HELPER_3(vavgub, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vavguh, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vavguw, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vabsdub, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vabsduh, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vabsduw, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vavgsb, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vavgsh, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vavgsw, void, avr, avr, avr)
|
||||
|
@ -138,6 +144,9 @@ DEF_HELPER_4(vcmpequb, void, env, avr, avr, avr)
|
|||
DEF_HELPER_4(vcmpequh, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpequw, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpequd, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpnezb, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpnezh, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpnezw, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpgtub, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpgtuh, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpgtuw, void, env, avr, avr, avr)
|
||||
|
@ -154,6 +163,9 @@ DEF_HELPER_4(vcmpequb_dot, void, env, avr, avr, avr)
|
|||
DEF_HELPER_4(vcmpequh_dot, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpequw_dot, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpequd_dot, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpnezb_dot, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpnezh_dot, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpnezw_dot, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpgtub_dot, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpgtuh_dot, void, env, avr, avr, avr)
|
||||
DEF_HELPER_4(vcmpgtuw_dot, void, env, avr, avr, avr)
|
||||
|
@ -199,6 +211,8 @@ DEF_HELPER_3(vslw, void, avr, avr, avr)
|
|||
DEF_HELPER_3(vsld, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vslo, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vsro, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vsrv, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vslv, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vaddcuw, void, avr, avr, avr)
|
||||
DEF_HELPER_3(vsubcuw, void, avr, avr, avr)
|
||||
DEF_HELPER_2(lvsl, void, avr, tl)
|
||||
|
@ -581,35 +595,35 @@ DEF_HELPER_2(load_dump_spr, void, env, i32)
|
|||
DEF_HELPER_2(store_dump_spr, void, env, i32)
|
||||
DEF_HELPER_4(fscr_facility_check, void, env, i32, i32, i32)
|
||||
DEF_HELPER_4(msr_facility_check, void, env, i32, i32, i32)
|
||||
DEF_HELPER_1(load_tbl, tl, env)
|
||||
DEF_HELPER_1(load_tbu, tl, env)
|
||||
DEF_HELPER_1(load_atbl, tl, env)
|
||||
DEF_HELPER_1(load_atbu, tl, env)
|
||||
DEF_HELPER_1(load_601_rtcl, tl, env)
|
||||
DEF_HELPER_1(load_601_rtcu, tl, env)
|
||||
DEF_HELPER_FLAGS_1(load_tbl, TCG_CALL_NO_RWG, tl, env)
|
||||
DEF_HELPER_FLAGS_1(load_tbu, TCG_CALL_NO_RWG, tl, env)
|
||||
DEF_HELPER_FLAGS_1(load_atbl, TCG_CALL_NO_RWG, tl, env)
|
||||
DEF_HELPER_FLAGS_1(load_atbu, TCG_CALL_NO_RWG, tl, env)
|
||||
DEF_HELPER_FLAGS_1(load_601_rtcl, TCG_CALL_NO_RWG, tl, env)
|
||||
DEF_HELPER_FLAGS_1(load_601_rtcu, TCG_CALL_NO_RWG, tl, env)
|
||||
#if !defined(CONFIG_USER_ONLY)
|
||||
#if defined(TARGET_PPC64)
|
||||
DEF_HELPER_1(load_purr, tl, env)
|
||||
DEF_HELPER_FLAGS_1(load_purr, TCG_CALL_NO_RWG, tl, env)
|
||||
#endif
|
||||
DEF_HELPER_2(store_sdr1, void, env, tl)
|
||||
DEF_HELPER_2(store_tbl, void, env, tl)
|
||||
DEF_HELPER_2(store_tbu, void, env, tl)
|
||||
DEF_HELPER_2(store_atbl, void, env, tl)
|
||||
DEF_HELPER_2(store_atbu, void, env, tl)
|
||||
DEF_HELPER_2(store_601_rtcl, void, env, tl)
|
||||
DEF_HELPER_2(store_601_rtcu, void, env, tl)
|
||||
DEF_HELPER_1(load_decr, tl, env)
|
||||
DEF_HELPER_2(store_decr, void, env, tl)
|
||||
DEF_HELPER_1(load_hdecr, tl, env)
|
||||
DEF_HELPER_2(store_hdecr, void, env, tl)
|
||||
DEF_HELPER_FLAGS_2(store_tbl, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_FLAGS_2(store_tbu, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_FLAGS_2(store_atbl, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_FLAGS_2(store_atbu, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_FLAGS_2(store_601_rtcl, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_FLAGS_2(store_601_rtcu, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_FLAGS_1(load_decr, TCG_CALL_NO_RWG, tl, env)
|
||||
DEF_HELPER_FLAGS_2(store_decr, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_FLAGS_1(load_hdecr, TCG_CALL_NO_RWG, tl, env)
|
||||
DEF_HELPER_FLAGS_2(store_hdecr, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_2(store_hid0_601, void, env, tl)
|
||||
DEF_HELPER_3(store_403_pbr, void, env, i32, tl)
|
||||
DEF_HELPER_1(load_40x_pit, tl, env)
|
||||
DEF_HELPER_2(store_40x_pit, void, env, tl)
|
||||
DEF_HELPER_FLAGS_1(load_40x_pit, TCG_CALL_NO_RWG, tl, env)
|
||||
DEF_HELPER_FLAGS_2(store_40x_pit, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_2(store_40x_dbcr0, void, env, tl)
|
||||
DEF_HELPER_2(store_40x_sler, void, env, tl)
|
||||
DEF_HELPER_2(store_booke_tcr, void, env, tl)
|
||||
DEF_HELPER_2(store_booke_tsr, void, env, tl)
|
||||
DEF_HELPER_FLAGS_2(store_booke_tcr, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_FLAGS_2(store_booke_tsr, TCG_CALL_NO_RWG, void, env, tl)
|
||||
DEF_HELPER_3(store_ibatl, void, env, i32, tl)
|
||||
DEF_HELPER_3(store_ibatu, void, env, i32, tl)
|
||||
DEF_HELPER_3(store_dbatl, void, env, i32, tl)
|
||||
|
@ -642,6 +656,8 @@ DEF_HELPER_3(dtstex, i32, env, fprp, fprp)
|
|||
DEF_HELPER_3(dtstexq, i32, env, fprp, fprp)
|
||||
DEF_HELPER_3(dtstsf, i32, env, fprp, fprp)
|
||||
DEF_HELPER_3(dtstsfq, i32, env, fprp, fprp)
|
||||
DEF_HELPER_3(dtstsfi, i32, env, i32, fprp)
|
||||
DEF_HELPER_3(dtstsfiq, i32, env, i32, fprp)
|
||||
DEF_HELPER_5(dquai, void, env, fprp, fprp, i32, i32)
|
||||
DEF_HELPER_5(dquaiq, void, env, fprp, fprp, i32, i32)
|
||||
DEF_HELPER_5(dqua, void, env, fprp, fprp, fprp, i32)
|
||||
|
@ -674,4 +690,4 @@ DEF_HELPER_4(dscli, void, env, fprp, fprp, i32)
|
|||
DEF_HELPER_4(dscliq, void, env, fprp, fprp, i32)
|
||||
|
||||
DEF_HELPER_1(tbegin, void, env)
|
||||
DEF_HELPER_1(fixup_thrm, void, env)
|
||||
DEF_HELPER_FLAGS_1(fixup_thrm, TCG_CALL_NO_RWG, void, env)
|
||||
|
|
|
@ -145,11 +145,43 @@ target_ulong helper_cntlzw(target_ulong t)
|
|||
return clz32(t);
|
||||
}
|
||||
|
||||
target_ulong helper_cnttzw(target_ulong t)
|
||||
{
|
||||
return ctz32(t);
|
||||
}
|
||||
|
||||
#if defined(TARGET_PPC64)
|
||||
/* if x = 0xab, returns 0xababababababababa */
|
||||
#define pattern(x) (((x) & 0xff) * (~(target_ulong)0 / 0xff))
|
||||
|
||||
/* substract 1 from each byte, and with inverse, check if MSB is set at each
|
||||
* byte.
|
||||
* i.e. ((0x00 - 0x01) & ~(0x00)) & 0x80
|
||||
* (0xFF & 0xFF) & 0x80 = 0x80 (zero found)
|
||||
*/
|
||||
#define haszero(v) (((v) - pattern(0x01)) & ~(v) & pattern(0x80))
|
||||
|
||||
/* When you XOR the pattern and there is a match, that byte will be zero */
|
||||
#define hasvalue(x, n) (haszero((x) ^ pattern(n)))
|
||||
|
||||
uint32_t helper_cmpeqb(target_ulong ra, target_ulong rb)
|
||||
{
|
||||
return hasvalue(rb, ra) ? 1 << CRF_GT : 0;
|
||||
}
|
||||
|
||||
#undef pattern
|
||||
#undef haszero
|
||||
#undef hasvalue
|
||||
|
||||
target_ulong helper_cntlzd(target_ulong t)
|
||||
{
|
||||
return clz64(t);
|
||||
}
|
||||
|
||||
target_ulong helper_cnttzd(target_ulong t)
|
||||
{
|
||||
return ctz64(t);
|
||||
}
|
||||
#endif
|
||||
|
||||
#if defined(TARGET_PPC64)
|
||||
|
@ -597,6 +629,30 @@ VAVG(w, s32, int64_t, u32, uint64_t)
|
|||
#undef VAVG_DO
|
||||
#undef VAVG
|
||||
|
||||
#define VABSDU_DO(name, element) \
|
||||
void helper_v##name(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b) \
|
||||
{ \
|
||||
int i; \
|
||||
\
|
||||
for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
|
||||
r->element[i] = (a->element[i] > b->element[i]) ? \
|
||||
(a->element[i] - b->element[i]) : \
|
||||
(b->element[i] - a->element[i]); \
|
||||
} \
|
||||
}
|
||||
|
||||
/* VABSDU - Vector absolute difference unsigned
|
||||
* name - instruction mnemonic suffix (b: byte, h: halfword, w: word)
|
||||
* element - element type to access from vector
|
||||
*/
|
||||
#define VABSDU(type, element) \
|
||||
VABSDU_DO(absdu##type, element)
|
||||
VABSDU(b, u8)
|
||||
VABSDU(h, u16)
|
||||
VABSDU(w, u32)
|
||||
#undef VABSDU_DO
|
||||
#undef VABSDU
|
||||
|
||||
#define VCF(suffix, cvt, element) \
|
||||
void helper_vcf##suffix(CPUPPCState *env, ppc_avr_t *r, \
|
||||
ppc_avr_t *b, uint32_t uim) \
|
||||
|
@ -663,6 +719,42 @@ VCMP(gtsd, >, s64)
|
|||
#undef VCMP_DO
|
||||
#undef VCMP
|
||||
|
||||
#define VCMPNEZ_DO(suffix, element, etype, record) \
|
||||
void helper_vcmpnez##suffix(CPUPPCState *env, ppc_avr_t *r, \
|
||||
ppc_avr_t *a, ppc_avr_t *b) \
|
||||
{ \
|
||||
etype ones = (etype)-1; \
|
||||
etype all = ones; \
|
||||
etype none = 0; \
|
||||
int i; \
|
||||
\
|
||||
for (i = 0; i < ARRAY_SIZE(r->element); i++) { \
|
||||
etype result = ((a->element[i] == 0) \
|
||||
|| (b->element[i] == 0) \
|
||||
|| (a->element[i] != b->element[i]) ? \
|
||||
ones : 0x0); \
|
||||
r->element[i] = result; \
|
||||
all &= result; \
|
||||
none |= result; \
|
||||
} \
|
||||
if (record) { \
|
||||
env->crf[6] = ((all != 0) << 3) | ((none == 0) << 1); \
|
||||
} \
|
||||
}
|
||||
|
||||
/* VCMPNEZ - Vector compare not equal to zero
|
||||
* suffix - instruction mnemonic suffix (b: byte, h: halfword, w: word)
|
||||
* element - element type to access from vector
|
||||
*/
|
||||
#define VCMPNEZ(suffix, element, etype) \
|
||||
VCMPNEZ_DO(suffix, element, etype, 0) \
|
||||
VCMPNEZ_DO(suffix##_dot, element, etype, 1)
|
||||
VCMPNEZ(b, u8, uint8_t)
|
||||
VCMPNEZ(h, u16, uint16_t)
|
||||
VCMPNEZ(w, u32, uint32_t)
|
||||
#undef VCMPNEZ_DO
|
||||
#undef VCMPNEZ
|
||||
|
||||
#define VCMPFP_DO(suffix, compare, order, record) \
|
||||
void helper_vcmp##suffix(CPUPPCState *env, ppc_avr_t *r, \
|
||||
ppc_avr_t *a, ppc_avr_t *b) \
|
||||
|
@ -1604,6 +1696,37 @@ VSL(w, u32, 0x1F)
|
|||
VSL(d, u64, 0x3F)
|
||||
#undef VSL
|
||||
|
||||
void helper_vslv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
|
||||
{
|
||||
int i;
|
||||
unsigned int shift, bytes, size;
|
||||
|
||||
size = ARRAY_SIZE(r->u8);
|
||||
for (i = 0; i < size; i++) {
|
||||
shift = b->u8[i] & 0x7; /* extract shift value */
|
||||
bytes = (a->u8[i] << 8) + /* extract adjacent bytes */
|
||||
(((i + 1) < size) ? a->u8[i + 1] : 0);
|
||||
r->u8[i] = (bytes << shift) >> 8; /* shift and store result */
|
||||
}
|
||||
}
|
||||
|
||||
void helper_vsrv(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b)
|
||||
{
|
||||
int i;
|
||||
unsigned int shift, bytes;
|
||||
|
||||
/* Use reverse order, as destination and source register can be same. Its
|
||||
* being modified in place saving temporary, reverse order will guarantee
|
||||
* that computed result is not fed back.
|
||||
*/
|
||||
for (i = ARRAY_SIZE(r->u8) - 1; i >= 0; i--) {
|
||||
shift = b->u8[i] & 0x7; /* extract shift value */
|
||||
bytes = ((i ? a->u8[i - 1] : 0) << 8) + a->u8[i];
|
||||
/* extract adjacent bytes */
|
||||
r->u8[i] = (bytes >> shift) & 0xFF; /* shift and store result */
|
||||
}
|
||||
}
|
||||
|
||||
void helper_vsldoi(ppc_avr_t *r, ppc_avr_t *a, ppc_avr_t *b, uint32_t shift)
|
||||
{
|
||||
int sh = shift & 0xf;
|
||||
|
|
|
@ -57,9 +57,9 @@ void helper_lmw(CPUPPCState *env, target_ulong addr, uint32_t reg)
|
|||
{
|
||||
for (; reg < 32; reg++) {
|
||||
if (needs_byteswap(env)) {
|
||||
env->gpr[reg] = bswap32(cpu_ldl_data(env, addr));
|
||||
env->gpr[reg] = bswap32(cpu_ldl_data_ra(env, addr, GETPC()));
|
||||
} else {
|
||||
env->gpr[reg] = cpu_ldl_data(env, addr);
|
||||
env->gpr[reg] = cpu_ldl_data_ra(env, addr, GETPC());
|
||||
}
|
||||
addr = addr_add(env, addr, 4);
|
||||
}
|
||||
|
@ -69,31 +69,39 @@ void helper_stmw(CPUPPCState *env, target_ulong addr, uint32_t reg)
|
|||
{
|
||||
for (; reg < 32; reg++) {
|
||||
if (needs_byteswap(env)) {
|
||||
cpu_stl_data(env, addr, bswap32((uint32_t)env->gpr[reg]));
|
||||
cpu_stl_data_ra(env, addr, bswap32((uint32_t)env->gpr[reg]),
|
||||
GETPC());
|
||||
} else {
|
||||
cpu_stl_data(env, addr, (uint32_t)env->gpr[reg]);
|
||||
cpu_stl_data_ra(env, addr, (uint32_t)env->gpr[reg], GETPC());
|
||||
}
|
||||
addr = addr_add(env, addr, 4);
|
||||
}
|
||||
}
|
||||
|
||||
void helper_lsw(CPUPPCState *env, target_ulong addr, uint32_t nb, uint32_t reg)
|
||||
static void do_lsw(CPUPPCState *env, target_ulong addr, uint32_t nb,
|
||||
uint32_t reg, uintptr_t raddr)
|
||||
{
|
||||
int sh;
|
||||
|
||||
for (; nb > 3; nb -= 4) {
|
||||
env->gpr[reg] = cpu_ldl_data(env, addr);
|
||||
env->gpr[reg] = cpu_ldl_data_ra(env, addr, raddr);
|
||||
reg = (reg + 1) % 32;
|
||||
addr = addr_add(env, addr, 4);
|
||||
}
|
||||
if (unlikely(nb > 0)) {
|
||||
env->gpr[reg] = 0;
|
||||
for (sh = 24; nb > 0; nb--, sh -= 8) {
|
||||
env->gpr[reg] |= cpu_ldub_data(env, addr) << sh;
|
||||
env->gpr[reg] |= cpu_ldub_data_ra(env, addr, raddr) << sh;
|
||||
addr = addr_add(env, addr, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void helper_lsw(CPUPPCState *env, target_ulong addr, uint32_t nb, uint32_t reg)
|
||||
{
|
||||
do_lsw(env, addr, nb, reg, GETPC());
|
||||
}
|
||||
|
||||
/* PPC32 specification says we must generate an exception if
|
||||
* rA is in the range of registers to be loaded.
|
||||
* In an other hand, IBM says this is valid, but rA won't be loaded.
|
||||
|
@ -106,12 +114,11 @@ void helper_lswx(CPUPPCState *env, target_ulong addr, uint32_t reg,
|
|||
int num_used_regs = (xer_bc + 3) / 4;
|
||||
if (unlikely((ra != 0 && lsw_reg_in_range(reg, num_used_regs, ra)) ||
|
||||
lsw_reg_in_range(reg, num_used_regs, rb))) {
|
||||
env->nip += 4; /* Compensate the "nip - 4" from gen_lswx() */
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_LSWX);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_LSWX, GETPC());
|
||||
} else {
|
||||
helper_lsw(env, addr, xer_bc, reg);
|
||||
do_lsw(env, addr, xer_bc, reg, GETPC());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -122,46 +129,51 @@ void helper_stsw(CPUPPCState *env, target_ulong addr, uint32_t nb,
|
|||
int sh;
|
||||
|
||||
for (; nb > 3; nb -= 4) {
|
||||
cpu_stl_data(env, addr, env->gpr[reg]);
|
||||
cpu_stl_data_ra(env, addr, env->gpr[reg], GETPC());
|
||||
reg = (reg + 1) % 32;
|
||||
addr = addr_add(env, addr, 4);
|
||||
}
|
||||
if (unlikely(nb > 0)) {
|
||||
for (sh = 24; nb > 0; nb--, sh -= 8) {
|
||||
cpu_stb_data(env, addr, (env->gpr[reg] >> sh) & 0xFF);
|
||||
cpu_stb_data_ra(env, addr, (env->gpr[reg] >> sh) & 0xFF, GETPC());
|
||||
addr = addr_add(env, addr, 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
static void do_dcbz(CPUPPCState *env, target_ulong addr, int dcache_line_size)
|
||||
void helper_dcbz(CPUPPCState *env, target_ulong addr, uint32_t opcode)
|
||||
{
|
||||
int i;
|
||||
|
||||
addr &= ~(dcache_line_size - 1);
|
||||
for (i = 0; i < dcache_line_size; i += 4) {
|
||||
cpu_stl_data(env, addr + i, 0);
|
||||
}
|
||||
if (env->reserve_addr == addr) {
|
||||
env->reserve_addr = (target_ulong)-1ULL;
|
||||
}
|
||||
}
|
||||
|
||||
void helper_dcbz(CPUPPCState *env, target_ulong addr, uint32_t is_dcbzl)
|
||||
{
|
||||
int dcbz_size = env->dcache_line_size;
|
||||
target_ulong mask, dcbz_size = env->dcache_line_size;
|
||||
uint32_t i;
|
||||
void *haddr;
|
||||
|
||||
#if defined(TARGET_PPC64)
|
||||
if (!is_dcbzl &&
|
||||
(env->excp_model == POWERPC_EXCP_970) &&
|
||||
((env->spr[SPR_970_HID5] >> 7) & 0x3) == 1) {
|
||||
/* Check for dcbz vs dcbzl on 970 */
|
||||
if (env->excp_model == POWERPC_EXCP_970 &&
|
||||
!(opcode & 0x00200000) && ((env->spr[SPR_970_HID5] >> 7) & 0x3) == 1) {
|
||||
dcbz_size = 32;
|
||||
}
|
||||
#endif
|
||||
|
||||
/* XXX add e500mc support */
|
||||
/* Align address */
|
||||
mask = ~(dcbz_size - 1);
|
||||
addr &= mask;
|
||||
|
||||
do_dcbz(env, addr, dcbz_size);
|
||||
/* Check reservation */
|
||||
if ((env->reserve_addr & mask) == (addr & mask)) {
|
||||
env->reserve_addr = (target_ulong)-1ULL;
|
||||
}
|
||||
|
||||
/* Try fast path translate */
|
||||
haddr = tlb_vaddr_to_host(env, addr, MMU_DATA_STORE, env->dmmu_idx);
|
||||
if (haddr) {
|
||||
memset(haddr, 0, dcbz_size);
|
||||
} else {
|
||||
/* Slow path */
|
||||
for (i = 0; i < dcbz_size; i += 8) {
|
||||
cpu_stq_data_ra(env, addr + i, 0, GETPC());
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
void helper_icbi(CPUPPCState *env, target_ulong addr)
|
||||
|
@ -172,7 +184,7 @@ void helper_icbi(CPUPPCState *env, target_ulong addr)
|
|||
* (not a fetch) by the MMU. To be sure it will be so,
|
||||
* do the load "by hand".
|
||||
*/
|
||||
cpu_ldl_data(env, addr);
|
||||
cpu_ldl_data_ra(env, addr, GETPC());
|
||||
}
|
||||
|
||||
/* XXX: to be tested */
|
||||
|
@ -183,7 +195,7 @@ target_ulong helper_lscbx(CPUPPCState *env, target_ulong addr, uint32_t reg,
|
|||
|
||||
d = 24;
|
||||
for (i = 0; i < xer_bc; i++) {
|
||||
c = cpu_ldub_data(env, addr);
|
||||
c = cpu_ldub_data_ra(env, addr, GETPC());
|
||||
addr = addr_add(env, addr, 1);
|
||||
/* ra (if not 0) and rb are never modified */
|
||||
if (likely(reg != rb && (ra == 0 || reg != ra))) {
|
||||
|
|
|
@ -39,7 +39,8 @@ void helper_store_dump_spr(CPUPPCState *env, uint32_t sprn)
|
|||
|
||||
#ifdef TARGET_PPC64
|
||||
static void raise_fu_exception(CPUPPCState *env, uint32_t bit,
|
||||
uint32_t sprn, uint32_t cause)
|
||||
uint32_t sprn, uint32_t cause,
|
||||
uintptr_t raddr)
|
||||
{
|
||||
qemu_log("Facility SPR %d is unavailable (SPR FSCR:%d)\n", sprn, bit);
|
||||
|
||||
|
@ -47,7 +48,7 @@ static void raise_fu_exception(CPUPPCState *env, uint32_t bit,
|
|||
cause &= FSCR_IC_MASK;
|
||||
env->spr[SPR_FSCR] |= (target_ulong)cause << FSCR_IC_POS;
|
||||
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_FU, 0);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_FU, 0, raddr);
|
||||
}
|
||||
#endif
|
||||
|
||||
|
@ -59,7 +60,7 @@ void helper_fscr_facility_check(CPUPPCState *env, uint32_t bit,
|
|||
/* Facility is enabled, continue */
|
||||
return;
|
||||
}
|
||||
raise_fu_exception(env, bit, sprn, cause);
|
||||
raise_fu_exception(env, bit, sprn, cause, GETPC());
|
||||
#endif
|
||||
}
|
||||
|
||||
|
@ -71,7 +72,7 @@ void helper_msr_facility_check(CPUPPCState *env, uint32_t bit,
|
|||
/* Facility is enabled, continue */
|
||||
return;
|
||||
}
|
||||
raise_fu_exception(env, bit, sprn, cause);
|
||||
raise_fu_exception(env, bit, sprn, cause, GETPC());
|
||||
#endif
|
||||
}
|
||||
|
||||
|
|
|
@ -241,8 +241,8 @@ void helper_store_slb(CPUPPCState *env, target_ulong rb, target_ulong rs)
|
|||
PowerPCCPU *cpu = ppc_env_get_cpu(env);
|
||||
|
||||
if (ppc_store_slb(cpu, rb & 0xfff, rb & ~0xfffULL, rs) < 0) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL, GETPC());
|
||||
}
|
||||
}
|
||||
|
||||
|
@ -252,8 +252,8 @@ target_ulong helper_load_slb_esid(CPUPPCState *env, target_ulong rb)
|
|||
target_ulong rt = 0;
|
||||
|
||||
if (ppc_load_slb_esid(cpu, rb, &rt) < 0) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL, GETPC());
|
||||
}
|
||||
return rt;
|
||||
}
|
||||
|
@ -264,8 +264,8 @@ target_ulong helper_find_slb_vsid(CPUPPCState *env, target_ulong rb)
|
|||
target_ulong rt = 0;
|
||||
|
||||
if (ppc_find_slb_vsid(cpu, rb, &rt) < 0) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL, GETPC());
|
||||
}
|
||||
return rt;
|
||||
}
|
||||
|
@ -276,8 +276,8 @@ target_ulong helper_load_slb_vsid(CPUPPCState *env, target_ulong rb)
|
|||
target_ulong rt = 0;
|
||||
|
||||
if (ppc_load_slb_vsid(cpu, rb, &rt) < 0) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL, GETPC());
|
||||
}
|
||||
return rt;
|
||||
}
|
||||
|
|
|
@ -1941,7 +1941,7 @@ void ppc_tlb_invalidate_all(CPUPPCState *env)
|
|||
break;
|
||||
default:
|
||||
/* XXX: TODO */
|
||||
cpu_abort(CPU(cpu), "Unknown MMU model\n");
|
||||
cpu_abort(CPU(cpu), "Unknown MMU model %d\n", env->mmu_model);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
@ -2598,9 +2598,9 @@ void helper_booke206_tlbwe(CPUPPCState *env)
|
|||
tlb = booke206_cur_tlb(env);
|
||||
|
||||
if (!tlb) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_INVAL);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_INVAL, GETPC());
|
||||
}
|
||||
|
||||
/* check that we support the targeted size */
|
||||
|
@ -2608,9 +2608,9 @@ void helper_booke206_tlbwe(CPUPPCState *env)
|
|||
size_ps = booke206_tlbnps(env, tlbn);
|
||||
if ((env->spr[SPR_BOOKE_MAS1] & MAS1_VALID) && (tlbncfg & TLBnCFG_AVAIL) &&
|
||||
!(size_ps & (1 << size_tlb))) {
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_INVAL);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_INVAL, GETPC());
|
||||
}
|
||||
|
||||
if (msr_gs) {
|
||||
|
@ -2892,10 +2892,7 @@ void tlb_fill(CPUState *cs, target_ulong addr, MMUAccessType access_type,
|
|||
ret = cpu_ppc_handle_mmu_fault(env, addr, access_type, mmu_idx);
|
||||
}
|
||||
if (unlikely(ret != 0)) {
|
||||
if (likely(retaddr)) {
|
||||
/* now we have a real cpu fault */
|
||||
cpu_restore_state(cs, retaddr);
|
||||
}
|
||||
helper_raise_exception_err(env, cs->exception_index, env->error_code);
|
||||
raise_exception_err_ra(env, cs->exception_index, env->error_code,
|
||||
retaddr);
|
||||
}
|
||||
}
|
||||
|
|
|
@ -19,6 +19,7 @@
|
|||
#include "qemu/osdep.h"
|
||||
#include "cpu.h"
|
||||
#include "exec/helper-proto.h"
|
||||
#include "exec/exec-all.h"
|
||||
#include "qemu/log.h"
|
||||
|
||||
/*****************************************************************************/
|
||||
|
@ -143,15 +144,16 @@ target_ulong helper_load_dcr(CPUPPCState *env, target_ulong dcrn)
|
|||
|
||||
if (unlikely(env->dcr_env == NULL)) {
|
||||
qemu_log_mask(LOG_GUEST_ERROR, "No DCR environment\n");
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_INVAL);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_INVAL, GETPC());
|
||||
} else if (unlikely(ppc_dcr_read(env->dcr_env,
|
||||
(uint32_t)dcrn, &val) != 0)) {
|
||||
qemu_log_mask(LOG_GUEST_ERROR, "DCR read error %d %03x\n",
|
||||
(uint32_t)dcrn, (uint32_t)dcrn);
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL | POWERPC_EXCP_PRIV_REG);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_PRIV_REG, GETPC());
|
||||
}
|
||||
return val;
|
||||
}
|
||||
|
@ -160,14 +162,15 @@ void helper_store_dcr(CPUPPCState *env, target_ulong dcrn, target_ulong val)
|
|||
{
|
||||
if (unlikely(env->dcr_env == NULL)) {
|
||||
qemu_log_mask(LOG_GUEST_ERROR, "No DCR environment\n");
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_INVAL);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_INVAL_INVAL, GETPC());
|
||||
} else if (unlikely(ppc_dcr_write(env->dcr_env, (uint32_t)dcrn,
|
||||
(uint32_t)val) != 0)) {
|
||||
qemu_log_mask(LOG_GUEST_ERROR, "DCR write error %d %03x\n",
|
||||
(uint32_t)dcrn, (uint32_t)dcrn);
|
||||
helper_raise_exception_err(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL | POWERPC_EXCP_PRIV_REG);
|
||||
raise_exception_err_ra(env, POWERPC_EXCP_PROGRAM,
|
||||
POWERPC_EXCP_INVAL |
|
||||
POWERPC_EXCP_PRIV_REG, GETPC());
|
||||
}
|
||||
}
|
||||
|
|
File diff suppressed because it is too large
Load diff
232
target-ppc/translate/dfp-impl.inc.c
Normal file
232
target-ppc/translate/dfp-impl.inc.c
Normal file
|
@ -0,0 +1,232 @@
|
|||
/*** Decimal Floating Point ***/
|
||||
|
||||
static inline TCGv_ptr gen_fprp_ptr(int reg)
|
||||
{
|
||||
TCGv_ptr r = tcg_temp_new_ptr();
|
||||
tcg_gen_addi_ptr(r, cpu_env, offsetof(CPUPPCState, fpr[reg]));
|
||||
return r;
|
||||
}
|
||||
|
||||
#define GEN_DFP_T_A_B_Rc(name) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rd, ra, rb; \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_update_nip(ctx, ctx->nip - 4); \
|
||||
rd = gen_fprp_ptr(rD(ctx->opcode)); \
|
||||
ra = gen_fprp_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_fprp_ptr(rB(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_env, rd, ra, rb); \
|
||||
if (unlikely(Rc(ctx->opcode) != 0)) { \
|
||||
gen_set_cr1_from_fpscr(ctx); \
|
||||
} \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
}
|
||||
|
||||
#define GEN_DFP_BF_A_B(name) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra, rb; \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_update_nip(ctx, ctx->nip - 4); \
|
||||
ra = gen_fprp_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_fprp_ptr(rB(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_crf[crfD(ctx->opcode)], \
|
||||
cpu_env, ra, rb); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
}
|
||||
|
||||
#define GEN_DFP_BF_I_B(name) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_i32 uim; \
|
||||
TCGv_ptr rb; \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_update_nip(ctx, ctx->nip - 4); \
|
||||
uim = tcg_const_i32(UIMM5(ctx->opcode)); \
|
||||
rb = gen_fprp_ptr(rB(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_crf[crfD(ctx->opcode)], \
|
||||
cpu_env, uim, rb); \
|
||||
tcg_temp_free_i32(uim); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
}
|
||||
|
||||
#define GEN_DFP_BF_A_DCM(name) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra; \
|
||||
TCGv_i32 dcm; \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_update_nip(ctx, ctx->nip - 4); \
|
||||
ra = gen_fprp_ptr(rA(ctx->opcode)); \
|
||||
dcm = tcg_const_i32(DCM(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_crf[crfD(ctx->opcode)], \
|
||||
cpu_env, ra, dcm); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_i32(dcm); \
|
||||
}
|
||||
|
||||
#define GEN_DFP_T_B_U32_U32_Rc(name, u32f1, u32f2) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rt, rb; \
|
||||
TCGv_i32 u32_1, u32_2; \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_update_nip(ctx, ctx->nip - 4); \
|
||||
rt = gen_fprp_ptr(rD(ctx->opcode)); \
|
||||
rb = gen_fprp_ptr(rB(ctx->opcode)); \
|
||||
u32_1 = tcg_const_i32(u32f1(ctx->opcode)); \
|
||||
u32_2 = tcg_const_i32(u32f2(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_env, rt, rb, u32_1, u32_2); \
|
||||
if (unlikely(Rc(ctx->opcode) != 0)) { \
|
||||
gen_set_cr1_from_fpscr(ctx); \
|
||||
} \
|
||||
tcg_temp_free_ptr(rt); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_i32(u32_1); \
|
||||
tcg_temp_free_i32(u32_2); \
|
||||
}
|
||||
|
||||
#define GEN_DFP_T_A_B_I32_Rc(name, i32fld) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rt, ra, rb; \
|
||||
TCGv_i32 i32; \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_update_nip(ctx, ctx->nip - 4); \
|
||||
rt = gen_fprp_ptr(rD(ctx->opcode)); \
|
||||
ra = gen_fprp_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_fprp_ptr(rB(ctx->opcode)); \
|
||||
i32 = tcg_const_i32(i32fld(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_env, rt, ra, rb, i32); \
|
||||
if (unlikely(Rc(ctx->opcode) != 0)) { \
|
||||
gen_set_cr1_from_fpscr(ctx); \
|
||||
} \
|
||||
tcg_temp_free_ptr(rt); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_i32(i32); \
|
||||
}
|
||||
|
||||
#define GEN_DFP_T_B_Rc(name) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rt, rb; \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_update_nip(ctx, ctx->nip - 4); \
|
||||
rt = gen_fprp_ptr(rD(ctx->opcode)); \
|
||||
rb = gen_fprp_ptr(rB(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_env, rt, rb); \
|
||||
if (unlikely(Rc(ctx->opcode) != 0)) { \
|
||||
gen_set_cr1_from_fpscr(ctx); \
|
||||
} \
|
||||
tcg_temp_free_ptr(rt); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
}
|
||||
|
||||
#define GEN_DFP_T_FPR_I32_Rc(name, fprfld, i32fld) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rt, rs; \
|
||||
TCGv_i32 i32; \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_update_nip(ctx, ctx->nip - 4); \
|
||||
rt = gen_fprp_ptr(rD(ctx->opcode)); \
|
||||
rs = gen_fprp_ptr(fprfld(ctx->opcode)); \
|
||||
i32 = tcg_const_i32(i32fld(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_env, rt, rs, i32); \
|
||||
if (unlikely(Rc(ctx->opcode) != 0)) { \
|
||||
gen_set_cr1_from_fpscr(ctx); \
|
||||
} \
|
||||
tcg_temp_free_ptr(rt); \
|
||||
tcg_temp_free_ptr(rs); \
|
||||
tcg_temp_free_i32(i32); \
|
||||
}
|
||||
|
||||
GEN_DFP_T_A_B_Rc(dadd)
|
||||
GEN_DFP_T_A_B_Rc(daddq)
|
||||
GEN_DFP_T_A_B_Rc(dsub)
|
||||
GEN_DFP_T_A_B_Rc(dsubq)
|
||||
GEN_DFP_T_A_B_Rc(dmul)
|
||||
GEN_DFP_T_A_B_Rc(dmulq)
|
||||
GEN_DFP_T_A_B_Rc(ddiv)
|
||||
GEN_DFP_T_A_B_Rc(ddivq)
|
||||
GEN_DFP_BF_A_B(dcmpu)
|
||||
GEN_DFP_BF_A_B(dcmpuq)
|
||||
GEN_DFP_BF_A_B(dcmpo)
|
||||
GEN_DFP_BF_A_B(dcmpoq)
|
||||
GEN_DFP_BF_A_DCM(dtstdc)
|
||||
GEN_DFP_BF_A_DCM(dtstdcq)
|
||||
GEN_DFP_BF_A_DCM(dtstdg)
|
||||
GEN_DFP_BF_A_DCM(dtstdgq)
|
||||
GEN_DFP_BF_A_B(dtstex)
|
||||
GEN_DFP_BF_A_B(dtstexq)
|
||||
GEN_DFP_BF_A_B(dtstsf)
|
||||
GEN_DFP_BF_A_B(dtstsfq)
|
||||
GEN_DFP_BF_I_B(dtstsfi)
|
||||
GEN_DFP_BF_I_B(dtstsfiq)
|
||||
GEN_DFP_T_B_U32_U32_Rc(dquai, SIMM5, RMC)
|
||||
GEN_DFP_T_B_U32_U32_Rc(dquaiq, SIMM5, RMC)
|
||||
GEN_DFP_T_A_B_I32_Rc(dqua, RMC)
|
||||
GEN_DFP_T_A_B_I32_Rc(dquaq, RMC)
|
||||
GEN_DFP_T_A_B_I32_Rc(drrnd, RMC)
|
||||
GEN_DFP_T_A_B_I32_Rc(drrndq, RMC)
|
||||
GEN_DFP_T_B_U32_U32_Rc(drintx, FPW, RMC)
|
||||
GEN_DFP_T_B_U32_U32_Rc(drintxq, FPW, RMC)
|
||||
GEN_DFP_T_B_U32_U32_Rc(drintn, FPW, RMC)
|
||||
GEN_DFP_T_B_U32_U32_Rc(drintnq, FPW, RMC)
|
||||
GEN_DFP_T_B_Rc(dctdp)
|
||||
GEN_DFP_T_B_Rc(dctqpq)
|
||||
GEN_DFP_T_B_Rc(drsp)
|
||||
GEN_DFP_T_B_Rc(drdpq)
|
||||
GEN_DFP_T_B_Rc(dcffix)
|
||||
GEN_DFP_T_B_Rc(dcffixq)
|
||||
GEN_DFP_T_B_Rc(dctfix)
|
||||
GEN_DFP_T_B_Rc(dctfixq)
|
||||
GEN_DFP_T_FPR_I32_Rc(ddedpd, rB, SP)
|
||||
GEN_DFP_T_FPR_I32_Rc(ddedpdq, rB, SP)
|
||||
GEN_DFP_T_FPR_I32_Rc(denbcd, rB, SP)
|
||||
GEN_DFP_T_FPR_I32_Rc(denbcdq, rB, SP)
|
||||
GEN_DFP_T_B_Rc(dxex)
|
||||
GEN_DFP_T_B_Rc(dxexq)
|
||||
GEN_DFP_T_A_B_Rc(diex)
|
||||
GEN_DFP_T_A_B_Rc(diexq)
|
||||
GEN_DFP_T_FPR_I32_Rc(dscli, rA, DCM)
|
||||
GEN_DFP_T_FPR_I32_Rc(dscliq, rA, DCM)
|
||||
GEN_DFP_T_FPR_I32_Rc(dscri, rA, DCM)
|
||||
GEN_DFP_T_FPR_I32_Rc(dscriq, rA, DCM)
|
||||
|
||||
#undef GEN_DFP_T_A_B_Rc
|
||||
#undef GEN_DFP_BF_A_B
|
||||
#undef GEN_DFP_BF_A_DCM
|
||||
#undef GEN_DFP_T_B_U32_U32_Rc
|
||||
#undef GEN_DFP_T_A_B_I32_Rc
|
||||
#undef GEN_DFP_T_B_Rc
|
||||
#undef GEN_DFP_T_FPR_I32_Rc
|
165
target-ppc/translate/dfp-ops.inc.c
Normal file
165
target-ppc/translate/dfp-ops.inc.c
Normal file
|
@ -0,0 +1,165 @@
|
|||
#define _GEN_DFP_LONG(name, op1, op2, mask) \
|
||||
GEN_HANDLER_E(name, 0x3B, op1, op2, mask, PPC_NONE, PPC2_DFP)
|
||||
|
||||
#define _GEN_DFP_LONG_300(name, op1, op2, mask) \
|
||||
GEN_HANDLER_E(name, 0x3B, op1, op2, mask, PPC_NONE, PPC2_ISA300)
|
||||
|
||||
#define _GEN_DFP_LONGx2(name, op1, op2, mask) \
|
||||
GEN_HANDLER_E(name, 0x3B, op1, 0x00 | op2, mask, PPC_NONE, PPC2_DFP), \
|
||||
GEN_HANDLER_E(name, 0x3B, op1, 0x10 | op2, mask, PPC_NONE, PPC2_DFP)
|
||||
|
||||
#define _GEN_DFP_LONGx4(name, op1, op2, mask) \
|
||||
GEN_HANDLER_E(name, 0x3B, op1, 0x00 | op2, mask, PPC_NONE, PPC2_DFP), \
|
||||
GEN_HANDLER_E(name, 0x3B, op1, 0x08 | op2, mask, PPC_NONE, PPC2_DFP), \
|
||||
GEN_HANDLER_E(name, 0x3B, op1, 0x10 | op2, mask, PPC_NONE, PPC2_DFP), \
|
||||
GEN_HANDLER_E(name, 0x3B, op1, 0x18 | op2, mask, PPC_NONE, PPC2_DFP)
|
||||
|
||||
#define _GEN_DFP_QUAD(name, op1, op2, mask) \
|
||||
GEN_HANDLER_E(name, 0x3F, op1, op2, mask, PPC_NONE, PPC2_DFP)
|
||||
|
||||
#define _GEN_DFP_QUAD_300(name, op1, op2, mask) \
|
||||
GEN_HANDLER_E(name, 0x3F, op1, op2, mask, PPC_NONE, PPC2_ISA300)
|
||||
|
||||
#define _GEN_DFP_QUADx2(name, op1, op2, mask) \
|
||||
GEN_HANDLER_E(name, 0x3F, op1, 0x00 | op2, mask, PPC_NONE, PPC2_DFP), \
|
||||
GEN_HANDLER_E(name, 0x3F, op1, 0x10 | op2, mask, PPC_NONE, PPC2_DFP)
|
||||
|
||||
#define _GEN_DFP_QUADx4(name, op1, op2, mask) \
|
||||
GEN_HANDLER_E(name, 0x3F, op1, 0x00 | op2, mask, PPC_NONE, PPC2_DFP), \
|
||||
GEN_HANDLER_E(name, 0x3F, op1, 0x08 | op2, mask, PPC_NONE, PPC2_DFP), \
|
||||
GEN_HANDLER_E(name, 0x3F, op1, 0x10 | op2, mask, PPC_NONE, PPC2_DFP), \
|
||||
GEN_HANDLER_E(name, 0x3F, op1, 0x18 | op2, mask, PPC_NONE, PPC2_DFP)
|
||||
|
||||
#define GEN_DFP_T_A_B_Rc(name, op1, op2) \
|
||||
_GEN_DFP_LONG(name, op1, op2, 0x00000000)
|
||||
|
||||
#define GEN_DFP_Tp_Ap_Bp_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x00210800)
|
||||
|
||||
#define GEN_DFP_Tp_A_Bp_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x00200800)
|
||||
|
||||
#define GEN_DFP_T_B_Rc(name, op1, op2) \
|
||||
_GEN_DFP_LONG(name, op1, op2, 0x001F0000)
|
||||
|
||||
#define GEN_DFP_Tp_Bp_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x003F0800)
|
||||
|
||||
#define GEN_DFP_Tp_B_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x003F0000)
|
||||
|
||||
#define GEN_DFP_T_Bp_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x001F0800)
|
||||
|
||||
#define GEN_DFP_BF_A_B(name, op1, op2) \
|
||||
_GEN_DFP_LONG(name, op1, op2, 0x00000001)
|
||||
|
||||
#define GEN_DFP_BF_A_B_300(name, op1, op2) \
|
||||
_GEN_DFP_LONG_300(name, op1, op2, 0x00400001)
|
||||
|
||||
#define GEN_DFP_BF_Ap_Bp(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x00610801)
|
||||
|
||||
#define GEN_DFP_BF_A_Bp(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x00600801)
|
||||
|
||||
#define GEN_DFP_BF_A_Bp_300(name, op1, op2) \
|
||||
_GEN_DFP_QUAD_300(name, op1, op2, 0x00400001)
|
||||
|
||||
#define GEN_DFP_BF_A_DCM(name, op1, op2) \
|
||||
_GEN_DFP_LONGx2(name, op1, op2, 0x00600001)
|
||||
|
||||
#define GEN_DFP_BF_Ap_DCM(name, op1, op2) \
|
||||
_GEN_DFP_QUADx2(name, op1, op2, 0x00610001)
|
||||
|
||||
#define GEN_DFP_T_A_B_RMC_Rc(name, op1, op2) \
|
||||
_GEN_DFP_LONGx4(name, op1, op2, 0x00000000)
|
||||
|
||||
#define GEN_DFP_Tp_Ap_Bp_RMC_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUADx4(name, op1, op2, 0x02010800)
|
||||
|
||||
#define GEN_DFP_Tp_A_Bp_RMC_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUADx4(name, op1, op2, 0x02000800)
|
||||
|
||||
#define GEN_DFP_TE_T_B_RMC_Rc(name, op1, op2) \
|
||||
_GEN_DFP_LONGx4(name, op1, op2, 0x00000000)
|
||||
|
||||
#define GEN_DFP_TE_Tp_Bp_RMC_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUADx4(name, op1, op2, 0x00200800)
|
||||
|
||||
#define GEN_DFP_R_T_B_RMC_Rc(name, op1, op2) \
|
||||
_GEN_DFP_LONGx4(name, op1, op2, 0x001E0000)
|
||||
|
||||
#define GEN_DFP_R_Tp_Bp_RMC_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUADx4(name, op1, op2, 0x003E0800)
|
||||
|
||||
#define GEN_DFP_SP_T_B_Rc(name, op1, op2) \
|
||||
_GEN_DFP_LONG(name, op1, op2, 0x00070000)
|
||||
|
||||
#define GEN_DFP_SP_Tp_Bp_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x00270800)
|
||||
|
||||
#define GEN_DFP_S_T_B_Rc(name, op1, op2) \
|
||||
_GEN_DFP_LONG(name, op1, op2, 0x000F0000)
|
||||
|
||||
#define GEN_DFP_S_Tp_Bp_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUAD(name, op1, op2, 0x002F0800)
|
||||
|
||||
#define GEN_DFP_T_A_SH_Rc(name, op1, op2) \
|
||||
_GEN_DFP_LONGx2(name, op1, op2, 0x00000000)
|
||||
|
||||
#define GEN_DFP_Tp_Ap_SH_Rc(name, op1, op2) \
|
||||
_GEN_DFP_QUADx2(name, op1, op2, 0x00210000)
|
||||
|
||||
GEN_DFP_T_A_B_Rc(dadd, 0x02, 0x00),
|
||||
GEN_DFP_Tp_Ap_Bp_Rc(daddq, 0x02, 0x00),
|
||||
GEN_DFP_T_A_B_Rc(dsub, 0x02, 0x10),
|
||||
GEN_DFP_Tp_Ap_Bp_Rc(dsubq, 0x02, 0x10),
|
||||
GEN_DFP_T_A_B_Rc(dmul, 0x02, 0x01),
|
||||
GEN_DFP_Tp_Ap_Bp_Rc(dmulq, 0x02, 0x01),
|
||||
GEN_DFP_T_A_B_Rc(ddiv, 0x02, 0x11),
|
||||
GEN_DFP_Tp_Ap_Bp_Rc(ddivq, 0x02, 0x11),
|
||||
GEN_DFP_BF_A_B(dcmpu, 0x02, 0x14),
|
||||
GEN_DFP_BF_Ap_Bp(dcmpuq, 0x02, 0x14),
|
||||
GEN_DFP_BF_A_B(dcmpo, 0x02, 0x04),
|
||||
GEN_DFP_BF_Ap_Bp(dcmpoq, 0x02, 0x04),
|
||||
GEN_DFP_BF_A_DCM(dtstdc, 0x02, 0x06),
|
||||
GEN_DFP_BF_Ap_DCM(dtstdcq, 0x02, 0x06),
|
||||
GEN_DFP_BF_A_DCM(dtstdg, 0x02, 0x07),
|
||||
GEN_DFP_BF_Ap_DCM(dtstdgq, 0x02, 0x07),
|
||||
GEN_DFP_BF_A_B(dtstex, 0x02, 0x05),
|
||||
GEN_DFP_BF_Ap_Bp(dtstexq, 0x02, 0x05),
|
||||
GEN_DFP_BF_A_B(dtstsf, 0x02, 0x15),
|
||||
GEN_DFP_BF_A_Bp(dtstsfq, 0x02, 0x15),
|
||||
GEN_DFP_BF_A_B_300(dtstsfi, 0x03, 0x15),
|
||||
GEN_DFP_BF_A_Bp_300(dtstsfiq, 0x03, 0x15),
|
||||
GEN_DFP_TE_T_B_RMC_Rc(dquai, 0x03, 0x02),
|
||||
GEN_DFP_TE_Tp_Bp_RMC_Rc(dquaiq, 0x03, 0x02),
|
||||
GEN_DFP_T_A_B_RMC_Rc(dqua, 0x03, 0x00),
|
||||
GEN_DFP_Tp_Ap_Bp_RMC_Rc(dquaq, 0x03, 0x00),
|
||||
GEN_DFP_T_A_B_RMC_Rc(drrnd, 0x03, 0x01),
|
||||
GEN_DFP_Tp_A_Bp_RMC_Rc(drrndq, 0x03, 0x01),
|
||||
GEN_DFP_R_T_B_RMC_Rc(drintx, 0x03, 0x03),
|
||||
GEN_DFP_R_Tp_Bp_RMC_Rc(drintxq, 0x03, 0x03),
|
||||
GEN_DFP_R_T_B_RMC_Rc(drintn, 0x03, 0x07),
|
||||
GEN_DFP_R_Tp_Bp_RMC_Rc(drintnq, 0x03, 0x07),
|
||||
GEN_DFP_T_B_Rc(dctdp, 0x02, 0x08),
|
||||
GEN_DFP_Tp_B_Rc(dctqpq, 0x02, 0x08),
|
||||
GEN_DFP_T_B_Rc(drsp, 0x02, 0x18),
|
||||
GEN_DFP_Tp_Bp_Rc(drdpq, 0x02, 0x18),
|
||||
GEN_DFP_T_B_Rc(dcffix, 0x02, 0x19),
|
||||
GEN_DFP_Tp_B_Rc(dcffixq, 0x02, 0x19),
|
||||
GEN_DFP_T_B_Rc(dctfix, 0x02, 0x09),
|
||||
GEN_DFP_T_Bp_Rc(dctfixq, 0x02, 0x09),
|
||||
GEN_DFP_SP_T_B_Rc(ddedpd, 0x02, 0x0a),
|
||||
GEN_DFP_SP_Tp_Bp_Rc(ddedpdq, 0x02, 0x0a),
|
||||
GEN_DFP_S_T_B_Rc(denbcd, 0x02, 0x1a),
|
||||
GEN_DFP_S_Tp_Bp_Rc(denbcdq, 0x02, 0x1a),
|
||||
GEN_DFP_T_B_Rc(dxex, 0x02, 0x0b),
|
||||
GEN_DFP_T_Bp_Rc(dxexq, 0x02, 0x0b),
|
||||
GEN_DFP_T_A_B_Rc(diex, 0x02, 0x1b),
|
||||
GEN_DFP_Tp_A_Bp_Rc(diexq, 0x02, 0x1b),
|
||||
GEN_DFP_T_A_SH_Rc(dscli, 0x02, 0x02),
|
||||
GEN_DFP_Tp_Ap_SH_Rc(dscliq, 0x02, 0x02),
|
||||
GEN_DFP_T_A_SH_Rc(dscri, 0x02, 0x03),
|
||||
GEN_DFP_Tp_Ap_SH_Rc(dscriq, 0x02, 0x03),
|
1070
target-ppc/translate/fp-impl.inc.c
Normal file
1070
target-ppc/translate/fp-impl.inc.c
Normal file
File diff suppressed because it is too large
Load diff
111
target-ppc/translate/fp-ops.inc.c
Normal file
111
target-ppc/translate/fp-ops.inc.c
Normal file
|
@ -0,0 +1,111 @@
|
|||
#define _GEN_FLOAT_ACB(name, op, op1, op2, isfloat, set_fprf, type) \
|
||||
GEN_HANDLER(f##name, op1, op2, 0xFF, 0x00000000, type)
|
||||
#define GEN_FLOAT_ACB(name, op2, set_fprf, type) \
|
||||
_GEN_FLOAT_ACB(name, name, 0x3F, op2, 0, set_fprf, type), \
|
||||
_GEN_FLOAT_ACB(name##s, name, 0x3B, op2, 1, set_fprf, type)
|
||||
#define _GEN_FLOAT_AB(name, op, op1, op2, inval, isfloat, set_fprf, type) \
|
||||
GEN_HANDLER(f##name, op1, op2, 0xFF, inval, type)
|
||||
#define GEN_FLOAT_AB(name, op2, inval, set_fprf, type) \
|
||||
_GEN_FLOAT_AB(name, name, 0x3F, op2, inval, 0, set_fprf, type), \
|
||||
_GEN_FLOAT_AB(name##s, name, 0x3B, op2, inval, 1, set_fprf, type)
|
||||
#define _GEN_FLOAT_AC(name, op, op1, op2, inval, isfloat, set_fprf, type) \
|
||||
GEN_HANDLER(f##name, op1, op2, 0xFF, inval, type)
|
||||
#define GEN_FLOAT_AC(name, op2, inval, set_fprf, type) \
|
||||
_GEN_FLOAT_AC(name, name, 0x3F, op2, inval, 0, set_fprf, type), \
|
||||
_GEN_FLOAT_AC(name##s, name, 0x3B, op2, inval, 1, set_fprf, type)
|
||||
#define GEN_FLOAT_B(name, op2, op3, set_fprf, type) \
|
||||
GEN_HANDLER(f##name, 0x3F, op2, op3, 0x001F0000, type)
|
||||
#define GEN_FLOAT_BS(name, op1, op2, set_fprf, type) \
|
||||
GEN_HANDLER(f##name, op1, op2, 0xFF, 0x001F07C0, type)
|
||||
|
||||
GEN_FLOAT_AB(add, 0x15, 0x000007C0, 1, PPC_FLOAT),
|
||||
GEN_FLOAT_AB(div, 0x12, 0x000007C0, 1, PPC_FLOAT),
|
||||
GEN_FLOAT_AC(mul, 0x19, 0x0000F800, 1, PPC_FLOAT),
|
||||
GEN_FLOAT_BS(re, 0x3F, 0x18, 1, PPC_FLOAT_EXT),
|
||||
GEN_FLOAT_BS(res, 0x3B, 0x18, 1, PPC_FLOAT_FRES),
|
||||
GEN_FLOAT_BS(rsqrte, 0x3F, 0x1A, 1, PPC_FLOAT_FRSQRTE),
|
||||
_GEN_FLOAT_ACB(sel, sel, 0x3F, 0x17, 0, 0, PPC_FLOAT_FSEL),
|
||||
GEN_FLOAT_AB(sub, 0x14, 0x000007C0, 1, PPC_FLOAT),
|
||||
GEN_FLOAT_ACB(madd, 0x1D, 1, PPC_FLOAT),
|
||||
GEN_FLOAT_ACB(msub, 0x1C, 1, PPC_FLOAT),
|
||||
GEN_FLOAT_ACB(nmadd, 0x1F, 1, PPC_FLOAT),
|
||||
GEN_FLOAT_ACB(nmsub, 0x1E, 1, PPC_FLOAT),
|
||||
GEN_HANDLER_E(ftdiv, 0x3F, 0x00, 0x04, 1, PPC_NONE, PPC2_FP_TST_ISA206),
|
||||
GEN_HANDLER_E(ftsqrt, 0x3F, 0x00, 0x05, 1, PPC_NONE, PPC2_FP_TST_ISA206),
|
||||
GEN_FLOAT_B(ctiw, 0x0E, 0x00, 0, PPC_FLOAT),
|
||||
GEN_HANDLER_E(fctiwu, 0x3F, 0x0E, 0x04, 0, PPC_NONE, PPC2_FP_CVT_ISA206),
|
||||
GEN_FLOAT_B(ctiwz, 0x0F, 0x00, 0, PPC_FLOAT),
|
||||
GEN_HANDLER_E(fctiwuz, 0x3F, 0x0F, 0x04, 0, PPC_NONE, PPC2_FP_CVT_ISA206),
|
||||
GEN_FLOAT_B(rsp, 0x0C, 0x00, 1, PPC_FLOAT),
|
||||
GEN_HANDLER_E(fcfid, 0x3F, 0x0E, 0x1A, 0x001F0000, PPC_NONE, PPC2_FP_CVT_S64),
|
||||
GEN_HANDLER_E(fcfids, 0x3B, 0x0E, 0x1A, 0, PPC_NONE, PPC2_FP_CVT_ISA206),
|
||||
GEN_HANDLER_E(fcfidu, 0x3F, 0x0E, 0x1E, 0, PPC_NONE, PPC2_FP_CVT_ISA206),
|
||||
GEN_HANDLER_E(fcfidus, 0x3B, 0x0E, 0x1E, 0, PPC_NONE, PPC2_FP_CVT_ISA206),
|
||||
GEN_HANDLER_E(fctid, 0x3F, 0x0E, 0x19, 0x001F0000, PPC_NONE, PPC2_FP_CVT_S64),
|
||||
GEN_HANDLER_E(fctidu, 0x3F, 0x0E, 0x1D, 0, PPC_NONE, PPC2_FP_CVT_ISA206),
|
||||
GEN_HANDLER_E(fctidz, 0x3F, 0x0F, 0x19, 0x001F0000, PPC_NONE, PPC2_FP_CVT_S64),
|
||||
GEN_HANDLER_E(fctiduz, 0x3F, 0x0F, 0x1D, 0, PPC_NONE, PPC2_FP_CVT_ISA206),
|
||||
GEN_FLOAT_B(rin, 0x08, 0x0C, 1, PPC_FLOAT_EXT),
|
||||
GEN_FLOAT_B(riz, 0x08, 0x0D, 1, PPC_FLOAT_EXT),
|
||||
GEN_FLOAT_B(rip, 0x08, 0x0E, 1, PPC_FLOAT_EXT),
|
||||
GEN_FLOAT_B(rim, 0x08, 0x0F, 1, PPC_FLOAT_EXT),
|
||||
|
||||
#define GEN_LDF(name, ldop, opc, type) \
|
||||
GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
|
||||
#define GEN_LDUF(name, ldop, opc, type) \
|
||||
GEN_HANDLER(name##u, opc, 0xFF, 0xFF, 0x00000000, type),
|
||||
#define GEN_LDUXF(name, ldop, opc, type) \
|
||||
GEN_HANDLER(name##ux, 0x1F, 0x17, opc, 0x00000001, type),
|
||||
#define GEN_LDXF(name, ldop, opc2, opc3, type) \
|
||||
GEN_HANDLER(name##x, 0x1F, opc2, opc3, 0x00000001, type),
|
||||
#define GEN_LDFS(name, ldop, op, type) \
|
||||
GEN_LDF(name, ldop, op | 0x20, type) \
|
||||
GEN_LDUF(name, ldop, op | 0x21, type) \
|
||||
GEN_LDUXF(name, ldop, op | 0x01, type) \
|
||||
GEN_LDXF(name, ldop, 0x17, op | 0x00, type)
|
||||
|
||||
GEN_LDFS(lfd, ld64, 0x12, PPC_FLOAT)
|
||||
GEN_LDFS(lfs, ld32fs, 0x10, PPC_FLOAT)
|
||||
GEN_HANDLER_E(lfiwax, 0x1f, 0x17, 0x1a, 0x00000001, PPC_NONE, PPC2_ISA205),
|
||||
GEN_HANDLER_E(lfiwzx, 0x1f, 0x17, 0x1b, 0x1, PPC_NONE, PPC2_FP_CVT_ISA206),
|
||||
GEN_HANDLER_E(lfdp, 0x39, 0xFF, 0xFF, 0x00200003, PPC_NONE, PPC2_ISA205),
|
||||
GEN_HANDLER_E(lfdpx, 0x1F, 0x17, 0x18, 0x00200001, PPC_NONE, PPC2_ISA205),
|
||||
|
||||
#define GEN_STF(name, stop, opc, type) \
|
||||
GEN_HANDLER(name, opc, 0xFF, 0xFF, 0x00000000, type),
|
||||
#define GEN_STUF(name, stop, opc, type) \
|
||||
GEN_HANDLER(name##u, opc, 0xFF, 0xFF, 0x00000000, type),
|
||||
#define GEN_STUXF(name, stop, opc, type) \
|
||||
GEN_HANDLER(name##ux, 0x1F, 0x17, opc, 0x00000001, type),
|
||||
#define GEN_STXF(name, stop, opc2, opc3, type) \
|
||||
GEN_HANDLER(name##x, 0x1F, opc2, opc3, 0x00000001, type),
|
||||
#define GEN_STFS(name, stop, op, type) \
|
||||
GEN_STF(name, stop, op | 0x20, type) \
|
||||
GEN_STUF(name, stop, op | 0x21, type) \
|
||||
GEN_STUXF(name, stop, op | 0x01, type) \
|
||||
GEN_STXF(name, stop, 0x17, op | 0x00, type)
|
||||
|
||||
GEN_STFS(stfd, st64, 0x16, PPC_FLOAT)
|
||||
GEN_STFS(stfs, st32fs, 0x14, PPC_FLOAT)
|
||||
GEN_STXF(stfiw, st32fiw, 0x17, 0x1E, PPC_FLOAT_STFIWX)
|
||||
GEN_HANDLER_E(stfdp, 0x3D, 0xFF, 0xFF, 0x00200003, PPC_NONE, PPC2_ISA205),
|
||||
GEN_HANDLER_E(stfdpx, 0x1F, 0x17, 0x1C, 0x00200001, PPC_NONE, PPC2_ISA205),
|
||||
|
||||
GEN_HANDLER(frsqrtes, 0x3B, 0x1A, 0xFF, 0x001F07C0, PPC_FLOAT_FRSQRTES),
|
||||
GEN_HANDLER(fsqrt, 0x3F, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT),
|
||||
GEN_HANDLER(fsqrts, 0x3B, 0x16, 0xFF, 0x001F07C0, PPC_FLOAT_FSQRT),
|
||||
GEN_HANDLER(fcmpo, 0x3F, 0x00, 0x01, 0x00600001, PPC_FLOAT),
|
||||
GEN_HANDLER(fcmpu, 0x3F, 0x00, 0x00, 0x00600001, PPC_FLOAT),
|
||||
GEN_HANDLER(fabs, 0x3F, 0x08, 0x08, 0x001F0000, PPC_FLOAT),
|
||||
GEN_HANDLER(fmr, 0x3F, 0x08, 0x02, 0x001F0000, PPC_FLOAT),
|
||||
GEN_HANDLER(fnabs, 0x3F, 0x08, 0x04, 0x001F0000, PPC_FLOAT),
|
||||
GEN_HANDLER(fneg, 0x3F, 0x08, 0x01, 0x001F0000, PPC_FLOAT),
|
||||
GEN_HANDLER_E(fcpsgn, 0x3F, 0x08, 0x00, 0x00000000, PPC_NONE, PPC2_ISA205),
|
||||
GEN_HANDLER_E(fmrgew, 0x3F, 0x06, 0x1E, 0x00000001, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(fmrgow, 0x3F, 0x06, 0x1A, 0x00000001, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER(mcrfs, 0x3F, 0x00, 0x02, 0x0063F801, PPC_FLOAT),
|
||||
GEN_HANDLER(mffs, 0x3F, 0x07, 0x12, 0x001FF800, PPC_FLOAT),
|
||||
GEN_HANDLER(mtfsb0, 0x3F, 0x06, 0x02, 0x001FF800, PPC_FLOAT),
|
||||
GEN_HANDLER(mtfsb1, 0x3F, 0x06, 0x01, 0x001FF800, PPC_FLOAT),
|
||||
GEN_HANDLER(mtfsf, 0x3F, 0x07, 0x16, 0x00000000, PPC_FLOAT),
|
||||
GEN_HANDLER(mtfsfi, 0x3F, 0x06, 0x04, 0x006e0800, PPC_FLOAT),
|
1229
target-ppc/translate/spe-impl.inc.c
Normal file
1229
target-ppc/translate/spe-impl.inc.c
Normal file
File diff suppressed because it is too large
Load diff
105
target-ppc/translate/spe-ops.inc.c
Normal file
105
target-ppc/translate/spe-ops.inc.c
Normal file
|
@ -0,0 +1,105 @@
|
|||
GEN_HANDLER2(evsel0, "evsel", 0x04, 0x1c, 0x09, 0x00000000, PPC_SPE),
|
||||
GEN_HANDLER2(evsel1, "evsel", 0x04, 0x1d, 0x09, 0x00000000, PPC_SPE),
|
||||
GEN_HANDLER2(evsel2, "evsel", 0x04, 0x1e, 0x09, 0x00000000, PPC_SPE),
|
||||
GEN_HANDLER2(evsel3, "evsel", 0x04, 0x1f, 0x09, 0x00000000, PPC_SPE),
|
||||
|
||||
#define GEN_SPE(name0, name1, opc2, opc3, inval0, inval1, type) \
|
||||
GEN_OPCODE_DUAL(name0##_##name1, 0x04, opc2, opc3, inval0, inval1, type, PPC_NONE)
|
||||
GEN_SPE(evaddw, speundef, 0x00, 0x08, 0x00000000, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(evaddiw, speundef, 0x01, 0x08, 0x00000000, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(evsubfw, speundef, 0x02, 0x08, 0x00000000, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(evsubifw, speundef, 0x03, 0x08, 0x00000000, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(evabs, evneg, 0x04, 0x08, 0x0000F800, 0x0000F800, PPC_SPE),
|
||||
GEN_SPE(evextsb, evextsh, 0x05, 0x08, 0x0000F800, 0x0000F800, PPC_SPE),
|
||||
GEN_SPE(evrndw, evcntlzw, 0x06, 0x08, 0x0000F800, 0x0000F800, PPC_SPE),
|
||||
GEN_SPE(evcntlsw, brinc, 0x07, 0x08, 0x0000F800, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evmra, speundef, 0x02, 0x13, 0x0000F800, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(speundef, evand, 0x08, 0x08, 0xFFFFFFFF, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evandc, speundef, 0x09, 0x08, 0x00000000, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(evxor, evor, 0x0B, 0x08, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evnor, eveqv, 0x0C, 0x08, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evmwumi, evmwsmi, 0x0C, 0x11, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evmwumia, evmwsmia, 0x1C, 0x11, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evmwumiaa, evmwsmiaa, 0x0C, 0x15, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(speundef, evorc, 0x0D, 0x08, 0xFFFFFFFF, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evnand, speundef, 0x0F, 0x08, 0x00000000, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(evsrwu, evsrws, 0x10, 0x08, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evsrwiu, evsrwis, 0x11, 0x08, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evslw, speundef, 0x12, 0x08, 0x00000000, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(evslwi, speundef, 0x13, 0x08, 0x00000000, 0xFFFFFFFF, PPC_SPE),
|
||||
GEN_SPE(evrlw, evsplati, 0x14, 0x08, 0x00000000, 0x0000F800, PPC_SPE),
|
||||
GEN_SPE(evrlwi, evsplatfi, 0x15, 0x08, 0x00000000, 0x0000F800, PPC_SPE),
|
||||
GEN_SPE(evmergehi, evmergelo, 0x16, 0x08, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evmergehilo, evmergelohi, 0x17, 0x08, 0x00000000, 0x00000000, PPC_SPE),
|
||||
GEN_SPE(evcmpgtu, evcmpgts, 0x18, 0x08, 0x00600000, 0x00600000, PPC_SPE),
|
||||
GEN_SPE(evcmpltu, evcmplts, 0x19, 0x08, 0x00600000, 0x00600000, PPC_SPE),
|
||||
GEN_SPE(evcmpeq, speundef, 0x1A, 0x08, 0x00600000, 0xFFFFFFFF, PPC_SPE),
|
||||
|
||||
GEN_SPE(evfsadd, evfssub, 0x00, 0x0A, 0x00000000, 0x00000000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfsabs, evfsnabs, 0x02, 0x0A, 0x0000F800, 0x0000F800, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfsneg, speundef, 0x03, 0x0A, 0x0000F800, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfsmul, evfsdiv, 0x04, 0x0A, 0x00000000, 0x00000000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfscmpgt, evfscmplt, 0x06, 0x0A, 0x00600000, 0x00600000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfscmpeq, speundef, 0x07, 0x0A, 0x00600000, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfscfui, evfscfsi, 0x08, 0x0A, 0x00180000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfscfuf, evfscfsf, 0x09, 0x0A, 0x00180000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfsctui, evfsctsi, 0x0A, 0x0A, 0x00180000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfsctuf, evfsctsf, 0x0B, 0x0A, 0x00180000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfsctuiz, speundef, 0x0C, 0x0A, 0x00180000, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfsctsiz, speundef, 0x0D, 0x0A, 0x00180000, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfststgt, evfststlt, 0x0E, 0x0A, 0x00600000, 0x00600000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(evfststeq, speundef, 0x0F, 0x0A, 0x00600000, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
|
||||
GEN_SPE(efsadd, efssub, 0x00, 0x0B, 0x00000000, 0x00000000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efsabs, efsnabs, 0x02, 0x0B, 0x0000F800, 0x0000F800, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efsneg, speundef, 0x03, 0x0B, 0x0000F800, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efsmul, efsdiv, 0x04, 0x0B, 0x00000000, 0x00000000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efscmpgt, efscmplt, 0x06, 0x0B, 0x00600000, 0x00600000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efscmpeq, efscfd, 0x07, 0x0B, 0x00600000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efscfui, efscfsi, 0x08, 0x0B, 0x00180000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efscfuf, efscfsf, 0x09, 0x0B, 0x00180000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efsctui, efsctsi, 0x0A, 0x0B, 0x00180000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efsctuf, efsctsf, 0x0B, 0x0B, 0x00180000, 0x00180000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efsctuiz, speundef, 0x0C, 0x0B, 0x00180000, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efsctsiz, speundef, 0x0D, 0x0B, 0x00180000, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efststgt, efststlt, 0x0E, 0x0B, 0x00600000, 0x00600000, PPC_SPE_SINGLE),
|
||||
GEN_SPE(efststeq, speundef, 0x0F, 0x0B, 0x00600000, 0xFFFFFFFF, PPC_SPE_SINGLE),
|
||||
|
||||
GEN_SPE(efdadd, efdsub, 0x10, 0x0B, 0x00000000, 0x00000000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdcfuid, efdcfsid, 0x11, 0x0B, 0x00180000, 0x00180000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdabs, efdnabs, 0x12, 0x0B, 0x0000F800, 0x0000F800, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdneg, speundef, 0x13, 0x0B, 0x0000F800, 0xFFFFFFFF, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdmul, efddiv, 0x14, 0x0B, 0x00000000, 0x00000000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdctuidz, efdctsidz, 0x15, 0x0B, 0x00180000, 0x00180000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdcmpgt, efdcmplt, 0x16, 0x0B, 0x00600000, 0x00600000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdcmpeq, efdcfs, 0x17, 0x0B, 0x00600000, 0x00180000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdcfui, efdcfsi, 0x18, 0x0B, 0x00180000, 0x00180000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdcfuf, efdcfsf, 0x19, 0x0B, 0x00180000, 0x00180000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdctui, efdctsi, 0x1A, 0x0B, 0x00180000, 0x00180000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdctuf, efdctsf, 0x1B, 0x0B, 0x00180000, 0x00180000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdctuiz, speundef, 0x1C, 0x0B, 0x00180000, 0xFFFFFFFF, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdctsiz, speundef, 0x1D, 0x0B, 0x00180000, 0xFFFFFFFF, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdtstgt, efdtstlt, 0x1E, 0x0B, 0x00600000, 0x00600000, PPC_SPE_DOUBLE),
|
||||
GEN_SPE(efdtsteq, speundef, 0x1F, 0x0B, 0x00600000, 0xFFFFFFFF, PPC_SPE_DOUBLE),
|
||||
|
||||
#define GEN_SPEOP_LDST(name, opc2, sh) \
|
||||
GEN_HANDLER(name, 0x04, opc2, 0x0C, 0x00000000, PPC_SPE)
|
||||
GEN_SPEOP_LDST(evldd, 0x00, 3),
|
||||
GEN_SPEOP_LDST(evldw, 0x01, 3),
|
||||
GEN_SPEOP_LDST(evldh, 0x02, 3),
|
||||
GEN_SPEOP_LDST(evlhhesplat, 0x04, 1),
|
||||
GEN_SPEOP_LDST(evlhhousplat, 0x06, 1),
|
||||
GEN_SPEOP_LDST(evlhhossplat, 0x07, 1),
|
||||
GEN_SPEOP_LDST(evlwhe, 0x08, 2),
|
||||
GEN_SPEOP_LDST(evlwhou, 0x0A, 2),
|
||||
GEN_SPEOP_LDST(evlwhos, 0x0B, 2),
|
||||
GEN_SPEOP_LDST(evlwwsplat, 0x0C, 2),
|
||||
GEN_SPEOP_LDST(evlwhsplat, 0x0E, 2),
|
||||
|
||||
GEN_SPEOP_LDST(evstdd, 0x10, 3),
|
||||
GEN_SPEOP_LDST(evstdw, 0x11, 3),
|
||||
GEN_SPEOP_LDST(evstdh, 0x12, 3),
|
||||
GEN_SPEOP_LDST(evstwhe, 0x18, 2),
|
||||
GEN_SPEOP_LDST(evstwho, 0x1A, 2),
|
||||
GEN_SPEOP_LDST(evstwwe, 0x1C, 2),
|
||||
GEN_SPEOP_LDST(evstwwo, 0x1E, 2),
|
843
target-ppc/translate/vmx-impl.inc.c
Normal file
843
target-ppc/translate/vmx-impl.inc.c
Normal file
|
@ -0,0 +1,843 @@
|
|||
/*
|
||||
* translate/vmx-impl.c
|
||||
*
|
||||
* Altivec/VMX translation
|
||||
*/
|
||||
|
||||
/*** Altivec vector extension ***/
|
||||
/* Altivec registers moves */
|
||||
|
||||
static inline TCGv_ptr gen_avr_ptr(int reg)
|
||||
{
|
||||
TCGv_ptr r = tcg_temp_new_ptr();
|
||||
tcg_gen_addi_ptr(r, cpu_env, offsetof(CPUPPCState, avr[reg]));
|
||||
return r;
|
||||
}
|
||||
|
||||
#define GEN_VR_LDX(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv EA; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_set_access_type(ctx, ACCESS_INT); \
|
||||
EA = tcg_temp_new(); \
|
||||
gen_addr_reg_index(ctx, EA); \
|
||||
tcg_gen_andi_tl(EA, EA, ~0xf); \
|
||||
/* We only need to swap high and low halves. gen_qemu_ld64 does necessary \
|
||||
64-bit byteswap already. */ \
|
||||
if (ctx->le_mode) { \
|
||||
gen_qemu_ld64(ctx, cpu_avrl[rD(ctx->opcode)], EA); \
|
||||
tcg_gen_addi_tl(EA, EA, 8); \
|
||||
gen_qemu_ld64(ctx, cpu_avrh[rD(ctx->opcode)], EA); \
|
||||
} else { \
|
||||
gen_qemu_ld64(ctx, cpu_avrh[rD(ctx->opcode)], EA); \
|
||||
tcg_gen_addi_tl(EA, EA, 8); \
|
||||
gen_qemu_ld64(ctx, cpu_avrl[rD(ctx->opcode)], EA); \
|
||||
} \
|
||||
tcg_temp_free(EA); \
|
||||
}
|
||||
|
||||
#define GEN_VR_STX(name, opc2, opc3) \
|
||||
static void gen_st##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv EA; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_set_access_type(ctx, ACCESS_INT); \
|
||||
EA = tcg_temp_new(); \
|
||||
gen_addr_reg_index(ctx, EA); \
|
||||
tcg_gen_andi_tl(EA, EA, ~0xf); \
|
||||
/* We only need to swap high and low halves. gen_qemu_st64 does necessary \
|
||||
64-bit byteswap already. */ \
|
||||
if (ctx->le_mode) { \
|
||||
gen_qemu_st64(ctx, cpu_avrl[rD(ctx->opcode)], EA); \
|
||||
tcg_gen_addi_tl(EA, EA, 8); \
|
||||
gen_qemu_st64(ctx, cpu_avrh[rD(ctx->opcode)], EA); \
|
||||
} else { \
|
||||
gen_qemu_st64(ctx, cpu_avrh[rD(ctx->opcode)], EA); \
|
||||
tcg_gen_addi_tl(EA, EA, 8); \
|
||||
gen_qemu_st64(ctx, cpu_avrl[rD(ctx->opcode)], EA); \
|
||||
} \
|
||||
tcg_temp_free(EA); \
|
||||
}
|
||||
|
||||
#define GEN_VR_LVE(name, opc2, opc3, size) \
|
||||
static void gen_lve##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv EA; \
|
||||
TCGv_ptr rs; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_set_access_type(ctx, ACCESS_INT); \
|
||||
EA = tcg_temp_new(); \
|
||||
gen_addr_reg_index(ctx, EA); \
|
||||
if (size > 1) { \
|
||||
tcg_gen_andi_tl(EA, EA, ~(size - 1)); \
|
||||
} \
|
||||
rs = gen_avr_ptr(rS(ctx->opcode)); \
|
||||
gen_helper_lve##name(cpu_env, rs, EA); \
|
||||
tcg_temp_free(EA); \
|
||||
tcg_temp_free_ptr(rs); \
|
||||
}
|
||||
|
||||
#define GEN_VR_STVE(name, opc2, opc3, size) \
|
||||
static void gen_stve##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv EA; \
|
||||
TCGv_ptr rs; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
gen_set_access_type(ctx, ACCESS_INT); \
|
||||
EA = tcg_temp_new(); \
|
||||
gen_addr_reg_index(ctx, EA); \
|
||||
if (size > 1) { \
|
||||
tcg_gen_andi_tl(EA, EA, ~(size - 1)); \
|
||||
} \
|
||||
rs = gen_avr_ptr(rS(ctx->opcode)); \
|
||||
gen_helper_stve##name(cpu_env, rs, EA); \
|
||||
tcg_temp_free(EA); \
|
||||
tcg_temp_free_ptr(rs); \
|
||||
}
|
||||
|
||||
GEN_VR_LDX(lvx, 0x07, 0x03);
|
||||
/* As we don't emulate the cache, lvxl is stricly equivalent to lvx */
|
||||
GEN_VR_LDX(lvxl, 0x07, 0x0B);
|
||||
|
||||
GEN_VR_LVE(bx, 0x07, 0x00, 1);
|
||||
GEN_VR_LVE(hx, 0x07, 0x01, 2);
|
||||
GEN_VR_LVE(wx, 0x07, 0x02, 4);
|
||||
|
||||
GEN_VR_STX(svx, 0x07, 0x07);
|
||||
/* As we don't emulate the cache, stvxl is stricly equivalent to stvx */
|
||||
GEN_VR_STX(svxl, 0x07, 0x0F);
|
||||
|
||||
GEN_VR_STVE(bx, 0x07, 0x04, 1);
|
||||
GEN_VR_STVE(hx, 0x07, 0x05, 2);
|
||||
GEN_VR_STVE(wx, 0x07, 0x06, 4);
|
||||
|
||||
static void gen_lvsl(DisasContext *ctx)
|
||||
{
|
||||
TCGv_ptr rd;
|
||||
TCGv EA;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
EA = tcg_temp_new();
|
||||
gen_addr_reg_index(ctx, EA);
|
||||
rd = gen_avr_ptr(rD(ctx->opcode));
|
||||
gen_helper_lvsl(rd, EA);
|
||||
tcg_temp_free(EA);
|
||||
tcg_temp_free_ptr(rd);
|
||||
}
|
||||
|
||||
static void gen_lvsr(DisasContext *ctx)
|
||||
{
|
||||
TCGv_ptr rd;
|
||||
TCGv EA;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
EA = tcg_temp_new();
|
||||
gen_addr_reg_index(ctx, EA);
|
||||
rd = gen_avr_ptr(rD(ctx->opcode));
|
||||
gen_helper_lvsr(rd, EA);
|
||||
tcg_temp_free(EA);
|
||||
tcg_temp_free_ptr(rd);
|
||||
}
|
||||
|
||||
static void gen_mfvscr(DisasContext *ctx)
|
||||
{
|
||||
TCGv_i32 t;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
tcg_gen_movi_i64(cpu_avrh[rD(ctx->opcode)], 0);
|
||||
t = tcg_temp_new_i32();
|
||||
tcg_gen_ld_i32(t, cpu_env, offsetof(CPUPPCState, vscr));
|
||||
tcg_gen_extu_i32_i64(cpu_avrl[rD(ctx->opcode)], t);
|
||||
tcg_temp_free_i32(t);
|
||||
}
|
||||
|
||||
static void gen_mtvscr(DisasContext *ctx)
|
||||
{
|
||||
TCGv_ptr p;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
p = gen_avr_ptr(rB(ctx->opcode));
|
||||
gen_helper_mtvscr(cpu_env, p);
|
||||
tcg_temp_free_ptr(p);
|
||||
}
|
||||
|
||||
/* Logical operations */
|
||||
#define GEN_VX_LOGICAL(name, tcg_op, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
tcg_op(cpu_avrh[rD(ctx->opcode)], cpu_avrh[rA(ctx->opcode)], cpu_avrh[rB(ctx->opcode)]); \
|
||||
tcg_op(cpu_avrl[rD(ctx->opcode)], cpu_avrl[rA(ctx->opcode)], cpu_avrl[rB(ctx->opcode)]); \
|
||||
}
|
||||
|
||||
GEN_VX_LOGICAL(vand, tcg_gen_and_i64, 2, 16);
|
||||
GEN_VX_LOGICAL(vandc, tcg_gen_andc_i64, 2, 17);
|
||||
GEN_VX_LOGICAL(vor, tcg_gen_or_i64, 2, 18);
|
||||
GEN_VX_LOGICAL(vxor, tcg_gen_xor_i64, 2, 19);
|
||||
GEN_VX_LOGICAL(vnor, tcg_gen_nor_i64, 2, 20);
|
||||
GEN_VX_LOGICAL(veqv, tcg_gen_eqv_i64, 2, 26);
|
||||
GEN_VX_LOGICAL(vnand, tcg_gen_nand_i64, 2, 22);
|
||||
GEN_VX_LOGICAL(vorc, tcg_gen_orc_i64, 2, 21);
|
||||
|
||||
#define GEN_VXFORM(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra, rb, rd; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
ra = gen_avr_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name (rd, ra, rb); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
#define GEN_VXFORM_ENV(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra, rb, rd; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
ra = gen_avr_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_env, rd, ra, rb); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
#define GEN_VXFORM3(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra, rb, rc, rd; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
ra = gen_avr_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rc = gen_avr_ptr(rC(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name(rd, ra, rb, rc); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rc); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
/*
|
||||
* Support for Altivec instruction pairs that use bit 31 (Rc) as
|
||||
* an opcode bit. In general, these pairs come from different
|
||||
* versions of the ISA, so we must also support a pair of flags for
|
||||
* each instruction.
|
||||
*/
|
||||
#define GEN_VXFORM_DUAL(name0, flg0, flg2_0, name1, flg1, flg2_1) \
|
||||
static void glue(gen_, name0##_##name1)(DisasContext *ctx) \
|
||||
{ \
|
||||
if ((Rc(ctx->opcode) == 0) && \
|
||||
((ctx->insns_flags & flg0) || (ctx->insns_flags2 & flg2_0))) { \
|
||||
gen_##name0(ctx); \
|
||||
} else if ((Rc(ctx->opcode) == 1) && \
|
||||
((ctx->insns_flags & flg1) || (ctx->insns_flags2 & flg2_1))) { \
|
||||
gen_##name1(ctx); \
|
||||
} else { \
|
||||
gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
|
||||
} \
|
||||
}
|
||||
|
||||
GEN_VXFORM(vaddubm, 0, 0);
|
||||
GEN_VXFORM(vadduhm, 0, 1);
|
||||
GEN_VXFORM(vadduwm, 0, 2);
|
||||
GEN_VXFORM(vaddudm, 0, 3);
|
||||
GEN_VXFORM(vsububm, 0, 16);
|
||||
GEN_VXFORM(vsubuhm, 0, 17);
|
||||
GEN_VXFORM(vsubuwm, 0, 18);
|
||||
GEN_VXFORM(vsubudm, 0, 19);
|
||||
GEN_VXFORM(vmaxub, 1, 0);
|
||||
GEN_VXFORM(vmaxuh, 1, 1);
|
||||
GEN_VXFORM(vmaxuw, 1, 2);
|
||||
GEN_VXFORM(vmaxud, 1, 3);
|
||||
GEN_VXFORM(vmaxsb, 1, 4);
|
||||
GEN_VXFORM(vmaxsh, 1, 5);
|
||||
GEN_VXFORM(vmaxsw, 1, 6);
|
||||
GEN_VXFORM(vmaxsd, 1, 7);
|
||||
GEN_VXFORM(vminub, 1, 8);
|
||||
GEN_VXFORM(vminuh, 1, 9);
|
||||
GEN_VXFORM(vminuw, 1, 10);
|
||||
GEN_VXFORM(vminud, 1, 11);
|
||||
GEN_VXFORM(vminsb, 1, 12);
|
||||
GEN_VXFORM(vminsh, 1, 13);
|
||||
GEN_VXFORM(vminsw, 1, 14);
|
||||
GEN_VXFORM(vminsd, 1, 15);
|
||||
GEN_VXFORM(vavgub, 1, 16);
|
||||
GEN_VXFORM(vabsdub, 1, 16);
|
||||
GEN_VXFORM_DUAL(vavgub, PPC_ALTIVEC, PPC_NONE, \
|
||||
vabsdub, PPC_NONE, PPC2_ISA300)
|
||||
GEN_VXFORM(vavguh, 1, 17);
|
||||
GEN_VXFORM(vabsduh, 1, 17);
|
||||
GEN_VXFORM_DUAL(vavguh, PPC_ALTIVEC, PPC_NONE, \
|
||||
vabsduh, PPC_NONE, PPC2_ISA300)
|
||||
GEN_VXFORM(vavguw, 1, 18);
|
||||
GEN_VXFORM(vabsduw, 1, 18);
|
||||
GEN_VXFORM_DUAL(vavguw, PPC_ALTIVEC, PPC_NONE, \
|
||||
vabsduw, PPC_NONE, PPC2_ISA300)
|
||||
GEN_VXFORM(vavgsb, 1, 20);
|
||||
GEN_VXFORM(vavgsh, 1, 21);
|
||||
GEN_VXFORM(vavgsw, 1, 22);
|
||||
GEN_VXFORM(vmrghb, 6, 0);
|
||||
GEN_VXFORM(vmrghh, 6, 1);
|
||||
GEN_VXFORM(vmrghw, 6, 2);
|
||||
GEN_VXFORM(vmrglb, 6, 4);
|
||||
GEN_VXFORM(vmrglh, 6, 5);
|
||||
GEN_VXFORM(vmrglw, 6, 6);
|
||||
|
||||
static void gen_vmrgew(DisasContext *ctx)
|
||||
{
|
||||
TCGv_i64 tmp;
|
||||
int VT, VA, VB;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
VT = rD(ctx->opcode);
|
||||
VA = rA(ctx->opcode);
|
||||
VB = rB(ctx->opcode);
|
||||
tmp = tcg_temp_new_i64();
|
||||
tcg_gen_shri_i64(tmp, cpu_avrh[VB], 32);
|
||||
tcg_gen_deposit_i64(cpu_avrh[VT], cpu_avrh[VA], tmp, 0, 32);
|
||||
tcg_gen_shri_i64(tmp, cpu_avrl[VB], 32);
|
||||
tcg_gen_deposit_i64(cpu_avrl[VT], cpu_avrl[VA], tmp, 0, 32);
|
||||
tcg_temp_free_i64(tmp);
|
||||
}
|
||||
|
||||
static void gen_vmrgow(DisasContext *ctx)
|
||||
{
|
||||
int VT, VA, VB;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
VT = rD(ctx->opcode);
|
||||
VA = rA(ctx->opcode);
|
||||
VB = rB(ctx->opcode);
|
||||
|
||||
tcg_gen_deposit_i64(cpu_avrh[VT], cpu_avrh[VB], cpu_avrh[VA], 32, 32);
|
||||
tcg_gen_deposit_i64(cpu_avrl[VT], cpu_avrl[VB], cpu_avrl[VA], 32, 32);
|
||||
}
|
||||
|
||||
GEN_VXFORM(vmuloub, 4, 0);
|
||||
GEN_VXFORM(vmulouh, 4, 1);
|
||||
GEN_VXFORM(vmulouw, 4, 2);
|
||||
GEN_VXFORM(vmuluwm, 4, 2);
|
||||
GEN_VXFORM_DUAL(vmulouw, PPC_ALTIVEC, PPC_NONE,
|
||||
vmuluwm, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM(vmulosb, 4, 4);
|
||||
GEN_VXFORM(vmulosh, 4, 5);
|
||||
GEN_VXFORM(vmulosw, 4, 6);
|
||||
GEN_VXFORM(vmuleub, 4, 8);
|
||||
GEN_VXFORM(vmuleuh, 4, 9);
|
||||
GEN_VXFORM(vmuleuw, 4, 10);
|
||||
GEN_VXFORM(vmulesb, 4, 12);
|
||||
GEN_VXFORM(vmulesh, 4, 13);
|
||||
GEN_VXFORM(vmulesw, 4, 14);
|
||||
GEN_VXFORM(vslb, 2, 4);
|
||||
GEN_VXFORM(vslh, 2, 5);
|
||||
GEN_VXFORM(vslw, 2, 6);
|
||||
GEN_VXFORM(vsld, 2, 23);
|
||||
GEN_VXFORM(vsrb, 2, 8);
|
||||
GEN_VXFORM(vsrh, 2, 9);
|
||||
GEN_VXFORM(vsrw, 2, 10);
|
||||
GEN_VXFORM(vsrd, 2, 27);
|
||||
GEN_VXFORM(vsrab, 2, 12);
|
||||
GEN_VXFORM(vsrah, 2, 13);
|
||||
GEN_VXFORM(vsraw, 2, 14);
|
||||
GEN_VXFORM(vsrad, 2, 15);
|
||||
GEN_VXFORM(vsrv, 2, 28);
|
||||
GEN_VXFORM(vslv, 2, 29);
|
||||
GEN_VXFORM(vslo, 6, 16);
|
||||
GEN_VXFORM(vsro, 6, 17);
|
||||
GEN_VXFORM(vaddcuw, 0, 6);
|
||||
GEN_VXFORM(vsubcuw, 0, 22);
|
||||
GEN_VXFORM_ENV(vaddubs, 0, 8);
|
||||
GEN_VXFORM_ENV(vadduhs, 0, 9);
|
||||
GEN_VXFORM_ENV(vadduws, 0, 10);
|
||||
GEN_VXFORM_ENV(vaddsbs, 0, 12);
|
||||
GEN_VXFORM_ENV(vaddshs, 0, 13);
|
||||
GEN_VXFORM_ENV(vaddsws, 0, 14);
|
||||
GEN_VXFORM_ENV(vsububs, 0, 24);
|
||||
GEN_VXFORM_ENV(vsubuhs, 0, 25);
|
||||
GEN_VXFORM_ENV(vsubuws, 0, 26);
|
||||
GEN_VXFORM_ENV(vsubsbs, 0, 28);
|
||||
GEN_VXFORM_ENV(vsubshs, 0, 29);
|
||||
GEN_VXFORM_ENV(vsubsws, 0, 30);
|
||||
GEN_VXFORM(vadduqm, 0, 4);
|
||||
GEN_VXFORM(vaddcuq, 0, 5);
|
||||
GEN_VXFORM3(vaddeuqm, 30, 0);
|
||||
GEN_VXFORM3(vaddecuq, 30, 0);
|
||||
GEN_VXFORM_DUAL(vaddeuqm, PPC_NONE, PPC2_ALTIVEC_207, \
|
||||
vaddecuq, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM(vsubuqm, 0, 20);
|
||||
GEN_VXFORM(vsubcuq, 0, 21);
|
||||
GEN_VXFORM3(vsubeuqm, 31, 0);
|
||||
GEN_VXFORM3(vsubecuq, 31, 0);
|
||||
GEN_VXFORM_DUAL(vsubeuqm, PPC_NONE, PPC2_ALTIVEC_207, \
|
||||
vsubecuq, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM(vrlb, 2, 0);
|
||||
GEN_VXFORM(vrlh, 2, 1);
|
||||
GEN_VXFORM(vrlw, 2, 2);
|
||||
GEN_VXFORM(vrld, 2, 3);
|
||||
GEN_VXFORM(vsl, 2, 7);
|
||||
GEN_VXFORM(vsr, 2, 11);
|
||||
GEN_VXFORM_ENV(vpkuhum, 7, 0);
|
||||
GEN_VXFORM_ENV(vpkuwum, 7, 1);
|
||||
GEN_VXFORM_ENV(vpkudum, 7, 17);
|
||||
GEN_VXFORM_ENV(vpkuhus, 7, 2);
|
||||
GEN_VXFORM_ENV(vpkuwus, 7, 3);
|
||||
GEN_VXFORM_ENV(vpkudus, 7, 19);
|
||||
GEN_VXFORM_ENV(vpkshus, 7, 4);
|
||||
GEN_VXFORM_ENV(vpkswus, 7, 5);
|
||||
GEN_VXFORM_ENV(vpksdus, 7, 21);
|
||||
GEN_VXFORM_ENV(vpkshss, 7, 6);
|
||||
GEN_VXFORM_ENV(vpkswss, 7, 7);
|
||||
GEN_VXFORM_ENV(vpksdss, 7, 23);
|
||||
GEN_VXFORM(vpkpx, 7, 12);
|
||||
GEN_VXFORM_ENV(vsum4ubs, 4, 24);
|
||||
GEN_VXFORM_ENV(vsum4sbs, 4, 28);
|
||||
GEN_VXFORM_ENV(vsum4shs, 4, 25);
|
||||
GEN_VXFORM_ENV(vsum2sws, 4, 26);
|
||||
GEN_VXFORM_ENV(vsumsws, 4, 30);
|
||||
GEN_VXFORM_ENV(vaddfp, 5, 0);
|
||||
GEN_VXFORM_ENV(vsubfp, 5, 1);
|
||||
GEN_VXFORM_ENV(vmaxfp, 5, 16);
|
||||
GEN_VXFORM_ENV(vminfp, 5, 17);
|
||||
|
||||
#define GEN_VXRFORM1(opname, name, str, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra, rb, rd; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
ra = gen_avr_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##opname(cpu_env, rd, ra, rb); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
#define GEN_VXRFORM(name, opc2, opc3) \
|
||||
GEN_VXRFORM1(name, name, #name, opc2, opc3) \
|
||||
GEN_VXRFORM1(name##_dot, name##_, #name ".", opc2, (opc3 | (0x1 << 4)))
|
||||
|
||||
/*
|
||||
* Support for Altivec instructions that use bit 31 (Rc) as an opcode
|
||||
* bit but also use bit 21 as an actual Rc bit. In general, thse pairs
|
||||
* come from different versions of the ISA, so we must also support a
|
||||
* pair of flags for each instruction.
|
||||
*/
|
||||
#define GEN_VXRFORM_DUAL(name0, flg0, flg2_0, name1, flg1, flg2_1) \
|
||||
static void glue(gen_, name0##_##name1)(DisasContext *ctx) \
|
||||
{ \
|
||||
if ((Rc(ctx->opcode) == 0) && \
|
||||
((ctx->insns_flags & flg0) || (ctx->insns_flags2 & flg2_0))) { \
|
||||
if (Rc21(ctx->opcode) == 0) { \
|
||||
gen_##name0(ctx); \
|
||||
} else { \
|
||||
gen_##name0##_(ctx); \
|
||||
} \
|
||||
} else if ((Rc(ctx->opcode) == 1) && \
|
||||
((ctx->insns_flags & flg1) || (ctx->insns_flags2 & flg2_1))) { \
|
||||
if (Rc21(ctx->opcode) == 0) { \
|
||||
gen_##name1(ctx); \
|
||||
} else { \
|
||||
gen_##name1##_(ctx); \
|
||||
} \
|
||||
} else { \
|
||||
gen_inval_exception(ctx, POWERPC_EXCP_INVAL_INVAL); \
|
||||
} \
|
||||
}
|
||||
|
||||
GEN_VXRFORM(vcmpequb, 3, 0)
|
||||
GEN_VXRFORM(vcmpequh, 3, 1)
|
||||
GEN_VXRFORM(vcmpequw, 3, 2)
|
||||
GEN_VXRFORM(vcmpequd, 3, 3)
|
||||
GEN_VXRFORM(vcmpnezb, 3, 4)
|
||||
GEN_VXRFORM(vcmpnezh, 3, 5)
|
||||
GEN_VXRFORM(vcmpnezw, 3, 6)
|
||||
GEN_VXRFORM(vcmpgtsb, 3, 12)
|
||||
GEN_VXRFORM(vcmpgtsh, 3, 13)
|
||||
GEN_VXRFORM(vcmpgtsw, 3, 14)
|
||||
GEN_VXRFORM(vcmpgtsd, 3, 15)
|
||||
GEN_VXRFORM(vcmpgtub, 3, 8)
|
||||
GEN_VXRFORM(vcmpgtuh, 3, 9)
|
||||
GEN_VXRFORM(vcmpgtuw, 3, 10)
|
||||
GEN_VXRFORM(vcmpgtud, 3, 11)
|
||||
GEN_VXRFORM(vcmpeqfp, 3, 3)
|
||||
GEN_VXRFORM(vcmpgefp, 3, 7)
|
||||
GEN_VXRFORM(vcmpgtfp, 3, 11)
|
||||
GEN_VXRFORM(vcmpbfp, 3, 15)
|
||||
|
||||
GEN_VXRFORM_DUAL(vcmpeqfp, PPC_ALTIVEC, PPC_NONE, \
|
||||
vcmpequd, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXRFORM_DUAL(vcmpbfp, PPC_ALTIVEC, PPC_NONE, \
|
||||
vcmpgtsd, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXRFORM_DUAL(vcmpgtfp, PPC_ALTIVEC, PPC_NONE, \
|
||||
vcmpgtud, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
|
||||
#define GEN_VXFORM_SIMM(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rd; \
|
||||
TCGv_i32 simm; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
simm = tcg_const_i32(SIMM5(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name (rd, simm); \
|
||||
tcg_temp_free_i32(simm); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
GEN_VXFORM_SIMM(vspltisb, 6, 12);
|
||||
GEN_VXFORM_SIMM(vspltish, 6, 13);
|
||||
GEN_VXFORM_SIMM(vspltisw, 6, 14);
|
||||
|
||||
#define GEN_VXFORM_NOA(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rb, rd; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name (rd, rb); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
#define GEN_VXFORM_NOA_ENV(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rb, rd; \
|
||||
\
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_env, rd, rb); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
GEN_VXFORM_NOA(vupkhsb, 7, 8);
|
||||
GEN_VXFORM_NOA(vupkhsh, 7, 9);
|
||||
GEN_VXFORM_NOA(vupkhsw, 7, 25);
|
||||
GEN_VXFORM_NOA(vupklsb, 7, 10);
|
||||
GEN_VXFORM_NOA(vupklsh, 7, 11);
|
||||
GEN_VXFORM_NOA(vupklsw, 7, 27);
|
||||
GEN_VXFORM_NOA(vupkhpx, 7, 13);
|
||||
GEN_VXFORM_NOA(vupklpx, 7, 15);
|
||||
GEN_VXFORM_NOA_ENV(vrefp, 5, 4);
|
||||
GEN_VXFORM_NOA_ENV(vrsqrtefp, 5, 5);
|
||||
GEN_VXFORM_NOA_ENV(vexptefp, 5, 6);
|
||||
GEN_VXFORM_NOA_ENV(vlogefp, 5, 7);
|
||||
GEN_VXFORM_NOA_ENV(vrfim, 5, 11);
|
||||
GEN_VXFORM_NOA_ENV(vrfin, 5, 8);
|
||||
GEN_VXFORM_NOA_ENV(vrfip, 5, 10);
|
||||
GEN_VXFORM_NOA_ENV(vrfiz, 5, 9);
|
||||
|
||||
#define GEN_VXFORM_SIMM(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rd; \
|
||||
TCGv_i32 simm; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
simm = tcg_const_i32(SIMM5(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name (rd, simm); \
|
||||
tcg_temp_free_i32(simm); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
#define GEN_VXFORM_UIMM(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rb, rd; \
|
||||
TCGv_i32 uimm; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
uimm = tcg_const_i32(UIMM5(ctx->opcode)); \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name (rd, rb, uimm); \
|
||||
tcg_temp_free_i32(uimm); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
#define GEN_VXFORM_UIMM_ENV(name, opc2, opc3) \
|
||||
static void glue(gen_, name)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr rb, rd; \
|
||||
TCGv_i32 uimm; \
|
||||
\
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
uimm = tcg_const_i32(UIMM5(ctx->opcode)); \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
gen_helper_##name(cpu_env, rd, rb, uimm); \
|
||||
tcg_temp_free_i32(uimm); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
GEN_VXFORM_UIMM(vspltb, 6, 8);
|
||||
GEN_VXFORM_UIMM(vsplth, 6, 9);
|
||||
GEN_VXFORM_UIMM(vspltw, 6, 10);
|
||||
GEN_VXFORM_UIMM_ENV(vcfux, 5, 12);
|
||||
GEN_VXFORM_UIMM_ENV(vcfsx, 5, 13);
|
||||
GEN_VXFORM_UIMM_ENV(vctuxs, 5, 14);
|
||||
GEN_VXFORM_UIMM_ENV(vctsxs, 5, 15);
|
||||
|
||||
static void gen_vsldoi(DisasContext *ctx)
|
||||
{
|
||||
TCGv_ptr ra, rb, rd;
|
||||
TCGv_i32 sh;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
ra = gen_avr_ptr(rA(ctx->opcode));
|
||||
rb = gen_avr_ptr(rB(ctx->opcode));
|
||||
rd = gen_avr_ptr(rD(ctx->opcode));
|
||||
sh = tcg_const_i32(VSH(ctx->opcode));
|
||||
gen_helper_vsldoi (rd, ra, rb, sh);
|
||||
tcg_temp_free_ptr(ra);
|
||||
tcg_temp_free_ptr(rb);
|
||||
tcg_temp_free_ptr(rd);
|
||||
tcg_temp_free_i32(sh);
|
||||
}
|
||||
|
||||
#define GEN_VAFORM_PAIRED(name0, name1, opc2) \
|
||||
static void glue(gen_, name0##_##name1)(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra, rb, rc, rd; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
ra = gen_avr_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rc = gen_avr_ptr(rC(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
if (Rc(ctx->opcode)) { \
|
||||
gen_helper_##name1(cpu_env, rd, ra, rb, rc); \
|
||||
} else { \
|
||||
gen_helper_##name0(cpu_env, rd, ra, rb, rc); \
|
||||
} \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rc); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
}
|
||||
|
||||
GEN_VAFORM_PAIRED(vmhaddshs, vmhraddshs, 16)
|
||||
|
||||
static void gen_vmladduhm(DisasContext *ctx)
|
||||
{
|
||||
TCGv_ptr ra, rb, rc, rd;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
ra = gen_avr_ptr(rA(ctx->opcode));
|
||||
rb = gen_avr_ptr(rB(ctx->opcode));
|
||||
rc = gen_avr_ptr(rC(ctx->opcode));
|
||||
rd = gen_avr_ptr(rD(ctx->opcode));
|
||||
gen_helper_vmladduhm(rd, ra, rb, rc);
|
||||
tcg_temp_free_ptr(ra);
|
||||
tcg_temp_free_ptr(rb);
|
||||
tcg_temp_free_ptr(rc);
|
||||
tcg_temp_free_ptr(rd);
|
||||
}
|
||||
|
||||
GEN_VAFORM_PAIRED(vmsumubm, vmsummbm, 18)
|
||||
GEN_VAFORM_PAIRED(vmsumuhm, vmsumuhs, 19)
|
||||
GEN_VAFORM_PAIRED(vmsumshm, vmsumshs, 20)
|
||||
GEN_VAFORM_PAIRED(vsel, vperm, 21)
|
||||
GEN_VAFORM_PAIRED(vmaddfp, vnmsubfp, 23)
|
||||
|
||||
GEN_VXFORM_NOA(vclzb, 1, 28)
|
||||
GEN_VXFORM_NOA(vclzh, 1, 29)
|
||||
GEN_VXFORM_NOA(vclzw, 1, 30)
|
||||
GEN_VXFORM_NOA(vclzd, 1, 31)
|
||||
GEN_VXFORM_NOA(vpopcntb, 1, 28)
|
||||
GEN_VXFORM_NOA(vpopcnth, 1, 29)
|
||||
GEN_VXFORM_NOA(vpopcntw, 1, 30)
|
||||
GEN_VXFORM_NOA(vpopcntd, 1, 31)
|
||||
GEN_VXFORM_DUAL(vclzb, PPC_NONE, PPC2_ALTIVEC_207, \
|
||||
vpopcntb, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM_DUAL(vclzh, PPC_NONE, PPC2_ALTIVEC_207, \
|
||||
vpopcnth, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM_DUAL(vclzw, PPC_NONE, PPC2_ALTIVEC_207, \
|
||||
vpopcntw, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM_DUAL(vclzd, PPC_NONE, PPC2_ALTIVEC_207, \
|
||||
vpopcntd, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM(vbpermq, 6, 21);
|
||||
GEN_VXFORM_NOA(vgbbd, 6, 20);
|
||||
GEN_VXFORM(vpmsumb, 4, 16)
|
||||
GEN_VXFORM(vpmsumh, 4, 17)
|
||||
GEN_VXFORM(vpmsumw, 4, 18)
|
||||
GEN_VXFORM(vpmsumd, 4, 19)
|
||||
|
||||
#define GEN_BCD(op) \
|
||||
static void gen_##op(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra, rb, rd; \
|
||||
TCGv_i32 ps; \
|
||||
\
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
\
|
||||
ra = gen_avr_ptr(rA(ctx->opcode)); \
|
||||
rb = gen_avr_ptr(rB(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
\
|
||||
ps = tcg_const_i32((ctx->opcode & 0x200) != 0); \
|
||||
\
|
||||
gen_helper_##op(cpu_crf[6], rd, ra, rb, ps); \
|
||||
\
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rb); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
tcg_temp_free_i32(ps); \
|
||||
}
|
||||
|
||||
GEN_BCD(bcdadd)
|
||||
GEN_BCD(bcdsub)
|
||||
|
||||
GEN_VXFORM_DUAL(vsububm, PPC_ALTIVEC, PPC_NONE, \
|
||||
bcdadd, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM_DUAL(vsububs, PPC_ALTIVEC, PPC_NONE, \
|
||||
bcdadd, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM_DUAL(vsubuhm, PPC_ALTIVEC, PPC_NONE, \
|
||||
bcdsub, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM_DUAL(vsubuhs, PPC_ALTIVEC, PPC_NONE, \
|
||||
bcdsub, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
|
||||
static void gen_vsbox(DisasContext *ctx)
|
||||
{
|
||||
TCGv_ptr ra, rd;
|
||||
if (unlikely(!ctx->altivec_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU);
|
||||
return;
|
||||
}
|
||||
ra = gen_avr_ptr(rA(ctx->opcode));
|
||||
rd = gen_avr_ptr(rD(ctx->opcode));
|
||||
gen_helper_vsbox(rd, ra);
|
||||
tcg_temp_free_ptr(ra);
|
||||
tcg_temp_free_ptr(rd);
|
||||
}
|
||||
|
||||
GEN_VXFORM(vcipher, 4, 20)
|
||||
GEN_VXFORM(vcipherlast, 4, 20)
|
||||
GEN_VXFORM(vncipher, 4, 21)
|
||||
GEN_VXFORM(vncipherlast, 4, 21)
|
||||
|
||||
GEN_VXFORM_DUAL(vcipher, PPC_NONE, PPC2_ALTIVEC_207,
|
||||
vcipherlast, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
GEN_VXFORM_DUAL(vncipher, PPC_NONE, PPC2_ALTIVEC_207,
|
||||
vncipherlast, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
|
||||
#define VSHASIGMA(op) \
|
||||
static void gen_##op(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv_ptr ra, rd; \
|
||||
TCGv_i32 st_six; \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
ra = gen_avr_ptr(rA(ctx->opcode)); \
|
||||
rd = gen_avr_ptr(rD(ctx->opcode)); \
|
||||
st_six = tcg_const_i32(rB(ctx->opcode)); \
|
||||
gen_helper_##op(rd, ra, st_six); \
|
||||
tcg_temp_free_ptr(ra); \
|
||||
tcg_temp_free_ptr(rd); \
|
||||
tcg_temp_free_i32(st_six); \
|
||||
}
|
||||
|
||||
VSHASIGMA(vshasigmaw)
|
||||
VSHASIGMA(vshasigmad)
|
||||
|
||||
GEN_VXFORM3(vpermxor, 22, 0xFF)
|
||||
GEN_VXFORM_DUAL(vsldoi, PPC_ALTIVEC, PPC_NONE,
|
||||
vpermxor, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
|
||||
#undef GEN_VR_LDX
|
||||
#undef GEN_VR_STX
|
||||
#undef GEN_VR_LVE
|
||||
#undef GEN_VR_STVE
|
||||
|
||||
#undef GEN_VX_LOGICAL
|
||||
#undef GEN_VX_LOGICAL_207
|
||||
#undef GEN_VXFORM
|
||||
#undef GEN_VXFORM_207
|
||||
#undef GEN_VXFORM_DUAL
|
||||
#undef GEN_VXRFORM_DUAL
|
||||
#undef GEN_VXRFORM1
|
||||
#undef GEN_VXRFORM
|
||||
#undef GEN_VXFORM_SIMM
|
||||
#undef GEN_VXFORM_NOA
|
||||
#undef GEN_VXFORM_UIMM
|
||||
#undef GEN_VAFORM_PAIRED
|
259
target-ppc/translate/vmx-ops.inc.c
Normal file
259
target-ppc/translate/vmx-ops.inc.c
Normal file
|
@ -0,0 +1,259 @@
|
|||
#define GEN_VR_LDX(name, opc2, opc3) \
|
||||
GEN_HANDLER(name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)
|
||||
#define GEN_VR_STX(name, opc2, opc3) \
|
||||
GEN_HANDLER(st##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)
|
||||
#define GEN_VR_LVE(name, opc2, opc3) \
|
||||
GEN_HANDLER(lve##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)
|
||||
#define GEN_VR_STVE(name, opc2, opc3) \
|
||||
GEN_HANDLER(stve##name, 0x1F, opc2, opc3, 0x00000001, PPC_ALTIVEC)
|
||||
GEN_VR_LDX(lvx, 0x07, 0x03),
|
||||
GEN_VR_LDX(lvxl, 0x07, 0x0B),
|
||||
GEN_VR_LVE(bx, 0x07, 0x00),
|
||||
GEN_VR_LVE(hx, 0x07, 0x01),
|
||||
GEN_VR_LVE(wx, 0x07, 0x02),
|
||||
GEN_VR_STX(svx, 0x07, 0x07),
|
||||
GEN_VR_STX(svxl, 0x07, 0x0F),
|
||||
GEN_VR_STVE(bx, 0x07, 0x04),
|
||||
GEN_VR_STVE(hx, 0x07, 0x05),
|
||||
GEN_VR_STVE(wx, 0x07, 0x06),
|
||||
|
||||
#define GEN_VX_LOGICAL(name, tcg_op, opc2, opc3) \
|
||||
GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_ALTIVEC)
|
||||
|
||||
#define GEN_VX_LOGICAL_207(name, tcg_op, opc2, opc3) \
|
||||
GEN_HANDLER_E(name, 0x04, opc2, opc3, 0x00000000, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
|
||||
GEN_VX_LOGICAL(vand, tcg_gen_and_i64, 2, 16),
|
||||
GEN_VX_LOGICAL(vandc, tcg_gen_andc_i64, 2, 17),
|
||||
GEN_VX_LOGICAL(vor, tcg_gen_or_i64, 2, 18),
|
||||
GEN_VX_LOGICAL(vxor, tcg_gen_xor_i64, 2, 19),
|
||||
GEN_VX_LOGICAL(vnor, tcg_gen_nor_i64, 2, 20),
|
||||
GEN_VX_LOGICAL_207(veqv, tcg_gen_eqv_i64, 2, 26),
|
||||
GEN_VX_LOGICAL_207(vnand, tcg_gen_nand_i64, 2, 22),
|
||||
GEN_VX_LOGICAL_207(vorc, tcg_gen_orc_i64, 2, 21),
|
||||
|
||||
#define GEN_VXFORM(name, opc2, opc3) \
|
||||
GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_ALTIVEC)
|
||||
|
||||
#define GEN_VXFORM_207(name, opc2, opc3) \
|
||||
GEN_HANDLER_E(name, 0x04, opc2, opc3, 0x00000000, PPC_NONE, PPC2_ALTIVEC_207)
|
||||
|
||||
#define GEN_VXFORM_300(name, opc2, opc3) \
|
||||
GEN_HANDLER_E(name, 0x04, opc2, opc3, 0x00000000, PPC_NONE, PPC2_ISA300)
|
||||
|
||||
#define GEN_VXFORM_DUAL(name0, name1, opc2, opc3, type0, type1) \
|
||||
GEN_HANDLER_E(name0##_##name1, 0x4, opc2, opc3, 0x00000000, type0, type1)
|
||||
|
||||
#define GEN_VXRFORM_DUAL(name0, name1, opc2, opc3, tp0, tp1) \
|
||||
GEN_HANDLER_E(name0##_##name1, 0x4, opc2, opc3, 0x00000000, tp0, tp1), \
|
||||
GEN_HANDLER_E(name0##_##name1, 0x4, opc2, (opc3 | 0x10), 0x00000000, tp0, tp1),
|
||||
|
||||
GEN_VXFORM(vaddubm, 0, 0),
|
||||
GEN_VXFORM(vadduhm, 0, 1),
|
||||
GEN_VXFORM(vadduwm, 0, 2),
|
||||
GEN_VXFORM_207(vaddudm, 0, 3),
|
||||
GEN_VXFORM_DUAL(vsububm, bcdadd, 0, 16, PPC_ALTIVEC, PPC_NONE),
|
||||
GEN_VXFORM_DUAL(vsubuhm, bcdsub, 0, 17, PPC_ALTIVEC, PPC_NONE),
|
||||
GEN_VXFORM(vsubuwm, 0, 18),
|
||||
GEN_VXFORM_207(vsubudm, 0, 19),
|
||||
GEN_VXFORM(vmaxub, 1, 0),
|
||||
GEN_VXFORM(vmaxuh, 1, 1),
|
||||
GEN_VXFORM(vmaxuw, 1, 2),
|
||||
GEN_VXFORM_207(vmaxud, 1, 3),
|
||||
GEN_VXFORM(vmaxsb, 1, 4),
|
||||
GEN_VXFORM(vmaxsh, 1, 5),
|
||||
GEN_VXFORM(vmaxsw, 1, 6),
|
||||
GEN_VXFORM_207(vmaxsd, 1, 7),
|
||||
GEN_VXFORM(vminub, 1, 8),
|
||||
GEN_VXFORM(vminuh, 1, 9),
|
||||
GEN_VXFORM(vminuw, 1, 10),
|
||||
GEN_VXFORM_207(vminud, 1, 11),
|
||||
GEN_VXFORM(vminsb, 1, 12),
|
||||
GEN_VXFORM(vminsh, 1, 13),
|
||||
GEN_VXFORM(vminsw, 1, 14),
|
||||
GEN_VXFORM_207(vminsd, 1, 15),
|
||||
GEN_VXFORM_DUAL(vavgub, vabsdub, 1, 16, PPC_ALTIVEC, PPC_NONE),
|
||||
GEN_VXFORM_DUAL(vavguh, vabsduh, 1, 17, PPC_ALTIVEC, PPC_NONE),
|
||||
GEN_VXFORM_DUAL(vavguw, vabsduw, 1, 18, PPC_ALTIVEC, PPC_NONE),
|
||||
GEN_VXFORM(vavgsb, 1, 20),
|
||||
GEN_VXFORM(vavgsh, 1, 21),
|
||||
GEN_VXFORM(vavgsw, 1, 22),
|
||||
GEN_VXFORM(vmrghb, 6, 0),
|
||||
GEN_VXFORM(vmrghh, 6, 1),
|
||||
GEN_VXFORM(vmrghw, 6, 2),
|
||||
GEN_VXFORM(vmrglb, 6, 4),
|
||||
GEN_VXFORM(vmrglh, 6, 5),
|
||||
GEN_VXFORM(vmrglw, 6, 6),
|
||||
GEN_VXFORM_207(vmrgew, 6, 30),
|
||||
GEN_VXFORM_207(vmrgow, 6, 26),
|
||||
GEN_VXFORM(vmuloub, 4, 0),
|
||||
GEN_VXFORM(vmulouh, 4, 1),
|
||||
GEN_VXFORM_DUAL(vmulouw, vmuluwm, 4, 2, PPC_ALTIVEC, PPC_NONE),
|
||||
GEN_VXFORM(vmulosb, 4, 4),
|
||||
GEN_VXFORM(vmulosh, 4, 5),
|
||||
GEN_VXFORM_207(vmulosw, 4, 6),
|
||||
GEN_VXFORM(vmuleub, 4, 8),
|
||||
GEN_VXFORM(vmuleuh, 4, 9),
|
||||
GEN_VXFORM_207(vmuleuw, 4, 10),
|
||||
GEN_VXFORM(vmulesb, 4, 12),
|
||||
GEN_VXFORM(vmulesh, 4, 13),
|
||||
GEN_VXFORM_207(vmulesw, 4, 14),
|
||||
GEN_VXFORM(vslb, 2, 4),
|
||||
GEN_VXFORM(vslh, 2, 5),
|
||||
GEN_VXFORM(vslw, 2, 6),
|
||||
GEN_VXFORM_207(vsld, 2, 23),
|
||||
GEN_VXFORM(vsrb, 2, 8),
|
||||
GEN_VXFORM(vsrh, 2, 9),
|
||||
GEN_VXFORM(vsrw, 2, 10),
|
||||
GEN_VXFORM_207(vsrd, 2, 27),
|
||||
GEN_VXFORM(vsrab, 2, 12),
|
||||
GEN_VXFORM(vsrah, 2, 13),
|
||||
GEN_VXFORM(vsraw, 2, 14),
|
||||
GEN_VXFORM_207(vsrad, 2, 15),
|
||||
GEN_VXFORM_300(vsrv, 2, 28),
|
||||
GEN_VXFORM_300(vslv, 2, 29),
|
||||
GEN_VXFORM(vslo, 6, 16),
|
||||
GEN_VXFORM(vsro, 6, 17),
|
||||
GEN_VXFORM(vaddcuw, 0, 6),
|
||||
GEN_VXFORM(vsubcuw, 0, 22),
|
||||
GEN_VXFORM(vaddubs, 0, 8),
|
||||
GEN_VXFORM(vadduhs, 0, 9),
|
||||
GEN_VXFORM(vadduws, 0, 10),
|
||||
GEN_VXFORM(vaddsbs, 0, 12),
|
||||
GEN_VXFORM(vaddshs, 0, 13),
|
||||
GEN_VXFORM(vaddsws, 0, 14),
|
||||
GEN_VXFORM_DUAL(vsububs, bcdadd, 0, 24, PPC_ALTIVEC, PPC_NONE),
|
||||
GEN_VXFORM_DUAL(vsubuhs, bcdsub, 0, 25, PPC_ALTIVEC, PPC_NONE),
|
||||
GEN_VXFORM(vsubuws, 0, 26),
|
||||
GEN_VXFORM(vsubsbs, 0, 28),
|
||||
GEN_VXFORM(vsubshs, 0, 29),
|
||||
GEN_VXFORM(vsubsws, 0, 30),
|
||||
GEN_VXFORM_207(vadduqm, 0, 4),
|
||||
GEN_VXFORM_207(vaddcuq, 0, 5),
|
||||
GEN_VXFORM_DUAL(vaddeuqm, vaddecuq, 30, 0xFF, PPC_NONE, PPC2_ALTIVEC_207),
|
||||
GEN_VXFORM_207(vsubuqm, 0, 20),
|
||||
GEN_VXFORM_207(vsubcuq, 0, 21),
|
||||
GEN_VXFORM_DUAL(vsubeuqm, vsubecuq, 31, 0xFF, PPC_NONE, PPC2_ALTIVEC_207),
|
||||
GEN_VXFORM(vrlb, 2, 0),
|
||||
GEN_VXFORM(vrlh, 2, 1),
|
||||
GEN_VXFORM(vrlw, 2, 2),
|
||||
GEN_VXFORM_207(vrld, 2, 3),
|
||||
GEN_VXFORM(vsl, 2, 7),
|
||||
GEN_VXFORM(vsr, 2, 11),
|
||||
GEN_VXFORM(vpkuhum, 7, 0),
|
||||
GEN_VXFORM(vpkuwum, 7, 1),
|
||||
GEN_VXFORM_207(vpkudum, 7, 17),
|
||||
GEN_VXFORM(vpkuhus, 7, 2),
|
||||
GEN_VXFORM(vpkuwus, 7, 3),
|
||||
GEN_VXFORM_207(vpkudus, 7, 19),
|
||||
GEN_VXFORM(vpkshus, 7, 4),
|
||||
GEN_VXFORM(vpkswus, 7, 5),
|
||||
GEN_VXFORM_207(vpksdus, 7, 21),
|
||||
GEN_VXFORM(vpkshss, 7, 6),
|
||||
GEN_VXFORM(vpkswss, 7, 7),
|
||||
GEN_VXFORM_207(vpksdss, 7, 23),
|
||||
GEN_VXFORM(vpkpx, 7, 12),
|
||||
GEN_VXFORM(vsum4ubs, 4, 24),
|
||||
GEN_VXFORM(vsum4sbs, 4, 28),
|
||||
GEN_VXFORM(vsum4shs, 4, 25),
|
||||
GEN_VXFORM(vsum2sws, 4, 26),
|
||||
GEN_VXFORM(vsumsws, 4, 30),
|
||||
GEN_VXFORM(vaddfp, 5, 0),
|
||||
GEN_VXFORM(vsubfp, 5, 1),
|
||||
GEN_VXFORM(vmaxfp, 5, 16),
|
||||
GEN_VXFORM(vminfp, 5, 17),
|
||||
|
||||
#define GEN_VXRFORM1(opname, name, str, opc2, opc3) \
|
||||
GEN_HANDLER2(name, str, 0x4, opc2, opc3, 0x00000000, PPC_ALTIVEC),
|
||||
#define GEN_VXRFORM1_300(opname, name, str, opc2, opc3) \
|
||||
GEN_HANDLER2_E(name, str, 0x4, opc2, opc3, 0x00000000, PPC_NONE, PPC2_ISA300),
|
||||
#define GEN_VXRFORM(name, opc2, opc3) \
|
||||
GEN_VXRFORM1(name, name, #name, opc2, opc3) \
|
||||
GEN_VXRFORM1(name##_dot, name##_, #name ".", opc2, (opc3 | (0x1 << 4)))
|
||||
#define GEN_VXRFORM_300(name, opc2, opc3) \
|
||||
GEN_VXRFORM1_300(name, name, #name, opc2, opc3) \
|
||||
GEN_VXRFORM1_300(name##_dot, name##_, #name ".", opc2, (opc3 | (0x1 << 4)))
|
||||
|
||||
GEN_VXRFORM(vcmpequb, 3, 0)
|
||||
GEN_VXRFORM(vcmpequh, 3, 1)
|
||||
GEN_VXRFORM(vcmpequw, 3, 2)
|
||||
GEN_VXRFORM_300(vcmpnezb, 3, 4)
|
||||
GEN_VXRFORM_300(vcmpnezh, 3, 5)
|
||||
GEN_VXRFORM_300(vcmpnezw, 3, 6)
|
||||
GEN_VXRFORM(vcmpgtsb, 3, 12)
|
||||
GEN_VXRFORM(vcmpgtsh, 3, 13)
|
||||
GEN_VXRFORM(vcmpgtsw, 3, 14)
|
||||
GEN_VXRFORM(vcmpgtub, 3, 8)
|
||||
GEN_VXRFORM(vcmpgtuh, 3, 9)
|
||||
GEN_VXRFORM(vcmpgtuw, 3, 10)
|
||||
GEN_VXRFORM_DUAL(vcmpeqfp, vcmpequd, 3, 3, PPC_ALTIVEC, PPC_NONE)
|
||||
GEN_VXRFORM(vcmpgefp, 3, 7)
|
||||
GEN_VXRFORM_DUAL(vcmpgtfp, vcmpgtud, 3, 11, PPC_ALTIVEC, PPC_NONE)
|
||||
GEN_VXRFORM_DUAL(vcmpbfp, vcmpgtsd, 3, 15, PPC_ALTIVEC, PPC_NONE)
|
||||
|
||||
#define GEN_VXFORM_SIMM(name, opc2, opc3) \
|
||||
GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_ALTIVEC)
|
||||
GEN_VXFORM_SIMM(vspltisb, 6, 12),
|
||||
GEN_VXFORM_SIMM(vspltish, 6, 13),
|
||||
GEN_VXFORM_SIMM(vspltisw, 6, 14),
|
||||
|
||||
#define GEN_VXFORM_NOA(name, opc2, opc3) \
|
||||
GEN_HANDLER(name, 0x04, opc2, opc3, 0x001f0000, PPC_ALTIVEC)
|
||||
GEN_VXFORM_NOA(vupkhsb, 7, 8),
|
||||
GEN_VXFORM_NOA(vupkhsh, 7, 9),
|
||||
GEN_VXFORM_207(vupkhsw, 7, 25),
|
||||
GEN_VXFORM_NOA(vupklsb, 7, 10),
|
||||
GEN_VXFORM_NOA(vupklsh, 7, 11),
|
||||
GEN_VXFORM_207(vupklsw, 7, 27),
|
||||
GEN_VXFORM_NOA(vupkhpx, 7, 13),
|
||||
GEN_VXFORM_NOA(vupklpx, 7, 15),
|
||||
GEN_VXFORM_NOA(vrefp, 5, 4),
|
||||
GEN_VXFORM_NOA(vrsqrtefp, 5, 5),
|
||||
GEN_VXFORM_NOA(vexptefp, 5, 6),
|
||||
GEN_VXFORM_NOA(vlogefp, 5, 7),
|
||||
GEN_VXFORM_NOA(vrfim, 5, 11),
|
||||
GEN_VXFORM_NOA(vrfin, 5, 8),
|
||||
GEN_VXFORM_NOA(vrfip, 5, 10),
|
||||
GEN_VXFORM_NOA(vrfiz, 5, 9),
|
||||
|
||||
#define GEN_VXFORM_UIMM(name, opc2, opc3) \
|
||||
GEN_HANDLER(name, 0x04, opc2, opc3, 0x00000000, PPC_ALTIVEC)
|
||||
GEN_VXFORM_UIMM(vspltb, 6, 8),
|
||||
GEN_VXFORM_UIMM(vsplth, 6, 9),
|
||||
GEN_VXFORM_UIMM(vspltw, 6, 10),
|
||||
GEN_VXFORM_UIMM(vcfux, 5, 12),
|
||||
GEN_VXFORM_UIMM(vcfsx, 5, 13),
|
||||
GEN_VXFORM_UIMM(vctuxs, 5, 14),
|
||||
GEN_VXFORM_UIMM(vctsxs, 5, 15),
|
||||
|
||||
|
||||
#define GEN_VAFORM_PAIRED(name0, name1, opc2) \
|
||||
GEN_HANDLER(name0##_##name1, 0x04, opc2, 0xFF, 0x00000000, PPC_ALTIVEC)
|
||||
GEN_VAFORM_PAIRED(vmhaddshs, vmhraddshs, 16),
|
||||
GEN_VAFORM_PAIRED(vmsumubm, vmsummbm, 18),
|
||||
GEN_VAFORM_PAIRED(vmsumuhm, vmsumuhs, 19),
|
||||
GEN_VAFORM_PAIRED(vmsumshm, vmsumshs, 20),
|
||||
GEN_VAFORM_PAIRED(vsel, vperm, 21),
|
||||
GEN_VAFORM_PAIRED(vmaddfp, vnmsubfp, 23),
|
||||
|
||||
GEN_VXFORM_DUAL(vclzb, vpopcntb, 1, 28, PPC_NONE, PPC2_ALTIVEC_207),
|
||||
GEN_VXFORM_DUAL(vclzh, vpopcnth, 1, 29, PPC_NONE, PPC2_ALTIVEC_207),
|
||||
GEN_VXFORM_DUAL(vclzw, vpopcntw, 1, 30, PPC_NONE, PPC2_ALTIVEC_207),
|
||||
GEN_VXFORM_DUAL(vclzd, vpopcntd, 1, 31, PPC_NONE, PPC2_ALTIVEC_207),
|
||||
|
||||
GEN_VXFORM_207(vbpermq, 6, 21),
|
||||
GEN_VXFORM_207(vgbbd, 6, 20),
|
||||
GEN_VXFORM_207(vpmsumb, 4, 16),
|
||||
GEN_VXFORM_207(vpmsumh, 4, 17),
|
||||
GEN_VXFORM_207(vpmsumw, 4, 18),
|
||||
GEN_VXFORM_207(vpmsumd, 4, 19),
|
||||
|
||||
GEN_VXFORM_207(vsbox, 4, 23),
|
||||
|
||||
GEN_VXFORM_DUAL(vcipher, vcipherlast, 4, 20, PPC_NONE, PPC2_ALTIVEC_207),
|
||||
GEN_VXFORM_DUAL(vncipher, vncipherlast, 4, 21, PPC_NONE, PPC2_ALTIVEC_207),
|
||||
|
||||
GEN_VXFORM_207(vshasigmaw, 1, 26),
|
||||
GEN_VXFORM_207(vshasigmad, 1, 27),
|
||||
|
||||
GEN_VXFORM_DUAL(vsldoi, vpermxor, 22, 0xFF, PPC_ALTIVEC, PPC_NONE),
|
715
target-ppc/translate/vsx-impl.inc.c
Normal file
715
target-ppc/translate/vsx-impl.inc.c
Normal file
|
@ -0,0 +1,715 @@
|
|||
/*** VSX extension ***/
|
||||
|
||||
static inline TCGv_i64 cpu_vsrh(int n)
|
||||
{
|
||||
if (n < 32) {
|
||||
return cpu_fpr[n];
|
||||
} else {
|
||||
return cpu_avrh[n-32];
|
||||
}
|
||||
}
|
||||
|
||||
static inline TCGv_i64 cpu_vsrl(int n)
|
||||
{
|
||||
if (n < 32) {
|
||||
return cpu_vsr[n];
|
||||
} else {
|
||||
return cpu_avrl[n-32];
|
||||
}
|
||||
}
|
||||
|
||||
#define VSX_LOAD_SCALAR(name, operation) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv EA; \
|
||||
if (unlikely(!ctx->vsx_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU); \
|
||||
return; \
|
||||
} \
|
||||
gen_set_access_type(ctx, ACCESS_INT); \
|
||||
EA = tcg_temp_new(); \
|
||||
gen_addr_reg_index(ctx, EA); \
|
||||
gen_qemu_##operation(ctx, cpu_vsrh(xT(ctx->opcode)), EA); \
|
||||
/* NOTE: cpu_vsrl is undefined */ \
|
||||
tcg_temp_free(EA); \
|
||||
}
|
||||
|
||||
VSX_LOAD_SCALAR(lxsdx, ld64)
|
||||
VSX_LOAD_SCALAR(lxsiwax, ld32s_i64)
|
||||
VSX_LOAD_SCALAR(lxsiwzx, ld32u_i64)
|
||||
VSX_LOAD_SCALAR(lxsspx, ld32fs)
|
||||
|
||||
static void gen_lxvd2x(DisasContext *ctx)
|
||||
{
|
||||
TCGv EA;
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
gen_set_access_type(ctx, ACCESS_INT);
|
||||
EA = tcg_temp_new();
|
||||
gen_addr_reg_index(ctx, EA);
|
||||
gen_qemu_ld64(ctx, cpu_vsrh(xT(ctx->opcode)), EA);
|
||||
tcg_gen_addi_tl(EA, EA, 8);
|
||||
gen_qemu_ld64(ctx, cpu_vsrl(xT(ctx->opcode)), EA);
|
||||
tcg_temp_free(EA);
|
||||
}
|
||||
|
||||
static void gen_lxvdsx(DisasContext *ctx)
|
||||
{
|
||||
TCGv EA;
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
gen_set_access_type(ctx, ACCESS_INT);
|
||||
EA = tcg_temp_new();
|
||||
gen_addr_reg_index(ctx, EA);
|
||||
gen_qemu_ld64(ctx, cpu_vsrh(xT(ctx->opcode)), EA);
|
||||
tcg_gen_mov_i64(cpu_vsrl(xT(ctx->opcode)), cpu_vsrh(xT(ctx->opcode)));
|
||||
tcg_temp_free(EA);
|
||||
}
|
||||
|
||||
static void gen_lxvw4x(DisasContext *ctx)
|
||||
{
|
||||
TCGv EA;
|
||||
TCGv_i64 tmp;
|
||||
TCGv_i64 xth = cpu_vsrh(xT(ctx->opcode));
|
||||
TCGv_i64 xtl = cpu_vsrl(xT(ctx->opcode));
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
gen_set_access_type(ctx, ACCESS_INT);
|
||||
EA = tcg_temp_new();
|
||||
tmp = tcg_temp_new_i64();
|
||||
|
||||
gen_addr_reg_index(ctx, EA);
|
||||
gen_qemu_ld32u_i64(ctx, tmp, EA);
|
||||
tcg_gen_addi_tl(EA, EA, 4);
|
||||
gen_qemu_ld32u_i64(ctx, xth, EA);
|
||||
tcg_gen_deposit_i64(xth, xth, tmp, 32, 32);
|
||||
|
||||
tcg_gen_addi_tl(EA, EA, 4);
|
||||
gen_qemu_ld32u_i64(ctx, tmp, EA);
|
||||
tcg_gen_addi_tl(EA, EA, 4);
|
||||
gen_qemu_ld32u_i64(ctx, xtl, EA);
|
||||
tcg_gen_deposit_i64(xtl, xtl, tmp, 32, 32);
|
||||
|
||||
tcg_temp_free(EA);
|
||||
tcg_temp_free_i64(tmp);
|
||||
}
|
||||
|
||||
#define VSX_STORE_SCALAR(name, operation) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv EA; \
|
||||
if (unlikely(!ctx->vsx_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU); \
|
||||
return; \
|
||||
} \
|
||||
gen_set_access_type(ctx, ACCESS_INT); \
|
||||
EA = tcg_temp_new(); \
|
||||
gen_addr_reg_index(ctx, EA); \
|
||||
gen_qemu_##operation(ctx, cpu_vsrh(xS(ctx->opcode)), EA); \
|
||||
tcg_temp_free(EA); \
|
||||
}
|
||||
|
||||
VSX_STORE_SCALAR(stxsdx, st64)
|
||||
VSX_STORE_SCALAR(stxsiwx, st32_i64)
|
||||
VSX_STORE_SCALAR(stxsspx, st32fs)
|
||||
|
||||
static void gen_stxvd2x(DisasContext *ctx)
|
||||
{
|
||||
TCGv EA;
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
gen_set_access_type(ctx, ACCESS_INT);
|
||||
EA = tcg_temp_new();
|
||||
gen_addr_reg_index(ctx, EA);
|
||||
gen_qemu_st64(ctx, cpu_vsrh(xS(ctx->opcode)), EA);
|
||||
tcg_gen_addi_tl(EA, EA, 8);
|
||||
gen_qemu_st64(ctx, cpu_vsrl(xS(ctx->opcode)), EA);
|
||||
tcg_temp_free(EA);
|
||||
}
|
||||
|
||||
static void gen_stxvw4x(DisasContext *ctx)
|
||||
{
|
||||
TCGv_i64 tmp;
|
||||
TCGv EA;
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
gen_set_access_type(ctx, ACCESS_INT);
|
||||
EA = tcg_temp_new();
|
||||
gen_addr_reg_index(ctx, EA);
|
||||
tmp = tcg_temp_new_i64();
|
||||
|
||||
tcg_gen_shri_i64(tmp, cpu_vsrh(xS(ctx->opcode)), 32);
|
||||
gen_qemu_st32_i64(ctx, tmp, EA);
|
||||
tcg_gen_addi_tl(EA, EA, 4);
|
||||
gen_qemu_st32_i64(ctx, cpu_vsrh(xS(ctx->opcode)), EA);
|
||||
|
||||
tcg_gen_shri_i64(tmp, cpu_vsrl(xS(ctx->opcode)), 32);
|
||||
tcg_gen_addi_tl(EA, EA, 4);
|
||||
gen_qemu_st32_i64(ctx, tmp, EA);
|
||||
tcg_gen_addi_tl(EA, EA, 4);
|
||||
gen_qemu_st32_i64(ctx, cpu_vsrl(xS(ctx->opcode)), EA);
|
||||
|
||||
tcg_temp_free(EA);
|
||||
tcg_temp_free_i64(tmp);
|
||||
}
|
||||
|
||||
#define MV_VSRW(name, tcgop1, tcgop2, target, source) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
if (xS(ctx->opcode) < 32) { \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
} else { \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
} \
|
||||
TCGv_i64 tmp = tcg_temp_new_i64(); \
|
||||
tcg_gen_##tcgop1(tmp, source); \
|
||||
tcg_gen_##tcgop2(target, tmp); \
|
||||
tcg_temp_free_i64(tmp); \
|
||||
}
|
||||
|
||||
|
||||
MV_VSRW(mfvsrwz, ext32u_i64, trunc_i64_tl, cpu_gpr[rA(ctx->opcode)], \
|
||||
cpu_vsrh(xS(ctx->opcode)))
|
||||
MV_VSRW(mtvsrwa, extu_tl_i64, ext32s_i64, cpu_vsrh(xT(ctx->opcode)), \
|
||||
cpu_gpr[rA(ctx->opcode)])
|
||||
MV_VSRW(mtvsrwz, extu_tl_i64, ext32u_i64, cpu_vsrh(xT(ctx->opcode)), \
|
||||
cpu_gpr[rA(ctx->opcode)])
|
||||
|
||||
#if defined(TARGET_PPC64)
|
||||
#define MV_VSRD(name, target, source) \
|
||||
static void gen_##name(DisasContext *ctx) \
|
||||
{ \
|
||||
if (xS(ctx->opcode) < 32) { \
|
||||
if (unlikely(!ctx->fpu_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_FPU); \
|
||||
return; \
|
||||
} \
|
||||
} else { \
|
||||
if (unlikely(!ctx->altivec_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VPU); \
|
||||
return; \
|
||||
} \
|
||||
} \
|
||||
tcg_gen_mov_i64(target, source); \
|
||||
}
|
||||
|
||||
MV_VSRD(mfvsrd, cpu_gpr[rA(ctx->opcode)], cpu_vsrh(xS(ctx->opcode)))
|
||||
MV_VSRD(mtvsrd, cpu_vsrh(xT(ctx->opcode)), cpu_gpr[rA(ctx->opcode)])
|
||||
|
||||
#endif
|
||||
|
||||
static void gen_xxpermdi(DisasContext *ctx)
|
||||
{
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
|
||||
if (unlikely((xT(ctx->opcode) == xA(ctx->opcode)) ||
|
||||
(xT(ctx->opcode) == xB(ctx->opcode)))) {
|
||||
TCGv_i64 xh, xl;
|
||||
|
||||
xh = tcg_temp_new_i64();
|
||||
xl = tcg_temp_new_i64();
|
||||
|
||||
if ((DM(ctx->opcode) & 2) == 0) {
|
||||
tcg_gen_mov_i64(xh, cpu_vsrh(xA(ctx->opcode)));
|
||||
} else {
|
||||
tcg_gen_mov_i64(xh, cpu_vsrl(xA(ctx->opcode)));
|
||||
}
|
||||
if ((DM(ctx->opcode) & 1) == 0) {
|
||||
tcg_gen_mov_i64(xl, cpu_vsrh(xB(ctx->opcode)));
|
||||
} else {
|
||||
tcg_gen_mov_i64(xl, cpu_vsrl(xB(ctx->opcode)));
|
||||
}
|
||||
|
||||
tcg_gen_mov_i64(cpu_vsrh(xT(ctx->opcode)), xh);
|
||||
tcg_gen_mov_i64(cpu_vsrl(xT(ctx->opcode)), xl);
|
||||
|
||||
tcg_temp_free_i64(xh);
|
||||
tcg_temp_free_i64(xl);
|
||||
} else {
|
||||
if ((DM(ctx->opcode) & 2) == 0) {
|
||||
tcg_gen_mov_i64(cpu_vsrh(xT(ctx->opcode)), cpu_vsrh(xA(ctx->opcode)));
|
||||
} else {
|
||||
tcg_gen_mov_i64(cpu_vsrh(xT(ctx->opcode)), cpu_vsrl(xA(ctx->opcode)));
|
||||
}
|
||||
if ((DM(ctx->opcode) & 1) == 0) {
|
||||
tcg_gen_mov_i64(cpu_vsrl(xT(ctx->opcode)), cpu_vsrh(xB(ctx->opcode)));
|
||||
} else {
|
||||
tcg_gen_mov_i64(cpu_vsrl(xT(ctx->opcode)), cpu_vsrl(xB(ctx->opcode)));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
#define OP_ABS 1
|
||||
#define OP_NABS 2
|
||||
#define OP_NEG 3
|
||||
#define OP_CPSGN 4
|
||||
#define SGN_MASK_DP 0x8000000000000000ull
|
||||
#define SGN_MASK_SP 0x8000000080000000ull
|
||||
|
||||
#define VSX_SCALAR_MOVE(name, op, sgn_mask) \
|
||||
static void glue(gen_, name)(DisasContext * ctx) \
|
||||
{ \
|
||||
TCGv_i64 xb, sgm; \
|
||||
if (unlikely(!ctx->vsx_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU); \
|
||||
return; \
|
||||
} \
|
||||
xb = tcg_temp_new_i64(); \
|
||||
sgm = tcg_temp_new_i64(); \
|
||||
tcg_gen_mov_i64(xb, cpu_vsrh(xB(ctx->opcode))); \
|
||||
tcg_gen_movi_i64(sgm, sgn_mask); \
|
||||
switch (op) { \
|
||||
case OP_ABS: { \
|
||||
tcg_gen_andc_i64(xb, xb, sgm); \
|
||||
break; \
|
||||
} \
|
||||
case OP_NABS: { \
|
||||
tcg_gen_or_i64(xb, xb, sgm); \
|
||||
break; \
|
||||
} \
|
||||
case OP_NEG: { \
|
||||
tcg_gen_xor_i64(xb, xb, sgm); \
|
||||
break; \
|
||||
} \
|
||||
case OP_CPSGN: { \
|
||||
TCGv_i64 xa = tcg_temp_new_i64(); \
|
||||
tcg_gen_mov_i64(xa, cpu_vsrh(xA(ctx->opcode))); \
|
||||
tcg_gen_and_i64(xa, xa, sgm); \
|
||||
tcg_gen_andc_i64(xb, xb, sgm); \
|
||||
tcg_gen_or_i64(xb, xb, xa); \
|
||||
tcg_temp_free_i64(xa); \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
tcg_gen_mov_i64(cpu_vsrh(xT(ctx->opcode)), xb); \
|
||||
tcg_temp_free_i64(xb); \
|
||||
tcg_temp_free_i64(sgm); \
|
||||
}
|
||||
|
||||
VSX_SCALAR_MOVE(xsabsdp, OP_ABS, SGN_MASK_DP)
|
||||
VSX_SCALAR_MOVE(xsnabsdp, OP_NABS, SGN_MASK_DP)
|
||||
VSX_SCALAR_MOVE(xsnegdp, OP_NEG, SGN_MASK_DP)
|
||||
VSX_SCALAR_MOVE(xscpsgndp, OP_CPSGN, SGN_MASK_DP)
|
||||
|
||||
#define VSX_VECTOR_MOVE(name, op, sgn_mask) \
|
||||
static void glue(gen_, name)(DisasContext * ctx) \
|
||||
{ \
|
||||
TCGv_i64 xbh, xbl, sgm; \
|
||||
if (unlikely(!ctx->vsx_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU); \
|
||||
return; \
|
||||
} \
|
||||
xbh = tcg_temp_new_i64(); \
|
||||
xbl = tcg_temp_new_i64(); \
|
||||
sgm = tcg_temp_new_i64(); \
|
||||
tcg_gen_mov_i64(xbh, cpu_vsrh(xB(ctx->opcode))); \
|
||||
tcg_gen_mov_i64(xbl, cpu_vsrl(xB(ctx->opcode))); \
|
||||
tcg_gen_movi_i64(sgm, sgn_mask); \
|
||||
switch (op) { \
|
||||
case OP_ABS: { \
|
||||
tcg_gen_andc_i64(xbh, xbh, sgm); \
|
||||
tcg_gen_andc_i64(xbl, xbl, sgm); \
|
||||
break; \
|
||||
} \
|
||||
case OP_NABS: { \
|
||||
tcg_gen_or_i64(xbh, xbh, sgm); \
|
||||
tcg_gen_or_i64(xbl, xbl, sgm); \
|
||||
break; \
|
||||
} \
|
||||
case OP_NEG: { \
|
||||
tcg_gen_xor_i64(xbh, xbh, sgm); \
|
||||
tcg_gen_xor_i64(xbl, xbl, sgm); \
|
||||
break; \
|
||||
} \
|
||||
case OP_CPSGN: { \
|
||||
TCGv_i64 xah = tcg_temp_new_i64(); \
|
||||
TCGv_i64 xal = tcg_temp_new_i64(); \
|
||||
tcg_gen_mov_i64(xah, cpu_vsrh(xA(ctx->opcode))); \
|
||||
tcg_gen_mov_i64(xal, cpu_vsrl(xA(ctx->opcode))); \
|
||||
tcg_gen_and_i64(xah, xah, sgm); \
|
||||
tcg_gen_and_i64(xal, xal, sgm); \
|
||||
tcg_gen_andc_i64(xbh, xbh, sgm); \
|
||||
tcg_gen_andc_i64(xbl, xbl, sgm); \
|
||||
tcg_gen_or_i64(xbh, xbh, xah); \
|
||||
tcg_gen_or_i64(xbl, xbl, xal); \
|
||||
tcg_temp_free_i64(xah); \
|
||||
tcg_temp_free_i64(xal); \
|
||||
break; \
|
||||
} \
|
||||
} \
|
||||
tcg_gen_mov_i64(cpu_vsrh(xT(ctx->opcode)), xbh); \
|
||||
tcg_gen_mov_i64(cpu_vsrl(xT(ctx->opcode)), xbl); \
|
||||
tcg_temp_free_i64(xbh); \
|
||||
tcg_temp_free_i64(xbl); \
|
||||
tcg_temp_free_i64(sgm); \
|
||||
}
|
||||
|
||||
VSX_VECTOR_MOVE(xvabsdp, OP_ABS, SGN_MASK_DP)
|
||||
VSX_VECTOR_MOVE(xvnabsdp, OP_NABS, SGN_MASK_DP)
|
||||
VSX_VECTOR_MOVE(xvnegdp, OP_NEG, SGN_MASK_DP)
|
||||
VSX_VECTOR_MOVE(xvcpsgndp, OP_CPSGN, SGN_MASK_DP)
|
||||
VSX_VECTOR_MOVE(xvabssp, OP_ABS, SGN_MASK_SP)
|
||||
VSX_VECTOR_MOVE(xvnabssp, OP_NABS, SGN_MASK_SP)
|
||||
VSX_VECTOR_MOVE(xvnegsp, OP_NEG, SGN_MASK_SP)
|
||||
VSX_VECTOR_MOVE(xvcpsgnsp, OP_CPSGN, SGN_MASK_SP)
|
||||
|
||||
#define GEN_VSX_HELPER_2(name, op1, op2, inval, type) \
|
||||
static void gen_##name(DisasContext * ctx) \
|
||||
{ \
|
||||
TCGv_i32 opc; \
|
||||
if (unlikely(!ctx->vsx_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU); \
|
||||
return; \
|
||||
} \
|
||||
opc = tcg_const_i32(ctx->opcode); \
|
||||
gen_helper_##name(cpu_env, opc); \
|
||||
tcg_temp_free_i32(opc); \
|
||||
}
|
||||
|
||||
#define GEN_VSX_HELPER_XT_XB_ENV(name, op1, op2, inval, type) \
|
||||
static void gen_##name(DisasContext * ctx) \
|
||||
{ \
|
||||
if (unlikely(!ctx->vsx_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU); \
|
||||
return; \
|
||||
} \
|
||||
gen_helper_##name(cpu_vsrh(xT(ctx->opcode)), cpu_env, \
|
||||
cpu_vsrh(xB(ctx->opcode))); \
|
||||
}
|
||||
|
||||
GEN_VSX_HELPER_2(xsadddp, 0x00, 0x04, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xssubdp, 0x00, 0x05, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsmuldp, 0x00, 0x06, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsdivdp, 0x00, 0x07, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsredp, 0x14, 0x05, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xssqrtdp, 0x16, 0x04, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsrsqrtedp, 0x14, 0x04, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xstdivdp, 0x14, 0x07, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xstsqrtdp, 0x14, 0x06, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsmaddadp, 0x04, 0x04, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsmaddmdp, 0x04, 0x05, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsmsubadp, 0x04, 0x06, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsmsubmdp, 0x04, 0x07, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsnmaddadp, 0x04, 0x14, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsnmaddmdp, 0x04, 0x15, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsnmsubadp, 0x04, 0x16, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsnmsubmdp, 0x04, 0x17, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xscmpodp, 0x0C, 0x05, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xscmpudp, 0x0C, 0x04, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsmaxdp, 0x00, 0x14, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsmindp, 0x00, 0x15, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xscvdpsp, 0x12, 0x10, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_XT_XB_ENV(xscvdpspn, 0x16, 0x10, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xscvspdp, 0x12, 0x14, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_XT_XB_ENV(xscvspdpn, 0x16, 0x14, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xscvdpsxds, 0x10, 0x15, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xscvdpsxws, 0x10, 0x05, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xscvdpuxds, 0x10, 0x14, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xscvdpuxws, 0x10, 0x04, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xscvsxddp, 0x10, 0x17, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xscvuxddp, 0x10, 0x16, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsrdpi, 0x12, 0x04, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsrdpic, 0x16, 0x06, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsrdpim, 0x12, 0x07, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsrdpip, 0x12, 0x06, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xsrdpiz, 0x12, 0x05, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_XT_XB_ENV(xsrsp, 0x12, 0x11, 0, PPC2_VSX207)
|
||||
|
||||
GEN_VSX_HELPER_2(xsaddsp, 0x00, 0x00, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xssubsp, 0x00, 0x01, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsmulsp, 0x00, 0x02, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsdivsp, 0x00, 0x03, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsresp, 0x14, 0x01, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xssqrtsp, 0x16, 0x00, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsrsqrtesp, 0x14, 0x00, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsmaddasp, 0x04, 0x00, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsmaddmsp, 0x04, 0x01, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsmsubasp, 0x04, 0x02, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsmsubmsp, 0x04, 0x03, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsnmaddasp, 0x04, 0x10, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsnmaddmsp, 0x04, 0x11, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsnmsubasp, 0x04, 0x12, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xsnmsubmsp, 0x04, 0x13, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xscvsxdsp, 0x10, 0x13, 0, PPC2_VSX207)
|
||||
GEN_VSX_HELPER_2(xscvuxdsp, 0x10, 0x12, 0, PPC2_VSX207)
|
||||
|
||||
GEN_VSX_HELPER_2(xvadddp, 0x00, 0x0C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvsubdp, 0x00, 0x0D, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmuldp, 0x00, 0x0E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvdivdp, 0x00, 0x0F, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvredp, 0x14, 0x0D, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvsqrtdp, 0x16, 0x0C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrsqrtedp, 0x14, 0x0C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvtdivdp, 0x14, 0x0F, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvtsqrtdp, 0x14, 0x0E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmaddadp, 0x04, 0x0C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmaddmdp, 0x04, 0x0D, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmsubadp, 0x04, 0x0E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmsubmdp, 0x04, 0x0F, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvnmaddadp, 0x04, 0x1C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvnmaddmdp, 0x04, 0x1D, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvnmsubadp, 0x04, 0x1E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvnmsubmdp, 0x04, 0x1F, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmaxdp, 0x00, 0x1C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmindp, 0x00, 0x1D, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcmpeqdp, 0x0C, 0x0C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcmpgtdp, 0x0C, 0x0D, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcmpgedp, 0x0C, 0x0E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvdpsp, 0x12, 0x18, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvdpsxds, 0x10, 0x1D, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvdpsxws, 0x10, 0x0D, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvdpuxds, 0x10, 0x1C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvdpuxws, 0x10, 0x0C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvsxddp, 0x10, 0x1F, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvuxddp, 0x10, 0x1E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvsxwdp, 0x10, 0x0F, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvuxwdp, 0x10, 0x0E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrdpi, 0x12, 0x0C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrdpic, 0x16, 0x0E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrdpim, 0x12, 0x0F, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrdpip, 0x12, 0x0E, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrdpiz, 0x12, 0x0D, 0, PPC2_VSX)
|
||||
|
||||
GEN_VSX_HELPER_2(xvaddsp, 0x00, 0x08, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvsubsp, 0x00, 0x09, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmulsp, 0x00, 0x0A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvdivsp, 0x00, 0x0B, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvresp, 0x14, 0x09, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvsqrtsp, 0x16, 0x08, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrsqrtesp, 0x14, 0x08, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvtdivsp, 0x14, 0x0B, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvtsqrtsp, 0x14, 0x0A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmaddasp, 0x04, 0x08, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmaddmsp, 0x04, 0x09, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmsubasp, 0x04, 0x0A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmsubmsp, 0x04, 0x0B, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvnmaddasp, 0x04, 0x18, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvnmaddmsp, 0x04, 0x19, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvnmsubasp, 0x04, 0x1A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvnmsubmsp, 0x04, 0x1B, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvmaxsp, 0x00, 0x18, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvminsp, 0x00, 0x19, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcmpeqsp, 0x0C, 0x08, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcmpgtsp, 0x0C, 0x09, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcmpgesp, 0x0C, 0x0A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvspdp, 0x12, 0x1C, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvspsxds, 0x10, 0x19, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvspsxws, 0x10, 0x09, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvspuxds, 0x10, 0x18, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvspuxws, 0x10, 0x08, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvsxdsp, 0x10, 0x1B, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvuxdsp, 0x10, 0x1A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvsxwsp, 0x10, 0x0B, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvcvuxwsp, 0x10, 0x0A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrspi, 0x12, 0x08, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrspic, 0x16, 0x0A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrspim, 0x12, 0x0B, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrspip, 0x12, 0x0A, 0, PPC2_VSX)
|
||||
GEN_VSX_HELPER_2(xvrspiz, 0x12, 0x09, 0, PPC2_VSX)
|
||||
|
||||
#define VSX_LOGICAL(name, tcg_op) \
|
||||
static void glue(gen_, name)(DisasContext * ctx) \
|
||||
{ \
|
||||
if (unlikely(!ctx->vsx_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU); \
|
||||
return; \
|
||||
} \
|
||||
tcg_op(cpu_vsrh(xT(ctx->opcode)), cpu_vsrh(xA(ctx->opcode)), \
|
||||
cpu_vsrh(xB(ctx->opcode))); \
|
||||
tcg_op(cpu_vsrl(xT(ctx->opcode)), cpu_vsrl(xA(ctx->opcode)), \
|
||||
cpu_vsrl(xB(ctx->opcode))); \
|
||||
}
|
||||
|
||||
VSX_LOGICAL(xxland, tcg_gen_and_i64)
|
||||
VSX_LOGICAL(xxlandc, tcg_gen_andc_i64)
|
||||
VSX_LOGICAL(xxlor, tcg_gen_or_i64)
|
||||
VSX_LOGICAL(xxlxor, tcg_gen_xor_i64)
|
||||
VSX_LOGICAL(xxlnor, tcg_gen_nor_i64)
|
||||
VSX_LOGICAL(xxleqv, tcg_gen_eqv_i64)
|
||||
VSX_LOGICAL(xxlnand, tcg_gen_nand_i64)
|
||||
VSX_LOGICAL(xxlorc, tcg_gen_orc_i64)
|
||||
|
||||
#define VSX_XXMRG(name, high) \
|
||||
static void glue(gen_, name)(DisasContext * ctx) \
|
||||
{ \
|
||||
TCGv_i64 a0, a1, b0, b1; \
|
||||
if (unlikely(!ctx->vsx_enabled)) { \
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU); \
|
||||
return; \
|
||||
} \
|
||||
a0 = tcg_temp_new_i64(); \
|
||||
a1 = tcg_temp_new_i64(); \
|
||||
b0 = tcg_temp_new_i64(); \
|
||||
b1 = tcg_temp_new_i64(); \
|
||||
if (high) { \
|
||||
tcg_gen_mov_i64(a0, cpu_vsrh(xA(ctx->opcode))); \
|
||||
tcg_gen_mov_i64(a1, cpu_vsrh(xA(ctx->opcode))); \
|
||||
tcg_gen_mov_i64(b0, cpu_vsrh(xB(ctx->opcode))); \
|
||||
tcg_gen_mov_i64(b1, cpu_vsrh(xB(ctx->opcode))); \
|
||||
} else { \
|
||||
tcg_gen_mov_i64(a0, cpu_vsrl(xA(ctx->opcode))); \
|
||||
tcg_gen_mov_i64(a1, cpu_vsrl(xA(ctx->opcode))); \
|
||||
tcg_gen_mov_i64(b0, cpu_vsrl(xB(ctx->opcode))); \
|
||||
tcg_gen_mov_i64(b1, cpu_vsrl(xB(ctx->opcode))); \
|
||||
} \
|
||||
tcg_gen_shri_i64(a0, a0, 32); \
|
||||
tcg_gen_shri_i64(b0, b0, 32); \
|
||||
tcg_gen_deposit_i64(cpu_vsrh(xT(ctx->opcode)), \
|
||||
b0, a0, 32, 32); \
|
||||
tcg_gen_deposit_i64(cpu_vsrl(xT(ctx->opcode)), \
|
||||
b1, a1, 32, 32); \
|
||||
tcg_temp_free_i64(a0); \
|
||||
tcg_temp_free_i64(a1); \
|
||||
tcg_temp_free_i64(b0); \
|
||||
tcg_temp_free_i64(b1); \
|
||||
}
|
||||
|
||||
VSX_XXMRG(xxmrghw, 1)
|
||||
VSX_XXMRG(xxmrglw, 0)
|
||||
|
||||
static void gen_xxsel(DisasContext * ctx)
|
||||
{
|
||||
TCGv_i64 a, b, c;
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
a = tcg_temp_new_i64();
|
||||
b = tcg_temp_new_i64();
|
||||
c = tcg_temp_new_i64();
|
||||
|
||||
tcg_gen_mov_i64(a, cpu_vsrh(xA(ctx->opcode)));
|
||||
tcg_gen_mov_i64(b, cpu_vsrh(xB(ctx->opcode)));
|
||||
tcg_gen_mov_i64(c, cpu_vsrh(xC(ctx->opcode)));
|
||||
|
||||
tcg_gen_and_i64(b, b, c);
|
||||
tcg_gen_andc_i64(a, a, c);
|
||||
tcg_gen_or_i64(cpu_vsrh(xT(ctx->opcode)), a, b);
|
||||
|
||||
tcg_gen_mov_i64(a, cpu_vsrl(xA(ctx->opcode)));
|
||||
tcg_gen_mov_i64(b, cpu_vsrl(xB(ctx->opcode)));
|
||||
tcg_gen_mov_i64(c, cpu_vsrl(xC(ctx->opcode)));
|
||||
|
||||
tcg_gen_and_i64(b, b, c);
|
||||
tcg_gen_andc_i64(a, a, c);
|
||||
tcg_gen_or_i64(cpu_vsrl(xT(ctx->opcode)), a, b);
|
||||
|
||||
tcg_temp_free_i64(a);
|
||||
tcg_temp_free_i64(b);
|
||||
tcg_temp_free_i64(c);
|
||||
}
|
||||
|
||||
static void gen_xxspltw(DisasContext *ctx)
|
||||
{
|
||||
TCGv_i64 b, b2;
|
||||
TCGv_i64 vsr = (UIM(ctx->opcode) & 2) ?
|
||||
cpu_vsrl(xB(ctx->opcode)) :
|
||||
cpu_vsrh(xB(ctx->opcode));
|
||||
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
|
||||
b = tcg_temp_new_i64();
|
||||
b2 = tcg_temp_new_i64();
|
||||
|
||||
if (UIM(ctx->opcode) & 1) {
|
||||
tcg_gen_ext32u_i64(b, vsr);
|
||||
} else {
|
||||
tcg_gen_shri_i64(b, vsr, 32);
|
||||
}
|
||||
|
||||
tcg_gen_shli_i64(b2, b, 32);
|
||||
tcg_gen_or_i64(cpu_vsrh(xT(ctx->opcode)), b, b2);
|
||||
tcg_gen_mov_i64(cpu_vsrl(xT(ctx->opcode)), cpu_vsrh(xT(ctx->opcode)));
|
||||
|
||||
tcg_temp_free_i64(b);
|
||||
tcg_temp_free_i64(b2);
|
||||
}
|
||||
|
||||
static void gen_xxsldwi(DisasContext *ctx)
|
||||
{
|
||||
TCGv_i64 xth, xtl;
|
||||
if (unlikely(!ctx->vsx_enabled)) {
|
||||
gen_exception(ctx, POWERPC_EXCP_VSXU);
|
||||
return;
|
||||
}
|
||||
xth = tcg_temp_new_i64();
|
||||
xtl = tcg_temp_new_i64();
|
||||
|
||||
switch (SHW(ctx->opcode)) {
|
||||
case 0: {
|
||||
tcg_gen_mov_i64(xth, cpu_vsrh(xA(ctx->opcode)));
|
||||
tcg_gen_mov_i64(xtl, cpu_vsrl(xA(ctx->opcode)));
|
||||
break;
|
||||
}
|
||||
case 1: {
|
||||
TCGv_i64 t0 = tcg_temp_new_i64();
|
||||
tcg_gen_mov_i64(xth, cpu_vsrh(xA(ctx->opcode)));
|
||||
tcg_gen_shli_i64(xth, xth, 32);
|
||||
tcg_gen_mov_i64(t0, cpu_vsrl(xA(ctx->opcode)));
|
||||
tcg_gen_shri_i64(t0, t0, 32);
|
||||
tcg_gen_or_i64(xth, xth, t0);
|
||||
tcg_gen_mov_i64(xtl, cpu_vsrl(xA(ctx->opcode)));
|
||||
tcg_gen_shli_i64(xtl, xtl, 32);
|
||||
tcg_gen_mov_i64(t0, cpu_vsrh(xB(ctx->opcode)));
|
||||
tcg_gen_shri_i64(t0, t0, 32);
|
||||
tcg_gen_or_i64(xtl, xtl, t0);
|
||||
tcg_temp_free_i64(t0);
|
||||
break;
|
||||
}
|
||||
case 2: {
|
||||
tcg_gen_mov_i64(xth, cpu_vsrl(xA(ctx->opcode)));
|
||||
tcg_gen_mov_i64(xtl, cpu_vsrh(xB(ctx->opcode)));
|
||||
break;
|
||||
}
|
||||
case 3: {
|
||||
TCGv_i64 t0 = tcg_temp_new_i64();
|
||||
tcg_gen_mov_i64(xth, cpu_vsrl(xA(ctx->opcode)));
|
||||
tcg_gen_shli_i64(xth, xth, 32);
|
||||
tcg_gen_mov_i64(t0, cpu_vsrh(xB(ctx->opcode)));
|
||||
tcg_gen_shri_i64(t0, t0, 32);
|
||||
tcg_gen_or_i64(xth, xth, t0);
|
||||
tcg_gen_mov_i64(xtl, cpu_vsrh(xB(ctx->opcode)));
|
||||
tcg_gen_shli_i64(xtl, xtl, 32);
|
||||
tcg_gen_mov_i64(t0, cpu_vsrl(xB(ctx->opcode)));
|
||||
tcg_gen_shri_i64(t0, t0, 32);
|
||||
tcg_gen_or_i64(xtl, xtl, t0);
|
||||
tcg_temp_free_i64(t0);
|
||||
break;
|
||||
}
|
||||
}
|
||||
|
||||
tcg_gen_mov_i64(cpu_vsrh(xT(ctx->opcode)), xth);
|
||||
tcg_gen_mov_i64(cpu_vsrl(xT(ctx->opcode)), xtl);
|
||||
|
||||
tcg_temp_free_i64(xth);
|
||||
tcg_temp_free_i64(xtl);
|
||||
}
|
||||
|
||||
#undef GEN_XX2FORM
|
||||
#undef GEN_XX3FORM
|
||||
#undef GEN_XX2IFORM
|
||||
#undef GEN_XX3_RC_FORM
|
||||
#undef GEN_XX3FORM_DM
|
||||
#undef VSX_LOGICAL
|
270
target-ppc/translate/vsx-ops.inc.c
Normal file
270
target-ppc/translate/vsx-ops.inc.c
Normal file
|
@ -0,0 +1,270 @@
|
|||
GEN_HANDLER_E(lxsdx, 0x1F, 0x0C, 0x12, 0, PPC_NONE, PPC2_VSX),
|
||||
GEN_HANDLER_E(lxsiwax, 0x1F, 0x0C, 0x02, 0, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(lxsiwzx, 0x1F, 0x0C, 0x00, 0, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(lxsspx, 0x1F, 0x0C, 0x10, 0, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(lxvd2x, 0x1F, 0x0C, 0x1A, 0, PPC_NONE, PPC2_VSX),
|
||||
GEN_HANDLER_E(lxvdsx, 0x1F, 0x0C, 0x0A, 0, PPC_NONE, PPC2_VSX),
|
||||
GEN_HANDLER_E(lxvw4x, 0x1F, 0x0C, 0x18, 0, PPC_NONE, PPC2_VSX),
|
||||
|
||||
GEN_HANDLER_E(stxsdx, 0x1F, 0xC, 0x16, 0, PPC_NONE, PPC2_VSX),
|
||||
GEN_HANDLER_E(stxsiwx, 0x1F, 0xC, 0x04, 0, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(stxsspx, 0x1F, 0xC, 0x14, 0, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(stxvd2x, 0x1F, 0xC, 0x1E, 0, PPC_NONE, PPC2_VSX),
|
||||
GEN_HANDLER_E(stxvw4x, 0x1F, 0xC, 0x1C, 0, PPC_NONE, PPC2_VSX),
|
||||
|
||||
GEN_HANDLER_E(mfvsrwz, 0x1F, 0x13, 0x03, 0x0000F800, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(mtvsrwa, 0x1F, 0x13, 0x06, 0x0000F800, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(mtvsrwz, 0x1F, 0x13, 0x07, 0x0000F800, PPC_NONE, PPC2_VSX207),
|
||||
#if defined(TARGET_PPC64)
|
||||
GEN_HANDLER_E(mfvsrd, 0x1F, 0x13, 0x01, 0x0000F800, PPC_NONE, PPC2_VSX207),
|
||||
GEN_HANDLER_E(mtvsrd, 0x1F, 0x13, 0x05, 0x0000F800, PPC_NONE, PPC2_VSX207),
|
||||
#endif
|
||||
|
||||
#define GEN_XX2FORM(name, opc2, opc3, fl2) \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0, opc3, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 1, opc3, 0, PPC_NONE, fl2)
|
||||
|
||||
#define GEN_XX3FORM(name, opc2, opc3, fl2) \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0, opc3, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 1, opc3, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 2, opc3, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 3, opc3, 0, PPC_NONE, fl2)
|
||||
|
||||
#define GEN_XX2IFORM(name, opc2, opc3, fl2) \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0, opc3, 1, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 1, opc3, 1, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 2, opc3, 1, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 3, opc3, 1, PPC_NONE, fl2)
|
||||
|
||||
#define GEN_XX3_RC_FORM(name, opc2, opc3, fl2) \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0x00, opc3 | 0x00, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0x01, opc3 | 0x00, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0x02, opc3 | 0x00, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0x03, opc3 | 0x00, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0x00, opc3 | 0x10, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0x01, opc3 | 0x10, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0x02, opc3 | 0x10, 0, PPC_NONE, fl2), \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2 | 0x03, opc3 | 0x10, 0, PPC_NONE, fl2)
|
||||
|
||||
#define GEN_XX3FORM_DM(name, opc2, opc3) \
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x00, opc3|0x00, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x01, opc3|0x00, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x02, opc3|0x00, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x03, opc3|0x00, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x00, opc3|0x04, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x01, opc3|0x04, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x02, opc3|0x04, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x03, opc3|0x04, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x00, opc3|0x08, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x01, opc3|0x08, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x02, opc3|0x08, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x03, opc3|0x08, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x00, opc3|0x0C, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x01, opc3|0x0C, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x02, opc3|0x0C, 0, PPC_NONE, PPC2_VSX),\
|
||||
GEN_HANDLER2_E(name, #name, 0x3C, opc2|0x03, opc3|0x0C, 0, PPC_NONE, PPC2_VSX)
|
||||
|
||||
GEN_XX2FORM(xsabsdp, 0x12, 0x15, PPC2_VSX),
|
||||
GEN_XX2FORM(xsnabsdp, 0x12, 0x16, PPC2_VSX),
|
||||
GEN_XX2FORM(xsnegdp, 0x12, 0x17, PPC2_VSX),
|
||||
GEN_XX3FORM(xscpsgndp, 0x00, 0x16, PPC2_VSX),
|
||||
|
||||
GEN_XX2FORM(xvabsdp, 0x12, 0x1D, PPC2_VSX),
|
||||
GEN_XX2FORM(xvnabsdp, 0x12, 0x1E, PPC2_VSX),
|
||||
GEN_XX2FORM(xvnegdp, 0x12, 0x1F, PPC2_VSX),
|
||||
GEN_XX3FORM(xvcpsgndp, 0x00, 0x1E, PPC2_VSX),
|
||||
GEN_XX2FORM(xvabssp, 0x12, 0x19, PPC2_VSX),
|
||||
GEN_XX2FORM(xvnabssp, 0x12, 0x1A, PPC2_VSX),
|
||||
GEN_XX2FORM(xvnegsp, 0x12, 0x1B, PPC2_VSX),
|
||||
GEN_XX3FORM(xvcpsgnsp, 0x00, 0x1A, PPC2_VSX),
|
||||
|
||||
GEN_XX3FORM(xsadddp, 0x00, 0x04, PPC2_VSX),
|
||||
GEN_XX3FORM(xssubdp, 0x00, 0x05, PPC2_VSX),
|
||||
GEN_XX3FORM(xsmuldp, 0x00, 0x06, PPC2_VSX),
|
||||
GEN_XX3FORM(xsdivdp, 0x00, 0x07, PPC2_VSX),
|
||||
GEN_XX2FORM(xsredp, 0x14, 0x05, PPC2_VSX),
|
||||
GEN_XX2FORM(xssqrtdp, 0x16, 0x04, PPC2_VSX),
|
||||
GEN_XX2FORM(xsrsqrtedp, 0x14, 0x04, PPC2_VSX),
|
||||
GEN_XX3FORM(xstdivdp, 0x14, 0x07, PPC2_VSX),
|
||||
GEN_XX2FORM(xstsqrtdp, 0x14, 0x06, PPC2_VSX),
|
||||
GEN_XX3FORM(xsmaddadp, 0x04, 0x04, PPC2_VSX),
|
||||
GEN_XX3FORM(xsmaddmdp, 0x04, 0x05, PPC2_VSX),
|
||||
GEN_XX3FORM(xsmsubadp, 0x04, 0x06, PPC2_VSX),
|
||||
GEN_XX3FORM(xsmsubmdp, 0x04, 0x07, PPC2_VSX),
|
||||
GEN_XX3FORM(xsnmaddadp, 0x04, 0x14, PPC2_VSX),
|
||||
GEN_XX3FORM(xsnmaddmdp, 0x04, 0x15, PPC2_VSX),
|
||||
GEN_XX3FORM(xsnmsubadp, 0x04, 0x16, PPC2_VSX),
|
||||
GEN_XX3FORM(xsnmsubmdp, 0x04, 0x17, PPC2_VSX),
|
||||
GEN_XX2IFORM(xscmpodp, 0x0C, 0x05, PPC2_VSX),
|
||||
GEN_XX2IFORM(xscmpudp, 0x0C, 0x04, PPC2_VSX),
|
||||
GEN_XX3FORM(xsmaxdp, 0x00, 0x14, PPC2_VSX),
|
||||
GEN_XX3FORM(xsmindp, 0x00, 0x15, PPC2_VSX),
|
||||
GEN_XX2FORM(xscvdpsp, 0x12, 0x10, PPC2_VSX),
|
||||
GEN_XX2FORM(xscvdpspn, 0x16, 0x10, PPC2_VSX207),
|
||||
GEN_XX2FORM(xscvspdp, 0x12, 0x14, PPC2_VSX),
|
||||
GEN_XX2FORM(xscvspdpn, 0x16, 0x14, PPC2_VSX207),
|
||||
GEN_XX2FORM(xscvdpsxds, 0x10, 0x15, PPC2_VSX),
|
||||
GEN_XX2FORM(xscvdpsxws, 0x10, 0x05, PPC2_VSX),
|
||||
GEN_XX2FORM(xscvdpuxds, 0x10, 0x14, PPC2_VSX),
|
||||
GEN_XX2FORM(xscvdpuxws, 0x10, 0x04, PPC2_VSX),
|
||||
GEN_XX2FORM(xscvsxddp, 0x10, 0x17, PPC2_VSX),
|
||||
GEN_XX2FORM(xscvuxddp, 0x10, 0x16, PPC2_VSX),
|
||||
GEN_XX2FORM(xsrdpi, 0x12, 0x04, PPC2_VSX),
|
||||
GEN_XX2FORM(xsrdpic, 0x16, 0x06, PPC2_VSX),
|
||||
GEN_XX2FORM(xsrdpim, 0x12, 0x07, PPC2_VSX),
|
||||
GEN_XX2FORM(xsrdpip, 0x12, 0x06, PPC2_VSX),
|
||||
GEN_XX2FORM(xsrdpiz, 0x12, 0x05, PPC2_VSX),
|
||||
|
||||
GEN_XX3FORM(xsaddsp, 0x00, 0x00, PPC2_VSX207),
|
||||
GEN_XX3FORM(xssubsp, 0x00, 0x01, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsmulsp, 0x00, 0x02, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsdivsp, 0x00, 0x03, PPC2_VSX207),
|
||||
GEN_XX2FORM(xsresp, 0x14, 0x01, PPC2_VSX207),
|
||||
GEN_XX2FORM(xsrsp, 0x12, 0x11, PPC2_VSX207),
|
||||
GEN_XX2FORM(xssqrtsp, 0x16, 0x00, PPC2_VSX207),
|
||||
GEN_XX2FORM(xsrsqrtesp, 0x14, 0x00, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsmaddasp, 0x04, 0x00, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsmaddmsp, 0x04, 0x01, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsmsubasp, 0x04, 0x02, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsmsubmsp, 0x04, 0x03, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsnmaddasp, 0x04, 0x10, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsnmaddmsp, 0x04, 0x11, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsnmsubasp, 0x04, 0x12, PPC2_VSX207),
|
||||
GEN_XX3FORM(xsnmsubmsp, 0x04, 0x13, PPC2_VSX207),
|
||||
GEN_XX2FORM(xscvsxdsp, 0x10, 0x13, PPC2_VSX207),
|
||||
GEN_XX2FORM(xscvuxdsp, 0x10, 0x12, PPC2_VSX207),
|
||||
|
||||
GEN_XX3FORM(xvadddp, 0x00, 0x0C, PPC2_VSX),
|
||||
GEN_XX3FORM(xvsubdp, 0x00, 0x0D, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmuldp, 0x00, 0x0E, PPC2_VSX),
|
||||
GEN_XX3FORM(xvdivdp, 0x00, 0x0F, PPC2_VSX),
|
||||
GEN_XX2FORM(xvredp, 0x14, 0x0D, PPC2_VSX),
|
||||
GEN_XX2FORM(xvsqrtdp, 0x16, 0x0C, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrsqrtedp, 0x14, 0x0C, PPC2_VSX),
|
||||
GEN_XX3FORM(xvtdivdp, 0x14, 0x0F, PPC2_VSX),
|
||||
GEN_XX2FORM(xvtsqrtdp, 0x14, 0x0E, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmaddadp, 0x04, 0x0C, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmaddmdp, 0x04, 0x0D, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmsubadp, 0x04, 0x0E, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmsubmdp, 0x04, 0x0F, PPC2_VSX),
|
||||
GEN_XX3FORM(xvnmaddadp, 0x04, 0x1C, PPC2_VSX),
|
||||
GEN_XX3FORM(xvnmaddmdp, 0x04, 0x1D, PPC2_VSX),
|
||||
GEN_XX3FORM(xvnmsubadp, 0x04, 0x1E, PPC2_VSX),
|
||||
GEN_XX3FORM(xvnmsubmdp, 0x04, 0x1F, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmaxdp, 0x00, 0x1C, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmindp, 0x00, 0x1D, PPC2_VSX),
|
||||
GEN_XX3_RC_FORM(xvcmpeqdp, 0x0C, 0x0C, PPC2_VSX),
|
||||
GEN_XX3_RC_FORM(xvcmpgtdp, 0x0C, 0x0D, PPC2_VSX),
|
||||
GEN_XX3_RC_FORM(xvcmpgedp, 0x0C, 0x0E, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvdpsp, 0x12, 0x18, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvdpsxds, 0x10, 0x1D, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvdpsxws, 0x10, 0x0D, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvdpuxds, 0x10, 0x1C, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvdpuxws, 0x10, 0x0C, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvsxddp, 0x10, 0x1F, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvuxddp, 0x10, 0x1E, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvsxwdp, 0x10, 0x0F, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvuxwdp, 0x10, 0x0E, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrdpi, 0x12, 0x0C, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrdpic, 0x16, 0x0E, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrdpim, 0x12, 0x0F, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrdpip, 0x12, 0x0E, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrdpiz, 0x12, 0x0D, PPC2_VSX),
|
||||
|
||||
GEN_XX3FORM(xvaddsp, 0x00, 0x08, PPC2_VSX),
|
||||
GEN_XX3FORM(xvsubsp, 0x00, 0x09, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmulsp, 0x00, 0x0A, PPC2_VSX),
|
||||
GEN_XX3FORM(xvdivsp, 0x00, 0x0B, PPC2_VSX),
|
||||
GEN_XX2FORM(xvresp, 0x14, 0x09, PPC2_VSX),
|
||||
GEN_XX2FORM(xvsqrtsp, 0x16, 0x08, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrsqrtesp, 0x14, 0x08, PPC2_VSX),
|
||||
GEN_XX3FORM(xvtdivsp, 0x14, 0x0B, PPC2_VSX),
|
||||
GEN_XX2FORM(xvtsqrtsp, 0x14, 0x0A, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmaddasp, 0x04, 0x08, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmaddmsp, 0x04, 0x09, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmsubasp, 0x04, 0x0A, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmsubmsp, 0x04, 0x0B, PPC2_VSX),
|
||||
GEN_XX3FORM(xvnmaddasp, 0x04, 0x18, PPC2_VSX),
|
||||
GEN_XX3FORM(xvnmaddmsp, 0x04, 0x19, PPC2_VSX),
|
||||
GEN_XX3FORM(xvnmsubasp, 0x04, 0x1A, PPC2_VSX),
|
||||
GEN_XX3FORM(xvnmsubmsp, 0x04, 0x1B, PPC2_VSX),
|
||||
GEN_XX3FORM(xvmaxsp, 0x00, 0x18, PPC2_VSX),
|
||||
GEN_XX3FORM(xvminsp, 0x00, 0x19, PPC2_VSX),
|
||||
GEN_XX3_RC_FORM(xvcmpeqsp, 0x0C, 0x08, PPC2_VSX),
|
||||
GEN_XX3_RC_FORM(xvcmpgtsp, 0x0C, 0x09, PPC2_VSX),
|
||||
GEN_XX3_RC_FORM(xvcmpgesp, 0x0C, 0x0A, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvspdp, 0x12, 0x1C, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvspsxds, 0x10, 0x19, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvspsxws, 0x10, 0x09, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvspuxds, 0x10, 0x18, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvspuxws, 0x10, 0x08, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvsxdsp, 0x10, 0x1B, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvuxdsp, 0x10, 0x1A, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvsxwsp, 0x10, 0x0B, PPC2_VSX),
|
||||
GEN_XX2FORM(xvcvuxwsp, 0x10, 0x0A, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrspi, 0x12, 0x08, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrspic, 0x16, 0x0A, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrspim, 0x12, 0x0B, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrspip, 0x12, 0x0A, PPC2_VSX),
|
||||
GEN_XX2FORM(xvrspiz, 0x12, 0x09, PPC2_VSX),
|
||||
|
||||
#define VSX_LOGICAL(name, opc2, opc3, fl2) \
|
||||
GEN_XX3FORM(name, opc2, opc3, fl2)
|
||||
|
||||
VSX_LOGICAL(xxland, 0x8, 0x10, PPC2_VSX),
|
||||
VSX_LOGICAL(xxlandc, 0x8, 0x11, PPC2_VSX),
|
||||
VSX_LOGICAL(xxlor, 0x8, 0x12, PPC2_VSX),
|
||||
VSX_LOGICAL(xxlxor, 0x8, 0x13, PPC2_VSX),
|
||||
VSX_LOGICAL(xxlnor, 0x8, 0x14, PPC2_VSX),
|
||||
VSX_LOGICAL(xxleqv, 0x8, 0x17, PPC2_VSX207),
|
||||
VSX_LOGICAL(xxlnand, 0x8, 0x16, PPC2_VSX207),
|
||||
VSX_LOGICAL(xxlorc, 0x8, 0x15, PPC2_VSX207),
|
||||
GEN_XX3FORM(xxmrghw, 0x08, 0x02, PPC2_VSX),
|
||||
GEN_XX3FORM(xxmrglw, 0x08, 0x06, PPC2_VSX),
|
||||
GEN_XX2FORM(xxspltw, 0x08, 0x0A, PPC2_VSX),
|
||||
GEN_XX3FORM_DM(xxsldwi, 0x08, 0x00),
|
||||
|
||||
#define GEN_XXSEL_ROW(opc3) \
|
||||
GEN_HANDLER2_E(xxsel, "xxsel", 0x3C, 0x18, opc3, 0, PPC_NONE, PPC2_VSX), \
|
||||
GEN_HANDLER2_E(xxsel, "xxsel", 0x3C, 0x19, opc3, 0, PPC_NONE, PPC2_VSX), \
|
||||
GEN_HANDLER2_E(xxsel, "xxsel", 0x3C, 0x1A, opc3, 0, PPC_NONE, PPC2_VSX), \
|
||||
GEN_HANDLER2_E(xxsel, "xxsel", 0x3C, 0x1B, opc3, 0, PPC_NONE, PPC2_VSX), \
|
||||
GEN_HANDLER2_E(xxsel, "xxsel", 0x3C, 0x1C, opc3, 0, PPC_NONE, PPC2_VSX), \
|
||||
GEN_HANDLER2_E(xxsel, "xxsel", 0x3C, 0x1D, opc3, 0, PPC_NONE, PPC2_VSX), \
|
||||
GEN_HANDLER2_E(xxsel, "xxsel", 0x3C, 0x1E, opc3, 0, PPC_NONE, PPC2_VSX), \
|
||||
GEN_HANDLER2_E(xxsel, "xxsel", 0x3C, 0x1F, opc3, 0, PPC_NONE, PPC2_VSX), \
|
||||
|
||||
GEN_XXSEL_ROW(0x00)
|
||||
GEN_XXSEL_ROW(0x01)
|
||||
GEN_XXSEL_ROW(0x02)
|
||||
GEN_XXSEL_ROW(0x03)
|
||||
GEN_XXSEL_ROW(0x04)
|
||||
GEN_XXSEL_ROW(0x05)
|
||||
GEN_XXSEL_ROW(0x06)
|
||||
GEN_XXSEL_ROW(0x07)
|
||||
GEN_XXSEL_ROW(0x08)
|
||||
GEN_XXSEL_ROW(0x09)
|
||||
GEN_XXSEL_ROW(0x0A)
|
||||
GEN_XXSEL_ROW(0x0B)
|
||||
GEN_XXSEL_ROW(0x0C)
|
||||
GEN_XXSEL_ROW(0x0D)
|
||||
GEN_XXSEL_ROW(0x0E)
|
||||
GEN_XXSEL_ROW(0x0F)
|
||||
GEN_XXSEL_ROW(0x10)
|
||||
GEN_XXSEL_ROW(0x11)
|
||||
GEN_XXSEL_ROW(0x12)
|
||||
GEN_XXSEL_ROW(0x13)
|
||||
GEN_XXSEL_ROW(0x14)
|
||||
GEN_XXSEL_ROW(0x15)
|
||||
GEN_XXSEL_ROW(0x16)
|
||||
GEN_XXSEL_ROW(0x17)
|
||||
GEN_XXSEL_ROW(0x18)
|
||||
GEN_XXSEL_ROW(0x19)
|
||||
GEN_XXSEL_ROW(0x1A)
|
||||
GEN_XXSEL_ROW(0x1B)
|
||||
GEN_XXSEL_ROW(0x1C)
|
||||
GEN_XXSEL_ROW(0x1D)
|
||||
GEN_XXSEL_ROW(0x1E)
|
||||
GEN_XXSEL_ROW(0x1F)
|
||||
|
||||
GEN_XX3FORM_DM(xxpermdi, 0x08, 0x01),
|
|
@ -7459,7 +7459,8 @@ enum BOOK3S_CPU_TYPE {
|
|||
BOOK3S_CPU_POWER5PLUS,
|
||||
BOOK3S_CPU_POWER6,
|
||||
BOOK3S_CPU_POWER7,
|
||||
BOOK3S_CPU_POWER8
|
||||
BOOK3S_CPU_POWER8,
|
||||
BOOK3S_CPU_POWER9
|
||||
};
|
||||
|
||||
static void gen_fscr_facility_check(DisasContext *ctx, int facility_sprn,
|
||||
|
@ -7469,7 +7470,6 @@ static void gen_fscr_facility_check(DisasContext *ctx, int facility_sprn,
|
|||
TCGv_i32 t2 = tcg_const_i32(sprn);
|
||||
TCGv_i32 t3 = tcg_const_i32(cause);
|
||||
|
||||
gen_update_current_nip(ctx);
|
||||
gen_helper_fscr_facility_check(cpu_env, t1, t2, t3);
|
||||
|
||||
tcg_temp_free_i32(t3);
|
||||
|
@ -7484,7 +7484,6 @@ static void gen_msr_facility_check(DisasContext *ctx, int facility_sprn,
|
|||
TCGv_i32 t2 = tcg_const_i32(sprn);
|
||||
TCGv_i32 t3 = tcg_const_i32(cause);
|
||||
|
||||
gen_update_current_nip(ctx);
|
||||
gen_helper_msr_facility_check(cpu_env, t1, t2, t3);
|
||||
|
||||
tcg_temp_free_i32(t3);
|
||||
|
@ -8241,6 +8240,7 @@ static void init_proc_book3s_64(CPUPPCState *env, int version)
|
|||
break;
|
||||
case BOOK3S_CPU_POWER7:
|
||||
case BOOK3S_CPU_POWER8:
|
||||
case BOOK3S_CPU_POWER9:
|
||||
gen_spr_book3s_ids(env);
|
||||
gen_spr_amr(env, version >= BOOK3S_CPU_POWER8);
|
||||
gen_spr_book3s_purr(env);
|
||||
|
@ -8293,6 +8293,7 @@ static void init_proc_book3s_64(CPUPPCState *env, int version)
|
|||
break;
|
||||
case BOOK3S_CPU_POWER7:
|
||||
case BOOK3S_CPU_POWER8:
|
||||
case BOOK3S_CPU_POWER9:
|
||||
default:
|
||||
env->slb_nr = 32;
|
||||
break;
|
||||
|
@ -8310,6 +8311,7 @@ static void init_proc_book3s_64(CPUPPCState *env, int version)
|
|||
ppcPOWER7_irq_init(ppc_env_get_cpu(env));
|
||||
break;
|
||||
case BOOK3S_CPU_POWER8:
|
||||
case BOOK3S_CPU_POWER9:
|
||||
init_excp_POWER8(env);
|
||||
ppcPOWER7_irq_init(ppc_env_get_cpu(env));
|
||||
break;
|
||||
|
@ -8772,6 +8774,86 @@ POWERPC_FAMILY(POWER8)(ObjectClass *oc, void *data)
|
|||
pcc->l1_icache_size = 0x8000;
|
||||
pcc->interrupts_big_endian = ppc_cpu_interrupts_big_endian_lpcr;
|
||||
}
|
||||
static void init_proc_POWER9(CPUPPCState *env)
|
||||
{
|
||||
init_proc_book3s_64(env, BOOK3S_CPU_POWER9);
|
||||
}
|
||||
|
||||
static bool ppc_pvr_match_power9(PowerPCCPUClass *pcc, uint32_t pvr)
|
||||
{
|
||||
if ((pvr & CPU_POWERPC_POWER_SERVER_MASK) == CPU_POWERPC_POWER9_BASE) {
|
||||
return true;
|
||||
}
|
||||
return false;
|
||||
}
|
||||
|
||||
POWERPC_FAMILY(POWER9)(ObjectClass *oc, void *data)
|
||||
{
|
||||
DeviceClass *dc = DEVICE_CLASS(oc);
|
||||
PowerPCCPUClass *pcc = POWERPC_CPU_CLASS(oc);
|
||||
|
||||
dc->fw_name = "PowerPC,POWER9";
|
||||
dc->desc = "POWER9";
|
||||
dc->props = powerpc_servercpu_properties;
|
||||
pcc->pvr_match = ppc_pvr_match_power9;
|
||||
pcc->pcr_mask = PCR_COMPAT_2_05 | PCR_COMPAT_2_06 | PCR_COMPAT_2_07;
|
||||
pcc->init_proc = init_proc_POWER9;
|
||||
pcc->check_pow = check_pow_nocheck;
|
||||
pcc->insns_flags = PPC_INSNS_BASE | PPC_ISEL | PPC_STRING | PPC_MFTB |
|
||||
PPC_FLOAT | PPC_FLOAT_FSEL | PPC_FLOAT_FRES |
|
||||
PPC_FLOAT_FSQRT | PPC_FLOAT_FRSQRTE |
|
||||
PPC_FLOAT_FRSQRTES |
|
||||
PPC_FLOAT_STFIWX |
|
||||
PPC_FLOAT_EXT |
|
||||
PPC_CACHE | PPC_CACHE_ICBI | PPC_CACHE_DCBZ |
|
||||
PPC_MEM_SYNC | PPC_MEM_EIEIO |
|
||||
PPC_MEM_TLBIE | PPC_MEM_TLBSYNC |
|
||||
PPC_64B | PPC_64BX | PPC_ALTIVEC |
|
||||
PPC_SEGMENT_64B | PPC_SLBI |
|
||||
PPC_POPCNTB | PPC_POPCNTWD |
|
||||
PPC_CILDST;
|
||||
pcc->insns_flags2 = PPC2_VSX | PPC2_VSX207 | PPC2_DFP | PPC2_DBRX |
|
||||
PPC2_PERM_ISA206 | PPC2_DIVE_ISA206 |
|
||||
PPC2_ATOMIC_ISA206 | PPC2_FP_CVT_ISA206 |
|
||||
PPC2_FP_TST_ISA206 | PPC2_BCTAR_ISA207 |
|
||||
PPC2_LSQ_ISA207 | PPC2_ALTIVEC_207 |
|
||||
PPC2_ISA205 | PPC2_ISA207S | PPC2_FP_CVT_S64 |
|
||||
PPC2_TM | PPC2_PM_ISA206 | PPC2_ISA300;
|
||||
pcc->msr_mask = (1ull << MSR_SF) |
|
||||
(1ull << MSR_TM) |
|
||||
(1ull << MSR_VR) |
|
||||
(1ull << MSR_VSX) |
|
||||
(1ull << MSR_EE) |
|
||||
(1ull << MSR_PR) |
|
||||
(1ull << MSR_FP) |
|
||||
(1ull << MSR_ME) |
|
||||
(1ull << MSR_FE0) |
|
||||
(1ull << MSR_SE) |
|
||||
(1ull << MSR_DE) |
|
||||
(1ull << MSR_FE1) |
|
||||
(1ull << MSR_IR) |
|
||||
(1ull << MSR_DR) |
|
||||
(1ull << MSR_PMM) |
|
||||
(1ull << MSR_RI) |
|
||||
(1ull << MSR_LE);
|
||||
/* Using 2.07 defines until new radix model is added. */
|
||||
pcc->mmu_model = POWERPC_MMU_2_07;
|
||||
#if defined(CONFIG_SOFTMMU)
|
||||
pcc->handle_mmu_fault = ppc_hash64_handle_mmu_fault;
|
||||
/* segment page size remain the same */
|
||||
pcc->sps = &POWER7_POWER8_sps;
|
||||
#endif
|
||||
pcc->excp_model = POWERPC_EXCP_POWER8;
|
||||
pcc->bus_model = PPC_FLAGS_INPUT_POWER7;
|
||||
pcc->bfd_mach = bfd_mach_ppc64;
|
||||
pcc->flags = POWERPC_FLAG_VRE | POWERPC_FLAG_SE |
|
||||
POWERPC_FLAG_BE | POWERPC_FLAG_PMM |
|
||||
POWERPC_FLAG_BUS_CLK | POWERPC_FLAG_CFAR |
|
||||
POWERPC_FLAG_VSX | POWERPC_FLAG_TM;
|
||||
pcc->l1_dcache_size = 0x8000;
|
||||
pcc->l1_icache_size = 0x8000;
|
||||
pcc->interrupts_big_endian = ppc_cpu_interrupts_big_endian_lpcr;
|
||||
}
|
||||
|
||||
#if !defined(CONFIG_USER_ONLY)
|
||||
|
||||
|
@ -9169,13 +9251,47 @@ static int register_dblind_insn (opc_handler_t **ppc_opcodes,
|
|||
return 0;
|
||||
}
|
||||
|
||||
static int register_trplind_insn(opc_handler_t **ppc_opcodes,
|
||||
unsigned char idx1, unsigned char idx2,
|
||||
unsigned char idx3, unsigned char idx4,
|
||||
opc_handler_t *handler)
|
||||
{
|
||||
opc_handler_t **table;
|
||||
|
||||
if (register_ind_in_table(ppc_opcodes, idx1, idx2, NULL) < 0) {
|
||||
printf("*** ERROR: unable to join indirect table idx "
|
||||
"[%02x-%02x]\n", idx1, idx2);
|
||||
return -1;
|
||||
}
|
||||
table = ind_table(ppc_opcodes[idx1]);
|
||||
if (register_ind_in_table(table, idx2, idx3, NULL) < 0) {
|
||||
printf("*** ERROR: unable to join 2nd-level indirect table idx "
|
||||
"[%02x-%02x-%02x]\n", idx1, idx2, idx3);
|
||||
return -1;
|
||||
}
|
||||
table = ind_table(table[idx2]);
|
||||
if (register_ind_in_table(table, idx3, idx4, handler) < 0) {
|
||||
printf("*** ERROR: unable to insert opcode "
|
||||
"[%02x-%02x-%02x-%02x]\n", idx1, idx2, idx3, idx4);
|
||||
return -1;
|
||||
}
|
||||
return 0;
|
||||
}
|
||||
static int register_insn (opc_handler_t **ppc_opcodes, opcode_t *insn)
|
||||
{
|
||||
if (insn->opc2 != 0xFF) {
|
||||
if (insn->opc3 != 0xFF) {
|
||||
if (register_dblind_insn(ppc_opcodes, insn->opc1, insn->opc2,
|
||||
insn->opc3, &insn->handler) < 0)
|
||||
return -1;
|
||||
if (insn->opc4 != 0xFF) {
|
||||
if (register_trplind_insn(ppc_opcodes, insn->opc1, insn->opc2,
|
||||
insn->opc3, insn->opc4,
|
||||
&insn->handler) < 0) {
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
if (register_dblind_insn(ppc_opcodes, insn->opc1, insn->opc2,
|
||||
insn->opc3, &insn->handler) < 0)
|
||||
return -1;
|
||||
}
|
||||
} else {
|
||||
if (register_ind_insn(ppc_opcodes, insn->opc1,
|
||||
insn->opc2, &insn->handler) < 0)
|
||||
|
@ -9251,7 +9367,7 @@ static void dump_ppc_insns (CPUPPCState *env)
|
|||
{
|
||||
opc_handler_t **table, *handler;
|
||||
const char *p, *q;
|
||||
uint8_t opc1, opc2, opc3;
|
||||
uint8_t opc1, opc2, opc3, opc4;
|
||||
|
||||
printf("Instructions set:\n");
|
||||
/* opc1 is 6 bits long */
|
||||
|
@ -9271,34 +9387,51 @@ static void dump_ppc_insns (CPUPPCState *env)
|
|||
for (opc3 = 0; opc3 < PPC_CPU_INDIRECT_OPCODES_LEN;
|
||||
opc3++) {
|
||||
handler = table[opc3];
|
||||
if (handler->handler != &gen_invalid) {
|
||||
/* Special hack to properly dump SPE insns */
|
||||
p = strchr(handler->oname, '_');
|
||||
if (p == NULL) {
|
||||
printf("INSN: %02x %02x %02x (%02d %04d) : "
|
||||
"%s\n",
|
||||
opc1, opc2, opc3, opc1,
|
||||
(opc3 << 5) | opc2,
|
||||
handler->oname);
|
||||
} else {
|
||||
q = "speundef";
|
||||
if ((p - handler->oname) != strlen(q) ||
|
||||
memcmp(handler->oname, q, strlen(q)) != 0) {
|
||||
/* First instruction */
|
||||
printf("INSN: %02x %02x %02x (%02d %04d) : "
|
||||
"%.*s\n",
|
||||
opc1, opc2 << 1, opc3, opc1,
|
||||
(opc3 << 6) | (opc2 << 1),
|
||||
(int)(p - handler->oname),
|
||||
if (is_indirect_opcode(handler)) {
|
||||
table = ind_table(handler);
|
||||
/* opc4 is 5 bits long */
|
||||
for (opc4 = 0; opc4 < PPC_CPU_INDIRECT_OPCODES_LEN;
|
||||
opc4++) {
|
||||
handler = table[opc4];
|
||||
if (handler->handler != &gen_invalid) {
|
||||
printf("INSN: %02x %02x %02x %02x -- "
|
||||
"(%02d %04d %02d) : %s\n",
|
||||
opc1, opc2, opc3, opc4,
|
||||
opc1, (opc3 << 5) | opc2, opc4,
|
||||
handler->oname);
|
||||
}
|
||||
if (strcmp(p + 1, q) != 0) {
|
||||
/* Second instruction */
|
||||
}
|
||||
} else {
|
||||
if (handler->handler != &gen_invalid) {
|
||||
/* Special hack to properly dump SPE insns */
|
||||
p = strchr(handler->oname, '_');
|
||||
if (p == NULL) {
|
||||
printf("INSN: %02x %02x %02x (%02d %04d) : "
|
||||
"%s\n",
|
||||
opc1, (opc2 << 1) | 1, opc3, opc1,
|
||||
(opc3 << 6) | (opc2 << 1) | 1,
|
||||
p + 1);
|
||||
opc1, opc2, opc3, opc1,
|
||||
(opc3 << 5) | opc2,
|
||||
handler->oname);
|
||||
} else {
|
||||
q = "speundef";
|
||||
if ((p - handler->oname) != strlen(q)
|
||||
|| (memcmp(handler->oname, q, strlen(q))
|
||||
!= 0)) {
|
||||
/* First instruction */
|
||||
printf("INSN: %02x %02x %02x"
|
||||
"(%02d %04d) : %.*s\n",
|
||||
opc1, opc2 << 1, opc3, opc1,
|
||||
(opc3 << 6) | (opc2 << 1),
|
||||
(int)(p - handler->oname),
|
||||
handler->oname);
|
||||
}
|
||||
if (strcmp(p + 1, q) != 0) {
|
||||
/* Second instruction */
|
||||
printf("INSN: %02x %02x %02x "
|
||||
"(%02d %04d) : %s\n", opc1,
|
||||
(opc2 << 1) | 1, opc3, opc1,
|
||||
(opc3 << 6) | (opc2 << 1) | 1,
|
||||
p + 1);
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
|
@ -9774,8 +9907,8 @@ static void ppc_cpu_unrealizefn(DeviceState *dev, Error **errp)
|
|||
{
|
||||
PowerPCCPU *cpu = POWERPC_CPU(dev);
|
||||
CPUPPCState *env = &cpu->env;
|
||||
opc_handler_t **table;
|
||||
int i, j;
|
||||
opc_handler_t **table, **table_2;
|
||||
int i, j, k;
|
||||
|
||||
cpu_exec_exit(CPU(dev));
|
||||
|
||||
|
@ -9786,10 +9919,20 @@ static void ppc_cpu_unrealizefn(DeviceState *dev, Error **errp)
|
|||
if (is_indirect_opcode(env->opcodes[i])) {
|
||||
table = ind_table(env->opcodes[i]);
|
||||
for (j = 0; j < PPC_CPU_INDIRECT_OPCODES_LEN; j++) {
|
||||
if (table[j] != &invalid_handler &&
|
||||
is_indirect_opcode(table[j])) {
|
||||
if (table[j] == &invalid_handler) {
|
||||
continue;
|
||||
}
|
||||
if (is_indirect_opcode(table[j])) {
|
||||
table_2 = ind_table(table[j]);
|
||||
for (k = 0; k < PPC_CPU_INDIRECT_OPCODES_LEN; k++) {
|
||||
if (table_2[k] != &invalid_handler &&
|
||||
is_indirect_opcode(table_2[k])) {
|
||||
g_free((opc_handler_t *)((uintptr_t)table_2[k] &
|
||||
~PPC_INDIRECT));
|
||||
}
|
||||
}
|
||||
g_free((opc_handler_t *)((uintptr_t)table[j] &
|
||||
~PPC_INDIRECT));
|
||||
~PPC_INDIRECT));
|
||||
}
|
||||
}
|
||||
g_free((opc_handler_t *)((uintptr_t)env->opcodes[i] &
|
||||
|
|
|
@ -195,6 +195,7 @@ check-qtest-i386-y += tests/hd-geo-test$(EXESUF)
|
|||
gcov-files-i386-y += hw/block/hd-geometry.c
|
||||
check-qtest-i386-y += tests/boot-order-test$(EXESUF)
|
||||
check-qtest-i386-y += tests/bios-tables-test$(EXESUF)
|
||||
check-qtest-i386-y += tests/boot-serial-test$(EXESUF)
|
||||
check-qtest-i386-y += tests/pxe-test$(EXESUF)
|
||||
check-qtest-i386-y += tests/rtc-test$(EXESUF)
|
||||
check-qtest-i386-y += tests/ipmi-kcs-test$(EXESUF)
|
||||
|
@ -241,37 +242,55 @@ check-qtest-i386-y += tests/postcopy-test$(EXESUF)
|
|||
check-qtest-x86_64-y += $(check-qtest-i386-y)
|
||||
gcov-files-i386-y += i386-softmmu/hw/timer/mc146818rtc.c
|
||||
gcov-files-x86_64-y = $(subst i386-softmmu/,x86_64-softmmu/,$(gcov-files-i386-y))
|
||||
|
||||
check-qtest-alpha-y = tests/boot-serial-test$(EXESUF)
|
||||
|
||||
check-qtest-mips-y = tests/endianness-test$(EXESUF)
|
||||
|
||||
check-qtest-mips64-y = tests/endianness-test$(EXESUF)
|
||||
|
||||
check-qtest-mips64el-y = tests/endianness-test$(EXESUF)
|
||||
|
||||
check-qtest-ppc-y = tests/endianness-test$(EXESUF)
|
||||
check-qtest-ppc64-y = tests/endianness-test$(EXESUF)
|
||||
check-qtest-ppc-y += tests/boot-order-test$(EXESUF)
|
||||
check-qtest-ppc-y += tests/prom-env-test$(EXESUF)
|
||||
check-qtest-ppc-y += tests/drive_del-test$(EXESUF)
|
||||
check-qtest-ppc-y += tests/boot-serial-test$(EXESUF)
|
||||
|
||||
check-qtest-ppc64-y = tests/spapr-phb-test$(EXESUF)
|
||||
gcov-files-ppc64-y = ppc64-softmmu/hw/ppc/spapr_pci.c
|
||||
check-qtest-ppc64-y += tests/endianness-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/boot-order-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/prom-env-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/drive_del-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/postcopy-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/boot-serial-test$(EXESUF)
|
||||
|
||||
check-qtest-sh4-y = tests/endianness-test$(EXESUF)
|
||||
|
||||
check-qtest-sh4eb-y = tests/endianness-test$(EXESUF)
|
||||
|
||||
check-qtest-sparc-y = tests/prom-env-test$(EXESUF)
|
||||
#check-qtest-sparc-y += tests/m48t59-test$(EXESUF)
|
||||
#gcov-files-sparc-y = hw/timer/m48t59.c
|
||||
|
||||
check-qtest-sparc64-y = tests/endianness-test$(EXESUF)
|
||||
#check-qtest-sparc-y = tests/m48t59-test$(EXESUF)
|
||||
#check-qtest-sparc64-y += tests/m48t59-test$(EXESUF)
|
||||
gcov-files-sparc-y += hw/timer/m48t59.c
|
||||
gcov-files-sparc64-y += hw/timer/m48t59.c
|
||||
#gcov-files-sparc64-y += hw/timer/m48t59.c
|
||||
#Disabled for now, triggers a TCG bug on 32-bit hosts
|
||||
#check-qtest-sparc64-y += tests/prom-env-test$(EXESUF)
|
||||
|
||||
check-qtest-arm-y = tests/tmp105-test$(EXESUF)
|
||||
check-qtest-arm-y += tests/ds1338-test$(EXESUF)
|
||||
gcov-files-arm-y += hw/misc/tmp105.c
|
||||
check-qtest-arm-y += tests/virtio-blk-test$(EXESUF)
|
||||
gcov-files-arm-y += arm-softmmu/hw/block/virtio-blk.c
|
||||
check-qtest-ppc-y += tests/boot-order-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/boot-order-test$(EXESUF)
|
||||
check-qtest-ppc-y += tests/drive_del-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/drive_del-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/spapr-phb-test$(EXESUF)
|
||||
gcov-files-ppc64-y += ppc64-softmmu/hw/ppc/spapr_pci.c
|
||||
check-qtest-ppc-y += tests/prom-env-test$(EXESUF)
|
||||
check-qtest-ppc64-y += tests/prom-env-test$(EXESUF)
|
||||
check-qtest-sparc-y += tests/prom-env-test$(EXESUF)
|
||||
#Disabled for now, triggers a TCG bug on 32-bit hosts
|
||||
#check-qtest-sparc64-y += tests/prom-env-test$(EXESUF)
|
||||
|
||||
check-qtest-microblazeel-y = $(check-qtest-microblaze-y)
|
||||
|
||||
check-qtest-xtensaeb-y = $(check-qtest-xtensa-y)
|
||||
check-qtest-ppc64-y += tests/postcopy-test$(EXESUF)
|
||||
|
||||
check-qtest-s390x-y = tests/boot-serial-test$(EXESUF)
|
||||
|
||||
check-qtest-generic-y += tests/qom-test$(EXESUF)
|
||||
|
||||
|
@ -578,6 +597,7 @@ tests/ipmi-kcs-test$(EXESUF): tests/ipmi-kcs-test.o
|
|||
tests/ipmi-bt-test$(EXESUF): tests/ipmi-bt-test.o
|
||||
tests/hd-geo-test$(EXESUF): tests/hd-geo-test.o
|
||||
tests/boot-order-test$(EXESUF): tests/boot-order-test.o $(libqos-obj-y)
|
||||
tests/boot-serial-test$(EXESUF): tests/boot-serial-test.o $(libqos-obj-y)
|
||||
tests/bios-tables-test$(EXESUF): tests/bios-tables-test.o \
|
||||
tests/boot-sector.o $(libqos-obj-y)
|
||||
tests/pxe-test$(EXESUF): tests/pxe-test.o tests/boot-sector.o $(libqos-obj-y)
|
||||
|
|
110
tests/boot-serial-test.c
Normal file
110
tests/boot-serial-test.c
Normal file
|
@ -0,0 +1,110 @@
|
|||
/*
|
||||
* Test serial output of some machines.
|
||||
*
|
||||
* Copyright 2016 Thomas Huth, Red Hat Inc.
|
||||
*
|
||||
* This work is licensed under the terms of the GNU GPL, version 2
|
||||
* or later. See the COPYING file in the top-level directory.
|
||||
*
|
||||
* This test is used to check that the serial output of the firmware
|
||||
* (that we provide for some machines) contains an expected string.
|
||||
* Thus we check that the firmware still boots at least to a certain
|
||||
* point and so we know that the machine is not completely broken.
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "libqtest.h"
|
||||
|
||||
typedef struct testdef {
|
||||
const char *arch; /* Target architecture */
|
||||
const char *machine; /* Name of the machine */
|
||||
const char *extra; /* Additional parameters */
|
||||
const char *expect; /* Expected string in the serial output */
|
||||
} testdef_t;
|
||||
|
||||
static testdef_t tests[] = {
|
||||
{ "alpha", "clipper", "", "PCI:" },
|
||||
{ "ppc", "ppce500", "", "U-Boot" },
|
||||
{ "ppc", "prep", "", "Open Hack'Ware BIOS" },
|
||||
{ "ppc64", "ppce500", "", "U-Boot" },
|
||||
{ "ppc64", "prep", "", "Open Hack'Ware BIOS" },
|
||||
{ "ppc64", "pseries", "", "Open Firmware" },
|
||||
{ "i386", "isapc", "-cpu qemu32 -device sga", "SGABIOS" },
|
||||
{ "i386", "pc", "-device sga", "SGABIOS" },
|
||||
{ "i386", "q35", "-device sga", "SGABIOS" },
|
||||
{ "x86_64", "isapc", "-cpu qemu32 -device sga", "SGABIOS" },
|
||||
{ "x86_64", "q35", "-device sga", "SGABIOS" },
|
||||
{ "s390x", "s390-ccw-virtio",
|
||||
"-nodefaults -device sclpconsole,chardev=serial0", "virtio device" },
|
||||
{ NULL }
|
||||
};
|
||||
|
||||
static void check_guest_output(const testdef_t *test, int fd)
|
||||
{
|
||||
bool output_ok = false;
|
||||
int i, nbr, pos = 0;
|
||||
char ch;
|
||||
|
||||
/* Poll serial output... Wait at most 60 seconds */
|
||||
for (i = 0; i < 6000; ++i) {
|
||||
while ((nbr = read(fd, &ch, 1)) == 1) {
|
||||
if (ch == test->expect[pos]) {
|
||||
pos += 1;
|
||||
if (test->expect[pos] == '\0') {
|
||||
/* We've reached the end of the expected string! */
|
||||
output_ok = true;
|
||||
goto done;
|
||||
}
|
||||
} else {
|
||||
pos = 0;
|
||||
}
|
||||
}
|
||||
g_assert(nbr >= 0);
|
||||
g_usleep(10000);
|
||||
}
|
||||
|
||||
done:
|
||||
g_assert(output_ok);
|
||||
}
|
||||
|
||||
static void test_machine(const void *data)
|
||||
{
|
||||
const testdef_t *test = data;
|
||||
char *args;
|
||||
char tmpname[] = "/tmp/qtest-boot-serial-XXXXXX";
|
||||
int fd;
|
||||
|
||||
fd = mkstemp(tmpname);
|
||||
g_assert(fd != -1);
|
||||
|
||||
args = g_strdup_printf("-M %s,accel=tcg -chardev file,id=serial0,path=%s"
|
||||
" -serial chardev:serial0 %s", test->machine,
|
||||
tmpname, test->extra);
|
||||
|
||||
qtest_start(args);
|
||||
unlink(tmpname);
|
||||
|
||||
check_guest_output(test, fd);
|
||||
qtest_quit(global_qtest);
|
||||
|
||||
g_free(args);
|
||||
close(fd);
|
||||
}
|
||||
|
||||
int main(int argc, char *argv[])
|
||||
{
|
||||
const char *arch = qtest_get_arch();
|
||||
int i;
|
||||
|
||||
g_test_init(&argc, &argv, NULL);
|
||||
|
||||
for (i = 0; tests[i].arch != NULL; i++) {
|
||||
if (strcmp(arch, tests[i].arch) == 0) {
|
||||
char *name = g_strdup_printf("boot-serial/%s", tests[i].machine);
|
||||
qtest_add_data_func(name, &tests[i], test_machine);
|
||||
g_free(name);
|
||||
}
|
||||
}
|
||||
|
||||
return g_test_run();
|
||||
}
|
Loading…
Reference in a new issue