mirror of
https://github.com/izzy2lost/xemu.git
synced 2026-07-06 00:20:22 -07:00
Merge remote-tracking branch 'remotes/amarkovic/tags/mips-queue-feb-14-2019' into staging
MIPS queue for February 14th, 2019 # gpg: Signature made Thu 14 Feb 2019 16:48:39 GMT # gpg: using RSA key D4972A8967F75A65 # gpg: Good signature from "Aleksandar Markovic <amarkovic@wavecomp.com>" [unknown] # gpg: WARNING: This key is not certified with a trusted signature! # gpg: There is no indication that the signature belongs to the owner. # Primary key fingerprint: 8526 FBF1 5DA3 811F 4A01 DD75 D497 2A89 67F7 5A65 * remotes/amarkovic/tags/mips-queue-feb-14-2019: tests/tcg: target/mips: Add tests for MSA logic instructions tests/tcg: target/mips: Add wrappers for MSA logic instructions tests/tcg: target/mips: Add tests for MSA interleave instructions tests/tcg: target/mips: Add wrappers for MSA interleave instructions tests/tcg: target/mips: Add tests for MSA bit counting instructions tests/tcg: target/mips: Add wrappers for MSA bit counting instructions tests/tcg: target/mips: Add a header with test utilities tests/tcg: target/mips: Add a header with test inputs tests/tcg: target/mips: Remove an unnecessary file target/mips: introduce MTTCG-enabled builds hw/mips_cpc: kick a VP when putting it into Run statewq target/mips: hold BQL in mips_vpe_wake() hw/mips_int: hold BQL for all interrupt requests target/mips: reimplement SC instruction emulation and use cmpxchg target/mips: compare virtual addresses in LL/SC sequence Signed-off-by: Peter Maydell <peter.maydell@linaro.org>
This commit is contained in:
Peter Maydell
@@ -7203,11 +7203,13 @@ case "$target_name" in
|
||||
target_compiler=$cross_cc_microblaze
|
||||
;;
|
||||
mips|mipsel)
|
||||
mttcg="yes"
|
||||
TARGET_ARCH=mips
|
||||
target_compiler=$cross_cc_mips
|
||||
echo "TARGET_ABI_MIPSO32=y" >> $config_target_mak
|
||||
;;
|
||||
mipsn32|mipsn32el)
|
||||
mttcg="yes"
|
||||
TARGET_ARCH=mips64
|
||||
TARGET_BASE_ARCH=mips
|
||||
target_compiler=$cross_cc_mipsn32
|
||||
@@ -7215,6 +7217,7 @@ case "$target_name" in
|
||||
echo "TARGET_ABI32=y" >> $config_target_mak
|
||||
;;
|
||||
mips64|mips64el)
|
||||
mttcg="yes"
|
||||
TARGET_ARCH=mips64
|
||||
TARGET_BASE_ARCH=mips
|
||||
target_compiler=$cross_cc_mips64
|
||||
|
||||
@@ -21,6 +21,7 @@
|
||||
*/
|
||||
|
||||
#include "qemu/osdep.h"
|
||||
#include "qemu/main-loop.h"
|
||||
#include "hw/hw.h"
|
||||
#include "hw/mips/cpudevs.h"
|
||||
#include "cpu.h"
|
||||
@@ -32,10 +33,17 @@ static void cpu_mips_irq_request(void *opaque, int irq, int level)
|
||||
MIPSCPU *cpu = opaque;
|
||||
CPUMIPSState *env = &cpu->env;
|
||||
CPUState *cs = CPU(cpu);
|
||||
bool locked = false;
|
||||
|
||||
if (irq < 0 || irq > 7)
|
||||
return;
|
||||
|
||||
/* Make sure locking works even if BQL is already held by the caller */
|
||||
if (!qemu_mutex_iothread_locked()) {
|
||||
locked = true;
|
||||
qemu_mutex_lock_iothread();
|
||||
}
|
||||
|
||||
if (level) {
|
||||
env->CP0_Cause |= 1 << (irq + CP0Ca_IP);
|
||||
|
||||
@@ -56,6 +64,10 @@ static void cpu_mips_irq_request(void *opaque, int irq, int level)
|
||||
} else {
|
||||
cpu_reset_interrupt(cs, CPU_INTERRUPT_HARD);
|
||||
}
|
||||
|
||||
if (locked) {
|
||||
qemu_mutex_unlock_iothread();
|
||||
}
|
||||
}
|
||||
|
||||
void cpu_mips_irq_init_cpu(MIPSCPU *cpu)
|
||||
|
||||
+15
-2
@@ -30,6 +30,14 @@ static inline uint64_t cpc_vp_run_mask(MIPSCPCState *cpc)
|
||||
return (1ULL << cpc->num_vp) - 1;
|
||||
}
|
||||
|
||||
static void mips_cpu_reset_async_work(CPUState *cs, run_on_cpu_data data)
|
||||
{
|
||||
MIPSCPCState *cpc = (MIPSCPCState *) data.host_ptr;
|
||||
|
||||
cpu_reset(cs);
|
||||
cpc->vp_running |= 1ULL << cs->cpu_index;
|
||||
}
|
||||
|
||||
static void cpc_run_vp(MIPSCPCState *cpc, uint64_t vp_run)
|
||||
{
|
||||
CPUState *cs = first_cpu;
|
||||
@@ -37,8 +45,13 @@ static void cpc_run_vp(MIPSCPCState *cpc, uint64_t vp_run)
|
||||
CPU_FOREACH(cs) {
|
||||
uint64_t i = 1ULL << cs->cpu_index;
|
||||
if (i & vp_run & ~cpc->vp_running) {
|
||||
cpu_reset(cs);
|
||||
cpc->vp_running |= i;
|
||||
/*
|
||||
* To avoid racing with a CPU we are just kicking off.
|
||||
* We do the final bit of preparation for the work in
|
||||
* the target CPUs context.
|
||||
*/
|
||||
async_safe_run_on_cpu(cs, mips_cpu_reset_async_work,
|
||||
RUN_ON_CPU_HOST_PTR(cpc));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
@@ -392,70 +392,6 @@ static const uint8_t mips_syscall_args[] = {
|
||||
# undef MIPS_SYS
|
||||
# endif /* O32 */
|
||||
|
||||
static int do_store_exclusive(CPUMIPSState *env)
|
||||
{
|
||||
target_ulong addr;
|
||||
target_ulong page_addr;
|
||||
target_ulong val;
|
||||
uint32_t val_wp = 0;
|
||||
uint32_t llnewval_wp = 0;
|
||||
int flags;
|
||||
int segv = 0;
|
||||
int reg;
|
||||
int d;
|
||||
int wp;
|
||||
|
||||
addr = env->lladdr;
|
||||
page_addr = addr & TARGET_PAGE_MASK;
|
||||
start_exclusive();
|
||||
mmap_lock();
|
||||
flags = page_get_flags(page_addr);
|
||||
if ((flags & PAGE_READ) == 0) {
|
||||
segv = 1;
|
||||
} else {
|
||||
reg = env->llreg & 0x1f;
|
||||
d = (env->llreg & 0x20) != 0;
|
||||
wp = (env->llreg & 0x40) != 0;
|
||||
if (!wp) {
|
||||
if (d) {
|
||||
segv = get_user_s64(val, addr);
|
||||
} else {
|
||||
segv = get_user_s32(val, addr);
|
||||
}
|
||||
} else {
|
||||
segv = get_user_s32(val, addr);
|
||||
segv |= get_user_s32(val_wp, addr);
|
||||
llnewval_wp = env->llnewval_wp;
|
||||
}
|
||||
if (!segv) {
|
||||
if (val != env->llval && val_wp == llnewval_wp) {
|
||||
env->active_tc.gpr[reg] = 0;
|
||||
} else {
|
||||
if (!wp) {
|
||||
if (d) {
|
||||
segv = put_user_u64(env->llnewval, addr);
|
||||
} else {
|
||||
segv = put_user_u32(env->llnewval, addr);
|
||||
}
|
||||
} else {
|
||||
segv = put_user_u32(env->llnewval, addr);
|
||||
segv |= put_user_u32(env->llnewval_wp, addr + 4);
|
||||
}
|
||||
if (!segv) {
|
||||
env->active_tc.gpr[reg] = 1;
|
||||
}
|
||||
}
|
||||
}
|
||||
}
|
||||
env->lladdr = -1;
|
||||
if (!segv) {
|
||||
env->active_tc.PC += 4;
|
||||
}
|
||||
mmap_unlock();
|
||||
end_exclusive();
|
||||
return segv;
|
||||
}
|
||||
|
||||
/* Break codes */
|
||||
enum {
|
||||
BRK_OVERFLOW = 6,
|
||||
@@ -597,15 +533,6 @@ done_syscall:
|
||||
info.si_code = TARGET_TRAP_BRKPT;
|
||||
queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
|
||||
break;
|
||||
case EXCP_SC:
|
||||
if (do_store_exclusive(env)) {
|
||||
info.si_signo = TARGET_SIGSEGV;
|
||||
info.si_errno = 0;
|
||||
info.si_code = TARGET_SEGV_MAPERR;
|
||||
info._sifields._sigfault._addr = env->active_tc.PC;
|
||||
queue_signal(env, info.si_signo, QEMU_SI_FAULT, &info);
|
||||
}
|
||||
break;
|
||||
case EXCP_DSPDIS:
|
||||
info.si_signo = TARGET_SIGILL;
|
||||
info.si_errno = 0;
|
||||
|
||||
+4
-5
@@ -11,6 +11,8 @@
|
||||
#include "exec/cpu-defs.h"
|
||||
#include "fpu/softfloat.h"
|
||||
|
||||
#define TCG_GUEST_DEFAULT_MO (0)
|
||||
|
||||
struct CPUMIPSState;
|
||||
|
||||
typedef struct CPUMIPSTLBContext CPUMIPSTLBContext;
|
||||
@@ -867,18 +869,17 @@ struct CPUMIPSState {
|
||||
#define CP0C5_NFExists 0
|
||||
int32_t CP0_Config6;
|
||||
int32_t CP0_Config7;
|
||||
uint64_t CP0_LLAddr;
|
||||
uint64_t CP0_MAAR[MIPS_MAAR_MAX];
|
||||
int32_t CP0_MAARI;
|
||||
/* XXX: Maybe make LLAddr per-TC? */
|
||||
/*
|
||||
* CP0 Register 17
|
||||
*/
|
||||
uint64_t lladdr;
|
||||
target_ulong lladdr; /* LL virtual address compared against SC */
|
||||
target_ulong llval;
|
||||
target_ulong llnewval;
|
||||
uint64_t llval_wp;
|
||||
uint32_t llnewval_wp;
|
||||
target_ulong llreg;
|
||||
uint64_t CP0_LLAddr_rw_bitmask;
|
||||
int CP0_LLAddr_shift;
|
||||
/*
|
||||
@@ -1155,8 +1156,6 @@ enum {
|
||||
|
||||
EXCP_LAST = EXCP_TLBRI,
|
||||
};
|
||||
/* Dummy exception for conditional stores. */
|
||||
#define EXCP_SC 0x100
|
||||
|
||||
/*
|
||||
* This is an internally generated WAKE request line.
|
||||
|
||||
@@ -1463,10 +1463,8 @@ void QEMU_NORETURN do_raise_exception_err(CPUMIPSState *env,
|
||||
{
|
||||
CPUState *cs = CPU(mips_env_get_cpu(env));
|
||||
|
||||
if (exception < EXCP_SC) {
|
||||
qemu_log_mask(CPU_LOG_INT, "%s: %d %d\n",
|
||||
__func__, exception, error_code);
|
||||
}
|
||||
qemu_log_mask(CPU_LOG_INT, "%s: %d %d\n",
|
||||
__func__, exception, error_code);
|
||||
cs->exception_index = exception;
|
||||
env->error_code = error_code;
|
||||
|
||||
|
||||
@@ -13,10 +13,8 @@ DEF_HELPER_4(swr, void, env, tl, tl, int)
|
||||
|
||||
#ifndef CONFIG_USER_ONLY
|
||||
DEF_HELPER_3(ll, tl, env, tl, int)
|
||||
DEF_HELPER_4(sc, tl, env, tl, tl, int)
|
||||
#ifdef TARGET_MIPS64
|
||||
DEF_HELPER_3(lld, tl, env, tl, int)
|
||||
DEF_HELPER_4(scd, tl, env, tl, tl, int)
|
||||
#endif
|
||||
#endif
|
||||
|
||||
|
||||
@@ -214,8 +214,8 @@ const VMStateDescription vmstate_tlb = {
|
||||
|
||||
const VMStateDescription vmstate_mips_cpu = {
|
||||
.name = "cpu",
|
||||
.version_id = 17,
|
||||
.minimum_version_id = 17,
|
||||
.version_id = 18,
|
||||
.minimum_version_id = 18,
|
||||
.post_load = cpu_post_load,
|
||||
.fields = (VMStateField[]) {
|
||||
/* Active TC */
|
||||
@@ -293,9 +293,10 @@ const VMStateDescription vmstate_mips_cpu = {
|
||||
VMSTATE_INT32(env.CP0_Config3, MIPSCPU),
|
||||
VMSTATE_INT32(env.CP0_Config6, MIPSCPU),
|
||||
VMSTATE_INT32(env.CP0_Config7, MIPSCPU),
|
||||
VMSTATE_UINT64(env.CP0_LLAddr, MIPSCPU),
|
||||
VMSTATE_UINT64_ARRAY(env.CP0_MAAR, MIPSCPU, MIPS_MAAR_MAX),
|
||||
VMSTATE_INT32(env.CP0_MAARI, MIPSCPU),
|
||||
VMSTATE_UINT64(env.lladdr, MIPSCPU),
|
||||
VMSTATE_UINTTL(env.lladdr, MIPSCPU),
|
||||
VMSTATE_UINTTL_ARRAY(env.CP0_WatchLo, MIPSCPU, 8),
|
||||
VMSTATE_INT32_ARRAY(env.CP0_WatchHi, MIPSCPU, 8),
|
||||
VMSTATE_UINTTL(env.CP0_XContext, MIPSCPU),
|
||||
|
||||
+21
-55
@@ -349,15 +349,15 @@ static inline hwaddr do_translate_address(CPUMIPSState *env,
|
||||
target_ulong address,
|
||||
int rw, uintptr_t retaddr)
|
||||
{
|
||||
hwaddr lladdr;
|
||||
hwaddr paddr;
|
||||
CPUState *cs = CPU(mips_env_get_cpu(env));
|
||||
|
||||
lladdr = cpu_mips_translate_address(env, address, rw);
|
||||
paddr = cpu_mips_translate_address(env, address, rw);
|
||||
|
||||
if (lladdr == -1LL) {
|
||||
if (paddr == -1LL) {
|
||||
cpu_loop_exit_restore(cs, retaddr);
|
||||
} else {
|
||||
return lladdr;
|
||||
return paddr;
|
||||
}
|
||||
}
|
||||
|
||||
@@ -370,7 +370,8 @@ target_ulong helper_##name(CPUMIPSState *env, target_ulong arg, int mem_idx) \
|
||||
} \
|
||||
do_raise_exception(env, EXCP_AdEL, GETPC()); \
|
||||
} \
|
||||
env->lladdr = do_translate_address(env, arg, 0, GETPC()); \
|
||||
env->CP0_LLAddr = do_translate_address(env, arg, 0, GETPC()); \
|
||||
env->lladdr = arg; \
|
||||
env->llval = do_##insn(env, arg, mem_idx, GETPC()); \
|
||||
return env->llval; \
|
||||
}
|
||||
@@ -379,33 +380,6 @@ HELPER_LD_ATOMIC(ll, lw, 0x3)
|
||||
HELPER_LD_ATOMIC(lld, ld, 0x7)
|
||||
#endif
|
||||
#undef HELPER_LD_ATOMIC
|
||||
|
||||
#define HELPER_ST_ATOMIC(name, ld_insn, st_insn, almask) \
|
||||
target_ulong helper_##name(CPUMIPSState *env, target_ulong arg1, \
|
||||
target_ulong arg2, int mem_idx) \
|
||||
{ \
|
||||
target_long tmp; \
|
||||
\
|
||||
if (arg2 & almask) { \
|
||||
if (!(env->hflags & MIPS_HFLAG_DM)) { \
|
||||
env->CP0_BadVAddr = arg2; \
|
||||
} \
|
||||
do_raise_exception(env, EXCP_AdES, GETPC()); \
|
||||
} \
|
||||
if (do_translate_address(env, arg2, 1, GETPC()) == env->lladdr) { \
|
||||
tmp = do_##ld_insn(env, arg2, mem_idx, GETPC()); \
|
||||
if (tmp == env->llval) { \
|
||||
do_##st_insn(env, arg2, arg1, mem_idx, GETPC()); \
|
||||
return 1; \
|
||||
} \
|
||||
} \
|
||||
return 0; \
|
||||
}
|
||||
HELPER_ST_ATOMIC(sc, lw, sw, 0x3)
|
||||
#ifdef TARGET_MIPS64
|
||||
HELPER_ST_ATOMIC(scd, ld, sd, 0x7)
|
||||
#endif
|
||||
#undef HELPER_ST_ATOMIC
|
||||
#endif
|
||||
|
||||
#ifdef TARGET_WORDS_BIGENDIAN
|
||||
@@ -665,7 +639,9 @@ static inline void mips_vpe_wake(MIPSCPU *c)
|
||||
/* Don't set ->halted = 0 directly, let it be done via cpu_has_work
|
||||
because there might be other conditions that state that c should
|
||||
be sleeping. */
|
||||
qemu_mutex_lock_iothread();
|
||||
cpu_interrupt(CPU(c), CPU_INTERRUPT_WAKE);
|
||||
qemu_mutex_unlock_iothread();
|
||||
}
|
||||
|
||||
static inline void mips_vpe_sleep(MIPSCPU *cpu)
|
||||
@@ -931,11 +907,7 @@ target_ulong helper_mftc0_tcschefback(CPUMIPSState *env)
|
||||
|
||||
target_ulong helper_mfc0_count(CPUMIPSState *env)
|
||||
{
|
||||
int32_t count;
|
||||
qemu_mutex_lock_iothread();
|
||||
count = (int32_t) cpu_mips_get_count(env);
|
||||
qemu_mutex_unlock_iothread();
|
||||
return count;
|
||||
return (int32_t)cpu_mips_get_count(env);
|
||||
}
|
||||
|
||||
target_ulong helper_mfc0_saar(CPUMIPSState *env)
|
||||
@@ -987,7 +959,7 @@ target_ulong helper_mftc0_status(CPUMIPSState *env)
|
||||
|
||||
target_ulong helper_mfc0_lladdr(CPUMIPSState *env)
|
||||
{
|
||||
return (int32_t)(env->lladdr >> env->CP0_LLAddr_shift);
|
||||
return (int32_t)(env->CP0_LLAddr >> env->CP0_LLAddr_shift);
|
||||
}
|
||||
|
||||
target_ulong helper_mfc0_maar(CPUMIPSState *env)
|
||||
@@ -1063,7 +1035,7 @@ target_ulong helper_dmfc0_tcschefback(CPUMIPSState *env)
|
||||
|
||||
target_ulong helper_dmfc0_lladdr(CPUMIPSState *env)
|
||||
{
|
||||
return env->lladdr >> env->CP0_LLAddr_shift;
|
||||
return env->CP0_LLAddr >> env->CP0_LLAddr_shift;
|
||||
}
|
||||
|
||||
target_ulong helper_dmfc0_maar(CPUMIPSState *env)
|
||||
@@ -1299,7 +1271,8 @@ void helper_mtc0_tcrestart(CPUMIPSState *env, target_ulong arg1)
|
||||
{
|
||||
env->active_tc.PC = arg1;
|
||||
env->active_tc.CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
|
||||
env->lladdr = 0ULL;
|
||||
env->CP0_LLAddr = 0;
|
||||
env->lladdr = 0;
|
||||
/* MIPS16 not implemented. */
|
||||
}
|
||||
|
||||
@@ -1311,12 +1284,14 @@ void helper_mttc0_tcrestart(CPUMIPSState *env, target_ulong arg1)
|
||||
if (other_tc == other->current_tc) {
|
||||
other->active_tc.PC = arg1;
|
||||
other->active_tc.CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
|
||||
other->lladdr = 0ULL;
|
||||
other->CP0_LLAddr = 0;
|
||||
other->lladdr = 0;
|
||||
/* MIPS16 not implemented. */
|
||||
} else {
|
||||
other->tcs[other_tc].PC = arg1;
|
||||
other->tcs[other_tc].CP0_TCStatus &= ~(1 << CP0TCSt_TDS);
|
||||
other->lladdr = 0ULL;
|
||||
other->CP0_LLAddr = 0;
|
||||
other->lladdr = 0;
|
||||
/* MIPS16 not implemented. */
|
||||
}
|
||||
}
|
||||
@@ -1617,9 +1592,7 @@ void helper_mtc0_hwrena(CPUMIPSState *env, target_ulong arg1)
|
||||
|
||||
void helper_mtc0_count(CPUMIPSState *env, target_ulong arg1)
|
||||
{
|
||||
qemu_mutex_lock_iothread();
|
||||
cpu_mips_store_count(env, arg1);
|
||||
qemu_mutex_unlock_iothread();
|
||||
}
|
||||
|
||||
void helper_mtc0_saari(CPUMIPSState *env, target_ulong arg1)
|
||||
@@ -1708,9 +1681,7 @@ void helper_mttc0_entryhi(CPUMIPSState *env, target_ulong arg1)
|
||||
|
||||
void helper_mtc0_compare(CPUMIPSState *env, target_ulong arg1)
|
||||
{
|
||||
qemu_mutex_lock_iothread();
|
||||
cpu_mips_store_compare(env, arg1);
|
||||
qemu_mutex_unlock_iothread();
|
||||
}
|
||||
|
||||
void helper_mtc0_status(CPUMIPSState *env, target_ulong arg1)
|
||||
@@ -1764,9 +1735,7 @@ void helper_mtc0_srsctl(CPUMIPSState *env, target_ulong arg1)
|
||||
|
||||
void helper_mtc0_cause(CPUMIPSState *env, target_ulong arg1)
|
||||
{
|
||||
qemu_mutex_lock_iothread();
|
||||
cpu_mips_store_cause(env, arg1);
|
||||
qemu_mutex_unlock_iothread();
|
||||
}
|
||||
|
||||
void helper_mttc0_cause(CPUMIPSState *env, target_ulong arg1)
|
||||
@@ -1868,7 +1837,7 @@ void helper_mtc0_lladdr(CPUMIPSState *env, target_ulong arg1)
|
||||
{
|
||||
target_long mask = env->CP0_LLAddr_rw_bitmask;
|
||||
arg1 = arg1 << env->CP0_LLAddr_shift;
|
||||
env->lladdr = (env->lladdr & ~mask) | (arg1 & mask);
|
||||
env->CP0_LLAddr = (env->CP0_LLAddr & ~mask) | (arg1 & mask);
|
||||
}
|
||||
|
||||
#define MTC0_MAAR_MASK(env) \
|
||||
@@ -2566,6 +2535,7 @@ static inline void exception_return(CPUMIPSState *env)
|
||||
void helper_eret(CPUMIPSState *env)
|
||||
{
|
||||
exception_return(env);
|
||||
env->CP0_LLAddr = 1;
|
||||
env->lladdr = 1;
|
||||
}
|
||||
|
||||
@@ -2609,16 +2579,12 @@ target_ulong helper_rdhwr_synci_step(CPUMIPSState *env)
|
||||
|
||||
target_ulong helper_rdhwr_cc(CPUMIPSState *env)
|
||||
{
|
||||
int32_t count;
|
||||
check_hwrena(env, 2, GETPC());
|
||||
#ifdef CONFIG_USER_ONLY
|
||||
count = env->CP0_Count;
|
||||
return env->CP0_Count;
|
||||
#else
|
||||
qemu_mutex_lock_iothread();
|
||||
count = (int32_t)cpu_mips_get_count(env);
|
||||
qemu_mutex_unlock_iothread();
|
||||
return (int32_t)cpu_mips_get_count(env);
|
||||
#endif
|
||||
return count;
|
||||
}
|
||||
|
||||
target_ulong helper_rdhwr_ccres(CPUMIPSState *env)
|
||||
|
||||
+44
-83
@@ -2450,6 +2450,7 @@ enum {
|
||||
static TCGv cpu_gpr[32], cpu_PC;
|
||||
static TCGv cpu_HI[MIPS_DSP_ACC], cpu_LO[MIPS_DSP_ACC];
|
||||
static TCGv cpu_dspctrl, btarget, bcond;
|
||||
static TCGv cpu_lladdr, cpu_llval;
|
||||
static TCGv_i32 hflags;
|
||||
static TCGv_i32 fpu_fcr0, fpu_fcr31;
|
||||
static TCGv_i64 fpu_f64[32];
|
||||
@@ -3326,48 +3327,6 @@ OP_LD_ATOMIC(lld,ld64);
|
||||
#endif
|
||||
#undef OP_LD_ATOMIC
|
||||
|
||||
#ifdef CONFIG_USER_ONLY
|
||||
#define OP_ST_ATOMIC(insn,fname,ldname,almask) \
|
||||
static inline void op_st_##insn(TCGv arg1, TCGv arg2, int rt, int mem_idx, \
|
||||
DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv t0 = tcg_temp_new(); \
|
||||
TCGLabel *l1 = gen_new_label(); \
|
||||
TCGLabel *l2 = gen_new_label(); \
|
||||
\
|
||||
tcg_gen_andi_tl(t0, arg2, almask); \
|
||||
tcg_gen_brcondi_tl(TCG_COND_EQ, t0, 0, l1); \
|
||||
tcg_gen_st_tl(arg2, cpu_env, offsetof(CPUMIPSState, CP0_BadVAddr)); \
|
||||
generate_exception(ctx, EXCP_AdES); \
|
||||
gen_set_label(l1); \
|
||||
tcg_gen_ld_tl(t0, cpu_env, offsetof(CPUMIPSState, lladdr)); \
|
||||
tcg_gen_brcond_tl(TCG_COND_NE, arg2, t0, l2); \
|
||||
tcg_gen_movi_tl(t0, rt | ((almask << 3) & 0x20)); \
|
||||
tcg_gen_st_tl(t0, cpu_env, offsetof(CPUMIPSState, llreg)); \
|
||||
tcg_gen_st_tl(arg1, cpu_env, offsetof(CPUMIPSState, llnewval)); \
|
||||
generate_exception_end(ctx, EXCP_SC); \
|
||||
gen_set_label(l2); \
|
||||
tcg_gen_movi_tl(t0, 0); \
|
||||
gen_store_gpr(t0, rt); \
|
||||
tcg_temp_free(t0); \
|
||||
}
|
||||
#else
|
||||
#define OP_ST_ATOMIC(insn,fname,ldname,almask) \
|
||||
static inline void op_st_##insn(TCGv arg1, TCGv arg2, int rt, int mem_idx, \
|
||||
DisasContext *ctx) \
|
||||
{ \
|
||||
TCGv t0 = tcg_temp_new(); \
|
||||
gen_helper_1e2i(insn, t0, arg1, arg2, mem_idx); \
|
||||
gen_store_gpr(t0, rt); \
|
||||
tcg_temp_free(t0); \
|
||||
}
|
||||
#endif
|
||||
OP_ST_ATOMIC(sc,st32,ld32s,0x3);
|
||||
#if defined(TARGET_MIPS64)
|
||||
OP_ST_ATOMIC(scd,st64,ld64,0x7);
|
||||
#endif
|
||||
#undef OP_ST_ATOMIC
|
||||
|
||||
static void gen_base_offset_addr (DisasContext *ctx, TCGv addr,
|
||||
int base, int offset)
|
||||
{
|
||||
@@ -3679,40 +3638,38 @@ static void gen_st (DisasContext *ctx, uint32_t opc, int rt,
|
||||
|
||||
|
||||
/* Store conditional */
|
||||
static void gen_st_cond (DisasContext *ctx, uint32_t opc, int rt,
|
||||
int base, int16_t offset)
|
||||
static void gen_st_cond(DisasContext *ctx, int rt, int base, int offset,
|
||||
TCGMemOp tcg_mo, bool eva)
|
||||
{
|
||||
TCGv t0, t1;
|
||||
int mem_idx = ctx->mem_idx;
|
||||
TCGv addr, t0, val;
|
||||
TCGLabel *l1 = gen_new_label();
|
||||
TCGLabel *done = gen_new_label();
|
||||
|
||||
#ifdef CONFIG_USER_ONLY
|
||||
t0 = tcg_temp_local_new();
|
||||
t1 = tcg_temp_local_new();
|
||||
#else
|
||||
t0 = tcg_temp_new();
|
||||
t1 = tcg_temp_new();
|
||||
#endif
|
||||
gen_base_offset_addr(ctx, t0, base, offset);
|
||||
gen_load_gpr(t1, rt);
|
||||
switch (opc) {
|
||||
#if defined(TARGET_MIPS64)
|
||||
case OPC_SCD:
|
||||
case R6_OPC_SCD:
|
||||
op_st_scd(t1, t0, rt, mem_idx, ctx);
|
||||
break;
|
||||
#endif
|
||||
case OPC_SCE:
|
||||
mem_idx = MIPS_HFLAG_UM;
|
||||
/* fall through */
|
||||
case OPC_SC:
|
||||
case R6_OPC_SC:
|
||||
op_st_sc(t1, t0, rt, mem_idx, ctx);
|
||||
break;
|
||||
}
|
||||
tcg_temp_free(t1);
|
||||
addr = tcg_temp_new();
|
||||
/* compare the address against that of the preceeding LL */
|
||||
gen_base_offset_addr(ctx, addr, base, offset);
|
||||
tcg_gen_brcond_tl(TCG_COND_EQ, addr, cpu_lladdr, l1);
|
||||
tcg_temp_free(addr);
|
||||
tcg_gen_movi_tl(t0, 0);
|
||||
gen_store_gpr(t0, rt);
|
||||
tcg_gen_br(done);
|
||||
|
||||
gen_set_label(l1);
|
||||
/* generate cmpxchg */
|
||||
val = tcg_temp_new();
|
||||
gen_load_gpr(val, rt);
|
||||
tcg_gen_atomic_cmpxchg_tl(t0, cpu_lladdr, cpu_llval, val,
|
||||
eva ? MIPS_HFLAG_UM : ctx->mem_idx, tcg_mo);
|
||||
tcg_gen_setcond_tl(TCG_COND_EQ, t0, t0, cpu_llval);
|
||||
gen_store_gpr(t0, rt);
|
||||
tcg_temp_free(val);
|
||||
|
||||
gen_set_label(done);
|
||||
tcg_temp_free(t0);
|
||||
}
|
||||
|
||||
|
||||
static void gen_scwp(DisasContext *ctx, uint32_t base, int16_t offset,
|
||||
uint32_t reg1, uint32_t reg2, bool eva)
|
||||
{
|
||||
@@ -6612,7 +6569,7 @@ static void gen_mfhc0(DisasContext *ctx, TCGv arg, int reg, int sel)
|
||||
case CP0_REGISTER_17:
|
||||
switch (sel) {
|
||||
case 0:
|
||||
gen_mfhc0_load64(arg, offsetof(CPUMIPSState, lladdr),
|
||||
gen_mfhc0_load64(arg, offsetof(CPUMIPSState, CP0_LLAddr),
|
||||
ctx->CP0_LLAddr_shift);
|
||||
register_name = "LLAddr";
|
||||
break;
|
||||
@@ -16864,13 +16821,13 @@ static void decode_micromips32_opc(CPUMIPSState *env, DisasContext *ctx)
|
||||
gen_st(ctx, mips32_op, rt, rs, offset);
|
||||
break;
|
||||
case SC:
|
||||
gen_st_cond(ctx, OPC_SC, rt, rs, offset);
|
||||
gen_st_cond(ctx, rt, rs, offset, MO_TESL, false);
|
||||
break;
|
||||
#if defined(TARGET_MIPS64)
|
||||
case SCD:
|
||||
check_insn(ctx, ISA_MIPS3);
|
||||
check_mips_64(ctx);
|
||||
gen_st_cond(ctx, OPC_SCD, rt, rs, offset);
|
||||
gen_st_cond(ctx, rt, rs, offset, MO_TEQ, false);
|
||||
break;
|
||||
#endif
|
||||
case LD_EVA:
|
||||
@@ -16951,7 +16908,7 @@ static void decode_micromips32_opc(CPUMIPSState *env, DisasContext *ctx)
|
||||
mips32_op = OPC_SHE;
|
||||
goto do_st_lr;
|
||||
case SCE:
|
||||
gen_st_cond(ctx, OPC_SCE, rt, rs, offset);
|
||||
gen_st_cond(ctx, rt, rs, offset, MO_TESL, true);
|
||||
break;
|
||||
case SWE:
|
||||
mips32_op = OPC_SWE;
|
||||
@@ -21558,7 +21515,7 @@ static int decode_nanomips_32_48_opc(CPUMIPSState *env, DisasContext *ctx)
|
||||
case NM_P_SC:
|
||||
switch (ctx->opcode & 0x03) {
|
||||
case NM_SC:
|
||||
gen_st_cond(ctx, OPC_SC, rt, rs, s);
|
||||
gen_st_cond(ctx, rt, rs, s, MO_TESL, false);
|
||||
break;
|
||||
case NM_SCWP:
|
||||
check_xnp(ctx);
|
||||
@@ -21661,7 +21618,7 @@ static int decode_nanomips_32_48_opc(CPUMIPSState *env, DisasContext *ctx)
|
||||
check_xnp(ctx);
|
||||
check_eva(ctx);
|
||||
check_cp0_enabled(ctx);
|
||||
gen_st_cond(ctx, OPC_SCE, rt, rs, s);
|
||||
gen_st_cond(ctx, rt, rs, s, MO_TESL, true);
|
||||
break;
|
||||
case NM_SCWPE:
|
||||
check_xnp(ctx);
|
||||
@@ -26698,7 +26655,7 @@ static void decode_opc_special3_r6(CPUMIPSState *env, DisasContext *ctx)
|
||||
}
|
||||
break;
|
||||
case R6_OPC_SC:
|
||||
gen_st_cond(ctx, op1, rt, rs, imm);
|
||||
gen_st_cond(ctx, rt, rs, imm, MO_TESL, false);
|
||||
break;
|
||||
case R6_OPC_LL:
|
||||
gen_ld(ctx, op1, rt, rs, imm);
|
||||
@@ -26725,7 +26682,7 @@ static void decode_opc_special3_r6(CPUMIPSState *env, DisasContext *ctx)
|
||||
break;
|
||||
#if defined(TARGET_MIPS64)
|
||||
case R6_OPC_SCD:
|
||||
gen_st_cond(ctx, op1, rt, rs, imm);
|
||||
gen_st_cond(ctx, rt, rs, imm, MO_TEQ, false);
|
||||
break;
|
||||
case R6_OPC_LLD:
|
||||
gen_ld(ctx, op1, rt, rs, imm);
|
||||
@@ -27580,7 +27537,7 @@ static void decode_opc_special3(CPUMIPSState *env, DisasContext *ctx)
|
||||
return;
|
||||
case OPC_SCE:
|
||||
check_cp0_enabled(ctx);
|
||||
gen_st_cond(ctx, op1, rt, rs, imm);
|
||||
gen_st_cond(ctx, rt, rs, imm, MO_TESL, true);
|
||||
return;
|
||||
case OPC_CACHEE:
|
||||
check_cp0_enabled(ctx);
|
||||
@@ -29172,8 +29129,8 @@ static void decode_opc(CPUMIPSState *env, DisasContext *ctx)
|
||||
if (ctx->insn_flags & INSN_R5900) {
|
||||
check_insn_opc_user_only(ctx, INSN_R5900);
|
||||
}
|
||||
gen_st_cond(ctx, op, rt, rs, imm);
|
||||
break;
|
||||
gen_st_cond(ctx, rt, rs, imm, MO_TESL, false);
|
||||
break;
|
||||
case OPC_CACHE:
|
||||
check_insn_opc_removed(ctx, ISA_MIPS32R6);
|
||||
check_cp0_enabled(ctx);
|
||||
@@ -29472,7 +29429,7 @@ static void decode_opc(CPUMIPSState *env, DisasContext *ctx)
|
||||
check_insn_opc_user_only(ctx, INSN_R5900);
|
||||
}
|
||||
check_mips_64(ctx);
|
||||
gen_st_cond(ctx, op, rt, rs, imm);
|
||||
gen_st_cond(ctx, rt, rs, imm, MO_TEQ, false);
|
||||
break;
|
||||
case OPC_BNVC: /* OPC_BNEZALC, OPC_BNEC, OPC_DADDI */
|
||||
if (ctx->insn_flags & ISA_MIPS32R6) {
|
||||
@@ -29795,7 +29752,7 @@ void mips_cpu_dump_state(CPUState *cs, FILE *f, fprintf_function cpu_fprintf,
|
||||
env->CP0_Status, env->CP0_Cause, env->CP0_EPC);
|
||||
cpu_fprintf(f, " Config0 0x%08x Config1 0x%08x LLAddr 0x%016"
|
||||
PRIx64 "\n",
|
||||
env->CP0_Config0, env->CP0_Config1, env->lladdr);
|
||||
env->CP0_Config0, env->CP0_Config1, env->CP0_LLAddr);
|
||||
cpu_fprintf(f, " Config2 0x%08x Config3 0x%08x\n",
|
||||
env->CP0_Config2, env->CP0_Config3);
|
||||
cpu_fprintf(f, " Config4 0x%08x Config5 0x%08x\n",
|
||||
@@ -29853,6 +29810,10 @@ void mips_tcg_init(void)
|
||||
fpu_fcr31 = tcg_global_mem_new_i32(cpu_env,
|
||||
offsetof(CPUMIPSState, active_fpu.fcr31),
|
||||
"fcr31");
|
||||
cpu_lladdr = tcg_global_mem_new(cpu_env, offsetof(CPUMIPSState, lladdr),
|
||||
"lladdr");
|
||||
cpu_llval = tcg_global_mem_new(cpu_env, offsetof(CPUMIPSState, llval),
|
||||
"llval");
|
||||
|
||||
#if defined(TARGET_MIPS64)
|
||||
cpu_mmr[0] = NULL;
|
||||
|
||||
@@ -0,0 +1,122 @@
|
||||
/*
|
||||
* Header file for pattern and random test inputs
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef TEST_INPUTS_H
|
||||
#define TEST_INPUTS_H
|
||||
|
||||
#include <stdint.h>
|
||||
|
||||
|
||||
#define PATTERN_INPUTS_COUNT 64
|
||||
#define PATTERN_INPUTS_SHORT_COUNT 8
|
||||
|
||||
uint64_t b128_pattern[PATTERN_INPUTS_COUNT][2] = {
|
||||
{ 0xFFFFFFFFFFFFFFFFULL, 0xFFFFFFFFFFFFFFFFULL, }, /* 0 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0xAAAAAAAAAAAAAAAAULL, 0xAAAAAAAAAAAAAAAAULL, },
|
||||
{ 0x5555555555555555ULL, 0x5555555555555555ULL, },
|
||||
{ 0xCCCCCCCCCCCCCCCCULL, 0xCCCCCCCCCCCCCCCCULL, },
|
||||
{ 0x3333333333333333ULL, 0x3333333333333333ULL, },
|
||||
{ 0xE38E38E38E38E38EULL, 0x38E38E38E38E38E3ULL, },
|
||||
{ 0x1C71C71C71C71C71ULL, 0xC71C71C71C71C71CULL, },
|
||||
{ 0xF0F0F0F0F0F0F0F0ULL, 0xF0F0F0F0F0F0F0F0ULL, }, /* 8 */
|
||||
{ 0x0F0F0F0F0F0F0F0FULL, 0x0F0F0F0F0F0F0F0FULL, },
|
||||
{ 0xF83E0F83E0F83E0FULL, 0x83E0F83E0F83E0F8ULL, },
|
||||
{ 0x07C1F07C1F07C1F0ULL, 0x7C1F07C1F07C1F07ULL, },
|
||||
{ 0xFC0FC0FC0FC0FC0FULL, 0xC0FC0FC0FC0FC0FCULL, },
|
||||
{ 0x03F03F03F03F03F0ULL, 0x3F03F03F03F03F03ULL, },
|
||||
{ 0xFE03F80FE03F80FEULL, 0x03F80FE03F80FE03ULL, },
|
||||
{ 0x01FC07F01FC07F01ULL, 0xFC07F01FC07F01FCULL, },
|
||||
{ 0xFF00FF00FF00FF00ULL, 0xFF00FF00FF00FF00ULL, }, /* 16 */
|
||||
{ 0x00FF00FF00FF00FFULL, 0x00FF00FF00FF00FFULL, },
|
||||
{ 0xFF803FE00FF803FEULL, 0x00FF803FE00FF803ULL, },
|
||||
{ 0x007FC01FF007FC01ULL, 0xFF007FC01FF007FCULL, },
|
||||
{ 0xFFC00FFC00FFC00FULL, 0xFC00FFC00FFC00FFULL, },
|
||||
{ 0x003FF003FF003FF0ULL, 0x03FF003FF003FF00ULL, },
|
||||
{ 0xFFE003FF800FFE00ULL, 0x3FF800FFE003FF80ULL, },
|
||||
{ 0x001FFC007FF001FFULL, 0xC007FF001FFC007FULL, },
|
||||
{ 0xFFF000FFF000FFF0ULL, 0x00FFF000FFF000FFULL, }, /* 24 */
|
||||
{ 0x000FFF000FFF000FULL, 0xFF000FFF000FFF00ULL, },
|
||||
{ 0xFFF8003FFE000FFFULL, 0x8003FFE000FFF800ULL, },
|
||||
{ 0x0007FFC001FFF000ULL, 0x7FFC001FFF0007FFULL, },
|
||||
{ 0xFFFC000FFFC000FFULL, 0xFC000FFFC000FFFCULL, },
|
||||
{ 0x0003FFF0003FFF00ULL, 0x03FFF0003FFF0003ULL, },
|
||||
{ 0xFFFE0003FFF8000FULL, 0xFFE0003FFF8000FFULL, },
|
||||
{ 0x0001FFFC0007FFF0ULL, 0x001FFFC0007FFF00ULL, },
|
||||
{ 0xFFFF0000FFFF0000ULL, 0xFFFF0000FFFF0000ULL, }, /* 32 */
|
||||
{ 0x0000FFFF0000FFFFULL, 0x0000FFFF0000FFFFULL, },
|
||||
{ 0xFFFF80003FFFE000ULL, 0x0FFFF80003FFFE00ULL, },
|
||||
{ 0x00007FFFC0001FFFULL, 0xF00007FFFC0001FFULL, },
|
||||
{ 0xFFFFC0000FFFFC00ULL, 0x00FFFFC0000FFFFCULL, },
|
||||
{ 0x00003FFFF00003FFULL, 0xFF00003FFFF00003ULL, },
|
||||
{ 0xFFFFE00003FFFF80ULL, 0x000FFFFE00003FFFULL, },
|
||||
{ 0x00001FFFFC00007FULL, 0xFFF00001FFFFC000ULL, },
|
||||
{ 0xFFFFF00000FFFFF0ULL, 0x0000FFFFF00000FFULL, }, /* 40 */
|
||||
{ 0x00000FFFFF00000FULL, 0xFFFF00000FFFFF00ULL, },
|
||||
{ 0xFFFFF800003FFFFEULL, 0x00000FFFFF800003ULL, },
|
||||
{ 0x000007FFFFC00001ULL, 0xFFFFF000007FFFFCULL, },
|
||||
{ 0xFFFFFC00000FFFFFULL, 0xC00000FFFFFC0000ULL, },
|
||||
{ 0x000003FFFFF00000ULL, 0x3FFFFF000003FFFFULL, },
|
||||
{ 0xFFFFFE000003FFFFULL, 0xF800000FFFFFE000ULL, },
|
||||
{ 0x000001FFFFFC0000ULL, 0x07FFFFF000001FFFULL, },
|
||||
{ 0xFFFFFF000000FFFFULL, 0xFF000000FFFFFF00ULL, }, /* 48 */
|
||||
{ 0x000000FFFFFF0000ULL, 0x00FFFFFF000000FFULL, },
|
||||
{ 0xFFFFFF8000003FFFULL, 0xFFE000000FFFFFF8ULL, },
|
||||
{ 0x0000007FFFFFC000ULL, 0x001FFFFFF0000007ULL, },
|
||||
{ 0xFFFFFFC000000FFFULL, 0xFFFC000000FFFFFFULL, },
|
||||
{ 0x0000003FFFFFF000ULL, 0x0003FFFFFF000000ULL, },
|
||||
{ 0xFFFFFFE0000003FFULL, 0xFFFF8000000FFFFFULL, },
|
||||
{ 0x0000001FFFFFFC00ULL, 0x00007FFFFFF00000ULL, },
|
||||
{ 0xFFFFFFF0000000FFULL, 0xFFFFF0000000FFFFULL, }, /* 56 */
|
||||
{ 0x0000000FFFFFFF00ULL, 0x00000FFFFFFF0000ULL, },
|
||||
{ 0xFFFFFFF80000003FULL, 0xFFFFFE0000000FFFULL, },
|
||||
{ 0x00000007FFFFFFC0ULL, 0x000001FFFFFFF000ULL, },
|
||||
{ 0xFFFFFFFC0000000FULL, 0xFFFFFFC0000000FFULL, },
|
||||
{ 0x00000003FFFFFFF0ULL, 0x0000003FFFFFFF00ULL, },
|
||||
{ 0xFFFFFFFE00000003ULL, 0xFFFFFFF80000000FULL, },
|
||||
{ 0x00000001FFFFFFFCULL, 0x00000007FFFFFFF0ULL, },
|
||||
};
|
||||
|
||||
|
||||
#define RANDOM_INPUTS_COUNT 16
|
||||
#define RANDOM_INPUTS_SHORT_COUNT 4
|
||||
|
||||
uint64_t b128_random[RANDOM_INPUTS_COUNT][2] = {
|
||||
{ 0x886AE6CC28625540ULL, 0x4B670B5EFE7BB00CULL, }, /* 0 */
|
||||
{ 0xFBBE00634D93C708ULL, 0x12F7BB1A153F52FCULL, },
|
||||
{ 0xAC5AAEAAB9CF8B80ULL, 0x27D8C6FFAB2B2514ULL, },
|
||||
{ 0x704F164D5E31E24EULL, 0x8DF188D8A942E2A0ULL, },
|
||||
{ 0xB9926B7C7DAF4258ULL, 0xA1227CADDCCE65B6ULL, },
|
||||
{ 0xD027BE89FF0A2EF9ULL, 0x170B5050FEA53078ULL, },
|
||||
{ 0xB83B580665CABC4AULL, 0x91230822BFF0BA62ULL, },
|
||||
{ 0xFC8F23F09AA6B782ULL, 0x93FD6637124275AEULL, },
|
||||
{ 0x201E09CD56AEE649ULL, 0xEF5DE039A6A52758ULL, }, /* 8 */
|
||||
{ 0xA57CD91365D9E5D7ULL, 0x9321BC9881ECBA5CULL, },
|
||||
{ 0xA2E8F6F5C9CBC61BULL, 0xB2C471545E0D7A12ULL, },
|
||||
{ 0xA89CF2F131A864AEULL, 0xD2A3E87A5DB986E7ULL, },
|
||||
{ 0xE61438E9A652EA0AULL, 0xA85483D97879D41CULL, },
|
||||
{ 0x944A35FD192361A8ULL, 0xF3912DA36A0B2D6BULL, },
|
||||
{ 0x4630426322BEF79CULL, 0xEB5686F7CB19304EULL, },
|
||||
{ 0x8B5AA7A2F259DEADULL, 0xD278CBCD696417E3ULL, },
|
||||
};
|
||||
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,78 @@
|
||||
/*
|
||||
* Header file for test utilities
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef TEST_UTILS_H
|
||||
#define TEST_UTILS_H
|
||||
|
||||
#include <stdio.h>
|
||||
#include <stdint.h>
|
||||
#include <inttypes.h>
|
||||
#include <string.h>
|
||||
|
||||
#define PRINT_RESULTS 1
|
||||
|
||||
|
||||
static inline int32_t check_results(char *instruction_name,
|
||||
uint32_t test_count,
|
||||
double elapsed_time,
|
||||
uint64_t *b128_result,
|
||||
uint64_t *b128_expect)
|
||||
{
|
||||
#if PRINT_RESULTS
|
||||
uint32_t ii;
|
||||
printf("\n");
|
||||
for (ii = 0; ii < test_count; ii++) {
|
||||
uint64_t a, b;
|
||||
memcpy(&a, (b128_result + 2 * ii), 8);
|
||||
memcpy(&b, (b128_result + 2 * ii + 1), 8);
|
||||
if (ii % 8 != 0) {
|
||||
printf(" { 0x%016llxULL, 0x%016llxULL, },\n", a, b);
|
||||
} else {
|
||||
printf(" { 0x%016llxULL, 0x%016llxULL, }, /* %3d */\n",
|
||||
a, b, ii);
|
||||
}
|
||||
}
|
||||
printf("\n");
|
||||
#endif
|
||||
uint32_t i;
|
||||
uint32_t pass_count = 0;
|
||||
uint32_t fail_count = 0;
|
||||
|
||||
printf("%s: ", instruction_name);
|
||||
for (i = 0; i < test_count; i++) {
|
||||
if (b128_result[i] == b128_expect[i]) {
|
||||
pass_count++;
|
||||
} else {
|
||||
fail_count++;
|
||||
}
|
||||
}
|
||||
|
||||
printf("PASS: %3d FAIL: %3d elapsed time: %5.2f ms\n",
|
||||
pass_count, fail_count, elapsed_time);
|
||||
|
||||
if (fail_count > 0) {
|
||||
return -1;
|
||||
} else {
|
||||
return 0;
|
||||
}
|
||||
}
|
||||
|
||||
#endif
|
||||
@@ -0,0 +1,101 @@
|
||||
/*
|
||||
* Header file for wrappers around MSA instructions assembler invocations
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#ifndef WRAPPERS_MSA_H
|
||||
#define WRAPPERS_MSA_H
|
||||
|
||||
|
||||
#define DO_MSA__WD__WS(suffix, mnemonic) \
|
||||
static inline void do_msa_##suffix(void *input, void *output) \
|
||||
{ \
|
||||
__asm__ volatile ( \
|
||||
"move $t0, %0\n\t" \
|
||||
"ld.d $w11, 0($t0)\n\t" \
|
||||
#mnemonic " $w10, $w11\n\t" \
|
||||
"move $t0, %1\n\t" \
|
||||
"st.d $w10, 0($t0)\n\t" \
|
||||
: \
|
||||
: "r" (input), "r" (output) \
|
||||
: "t0", "memory" \
|
||||
); \
|
||||
}
|
||||
|
||||
DO_MSA__WD__WS(NLOC_B, nloc.b)
|
||||
DO_MSA__WD__WS(NLOC_H, nloc.h)
|
||||
DO_MSA__WD__WS(NLOC_W, nloc.w)
|
||||
DO_MSA__WD__WS(NLOC_D, nloc.d)
|
||||
|
||||
DO_MSA__WD__WS(NLZC_B, nlzc.b)
|
||||
DO_MSA__WD__WS(NLZC_H, nlzc.h)
|
||||
DO_MSA__WD__WS(NLZC_W, nlzc.w)
|
||||
DO_MSA__WD__WS(NLZC_D, nlzc.d)
|
||||
|
||||
DO_MSA__WD__WS(PCNT_B, pcnt.b)
|
||||
DO_MSA__WD__WS(PCNT_H, pcnt.h)
|
||||
DO_MSA__WD__WS(PCNT_W, pcnt.w)
|
||||
DO_MSA__WD__WS(PCNT_D, pcnt.d)
|
||||
|
||||
|
||||
#define DO_MSA__WD__WS_WT(suffix, mnemonic) \
|
||||
static inline void do_msa_##suffix(void *input1, void *input2, \
|
||||
void *output) \
|
||||
{ \
|
||||
__asm__ volatile ( \
|
||||
"move $t0, %0\n\t" \
|
||||
"ld.d $w11, 0($t0)\n\t" \
|
||||
"move $t0, %1\n\t" \
|
||||
"ld.d $w12, 0($t0)\n\t" \
|
||||
#mnemonic " $w10, $w11, $w12\n\t" \
|
||||
"move $t0, %2\n\t" \
|
||||
"st.d $w10, 0($t0)\n\t" \
|
||||
: \
|
||||
: "r" (input1), "r" (input2), "r" (output) \
|
||||
: "t0", "memory" \
|
||||
); \
|
||||
}
|
||||
|
||||
DO_MSA__WD__WS_WT(ILVEV_B, ilvev.b)
|
||||
DO_MSA__WD__WS_WT(ILVEV_H, ilvev.h)
|
||||
DO_MSA__WD__WS_WT(ILVEV_W, ilvev.w)
|
||||
DO_MSA__WD__WS_WT(ILVEV_D, ilvev.d)
|
||||
|
||||
DO_MSA__WD__WS_WT(ILVOD_B, ilvod.b)
|
||||
DO_MSA__WD__WS_WT(ILVOD_H, ilvod.h)
|
||||
DO_MSA__WD__WS_WT(ILVOD_W, ilvod.w)
|
||||
DO_MSA__WD__WS_WT(ILVOD_D, ilvod.d)
|
||||
|
||||
DO_MSA__WD__WS_WT(ILVL_B, ilvl.b)
|
||||
DO_MSA__WD__WS_WT(ILVL_H, ilvl.h)
|
||||
DO_MSA__WD__WS_WT(ILVL_W, ilvl.w)
|
||||
DO_MSA__WD__WS_WT(ILVL_D, ilvl.d)
|
||||
|
||||
DO_MSA__WD__WS_WT(ILVR_B, ilvr.b)
|
||||
DO_MSA__WD__WS_WT(ILVR_H, ilvr.h)
|
||||
DO_MSA__WD__WS_WT(ILVR_W, ilvr.w)
|
||||
DO_MSA__WD__WS_WT(ILVR_D, ilvr.d)
|
||||
|
||||
DO_MSA__WD__WS_WT(AND_V, and.v)
|
||||
DO_MSA__WD__WS_WT(NOR_V, nor.v)
|
||||
DO_MSA__WD__WS_WT(OR_V, or.v)
|
||||
DO_MSA__WD__WS_WT(XOR_V, xor.v)
|
||||
|
||||
|
||||
#endif
|
||||
@@ -1,2 +0,0 @@
|
||||
[Dolphin]
|
||||
Timestamp=2012,8,3,16,41,52
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* Test program for MSA instruction NLOC.B
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../../../include/wrappers_msa.h"
|
||||
#include "../../../include/test_inputs.h"
|
||||
#include "../../../include/test_utils.h"
|
||||
|
||||
#define TEST_COUNT_TOTAL (PATTERN_INPUTS_COUNT + RANDOM_INPUTS_COUNT)
|
||||
|
||||
|
||||
int32_t main(void)
|
||||
{
|
||||
char *instruction_name = "NLOC.B";
|
||||
int32_t ret;
|
||||
uint32_t i;
|
||||
struct timeval start, end;
|
||||
double elapsed_time;
|
||||
|
||||
uint64_t b128_result[TEST_COUNT_TOTAL][2];
|
||||
uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
|
||||
{ 0x0808080808080808ULL, 0x0808080808080808ULL, }, /* 0 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0101010101010101ULL, 0x0101010101010101ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0202020202020202ULL, 0x0202020202020202ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0301000301000301ULL, 0x0003010003010003ULL, },
|
||||
{ 0x0000020000020000ULL, 0x0200000200000200ULL, },
|
||||
{ 0x0404040404040404ULL, 0x0404040404040404ULL, }, /* 8 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0500000103050000ULL, 0x0103050000010305ULL, },
|
||||
{ 0x0002040000000204ULL, 0x0000000204000000ULL, },
|
||||
{ 0x0600020600020600ULL, 0x0206000206000206ULL, },
|
||||
{ 0x0004000004000004ULL, 0x0000040000040000ULL, },
|
||||
{ 0x0700050003000107ULL, 0x0005000300010700ULL, },
|
||||
{ 0x0006000400020000ULL, 0x0600040002000006ULL, },
|
||||
{ 0x0800080008000800ULL, 0x0800080008000800ULL, }, /* 16 */
|
||||
{ 0x0008000800080008ULL, 0x0008000800080008ULL, },
|
||||
{ 0x0801000300050007ULL, 0x0008010003000500ULL, },
|
||||
{ 0x0000020004000600ULL, 0x0800000200040006ULL, },
|
||||
{ 0x0802000600080200ULL, 0x0600080200060008ULL, },
|
||||
{ 0x0000040008000004ULL, 0x0008000004000800ULL, },
|
||||
{ 0x0803000801000700ULL, 0x0005000803000801ULL, },
|
||||
{ 0x0000060000040008ULL, 0x0200080000060000ULL, },
|
||||
{ 0x0804000804000804ULL, 0x0008040008040008ULL, }, /* 24 */
|
||||
{ 0x0000080000080000ULL, 0x0800000800000800ULL, },
|
||||
{ 0x0805000007000008ULL, 0x0100080300080500ULL, },
|
||||
{ 0x0000080200080400ULL, 0x0006000008000008ULL, },
|
||||
{ 0x0806000008020008ULL, 0x0600000802000806ULL, },
|
||||
{ 0x0000080400000800ULL, 0x0008040000080000ULL, },
|
||||
{ 0x0807000008050000ULL, 0x0803000008010008ULL, },
|
||||
{ 0x0000080600000804ULL, 0x0000080200000800ULL, },
|
||||
{ 0x0808000008080000ULL, 0x0808000008080000ULL, }, /* 32 */
|
||||
{ 0x0000080800000808ULL, 0x0000080800000808ULL, },
|
||||
{ 0x0808010000080300ULL, 0x0008050000080700ULL, },
|
||||
{ 0x0000000802000008ULL, 0x0400000806000008ULL, },
|
||||
{ 0x0808020000080600ULL, 0x0008080200000806ULL, },
|
||||
{ 0x0000000804000008ULL, 0x0800000008040000ULL, },
|
||||
{ 0x0808030000080801ULL, 0x0000080700000008ULL, },
|
||||
{ 0x0000000806000000ULL, 0x0804000008080200ULL, },
|
||||
{ 0x0808040000080804ULL, 0x0000080804000008ULL, }, /* 40 */
|
||||
{ 0x0000000808000000ULL, 0x0808000000080800ULL, },
|
||||
{ 0x0808050000000807ULL, 0x0000000808010000ULL, },
|
||||
{ 0x0000000808020000ULL, 0x0808040000000806ULL, },
|
||||
{ 0x0808060000000808ULL, 0x0200000808060000ULL, },
|
||||
{ 0x0000000808040000ULL, 0x0008080000000808ULL, },
|
||||
{ 0x0808070000000808ULL, 0x0500000008080300ULL, },
|
||||
{ 0x0000000808060000ULL, 0x0008080400000008ULL, },
|
||||
{ 0x0808080000000808ULL, 0x0800000008080800ULL, }, /* 48 */
|
||||
{ 0x0000000808080000ULL, 0x0008080800000008ULL, },
|
||||
{ 0x0808080100000008ULL, 0x0803000000080805ULL, },
|
||||
{ 0x0000000008080200ULL, 0x0000080804000000ULL, },
|
||||
{ 0x0808080200000008ULL, 0x0806000000080808ULL, },
|
||||
{ 0x0000000008080400ULL, 0x0000080808000000ULL, },
|
||||
{ 0x0808080300000008ULL, 0x0808010000000808ULL, },
|
||||
{ 0x0000000008080600ULL, 0x0000000808040000ULL, },
|
||||
{ 0x0808080400000008ULL, 0x0808040000000808ULL, }, /* 56 */
|
||||
{ 0x0000000008080800ULL, 0x0000000808080000ULL, },
|
||||
{ 0x0808080500000000ULL, 0x0808070000000008ULL, },
|
||||
{ 0x0000000008080802ULL, 0x0000000808080400ULL, },
|
||||
{ 0x0808080600000000ULL, 0x0808080200000008ULL, },
|
||||
{ 0x0000000008080804ULL, 0x0000000008080800ULL, },
|
||||
{ 0x0808080700000000ULL, 0x0808080500000000ULL, },
|
||||
{ 0x0000000008080806ULL, 0x0000000008080804ULL, },
|
||||
{ 0x0100030200000000ULL, 0x0000000007000100ULL, }, /* 64 */
|
||||
{ 0x0501000000010200ULL, 0x0004010000000006ULL, },
|
||||
{ 0x0100010101020101ULL, 0x0002020801000000ULL, },
|
||||
{ 0x0000000000000300ULL, 0x0104010201000301ULL, },
|
||||
{ 0x0101000000010000ULL, 0x0100000102020001ULL, },
|
||||
{ 0x0200010108000005ULL, 0x0000000007010000ULL, },
|
||||
{ 0x0100000000020100ULL, 0x0100000001040100ULL, },
|
||||
{ 0x0601000401010101ULL, 0x0106000000000001ULL, },
|
||||
{ 0x0000000200010300ULL, 0x0300030001010000ULL, }, /* 72 */
|
||||
{ 0x0100020000020302ULL, 0x0100010101030100ULL, },
|
||||
{ 0x0103040402020200ULL, 0x0102000000000000ULL, },
|
||||
{ 0x0101040400010001ULL, 0x0201030000010103ULL, },
|
||||
{ 0x0300000301000300ULL, 0x0100010200000200ULL, },
|
||||
{ 0x0100000600000001ULL, 0x0401000100000000ULL, },
|
||||
{ 0x0000000000010401ULL, 0x0300010402000000ULL, },
|
||||
{ 0x0100010104000201ULL, 0x0200020200000003ULL, },
|
||||
};
|
||||
|
||||
gettimeofday(&start, NULL);
|
||||
|
||||
for (i = 0; i < TEST_COUNT_TOTAL; i++) {
|
||||
if (i < PATTERN_INPUTS_COUNT) {
|
||||
do_msa_NLOC_B(b128_pattern[i], b128_result[i]);
|
||||
} else {
|
||||
do_msa_NLOC_B(b128_random[i - PATTERN_INPUTS_COUNT],
|
||||
b128_result[i]);
|
||||
}
|
||||
}
|
||||
|
||||
gettimeofday(&end, NULL);
|
||||
|
||||
elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
|
||||
elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
|
||||
|
||||
ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
|
||||
&b128_result[0][0], &b128_expect[0][0]);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* Test program for MSA instruction NLOC.D
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../../../include/wrappers_msa.h"
|
||||
#include "../../../include/test_inputs.h"
|
||||
#include "../../../include/test_utils.h"
|
||||
|
||||
#define TEST_COUNT_TOTAL (PATTERN_INPUTS_COUNT + RANDOM_INPUTS_COUNT)
|
||||
|
||||
|
||||
int32_t main(void)
|
||||
{
|
||||
char *instruction_name = "NLOC.D";
|
||||
int32_t ret;
|
||||
uint32_t i;
|
||||
struct timeval start, end;
|
||||
double elapsed_time;
|
||||
|
||||
uint64_t b128_result[TEST_COUNT_TOTAL][2];
|
||||
uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
|
||||
{ 0x0000000000000040ULL, 0x0000000000000040ULL, }, /* 0 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000002ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000003ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000004ULL, 0x0000000000000004ULL, }, /* 8 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000005ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000006ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000007ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000006ULL, },
|
||||
{ 0x0000000000000008ULL, 0x0000000000000008ULL, }, /* 16 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000009ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000008ULL, },
|
||||
{ 0x000000000000000aULL, 0x0000000000000006ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000000bULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000002ULL, },
|
||||
{ 0x000000000000000cULL, 0x0000000000000000ULL, }, /* 24 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000008ULL, },
|
||||
{ 0x000000000000000dULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000000eULL, 0x0000000000000006ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000000fULL, 0x000000000000000bULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000010ULL, 0x0000000000000010ULL, }, /* 32 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000011ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000004ULL, },
|
||||
{ 0x0000000000000012ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000008ULL, },
|
||||
{ 0x0000000000000013ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x000000000000000cULL, },
|
||||
{ 0x0000000000000014ULL, 0x0000000000000000ULL, }, /* 40 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000010ULL, },
|
||||
{ 0x0000000000000015ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000014ULL, },
|
||||
{ 0x0000000000000016ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000017ULL, 0x0000000000000005ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000018ULL, 0x0000000000000008ULL, }, /* 48 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000019ULL, 0x000000000000000bULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001aULL, 0x000000000000000eULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001bULL, 0x0000000000000011ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001cULL, 0x0000000000000014ULL, }, /* 56 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001dULL, 0x0000000000000017ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001eULL, 0x000000000000001aULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001fULL, 0x000000000000001dULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000000ULL, }, /* 64 */
|
||||
{ 0x0000000000000005ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000002ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000006ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000003ULL, }, /* 72 */
|
||||
{ 0x0000000000000001ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000003ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000004ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000003ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000002ULL, },
|
||||
};
|
||||
|
||||
gettimeofday(&start, NULL);
|
||||
|
||||
for (i = 0; i < TEST_COUNT_TOTAL; i++) {
|
||||
if (i < PATTERN_INPUTS_COUNT) {
|
||||
do_msa_NLOC_D(b128_pattern[i], b128_result[i]);
|
||||
} else {
|
||||
do_msa_NLOC_D(b128_random[i - PATTERN_INPUTS_COUNT],
|
||||
b128_result[i]);
|
||||
}
|
||||
}
|
||||
|
||||
gettimeofday(&end, NULL);
|
||||
|
||||
elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
|
||||
elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
|
||||
|
||||
ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
|
||||
&b128_result[0][0], &b128_expect[0][0]);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* Test program for MSA instruction NLOC.H
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../../../include/wrappers_msa.h"
|
||||
#include "../../../include/test_inputs.h"
|
||||
#include "../../../include/test_utils.h"
|
||||
|
||||
#define TEST_COUNT_TOTAL (PATTERN_INPUTS_COUNT + RANDOM_INPUTS_COUNT)
|
||||
|
||||
|
||||
int32_t main(void)
|
||||
{
|
||||
char *instruction_name = "NLOC.H";
|
||||
int32_t ret;
|
||||
uint32_t i;
|
||||
struct timeval start, end;
|
||||
double elapsed_time;
|
||||
|
||||
uint64_t b128_result[TEST_COUNT_TOTAL][2];
|
||||
uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
|
||||
{ 0x0010001000100010ULL, 0x0010001000100010ULL, }, /* 0 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0001000100010001ULL, 0x0001000100010001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0002000200020002ULL, 0x0002000200020002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0003000000010003ULL, 0x0000000100030000ULL, },
|
||||
{ 0x0000000200000000ULL, 0x0002000000000002ULL, },
|
||||
{ 0x0004000400040004ULL, 0x0004000400040004ULL, }, /* 8 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0005000000030000ULL, 0x0001000500000003ULL, },
|
||||
{ 0x0000000400000002ULL, 0x0000000000040000ULL, },
|
||||
{ 0x0006000200000006ULL, 0x0002000000060002ULL, },
|
||||
{ 0x0000000000040000ULL, 0x0000000400000000ULL, },
|
||||
{ 0x0007000500030001ULL, 0x0000000000000007ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0006000400020000ULL, },
|
||||
{ 0x0008000800080008ULL, 0x0008000800080008ULL, }, /* 16 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0009000000000000ULL, 0x0000000100030005ULL, },
|
||||
{ 0x0000000200040006ULL, 0x0008000000000000ULL, },
|
||||
{ 0x000a000000000002ULL, 0x0006000a00000000ULL, },
|
||||
{ 0x0000000400080000ULL, 0x0000000000040008ULL, },
|
||||
{ 0x000b000000010007ULL, 0x0000000000030009ULL, },
|
||||
{ 0x0000000600000000ULL, 0x0002000800000000ULL, },
|
||||
{ 0x000c00000004000cULL, 0x00000004000c0000ULL, }, /* 24 */
|
||||
{ 0x0000000800000000ULL, 0x0008000000000008ULL, },
|
||||
{ 0x000d000000070000ULL, 0x0001000b00000005ULL, },
|
||||
{ 0x0000000a00000004ULL, 0x0000000000080000ULL, },
|
||||
{ 0x000e0000000a0000ULL, 0x000600000002000eULL, },
|
||||
{ 0x0000000c00000008ULL, 0x0000000400000000ULL, },
|
||||
{ 0x000f0000000d0000ULL, 0x000b000000090000ULL, },
|
||||
{ 0x0000000e0000000cULL, 0x0000000a00000008ULL, },
|
||||
{ 0x0010000000100000ULL, 0x0010000000100000ULL, }, /* 32 */
|
||||
{ 0x0000001000000010ULL, 0x0000001000000010ULL, },
|
||||
{ 0x0010000100000003ULL, 0x0000000500000007ULL, },
|
||||
{ 0x0000000000020000ULL, 0x0004000000060000ULL, },
|
||||
{ 0x0010000200000006ULL, 0x0000000a0000000eULL, },
|
||||
{ 0x0000000000040000ULL, 0x00080000000c0000ULL, },
|
||||
{ 0x0010000300000009ULL, 0x0000000f00000000ULL, },
|
||||
{ 0x0000000000060000ULL, 0x000c000000100002ULL, },
|
||||
{ 0x001000040000000cULL, 0x0000001000040000ULL, }, /* 40 */
|
||||
{ 0x0000000000080000ULL, 0x0010000000000008ULL, },
|
||||
{ 0x001000050000000fULL, 0x0000000000090000ULL, },
|
||||
{ 0x00000000000a0000ULL, 0x001000040000000eULL, },
|
||||
{ 0x0010000600000010ULL, 0x00020000000e0000ULL, },
|
||||
{ 0x00000000000c0000ULL, 0x0000000800000010ULL, },
|
||||
{ 0x0010000700000010ULL, 0x0005000000100003ULL, },
|
||||
{ 0x00000000000e0000ULL, 0x0000000c00000000ULL, },
|
||||
{ 0x0010000800000010ULL, 0x0008000000100008ULL, }, /* 48 */
|
||||
{ 0x0000000000100000ULL, 0x0000001000000000ULL, },
|
||||
{ 0x0010000900000000ULL, 0x000b00000000000dULL, },
|
||||
{ 0x0000000000100002ULL, 0x0000001000040000ULL, },
|
||||
{ 0x0010000a00000000ULL, 0x000e000000000010ULL, },
|
||||
{ 0x0000000000100004ULL, 0x0000001000080000ULL, },
|
||||
{ 0x0010000b00000000ULL, 0x0010000100000010ULL, },
|
||||
{ 0x0000000000100006ULL, 0x00000000000c0000ULL, },
|
||||
{ 0x0010000c00000000ULL, 0x0010000400000010ULL, }, /* 56 */
|
||||
{ 0x0000000000100008ULL, 0x0000000000100000ULL, },
|
||||
{ 0x0010000d00000000ULL, 0x0010000700000000ULL, },
|
||||
{ 0x000000000010000aULL, 0x0000000000100004ULL, },
|
||||
{ 0x0010000e00000000ULL, 0x0010000a00000000ULL, },
|
||||
{ 0x000000000010000cULL, 0x0000000000100008ULL, },
|
||||
{ 0x0010000f00000000ULL, 0x0010000d00000000ULL, },
|
||||
{ 0x000000000010000eULL, 0x000000000010000cULL, },
|
||||
{ 0x0001000300000000ULL, 0x0000000000070001ULL, }, /* 64 */
|
||||
{ 0x0005000000000002ULL, 0x0000000100000000ULL, },
|
||||
{ 0x0001000100010001ULL, 0x0000000200010000ULL, },
|
||||
{ 0x0000000000000003ULL, 0x0001000100010003ULL, },
|
||||
{ 0x0001000000000000ULL, 0x0001000000020000ULL, },
|
||||
{ 0x0002000100080000ULL, 0x0000000000070000ULL, },
|
||||
{ 0x0001000000000001ULL, 0x0001000000010001ULL, },
|
||||
{ 0x0006000000010001ULL, 0x0001000000000000ULL, },
|
||||
{ 0x0000000000000003ULL, 0x0003000300010000ULL, }, /* 72 */
|
||||
{ 0x0001000200000003ULL, 0x0001000100010001ULL, },
|
||||
{ 0x0001000400020002ULL, 0x0001000000000000ULL, },
|
||||
{ 0x0001000400000000ULL, 0x0002000300000001ULL, },
|
||||
{ 0x0003000000010003ULL, 0x0001000100000002ULL, },
|
||||
{ 0x0001000000000000ULL, 0x0004000000000000ULL, },
|
||||
{ 0x0000000000000004ULL, 0x0003000100020000ULL, },
|
||||
{ 0x0001000100040002ULL, 0x0002000200000000ULL, },
|
||||
};
|
||||
|
||||
gettimeofday(&start, NULL);
|
||||
|
||||
for (i = 0; i < TEST_COUNT_TOTAL; i++) {
|
||||
if (i < PATTERN_INPUTS_COUNT) {
|
||||
do_msa_NLOC_H(b128_pattern[i], b128_result[i]);
|
||||
} else {
|
||||
do_msa_NLOC_H(b128_random[i - PATTERN_INPUTS_COUNT],
|
||||
b128_result[i]);
|
||||
}
|
||||
}
|
||||
|
||||
gettimeofday(&end, NULL);
|
||||
|
||||
elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
|
||||
elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
|
||||
|
||||
ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
|
||||
&b128_result[0][0], &b128_expect[0][0]);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* Test program for MSA instruction NLOC.W
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../../../include/wrappers_msa.h"
|
||||
#include "../../../include/test_inputs.h"
|
||||
#include "../../../include/test_utils.h"
|
||||
|
||||
#define TEST_COUNT_TOTAL (PATTERN_INPUTS_COUNT + RANDOM_INPUTS_COUNT)
|
||||
|
||||
|
||||
int32_t main(void)
|
||||
{
|
||||
char *instruction_name = "NLOC.W";
|
||||
int32_t ret;
|
||||
uint32_t i;
|
||||
struct timeval start, end;
|
||||
double elapsed_time;
|
||||
|
||||
uint64_t b128_result[TEST_COUNT_TOTAL][2];
|
||||
uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
|
||||
{ 0x0000002000000020ULL, 0x0000002000000020ULL, }, /* 0 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000100000001ULL, 0x0000000100000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000200000002ULL, 0x0000000200000002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000300000001ULL, 0x0000000000000003ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000200000000ULL, },
|
||||
{ 0x0000000400000004ULL, 0x0000000400000004ULL, }, /* 8 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000500000003ULL, 0x0000000100000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000004ULL, },
|
||||
{ 0x0000000600000000ULL, 0x0000000200000006ULL, },
|
||||
{ 0x0000000000000004ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000700000003ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000600000002ULL, },
|
||||
{ 0x0000000800000008ULL, 0x0000000800000008ULL, }, /* 16 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000900000000ULL, 0x0000000000000003ULL, },
|
||||
{ 0x0000000000000004ULL, 0x0000000800000000ULL, },
|
||||
{ 0x0000000a00000000ULL, 0x0000000600000000ULL, },
|
||||
{ 0x0000000000000008ULL, 0x0000000000000004ULL, },
|
||||
{ 0x0000000b00000001ULL, 0x0000000000000003ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000200000000ULL, },
|
||||
{ 0x0000000c00000004ULL, 0x000000000000000cULL, }, /* 24 */
|
||||
{ 0x0000000000000000ULL, 0x0000000800000000ULL, },
|
||||
{ 0x0000000d00000007ULL, 0x0000000100000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000008ULL, },
|
||||
{ 0x0000000e0000000aULL, 0x0000000600000002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000f0000000dULL, 0x0000000b00000009ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000001000000010ULL, 0x0000001000000010ULL, }, /* 32 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000001100000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000002ULL, 0x0000000400000006ULL, },
|
||||
{ 0x0000001200000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000004ULL, 0x000000080000000cULL, },
|
||||
{ 0x0000001300000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000006ULL, 0x0000000c00000012ULL, },
|
||||
{ 0x0000001400000000ULL, 0x0000000000000004ULL, }, /* 40 */
|
||||
{ 0x0000000000000008ULL, 0x0000001000000000ULL, },
|
||||
{ 0x0000001500000000ULL, 0x0000000000000009ULL, },
|
||||
{ 0x000000000000000aULL, 0x0000001400000000ULL, },
|
||||
{ 0x0000001600000000ULL, 0x000000020000000eULL, },
|
||||
{ 0x000000000000000cULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000001700000000ULL, 0x0000000500000013ULL, },
|
||||
{ 0x000000000000000eULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000001800000000ULL, 0x0000000800000018ULL, }, /* 48 */
|
||||
{ 0x0000000000000010ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000001900000000ULL, 0x0000000b00000000ULL, },
|
||||
{ 0x0000000000000012ULL, 0x0000000000000004ULL, },
|
||||
{ 0x0000001a00000000ULL, 0x0000000e00000000ULL, },
|
||||
{ 0x0000000000000014ULL, 0x0000000000000008ULL, },
|
||||
{ 0x0000001b00000000ULL, 0x0000001100000000ULL, },
|
||||
{ 0x0000000000000016ULL, 0x000000000000000cULL, },
|
||||
{ 0x0000001c00000000ULL, 0x0000001400000000ULL, }, /* 56 */
|
||||
{ 0x0000000000000018ULL, 0x0000000000000010ULL, },
|
||||
{ 0x0000001d00000000ULL, 0x0000001700000000ULL, },
|
||||
{ 0x000000000000001aULL, 0x0000000000000014ULL, },
|
||||
{ 0x0000001e00000000ULL, 0x0000001a00000000ULL, },
|
||||
{ 0x000000000000001cULL, 0x0000000000000018ULL, },
|
||||
{ 0x0000001f00000000ULL, 0x0000001d00000000ULL, },
|
||||
{ 0x000000000000001eULL, 0x000000000000001cULL, },
|
||||
{ 0x0000000100000000ULL, 0x0000000000000007ULL, }, /* 64 */
|
||||
{ 0x0000000500000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000100000001ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000100000001ULL, },
|
||||
{ 0x0000000100000000ULL, 0x0000000100000002ULL, },
|
||||
{ 0x0000000200000008ULL, 0x0000000000000007ULL, },
|
||||
{ 0x0000000100000000ULL, 0x0000000100000001ULL, },
|
||||
{ 0x0000000600000001ULL, 0x0000000100000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000300000001ULL, }, /* 72 */
|
||||
{ 0x0000000100000000ULL, 0x0000000100000001ULL, },
|
||||
{ 0x0000000100000002ULL, 0x0000000100000000ULL, },
|
||||
{ 0x0000000100000000ULL, 0x0000000200000000ULL, },
|
||||
{ 0x0000000300000001ULL, 0x0000000100000000ULL, },
|
||||
{ 0x0000000100000000ULL, 0x0000000400000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000300000002ULL, },
|
||||
{ 0x0000000100000004ULL, 0x0000000200000000ULL, },
|
||||
};
|
||||
|
||||
gettimeofday(&start, NULL);
|
||||
|
||||
for (i = 0; i < TEST_COUNT_TOTAL; i++) {
|
||||
if (i < PATTERN_INPUTS_COUNT) {
|
||||
do_msa_NLOC_W(b128_pattern[i], b128_result[i]);
|
||||
} else {
|
||||
do_msa_NLOC_W(b128_random[i - PATTERN_INPUTS_COUNT],
|
||||
b128_result[i]);
|
||||
}
|
||||
}
|
||||
|
||||
gettimeofday(&end, NULL);
|
||||
|
||||
elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
|
||||
elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
|
||||
|
||||
ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
|
||||
&b128_result[0][0], &b128_expect[0][0]);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* Test program for MSA instruction NLZC.B
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../../../include/wrappers_msa.h"
|
||||
#include "../../../include/test_inputs.h"
|
||||
#include "../../../include/test_utils.h"
|
||||
|
||||
#define TEST_COUNT_TOTAL (PATTERN_INPUTS_COUNT + RANDOM_INPUTS_COUNT)
|
||||
|
||||
|
||||
int32_t main(void)
|
||||
{
|
||||
char *instruction_name = "NLZC.B";
|
||||
int32_t ret;
|
||||
uint32_t i;
|
||||
struct timeval start, end;
|
||||
double elapsed_time;
|
||||
|
||||
uint64_t b128_result[TEST_COUNT_TOTAL][2];
|
||||
uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, }, /* 0 */
|
||||
{ 0x0808080808080808ULL, 0x0808080808080808ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0101010101010101ULL, 0x0101010101010101ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0202020202020202ULL, 0x0202020202020202ULL, },
|
||||
{ 0x0000020000020000ULL, 0x0200000200000200ULL, },
|
||||
{ 0x0301000301000301ULL, 0x0003010003010003ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, }, /* 8 */
|
||||
{ 0x0404040404040404ULL, 0x0404040404040404ULL, },
|
||||
{ 0x0002040000000204ULL, 0x0000000204000000ULL, },
|
||||
{ 0x0500000103050000ULL, 0x0103050000010305ULL, },
|
||||
{ 0x0004000004000004ULL, 0x0000040000040000ULL, },
|
||||
{ 0x0600020600020600ULL, 0x0206000206000206ULL, },
|
||||
{ 0x0006000400020000ULL, 0x0600040002000006ULL, },
|
||||
{ 0x0700050003000107ULL, 0x0005000300010700ULL, },
|
||||
{ 0x0008000800080008ULL, 0x0008000800080008ULL, }, /* 16 */
|
||||
{ 0x0800080008000800ULL, 0x0800080008000800ULL, },
|
||||
{ 0x0000020004000600ULL, 0x0800000200040006ULL, },
|
||||
{ 0x0801000300050007ULL, 0x0008010003000500ULL, },
|
||||
{ 0x0000040008000004ULL, 0x0008000004000800ULL, },
|
||||
{ 0x0802000600080200ULL, 0x0600080200060008ULL, },
|
||||
{ 0x0000060000040008ULL, 0x0200080000060000ULL, },
|
||||
{ 0x0803000801000700ULL, 0x0005000803000801ULL, },
|
||||
{ 0x0000080000080000ULL, 0x0800000800000800ULL, }, /* 24 */
|
||||
{ 0x0804000804000804ULL, 0x0008040008040008ULL, },
|
||||
{ 0x0000080200080400ULL, 0x0006000008000008ULL, },
|
||||
{ 0x0805000007000008ULL, 0x0100080300080500ULL, },
|
||||
{ 0x0000080400000800ULL, 0x0008040000080000ULL, },
|
||||
{ 0x0806000008020008ULL, 0x0600000802000806ULL, },
|
||||
{ 0x0000080600000804ULL, 0x0000080200000800ULL, },
|
||||
{ 0x0807000008050000ULL, 0x0803000008010008ULL, },
|
||||
{ 0x0000080800000808ULL, 0x0000080800000808ULL, }, /* 32 */
|
||||
{ 0x0808000008080000ULL, 0x0808000008080000ULL, },
|
||||
{ 0x0000000802000008ULL, 0x0400000806000008ULL, },
|
||||
{ 0x0808010000080300ULL, 0x0008050000080700ULL, },
|
||||
{ 0x0000000804000008ULL, 0x0800000008040000ULL, },
|
||||
{ 0x0808020000080600ULL, 0x0008080200000806ULL, },
|
||||
{ 0x0000000806000000ULL, 0x0804000008080200ULL, },
|
||||
{ 0x0808030000080801ULL, 0x0000080700000008ULL, },
|
||||
{ 0x0000000808000000ULL, 0x0808000000080800ULL, }, /* 40 */
|
||||
{ 0x0808040000080804ULL, 0x0000080804000008ULL, },
|
||||
{ 0x0000000808020000ULL, 0x0808040000000806ULL, },
|
||||
{ 0x0808050000000807ULL, 0x0000000808010000ULL, },
|
||||
{ 0x0000000808040000ULL, 0x0008080000000808ULL, },
|
||||
{ 0x0808060000000808ULL, 0x0200000808060000ULL, },
|
||||
{ 0x0000000808060000ULL, 0x0008080400000008ULL, },
|
||||
{ 0x0808070000000808ULL, 0x0500000008080300ULL, },
|
||||
{ 0x0000000808080000ULL, 0x0008080800000008ULL, }, /* 48 */
|
||||
{ 0x0808080000000808ULL, 0x0800000008080800ULL, },
|
||||
{ 0x0000000008080200ULL, 0x0000080804000000ULL, },
|
||||
{ 0x0808080100000008ULL, 0x0803000000080805ULL, },
|
||||
{ 0x0000000008080400ULL, 0x0000080808000000ULL, },
|
||||
{ 0x0808080200000008ULL, 0x0806000000080808ULL, },
|
||||
{ 0x0000000008080600ULL, 0x0000000808040000ULL, },
|
||||
{ 0x0808080300000008ULL, 0x0808010000000808ULL, },
|
||||
{ 0x0000000008080800ULL, 0x0000000808080000ULL, }, /* 56 */
|
||||
{ 0x0808080400000008ULL, 0x0808040000000808ULL, },
|
||||
{ 0x0000000008080802ULL, 0x0000000808080400ULL, },
|
||||
{ 0x0808080500000000ULL, 0x0808070000000008ULL, },
|
||||
{ 0x0000000008080804ULL, 0x0000000008080800ULL, },
|
||||
{ 0x0808080600000000ULL, 0x0808080200000008ULL, },
|
||||
{ 0x0000000008080806ULL, 0x0000000008080804ULL, },
|
||||
{ 0x0808080700000000ULL, 0x0808080500000000ULL, },
|
||||
{ 0x0001000002010101ULL, 0x0101040100010004ULL, }, /* 64 */
|
||||
{ 0x0000080101000004ULL, 0x0300000303020100ULL, },
|
||||
{ 0x0001000000000000ULL, 0x0200000000020203ULL, },
|
||||
{ 0x0101030101020001ULL, 0x0000000000010000ULL, },
|
||||
{ 0x0000010101000101ULL, 0x0002010000000100ULL, },
|
||||
{ 0x0002000000040200ULL, 0x0304010100000201ULL, },
|
||||
{ 0x0002010501000001ULL, 0x0002040200000001ULL, },
|
||||
{ 0x0000020000000000ULL, 0x0000010203010100ULL, },
|
||||
{ 0x0203040001000001ULL, 0x0001000200000201ULL, }, /* 72 */
|
||||
{ 0x0001000301000000ULL, 0x0002000000000001ULL, },
|
||||
{ 0x0000000000000003ULL, 0x0000010101040103ULL, },
|
||||
{ 0x0000000002000100ULL, 0x0000000101000000ULL, },
|
||||
{ 0x0003020000010004ULL, 0x0001000001010003ULL, },
|
||||
{ 0x0001020003020100ULL, 0x0000020001040201ULL, },
|
||||
{ 0x0102010102000000ULL, 0x0001000000030201ULL, },
|
||||
{ 0x0001000000010000ULL, 0x0001000001010300ULL, },
|
||||
};
|
||||
|
||||
gettimeofday(&start, NULL);
|
||||
|
||||
for (i = 0; i < TEST_COUNT_TOTAL; i++) {
|
||||
if (i < PATTERN_INPUTS_COUNT) {
|
||||
do_msa_NLZC_B(b128_pattern[i], b128_result[i]);
|
||||
} else {
|
||||
do_msa_NLZC_B(b128_random[i - PATTERN_INPUTS_COUNT],
|
||||
b128_result[i]);
|
||||
}
|
||||
}
|
||||
|
||||
gettimeofday(&end, NULL);
|
||||
|
||||
elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
|
||||
elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
|
||||
|
||||
ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
|
||||
&b128_result[0][0], &b128_expect[0][0]);
|
||||
|
||||
return ret;
|
||||
}
|
||||
@@ -0,0 +1,144 @@
|
||||
/*
|
||||
* Test program for MSA instruction NLZC.D
|
||||
*
|
||||
* Copyright (C) 2018 Wave Computing, Inc.
|
||||
* Copyright (C) 2018 Aleksandar Markovic <amarkovic@wavecomp.com>
|
||||
*
|
||||
* This program is free software: you can redistribute it and/or modify
|
||||
* it under the terms of the GNU General Public License as published by
|
||||
* the Free Software Foundation, either version 2 of the License, or
|
||||
* (at your option) any later version.
|
||||
*
|
||||
* This program is distributed in the hope that it will be useful,
|
||||
* but WITHOUT ANY WARRANTY; without even the implied warranty of
|
||||
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
||||
* GNU General Public License for more details.
|
||||
*
|
||||
* You should have received a copy of the GNU General Public License
|
||||
* along with this program. If not, see <https://www.gnu.org/licenses/>.
|
||||
*
|
||||
*/
|
||||
|
||||
#include <sys/time.h>
|
||||
#include <stdint.h>
|
||||
|
||||
#include "../../../include/wrappers_msa.h"
|
||||
#include "../../../include/test_inputs.h"
|
||||
#include "../../../include/test_utils.h"
|
||||
|
||||
#define TEST_COUNT_TOTAL (PATTERN_INPUTS_COUNT + RANDOM_INPUTS_COUNT)
|
||||
|
||||
|
||||
int32_t main(void)
|
||||
{
|
||||
char *instruction_name = "NLZC.D";
|
||||
int32_t ret;
|
||||
uint32_t i;
|
||||
struct timeval start, end;
|
||||
double elapsed_time;
|
||||
|
||||
uint64_t b128_result[TEST_COUNT_TOTAL][2];
|
||||
uint64_t b128_expect[TEST_COUNT_TOTAL][2] = {
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, }, /* 0 */
|
||||
{ 0x0000000000000040ULL, 0x0000000000000040ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000002ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000003ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, }, /* 8 */
|
||||
{ 0x0000000000000004ULL, 0x0000000000000004ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000005ULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000006ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000006ULL, },
|
||||
{ 0x0000000000000007ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, }, /* 16 */
|
||||
{ 0x0000000000000008ULL, 0x0000000000000008ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000008ULL, },
|
||||
{ 0x0000000000000009ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000000aULL, 0x0000000000000006ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000002ULL, },
|
||||
{ 0x000000000000000bULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000008ULL, }, /* 24 */
|
||||
{ 0x000000000000000cULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000000dULL, 0x0000000000000001ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000000eULL, 0x0000000000000006ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000000fULL, 0x000000000000000bULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, }, /* 32 */
|
||||
{ 0x0000000000000010ULL, 0x0000000000000010ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000004ULL, },
|
||||
{ 0x0000000000000011ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000008ULL, },
|
||||
{ 0x0000000000000012ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x000000000000000cULL, },
|
||||
{ 0x0000000000000013ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000010ULL, }, /* 40 */
|
||||
{ 0x0000000000000014ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000014ULL, },
|
||||
{ 0x0000000000000015ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000016ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000017ULL, 0x0000000000000005ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, }, /* 48 */
|
||||
{ 0x0000000000000018ULL, 0x0000000000000008ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000019ULL, 0x000000000000000bULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001aULL, 0x000000000000000eULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001bULL, 0x0000000000000011ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, }, /* 56 */
|
||||
{ 0x000000000000001cULL, 0x0000000000000014ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001dULL, 0x0000000000000017ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001eULL, 0x000000000000001aULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x000000000000001fULL, 0x000000000000001dULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000001ULL, }, /* 64 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000003ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000002ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000003ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000002ULL, 0x0000000000000000ULL, }, /* 72 */
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000001ULL, 0x0000000000000000ULL, },
|
||||
{ 0x0000000000000000ULL, 0x0000000000000000ULL, },
|
||||
};
|
||||
|
||||
gettimeofday(&start, NULL);
|
||||
|
||||
for (i = 0; i < TEST_COUNT_TOTAL; i++) {
|
||||
if (i < PATTERN_INPUTS_COUNT) {
|
||||
do_msa_NLZC_D(b128_pattern[i], b128_result[i]);
|
||||
} else {
|
||||
do_msa_NLZC_D(b128_random[i - PATTERN_INPUTS_COUNT],
|
||||
b128_result[i]);
|
||||
}
|
||||
}
|
||||
|
||||
gettimeofday(&end, NULL);
|
||||
|
||||
elapsed_time = (end.tv_sec - start.tv_sec) * 1000.0;
|
||||
elapsed_time += (end.tv_usec - start.tv_usec) / 1000.0;
|
||||
|
||||
ret = check_results(instruction_name, TEST_COUNT_TOTAL, elapsed_time,
|
||||
&b128_result[0][0], &b128_expect[0][0]);
|
||||
|
||||
return ret;
|
||||
}
|
||||
Some files were not shown because too many files have changed in this diff Show More
Reference in New Issue
Block a user