# e500 core instructions, for PSIM, the PowerPC simulator.
|
# e500 core instructions, for PSIM, the PowerPC simulator.
|
|
|
# Copyright 2003 Free Software Foundation, Inc.
|
# Copyright 2003 Free Software Foundation, Inc.
|
|
|
# Contributed by Red Hat Inc; developed under contract from Motorola.
|
# Contributed by Red Hat Inc; developed under contract from Motorola.
|
# Written by matthew green .
|
# Written by matthew green .
|
|
|
# This file is part of GDB.
|
# This file is part of GDB.
|
|
|
# This program is free software; you can redistribute it and/or modify
|
# 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
|
# it under the terms of the GNU General Public License as published by
|
# the Free Software Foundation; either version 3 of the License, or
|
# the Free Software Foundation; either version 3 of the License, or
|
# (at your option) any later version.
|
# (at your option) any later version.
|
|
|
# This program is distributed in the hope that it will be useful,
|
# This program is distributed in the hope that it will be useful,
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
# but WITHOUT ANY WARRANTY; without even the implied warranty of
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
# MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
|
# GNU General Public License for more details.
|
# GNU General Public License for more details.
|
|
|
# You should have received a copy of the GNU General Public License
|
# You should have received a copy of the GNU General Public License
|
# along with this program. If not, see .
|
# along with this program. If not, see .
|
|
|
#
|
#
|
# e500 Core Complex Instructions
|
# e500 Core Complex Instructions
|
#
|
#
|
|
|
:cache:e500::signed_word *:rAh:RA:(cpu_registers(processor)->e500.gprh + RA)
|
:cache:e500::signed_word *:rAh:RA:(cpu_registers(processor)->e500.gprh + RA)
|
:cache:e500::signed_word *:rSh:RS:(cpu_registers(processor)->e500.gprh + RS)
|
:cache:e500::signed_word *:rSh:RS:(cpu_registers(processor)->e500.gprh + RS)
|
:cache:e500::signed_word *:rBh:RB:(cpu_registers(processor)->e500.gprh + RB)
|
:cache:e500::signed_word *:rBh:RB:(cpu_registers(processor)->e500.gprh + RB)
|
|
|
# Flags for model.h
|
# Flags for model.h
|
::model-macro:::
|
::model-macro:::
|
#define PPC_INSN_INT_SPR(OUT_MASK, IN_MASK, SPR) \
|
#define PPC_INSN_INT_SPR(OUT_MASK, IN_MASK, SPR) \
|
do { \
|
do { \
|
if (CURRENT_MODEL_ISSUE > 0) \
|
if (CURRENT_MODEL_ISSUE > 0) \
|
ppc_insn_int_spr(MY_INDEX, cpu_model(processor), OUT_MASK, IN_MASK, SPR); \
|
ppc_insn_int_spr(MY_INDEX, cpu_model(processor), OUT_MASK, IN_MASK, SPR); \
|
} while (0)
|
} while (0)
|
|
|
# Schedule an instruction that takes 2 integer register and produces a special purpose output register plus an integer output register
|
# Schedule an instruction that takes 2 integer register and produces a special purpose output register plus an integer output register
|
void::model-function::ppc_insn_int_spr:itable_index index, model_data *model_ptr, const unsigned32 out_mask, const unsigned32 in_mask, const unsigned nSPR
|
void::model-function::ppc_insn_int_spr:itable_index index, model_data *model_ptr, const unsigned32 out_mask, const unsigned32 in_mask, const unsigned nSPR
|
const unsigned32 int_mask = out_mask | in_mask;
|
const unsigned32 int_mask = out_mask | in_mask;
|
model_busy *busy_ptr;
|
model_busy *busy_ptr;
|
|
|
while ((model_ptr->int_busy & int_mask) != 0 || model_ptr->spr_busy[nSPR] != 0) {
|
while ((model_ptr->int_busy & int_mask) != 0 || model_ptr->spr_busy[nSPR] != 0) {
|
if (WITH_TRACE && ppc_trace[trace_model])
|
if (WITH_TRACE && ppc_trace[trace_model])
|
model_trace_busy_p(model_ptr, int_mask, 0, 0, nSPR);
|
model_trace_busy_p(model_ptr, int_mask, 0, 0, nSPR);
|
|
|
model_ptr->nr_stalls_data++;
|
model_ptr->nr_stalls_data++;
|
model_new_cycle(model_ptr);
|
model_new_cycle(model_ptr);
|
}
|
}
|
|
|
busy_ptr = model_wait_for_unit(index, model_ptr, &model_ptr->timing[index]);
|
busy_ptr = model_wait_for_unit(index, model_ptr, &model_ptr->timing[index]);
|
busy_ptr->int_busy |= out_mask;
|
busy_ptr->int_busy |= out_mask;
|
model_ptr->int_busy |= out_mask;
|
model_ptr->int_busy |= out_mask;
|
busy_ptr->spr_busy = nSPR;
|
busy_ptr->spr_busy = nSPR;
|
model_ptr->spr_busy[nSPR] = 1;
|
model_ptr->spr_busy[nSPR] = 1;
|
busy_ptr->nr_writebacks = (PPC_ONE_BIT_SET_P(out_mask)) ? 3 : 2;
|
busy_ptr->nr_writebacks = (PPC_ONE_BIT_SET_P(out_mask)) ? 3 : 2;
|
TRACE(trace_model,("Making register %s busy.\n", spr_name(nSPR)));
|
TRACE(trace_model,("Making register %s busy.\n", spr_name(nSPR)));
|
|
|
#
|
#
|
# SPE Modulo Fractional Multiplication handling support
|
# SPE Modulo Fractional Multiplication handling support
|
#
|
#
|
:function:e500::unsigned64:ev_multiply16_smf:signed16 a, signed16 b, int *sat
|
:function:e500::unsigned64:ev_multiply16_smf:signed16 a, signed16 b, int *sat
|
signed32 a32 = a, b32 = b, rv32;
|
signed32 a32 = a, b32 = b, rv32;
|
rv32 = a * b;
|
rv32 = a * b;
|
*sat = (rv32 & (3<<30)) == (3<<30);
|
*sat = (rv32 & (3<<30)) == (3<<30);
|
return (signed64)rv32 << 1;
|
return (signed64)rv32 << 1;
|
|
|
:function:e500::unsigned64:ev_multiply32_smf:signed32 a, signed32 b, int *sat
|
:function:e500::unsigned64:ev_multiply32_smf:signed32 a, signed32 b, int *sat
|
signed64 rv64, a64 = a, b64 = b;
|
signed64 rv64, a64 = a, b64 = b;
|
rv64 = a64 * b64;
|
rv64 = a64 * b64;
|
*sat = (rv64 & ((signed64)3<<62)) == ((signed64)3<<62);
|
*sat = (rv64 & ((signed64)3<<62)) == ((signed64)3<<62);
|
/* Loses top sign bit. */
|
/* Loses top sign bit. */
|
return rv64 << 1;
|
return rv64 << 1;
|
#
|
#
|
# SPE Saturation handling support
|
# SPE Saturation handling support
|
#
|
#
|
:function:e500::signed32:ev_multiply16_ssf:signed16 a, signed16 b, int *sat
|
:function:e500::signed32:ev_multiply16_ssf:signed16 a, signed16 b, int *sat
|
signed32 rv32;
|
signed32 rv32;
|
if (a == 0xffff8000 && b == 0xffff8000)
|
if (a == 0xffff8000 && b == 0xffff8000)
|
{
|
{
|
rv32 = 0x7fffffffL;
|
rv32 = 0x7fffffffL;
|
* sat = 1;
|
* sat = 1;
|
return rv32;
|
return rv32;
|
}
|
}
|
else
|
else
|
{
|
{
|
signed32 a32 = a, b32 = b;
|
signed32 a32 = a, b32 = b;
|
|
|
rv32 = a * b;
|
rv32 = a * b;
|
* sat = (rv32 & (3<<30)) == (3<<30);
|
* sat = (rv32 & (3<<30)) == (3<<30);
|
return (signed64)rv32 << 1;
|
return (signed64)rv32 << 1;
|
}
|
}
|
|
|
:function:e500::signed64:ev_multiply32_ssf:signed32 a, signed32 b, int *sat
|
:function:e500::signed64:ev_multiply32_ssf:signed32 a, signed32 b, int *sat
|
signed64 rv64;
|
signed64 rv64;
|
if (a == 0x80000000 && b == 0x80000000)
|
if (a == 0x80000000 && b == 0x80000000)
|
{
|
{
|
rv64 = 0x7fffffffffffffffLL;
|
rv64 = 0x7fffffffffffffffLL;
|
* sat = 1;
|
* sat = 1;
|
return rv64;
|
return rv64;
|
}
|
}
|
else
|
else
|
{
|
{
|
signed64 a64 = a, b64 = b;
|
signed64 a64 = a, b64 = b;
|
rv64 = a64 * b64;
|
rv64 = a64 * b64;
|
*sat = (rv64 & ((signed64)3<<62)) == ((signed64)3<<62);
|
*sat = (rv64 & ((signed64)3<<62)) == ((signed64)3<<62);
|
/* Loses top sign bit. */
|
/* Loses top sign bit. */
|
return rv64 << 1;
|
return rv64 << 1;
|
}
|
}
|
|
|
#
|
#
|
# SPE FP handling support
|
# SPE FP handling support
|
#
|
#
|
|
|
:function:e500::void:ev_check_guard:sim_fpu *a, int fg, int fx, cpu *processor
|
:function:e500::void:ev_check_guard:sim_fpu *a, int fg, int fx, cpu *processor
|
unsigned64 guard;
|
unsigned64 guard;
|
guard = sim_fpu_guard(a, 0);
|
guard = sim_fpu_guard(a, 0);
|
if (guard & 1)
|
if (guard & 1)
|
EV_SET_SPEFSCR_BITS(fg);
|
EV_SET_SPEFSCR_BITS(fg);
|
if (guard & ~1)
|
if (guard & ~1)
|
EV_SET_SPEFSCR_BITS(fx);
|
EV_SET_SPEFSCR_BITS(fx);
|
|
|
:function:e500::void:booke_sim_fpu_32to:sim_fpu *dst, unsigned32 packed
|
:function:e500::void:booke_sim_fpu_32to:sim_fpu *dst, unsigned32 packed
|
sim_fpu_32to (dst, packed);
|
sim_fpu_32to (dst, packed);
|
|
|
/* Set normally unused fields to allow booke arithmetic. */
|
/* Set normally unused fields to allow booke arithmetic. */
|
if (dst->class == sim_fpu_class_infinity)
|
if (dst->class == sim_fpu_class_infinity)
|
{
|
{
|
dst->normal_exp = 128;
|
dst->normal_exp = 128;
|
dst->fraction = ((unsigned64)1 << 60);
|
dst->fraction = ((unsigned64)1 << 60);
|
}
|
}
|
else if (dst->class == sim_fpu_class_qnan
|
else if (dst->class == sim_fpu_class_qnan
|
|| dst->class == sim_fpu_class_snan)
|
|| dst->class == sim_fpu_class_snan)
|
{
|
{
|
dst->normal_exp = 128;
|
dst->normal_exp = 128;
|
/* This is set, but without the implicit bit, so we have to or
|
/* This is set, but without the implicit bit, so we have to or
|
in the implicit bit. */
|
in the implicit bit. */
|
dst->fraction |= ((unsigned64)1 << 60);
|
dst->fraction |= ((unsigned64)1 << 60);
|
}
|
}
|
|
|
:function:e500::int:booke_sim_fpu_add:sim_fpu *d, sim_fpu *a, sim_fpu *b, int inv, int over, int under, cpu *processor
|
:function:e500::int:booke_sim_fpu_add:sim_fpu *d, sim_fpu *a, sim_fpu *b, int inv, int over, int under, cpu *processor
|
int invalid_operand, overflow_result, underflow_result;
|
int invalid_operand, overflow_result, underflow_result;
|
int dest_exp;
|
int dest_exp;
|
|
|
invalid_operand = 0;
|
invalid_operand = 0;
|
overflow_result = 0;
|
overflow_result = 0;
|
underflow_result = 0;
|
underflow_result = 0;
|
|
|
/* Treat NaN, Inf, and denorm like normal numbers, and signal invalid
|
/* Treat NaN, Inf, and denorm like normal numbers, and signal invalid
|
operand if it hasn't already been done. */
|
operand if it hasn't already been done. */
|
if (EV_IS_INFDENORMNAN (a))
|
if (EV_IS_INFDENORMNAN (a))
|
{
|
{
|
a->class = sim_fpu_class_number;
|
a->class = sim_fpu_class_number;
|
|
|
EV_SET_SPEFSCR_BITS (inv);
|
EV_SET_SPEFSCR_BITS (inv);
|
invalid_operand = 1;
|
invalid_operand = 1;
|
}
|
}
|
if (EV_IS_INFDENORMNAN (b))
|
if (EV_IS_INFDENORMNAN (b))
|
{
|
{
|
b->class = sim_fpu_class_number;
|
b->class = sim_fpu_class_number;
|
|
|
if (! invalid_operand)
|
if (! invalid_operand)
|
{
|
{
|
EV_SET_SPEFSCR_BITS (inv);
|
EV_SET_SPEFSCR_BITS (inv);
|
invalid_operand = 1;
|
invalid_operand = 1;
|
}
|
}
|
}
|
}
|
|
|
sim_fpu_add (d, a, b);
|
sim_fpu_add (d, a, b);
|
|
|
dest_exp = booke_sim_fpu_exp (d);
|
dest_exp = booke_sim_fpu_exp (d);
|
/* If this is a denorm, force to zero, and signal underflow if
|
/* If this is a denorm, force to zero, and signal underflow if
|
we haven't already indicated invalid operand. */
|
we haven't already indicated invalid operand. */
|
if (dest_exp <= -127)
|
if (dest_exp <= -127)
|
{
|
{
|
int sign = d->sign;
|
int sign = d->sign;
|
|
|
*d = sim_fpu_zero;
|
*d = sim_fpu_zero;
|
d->sign = sign;
|
d->sign = sign;
|
if (! invalid_operand)
|
if (! invalid_operand)
|
{
|
{
|
EV_SET_SPEFSCR_BITS (under);
|
EV_SET_SPEFSCR_BITS (under);
|
underflow_result = 1;
|
underflow_result = 1;
|
}
|
}
|
}
|
}
|
/* If this is Inf/NaN, force to pmax/nmax, and signal overflow if
|
/* If this is Inf/NaN, force to pmax/nmax, and signal overflow if
|
we haven't already indicated invalid operand. */
|
we haven't already indicated invalid operand. */
|
else if (dest_exp >= 127)
|
else if (dest_exp >= 127)
|
{
|
{
|
int sign = d->sign;
|
int sign = d->sign;
|
|
|
*d = sim_fpu_max32;
|
*d = sim_fpu_max32;
|
d->sign = sign;
|
d->sign = sign;
|
if (! invalid_operand)
|
if (! invalid_operand)
|
{
|
{
|
EV_SET_SPEFSCR_BITS (over);
|
EV_SET_SPEFSCR_BITS (over);
|
overflow_result = 1;
|
overflow_result = 1;
|
}
|
}
|
}
|
}
|
/* Destination sign is sign of operand with larger magnitude, or
|
/* Destination sign is sign of operand with larger magnitude, or
|
the sign of the first operand if operands have the same
|
the sign of the first operand if operands have the same
|
magnitude. Thus if the result is zero, we force it to have
|
magnitude. Thus if the result is zero, we force it to have
|
the sign of the first operand. */
|
the sign of the first operand. */
|
else if (d->fraction == 0)
|
else if (d->fraction == 0)
|
d->sign = a->sign;
|
d->sign = a->sign;
|
|
|
return invalid_operand || overflow_result || underflow_result;
|
return invalid_operand || overflow_result || underflow_result;
|
|
|
:function:e500::unsigned32:ev_fs_add:unsigned32 aa, unsigned32 bb, int inv, int over, int under, int fg, int fx, cpu *processor
|
:function:e500::unsigned32:ev_fs_add:unsigned32 aa, unsigned32 bb, int inv, int over, int under, int fg, int fx, cpu *processor
|
sim_fpu a, b, d;
|
sim_fpu a, b, d;
|
unsigned32 w;
|
unsigned32 w;
|
int exception;
|
int exception;
|
|
|
booke_sim_fpu_32to (&a, aa);
|
booke_sim_fpu_32to (&a, aa);
|
booke_sim_fpu_32to (&b, bb);
|
booke_sim_fpu_32to (&b, bb);
|
|
|
exception = booke_sim_fpu_add (&d, &a, &b, inv, over, under,
|
exception = booke_sim_fpu_add (&d, &a, &b, inv, over, under,
|
processor);
|
processor);
|
|
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
if (! exception)
|
if (! exception)
|
ev_check_guard(&d, fg, fx, processor);
|
ev_check_guard(&d, fg, fx, processor);
|
return w;
|
return w;
|
|
|
:function:e500::unsigned32:ev_fs_sub:unsigned32 aa, unsigned32 bb, int inv, int over, int under, int fg, int fx, cpu *processor
|
:function:e500::unsigned32:ev_fs_sub:unsigned32 aa, unsigned32 bb, int inv, int over, int under, int fg, int fx, cpu *processor
|
sim_fpu a, b, d;
|
sim_fpu a, b, d;
|
unsigned32 w;
|
unsigned32 w;
|
int exception;
|
int exception;
|
|
|
booke_sim_fpu_32to (&a, aa);
|
booke_sim_fpu_32to (&a, aa);
|
booke_sim_fpu_32to (&b, bb);
|
booke_sim_fpu_32to (&b, bb);
|
|
|
/* Invert sign of second operand, and add. */
|
/* Invert sign of second operand, and add. */
|
b.sign = ! b.sign;
|
b.sign = ! b.sign;
|
exception = booke_sim_fpu_add (&d, &a, &b, inv, over, under,
|
exception = booke_sim_fpu_add (&d, &a, &b, inv, over, under,
|
processor);
|
processor);
|
|
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
if (! exception)
|
if (! exception)
|
ev_check_guard(&d, fg, fx, processor);
|
ev_check_guard(&d, fg, fx, processor);
|
return w;
|
return w;
|
|
|
# sim_fpu_exp leaves the normal_exp field undefined for Inf and NaN.
|
# sim_fpu_exp leaves the normal_exp field undefined for Inf and NaN.
|
# The booke algorithms require exp values, so we fake them here.
|
# The booke algorithms require exp values, so we fake them here.
|
# fixme: It also apparently does the same for zero, but should not.
|
# fixme: It also apparently does the same for zero, but should not.
|
:function:e500::unsigned32:booke_sim_fpu_exp:sim_fpu *x
|
:function:e500::unsigned32:booke_sim_fpu_exp:sim_fpu *x
|
int y = sim_fpu_is (x);
|
int y = sim_fpu_is (x);
|
if (y == SIM_FPU_IS_PZERO || y == SIM_FPU_IS_NZERO)
|
if (y == SIM_FPU_IS_PZERO || y == SIM_FPU_IS_NZERO)
|
return 0;
|
return 0;
|
else if (y == SIM_FPU_IS_SNAN || y == SIM_FPU_IS_QNAN
|
else if (y == SIM_FPU_IS_SNAN || y == SIM_FPU_IS_QNAN
|
|| y == SIM_FPU_IS_NINF || y == SIM_FPU_IS_PINF)
|
|| y == SIM_FPU_IS_NINF || y == SIM_FPU_IS_PINF)
|
return 128;
|
return 128;
|
else
|
else
|
return sim_fpu_exp (x);
|
return sim_fpu_exp (x);
|
|
|
:function:e500::unsigned32:ev_fs_mul:unsigned32 aa, unsigned32 bb, int inv, int over, int under, int fg, int fx, cpu *processor
|
:function:e500::unsigned32:ev_fs_mul:unsigned32 aa, unsigned32 bb, int inv, int over, int under, int fg, int fx, cpu *processor
|
sim_fpu a, b, d;
|
sim_fpu a, b, d;
|
unsigned32 w;
|
unsigned32 w;
|
int sa, sb, ea, eb, ei;
|
int sa, sb, ea, eb, ei;
|
sim_fpu_32to (&a, aa);
|
sim_fpu_32to (&a, aa);
|
sim_fpu_32to (&b, bb);
|
sim_fpu_32to (&b, bb);
|
sa = sim_fpu_sign(&a);
|
sa = sim_fpu_sign(&a);
|
sb = sim_fpu_sign(&b);
|
sb = sim_fpu_sign(&b);
|
ea = booke_sim_fpu_exp(&a);
|
ea = booke_sim_fpu_exp(&a);
|
eb = booke_sim_fpu_exp(&b);
|
eb = booke_sim_fpu_exp(&b);
|
ei = ea + eb + 127;
|
ei = ea + eb + 127;
|
if (sim_fpu_is_zero (&a) || sim_fpu_is_zero (&b))
|
if (sim_fpu_is_zero (&a) || sim_fpu_is_zero (&b))
|
w = 0;
|
w = 0;
|
else if (sa == sb) {
|
else if (sa == sb) {
|
if (ei >= 254) {
|
if (ei >= 254) {
|
w = EV_PMAX;
|
w = EV_PMAX;
|
EV_SET_SPEFSCR_BITS(over);
|
EV_SET_SPEFSCR_BITS(over);
|
} else if (ei < 1) {
|
} else if (ei < 1) {
|
d = sim_fpu_zero;
|
d = sim_fpu_zero;
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
w &= 0x7fffffff; /* Clear sign bit. */
|
w &= 0x7fffffff; /* Clear sign bit. */
|
} else {
|
} else {
|
goto normal_mul;
|
goto normal_mul;
|
}
|
}
|
} else {
|
} else {
|
if (ei >= 254) {
|
if (ei >= 254) {
|
w = EV_NMAX;
|
w = EV_NMAX;
|
EV_SET_SPEFSCR_BITS(over);
|
EV_SET_SPEFSCR_BITS(over);
|
} else if (ei < 1) {
|
} else if (ei < 1) {
|
d = sim_fpu_zero;
|
d = sim_fpu_zero;
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
w |= 0x80000000; /* Set sign bit. */
|
w |= 0x80000000; /* Set sign bit. */
|
} else {
|
} else {
|
normal_mul:
|
normal_mul:
|
if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b))
|
if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b))
|
EV_SET_SPEFSCR_BITS(inv);
|
EV_SET_SPEFSCR_BITS(inv);
|
sim_fpu_mul (&d, &a, &b);
|
sim_fpu_mul (&d, &a, &b);
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
}
|
}
|
}
|
}
|
return w;
|
return w;
|
|
|
:function:e500::unsigned32:ev_fs_div:unsigned32 aa, unsigned32 bb, int inv, int over, int under, int dbz, int fg, int fx, cpu *processor
|
:function:e500::unsigned32:ev_fs_div:unsigned32 aa, unsigned32 bb, int inv, int over, int under, int dbz, int fg, int fx, cpu *processor
|
sim_fpu a, b, d;
|
sim_fpu a, b, d;
|
unsigned32 w;
|
unsigned32 w;
|
int sa, sb, ea, eb, ei;
|
int sa, sb, ea, eb, ei;
|
|
|
sim_fpu_32to (&a, aa);
|
sim_fpu_32to (&a, aa);
|
sim_fpu_32to (&b, bb);
|
sim_fpu_32to (&b, bb);
|
sa = sim_fpu_sign(&a);
|
sa = sim_fpu_sign(&a);
|
sb = sim_fpu_sign(&b);
|
sb = sim_fpu_sign(&b);
|
ea = booke_sim_fpu_exp(&a);
|
ea = booke_sim_fpu_exp(&a);
|
eb = booke_sim_fpu_exp(&b);
|
eb = booke_sim_fpu_exp(&b);
|
ei = ea - eb + 127;
|
ei = ea - eb + 127;
|
|
|
/* Special cases to handle behaviour of e500 hardware.
|
/* Special cases to handle behaviour of e500 hardware.
|
cf case 107543. */
|
cf case 107543. */
|
if (sim_fpu_is_nan (&a) || sim_fpu_is_nan (&b)
|
if (sim_fpu_is_nan (&a) || sim_fpu_is_nan (&b)
|
|| sim_fpu_is_zero (&a) || sim_fpu_is_zero (&b))
|
|| sim_fpu_is_zero (&a) || sim_fpu_is_zero (&b))
|
{
|
{
|
if (sim_fpu_is_snan (&a) || sim_fpu_is_snan (&b))
|
if (sim_fpu_is_snan (&a) || sim_fpu_is_snan (&b))
|
{
|
{
|
if (bb == 0x3f800000)
|
if (bb == 0x3f800000)
|
w = EV_PMAX;
|
w = EV_PMAX;
|
else if (aa == 0x7fc00001)
|
else if (aa == 0x7fc00001)
|
w = 0x3fbffffe;
|
w = 0x3fbffffe;
|
else
|
else
|
goto normal_div;
|
goto normal_div;
|
}
|
}
|
else
|
else
|
goto normal_div;
|
goto normal_div;
|
}
|
}
|
else if (sim_fpu_is_infinity (&a) && sim_fpu_is_infinity (&b))
|
else if (sim_fpu_is_infinity (&a) && sim_fpu_is_infinity (&b))
|
{
|
{
|
if (sa == sb)
|
if (sa == sb)
|
sim_fpu_32to (&d, 0x3f800000);
|
sim_fpu_32to (&d, 0x3f800000);
|
else
|
else
|
sim_fpu_32to (&d, 0xbf800000);
|
sim_fpu_32to (&d, 0xbf800000);
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
}
|
}
|
else if (sa == sb) {
|
else if (sa == sb) {
|
if (ei > 254) {
|
if (ei > 254) {
|
w = EV_PMAX;
|
w = EV_PMAX;
|
EV_SET_SPEFSCR_BITS(over);
|
EV_SET_SPEFSCR_BITS(over);
|
} else if (ei <= 1) {
|
} else if (ei <= 1) {
|
d = sim_fpu_zero;
|
d = sim_fpu_zero;
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
w &= 0x7fffffff; /* Clear sign bit. */
|
w &= 0x7fffffff; /* Clear sign bit. */
|
} else {
|
} else {
|
goto normal_div;
|
goto normal_div;
|
}
|
}
|
} else {
|
} else {
|
if (ei > 254) {
|
if (ei > 254) {
|
w = EV_NMAX;
|
w = EV_NMAX;
|
EV_SET_SPEFSCR_BITS(over);
|
EV_SET_SPEFSCR_BITS(over);
|
} else if (ei <= 1) {
|
} else if (ei <= 1) {
|
d = sim_fpu_zero;
|
d = sim_fpu_zero;
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
w |= 0x80000000; /* Set sign bit. */
|
w |= 0x80000000; /* Set sign bit. */
|
} else {
|
} else {
|
normal_div:
|
normal_div:
|
if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b))
|
if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b))
|
EV_SET_SPEFSCR_BITS(inv);
|
EV_SET_SPEFSCR_BITS(inv);
|
if (sim_fpu_is_zero (&b))
|
if (sim_fpu_is_zero (&b))
|
{
|
{
|
if (sim_fpu_is_zero (&a))
|
if (sim_fpu_is_zero (&a))
|
EV_SET_SPEFSCR_BITS(dbz);
|
EV_SET_SPEFSCR_BITS(dbz);
|
else
|
else
|
EV_SET_SPEFSCR_BITS(inv);
|
EV_SET_SPEFSCR_BITS(inv);
|
w = sa ? EV_NMAX : EV_PMAX;
|
w = sa ? EV_NMAX : EV_PMAX;
|
}
|
}
|
else
|
else
|
{
|
{
|
sim_fpu_div (&d, &a, &b);
|
sim_fpu_div (&d, &a, &b);
|
sim_fpu_to32 (&w, &d);
|
sim_fpu_to32 (&w, &d);
|
ev_check_guard(&d, fg, fx, processor);
|
ev_check_guard(&d, fg, fx, processor);
|
}
|
}
|
}
|
}
|
}
|
}
|
return w;
|
return w;
|
|
|
|
|
#
|
#
|
# A.2.7 Integer SPE Simple Instructions
|
# A.2.7 Integer SPE Simple Instructions
|
#
|
#
|
|
|
0.4,6.RS,11.RA,16.RB,21.512:X:e500:evaddw %RS,%RA,%RB:Vector Add Word
|
0.4,6.RS,11.RA,16.RB,21.512:X:e500:evaddw %RS,%RA,%RB:Vector Add Word
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rBh + *rAh;
|
w1 = *rBh + *rAh;
|
w2 = *rB + *rA;
|
w2 = *rB + *rA;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evaddw: *rSh = %08x; *rS = %08x; w1 = %08x w2 = %08x\n", *rSh, *rS, w1, w2);
|
//printf("evaddw: *rSh = %08x; *rS = %08x; w1 = %08x w2 = %08x\n", *rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.IMM,16.RB,21.514:X:e500:evaddiw %RS,%RB,%IMM:Vector Add Immediate Word
|
0.4,6.RS,11.IMM,16.RB,21.514:X:e500:evaddiw %RS,%RB,%IMM:Vector Add Immediate Word
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rBh + IMM;
|
w1 = *rBh + IMM;
|
w2 = *rB + IMM;
|
w2 = *rB + IMM;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evaddiw: *rSh = %08x; *rS = %08x; w1 = %08x w2 = %08x\n", *rSh, *rS, w1, w2);
|
//printf("evaddiw: *rSh = %08x; *rS = %08x; w1 = %08x w2 = %08x\n", *rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.516:X:e500:evsubfw %RS,%RA,%RB:Vector Subtract from Word
|
0.4,6.RS,11.RA,16.RB,21.516:X:e500:evsubfw %RS,%RA,%RB:Vector Subtract from Word
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rBh - *rAh;
|
w1 = *rBh - *rAh;
|
w2 = *rB - *rA;
|
w2 = *rB - *rA;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evsubfw: *rSh = %08x; *rS = %08x; w1 = %08x w2 = %08x\n", *rSh, *rS, w1, w2);
|
//printf("evsubfw: *rSh = %08x; *rS = %08x; w1 = %08x w2 = %08x\n", *rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.IMM,16.RB,21.518:X:e500:evsubifw %RS,%RB,%IMM:Vector Subtract Immediate from Word
|
0.4,6.RS,11.IMM,16.RB,21.518:X:e500:evsubifw %RS,%RB,%IMM:Vector Subtract Immediate from Word
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rBh - IMM;
|
w1 = *rBh - IMM;
|
w2 = *rB - IMM;
|
w2 = *rB - IMM;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evsubifw: *rSh = %08x; *rS = %08x; IMM = %d\n", *rSh, *rS, IMM);
|
//printf("evsubifw: *rSh = %08x; *rS = %08x; IMM = %d\n", *rSh, *rS, IMM);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.520:X:e500:evabs %RS,%RA:Vector Absolute Value
|
0.4,6.RS,11.RA,16.0,21.520:X:e500:evabs %RS,%RA:Vector Absolute Value
|
signed32 w1, w2;
|
signed32 w1, w2;
|
w1 = *rAh;
|
w1 = *rAh;
|
if (w1 < 0 && w1 != 0x80000000)
|
if (w1 < 0 && w1 != 0x80000000)
|
w1 = -w1;
|
w1 = -w1;
|
w2 = *rA;
|
w2 = *rA;
|
if (w2 < 0 && w2 != 0x80000000)
|
if (w2 < 0 && w2 != 0x80000000)
|
w2 = -w2;
|
w2 = -w2;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.521:X:e500:evneg %RS,%RA:Vector Negate
|
0.4,6.RS,11.RA,16.0,21.521:X:e500:evneg %RS,%RA:Vector Negate
|
signed32 w1, w2;
|
signed32 w1, w2;
|
w1 = *rAh;
|
w1 = *rAh;
|
/* the negative most negative number is the most negative number */
|
/* the negative most negative number is the most negative number */
|
if (w1 != 0x80000000)
|
if (w1 != 0x80000000)
|
w1 = -w1;
|
w1 = -w1;
|
w2 = *rA;
|
w2 = *rA;
|
if (w2 != 0x80000000)
|
if (w2 != 0x80000000)
|
w2 = -w2;
|
w2 = -w2;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.522:X:e500:evextsb %RS,%RA:Vector Extend Signed Byte
|
0.4,6.RS,11.RA,16.0,21.522:X:e500:evextsb %RS,%RA:Vector Extend Signed Byte
|
unsigned64 w1, w2;
|
unsigned64 w1, w2;
|
w1 = *rAh & 0xff;
|
w1 = *rAh & 0xff;
|
if (w1 & 0x80)
|
if (w1 & 0x80)
|
w1 |= 0xffffff00;
|
w1 |= 0xffffff00;
|
w2 = *rA & 0xff;
|
w2 = *rA & 0xff;
|
if (w2 & 0x80)
|
if (w2 & 0x80)
|
w2 |= 0xffffff00;
|
w2 |= 0xffffff00;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK , 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK , 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.523:X:e500:evextsb %RS,%RA:Vector Extend Signed Half Word
|
0.4,6.RS,11.RA,16.0,21.523:X:e500:evextsb %RS,%RA:Vector Extend Signed Half Word
|
unsigned64 w1, w2;
|
unsigned64 w1, w2;
|
w1 = *rAh & 0xffff;
|
w1 = *rAh & 0xffff;
|
if (w1 & 0x8000)
|
if (w1 & 0x8000)
|
w1 |= 0xffff0000;
|
w1 |= 0xffff0000;
|
w2 = *rA & 0xffff;
|
w2 = *rA & 0xffff;
|
if (w2 & 0x8000)
|
if (w2 & 0x8000)
|
w2 |= 0xffff0000;
|
w2 |= 0xffff0000;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.529:X:e500:evand %RS,%RA,%RB:Vector AND
|
0.4,6.RS,11.RA,16.RB,21.529:X:e500:evand %RS,%RA,%RB:Vector AND
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rBh & *rAh;
|
w1 = *rBh & *rAh;
|
w2 = *rB & *rA;
|
w2 = *rB & *rA;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.535:X:e500:evor %RS,%RA,%RB:Vector OR
|
0.4,6.RS,11.RA,16.RB,21.535:X:e500:evor %RS,%RA,%RB:Vector OR
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rBh | *rAh;
|
w1 = *rBh | *rAh;
|
w2 = *rB | *rA;
|
w2 = *rB | *rA;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.534:X:e500:evxor %RS,%RA,%RB:Vector XOR
|
0.4,6.RS,11.RA,16.RB,21.534:X:e500:evxor %RS,%RA,%RB:Vector XOR
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rBh ^ *rAh;
|
w1 = *rBh ^ *rAh;
|
w2 = *rB ^ *rA;
|
w2 = *rB ^ *rA;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.542:X:e500:evnand %RS,%RA,%RB:Vector NAND
|
0.4,6.RS,11.RA,16.RB,21.542:X:e500:evnand %RS,%RA,%RB:Vector NAND
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = ~(*rBh & *rAh);
|
w1 = ~(*rBh & *rAh);
|
w2 = ~(*rB & *rA);
|
w2 = ~(*rB & *rA);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.536:X:e500:evnor %RS,%RA,%RB:Vector NOR
|
0.4,6.RS,11.RA,16.RB,21.536:X:e500:evnor %RS,%RA,%RB:Vector NOR
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = ~(*rBh | *rAh);
|
w1 = ~(*rBh | *rAh);
|
w2 = ~(*rB | *rA);
|
w2 = ~(*rB | *rA);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.537:X:e500:eveqv %RS,%RA,%RB:Vector Equivalent
|
0.4,6.RS,11.RA,16.RB,21.537:X:e500:eveqv %RS,%RA,%RB:Vector Equivalent
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = (~*rBh) ^ *rAh;
|
w1 = (~*rBh) ^ *rAh;
|
w2 = (~*rB) ^ *rA;
|
w2 = (~*rB) ^ *rA;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.530:X:e500:evandc %RS,%RA,%RB:Vector AND with Compliment
|
0.4,6.RS,11.RA,16.RB,21.530:X:e500:evandc %RS,%RA,%RB:Vector AND with Compliment
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = (~*rBh) & *rAh;
|
w1 = (~*rBh) & *rAh;
|
w2 = (~*rB) & *rA;
|
w2 = (~*rB) & *rA;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evandc: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
//printf("evandc: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.539:X:e500:evorc %RS,%RA,%RB:Vector OR with Compliment
|
0.4,6.RS,11.RA,16.RB,21.539:X:e500:evorc %RS,%RA,%RB:Vector OR with Compliment
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = (~*rBh) | *rAh;
|
w1 = (~*rBh) | *rAh;
|
w2 = (~*rB) | *rA;
|
w2 = (~*rB) | *rA;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evorc: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
//printf("evorc: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.552:X:e500:evrlw %RS,%RA,%RB:Vector Rotate Left Word
|
0.4,6.RS,11.RA,16.RB,21.552:X:e500:evrlw %RS,%RA,%RB:Vector Rotate Left Word
|
unsigned32 nh, nl, w1, w2;
|
unsigned32 nh, nl, w1, w2;
|
nh = *rBh & 0x1f;
|
nh = *rBh & 0x1f;
|
nl = *rB & 0x1f;
|
nl = *rB & 0x1f;
|
w1 = ((unsigned32)*rAh) << nh | ((unsigned32)*rAh) >> (32 - nh);
|
w1 = ((unsigned32)*rAh) << nh | ((unsigned32)*rAh) >> (32 - nh);
|
w2 = ((unsigned32)*rA) << nl | ((unsigned32)*rA) >> (32 - nl);
|
w2 = ((unsigned32)*rA) << nl | ((unsigned32)*rA) >> (32 - nl);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evrlw: nh %d nl %d *rSh = %08x; *rS = %08x\n", nh, nl, *rSh, *rS);
|
//printf("evrlw: nh %d nl %d *rSh = %08x; *rS = %08x\n", nh, nl, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.554:X:e500:evrlwi %RS,%RA,%UIMM:Vector Rotate Left Word Immediate
|
0.4,6.RS,11.RA,16.UIMM,21.554:X:e500:evrlwi %RS,%RA,%UIMM:Vector Rotate Left Word Immediate
|
unsigned32 w1, w2, imm;
|
unsigned32 w1, w2, imm;
|
imm = (unsigned32)UIMM;
|
imm = (unsigned32)UIMM;
|
w1 = ((unsigned32)*rAh) << imm | ((unsigned32)*rAh) >> (32 - imm);
|
w1 = ((unsigned32)*rAh) << imm | ((unsigned32)*rAh) >> (32 - imm);
|
w2 = ((unsigned32)*rA) << imm | ((unsigned32)*rA) >> (32 - imm);
|
w2 = ((unsigned32)*rA) << imm | ((unsigned32)*rA) >> (32 - imm);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.548:X:e500:evslw %RS,%RA,%RB:Vector Shift Left Word
|
0.4,6.RS,11.RA,16.RB,21.548:X:e500:evslw %RS,%RA,%RB:Vector Shift Left Word
|
unsigned32 nh, nl, w1, w2;
|
unsigned32 nh, nl, w1, w2;
|
nh = *rBh & 0x1f;
|
nh = *rBh & 0x1f;
|
nl = *rB & 0x1f;
|
nl = *rB & 0x1f;
|
w1 = ((unsigned32)*rAh) << nh;
|
w1 = ((unsigned32)*rAh) << nh;
|
w2 = ((unsigned32)*rA) << nl;
|
w2 = ((unsigned32)*rA) << nl;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.550:X:e500:evslwi %RS,%RA,%UIMM:Vector Shift Left Word Immediate
|
0.4,6.RS,11.RA,16.UIMM,21.550:X:e500:evslwi %RS,%RA,%UIMM:Vector Shift Left Word Immediate
|
unsigned32 w1, w2, imm = UIMM;
|
unsigned32 w1, w2, imm = UIMM;
|
w1 = ((unsigned32)*rAh) << imm;
|
w1 = ((unsigned32)*rAh) << imm;
|
w2 = ((unsigned32)*rA) << imm;
|
w2 = ((unsigned32)*rA) << imm;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.545:X:e500:evsrws %RS,%RA,%RB:Vector Shift Right Word Signed
|
0.4,6.RS,11.RA,16.RB,21.545:X:e500:evsrws %RS,%RA,%RB:Vector Shift Right Word Signed
|
signed32 w1, w2;
|
signed32 w1, w2;
|
unsigned32 nh, nl;
|
unsigned32 nh, nl;
|
nh = *rBh & 0x1f;
|
nh = *rBh & 0x1f;
|
nl = *rB & 0x1f;
|
nl = *rB & 0x1f;
|
w1 = ((signed32)*rAh) >> nh;
|
w1 = ((signed32)*rAh) >> nh;
|
w2 = ((signed32)*rA) >> nl;
|
w2 = ((signed32)*rA) >> nl;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evsrws: nh %d nl %d *rSh = %08x; *rS = %08x\n", nh, nl, *rSh, *rS);
|
//printf("evsrws: nh %d nl %d *rSh = %08x; *rS = %08x\n", nh, nl, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.544:X:e500:evsrwu %RS,%RA,%RB:Vector Shift Right Word Unsigned
|
0.4,6.RS,11.RA,16.RB,21.544:X:e500:evsrwu %RS,%RA,%RB:Vector Shift Right Word Unsigned
|
unsigned32 w1, w2, nh, nl;
|
unsigned32 w1, w2, nh, nl;
|
nh = *rBh & 0x1f;
|
nh = *rBh & 0x1f;
|
nl = *rB & 0x1f;
|
nl = *rB & 0x1f;
|
w1 = ((unsigned32)*rAh) >> nh;
|
w1 = ((unsigned32)*rAh) >> nh;
|
w2 = ((unsigned32)*rA) >> nl;
|
w2 = ((unsigned32)*rA) >> nl;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.547:X:e500:evsrwis %RS,%RA,%UIMM:Vector Shift Right Word Immediate Signed
|
0.4,6.RS,11.RA,16.UIMM,21.547:X:e500:evsrwis %RS,%RA,%UIMM:Vector Shift Right Word Immediate Signed
|
signed32 w1, w2;
|
signed32 w1, w2;
|
unsigned32 imm = UIMM;
|
unsigned32 imm = UIMM;
|
w1 = ((signed32)*rAh) >> imm;
|
w1 = ((signed32)*rAh) >> imm;
|
w2 = ((signed32)*rA) >> imm;
|
w2 = ((signed32)*rA) >> imm;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.546:X:e500:evsrwiu %RS,%RA,%UIMM:Vector Shift Right Word Immediate Unsigned
|
0.4,6.RS,11.RA,16.UIMM,21.546:X:e500:evsrwiu %RS,%RA,%UIMM:Vector Shift Right Word Immediate Unsigned
|
unsigned32 w1, w2, imm = UIMM;
|
unsigned32 w1, w2, imm = UIMM;
|
w1 = ((unsigned32)*rAh) >> imm;
|
w1 = ((unsigned32)*rAh) >> imm;
|
w2 = ((unsigned32)*rA) >> imm;
|
w2 = ((unsigned32)*rA) >> imm;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.525:X:e500:evcntlzw %RS,%RA:Vector Count Leading Zeros Word
|
0.4,6.RS,11.RA,16.0,21.525:X:e500:evcntlzw %RS,%RA:Vector Count Leading Zeros Word
|
unsigned32 w1, w2, mask, c1, c2;
|
unsigned32 w1, w2, mask, c1, c2;
|
for (c1 = 0, mask = 0x80000000, w1 = *rAh;
|
for (c1 = 0, mask = 0x80000000, w1 = *rAh;
|
!(w1 & mask) && mask != 0; mask >>= 1)
|
!(w1 & mask) && mask != 0; mask >>= 1)
|
c1++;
|
c1++;
|
for (c2 = 0, mask = 0x80000000, w2 = *rA;
|
for (c2 = 0, mask = 0x80000000, w2 = *rA;
|
!(w2 & mask) && mask != 0; mask >>= 1)
|
!(w2 & mask) && mask != 0; mask >>= 1)
|
c2++;
|
c2++;
|
EV_SET_REG2(*rSh, *rS, c1, c2);
|
EV_SET_REG2(*rSh, *rS, c1, c2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.526:X:e500:evcntlsw %RS,%RA:Vector Count Leading Sign Bits Word
|
0.4,6.RS,11.RA,16.0,21.526:X:e500:evcntlsw %RS,%RA:Vector Count Leading Sign Bits Word
|
unsigned32 w1, w2, mask, sign_bit, c1, c2;
|
unsigned32 w1, w2, mask, sign_bit, c1, c2;
|
for (c1 = 0, mask = 0x80000000, w1 = *rAh, sign_bit = w1 & mask;
|
for (c1 = 0, mask = 0x80000000, w1 = *rAh, sign_bit = w1 & mask;
|
((w1 & mask) == sign_bit) && mask != 0;
|
((w1 & mask) == sign_bit) && mask != 0;
|
mask >>= 1, sign_bit >>= 1)
|
mask >>= 1, sign_bit >>= 1)
|
c1++;
|
c1++;
|
for (c2 = 0, mask = 0x80000000, w2 = *rA, sign_bit = w2 & mask;
|
for (c2 = 0, mask = 0x80000000, w2 = *rA, sign_bit = w2 & mask;
|
((w2 & mask) == sign_bit) && mask != 0;
|
((w2 & mask) == sign_bit) && mask != 0;
|
mask >>= 1, sign_bit >>= 1)
|
mask >>= 1, sign_bit >>= 1)
|
c2++;
|
c2++;
|
EV_SET_REG2(*rSh, *rS, c1, c2);
|
EV_SET_REG2(*rSh, *rS, c1, c2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.524:X:e500:evrndw %RS,%RA:Vector Round Word
|
0.4,6.RS,11.RA,16.0,21.524:X:e500:evrndw %RS,%RA:Vector Round Word
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = ((unsigned32)*rAh + 0x8000) & 0xffff0000;
|
w1 = ((unsigned32)*rAh + 0x8000) & 0xffff0000;
|
w2 = ((unsigned32)*rA + 0x8000) & 0xffff0000;
|
w2 = ((unsigned32)*rA + 0x8000) & 0xffff0000;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
//printf("evrndw: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
//printf("evrndw: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.556:X:e500:evmergehi %RS,%RA,%RB:Vector Merge Hi
|
0.4,6.RS,11.RA,16.RB,21.556:X:e500:evmergehi %RS,%RA,%RB:Vector Merge Hi
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rAh;
|
w1 = *rAh;
|
w2 = *rBh;
|
w2 = *rBh;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.557:X:e500:evmergelo %RS,%RA,%RB:Vector Merge Low
|
0.4,6.RS,11.RA,16.RB,21.557:X:e500:evmergelo %RS,%RA,%RB:Vector Merge Low
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rA;
|
w1 = *rA;
|
w2 = *rB;
|
w2 = *rB;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.559:X:e500:evmergelohi %RS,%RA,%RB:Vector Merge Low Hi
|
0.4,6.RS,11.RA,16.RB,21.559:X:e500:evmergelohi %RS,%RA,%RB:Vector Merge Low Hi
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rA;
|
w1 = *rA;
|
w2 = *rBh;
|
w2 = *rBh;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.558:X:e500:evmergehilo %RS,%RA,%RB:Vector Merge Hi Low
|
0.4,6.RS,11.RA,16.RB,21.558:X:e500:evmergehilo %RS,%RA,%RB:Vector Merge Hi Low
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rAh;
|
w1 = *rAh;
|
w2 = *rB;
|
w2 = *rB;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.SIMM,16.0,21.553:X:e500:evsplati %RS,%SIMM:Vector Splat Immediate
|
0.4,6.RS,11.SIMM,16.0,21.553:X:e500:evsplati %RS,%SIMM:Vector Splat Immediate
|
unsigned32 w;
|
unsigned32 w;
|
w = SIMM & 0x1f;
|
w = SIMM & 0x1f;
|
if (w & 0x10)
|
if (w & 0x10)
|
w |= 0xffffffe0;
|
w |= 0xffffffe0;
|
EV_SET_REG2(*rSh, *rS, w, w);
|
EV_SET_REG2(*rSh, *rS, w, w);
|
PPC_INSN_INT(RS_BITMASK, 0, 0);
|
PPC_INSN_INT(RS_BITMASK, 0, 0);
|
|
|
0.4,6.RS,11.SIMM,16.0,21.555:X:e500:evsplatfi %RS,%SIMM:Vector Splat Fractional Immediate
|
0.4,6.RS,11.SIMM,16.0,21.555:X:e500:evsplatfi %RS,%SIMM:Vector Splat Fractional Immediate
|
unsigned32 w;
|
unsigned32 w;
|
w = SIMM << 27;
|
w = SIMM << 27;
|
EV_SET_REG2(*rSh, *rS, w, w);
|
EV_SET_REG2(*rSh, *rS, w, w);
|
PPC_INSN_INT(RS_BITMASK, 0, 0);
|
PPC_INSN_INT(RS_BITMASK, 0, 0);
|
|
|
0.4,6.BF,9.0,11.RA,16.RB,21.561:X:e500:evcmpgts %BF,%RA,%RB:Vector Compare Greater Than Signed
|
0.4,6.BF,9.0,11.RA,16.RB,21.561:X:e500:evcmpgts %BF,%RA,%RB:Vector Compare Greater Than Signed
|
signed32 ah, al, bh, bl;
|
signed32 ah, al, bh, bl;
|
int w, ch, cl;
|
int w, ch, cl;
|
ah = *rAh;
|
ah = *rAh;
|
al = *rA;
|
al = *rA;
|
bh = *rBh;
|
bh = *rBh;
|
bl = *rB;
|
bl = *rB;
|
if (ah > bh)
|
if (ah > bh)
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (al > bl)
|
if (al > bl)
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.BF,9.0,11.RA,16.RB,21.560:X:e500:evcmpgtu %BF,%RA,%RB:Vector Compare Greater Than Unsigned
|
0.4,6.BF,9.0,11.RA,16.RB,21.560:X:e500:evcmpgtu %BF,%RA,%RB:Vector Compare Greater Than Unsigned
|
unsigned32 ah, al, bh, bl;
|
unsigned32 ah, al, bh, bl;
|
int w, ch, cl;
|
int w, ch, cl;
|
ah = *rAh;
|
ah = *rAh;
|
al = *rA;
|
al = *rA;
|
bh = *rBh;
|
bh = *rBh;
|
bl = *rB;
|
bl = *rB;
|
if (ah > bh)
|
if (ah > bh)
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (al > bl)
|
if (al > bl)
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.BF,9.0,11.RA,16.RB,21.563:X:e500:evcmplts %BF,%RA,%RB:Vector Compare Less Than Signed
|
0.4,6.BF,9.0,11.RA,16.RB,21.563:X:e500:evcmplts %BF,%RA,%RB:Vector Compare Less Than Signed
|
signed32 ah, al, bh, bl;
|
signed32 ah, al, bh, bl;
|
int w, ch, cl;
|
int w, ch, cl;
|
ah = *rAh;
|
ah = *rAh;
|
al = *rA;
|
al = *rA;
|
bh = *rBh;
|
bh = *rBh;
|
bl = *rB;
|
bl = *rB;
|
if (ah < bh)
|
if (ah < bh)
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (al < bl)
|
if (al < bl)
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.BF,9.0,11.RA,16.RB,21.562:X:e500:evcmpltu %BF,%RA,%RB:Vector Compare Less Than Unsigned
|
0.4,6.BF,9.0,11.RA,16.RB,21.562:X:e500:evcmpltu %BF,%RA,%RB:Vector Compare Less Than Unsigned
|
unsigned32 ah, al, bh, bl;
|
unsigned32 ah, al, bh, bl;
|
int w, ch, cl;
|
int w, ch, cl;
|
ah = *rAh;
|
ah = *rAh;
|
al = *rA;
|
al = *rA;
|
bh = *rBh;
|
bh = *rBh;
|
bl = *rB;
|
bl = *rB;
|
if (ah < bh)
|
if (ah < bh)
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (al < bl)
|
if (al < bl)
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.BF,9.0,11.RA,16.RB,21.564:X:e500:evcmpeq %BF,%RA,%RB:Vector Compare Equal
|
0.4,6.BF,9.0,11.RA,16.RB,21.564:X:e500:evcmpeq %BF,%RA,%RB:Vector Compare Equal
|
unsigned32 ah, al, bh, bl;
|
unsigned32 ah, al, bh, bl;
|
int w, ch, cl;
|
int w, ch, cl;
|
ah = *rAh;
|
ah = *rAh;
|
al = *rA;
|
al = *rA;
|
bh = *rBh;
|
bh = *rBh;
|
bl = *rB;
|
bl = *rB;
|
if (ah == bh)
|
if (ah == bh)
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (al == bl)
|
if (al == bl)
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
//printf("evcmpeq: ch %d cl %d BF %d, CR is now %08x\n", ch, cl, BF, CR);
|
//printf("evcmpeq: ch %d cl %d BF %d, CR is now %08x\n", ch, cl, BF, CR);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.RS,11.RA,16.RB,21.79,29.CRFS:X:e500:evsel %RS,%RA,%RB,%CRFS:Vector Select
|
0.4,6.RS,11.RA,16.RB,21.79,29.CRFS:X:e500:evsel %RS,%RA,%RB,%CRFS:Vector Select
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
int cr;
|
int cr;
|
cr = CR_FIELD(CRFS);
|
cr = CR_FIELD(CRFS);
|
if (cr & 8)
|
if (cr & 8)
|
w1 = *rAh;
|
w1 = *rAh;
|
else
|
else
|
w1 = *rBh;
|
w1 = *rBh;
|
if (cr & 4)
|
if (cr & 4)
|
w2 = *rA;
|
w2 = *rA;
|
else
|
else
|
w2 = *rB;
|
w2 = *rB;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.527:X:e500:brinc %RS,%RA,%RB:Bit Reversed Increment
|
0.4,6.RS,11.RA,16.RB,21.527:X:e500:brinc %RS,%RA,%RB:Bit Reversed Increment
|
unsigned32 w1, w2, a, d, mask;
|
unsigned32 w1, w2, a, d, mask;
|
mask = (*rB) & 0xffff;
|
mask = (*rB) & 0xffff;
|
a = (*rA) & 0xffff;
|
a = (*rA) & 0xffff;
|
d = EV_BITREVERSE16(1 + EV_BITREVERSE16(a | ~mask));
|
d = EV_BITREVERSE16(1 + EV_BITREVERSE16(a | ~mask));
|
*rS = ((*rA) & 0xffff0000) | (d & 0xffff);
|
*rS = ((*rA) & 0xffff0000) | (d & 0xffff);
|
//printf("brinc: *rS = %08x\n", *rS);
|
//printf("brinc: *rS = %08x\n", *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
#
|
#
|
# A.2.8 Integer SPE Complex Instructions
|
# A.2.8 Integer SPE Complex Instructions
|
#
|
#
|
|
|
0.4,6.RS,11.RA,16.RB,21.1031:EVX:e500:evmhossf %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Fractional
|
0.4,6.RS,11.RA,16.RB,21.1031:EVX:e500:evmhossf %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Fractional
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 tl, th;
|
signed32 tl, th;
|
int movl, movh;
|
int movl, movh;
|
|
|
al = (signed16) EV_LOHALF (*rA);
|
al = (signed16) EV_LOHALF (*rA);
|
ah = (signed16) EV_LOHALF (*rAh);
|
ah = (signed16) EV_LOHALF (*rAh);
|
bl = (signed16) EV_LOHALF (*rB);
|
bl = (signed16) EV_LOHALF (*rB);
|
bh = (signed16) EV_LOHALF (*rBh);
|
bh = (signed16) EV_LOHALF (*rBh);
|
tl = ev_multiply16_ssf (al, bl, &movl);
|
tl = ev_multiply16_ssf (al, bl, &movl);
|
th = ev_multiply16_ssf (ah, bh, &movh);
|
th = ev_multiply16_ssf (ah, bh, &movh);
|
EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th),
|
EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th),
|
EV_SATURATE (movl, 0x7fffffff, tl));
|
EV_SATURATE (movl, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV (movl, movh);
|
EV_SET_SPEFSCR_OV (movl, movh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1063:EVX:e500:evmhossfa %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Fractional Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1063:EVX:e500:evmhossfa %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Fractional Accumulate
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 tl, th;
|
signed32 tl, th;
|
int movl, movh;
|
int movl, movh;
|
|
|
al = (signed16) EV_LOHALF (*rA);
|
al = (signed16) EV_LOHALF (*rA);
|
ah = (signed16) EV_LOHALF (*rAh);
|
ah = (signed16) EV_LOHALF (*rAh);
|
bl = (signed16) EV_LOHALF (*rB);
|
bl = (signed16) EV_LOHALF (*rB);
|
bh = (signed16) EV_LOHALF (*rBh);
|
bh = (signed16) EV_LOHALF (*rBh);
|
tl = ev_multiply16_ssf (al, bl, &movl);
|
tl = ev_multiply16_ssf (al, bl, &movl);
|
th = ev_multiply16_ssf (ah, bh, &movh);
|
th = ev_multiply16_ssf (ah, bh, &movh);
|
EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th),
|
EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th),
|
EV_SATURATE (movl, 0x7fffffff, tl));
|
EV_SATURATE (movl, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV (movl, movh);
|
EV_SET_SPEFSCR_OV (movl, movh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1039:EVX:e500:evmhosmf %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Fractional
|
0.4,6.RS,11.RA,16.RB,21.1039:EVX:e500:evmhosmf %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Fractional
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 tl, th;
|
signed32 tl, th;
|
int dummy;
|
int dummy;
|
|
|
al = (signed16) EV_LOHALF (*rA);
|
al = (signed16) EV_LOHALF (*rA);
|
ah = (signed16) EV_LOHALF (*rAh);
|
ah = (signed16) EV_LOHALF (*rAh);
|
bl = (signed16) EV_LOHALF (*rB);
|
bl = (signed16) EV_LOHALF (*rB);
|
bh = (signed16) EV_LOHALF (*rBh);
|
bh = (signed16) EV_LOHALF (*rBh);
|
tl = ev_multiply16_smf (al, bl, & dummy);
|
tl = ev_multiply16_smf (al, bl, & dummy);
|
th = ev_multiply16_smf (ah, bh, & dummy);
|
th = ev_multiply16_smf (ah, bh, & dummy);
|
EV_SET_REG2 (*rSh, *rS, th, tl);
|
EV_SET_REG2 (*rSh, *rS, th, tl);
|
PPC_INSN_INT (RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT (RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1071:EVX:e500:evmhosmfa %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Fractional Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1071:EVX:e500:evmhosmfa %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Fractional Accumulate
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed32 tl, th;
|
signed32 tl, th;
|
int dummy;
|
int dummy;
|
|
|
al = (signed16) EV_LOHALF (*rA);
|
al = (signed16) EV_LOHALF (*rA);
|
ah = (signed16) EV_LOHALF (*rAh);
|
ah = (signed16) EV_LOHALF (*rAh);
|
bl = (signed16) EV_LOHALF (*rB);
|
bl = (signed16) EV_LOHALF (*rB);
|
bh = (signed16) EV_LOHALF (*rBh);
|
bh = (signed16) EV_LOHALF (*rBh);
|
tl = ev_multiply16_smf (al, bl, & dummy);
|
tl = ev_multiply16_smf (al, bl, & dummy);
|
th = ev_multiply16_smf (ah, bh, & dummy);
|
th = ev_multiply16_smf (ah, bh, & dummy);
|
EV_SET_REG2_ACC (*rSh, *rS, th, tl);
|
EV_SET_REG2_ACC (*rSh, *rS, th, tl);
|
PPC_INSN_INT (RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT (RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1037:EVX:e500:evmhosmi %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1037:EVX:e500:evmhosmi %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Integer
|
signed32 al, ah, bl, bh, tl, th;
|
signed32 al, ah, bl, bh, tl, th;
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
tl = al * bl;
|
tl = al * bl;
|
th = ah * bh;
|
th = ah * bh;
|
EV_SET_REG2(*rSh, *rS, th, tl);
|
EV_SET_REG2(*rSh, *rS, th, tl);
|
//printf("evmhosmi: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
//printf("evmhosmi: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1069:EVX:e500:evmhosmia %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Integer Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1069:EVX:e500:evmhosmia %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Integer Accumulate
|
signed32 al, ah, bl, bh, tl, th;
|
signed32 al, ah, bl, bh, tl, th;
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
tl = al * bl;
|
tl = al * bl;
|
th = ah * bh;
|
th = ah * bh;
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
//printf("evmhosmia: ACC = %08x; *rSh = %08x; *rS = %08x\n", ACC, *rSh, *rS);
|
//printf("evmhosmia: ACC = %08x; *rSh = %08x; *rS = %08x\n", ACC, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1036:EVX:e500:evmhoumi %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1036:EVX:e500:evmhoumi %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Modulo Integer
|
unsigned32 al, ah, bl, bh, tl, th;
|
unsigned32 al, ah, bl, bh, tl, th;
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
tl = al * bl;
|
tl = al * bl;
|
th = ah * bh;
|
th = ah * bh;
|
EV_SET_REG2(*rSh, *rS, th, tl);
|
EV_SET_REG2(*rSh, *rS, th, tl);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1068:EVX:e500:evmhoumia %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Modulo Integer Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1068:EVX:e500:evmhoumia %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Modulo Integer Accumulate
|
unsigned32 al, ah, bl, bh, tl, th;
|
unsigned32 al, ah, bl, bh, tl, th;
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
tl = al * bl;
|
tl = al * bl;
|
th = ah * bh;
|
th = ah * bh;
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1027:EVX:e500:evmhessf %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Fractional
|
0.4,6.RS,11.RA,16.RB,21.1027:EVX:e500:evmhessf %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Fractional
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 tl, th;
|
signed32 tl, th;
|
int movl, movh;
|
int movl, movh;
|
|
|
al = (signed16) EV_HIHALF (*rA);
|
al = (signed16) EV_HIHALF (*rA);
|
ah = (signed16) EV_HIHALF (*rAh);
|
ah = (signed16) EV_HIHALF (*rAh);
|
bl = (signed16) EV_HIHALF (*rB);
|
bl = (signed16) EV_HIHALF (*rB);
|
bh = (signed16) EV_HIHALF (*rBh);
|
bh = (signed16) EV_HIHALF (*rBh);
|
tl = ev_multiply16_ssf (al, bl, &movl);
|
tl = ev_multiply16_ssf (al, bl, &movl);
|
th = ev_multiply16_ssf (ah, bh, &movh);
|
th = ev_multiply16_ssf (ah, bh, &movh);
|
EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th),
|
EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th),
|
EV_SATURATE (movl, 0x7fffffff, tl));
|
EV_SATURATE (movl, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV (movl, movh);
|
EV_SET_SPEFSCR_OV (movl, movh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1059:EVX:e500:evmhessfa %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Fractional Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1059:EVX:e500:evmhessfa %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Fractional Accumulate
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 tl, th;
|
signed32 tl, th;
|
int movl, movh;
|
int movl, movh;
|
|
|
al = (signed16) EV_HIHALF (*rA);
|
al = (signed16) EV_HIHALF (*rA);
|
ah = (signed16) EV_HIHALF (*rAh);
|
ah = (signed16) EV_HIHALF (*rAh);
|
bl = (signed16) EV_HIHALF (*rB);
|
bl = (signed16) EV_HIHALF (*rB);
|
bh = (signed16) EV_HIHALF (*rBh);
|
bh = (signed16) EV_HIHALF (*rBh);
|
tl = ev_multiply16_ssf (al, bl, &movl);
|
tl = ev_multiply16_ssf (al, bl, &movl);
|
th = ev_multiply16_ssf (ah, bh, &movh);
|
th = ev_multiply16_ssf (ah, bh, &movh);
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th),
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th),
|
EV_SATURATE (movl, 0x7fffffff, tl));
|
EV_SATURATE (movl, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV (movl, movh);
|
EV_SET_SPEFSCR_OV (movl, movh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1035:EVX:e500:evmhesmf %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Fractional
|
0.4,6.RS,11.RA,16.RB,21.1035:EVX:e500:evmhesmf %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Fractional
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed64 tl, th;
|
signed64 tl, th;
|
int movl, movh;
|
int movl, movh;
|
|
|
al = (signed16) EV_HIHALF (*rA);
|
al = (signed16) EV_HIHALF (*rA);
|
ah = (signed16) EV_HIHALF (*rAh);
|
ah = (signed16) EV_HIHALF (*rAh);
|
bl = (signed16) EV_HIHALF (*rB);
|
bl = (signed16) EV_HIHALF (*rB);
|
bh = (signed16) EV_HIHALF (*rBh);
|
bh = (signed16) EV_HIHALF (*rBh);
|
tl = ev_multiply16_smf (al, bl, &movl);
|
tl = ev_multiply16_smf (al, bl, &movl);
|
th = ev_multiply16_smf (ah, bh, &movh);
|
th = ev_multiply16_smf (ah, bh, &movh);
|
EV_SET_REG2 (*rSh, *rS, th, tl);
|
EV_SET_REG2 (*rSh, *rS, th, tl);
|
EV_SET_SPEFSCR_OV (movl, movh);
|
EV_SET_SPEFSCR_OV (movl, movh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1067:EVX:e500:evmhesmfa %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Fractional Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1067:EVX:e500:evmhesmfa %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Fractional Accumulate
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 tl, th;
|
signed32 tl, th;
|
int dummy;
|
int dummy;
|
|
|
al = (signed16) EV_HIHALF (*rA);
|
al = (signed16) EV_HIHALF (*rA);
|
ah = (signed16) EV_HIHALF (*rAh);
|
ah = (signed16) EV_HIHALF (*rAh);
|
bl = (signed16) EV_HIHALF (*rB);
|
bl = (signed16) EV_HIHALF (*rB);
|
bh = (signed16) EV_HIHALF (*rBh);
|
bh = (signed16) EV_HIHALF (*rBh);
|
tl = ev_multiply16_smf (al, bl, & dummy);
|
tl = ev_multiply16_smf (al, bl, & dummy);
|
th = ev_multiply16_smf (ah, bh, & dummy);
|
th = ev_multiply16_smf (ah, bh, & dummy);
|
EV_SET_REG2_ACC (*rSh, *rS, th, tl);
|
EV_SET_REG2_ACC (*rSh, *rS, th, tl);
|
PPC_INSN_INT (RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT (RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1033:EVX:e500:evmhesmi %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1033:EVX:e500:evmhesmi %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Integer
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 tl, th;
|
signed32 tl, th;
|
|
|
al = (signed16) EV_HIHALF (*rA);
|
al = (signed16) EV_HIHALF (*rA);
|
ah = (signed16) EV_HIHALF (*rAh);
|
ah = (signed16) EV_HIHALF (*rAh);
|
bl = (signed16) EV_HIHALF (*rB);
|
bl = (signed16) EV_HIHALF (*rB);
|
bh = (signed16) EV_HIHALF (*rBh);
|
bh = (signed16) EV_HIHALF (*rBh);
|
tl = al * bl;
|
tl = al * bl;
|
th = ah * bh;
|
th = ah * bh;
|
EV_SET_REG2 (*rSh, *rS, th, tl);
|
EV_SET_REG2 (*rSh, *rS, th, tl);
|
PPC_INSN_INT (RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT (RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1065:EVX:e500:evmhesmia %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Integer Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1065:EVX:e500:evmhesmia %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Integer Accumulate
|
signed32 al, ah, bl, bh, tl, th;
|
signed32 al, ah, bl, bh, tl, th;
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
tl = al * bl;
|
tl = al * bl;
|
th = ah * bh;
|
th = ah * bh;
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1032:EVX:e500:evmheumi %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1032:EVX:e500:evmheumi %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Modulo Integer
|
unsigned32 al, ah, bl, bh, tl, th;
|
unsigned32 al, ah, bl, bh, tl, th;
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
tl = al * bl;
|
tl = al * bl;
|
th = ah * bh;
|
th = ah * bh;
|
EV_SET_REG2(*rSh, *rS, th, tl);
|
EV_SET_REG2(*rSh, *rS, th, tl);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1064:EVX:e500:evmheumia %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Modulo Integer Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1064:EVX:e500:evmheumia %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Modulo Integer Accumulate
|
unsigned32 al, ah, bl, bh, tl, th;
|
unsigned32 al, ah, bl, bh, tl, th;
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
tl = al * bl;
|
tl = al * bl;
|
th = ah * bh;
|
th = ah * bh;
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1287:EVX:e500:evmhossfaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Fractional and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1287:EVX:e500:evmhossfaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Fractional and Accumulate into Words
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 t1, t2;
|
signed32 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
int movl, movh, ovl, ovh;
|
int movl, movh, ovl, ovh;
|
|
|
al = (signed16) EV_LOHALF (*rA);
|
al = (signed16) EV_LOHALF (*rA);
|
ah = (signed16) EV_LOHALF (*rAh);
|
ah = (signed16) EV_LOHALF (*rAh);
|
bl = (signed16) EV_LOHALF (*rB);
|
bl = (signed16) EV_LOHALF (*rB);
|
bh = (signed16) EV_LOHALF (*rBh);
|
bh = (signed16) EV_LOHALF (*rBh);
|
t1 = ev_multiply16_ssf (ah, bh, &movh);
|
t1 = ev_multiply16_ssf (ah, bh, &movh);
|
t2 = ev_multiply16_ssf (al, bl, &movl);
|
t2 = ev_multiply16_ssf (al, bl, &movl);
|
th = EV_ACCHIGH + EV_SATURATE (movh, 0x7fffffff, t1);
|
th = EV_ACCHIGH + EV_SATURATE (movh, 0x7fffffff, t1);
|
tl = EV_ACCLOW + EV_SATURATE (movl, 0x7fffffff, t2);
|
tl = EV_ACCLOW + EV_SATURATE (movl, 0x7fffffff, t2);
|
ovh = EV_SAT_P_S32 (th);
|
ovh = EV_SAT_P_S32 (th);
|
ovl = EV_SAT_P_S32 (tl);
|
ovl = EV_SAT_P_S32 (tl);
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh);
|
EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1285:EVX:e500:evmhossiaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Integer and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1285:EVX:e500:evmhossiaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Integer and Accumulate into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH + t1;
|
th = EV_ACCHIGH + t1;
|
tl = EV_ACCLOW + t2;
|
tl = EV_ACCLOW + t2;
|
ovh = EV_SAT_P_S32(th);
|
ovh = EV_SAT_P_S32(th);
|
ovl = EV_SAT_P_S32(tl);
|
ovl = EV_SAT_P_S32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
//printf("evmhossiaaw: ovh %d ovl %d al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", ovh, ovl, al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhossiaaw: ovh %d ovl %d al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", ovh, ovl, al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhossiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmhossiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1295:EVX:e500:evmhosmfaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Fractional and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1295:EVX:e500:evmhosmfaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Fractional and Accumulate into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
t1 = ((signed64)ah * bh) << 1;
|
t1 = ((signed64)ah * bh) << 1;
|
t2 = ((signed64)al * bl) << 1;
|
t2 = ((signed64)al * bl) << 1;
|
th = EV_ACCHIGH + (t1 & 0xffffffff);
|
th = EV_ACCHIGH + (t1 & 0xffffffff);
|
tl = EV_ACCLOW + (t2 & 0xffffffff);
|
tl = EV_ACCLOW + (t2 & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1293:EVX:e500:evmhosmiaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Integer and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1293:EVX:e500:evmhosmiaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Integer and Accumulate into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH + t1;
|
th = EV_ACCHIGH + t1;
|
tl = EV_ACCLOW + t2;
|
tl = EV_ACCLOW + t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
//printf("evmhosmiaaw: al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhosmiaaw: al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhosmiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmhosmiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1284:EVX:e500:evmhousiaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Saturate Integer and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1284:EVX:e500:evmhousiaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Saturate Integer and Accumulate into Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = (signed64)EV_ACCHIGH + (signed64)t1;
|
th = (signed64)EV_ACCHIGH + (signed64)t1;
|
tl = (signed64)EV_ACCLOW + (signed64)t2;
|
tl = (signed64)EV_ACCLOW + (signed64)t2;
|
ovh = EV_SAT_P_U32(th);
|
ovh = EV_SAT_P_U32(th);
|
ovl = EV_SAT_P_U32(tl);
|
ovl = EV_SAT_P_U32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl));
|
//printf("evmhousiaaw: al %u ah %u bl %u bh %u t1 %qu t2 %qu tl %qu th %qu\n", al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhousiaaw: al %u ah %u bl %u bh %u t1 %qu t2 %qu tl %qu th %qu\n", al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhousiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmhousiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1292:EVX:e500:evmhoumiaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Modulo Integer and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1292:EVX:e500:evmhoumiaaw %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Modulo Integer and Accumulate into Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned32 t1, t2;
|
unsigned32 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH + t1;
|
th = EV_ACCHIGH + t1;
|
tl = EV_ACCLOW + t2;
|
tl = EV_ACCLOW + t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
//printf("evmhoumiaaw: al %u ah %u bl %u bh %u t1 %qu t2 %qu tl %qu th %qu\n", al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhoumiaaw: al %u ah %u bl %u bh %u t1 %qu t2 %qu tl %qu th %qu\n", al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhoumiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmhoumiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1283:EVX:e500:evmhessfaaw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Fractional and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1283:EVX:e500:evmhessfaaw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Fractional and Accumulate into Words
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 t1, t2;
|
signed32 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
int movl, movh, ovl, ovh;
|
int movl, movh, ovl, ovh;
|
|
|
al = (signed16) EV_HIHALF (*rA);
|
al = (signed16) EV_HIHALF (*rA);
|
ah = (signed16) EV_HIHALF (*rAh);
|
ah = (signed16) EV_HIHALF (*rAh);
|
bl = (signed16) EV_HIHALF (*rB);
|
bl = (signed16) EV_HIHALF (*rB);
|
bh = (signed16) EV_HIHALF (*rBh);
|
bh = (signed16) EV_HIHALF (*rBh);
|
t1 = ev_multiply16_ssf (ah, bh, &movh);
|
t1 = ev_multiply16_ssf (ah, bh, &movh);
|
t2 = ev_multiply16_ssf (al, bl, &movl);
|
t2 = ev_multiply16_ssf (al, bl, &movl);
|
th = EV_ACCHIGH + EV_SATURATE (movh, 0x7fffffff, t1);
|
th = EV_ACCHIGH + EV_SATURATE (movh, 0x7fffffff, t1);
|
tl = EV_ACCLOW + EV_SATURATE (movl, 0x7fffffff, t2);
|
tl = EV_ACCLOW + EV_SATURATE (movl, 0x7fffffff, t2);
|
ovh = EV_SAT_P_S32 (th);
|
ovh = EV_SAT_P_S32 (th);
|
ovl = EV_SAT_P_S32 (tl);
|
ovl = EV_SAT_P_S32 (tl);
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh);
|
EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1281:EVX:e500:evmhessiaaw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Integer and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1281:EVX:e500:evmhessiaaw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Integer and Accumulate into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH + t1;
|
th = EV_ACCHIGH + t1;
|
tl = EV_ACCLOW + t2;
|
tl = EV_ACCLOW + t2;
|
ovh = EV_SAT_P_S32(th);
|
ovh = EV_SAT_P_S32(th);
|
ovl = EV_SAT_P_S32(tl);
|
ovl = EV_SAT_P_S32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
//printf("evmhessiaaw: ovh %d ovl %d al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", ovh, ovl, al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhessiaaw: ovh %d ovl %d al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", ovh, ovl, al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhessiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmhessiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1291:EVX:e500:evmhesmfaaw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Fractional and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1291:EVX:e500:evmhesmfaaw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Fractional and Accumulate into Words
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 t1, t2, th, tl;
|
signed32 t1, t2, th, tl;
|
int dummy;
|
int dummy;
|
|
|
al = (signed16)EV_HIHALF(*rA);
|
al = (signed16)EV_HIHALF(*rA);
|
ah = (signed16)EV_HIHALF(*rAh);
|
ah = (signed16)EV_HIHALF(*rAh);
|
bl = (signed16)EV_HIHALF(*rB);
|
bl = (signed16)EV_HIHALF(*rB);
|
bh = (signed16)EV_HIHALF(*rBh);
|
bh = (signed16)EV_HIHALF(*rBh);
|
t1 = ev_multiply16_smf (ah, bh, &dummy);
|
t1 = ev_multiply16_smf (ah, bh, &dummy);
|
t2 = ev_multiply16_smf (al, bl, &dummy);
|
t2 = ev_multiply16_smf (al, bl, &dummy);
|
th = EV_ACCHIGH + t1;
|
th = EV_ACCHIGH + t1;
|
tl = EV_ACCLOW + t2;
|
tl = EV_ACCLOW + t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
EV_SET_REG2_ACC(*rSh, *rS, th, tl);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1289:EVX:e500:evmhesmiaaw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Integer and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1289:EVX:e500:evmhesmiaaw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Integer and Accumulate into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH + t1;
|
th = EV_ACCHIGH + t1;
|
tl = EV_ACCLOW + t2;
|
tl = EV_ACCLOW + t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1280:EVX:e500:evmheusiaaw %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Saturate Integer and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1280:EVX:e500:evmheusiaaw %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Saturate Integer and Accumulate into Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = (signed64)EV_ACCHIGH + (signed64)t1;
|
th = (signed64)EV_ACCHIGH + (signed64)t1;
|
tl = (signed64)EV_ACCLOW + (signed64)t2;
|
tl = (signed64)EV_ACCLOW + (signed64)t2;
|
ovh = EV_SAT_P_U32(th);
|
ovh = EV_SAT_P_U32(th);
|
ovl = EV_SAT_P_U32(tl);
|
ovl = EV_SAT_P_U32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1288:EVX:e500:evmheumiaaw %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Modulo Integer and Accumulate into Words
|
0.4,6.RS,11.RA,16.RB,21.1288:EVX:e500:evmheumiaaw %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Modulo Integer and Accumulate into Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned32 t1, t2;
|
unsigned32 t1, t2;
|
unsigned64 tl, th;
|
unsigned64 tl, th;
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH + t1;
|
th = EV_ACCHIGH + t1;
|
tl = EV_ACCLOW + t2;
|
tl = EV_ACCLOW + t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1415:EVX:e500:evmhossfanw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Fractional and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1415:EVX:e500:evmhossfanw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Fractional and Accumulate Negative into Words
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 t1, t2;
|
signed32 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
int movl, movh, ovl, ovh;
|
int movl, movh, ovl, ovh;
|
|
|
al = (signed16) EV_LOHALF (*rA);
|
al = (signed16) EV_LOHALF (*rA);
|
ah = (signed16) EV_LOHALF (*rAh);
|
ah = (signed16) EV_LOHALF (*rAh);
|
bl = (signed16) EV_LOHALF (*rB);
|
bl = (signed16) EV_LOHALF (*rB);
|
bh = (signed16) EV_LOHALF (*rBh);
|
bh = (signed16) EV_LOHALF (*rBh);
|
t1 = ev_multiply16_ssf (ah, bh, &movh);
|
t1 = ev_multiply16_ssf (ah, bh, &movh);
|
t2 = ev_multiply16_ssf (al, bl, &movl);
|
t2 = ev_multiply16_ssf (al, bl, &movl);
|
th = EV_ACCHIGH - EV_SATURATE (movh, 0x7fffffff, t1);
|
th = EV_ACCHIGH - EV_SATURATE (movh, 0x7fffffff, t1);
|
tl = EV_ACCLOW - EV_SATURATE (movl, 0x7fffffff, t2);
|
tl = EV_ACCLOW - EV_SATURATE (movl, 0x7fffffff, t2);
|
ovh = EV_SAT_P_S32 (th);
|
ovh = EV_SAT_P_S32 (th);
|
ovl = EV_SAT_P_S32 (tl);
|
ovl = EV_SAT_P_S32 (tl);
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh);
|
EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1413:EVX:e500:evmhossianw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Integer and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1413:EVX:e500:evmhossianw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Saturate Integer and Accumulate Negative into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH - t1;
|
th = EV_ACCHIGH - t1;
|
tl = EV_ACCLOW - t2;
|
tl = EV_ACCLOW - t2;
|
ovh = EV_SAT_P_S32(th);
|
ovh = EV_SAT_P_S32(th);
|
ovl = EV_SAT_P_S32(tl);
|
ovl = EV_SAT_P_S32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
//printf("evmhossianw: ACC = %08x; *rSh = %08x; *rS = %08x\n", ACC, *rSh, *rS);
|
//printf("evmhossianw: ACC = %08x; *rSh = %08x; *rS = %08x\n", ACC, *rSh, *rS);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1423:EVX:e500:evmhosmfanw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Fractional and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1423:EVX:e500:evmhosmfanw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Fractional and Accumulate Negative into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
t1 = ((signed64)ah * bh) << 1;
|
t1 = ((signed64)ah * bh) << 1;
|
t2 = ((signed64)al * bl) << 1;
|
t2 = ((signed64)al * bl) << 1;
|
th = EV_ACCHIGH - (t1 & 0xffffffff);
|
th = EV_ACCHIGH - (t1 & 0xffffffff);
|
tl = EV_ACCLOW - (t2 & 0xffffffff);
|
tl = EV_ACCLOW - (t2 & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1421:EVX:e500:evmhosmianw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Integer and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1421:EVX:e500:evmhosmianw %RS,%RA,%RB:Vector Multiply Half Words Odd Signed Modulo Integer and Accumulate Negative into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
al = (signed32)(signed16)EV_LOHALF(*rA);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
ah = (signed32)(signed16)EV_LOHALF(*rAh);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bl = (signed32)(signed16)EV_LOHALF(*rB);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
bh = (signed32)(signed16)EV_LOHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH - t1;
|
th = EV_ACCHIGH - t1;
|
tl = EV_ACCLOW - t2;
|
tl = EV_ACCLOW - t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1412:EVX:e500:evmhousianw %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Saturate Integer and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1412:EVX:e500:evmhousianw %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Saturate Integer and Accumulate Negative into Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = (signed64)EV_ACCHIGH - (signed64)t1;
|
th = (signed64)EV_ACCHIGH - (signed64)t1;
|
tl = (signed64)EV_ACCLOW - (signed64)t2;
|
tl = (signed64)EV_ACCLOW - (signed64)t2;
|
ovl = EV_SAT_P_U32(tl);
|
ovl = EV_SAT_P_U32(tl);
|
ovh = EV_SAT_P_U32(th);
|
ovh = EV_SAT_P_U32(th);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl));
|
//printf("evmhousianw: ovh %d ovl %d al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", ovh, ovl, al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhousianw: ovh %d ovl %d al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", ovh, ovl, al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmoussianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmoussianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1420:EVX:e500:evmhoumianw %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Modulo Integer and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1420:EVX:e500:evmhoumianw %RS,%RA,%RB:Vector Multiply Half Words Odd Unsigned Modulo Integer and Accumulate Negative into Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned32 t1, t2;
|
unsigned32 t1, t2;
|
unsigned64 tl, th;
|
unsigned64 tl, th;
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_LOHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_LOHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH - t1;
|
th = EV_ACCHIGH - t1;
|
tl = EV_ACCLOW - t2;
|
tl = EV_ACCLOW - t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1411:EVX:e500:evmhessfanw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Fractional and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1411:EVX:e500:evmhessfanw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Fractional and Accumulate Negative into Words
|
signed16 al, ah, bl, bh;
|
signed16 al, ah, bl, bh;
|
signed32 t1, t2;
|
signed32 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
int movl, movh, ovl, ovh;
|
int movl, movh, ovl, ovh;
|
|
|
al = (signed16) EV_HIHALF (*rA);
|
al = (signed16) EV_HIHALF (*rA);
|
ah = (signed16) EV_HIHALF (*rAh);
|
ah = (signed16) EV_HIHALF (*rAh);
|
bl = (signed16) EV_HIHALF (*rB);
|
bl = (signed16) EV_HIHALF (*rB);
|
bh = (signed16) EV_HIHALF (*rBh);
|
bh = (signed16) EV_HIHALF (*rBh);
|
t1 = ev_multiply16_ssf (ah, bh, &movh);
|
t1 = ev_multiply16_ssf (ah, bh, &movh);
|
t2 = ev_multiply16_ssf (al, bl, &movl);
|
t2 = ev_multiply16_ssf (al, bl, &movl);
|
th = EV_ACCHIGH - EV_SATURATE (movh, 0x7fffffff, t1);
|
th = EV_ACCHIGH - EV_SATURATE (movh, 0x7fffffff, t1);
|
tl = EV_ACCLOW - EV_SATURATE (movl, 0x7fffffff, t2);
|
tl = EV_ACCLOW - EV_SATURATE (movl, 0x7fffffff, t2);
|
ovh = EV_SAT_P_S32 (th);
|
ovh = EV_SAT_P_S32 (th);
|
ovl = EV_SAT_P_S32 (tl);
|
ovl = EV_SAT_P_S32 (tl);
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh);
|
EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR (RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1409:EVX:e500:evmhessianw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Integer and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1409:EVX:e500:evmhessianw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Saturate Integer and Accumulate Negative into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH - t1;
|
th = EV_ACCHIGH - t1;
|
tl = EV_ACCLOW - t2;
|
tl = EV_ACCLOW - t2;
|
ovh = EV_SAT_P_S32(th);
|
ovh = EV_SAT_P_S32(th);
|
ovl = EV_SAT_P_S32(tl);
|
ovl = EV_SAT_P_S32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1419:EVX:e500:evmhesmfanw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Fractional and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1419:EVX:e500:evmhesmfanw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Fractional and Accumulate Negative into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
t1 = ((signed64)ah * bh) << 1;
|
t1 = ((signed64)ah * bh) << 1;
|
t2 = ((signed64)al * bl) << 1;
|
t2 = ((signed64)al * bl) << 1;
|
th = EV_ACCHIGH - (t1 & 0xffffffff);
|
th = EV_ACCHIGH - (t1 & 0xffffffff);
|
tl = EV_ACCLOW - (t2 & 0xffffffff);
|
tl = EV_ACCLOW - (t2 & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1417:EVX:e500:evmhesmianw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Integer and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1417:EVX:e500:evmhesmianw %RS,%RA,%RB:Vector Multiply Half Words Even Signed Modulo Integer and Accumulate Negative into Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
al = (signed32)(signed16)EV_HIHALF(*rA);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
ah = (signed32)(signed16)EV_HIHALF(*rAh);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bl = (signed32)(signed16)EV_HIHALF(*rB);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
bh = (signed32)(signed16)EV_HIHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH - t1;
|
th = EV_ACCHIGH - t1;
|
tl = EV_ACCLOW - t2;
|
tl = EV_ACCLOW - t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
//printf("evmhesmianw: al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhesmianw: al %d ah %d bl %d bh %d t1 %qd t2 %qd tl %qd th %qd\n", al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmhesmianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmhesmianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1408:EVX:e500:evmheusianw %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Saturate Integer and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1408:EVX:e500:evmheusianw %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Saturate Integer and Accumulate Negative into Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
signed64 tl, th;
|
signed64 tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = (signed64)EV_ACCHIGH - (signed64)t1;
|
th = (signed64)EV_ACCHIGH - (signed64)t1;
|
tl = (signed64)EV_ACCLOW - (signed64)t2;
|
tl = (signed64)EV_ACCLOW - (signed64)t2;
|
ovl = EV_SAT_P_U32(tl);
|
ovl = EV_SAT_P_U32(tl);
|
ovh = EV_SAT_P_U32(th);
|
ovh = EV_SAT_P_U32(th);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl));
|
//printf("evmheusianw: ovh %d ovl %d al %u ah %u bl %u bh %u t1 %qu t2 %qu tl %qd th %qd\n", ovh, ovl, al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmheusianw: ovh %d ovl %d al %u ah %u bl %u bh %u t1 %qu t2 %qu tl %qd th %qd\n", ovh, ovl, al, ah, bl, bh, t1, t2, tl, th);
|
//printf("evmheusianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmheusianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1416:EVX:e500:evmheumianw %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Modulo Integer and Accumulate Negative into Words
|
0.4,6.RS,11.RA,16.RB,21.1416:EVX:e500:evmheumianw %RS,%RA,%RB:Vector Multiply Half Words Even Unsigned Modulo Integer and Accumulate Negative into Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned32 t1, t2;
|
unsigned32 t1, t2;
|
unsigned64 tl, th;
|
unsigned64 tl, th;
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
al = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
ah = (unsigned32)(unsigned16)EV_HIHALF(*rAh);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bl = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
bh = (unsigned32)(unsigned16)EV_HIHALF(*rBh);
|
t1 = ah * bh;
|
t1 = ah * bh;
|
t2 = al * bl;
|
t2 = al * bl;
|
th = EV_ACCHIGH - t1;
|
th = EV_ACCHIGH - t1;
|
tl = EV_ACCLOW - t2;
|
tl = EV_ACCLOW - t2;
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1327:EVX:e500:evmhogsmfaa %RS,%RA,%RB:Multiply Half Words Odd Guarded Signed Modulo Fractional and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1327:EVX:e500:evmhogsmfaa %RS,%RA,%RB:Multiply Half Words Odd Guarded Signed Modulo Fractional and Accumulate
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
a = (signed32)(signed16)EV_LOHALF(*rA);
|
a = (signed32)(signed16)EV_LOHALF(*rA);
|
b = (signed32)(signed16)EV_LOHALF(*rB);
|
b = (signed32)(signed16)EV_LOHALF(*rB);
|
t1 = EV_MUL16_SSF(a, b);
|
t1 = EV_MUL16_SSF(a, b);
|
if (t1 & ((unsigned64)1 << 32))
|
if (t1 & ((unsigned64)1 << 32))
|
t1 |= 0xfffffffe00000000;
|
t1 |= 0xfffffffe00000000;
|
t2 = ACC + t1;
|
t2 = ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1325:EVX:e500:evmhogsmiaa %RS,%RA,%RB:Multiply Half Words Odd Guarded Signed Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1325:EVX:e500:evmhogsmiaa %RS,%RA,%RB:Multiply Half Words Odd Guarded Signed Modulo Integer and Accumulate
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
a = (signed32)(signed16)EV_LOHALF(*rA);
|
a = (signed32)(signed16)EV_LOHALF(*rA);
|
b = (signed32)(signed16)EV_LOHALF(*rB);
|
b = (signed32)(signed16)EV_LOHALF(*rB);
|
t1 = (signed64)a * (signed64)b;
|
t1 = (signed64)a * (signed64)b;
|
t2 = (signed64)ACC + t1;
|
t2 = (signed64)ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
//printf("evmhogsmiaa: a %d b %d t1 %qd t2 %qd\n", a, b, t1, t2);
|
//printf("evmhogsmiaa: a %d b %d t1 %qd t2 %qd\n", a, b, t1, t2);
|
//printf("evmhogsmiaa: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmhogsmiaa: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1324:EVX:e500:evmhogumiaa %RS,%RA,%RB:Multiply Half Words Odd Guarded Unsigned Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1324:EVX:e500:evmhogumiaa %RS,%RA,%RB:Multiply Half Words Odd Guarded Unsigned Modulo Integer and Accumulate
|
unsigned32 a, b;
|
unsigned32 a, b;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
a = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
a = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
b = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
b = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
t1 = a * b;
|
t1 = a * b;
|
t2 = ACC + t1;
|
t2 = ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1323:EVX:e500:evmhegsmfaa %RS,%RA,%RB:Multiply Half Words Even Guarded Signed Modulo Fractional and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1323:EVX:e500:evmhegsmfaa %RS,%RA,%RB:Multiply Half Words Even Guarded Signed Modulo Fractional and Accumulate
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
a = (signed32)(signed16)EV_HIHALF(*rA);
|
a = (signed32)(signed16)EV_HIHALF(*rA);
|
b = (signed32)(signed16)EV_HIHALF(*rB);
|
b = (signed32)(signed16)EV_HIHALF(*rB);
|
t1 = EV_MUL16_SSF(a, b);
|
t1 = EV_MUL16_SSF(a, b);
|
if (t1 & ((unsigned64)1 << 32))
|
if (t1 & ((unsigned64)1 << 32))
|
t1 |= 0xfffffffe00000000;
|
t1 |= 0xfffffffe00000000;
|
t2 = ACC + t1;
|
t2 = ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1321:EVX:e500:evmhegsmiaa %RS,%RA,%RB:Multiply Half Words Even Guarded Signed Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1321:EVX:e500:evmhegsmiaa %RS,%RA,%RB:Multiply Half Words Even Guarded Signed Modulo Integer and Accumulate
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
a = (signed32)(signed16)EV_HIHALF(*rA);
|
a = (signed32)(signed16)EV_HIHALF(*rA);
|
b = (signed32)(signed16)EV_HIHALF(*rB);
|
b = (signed32)(signed16)EV_HIHALF(*rB);
|
t1 = (signed64)(a * b);
|
t1 = (signed64)(a * b);
|
t2 = ACC + t1;
|
t2 = ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1320:EVX:e500:evmhegumiaa %RS,%RA,%RB:Multiply Half Words Even Guarded Unsigned Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1320:EVX:e500:evmhegumiaa %RS,%RA,%RB:Multiply Half Words Even Guarded Unsigned Modulo Integer and Accumulate
|
unsigned32 a, b;
|
unsigned32 a, b;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
a = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
a = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
b = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
b = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
t1 = a * b;
|
t1 = a * b;
|
t2 = ACC + t1;
|
t2 = ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1455:EVX:e500:evmhogsmfan %RS,%RA,%RB:Multiply Half Words Odd Guarded Signed Modulo Fractional and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1455:EVX:e500:evmhogsmfan %RS,%RA,%RB:Multiply Half Words Odd Guarded Signed Modulo Fractional and Accumulate Negative
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
a = (signed32)(signed16)EV_LOHALF(*rA);
|
a = (signed32)(signed16)EV_LOHALF(*rA);
|
b = (signed32)(signed16)EV_LOHALF(*rB);
|
b = (signed32)(signed16)EV_LOHALF(*rB);
|
t1 = EV_MUL16_SSF(a, b);
|
t1 = EV_MUL16_SSF(a, b);
|
if (t1 & ((unsigned64)1 << 32))
|
if (t1 & ((unsigned64)1 << 32))
|
t1 |= 0xfffffffe00000000;
|
t1 |= 0xfffffffe00000000;
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1453:EVX:e500:evmhogsmian %RS,%RA,%RB:Multiply Half Words Odd Guarded Signed Modulo Integer and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1453:EVX:e500:evmhogsmian %RS,%RA,%RB:Multiply Half Words Odd Guarded Signed Modulo Integer and Accumulate Negative
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
a = (signed32)(signed16)EV_LOHALF(*rA);
|
a = (signed32)(signed16)EV_LOHALF(*rA);
|
b = (signed32)(signed16)EV_LOHALF(*rB);
|
b = (signed32)(signed16)EV_LOHALF(*rB);
|
t1 = (signed64)a * (signed64)b;
|
t1 = (signed64)a * (signed64)b;
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
//printf("evmhogsmian: a %d b %d t1 %qd t2 %qd\n", a, b, t1, t2);
|
//printf("evmhogsmian: a %d b %d t1 %qd t2 %qd\n", a, b, t1, t2);
|
//printf("evmhogsmian: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmhogsmian: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1452:EVX:e500:evmhogumian %RS,%RA,%RB:Multiply Half Words Odd Guarded Unsigned Modulo Integer and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1452:EVX:e500:evmhogumian %RS,%RA,%RB:Multiply Half Words Odd Guarded Unsigned Modulo Integer and Accumulate Negative
|
unsigned32 a, b;
|
unsigned32 a, b;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
a = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
a = (unsigned32)(unsigned16)EV_LOHALF(*rA);
|
b = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
b = (unsigned32)(unsigned16)EV_LOHALF(*rB);
|
t1 = (unsigned64)a * (unsigned64)b;
|
t1 = (unsigned64)a * (unsigned64)b;
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1451:EVX:e500:evmhegsmfan %RS,%RA,%RB:Multiply Half Words Even Guarded Signed Modulo Fractional and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1451:EVX:e500:evmhegsmfan %RS,%RA,%RB:Multiply Half Words Even Guarded Signed Modulo Fractional and Accumulate Negative
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
a = (signed32)(signed16)EV_HIHALF(*rA);
|
a = (signed32)(signed16)EV_HIHALF(*rA);
|
b = (signed32)(signed16)EV_HIHALF(*rB);
|
b = (signed32)(signed16)EV_HIHALF(*rB);
|
t1 = EV_MUL16_SSF(a, b);
|
t1 = EV_MUL16_SSF(a, b);
|
if (t1 & ((unsigned64)1 << 32))
|
if (t1 & ((unsigned64)1 << 32))
|
t1 |= 0xfffffffe00000000;
|
t1 |= 0xfffffffe00000000;
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1449:EVX:e500:evmhegsmian %RS,%RA,%RB:Multiply Half Words Even Guarded Signed Modulo Integer and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1449:EVX:e500:evmhegsmian %RS,%RA,%RB:Multiply Half Words Even Guarded Signed Modulo Integer and Accumulate Negative
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
a = (signed32)(signed16)EV_HIHALF(*rA);
|
a = (signed32)(signed16)EV_HIHALF(*rA);
|
b = (signed32)(signed16)EV_HIHALF(*rB);
|
b = (signed32)(signed16)EV_HIHALF(*rB);
|
t1 = (signed64)a * (signed64)b;
|
t1 = (signed64)a * (signed64)b;
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1448:EVX:e500:evmhegumian %RS,%RA,%RB:Multiply Half Words Even Guarded Unsigned Modulo Integer and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1448:EVX:e500:evmhegumian %RS,%RA,%RB:Multiply Half Words Even Guarded Unsigned Modulo Integer and Accumulate Negative
|
unsigned32 a, b;
|
unsigned32 a, b;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
a = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
a = (unsigned32)(unsigned16)EV_HIHALF(*rA);
|
b = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
b = (unsigned32)(unsigned16)EV_HIHALF(*rB);
|
t1 = (unsigned64)a * (unsigned64)b;
|
t1 = (unsigned64)a * (unsigned64)b;
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1095:EVX:e500:evmwhssf %RS,%RA,%RB:Vector Multiply Word High Signed Saturate Fractional
|
0.4,6.RS,11.RA,16.RB,21.1095:EVX:e500:evmwhssf %RS,%RA,%RB:Vector Multiply Word High Signed Saturate Fractional
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
int movl, movh;
|
int movl, movh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = ev_multiply32_ssf(al, bl, &movl);
|
t1 = ev_multiply32_ssf(al, bl, &movl);
|
t2 = ev_multiply32_ssf(ah, bh, &movh);
|
t2 = ev_multiply32_ssf(ah, bh, &movh);
|
EV_SET_REG2(*rSh, *rS, EV_SATURATE(movh, 0x7fffffff, t2 >> 32),
|
EV_SET_REG2(*rSh, *rS, EV_SATURATE(movh, 0x7fffffff, t2 >> 32),
|
EV_SATURATE(movl, 0x7fffffff, t1 >> 32));
|
EV_SATURATE(movl, 0x7fffffff, t1 >> 32));
|
EV_SET_SPEFSCR_OV(movl, movh);
|
EV_SET_SPEFSCR_OV(movl, movh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1127:EVX:e500:evmwhssfa %RS,%RA,%RB:Vector Multiply Word High Signed Saturate Fractional and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1127:EVX:e500:evmwhssfa %RS,%RA,%RB:Vector Multiply Word High Signed Saturate Fractional and Accumulate
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
int movl, movh;
|
int movl, movh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = ev_multiply32_ssf(al, bl, &movl);
|
t1 = ev_multiply32_ssf(al, bl, &movl);
|
t2 = ev_multiply32_ssf(ah, bh, &movh);
|
t2 = ev_multiply32_ssf(ah, bh, &movh);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(movh, 0x7fffffff, t2 >> 32),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(movh, 0x7fffffff, t2 >> 32),
|
EV_SATURATE(movl, 0x7fffffff, t1 >> 32));
|
EV_SATURATE(movl, 0x7fffffff, t1 >> 32));
|
EV_SET_SPEFSCR_OV(movl, movh);
|
EV_SET_SPEFSCR_OV(movl, movh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1103:EVX:e500:evmwhsmf %RS,%RA,%RB:Vector Multiply Word High Signed Modulo Fractional
|
0.4,6.RS,11.RA,16.RB,21.1103:EVX:e500:evmwhsmf %RS,%RA,%RB:Vector Multiply Word High Signed Modulo Fractional
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = EV_MUL32_SSF(al, bl);
|
t1 = EV_MUL32_SSF(al, bl);
|
t2 = EV_MUL32_SSF(ah, bh);
|
t2 = EV_MUL32_SSF(ah, bh);
|
EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32);
|
EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1135:EVX:e500:evmwhsmfa %RS,%RA,%RB:Vector Multiply Word High Signed Modulo Fractional and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1135:EVX:e500:evmwhsmfa %RS,%RA,%RB:Vector Multiply Word High Signed Modulo Fractional and Accumulate
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = EV_MUL32_SSF(al, bl);
|
t1 = EV_MUL32_SSF(al, bl);
|
t2 = EV_MUL32_SSF(ah, bh);
|
t2 = EV_MUL32_SSF(ah, bh);
|
EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32);
|
EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1101:EVX:e500:evmwhsmi %RS,%RA,%RB:Vector Multiply Word High Signed Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1101:EVX:e500:evmwhsmi %RS,%RA,%RB:Vector Multiply Word High Signed Modulo Integer
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (signed64)al * (signed64)bl;
|
t1 = (signed64)al * (signed64)bl;
|
t2 = (signed64)ah * (signed64)bh;
|
t2 = (signed64)ah * (signed64)bh;
|
EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32);
|
EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1133:EVX:e500:evmwhsmia %RS,%RA,%RB:Vector Multiply Word High Signed Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1133:EVX:e500:evmwhsmia %RS,%RA,%RB:Vector Multiply Word High Signed Modulo Integer and Accumulate
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (signed64)al * (signed64)bl;
|
t1 = (signed64)al * (signed64)bl;
|
t2 = (signed64)ah * (signed64)bh;
|
t2 = (signed64)ah * (signed64)bh;
|
EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32);
|
EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1100:EVX:e500:evmwhumi %RS,%RA,%RB:Vector Multiply Word High Unsigned Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1100:EVX:e500:evmwhumi %RS,%RA,%RB:Vector Multiply Word High Unsigned Modulo Integer
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (unsigned64)al * (unsigned64)bl;
|
t1 = (unsigned64)al * (unsigned64)bl;
|
t2 = (unsigned64)ah * (unsigned64)bh;
|
t2 = (unsigned64)ah * (unsigned64)bh;
|
EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32);
|
EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1132:EVX:e500:evmwhumia %RS,%RA,%RB:Vector Multiply Word High Unsigned Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1132:EVX:e500:evmwhumia %RS,%RA,%RB:Vector Multiply Word High Unsigned Modulo Integer and Accumulate
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (unsigned64)al * (unsigned64)bl;
|
t1 = (unsigned64)al * (unsigned64)bl;
|
t2 = (unsigned64)ah * (unsigned64)bh;
|
t2 = (unsigned64)ah * (unsigned64)bh;
|
EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32);
|
EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1091:EVX:e500:evmwlssf %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Fractional
|
0.4,6.RS,11.RA,16.RB,21.1091:EVX:e500:evmwlssf %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Fractional
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
int movl, movh;
|
int movl, movh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = ev_multiply32_ssf(al, bl, &movl);
|
t1 = ev_multiply32_ssf(al, bl, &movl);
|
t2 = ev_multiply32_ssf(ah, bh, &movh);
|
t2 = ev_multiply32_ssf(ah, bh, &movh);
|
EV_SET_REG2(*rSh, *rS, EV_SATURATE(movh, 0xffffffff, t2),
|
EV_SET_REG2(*rSh, *rS, EV_SATURATE(movh, 0xffffffff, t2),
|
EV_SATURATE(movl, 0xffffffff, t1));
|
EV_SATURATE(movl, 0xffffffff, t1));
|
EV_SET_SPEFSCR_OV(movl, movh);
|
EV_SET_SPEFSCR_OV(movl, movh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1123:EVX:e500:evmwlssfa %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Fractional and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1123:EVX:e500:evmwlssfa %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Fractional and Accumulate
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
int movl, movh;
|
int movl, movh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = ev_multiply32_ssf(al, bl, &movl);
|
t1 = ev_multiply32_ssf(al, bl, &movl);
|
t2 = ev_multiply32_ssf(ah, bh, &movh);
|
t2 = ev_multiply32_ssf(ah, bh, &movh);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(movh, 0xffffffff, t2),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(movh, 0xffffffff, t2),
|
EV_SATURATE(movl, 0xffffffff, t1));
|
EV_SATURATE(movl, 0xffffffff, t1));
|
EV_SET_SPEFSCR_OV(movl, movh);
|
EV_SET_SPEFSCR_OV(movl, movh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1099:EVX:e500:evmwlsmf %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Fractional
|
0.4,6.RS,11.RA,16.RB,21.1099:EVX:e500:evmwlsmf %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Fractional
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = EV_MUL32_SSF(al, bl);
|
t1 = EV_MUL32_SSF(al, bl);
|
t2 = EV_MUL32_SSF(ah, bh);
|
t2 = EV_MUL32_SSF(ah, bh);
|
EV_SET_REG2(*rSh, *rS, t2, t1);
|
EV_SET_REG2(*rSh, *rS, t2, t1);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1131:EVX:e500:evmwlsmfa %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Fractional and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1131:EVX:e500:evmwlsmfa %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Fractional and Accumulate
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = EV_MUL32_SSF(al, bl);
|
t1 = EV_MUL32_SSF(al, bl);
|
t2 = EV_MUL32_SSF(ah, bh);
|
t2 = EV_MUL32_SSF(ah, bh);
|
EV_SET_REG2_ACC(*rSh, *rS, t2, t1);
|
EV_SET_REG2_ACC(*rSh, *rS, t2, t1);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1096:EVX:e500:evmwlumi %RS,%RA,%RB:Vector Multiply Word Low Unsigned Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1096:EVX:e500:evmwlumi %RS,%RA,%RB:Vector Multiply Word Low Unsigned Modulo Integer
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (unsigned64)al * (unsigned64)bl;
|
t1 = (unsigned64)al * (unsigned64)bl;
|
t2 = (unsigned64)ah * (unsigned64)bh;
|
t2 = (unsigned64)ah * (unsigned64)bh;
|
EV_SET_REG2(*rSh, *rS, t2, t1);
|
EV_SET_REG2(*rSh, *rS, t2, t1);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1128:EVX:e500:evmwlumia %RS,%RA,%RB:Vector Multiply Word Low Unsigned Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1128:EVX:e500:evmwlumia %RS,%RA,%RB:Vector Multiply Word Low Unsigned Modulo Integer and Accumulate
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (unsigned64)al * (unsigned64)bl;
|
t1 = (unsigned64)al * (unsigned64)bl;
|
t2 = (unsigned64)ah * (unsigned64)bh;
|
t2 = (unsigned64)ah * (unsigned64)bh;
|
EV_SET_REG2_ACC(*rSh, *rS, t2, t1);
|
EV_SET_REG2_ACC(*rSh, *rS, t2, t1);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1347:EVX:e500:evmwlssfaaw %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Fractional and Accumulate in Words
|
0.4,6.RS,11.RA,16.RB,21.1347:EVX:e500:evmwlssfaaw %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Fractional and Accumulate in Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
int movl, movh, ovl, ovh;
|
int movl, movh, ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = ev_multiply32_ssf(ah, bh, &movh);
|
t1 = ev_multiply32_ssf(ah, bh, &movh);
|
t2 = ev_multiply32_ssf(al, bl, &movl);
|
t2 = ev_multiply32_ssf(al, bl, &movl);
|
th = EV_ACCHIGH + EV_SATURATE(movh, 0xffffffff, t1);
|
th = EV_ACCHIGH + EV_SATURATE(movh, 0xffffffff, t1);
|
tl = EV_ACCLOW + EV_SATURATE(movl, 0xffffffff, t2);
|
tl = EV_ACCLOW + EV_SATURATE(movl, 0xffffffff, t2);
|
ovh = EV_SAT_P_S32(th);
|
ovh = EV_SAT_P_S32(th);
|
ovl = EV_SAT_P_S32(tl);
|
ovl = EV_SAT_P_S32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV(movl | ovl, movh | ovh);
|
EV_SET_SPEFSCR_OV(movl | ovl, movh | ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1345:EVX:e500:evmwlssiaaw %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Integer and Accumulate in Words
|
0.4,6.RS,11.RA,16.RB,21.1345:EVX:e500:evmwlssiaaw %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Integer and Accumulate in Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (signed64)ah * (signed64)bh;
|
t1 = (signed64)ah * (signed64)bh;
|
t2 = (signed64)al * (signed64)bl;
|
t2 = (signed64)al * (signed64)bl;
|
th = EV_ACCHIGH + (t1 & 0xffffffff);
|
th = EV_ACCHIGH + (t1 & 0xffffffff);
|
tl = EV_ACCLOW + (t2 & 0xffffffff);
|
tl = EV_ACCLOW + (t2 & 0xffffffff);
|
ovh = EV_SAT_P_S32(th);
|
ovh = EV_SAT_P_S32(th);
|
ovl = EV_SAT_P_S32(tl);
|
ovl = EV_SAT_P_S32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1355:EVX:e500:evmwlsmfaaw %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Fractional and Accumulate in Words
|
0.4,6.RS,11.RA,16.RB,21.1355:EVX:e500:evmwlsmfaaw %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Fractional and Accumulate in Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
int mov;
|
int mov;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = ev_multiply32_smf(ah, bh, &mov);
|
t1 = ev_multiply32_smf(ah, bh, &mov);
|
t2 = ev_multiply32_smf(al, bl, &mov);
|
t2 = ev_multiply32_smf(al, bl, &mov);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 0xffffffff),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 0xffffffff),
|
EV_ACCLOW + (t2 & 0xffffffff));
|
EV_ACCLOW + (t2 & 0xffffffff));
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1353:EVX:e500:evmwlsmiaaw %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Integer and Accumulate in Words
|
0.4,6.RS,11.RA,16.RB,21.1353:EVX:e500:evmwlsmiaaw %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Integer and Accumulate in Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (signed64)ah * (signed64)bh;
|
t1 = (signed64)ah * (signed64)bh;
|
t2 = (signed64)al * (signed64)bl;
|
t2 = (signed64)al * (signed64)bl;
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 0xffffffff),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 0xffffffff),
|
EV_ACCLOW + (t2 & 0xffffffff));
|
EV_ACCLOW + (t2 & 0xffffffff));
|
//printf("evmwlsmiaaw: al %d ah %d bl %d bh %d t1 %qd t2 %qd\n", al, ah, bl, bh, t1, t2);
|
//printf("evmwlsmiaaw: al %d ah %d bl %d bh %d t1 %qd t2 %qd\n", al, ah, bl, bh, t1, t2);
|
//printf("evmwlsmiaaw: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
//printf("evmwlsmiaaw: *rSh = %08x; *rS = %08x\n", *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1344:EVX:e500:evmwlusiaaw %RS,%RA,%RB:Vector Multiply Word Low Unsigned Saturate Integer and Accumulate in Words
|
0.4,6.RS,11.RA,16.RB,21.1344:EVX:e500:evmwlusiaaw %RS,%RA,%RB:Vector Multiply Word Low Unsigned Saturate Integer and Accumulate in Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2, tl, th;
|
unsigned64 t1, t2, tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (unsigned64)ah * (unsigned64)bh;
|
t1 = (unsigned64)ah * (unsigned64)bh;
|
t2 = (unsigned64)al * (unsigned64)bl;
|
t2 = (unsigned64)al * (unsigned64)bl;
|
th = EV_ACCHIGH + (t1 & 0xffffffff);
|
th = EV_ACCHIGH + (t1 & 0xffffffff);
|
tl = EV_ACCLOW + (t2 & 0xffffffff);
|
tl = EV_ACCLOW + (t2 & 0xffffffff);
|
ovh = (th >> 32);
|
ovh = (th >> 32);
|
ovl = (tl >> 32);
|
ovl = (tl >> 32);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, th),
|
EV_SATURATE(ovl, 0xffffffff, tl));
|
EV_SATURATE(ovl, 0xffffffff, tl));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1352:EVX:e500:evmwlumiaaw %RS,%RA,%RB:Vector Multiply Word Low Unsigned Modulo Integer and Accumulate in Words
|
0.4,6.RS,11.RA,16.RB,21.1352:EVX:e500:evmwlumiaaw %RS,%RA,%RB:Vector Multiply Word Low Unsigned Modulo Integer and Accumulate in Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (unsigned64)ah * (unsigned64)bh;
|
t1 = (unsigned64)ah * (unsigned64)bh;
|
t2 = (unsigned64)al * (unsigned64)bl;
|
t2 = (unsigned64)al * (unsigned64)bl;
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 0xffffffff),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 0xffffffff),
|
EV_ACCLOW + (t2 & 0xffffffff));
|
EV_ACCLOW + (t2 & 0xffffffff));
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1475:EVX:e500:evmwlssfanw %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Fractional and Accumulate Negative in Words
|
0.4,6.RS,11.RA,16.RB,21.1475:EVX:e500:evmwlssfanw %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Fractional and Accumulate Negative in Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
int movl, movh, ovl, ovh;
|
int movl, movh, ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = ev_multiply32_ssf(ah, bh, &movh);
|
t1 = ev_multiply32_ssf(ah, bh, &movh);
|
t2 = ev_multiply32_ssf(al, bl, &movl);
|
t2 = ev_multiply32_ssf(al, bl, &movl);
|
th = EV_ACCHIGH - EV_SATURATE(movh, 0xffffffff, t1);
|
th = EV_ACCHIGH - EV_SATURATE(movh, 0xffffffff, t1);
|
tl = EV_ACCLOW - EV_SATURATE(movl, 0xffffffff, t2);
|
tl = EV_ACCLOW - EV_SATURATE(movl, 0xffffffff, t2);
|
ovh = EV_SAT_P_S32(th);
|
ovh = EV_SAT_P_S32(th);
|
ovl = EV_SAT_P_S32(tl);
|
ovl = EV_SAT_P_S32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV(movl | ovl, movh | ovh);
|
EV_SET_SPEFSCR_OV(movl | ovl, movh | ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1473:EVX:e500:evmwlssianw %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Integer and Accumulate Negative in Words
|
0.4,6.RS,11.RA,16.RB,21.1473:EVX:e500:evmwlssianw %RS,%RA,%RB:Vector Multiply Word Low Signed Saturate Integer and Accumulate Negative in Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2, tl, th;
|
signed64 t1, t2, tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (signed64)ah * (signed64)bh;
|
t1 = (signed64)ah * (signed64)bh;
|
t2 = (signed64)al * (signed64)bl;
|
t2 = (signed64)al * (signed64)bl;
|
th = EV_ACCHIGH - (t1 & 0xffffffff);
|
th = EV_ACCHIGH - (t1 & 0xffffffff);
|
tl = EV_ACCLOW - (t2 & 0xffffffff);
|
tl = EV_ACCLOW - (t2 & 0xffffffff);
|
ovh = EV_SAT_P_S32(th);
|
ovh = EV_SAT_P_S32(th);
|
ovl = EV_SAT_P_S32(tl);
|
ovl = EV_SAT_P_S32(tl);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th),
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1483:EVX:e500:evmwlsmfanw %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Fractional and Accumulate Negative in Words
|
0.4,6.RS,11.RA,16.RB,21.1483:EVX:e500:evmwlsmfanw %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Fractional and Accumulate Negative in Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
int mov;
|
int mov;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = ev_multiply32_smf(ah, bh, &mov);
|
t1 = ev_multiply32_smf(ah, bh, &mov);
|
t2 = ev_multiply32_smf(al, bl, &mov);
|
t2 = ev_multiply32_smf(al, bl, &mov);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff),
|
EV_ACCLOW - (t2 & 0xffffffff));
|
EV_ACCLOW - (t2 & 0xffffffff));
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1481:EVX:e500:evmwlsmianw %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Integer and Accumulate Negative in Words
|
0.4,6.RS,11.RA,16.RB,21.1481:EVX:e500:evmwlsmianw %RS,%RA,%RB:Vector Multiply Word Low Signed Modulo Integer and Accumulate Negative in Words
|
signed32 al, ah, bl, bh;
|
signed32 al, ah, bl, bh;
|
signed64 t1, t2;
|
signed64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (signed64)ah * (signed64)bh;
|
t1 = (signed64)ah * (signed64)bh;
|
t2 = (signed64)al * (signed64)bl;
|
t2 = (signed64)al * (signed64)bl;
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff),
|
EV_ACCLOW - (t2 & 0xffffffff));
|
EV_ACCLOW - (t2 & 0xffffffff));
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1472:EVX:e500:evmwlusianw %RS,%RA,%RB:Vector Multiply Word Low Unsigned Saturate Integer and Accumulate Negative in Words
|
0.4,6.RS,11.RA,16.RB,21.1472:EVX:e500:evmwlusianw %RS,%RA,%RB:Vector Multiply Word Low Unsigned Saturate Integer and Accumulate Negative in Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2, tl, th;
|
unsigned64 t1, t2, tl, th;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (unsigned64)ah * (unsigned64)bh;
|
t1 = (unsigned64)ah * (unsigned64)bh;
|
t2 = (unsigned64)al * (unsigned64)bl;
|
t2 = (unsigned64)al * (unsigned64)bl;
|
th = EV_ACCHIGH - (t1 & 0xffffffff);
|
th = EV_ACCHIGH - (t1 & 0xffffffff);
|
tl = EV_ACCLOW - (t2 & 0xffffffff);
|
tl = EV_ACCLOW - (t2 & 0xffffffff);
|
ovh = (th >> 32);
|
ovh = (th >> 32);
|
ovl = (tl >> 32);
|
ovl = (tl >> 32);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, th),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, th),
|
EV_SATURATE(ovl, 0xffffffff, tl));
|
EV_SATURATE(ovl, 0xffffffff, tl));
|
//printf("evmwlusianw: ovl %d ovh %d al %d ah %d bl %d bh %d t1 %qd t2 %qd th %qd tl %qd\n", ovl, ovh, al, ah, al, bh, t1, t2, th, tl);
|
//printf("evmwlusianw: ovl %d ovh %d al %d ah %d bl %d bh %d t1 %qd t2 %qd th %qd tl %qd\n", ovl, ovh, al, ah, al, bh, t1, t2, th, tl);
|
//printf("evmwlusianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evmwlusianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1480:EVX:e500:evmwlumianw %RS,%RA,%RB:Vector Multiply Word Low Unsigned Modulo Integer and Accumulate Negative in Words
|
0.4,6.RS,11.RA,16.RB,21.1480:EVX:e500:evmwlumianw %RS,%RA,%RB:Vector Multiply Word Low Unsigned Modulo Integer and Accumulate Negative in Words
|
unsigned32 al, ah, bl, bh;
|
unsigned32 al, ah, bl, bh;
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
bl = *rB;
|
bl = *rB;
|
bh = *rBh;
|
bh = *rBh;
|
t1 = (unsigned64)ah * (unsigned64)bh;
|
t1 = (unsigned64)ah * (unsigned64)bh;
|
t2 = (unsigned64)al * (unsigned64)bl;
|
t2 = (unsigned64)al * (unsigned64)bl;
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff),
|
EV_ACCLOW - (t2 & 0xffffffff));
|
EV_ACCLOW - (t2 & 0xffffffff));
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1107:EVX:e500:evmwssf %RS,%RA,%RB:Vector Multiply Word Signed Saturate Fractional
|
0.4,6.RS,11.RA,16.RB,21.1107:EVX:e500:evmwssf %RS,%RA,%RB:Vector Multiply Word Signed Saturate Fractional
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t;
|
signed64 t;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t = ev_multiply32_ssf(a, b, &movl);
|
t = ev_multiply32_ssf(a, b, &movl);
|
EV_SET_REG1(*rSh, *rS, EV_SATURATE(movl, 0x7fffffffffffffff, t));
|
EV_SET_REG1(*rSh, *rS, EV_SATURATE(movl, 0x7fffffffffffffff, t));
|
EV_SET_SPEFSCR_OV(movl, 0);
|
EV_SET_SPEFSCR_OV(movl, 0);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1139:EVX:e500:evmwssfa %RS,%RA,%RB:Vector Multiply Word Signed Saturate Fractional and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1139:EVX:e500:evmwssfa %RS,%RA,%RB:Vector Multiply Word Signed Saturate Fractional and Accumulate
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t;
|
signed64 t;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t = ev_multiply32_ssf(a, b, &movl);
|
t = ev_multiply32_ssf(a, b, &movl);
|
EV_SET_REG1_ACC(*rSh, *rS, EV_SATURATE(movl, 0x7fffffffffffffff, t));
|
EV_SET_REG1_ACC(*rSh, *rS, EV_SATURATE(movl, 0x7fffffffffffffff, t));
|
EV_SET_SPEFSCR_OV(movl, 0);
|
EV_SET_SPEFSCR_OV(movl, 0);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1115:EVX:e500:evmwsmf %RS,%RA,%RB:Vector Multiply Word Signed Modulo Fractional
|
0.4,6.RS,11.RA,16.RB,21.1115:EVX:e500:evmwsmf %RS,%RA,%RB:Vector Multiply Word Signed Modulo Fractional
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t;
|
signed64 t;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t = ev_multiply32_smf(a, b, &movl);
|
t = ev_multiply32_smf(a, b, &movl);
|
EV_SET_REG1(*rSh, *rS, t);
|
EV_SET_REG1(*rSh, *rS, t);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1147:EVX:e500:evmwsmfa %RS,%RA,%RB:Vector Multiply Word Signed Modulo Fractional and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1147:EVX:e500:evmwsmfa %RS,%RA,%RB:Vector Multiply Word Signed Modulo Fractional and Accumulate
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t;
|
signed64 t;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t = ev_multiply32_smf(a, b, &movl);
|
t = ev_multiply32_smf(a, b, &movl);
|
EV_SET_REG1_ACC(*rSh, *rS, t);
|
EV_SET_REG1_ACC(*rSh, *rS, t);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1113:EVX:e500:evmwsmi %RS,%RA,%RB:Vector Multiply Word Signed Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1113:EVX:e500:evmwsmi %RS,%RA,%RB:Vector Multiply Word Signed Modulo Integer
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t;
|
signed64 t;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t = (signed64)a * (signed64)b;
|
t = (signed64)a * (signed64)b;
|
EV_SET_REG1(*rSh, *rS, t);
|
EV_SET_REG1(*rSh, *rS, t);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1145:EVX:e500:evmwsmia %RS,%RA,%RB:Vector Multiply Word Signed Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1145:EVX:e500:evmwsmia %RS,%RA,%RB:Vector Multiply Word Signed Modulo Integer and Accumulate
|
signed32 a, b;
|
signed32 a, b;
|
signed64 t;
|
signed64 t;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t = (signed64)a * (signed64)b;
|
t = (signed64)a * (signed64)b;
|
EV_SET_REG1_ACC(*rSh, *rS, t);
|
EV_SET_REG1_ACC(*rSh, *rS, t);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1112:EVX:e500:evmwumi %RS,%RA,%RB:Vector Multiply Word Unigned Modulo Integer
|
0.4,6.RS,11.RA,16.RB,21.1112:EVX:e500:evmwumi %RS,%RA,%RB:Vector Multiply Word Unigned Modulo Integer
|
unsigned32 a, b;
|
unsigned32 a, b;
|
unsigned64 t;
|
unsigned64 t;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t = (signed64)a * (signed64)b;
|
t = (signed64)a * (signed64)b;
|
EV_SET_REG1(*rSh, *rS, t);
|
EV_SET_REG1(*rSh, *rS, t);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1144:EVX:e500:evmwumia %RS,%RA,%RB:Vector Multiply Word Unigned Modulo Integer and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1144:EVX:e500:evmwumia %RS,%RA,%RB:Vector Multiply Word Unigned Modulo Integer and Accumulate
|
unsigned32 a, b;
|
unsigned32 a, b;
|
unsigned64 t;
|
unsigned64 t;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t = (signed64)a * (signed64)b;
|
t = (signed64)a * (signed64)b;
|
EV_SET_REG1_ACC(*rSh, *rS, t);
|
EV_SET_REG1_ACC(*rSh, *rS, t);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1363:EVX:e500:evmwssfaa %RS,%RA,%RB:Vector Multiply Word Signed Saturate Fractional Add and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1363:EVX:e500:evmwssfaa %RS,%RA,%RB:Vector Multiply Word Signed Saturate Fractional Add and Accumulate
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 a, b;
|
signed32 a, b;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t1 = ev_multiply32_ssf(a, b, &movl);
|
t1 = ev_multiply32_ssf(a, b, &movl);
|
t2 = ACC + EV_SATURATE(movl, 0x7fffffffffffffff, t1);
|
t2 = ACC + EV_SATURATE(movl, 0x7fffffffffffffff, t1);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_SPEFSCR_OV(movl, 0);
|
EV_SET_SPEFSCR_OV(movl, 0);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1371:EVX:e500:evmwsmfaa %RS,%RA,%RB:Vector Multiply Word Signed Modulo Fractional Add and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1371:EVX:e500:evmwsmfaa %RS,%RA,%RB:Vector Multiply Word Signed Modulo Fractional Add and Accumulate
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 a, b;
|
signed32 a, b;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t1 = ev_multiply32_smf(a, b, &movl);
|
t1 = ev_multiply32_smf(a, b, &movl);
|
t2 = ACC + t1;
|
t2 = ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1369:EVX:e500:evmwsmiaa %RS,%RA,%RB:Vector Multiply Word Signed Modulo Integer And and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1369:EVX:e500:evmwsmiaa %RS,%RA,%RB:Vector Multiply Word Signed Modulo Integer And and Accumulate
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 a, b;
|
signed32 a, b;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t1 = (signed64)a * (signed64)b;
|
t1 = (signed64)a * (signed64)b;
|
t2 = ACC + t1;
|
t2 = ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1368:EVX:e500:evmwumiaa %RS,%RA,%RB:Vector Multiply Word Unsigned Modulo Integer Add and Accumulate
|
0.4,6.RS,11.RA,16.RB,21.1368:EVX:e500:evmwumiaa %RS,%RA,%RB:Vector Multiply Word Unsigned Modulo Integer Add and Accumulate
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
unsigned32 a, b;
|
unsigned32 a, b;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t1 = (unsigned64)a * (unsigned64)b;
|
t1 = (unsigned64)a * (unsigned64)b;
|
t2 = ACC + t1;
|
t2 = ACC + t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1491:EVX:e500:evmwssfan %RS,%RA,%RB:Vector Multiply Word Signed Saturate Fractional and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1491:EVX:e500:evmwssfan %RS,%RA,%RB:Vector Multiply Word Signed Saturate Fractional and Accumulate Negative
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 a, b;
|
signed32 a, b;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t1 = ev_multiply32_ssf(a, b, &movl);
|
t1 = ev_multiply32_ssf(a, b, &movl);
|
t2 = ACC - EV_SATURATE(movl, 0x7fffffffffffffff, t1);
|
t2 = ACC - EV_SATURATE(movl, 0x7fffffffffffffff, t1);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_SPEFSCR_OV(movl, 0);
|
EV_SET_SPEFSCR_OV(movl, 0);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1499:EVX:e500:evmwsmfan %RS,%RA,%RB:Vector Multiply Word Signed Modulo Fractional and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1499:EVX:e500:evmwsmfan %RS,%RA,%RB:Vector Multiply Word Signed Modulo Fractional and Accumulate Negative
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 a, b;
|
signed32 a, b;
|
int movl;
|
int movl;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t1 = ev_multiply32_smf(a, b, &movl);
|
t1 = ev_multiply32_smf(a, b, &movl);
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1497:EVX:e500:evmwsmian %RS,%RA,%RB:Vector Multiply Word Signed Modulo Integer and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1497:EVX:e500:evmwsmian %RS,%RA,%RB:Vector Multiply Word Signed Modulo Integer and Accumulate Negative
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 a, b;
|
signed32 a, b;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t1 = (signed64)a * (signed64)b;
|
t1 = (signed64)a * (signed64)b;
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1496:EVX:e500:evmwumian %RS,%RA,%RB:Vector Multiply Word Unsigned Modulo Integer and Accumulate Negative
|
0.4,6.RS,11.RA,16.RB,21.1496:EVX:e500:evmwumian %RS,%RA,%RB:Vector Multiply Word Unsigned Modulo Integer and Accumulate Negative
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
unsigned32 a, b;
|
unsigned32 a, b;
|
a = *rA;
|
a = *rA;
|
b = *rB;
|
b = *rB;
|
t1 = (unsigned64)a * (unsigned64)b;
|
t1 = (unsigned64)a * (unsigned64)b;
|
t2 = ACC - t1;
|
t2 = ACC - t1;
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
EV_SET_REG1_ACC(*rSh, *rS, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.0,21.1217:EVX:e500:evaddssiaaw %RS,%RA:Vector Add Signed Saturate Integer to Accumulator Word
|
0.4,6.RS,11.RA,16.0,21.1217:EVX:e500:evaddssiaaw %RS,%RA:Vector Add Signed Saturate Integer to Accumulator Word
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 al, ah;
|
signed32 al, ah;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
t1 = (signed64)EV_ACCHIGH + (signed64)ah;
|
t1 = (signed64)EV_ACCHIGH + (signed64)ah;
|
t2 = (signed64)EV_ACCLOW + (signed64)al;
|
t2 = (signed64)EV_ACCLOW + (signed64)al;
|
ovh = EV_SAT_P_S32(t1);
|
ovh = EV_SAT_P_S32(t1);
|
ovl = EV_SAT_P_S32(t2);
|
ovl = EV_SAT_P_S32(t2);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, t1 & ((unsigned64)1 << 32), 0x80000000, 0x7fffffff, t1),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, t1 & ((unsigned64)1 << 32), 0x80000000, 0x7fffffff, t1),
|
EV_SATURATE_ACC(ovl, t2 & ((unsigned64)1 << 32), 0x80000000, 0x7fffffff, t2));
|
EV_SATURATE_ACC(ovl, t2 & ((unsigned64)1 << 32), 0x80000000, 0x7fffffff, t2));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.0,21.1225:EVX:e500:evaddsmiaaw %RS,%RA:Vector Add Signed Modulo Integer to Accumulator Word
|
0.4,6.RS,11.RA,16.0,21.1225:EVX:e500:evaddsmiaaw %RS,%RA:Vector Add Signed Modulo Integer to Accumulator Word
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 al, ah;
|
signed32 al, ah;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
t1 = (signed64)EV_ACCHIGH + (signed64)ah;
|
t1 = (signed64)EV_ACCHIGH + (signed64)ah;
|
t2 = (signed64)EV_ACCLOW + (signed64)al;
|
t2 = (signed64)EV_ACCLOW + (signed64)al;
|
EV_SET_REG2_ACC(*rSh, *rS, t1, t2);
|
EV_SET_REG2_ACC(*rSh, *rS, t1, t2);
|
//printf("evaddsmiaaw: al %d ah %d t1 %qd t2 %qd\n", al, ah, t1, t2);
|
//printf("evaddsmiaaw: al %d ah %d t1 %qd t2 %qd\n", al, ah, t1, t2);
|
//printf("evaddsmiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evaddsmiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.1216:EVX:e500:evaddusiaaw %RS,%RA:Vector Add Unsigned Saturate Integer to Accumulator Word
|
0.4,6.RS,11.RA,16.0,21.1216:EVX:e500:evaddusiaaw %RS,%RA:Vector Add Unsigned Saturate Integer to Accumulator Word
|
signed64 t1, t2;
|
signed64 t1, t2;
|
unsigned32 al, ah;
|
unsigned32 al, ah;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
t1 = (signed64)EV_ACCHIGH + (signed64)ah;
|
t1 = (signed64)EV_ACCHIGH + (signed64)ah;
|
t2 = (signed64)EV_ACCLOW + (signed64)al;
|
t2 = (signed64)EV_ACCLOW + (signed64)al;
|
ovh = EV_SAT_P_U32(t1);
|
ovh = EV_SAT_P_U32(t1);
|
ovl = EV_SAT_P_U32(t2);
|
ovl = EV_SAT_P_U32(t2);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, t1),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, t1),
|
EV_SATURATE(ovl, 0xffffffff, t2));
|
EV_SATURATE(ovl, 0xffffffff, t2));
|
//printf("evaddusiaaw: ovl %d ovh %d al %d ah %d t1 %qd t2 %qd\n", ovl, ovh, al, ah, t1, t2);
|
//printf("evaddusiaaw: ovl %d ovh %d al %d ah %d t1 %qd t2 %qd\n", ovl, ovh, al, ah, t1, t2);
|
//printf("evaddusiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
//printf("evaddusiaaw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.0,21.1224:EVX:e500:evaddumiaaw %RS,%RA:Vector Add Unsigned Modulo Integer to Accumulator Word
|
0.4,6.RS,11.RA,16.0,21.1224:EVX:e500:evaddumiaaw %RS,%RA:Vector Add Unsigned Modulo Integer to Accumulator Word
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
unsigned32 al, ah;
|
unsigned32 al, ah;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
t1 = (unsigned64)EV_ACCHIGH + (unsigned64)ah;
|
t1 = (unsigned64)EV_ACCHIGH + (unsigned64)ah;
|
t2 = EV_ACCLOW + al;
|
t2 = EV_ACCLOW + al;
|
EV_SET_REG2_ACC(*rSh, *rS, t1, t2);
|
EV_SET_REG2_ACC(*rSh, *rS, t1, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.0,21.1219:EVX:e500:evsubfssiaaw %RS,%RA:Vector Subtract Signed Saturate Integer to Accumulator Word
|
0.4,6.RS,11.RA,16.0,21.1219:EVX:e500:evsubfssiaaw %RS,%RA:Vector Subtract Signed Saturate Integer to Accumulator Word
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 al, ah;
|
signed32 al, ah;
|
int ovl, ovh;
|
int ovl, ovh;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
t1 = (signed64)EV_ACCHIGH - (signed64)ah;
|
t1 = (signed64)EV_ACCHIGH - (signed64)ah;
|
t2 = (signed64)EV_ACCLOW - (signed64)al;
|
t2 = (signed64)EV_ACCLOW - (signed64)al;
|
ovh = EV_SAT_P_S32(t1);
|
ovh = EV_SAT_P_S32(t1);
|
ovl = EV_SAT_P_S32(t2);
|
ovl = EV_SAT_P_S32(t2);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, t1, 0x80000000, 0x7fffffff, t1),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, t1, 0x80000000, 0x7fffffff, t1),
|
EV_SATURATE_ACC(ovl, t2, 0x80000000, 0x7fffffff, t2));
|
EV_SATURATE_ACC(ovl, t2, 0x80000000, 0x7fffffff, t2));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.0,21.1227:EVX:e500:evsubfsmiaaw %RS,%RA:Vector Subtract Signed Modulo Integer to Accumulator Word
|
0.4,6.RS,11.RA,16.0,21.1227:EVX:e500:evsubfsmiaaw %RS,%RA:Vector Subtract Signed Modulo Integer to Accumulator Word
|
signed64 t1, t2;
|
signed64 t1, t2;
|
signed32 al, ah;
|
signed32 al, ah;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
t1 = (signed64)EV_ACCHIGH - (signed64)ah;
|
t1 = (signed64)EV_ACCHIGH - (signed64)ah;
|
t2 = (signed64)EV_ACCLOW - (signed64)al;
|
t2 = (signed64)EV_ACCLOW - (signed64)al;
|
EV_SET_REG2_ACC(*rSh, *rS, t1, t2);
|
EV_SET_REG2_ACC(*rSh, *rS, t1, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.1218:EVX:e500:evsubfusiaaw %RS,%RA:Vector Subtract Unsigned Saturate Integer to Accumulator Word
|
0.4,6.RS,11.RA,16.0,21.1218:EVX:e500:evsubfusiaaw %RS,%RA:Vector Subtract Unsigned Saturate Integer to Accumulator Word
|
signed64 t1, t2;
|
signed64 t1, t2;
|
unsigned32 al, ah;
|
unsigned32 al, ah;
|
int ovl, ovh;
|
int ovl, ovh;
|
|
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
t1 = (signed64)EV_ACCHIGH - (signed64)ah;
|
t1 = (signed64)EV_ACCHIGH - (signed64)ah;
|
t2 = (signed64)EV_ACCLOW - (signed64)al;
|
t2 = (signed64)EV_ACCLOW - (signed64)al;
|
ovh = EV_SAT_P_U32(t1);
|
ovh = EV_SAT_P_U32(t1);
|
ovl = EV_SAT_P_U32(t2);
|
ovl = EV_SAT_P_U32(t2);
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0, t1),
|
EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0, t1),
|
EV_SATURATE(ovl, 0, t2));
|
EV_SATURATE(ovl, 0, t2));
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.0,21.1226:EVX:e500:evsubfumiaaw %RS,%RA:Vector Subtract Unsigned Modulo Integer to Accumulator Word
|
0.4,6.RS,11.RA,16.0,21.1226:EVX:e500:evsubfumiaaw %RS,%RA:Vector Subtract Unsigned Modulo Integer to Accumulator Word
|
unsigned64 t1, t2;
|
unsigned64 t1, t2;
|
unsigned32 al, ah;
|
unsigned32 al, ah;
|
al = *rA;
|
al = *rA;
|
ah = *rAh;
|
ah = *rAh;
|
t1 = (unsigned64)EV_ACCHIGH - (unsigned64)ah;
|
t1 = (unsigned64)EV_ACCHIGH - (unsigned64)ah;
|
t2 = (unsigned64)EV_ACCLOW - (unsigned64)al;
|
t2 = (unsigned64)EV_ACCLOW - (unsigned64)al;
|
EV_SET_REG2_ACC(*rSh, *rS, t1, t2);
|
EV_SET_REG2_ACC(*rSh, *rS, t1, t2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.0,21.1220:EVX:e500:evmra %RS,%RA:Initialize Accumulator
|
0.4,6.RS,11.RA,16.0,21.1220:EVX:e500:evmra %RS,%RA:Initialize Accumulator
|
EV_SET_REG2_ACC(*rSh, *rS, *rAh, *rA);
|
EV_SET_REG2_ACC(*rSh, *rS, *rAh, *rA);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.1222:EVX:e500:evdivws %RS,%RA,%RB:Vector Divide Word Signed
|
0.4,6.RS,11.RA,16.RB,21.1222:EVX:e500:evdivws %RS,%RA,%RB:Vector Divide Word Signed
|
signed32 dividendh, dividendl, divisorh, divisorl;
|
signed32 dividendh, dividendl, divisorh, divisorl;
|
signed32 w1, w2;
|
signed32 w1, w2;
|
int ovh, ovl;
|
int ovh, ovl;
|
dividendh = *rAh;
|
dividendh = *rAh;
|
dividendl = *rA;
|
dividendl = *rA;
|
divisorh = *rBh;
|
divisorh = *rBh;
|
divisorl = *rB;
|
divisorl = *rB;
|
if (dividendh < 0 && divisorh == 0) {
|
if (dividendh < 0 && divisorh == 0) {
|
w1 = 0x80000000;
|
w1 = 0x80000000;
|
ovh = 1;
|
ovh = 1;
|
} else if (dividendh > 0 && divisorh == 0) {
|
} else if (dividendh > 0 && divisorh == 0) {
|
w1 = 0x7fffffff;
|
w1 = 0x7fffffff;
|
ovh = 1;
|
ovh = 1;
|
} else if (dividendh == 0x80000000 && divisorh == -1) {
|
} else if (dividendh == 0x80000000 && divisorh == -1) {
|
w1 = 0x7fffffff;
|
w1 = 0x7fffffff;
|
ovh = 1;
|
ovh = 1;
|
} else {
|
} else {
|
w1 = dividendh / divisorh;
|
w1 = dividendh / divisorh;
|
ovh = 0;
|
ovh = 0;
|
}
|
}
|
if (dividendl < 0 && divisorl == 0) {
|
if (dividendl < 0 && divisorl == 0) {
|
w2 = 0x80000000;
|
w2 = 0x80000000;
|
ovl = 1;
|
ovl = 1;
|
} else if (dividendl > 0 && divisorl == 0) {
|
} else if (dividendl > 0 && divisorl == 0) {
|
w2 = 0x7fffffff;
|
w2 = 0x7fffffff;
|
ovl = 1;
|
ovl = 1;
|
} else if (dividendl == 0x80000000 && divisorl == -1) {
|
} else if (dividendl == 0x80000000 && divisorl == -1) {
|
w2 = 0x7fffffff;
|
w2 = 0x7fffffff;
|
ovl = 1;
|
ovl = 1;
|
} else {
|
} else {
|
w2 = dividendl / divisorl;
|
w2 = dividendl / divisorl;
|
ovl = 0;
|
ovl = 0;
|
}
|
}
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
|
|
|
|
0.4,6.RS,11.RA,16.RB,21.1223:EVX:e500:evdivwu %RS,%RA,%RB:Vector Divide Word Unsigned
|
0.4,6.RS,11.RA,16.RB,21.1223:EVX:e500:evdivwu %RS,%RA,%RB:Vector Divide Word Unsigned
|
unsigned32 dividendh, dividendl, divisorh, divisorl;
|
unsigned32 dividendh, dividendl, divisorh, divisorl;
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
int ovh, ovl;
|
int ovh, ovl;
|
dividendh = *rAh;
|
dividendh = *rAh;
|
dividendl = *rA;
|
dividendl = *rA;
|
divisorh = *rBh;
|
divisorh = *rBh;
|
divisorl = *rB;
|
divisorl = *rB;
|
if (divisorh == 0) {
|
if (divisorh == 0) {
|
w1 = 0xffffffff;
|
w1 = 0xffffffff;
|
ovh = 1;
|
ovh = 1;
|
} else {
|
} else {
|
w1 = dividendh / divisorh;
|
w1 = dividendh / divisorh;
|
ovh = 0;
|
ovh = 0;
|
}
|
}
|
if (divisorl == 0) {
|
if (divisorl == 0) {
|
w2 = 0xffffffff;
|
w2 = 0xffffffff;
|
ovl = 1;
|
ovl = 1;
|
} else {
|
} else {
|
w2 = dividendl / divisorl;
|
w2 = dividendl / divisorl;
|
ovl = 0;
|
ovl = 0;
|
}
|
}
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
EV_SET_SPEFSCR_OV(ovl, ovh);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr);
|
|
|
|
|
#
|
#
|
# A.2.9 Floating Point SPE Instructions
|
# A.2.9 Floating Point SPE Instructions
|
#
|
#
|
|
|
0.4,6.RS,11.RA,16.0,21.644:EVX:e500:evfsabs %RS,%RA:Vector Floating-Point Absolute Value
|
0.4,6.RS,11.RA,16.0,21.644:EVX:e500:evfsabs %RS,%RA:Vector Floating-Point Absolute Value
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rAh & 0x7fffffff;
|
w1 = *rAh & 0x7fffffff;
|
w2 = *rA & 0x7fffffff;
|
w2 = *rA & 0x7fffffff;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.645:EVX:e500:evfsnabs %RS,%RA:Vector Floating-Point Negative Absolute Value
|
0.4,6.RS,11.RA,16.0,21.645:EVX:e500:evfsnabs %RS,%RA:Vector Floating-Point Negative Absolute Value
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rAh | 0x80000000;
|
w1 = *rAh | 0x80000000;
|
w2 = *rA | 0x80000000;
|
w2 = *rA | 0x80000000;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.646:EVX:e500:evfsneg %RS,%RA:Vector Floating-Point Negate
|
0.4,6.RS,11.RA,16.0,21.646:EVX:e500:evfsneg %RS,%RA:Vector Floating-Point Negate
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rAh;
|
w1 = *rAh;
|
w2 = *rA;
|
w2 = *rA;
|
w1 = (w1 & 0x7fffffff) | ((~w1) & 0x80000000);
|
w1 = (w1 & 0x7fffffff) | ((~w1) & 0x80000000);
|
w2 = (w2 & 0x7fffffff) | ((~w2) & 0x80000000);
|
w2 = (w2 & 0x7fffffff) | ((~w2) & 0x80000000);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.640:EVX:e500:evfsadd %RS,%RA,%RB:Vector Floating-Point Add
|
0.4,6.RS,11.RA,16.RB,21.640:EVX:e500:evfsadd %RS,%RA,%RB:Vector Floating-Point Add
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = ev_fs_add (*rAh, *rBh, spefscr_finvh, spefscr_fovfh, spefscr_funfh, spefscr_fgh, spefscr_fxh, processor);
|
w1 = ev_fs_add (*rAh, *rBh, spefscr_finvh, spefscr_fovfh, spefscr_funfh, spefscr_fgh, spefscr_fxh, processor);
|
w2 = ev_fs_add (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
w2 = ev_fs_add (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.641:EVX:e500:evfssub %RS,%RA,%RB:Vector Floating-Point Subtract
|
0.4,6.RS,11.RA,16.RB,21.641:EVX:e500:evfssub %RS,%RA,%RB:Vector Floating-Point Subtract
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = ev_fs_sub (*rAh, *rBh, spefscr_finvh, spefscr_fovfh, spefscr_funfh, spefscr_fgh, spefscr_fxh, processor);
|
w1 = ev_fs_sub (*rAh, *rBh, spefscr_finvh, spefscr_fovfh, spefscr_funfh, spefscr_fgh, spefscr_fxh, processor);
|
w2 = ev_fs_sub (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
w2 = ev_fs_sub (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.648:EVX:e500:evfsmul %RS,%RA,%RB:Vector Floating-Point Multiply
|
0.4,6.RS,11.RA,16.RB,21.648:EVX:e500:evfsmul %RS,%RA,%RB:Vector Floating-Point Multiply
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = ev_fs_mul (*rAh, *rBh, spefscr_finvh, spefscr_fovfh, spefscr_funfh, spefscr_fgh, spefscr_fxh, processor);
|
w1 = ev_fs_mul (*rAh, *rBh, spefscr_finvh, spefscr_fovfh, spefscr_funfh, spefscr_fgh, spefscr_fxh, processor);
|
w2 = ev_fs_mul (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
w2 = ev_fs_mul (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.649:EVX:e500:evfsdiv %RS,%RA,%RB:Vector Floating-Point Divide
|
0.4,6.RS,11.RA,16.RB,21.649:EVX:e500:evfsdiv %RS,%RA,%RB:Vector Floating-Point Divide
|
signed32 w1, w2;
|
signed32 w1, w2;
|
w1 = ev_fs_div (*rAh, *rBh, spefscr_finvh, spefscr_fovfh, spefscr_funfh, spefscr_fdbzh, spefscr_fgh, spefscr_fxh, processor);
|
w1 = ev_fs_div (*rAh, *rBh, spefscr_finvh, spefscr_fovfh, spefscr_funfh, spefscr_fdbzh, spefscr_fgh, spefscr_fxh, processor);
|
w2 = ev_fs_div (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fdbz, spefscr_fg, spefscr_fx, processor);
|
w2 = ev_fs_div (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fdbz, spefscr_fg, spefscr_fx, processor);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.652:EVX:e500:evfscmpgt %BF,%RA,%RB:Vector Floating-Point Compare Greater Than
|
0.4,6.BF,9./,11.RA,16.RB,21.652:EVX:e500:evfscmpgt %BF,%RA,%RB:Vector Floating-Point Compare Greater Than
|
sim_fpu al, ah, bl, bh;
|
sim_fpu al, ah, bl, bh;
|
int w, ch, cl;
|
int w, ch, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bh, *rBh);
|
sim_fpu_32to (&bh, *rBh);
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh))
|
if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh))
|
EV_SET_SPEFSCR_BITS(spefscr_finvh);
|
EV_SET_SPEFSCR_BITS(spefscr_finvh);
|
if (sim_fpu_is_gt(&ah, &bh))
|
if (sim_fpu_is_gt(&ah, &bh))
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (sim_fpu_is_gt(&al, &bl))
|
if (sim_fpu_is_gt(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.653:EVX:e500:evfscmplt %BF,%RA,%RB:Vector Floating-Point Compare Less Than
|
0.4,6.BF,9./,11.RA,16.RB,21.653:EVX:e500:evfscmplt %BF,%RA,%RB:Vector Floating-Point Compare Less Than
|
sim_fpu al, ah, bl, bh;
|
sim_fpu al, ah, bl, bh;
|
int w, ch, cl;
|
int w, ch, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bh, *rBh);
|
sim_fpu_32to (&bh, *rBh);
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh))
|
if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh))
|
EV_SET_SPEFSCR_BITS(spefscr_finvh);
|
EV_SET_SPEFSCR_BITS(spefscr_finvh);
|
if (sim_fpu_is_lt(&ah, &bh))
|
if (sim_fpu_is_lt(&ah, &bh))
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (sim_fpu_is_lt(&al, &bl))
|
if (sim_fpu_is_lt(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.654:EVX:e500:evfscmpeq %BF,%RA,%RB:Vector Floating-Point Compare Equal
|
0.4,6.BF,9./,11.RA,16.RB,21.654:EVX:e500:evfscmpeq %BF,%RA,%RB:Vector Floating-Point Compare Equal
|
sim_fpu al, ah, bl, bh;
|
sim_fpu al, ah, bl, bh;
|
int w, ch, cl;
|
int w, ch, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bh, *rBh);
|
sim_fpu_32to (&bh, *rBh);
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh))
|
if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh))
|
EV_SET_SPEFSCR_BITS(spefscr_finvh);
|
EV_SET_SPEFSCR_BITS(spefscr_finvh);
|
if (sim_fpu_is_eq(&ah, &bh))
|
if (sim_fpu_is_eq(&ah, &bh))
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (sim_fpu_is_eq(&al, &bl))
|
if (sim_fpu_is_eq(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.668:EVX:e500:evfststgt %BF,%RA,%RB:Vector Floating-Point Test Greater Than
|
0.4,6.BF,9./,11.RA,16.RB,21.668:EVX:e500:evfststgt %BF,%RA,%RB:Vector Floating-Point Test Greater Than
|
sim_fpu al, ah, bl, bh;
|
sim_fpu al, ah, bl, bh;
|
int w, ch, cl;
|
int w, ch, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bh, *rBh);
|
sim_fpu_32to (&bh, *rBh);
|
if (sim_fpu_is_gt(&ah, &bh))
|
if (sim_fpu_is_gt(&ah, &bh))
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (sim_fpu_is_gt(&al, &bl))
|
if (sim_fpu_is_gt(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.669:EVX:e500:evfststlt %BF,%RA,%RB:Vector Floating-Point Test Less Than
|
0.4,6.BF,9./,11.RA,16.RB,21.669:EVX:e500:evfststlt %BF,%RA,%RB:Vector Floating-Point Test Less Than
|
sim_fpu al, ah, bl, bh;
|
sim_fpu al, ah, bl, bh;
|
int w, ch, cl;
|
int w, ch, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bh, *rBh);
|
sim_fpu_32to (&bh, *rBh);
|
if (sim_fpu_is_lt(&ah, &bh))
|
if (sim_fpu_is_lt(&ah, &bh))
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (sim_fpu_is_lt(&al, &bl))
|
if (sim_fpu_is_lt(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.670:EVX:e500:evfststeq %BF,%RA,%RB:Vector Floating-Point Test Equal
|
0.4,6.BF,9./,11.RA,16.RB,21.670:EVX:e500:evfststeq %BF,%RA,%RB:Vector Floating-Point Test Equal
|
sim_fpu al, ah, bl, bh;
|
sim_fpu al, ah, bl, bh;
|
int w, ch, cl;
|
int w, ch, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&ah, *rAh);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bh, *rBh);
|
sim_fpu_32to (&bh, *rBh);
|
if (sim_fpu_is_eq(&ah, &bh))
|
if (sim_fpu_is_eq(&ah, &bh))
|
ch = 1;
|
ch = 1;
|
else
|
else
|
ch = 0;
|
ch = 0;
|
if (sim_fpu_is_eq(&al, &bl))
|
if (sim_fpu_is_eq(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl);
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.RS,11.0,16.RB,21.656:EVX:e500:evfscfui %RS,%RB:Vector Convert Floating-Point from Unsigned Integer
|
0.4,6.RS,11.0,16.RB,21.656:EVX:e500:evfscfui %RS,%RB:Vector Convert Floating-Point from Unsigned Integer
|
unsigned32 f, w1, w2;
|
unsigned32 f, w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
|
|
sim_fpu_u32to (&b, *rBh, sim_fpu_round_default);
|
sim_fpu_u32to (&b, *rBh, sim_fpu_round_default);
|
sim_fpu_to32 (&w1, &b);
|
sim_fpu_to32 (&w1, &b);
|
sim_fpu_u32to (&b, *rB, sim_fpu_round_default);
|
sim_fpu_u32to (&b, *rB, sim_fpu_round_default);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.664:EVX:e500:evfsctuiz %RS,%RB:Vector Convert Floating-Point to Unsigned Integer with Round toward Zero
|
0.4,6.RS,11.0,16.RB,21.664:EVX:e500:evfsctuiz %RS,%RB:Vector Convert Floating-Point to Unsigned Integer with Round toward Zero
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
|
|
sim_fpu_32to (&b, *rBh);
|
sim_fpu_32to (&b, *rBh);
|
sim_fpu_to32u (&w1, &b, sim_fpu_round_zero);
|
sim_fpu_to32u (&w1, &b, sim_fpu_round_zero);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_zero);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_zero);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.657:EVX:e500:evfscfsi %RS,%RB:Vector Convert Floating-Point from Signed Integer
|
0.4,6.RS,11.0,16.RB,21.657:EVX:e500:evfscfsi %RS,%RB:Vector Convert Floating-Point from Signed Integer
|
signed32 w1, w2;
|
signed32 w1, w2;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
|
|
sim_fpu_i32to (&b, *rBh, sim_fpu_round_default);
|
sim_fpu_i32to (&b, *rBh, sim_fpu_round_default);
|
sim_fpu_to32 (&w1, &b);
|
sim_fpu_to32 (&w1, &b);
|
sim_fpu_i32to (&b, *rB, sim_fpu_round_default);
|
sim_fpu_i32to (&b, *rB, sim_fpu_round_default);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.658:EVX:e500:evfscfuf %RS,%RB:Vector Convert Floating-Point from Unsigned Fraction
|
0.4,6.RS,11.0,16.RB,21.658:EVX:e500:evfscfuf %RS,%RB:Vector Convert Floating-Point from Unsigned Fraction
|
unsigned32 w1, w2, bh, bl;
|
unsigned32 w1, w2, bh, bl;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
bh = *rBh;
|
bh = *rBh;
|
if (bh == 0xffffffff)
|
if (bh == 0xffffffff)
|
sim_fpu_to32 (&w1, &sim_fpu_one);
|
sim_fpu_to32 (&w1, &sim_fpu_one);
|
else {
|
else {
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u32to (&y, bh, sim_fpu_round_default);
|
sim_fpu_u32to (&y, bh, sim_fpu_round_default);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_to32 (&w1, &b);
|
sim_fpu_to32 (&w1, &b);
|
}
|
}
|
bl = *rB;
|
bl = *rB;
|
if (bl == 0xffffffff)
|
if (bl == 0xffffffff)
|
sim_fpu_to32 (&w2, &sim_fpu_one);
|
sim_fpu_to32 (&w2, &sim_fpu_one);
|
else {
|
else {
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u32to (&y, bl, sim_fpu_round_default);
|
sim_fpu_u32to (&y, bl, sim_fpu_round_default);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
}
|
}
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.659:EVX:e500:evfscfsf %RS,%RB:Vector Convert Floating-Point from Signed Fraction
|
0.4,6.RS,11.0,16.RB,21.659:EVX:e500:evfscfsf %RS,%RB:Vector Convert Floating-Point from Signed Fraction
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
|
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_i32to (&y, *rBh, sim_fpu_round_default);
|
sim_fpu_i32to (&y, *rBh, sim_fpu_round_default);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_to32 (&w1, &b);
|
sim_fpu_to32 (&w1, &b);
|
|
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_i32to (&y, *rB, sim_fpu_round_default);
|
sim_fpu_i32to (&y, *rB, sim_fpu_round_default);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.660:EVX:e500:evfsctui %RS,%RB:Vector Convert Floating-Point to Unsigned Integer
|
0.4,6.RS,11.0,16.RB,21.660:EVX:e500:evfsctui %RS,%RB:Vector Convert Floating-Point to Unsigned Integer
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
|
|
sim_fpu_32to (&b, *rBh);
|
sim_fpu_32to (&b, *rBh);
|
sim_fpu_to32u (&w1, &b, sim_fpu_round_default);
|
sim_fpu_to32u (&w1, &b, sim_fpu_round_default);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_default);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_default);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.661:EVX:e500:evfsctsi %RS,%RB:Vector Convert Floating-Point to Signed Integer
|
0.4,6.RS,11.0,16.RB,21.661:EVX:e500:evfsctsi %RS,%RB:Vector Convert Floating-Point to Signed Integer
|
signed32 w1, w2;
|
signed32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
|
|
sim_fpu_32to (&b, *rBh);
|
sim_fpu_32to (&b, *rBh);
|
sim_fpu_to32i (&w1, &b, sim_fpu_round_default);
|
sim_fpu_to32i (&w1, &b, sim_fpu_round_default);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_default);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_default);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.666:EVX:e500:evfsctsiz %RS,%RB:Vector Convert Floating-Point to Signed Integer with Round toward Zero
|
0.4,6.RS,11.0,16.RB,21.666:EVX:e500:evfsctsiz %RS,%RB:Vector Convert Floating-Point to Signed Integer with Round toward Zero
|
signed32 w1, w2;
|
signed32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
|
|
sim_fpu_32to (&b, *rBh);
|
sim_fpu_32to (&b, *rBh);
|
sim_fpu_to32i (&w1, &b, sim_fpu_round_zero);
|
sim_fpu_to32i (&w1, &b, sim_fpu_round_zero);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_zero);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_zero);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.662:EVX:e500:evfsctuf %RS,%RB:Vector Convert Floating-Point to Unsigned Fraction
|
0.4,6.RS,11.0,16.RB,21.662:EVX:e500:evfsctuf %RS,%RB:Vector Convert Floating-Point to Unsigned Fraction
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
|
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_32to (&y, *rBh);
|
sim_fpu_32to (&y, *rBh);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_to32u (&w1, &b, sim_fpu_round_default);
|
sim_fpu_to32u (&w1, &b, sim_fpu_round_default);
|
|
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_32to (&y, *rB);
|
sim_fpu_32to (&y, *rB);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_default);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_default);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.663:EVX:e500:evfsctsf %RS,%RB:Vector Convert Floating-Point to Signed Fraction
|
0.4,6.RS,11.0,16.RB,21.663:EVX:e500:evfsctsf %RS,%RB:Vector Convert Floating-Point to Signed Fraction
|
signed32 w1, w2;
|
signed32 w1, w2;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
|
|
sim_fpu_32to (&y, *rBh);
|
sim_fpu_32to (&y, *rBh);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_to32i (&w1, &b, sim_fpu_round_near);
|
sim_fpu_to32i (&w1, &b, sim_fpu_round_near);
|
|
|
sim_fpu_32to (&y, *rB);
|
sim_fpu_32to (&y, *rB);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_near);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_near);
|
|
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.0,21.708:EVX:e500:efsabs %RS,%RA:Floating-Point Absolute Value
|
0.4,6.RS,11.RA,16.0,21.708:EVX:e500:efsabs %RS,%RA:Floating-Point Absolute Value
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rSh;
|
w1 = *rSh;
|
w2 = *rA & 0x7fffffff;
|
w2 = *rA & 0x7fffffff;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.709:EVX:e500:efsnabs %RS,%RA:Floating-Point Negative Absolute Value
|
0.4,6.RS,11.RA,16.0,21.709:EVX:e500:efsnabs %RS,%RA:Floating-Point Negative Absolute Value
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rSh;
|
w1 = *rSh;
|
w2 = *rA | 0x80000000;
|
w2 = *rA | 0x80000000;
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.0,21.710:EVX:e500:efsneg %RS,%RA:Floating-Point Negate
|
0.4,6.RS,11.RA,16.0,21.710:EVX:e500:efsneg %RS,%RA:Floating-Point Negate
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
w1 = *rSh;
|
w1 = *rSh;
|
w2 = (*rA & 0x7fffffff) | ((~*rA) & 0x80000000);
|
w2 = (*rA & 0x7fffffff) | ((~*rA) & 0x80000000);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.704:EVX:e500:efsadd %RS,%RA,%RB:Floating-Point Add
|
0.4,6.RS,11.RA,16.RB,21.704:EVX:e500:efsadd %RS,%RA,%RB:Floating-Point Add
|
unsigned32 w;
|
unsigned32 w;
|
w = ev_fs_add (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
w = ev_fs_add (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
EV_SET_REG(*rS, w);
|
EV_SET_REG(*rS, w);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.705:EVX:e500:efssub %RS,%RA,%RB:Floating-Point Subtract
|
0.4,6.RS,11.RA,16.RB,21.705:EVX:e500:efssub %RS,%RA,%RB:Floating-Point Subtract
|
unsigned32 w;
|
unsigned32 w;
|
w = ev_fs_sub (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
w = ev_fs_sub (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
EV_SET_REG(*rS, w);
|
EV_SET_REG(*rS, w);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.712:EVX:e500:efsmul %RS,%RA,%RB:Floating-Point Multiply
|
0.4,6.RS,11.RA,16.RB,21.712:EVX:e500:efsmul %RS,%RA,%RB:Floating-Point Multiply
|
unsigned32 w;
|
unsigned32 w;
|
w = ev_fs_mul (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
w = ev_fs_mul (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor);
|
EV_SET_REG(*rS, w);
|
EV_SET_REG(*rS, w);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.RS,11.RA,16.RB,21.713:EVX:e500:efsdiv %RS,%RA,%RB:Floating-Point Divide
|
0.4,6.RS,11.RA,16.RB,21.713:EVX:e500:efsdiv %RS,%RA,%RB:Floating-Point Divide
|
unsigned32 w;
|
unsigned32 w;
|
w = ev_fs_div (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fdbz, spefscr_fg, spefscr_fx, processor);
|
w = ev_fs_div (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fdbz, spefscr_fg, spefscr_fx, processor);
|
EV_SET_REG(*rS, w);
|
EV_SET_REG(*rS, w);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.716:EVX:e500:efscmpgt %BF,%RA,%RB:Floating-Point Compare Greater Than
|
0.4,6.BF,9./,11.RA,16.RB,21.716:EVX:e500:efscmpgt %BF,%RA,%RB:Floating-Point Compare Greater Than
|
sim_fpu a, b;
|
sim_fpu a, b;
|
int w, cl;
|
int w, cl;
|
sim_fpu_32to (&a, *rA);
|
sim_fpu_32to (&a, *rA);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b))
|
if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b))
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
if (sim_fpu_is_gt(&a, &b))
|
if (sim_fpu_is_gt(&a, &b))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = cl << 2 | cl << 1;
|
w = cl << 2 | cl << 1;
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.717:EVX:e500:efscmplt %BF,%RA,%RB:Floating-Point Compare Less Than
|
0.4,6.BF,9./,11.RA,16.RB,21.717:EVX:e500:efscmplt %BF,%RA,%RB:Floating-Point Compare Less Than
|
sim_fpu al, bl;
|
sim_fpu al, bl;
|
int w, cl;
|
int w, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
if (sim_fpu_is_lt(&al, &bl))
|
if (sim_fpu_is_lt(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = cl << 2 | cl << 1;
|
w = cl << 2 | cl << 1;
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.718:EVX:e500:efscmpeq %BF,%RA,%RB:Floating-Point Compare Equal
|
0.4,6.BF,9./,11.RA,16.RB,21.718:EVX:e500:efscmpeq %BF,%RA,%RB:Floating-Point Compare Equal
|
sim_fpu al, bl;
|
sim_fpu al, bl;
|
int w, cl;
|
int w, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl))
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
EV_SET_SPEFSCR_BITS(spefscr_finv);
|
if (sim_fpu_is_eq(&al, &bl))
|
if (sim_fpu_is_eq(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = cl << 2 | cl << 1;
|
w = cl << 2 | cl << 1;
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
PPC_INSN_INT_SPR(0, RA_BITMASK | RB_BITMASK, spr_spefscr);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.732:EVX:e500:efststgt %BF,%RA,%RB:Floating-Point Test Greater Than
|
0.4,6.BF,9./,11.RA,16.RB,21.732:EVX:e500:efststgt %BF,%RA,%RB:Floating-Point Test Greater Than
|
sim_fpu al, bl;
|
sim_fpu al, bl;
|
int w, cl;
|
int w, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
if (sim_fpu_is_gt(&al, &bl))
|
if (sim_fpu_is_gt(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = cl << 2 | cl << 1;
|
w = cl << 2 | cl << 1;
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.733:EVX:e500:efststlt %BF,%RA,%RB:Floating-Point Test Less Than
|
0.4,6.BF,9./,11.RA,16.RB,21.733:EVX:e500:efststlt %BF,%RA,%RB:Floating-Point Test Less Than
|
sim_fpu al, bl;
|
sim_fpu al, bl;
|
int w, cl;
|
int w, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
if (sim_fpu_is_lt(&al, &bl))
|
if (sim_fpu_is_lt(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = cl << 2 | cl << 1;
|
w = cl << 2 | cl << 1;
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.BF,9./,11.RA,16.RB,21.734:EVX:e500:efststeq %BF,%RA,%RB:Floating-Point Test Equal
|
0.4,6.BF,9./,11.RA,16.RB,21.734:EVX:e500:efststeq %BF,%RA,%RB:Floating-Point Test Equal
|
sim_fpu al, bl;
|
sim_fpu al, bl;
|
int w, cl;
|
int w, cl;
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&al, *rA);
|
sim_fpu_32to (&bl, *rB);
|
sim_fpu_32to (&bl, *rB);
|
if (sim_fpu_is_eq(&al, &bl))
|
if (sim_fpu_is_eq(&al, &bl))
|
cl = 1;
|
cl = 1;
|
else
|
else
|
cl = 0;
|
cl = 0;
|
w = cl << 2 | cl << 1;
|
w = cl << 2 | cl << 1;
|
CR_SET(BF, w);
|
CR_SET(BF, w);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
PPC_INSN_INT_CR(0, RA_BITMASK | RB_BITMASK, BF_BITMASK);
|
|
|
0.4,6.RS,11.0,16.RB,21.721:EVX:e500:efscfsi %RS,%RB:Convert Floating-Point from Signed Integer
|
0.4,6.RS,11.0,16.RB,21.721:EVX:e500:efscfsi %RS,%RB:Convert Floating-Point from Signed Integer
|
signed32 f, w1, w2;
|
signed32 f, w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_i32to (&b, *rB, sim_fpu_round_default);
|
sim_fpu_i32to (&b, *rB, sim_fpu_round_default);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.720:EVX:e500:efscfui %RS,%RB:Convert Floating-Point from Unsigned Integer
|
0.4,6.RS,11.0,16.RB,21.720:EVX:e500:efscfui %RS,%RB:Convert Floating-Point from Unsigned Integer
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_u32to (&b, *rB, sim_fpu_round_default);
|
sim_fpu_u32to (&b, *rB, sim_fpu_round_default);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.723:EVX:e500:efscfsf %RS,%RB:Convert Floating-Point from Signed Fraction
|
0.4,6.RS,11.0,16.RB,21.723:EVX:e500:efscfsf %RS,%RB:Convert Floating-Point from Signed Fraction
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_i32to (&y, *rB, sim_fpu_round_default);
|
sim_fpu_i32to (&y, *rB, sim_fpu_round_default);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.722:EVX:e500:efscfuf %RS,%RB:Convert Floating-Point from Unsigned Fraction
|
0.4,6.RS,11.0,16.RB,21.722:EVX:e500:efscfuf %RS,%RB:Convert Floating-Point from Unsigned Fraction
|
unsigned32 w1, w2, bl;
|
unsigned32 w1, w2, bl;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
w1 = *rSh;
|
w1 = *rSh;
|
bl = *rB;
|
bl = *rB;
|
if (bl == 0xffffffff)
|
if (bl == 0xffffffff)
|
sim_fpu_to32 (&w2, &sim_fpu_one);
|
sim_fpu_to32 (&w2, &sim_fpu_one);
|
else {
|
else {
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u32to (&y, bl, sim_fpu_round_default);
|
sim_fpu_u32to (&y, bl, sim_fpu_round_default);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_div (&b, &y, &x);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
}
|
}
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.725:EVX:e500:efsctsi %RS,%RB:Convert Floating-Point to Signed Integer
|
0.4,6.RS,11.0,16.RB,21.725:EVX:e500:efsctsi %RS,%RB:Convert Floating-Point to Signed Integer
|
signed64 temp;
|
signed64 temp;
|
signed32 w1, w2;
|
signed32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_default);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_default);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.730:EVX:e500:efsctsiz %RS,%RB:Convert Floating-Point to Signed Integer with Round toward Zero
|
0.4,6.RS,11.0,16.RB,21.730:EVX:e500:efsctsiz %RS,%RB:Convert Floating-Point to Signed Integer with Round toward Zero
|
signed64 temp;
|
signed64 temp;
|
signed32 w1, w2;
|
signed32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_zero);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_zero);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.724:EVX:e500:efsctui %RS,%RB:Convert Floating-Point to Unsigned Integer
|
0.4,6.RS,11.0,16.RB,21.724:EVX:e500:efsctui %RS,%RB:Convert Floating-Point to Unsigned Integer
|
unsigned64 temp;
|
unsigned64 temp;
|
signed32 w1, w2;
|
signed32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_default);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_default);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.728:EVX:e500:efsctuiz %RS,%RB:Convert Floating-Point to Unsigned Integer with Round toward Zero
|
0.4,6.RS,11.0,16.RB,21.728:EVX:e500:efsctuiz %RS,%RB:Convert Floating-Point to Unsigned Integer with Round toward Zero
|
unsigned64 temp;
|
unsigned64 temp;
|
signed32 w1, w2;
|
signed32 w1, w2;
|
sim_fpu b;
|
sim_fpu b;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_32to (&b, *rB);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_zero);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_zero);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.727:EVX:e500:efsctsf %RS,%RB:Convert Floating-Point to Signed Fraction
|
0.4,6.RS,11.0,16.RB,21.727:EVX:e500:efsctsf %RS,%RB:Convert Floating-Point to Signed Fraction
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_32to (&y, *rB);
|
sim_fpu_32to (&y, *rB);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_default);
|
sim_fpu_to32i (&w2, &b, sim_fpu_round_default);
|
sim_fpu_to32 (&w2, &b);
|
sim_fpu_to32 (&w2, &b);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.0,16.RB,21.726:EVX:e500:efsctuf %RS,%RB:Convert Floating-Point to Unsigned Fraction
|
0.4,6.RS,11.0,16.RB,21.726:EVX:e500:efsctuf %RS,%RB:Convert Floating-Point to Unsigned Fraction
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
sim_fpu b, x, y;
|
sim_fpu b, x, y;
|
w1 = *rSh;
|
w1 = *rSh;
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default);
|
sim_fpu_32to (&y, *rB);
|
sim_fpu_32to (&y, *rB);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_mul (&b, &y, &x);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_default);
|
sim_fpu_to32u (&w2, &b, sim_fpu_round_default);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0);
|
|
|
|
|
#
|
#
|
# A.2.10 Vector Load/Store Instructions
|
# A.2.10 Vector Load/Store Instructions
|
#
|
#
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.769:EVX:e500:evldd %RS,%RA,%UIMM:Vector Load Double Word into Double Word
|
0.4,6.RS,11.RA,16.UIMM,21.769:EVX:e500:evldd %RS,%RA,%UIMM:Vector Load Double Word into Double Word
|
unsigned64 m;
|
unsigned64 m;
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
m = MEM(unsigned, EA, 8);
|
m = MEM(unsigned, EA, 8);
|
EV_SET_REG1(*rSh, *rS, m);
|
EV_SET_REG1(*rSh, *rS, m);
|
//printf("evldd(%d<-%d + %u): m %08x.%08x, *rSh %x *rS %x\n", RS, RA, UIMM, (int)(m >> 32), (int)m, *rSh, *rS);
|
//printf("evldd(%d<-%d + %u): m %08x.%08x, *rSh %x *rS %x\n", RS, RA, UIMM, (int)(m >> 32), (int)m, *rSh, *rS);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.768:EVX:e500:evlddx %RS,%RA,%RB:Vector Load Double Word into Double Word Indexed
|
0.4,6.RS,11.RA,16.RB,21.768:EVX:e500:evlddx %RS,%RA,%RB:Vector Load Double Word into Double Word Indexed
|
unsigned64 m;
|
unsigned64 m;
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
m = MEM(unsigned, EA, 8);
|
m = MEM(unsigned, EA, 8);
|
EV_SET_REG1(*rSh, *rS, m);
|
EV_SET_REG1(*rSh, *rS, m);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.771:EVX:e500:evldw %RS,%RA,%UIMM:Vector Load Double into Two Words
|
0.4,6.RS,11.RA,16.UIMM,21.771:EVX:e500:evldw %RS,%RA,%UIMM:Vector Load Double into Two Words
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
w1 = MEM(unsigned, EA, 4);
|
w1 = MEM(unsigned, EA, 4);
|
w2 = MEM(unsigned, EA + 4, 4);
|
w2 = MEM(unsigned, EA + 4, 4);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.770:EVX:e500:evldwx %RS,%RA,%RB:Vector Load Double into Two Words Indexed
|
0.4,6.RS,11.RA,16.RB,21.770:EVX:e500:evldwx %RS,%RA,%RB:Vector Load Double into Two Words Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
w1 = MEM(unsigned, EA, 4);
|
w1 = MEM(unsigned, EA, 4);
|
w2 = MEM(unsigned, EA + 4, 4);
|
w2 = MEM(unsigned, EA + 4, 4);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
EV_SET_REG2(*rSh, *rS, w1, w2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.773:EVX:e500:evldh %RS,%RA,%UIMM:Vector Load Double into 4 Half Words
|
0.4,6.RS,11.RA,16.UIMM,21.773:EVX:e500:evldh %RS,%RA,%UIMM:Vector Load Double into 4 Half Words
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
h1 = MEM(unsigned, EA, 2);
|
h1 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA + 2, 2);
|
h2 = MEM(unsigned, EA + 2, 2);
|
h3 = MEM(unsigned, EA + 4, 2);
|
h3 = MEM(unsigned, EA + 4, 2);
|
h4 = MEM(unsigned, EA + 6, 2);
|
h4 = MEM(unsigned, EA + 6, 2);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.772:EVX:e500:evldhx %RS,%RA,%RB:Vector Load Double into 4 Half Words Indexed
|
0.4,6.RS,11.RA,16.RB,21.772:EVX:e500:evldhx %RS,%RA,%RB:Vector Load Double into 4 Half Words Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h1 = MEM(unsigned, EA, 2);
|
h1 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA + 2, 2);
|
h2 = MEM(unsigned, EA + 2, 2);
|
h3 = MEM(unsigned, EA + 4, 2);
|
h3 = MEM(unsigned, EA + 4, 2);
|
h4 = MEM(unsigned, EA + 6, 2);
|
h4 = MEM(unsigned, EA + 6, 2);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.785:EVX:e500:evlwhe %RS,%RA,%UIMM:Vector Load Word into Two Half Words Even
|
0.4,6.RS,11.RA,16.UIMM,21.785:EVX:e500:evlwhe %RS,%RA,%UIMM:Vector Load Word into Two Half Words Even
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 2);
|
EA = b + (UIMM << 2);
|
h1 = MEM(unsigned, EA, 2);
|
h1 = MEM(unsigned, EA, 2);
|
h2 = 0;
|
h2 = 0;
|
h3 = MEM(unsigned, EA + 2, 2);
|
h3 = MEM(unsigned, EA + 2, 2);
|
h4 = 0;
|
h4 = 0;
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.784:EVX:e500:evlwhex %RS,%RA,%RB:Vector Load Word into Two Half Words Even Indexed
|
0.4,6.RS,11.RA,16.RB,21.784:EVX:e500:evlwhex %RS,%RA,%RB:Vector Load Word into Two Half Words Even Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h1 = MEM(unsigned, EA, 2);
|
h1 = MEM(unsigned, EA, 2);
|
h2 = 0;
|
h2 = 0;
|
h3 = MEM(unsigned, EA + 2, 2);
|
h3 = MEM(unsigned, EA + 2, 2);
|
h4 = 0;
|
h4 = 0;
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.789:EVX:e500:evlwhou %RS,%RA,%UIMM:Vector Load Word into Two Half Words Odd Unsigned zero-extended
|
0.4,6.RS,11.RA,16.UIMM,21.789:EVX:e500:evlwhou %RS,%RA,%UIMM:Vector Load Word into Two Half Words Odd Unsigned zero-extended
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 2);
|
EA = b + (UIMM << 2);
|
h1 = 0;
|
h1 = 0;
|
h2 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA, 2);
|
h3 = 0;
|
h3 = 0;
|
h4 = MEM(unsigned, EA + 2, 2);
|
h4 = MEM(unsigned, EA + 2, 2);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.788:EVX:e500:evlwhoux %RS,%RA,%RB:Vector Load Word into Two Half Words Odd Unsigned Indexed zero-extended
|
0.4,6.RS,11.RA,16.RB,21.788:EVX:e500:evlwhoux %RS,%RA,%RB:Vector Load Word into Two Half Words Odd Unsigned Indexed zero-extended
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h1 = 0;
|
h1 = 0;
|
h2 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA, 2);
|
h3 = 0;
|
h3 = 0;
|
h4 = MEM(unsigned, EA + 2, 2);
|
h4 = MEM(unsigned, EA + 2, 2);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.791:EVX:e500:evlwhos %RS,%RA,%UIMM:Vector Load Word into Half Words Odd Signed with sign extension
|
0.4,6.RS,11.RA,16.UIMM,21.791:EVX:e500:evlwhos %RS,%RA,%UIMM:Vector Load Word into Half Words Odd Signed with sign extension
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 2);
|
EA = b + (UIMM << 2);
|
h2 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA, 2);
|
if (h2 & 0x8000)
|
if (h2 & 0x8000)
|
h1 = 0xffff;
|
h1 = 0xffff;
|
else
|
else
|
h1 = 0;
|
h1 = 0;
|
h4 = MEM(unsigned, EA + 2, 2);
|
h4 = MEM(unsigned, EA + 2, 2);
|
if (h4 & 0x8000)
|
if (h4 & 0x8000)
|
h3 = 0xffff;
|
h3 = 0xffff;
|
else
|
else
|
h3 = 0;
|
h3 = 0;
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.790:EVX:e500:evlwhosx %RS,%RA,%RB:Vector Load Word into Half Words Odd Signed Indexed with sign extension
|
0.4,6.RS,11.RA,16.RB,21.790:EVX:e500:evlwhosx %RS,%RA,%RB:Vector Load Word into Half Words Odd Signed Indexed with sign extension
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h2 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA, 2);
|
if (h2 & 0x8000)
|
if (h2 & 0x8000)
|
h1 = 0xffff;
|
h1 = 0xffff;
|
else
|
else
|
h1 = 0;
|
h1 = 0;
|
h4 = MEM(unsigned, EA + 2, 2);
|
h4 = MEM(unsigned, EA + 2, 2);
|
if (h4 & 0x8000)
|
if (h4 & 0x8000)
|
h3 = 0xffff;
|
h3 = 0xffff;
|
else
|
else
|
h3 = 0;
|
h3 = 0;
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.793:EVX:e500:evlwwsplat %RS,%RA,%UIMM:Vector Load Word into Word and Splat
|
0.4,6.RS,11.RA,16.UIMM,21.793:EVX:e500:evlwwsplat %RS,%RA,%UIMM:Vector Load Word into Word and Splat
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w1;
|
unsigned32 w1;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 2);
|
EA = b + (UIMM << 2);
|
w1 = MEM(unsigned, EA, 4);
|
w1 = MEM(unsigned, EA, 4);
|
EV_SET_REG2(*rSh, *rS, w1, w1);
|
EV_SET_REG2(*rSh, *rS, w1, w1);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.792:EVX:e500:evlwwsplatx %RS,%RA,%RB:Vector Load Word into Word and Splat Indexed
|
0.4,6.RS,11.RA,16.RB,21.792:EVX:e500:evlwwsplatx %RS,%RA,%RB:Vector Load Word into Word and Splat Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w1;
|
unsigned32 w1;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
w1 = MEM(unsigned, EA, 4);
|
w1 = MEM(unsigned, EA, 4);
|
EV_SET_REG2(*rSh, *rS, w1, w1);
|
EV_SET_REG2(*rSh, *rS, w1, w1);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.797:EVX:e500:evlwhsplat %RS,%RA,%UIMM:Vector Load Word into 2 Half Words and Splat
|
0.4,6.RS,11.RA,16.UIMM,21.797:EVX:e500:evlwhsplat %RS,%RA,%UIMM:Vector Load Word into 2 Half Words and Splat
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2;
|
unsigned16 h1, h2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 2);
|
EA = b + (UIMM << 2);
|
h1 = MEM(unsigned, EA, 2);
|
h1 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA + 2, 2);
|
h2 = MEM(unsigned, EA + 2, 2);
|
EV_SET_REG4(*rSh, *rS, h1, h1, h2, h2);
|
EV_SET_REG4(*rSh, *rS, h1, h1, h2, h2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.796:EVX:e500:evlwhsplatx %RS,%RA,%RB:Vector Load Word into 2 Half Words and Splat Indexed
|
0.4,6.RS,11.RA,16.RB,21.796:EVX:e500:evlwhsplatx %RS,%RA,%RB:Vector Load Word into 2 Half Words and Splat Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2;
|
unsigned16 h1, h2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h1 = MEM(unsigned, EA, 2);
|
h1 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA + 2, 2);
|
h2 = MEM(unsigned, EA + 2, 2);
|
EV_SET_REG4(*rSh, *rS, h1, h1, h2, h2);
|
EV_SET_REG4(*rSh, *rS, h1, h1, h2, h2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.777:EVX:e500:evlhhesplat %RS,%RA,%UIMM:Vector Load Half Word into Half Words Even and Splat
|
0.4,6.RS,11.RA,16.UIMM,21.777:EVX:e500:evlhhesplat %RS,%RA,%UIMM:Vector Load Half Word into Half Words Even and Splat
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h;
|
unsigned16 h;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 1);
|
EA = b + (UIMM << 1);
|
h = MEM(unsigned, EA, 2);
|
h = MEM(unsigned, EA, 2);
|
EV_SET_REG4(*rSh, *rS, h, 0, h, 0);
|
EV_SET_REG4(*rSh, *rS, h, 0, h, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.776:EVX:e500:evlhhesplatx %RS,%RA,%RB:Vector Load Half Word into Half Words Even and Splat Indexed
|
0.4,6.RS,11.RA,16.RB,21.776:EVX:e500:evlhhesplatx %RS,%RA,%RB:Vector Load Half Word into Half Words Even and Splat Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h;
|
unsigned16 h;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h = MEM(unsigned, EA, 2);
|
h = MEM(unsigned, EA, 2);
|
EV_SET_REG4(*rSh, *rS, h, 0, h, 0);
|
EV_SET_REG4(*rSh, *rS, h, 0, h, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.781:EVX:e500:evlhhousplat %RS,%RA,%UIMM:Vector Load Half Word into Half Word Odd Unsigned and Splat
|
0.4,6.RS,11.RA,16.UIMM,21.781:EVX:e500:evlhhousplat %RS,%RA,%UIMM:Vector Load Half Word into Half Word Odd Unsigned and Splat
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h;
|
unsigned16 h;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 1);
|
EA = b + (UIMM << 1);
|
h = MEM(unsigned, EA, 2);
|
h = MEM(unsigned, EA, 2);
|
EV_SET_REG4(*rSh, *rS, 0, h, 0, h);
|
EV_SET_REG4(*rSh, *rS, 0, h, 0, h);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.780:EVX:e500:evlhhousplatx %RS,%RA,%RB:Vector Load Half Word into Half Word Odd Unsigned and Splat Indexed
|
0.4,6.RS,11.RA,16.RB,21.780:EVX:e500:evlhhousplatx %RS,%RA,%RB:Vector Load Half Word into Half Word Odd Unsigned and Splat Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h;
|
unsigned16 h;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h = MEM(unsigned, EA, 2);
|
h = MEM(unsigned, EA, 2);
|
EV_SET_REG4(*rSh, *rS, 0, h, 0, h);
|
EV_SET_REG4(*rSh, *rS, 0, h, 0, h);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.783:EVX:e500:evlhhossplat %RS,%RA,%UIMM:Vector Load Half Word into Half Word Odd Signed and Splat
|
0.4,6.RS,11.RA,16.UIMM,21.783:EVX:e500:evlhhossplat %RS,%RA,%UIMM:Vector Load Half Word into Half Word Odd Signed and Splat
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2;
|
unsigned16 h1, h2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 1);
|
EA = b + (UIMM << 1);
|
h2 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA, 2);
|
if (h2 & 0x8000)
|
if (h2 & 0x8000)
|
h1 = 0xffff;
|
h1 = 0xffff;
|
else
|
else
|
h1 = 0;
|
h1 = 0;
|
EV_SET_REG4(*rSh, *rS, h1, h2, h1, h2);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h1, h2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.782:EVX:e500:evlhhossplatx %RS,%RA,%RB:Vector Load Half Word into Half Word Odd Signed and Splat Indexed
|
0.4,6.RS,11.RA,16.RB,21.782:EVX:e500:evlhhossplatx %RS,%RA,%RB:Vector Load Half Word into Half Word Odd Signed and Splat Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2;
|
unsigned16 h1, h2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h2 = MEM(unsigned, EA, 2);
|
h2 = MEM(unsigned, EA, 2);
|
if (h2 & 0x8000)
|
if (h2 & 0x8000)
|
h1 = 0xffff;
|
h1 = 0xffff;
|
else
|
else
|
h1 = 0;
|
h1 = 0;
|
EV_SET_REG4(*rSh, *rS, h1, h2, h1, h2);
|
EV_SET_REG4(*rSh, *rS, h1, h2, h1, h2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.801:EVX:e500:evstdd %RS,%RA,%UIMM:Vector Store Double of Double
|
0.4,6.RS,11.RA,16.UIMM,21.801:EVX:e500:evstdd %RS,%RA,%UIMM:Vector Store Double of Double
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
STORE(EA, 4, (*rSh));
|
STORE(EA, 4, (*rSh));
|
STORE(EA + 4, 4, (*rS));
|
STORE(EA + 4, 4, (*rS));
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.800:EVX:e500:evstddx %RS,%RA,%RB:Vector Store Double of Double Indexed
|
0.4,6.RS,11.RA,16.RB,21.800:EVX:e500:evstddx %RS,%RA,%RB:Vector Store Double of Double Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
STORE(EA, 4, (*rSh));
|
STORE(EA, 4, (*rSh));
|
STORE(EA + 4, 4, (*rS));
|
STORE(EA + 4, 4, (*rS));
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.803:EVX:e500:evstdw %RS,%RA,%UIMM:Vector Store Double of Two Words
|
0.4,6.RS,11.RA,16.UIMM,21.803:EVX:e500:evstdw %RS,%RA,%UIMM:Vector Store Double of Two Words
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
w1 = *rSh;
|
w1 = *rSh;
|
w2 = *rS;
|
w2 = *rS;
|
STORE(EA + 0, 4, w1);
|
STORE(EA + 0, 4, w1);
|
STORE(EA + 4, 4, w2);
|
STORE(EA + 4, 4, w2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.802:EVX:e500:evstdwx %RS,%RA,%RB:Vector Store Double of Two Words Indexed
|
0.4,6.RS,11.RA,16.RB,21.802:EVX:e500:evstdwx %RS,%RA,%RB:Vector Store Double of Two Words Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w1, w2;
|
unsigned32 w1, w2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
w1 = *rSh;
|
w1 = *rSh;
|
w2 = *rS;
|
w2 = *rS;
|
STORE(EA + 0, 4, w1);
|
STORE(EA + 0, 4, w1);
|
STORE(EA + 4, 4, w2);
|
STORE(EA + 4, 4, w2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.805:EVX:e500:evstdh %RS,%RA,%UIMM:Vector Store Double of Four Half Words
|
0.4,6.RS,11.RA,16.UIMM,21.805:EVX:e500:evstdh %RS,%RA,%UIMM:Vector Store Double of Four Half Words
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
h1 = EV_HIHALF(*rSh);
|
h1 = EV_HIHALF(*rSh);
|
h2 = EV_LOHALF(*rSh);
|
h2 = EV_LOHALF(*rSh);
|
h3 = EV_HIHALF(*rS);
|
h3 = EV_HIHALF(*rS);
|
h4 = EV_LOHALF(*rS);
|
h4 = EV_LOHALF(*rS);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 2, 2, h2);
|
STORE(EA + 2, 2, h2);
|
STORE(EA + 4, 2, h3);
|
STORE(EA + 4, 2, h3);
|
STORE(EA + 6, 2, h4);
|
STORE(EA + 6, 2, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.804:EVX:e500:evstdhx %RS,%RA,%RB:Vector Store Double of Four Half Words Indexed
|
0.4,6.RS,11.RA,16.RB,21.804:EVX:e500:evstdhx %RS,%RA,%RB:Vector Store Double of Four Half Words Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2, h3, h4;
|
unsigned16 h1, h2, h3, h4;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h1 = EV_HIHALF(*rSh);
|
h1 = EV_HIHALF(*rSh);
|
h2 = EV_LOHALF(*rSh);
|
h2 = EV_LOHALF(*rSh);
|
h3 = EV_HIHALF(*rS);
|
h3 = EV_HIHALF(*rS);
|
h4 = EV_LOHALF(*rS);
|
h4 = EV_LOHALF(*rS);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 2, 2, h2);
|
STORE(EA + 2, 2, h2);
|
STORE(EA + 4, 2, h3);
|
STORE(EA + 4, 2, h3);
|
STORE(EA + 6, 2, h4);
|
STORE(EA + 6, 2, h4);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.825:EVX:e500:evstwwe %RS,%RA,%UIMM:Vector Store Word of Word from Even
|
0.4,6.RS,11.RA,16.UIMM,21.825:EVX:e500:evstwwe %RS,%RA,%UIMM:Vector Store Word of Word from Even
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w;
|
unsigned32 w;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
w = *rSh;
|
w = *rSh;
|
STORE(EA, 4, w);
|
STORE(EA, 4, w);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.824:EVX:e500:evstwwex %RS,%RA,%RB:Vector Store Word of Word from Even Indexed
|
0.4,6.RS,11.RA,16.RB,21.824:EVX:e500:evstwwex %RS,%RA,%RB:Vector Store Word of Word from Even Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w;
|
unsigned32 w;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
w = *rSh;
|
w = *rSh;
|
STORE(EA, 4, w);
|
STORE(EA, 4, w);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.829:EVX:e500:evstwwo %RS,%RA,%UIMM:Vector Store Word of Word from Odd
|
0.4,6.RS,11.RA,16.UIMM,21.829:EVX:e500:evstwwo %RS,%RA,%UIMM:Vector Store Word of Word from Odd
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w;
|
unsigned32 w;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
w = *rS;
|
w = *rS;
|
STORE(EA, 4, w);
|
STORE(EA, 4, w);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.828:EVX:e500:evstwwox %RS,%RA,%RB:Vector Store Word of Word from Odd Indexed
|
0.4,6.RS,11.RA,16.RB,21.828:EVX:e500:evstwwox %RS,%RA,%RB:Vector Store Word of Word from Odd Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned32 w;
|
unsigned32 w;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
w = *rS;
|
w = *rS;
|
STORE(EA, 4, w);
|
STORE(EA, 4, w);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.817:EVX:e500:evstwhe %RS,%RA,%UIMM:Vector Store Word of Two Half Words from Even
|
0.4,6.RS,11.RA,16.UIMM,21.817:EVX:e500:evstwhe %RS,%RA,%UIMM:Vector Store Word of Two Half Words from Even
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2;
|
unsigned16 h1, h2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
h1 = EV_HIHALF(*rSh);
|
h1 = EV_HIHALF(*rSh);
|
h2 = EV_HIHALF(*rS);
|
h2 = EV_HIHALF(*rS);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 2, 2, h2);
|
STORE(EA + 2, 2, h2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.816:EVX:e500:evstwhex %RS,%RA,%RB:Vector Store Word of Two Half Words from Even Indexed
|
0.4,6.RS,11.RA,16.RB,21.816:EVX:e500:evstwhex %RS,%RA,%RB:Vector Store Word of Two Half Words from Even Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2;
|
unsigned16 h1, h2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h1 = EV_HIHALF(*rSh);
|
h1 = EV_HIHALF(*rSh);
|
h2 = EV_HIHALF(*rS);
|
h2 = EV_HIHALF(*rS);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 2, 2, h2);
|
STORE(EA + 2, 2, h2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
0.4,6.RS,11.RA,16.UIMM,21.821:EVX:e500:evstwho %RS,%RA,%UIMM:Vector Store Word of Two Half Words from Odd
|
0.4,6.RS,11.RA,16.UIMM,21.821:EVX:e500:evstwho %RS,%RA,%UIMM:Vector Store Word of Two Half Words from Odd
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2;
|
unsigned16 h1, h2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + (UIMM << 3);
|
EA = b + (UIMM << 3);
|
h1 = EV_LOHALF(*rSh);
|
h1 = EV_LOHALF(*rSh);
|
h2 = EV_LOHALF(*rS);
|
h2 = EV_LOHALF(*rS);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 2, 2, h2);
|
STORE(EA + 2, 2, h2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1), 0);
|
|
|
0.4,6.RS,11.RA,16.RB,21.820:EVX:e500:evstwhox %RS,%RA,%RB:Vector Store Word of Two Half Words from Odd Indexed
|
0.4,6.RS,11.RA,16.RB,21.820:EVX:e500:evstwhox %RS,%RA,%RB:Vector Store Word of Two Half Words from Odd Indexed
|
unsigned_word b;
|
unsigned_word b;
|
unsigned_word EA;
|
unsigned_word EA;
|
unsigned16 h1, h2;
|
unsigned16 h1, h2;
|
if (RA_is_0) b = 0;
|
if (RA_is_0) b = 0;
|
else b = *rA;
|
else b = *rA;
|
EA = b + *rB;
|
EA = b + *rB;
|
h1 = EV_LOHALF(*rSh);
|
h1 = EV_LOHALF(*rSh);
|
h2 = EV_LOHALF(*rS);
|
h2 = EV_LOHALF(*rS);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 0, 2, h1);
|
STORE(EA + 2, 2, h2);
|
STORE(EA + 2, 2, h2);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0);
|
|
|
|
|
#
|
#
|
# 4.5.1 Integer Select Instruction
|
# 4.5.1 Integer Select Instruction
|
#
|
#
|
|
|
0.31,6.RS,11.RA,16.RB,21.CRB,26.30:X:e500:isel %RS,%RA,%RB,%CRB:Integer Select
|
0.31,6.RS,11.RA,16.RB,21.CRB,26.30:X:e500:isel %RS,%RA,%RB,%CRB:Integer Select
|
if (CR & (1 << (31 - (unsigned)CRB)))
|
if (CR & (1 << (31 - (unsigned)CRB)))
|
if (RA_is_0)
|
if (RA_is_0)
|
EV_SET_REG1(*rSh, *rS, 0);
|
EV_SET_REG1(*rSh, *rS, 0);
|
else
|
else
|
EV_SET_REG2(*rSh, *rS, *rAh, *rA);
|
EV_SET_REG2(*rSh, *rS, *rAh, *rA);
|
else
|
else
|
EV_SET_REG2(*rSh, *rS, *rBh, *rB);
|
EV_SET_REG2(*rSh, *rS, *rBh, *rB);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0);
|
|
|
