| # e500 core instructions, for PSIM, the PowerPC simulator. | |
| # Copyright 2003-2024 Free Software Foundation, Inc. | |
| # Contributed by Red Hat Inc; developed under contract from Motorola. | |
| # Written by matthew green <mrg@redhat.com>. | |
| # This file is part of GDB. | |
| # This program is free software; you can redistribute it and/or modify | |
| # it under the terms of the GNU General Public License as published by | |
| # the Free Software Foundation; either version 3 of the License, or | |
| # (at your option) any later version. | |
| # This program is distributed in the hope that it will be useful, | |
| # but WITHOUT ANY WARRANTY; without even the implied warranty of | |
| # MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the | |
| # GNU General Public License for more details. | |
| # You should have received a copy of the GNU General Public License | |
| # along with this program. If not, see <http://www.gnu.org/licenses/>. | |
| # | |
| # e500 Core Complex Instructions | |
| # | |
| :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 *:rBh:RB:(cpu_registers(processor)->e500.gprh + RB) | |
| # Flags for model.h | |
| ::model-macro::: | |
| #define PPC_INSN_INT_SPR(OUT_MASK, IN_MASK, SPR) \ | |
| do { \ | |
| if (CURRENT_MODEL_ISSUE > 0) \ | |
| ppc_insn_int_spr(MY_INDEX, cpu_model(processor), OUT_MASK, IN_MASK, SPR); \ | |
| } while (0) | |
| # 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 uint32_t out_mask, const uint32_t in_mask, const unsigned nSPR | |
| const uint32_t int_mask = out_mask | in_mask; | |
| model_busy *busy_ptr; | |
| while ((model_ptr->int_busy & int_mask) != 0 || model_ptr->spr_busy[nSPR] != 0) { | |
| if (WITH_TRACE && ppc_trace[trace_model]) | |
| model_trace_busy_p(model_ptr, int_mask, 0, 0, nSPR); | |
| model_ptr->nr_stalls_data++; | |
| model_new_cycle(model_ptr); | |
| } | |
| busy_ptr = model_wait_for_unit(index, model_ptr, &model_ptr->timing[index]); | |
| busy_ptr->int_busy |= out_mask; | |
| model_ptr->int_busy |= out_mask; | |
| busy_ptr->spr_busy = nSPR; | |
| model_ptr->spr_busy[nSPR] = 1; | |
| busy_ptr->nr_writebacks = (PPC_ONE_BIT_SET_P(out_mask)) ? 3 : 2; | |
| TRACE(trace_model,("Making register %s busy.\n", spr_name(nSPR))); | |
| # | |
| # SPE Modulo Fractional Multiplication handling support | |
| # | |
| :function:e500::uint64_t:ev_multiply16_smf:int16_t a, int16_t b, int *sat | |
| int32_t a32 = a, b32 = b, rv32; | |
| rv32 = a * b; | |
| *sat = (rv32 & (3<<30)) == (3<<30); | |
| return (int64_t)rv32 << 1; | |
| :function:e500::uint64_t:ev_multiply32_smf:int32_t a, int32_t b, int *sat | |
| int64_t rv64, a64 = a, b64 = b; | |
| rv64 = a64 * b64; | |
| *sat = (rv64 & ((int64_t)3<<62)) == ((int64_t)3<<62); | |
| /* Loses top sign bit. */ | |
| return rv64 << 1; | |
| # | |
| # SPE Saturation handling support | |
| # | |
| :function:e500::int32_t:ev_multiply16_ssf:int16_t a, int16_t b, int *sat | |
| int32_t rv32; | |
| if (a == 0xffff8000 && b == 0xffff8000) | |
| { | |
| rv32 = 0x7fffffffL; | |
| * sat = 1; | |
| return rv32; | |
| } | |
| else | |
| { | |
| int32_t a32 = a, b32 = b; | |
| rv32 = a * b; | |
| * sat = (rv32 & (3<<30)) == (3<<30); | |
| return (int64_t)rv32 << 1; | |
| } | |
| :function:e500::int64_t:ev_multiply32_ssf:int32_t a, int32_t b, int *sat | |
| int64_t rv64; | |
| if (a == 0x80000000 && b == 0x80000000) | |
| { | |
| rv64 = 0x7fffffffffffffffLL; | |
| * sat = 1; | |
| return rv64; | |
| } | |
| else | |
| { | |
| int64_t a64 = a, b64 = b; | |
| rv64 = a64 * b64; | |
| *sat = (rv64 & ((int64_t)3<<62)) == ((int64_t)3<<62); | |
| /* Loses top sign bit. */ | |
| return rv64 << 1; | |
| } | |
| # | |
| # SPE FP handling support | |
| # | |
| :function:e500::void:ev_check_guard:sim_fpu *a, int fg, int fx, cpu *processor | |
| uint64_t guard; | |
| guard = sim_fpu_guard(a, 0); | |
| if (guard & 1) | |
| EV_SET_SPEFSCR_BITS(fg); | |
| if (guard & ~1) | |
| EV_SET_SPEFSCR_BITS(fx); | |
| :function:e500::void:booke_sim_fpu_32to:sim_fpu *dst, uint32_t packed | |
| sim_fpu_32to (dst, packed); | |
| /* Set normally unused fields to allow booke arithmetic. */ | |
| if (dst->class == sim_fpu_class_infinity) | |
| { | |
| dst->normal_exp = 128; | |
| dst->fraction = ((uint64_t)1 << 60); | |
| } | |
| else if (dst->class == sim_fpu_class_qnan | |
| || dst->class == sim_fpu_class_snan) | |
| { | |
| dst->normal_exp = 128; | |
| /* This is set, but without the implicit bit, so we have to or | |
| in the implicit bit. */ | |
| dst->fraction |= ((uint64_t)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 | |
| int invalid_operand, overflow_result, underflow_result; | |
| int dest_exp; | |
| invalid_operand = 0; | |
| overflow_result = 0; | |
| underflow_result = 0; | |
| /* Treat NaN, Inf, and denorm like normal numbers, and signal invalid | |
| operand if it hasn't already been done. */ | |
| if (EV_IS_INFDENORMNAN (a)) | |
| { | |
| a->class = sim_fpu_class_number; | |
| EV_SET_SPEFSCR_BITS (inv); | |
| invalid_operand = 1; | |
| } | |
| if (EV_IS_INFDENORMNAN (b)) | |
| { | |
| b->class = sim_fpu_class_number; | |
| if (! invalid_operand) | |
| { | |
| EV_SET_SPEFSCR_BITS (inv); | |
| invalid_operand = 1; | |
| } | |
| } | |
| sim_fpu_add (d, a, b); | |
| dest_exp = booke_sim_fpu_exp (d); | |
| /* If this is a denorm, force to zero, and signal underflow if | |
| we haven't already indicated invalid operand. */ | |
| if (dest_exp <= -127) | |
| { | |
| int sign = d->sign; | |
| *d = sim_fpu_zero; | |
| d->sign = sign; | |
| if (! invalid_operand) | |
| { | |
| EV_SET_SPEFSCR_BITS (under); | |
| underflow_result = 1; | |
| } | |
| } | |
| /* If this is Inf/NaN, force to pmax/nmax, and signal overflow if | |
| we haven't already indicated invalid operand. */ | |
| else if (dest_exp >= 127) | |
| { | |
| int sign = d->sign; | |
| *d = sim_fpu_max32; | |
| d->sign = sign; | |
| if (! invalid_operand) | |
| { | |
| EV_SET_SPEFSCR_BITS (over); | |
| overflow_result = 1; | |
| } | |
| } | |
| /* Destination sign is sign of operand with larger magnitude, or | |
| the sign of the first operand if operands have the same | |
| magnitude. Thus if the result is zero, we force it to have | |
| the sign of the first operand. */ | |
| else if (d->fraction == 0) | |
| d->sign = a->sign; | |
| return invalid_operand || overflow_result || underflow_result; | |
| :function:e500::uint32_t:ev_fs_add:uint32_t aa, uint32_t bb, int inv, int over, int under, int fg, int fx, cpu *processor | |
| sim_fpu a, b, d; | |
| uint32_t w; | |
| int exception; | |
| booke_sim_fpu_32to (&a, aa); | |
| booke_sim_fpu_32to (&b, bb); | |
| exception = booke_sim_fpu_add (&d, &a, &b, inv, over, under, | |
| processor); | |
| sim_fpu_to32 (&w, &d); | |
| if (! exception) | |
| ev_check_guard(&d, fg, fx, processor); | |
| return w; | |
| :function:e500::uint32_t:ev_fs_sub:uint32_t aa, uint32_t bb, int inv, int over, int under, int fg, int fx, cpu *processor | |
| sim_fpu a, b, d; | |
| uint32_t w; | |
| int exception; | |
| booke_sim_fpu_32to (&a, aa); | |
| booke_sim_fpu_32to (&b, bb); | |
| /* Invert sign of second operand, and add. */ | |
| b.sign = ! b.sign; | |
| exception = booke_sim_fpu_add (&d, &a, &b, inv, over, under, | |
| processor); | |
| sim_fpu_to32 (&w, &d); | |
| if (! exception) | |
| ev_check_guard(&d, fg, fx, processor); | |
| return w; | |
| # sim_fpu_exp leaves the normal_exp field undefined for Inf and NaN. | |
| # The booke algorithms require exp values, so we fake them here. | |
| # fixme: It also apparently does the same for zero, but should not. | |
| :function:e500::uint32_t:booke_sim_fpu_exp:sim_fpu *x | |
| int y = sim_fpu_is (x); | |
| if (y == SIM_FPU_IS_PZERO || y == SIM_FPU_IS_NZERO) | |
| return 0; | |
| else if (y == SIM_FPU_IS_SNAN || y == SIM_FPU_IS_QNAN | |
| || y == SIM_FPU_IS_NINF || y == SIM_FPU_IS_PINF) | |
| return 128; | |
| else | |
| return sim_fpu_exp (x); | |
| :function:e500::uint32_t:ev_fs_mul:uint32_t aa, uint32_t bb, int inv, int over, int under, int fg, int fx, cpu *processor | |
| sim_fpu a, b, d; | |
| uint32_t w; | |
| int sa, sb, ea, eb, ei; | |
| sim_fpu_32to (&a, aa); | |
| sim_fpu_32to (&b, bb); | |
| sa = sim_fpu_sign(&a); | |
| sb = sim_fpu_sign(&b); | |
| ea = booke_sim_fpu_exp(&a); | |
| eb = booke_sim_fpu_exp(&b); | |
| ei = ea + eb + 127; | |
| if (sim_fpu_is_zero (&a) || sim_fpu_is_zero (&b)) | |
| w = 0; | |
| else if (sa == sb) { | |
| if (ei >= 254) { | |
| w = EV_PMAX; | |
| EV_SET_SPEFSCR_BITS(over); | |
| } else if (ei < 1) { | |
| d = sim_fpu_zero; | |
| sim_fpu_to32 (&w, &d); | |
| w &= 0x7fffffff; /* Clear sign bit. */ | |
| } else { | |
| goto normal_mul; | |
| } | |
| } else { | |
| if (ei >= 254) { | |
| w = EV_NMAX; | |
| EV_SET_SPEFSCR_BITS(over); | |
| } else if (ei < 1) { | |
| d = sim_fpu_zero; | |
| sim_fpu_to32 (&w, &d); | |
| w |= 0x80000000; /* Set sign bit. */ | |
| } else { | |
| normal_mul: | |
| if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b)) | |
| EV_SET_SPEFSCR_BITS(inv); | |
| sim_fpu_mul (&d, &a, &b); | |
| sim_fpu_to32 (&w, &d); | |
| } | |
| } | |
| return w; | |
| :function:e500::uint32_t:ev_fs_div:uint32_t aa, uint32_t bb, int inv, int over, int under, int dbz, int fg, int fx, cpu *processor | |
| sim_fpu a, b, d; | |
| uint32_t w; | |
| int sa, sb, ea, eb, ei; | |
| sim_fpu_32to (&a, aa); | |
| sim_fpu_32to (&b, bb); | |
| sa = sim_fpu_sign(&a); | |
| sb = sim_fpu_sign(&b); | |
| ea = booke_sim_fpu_exp(&a); | |
| eb = booke_sim_fpu_exp(&b); | |
| ei = ea - eb + 127; | |
| /* Special cases to handle behaviour of e500 hardware. | |
| cf case 107543. */ | |
| if (sim_fpu_is_nan (&a) || sim_fpu_is_nan (&b) | |
| || sim_fpu_is_zero (&a) || sim_fpu_is_zero (&b)) | |
| { | |
| if (sim_fpu_is_snan (&a) || sim_fpu_is_snan (&b)) | |
| { | |
| if (bb == 0x3f800000) | |
| w = EV_PMAX; | |
| else if (aa == 0x7fc00001) | |
| w = 0x3fbffffe; | |
| else | |
| goto normal_div; | |
| } | |
| else | |
| goto normal_div; | |
| } | |
| else if (sim_fpu_is_infinity (&a) && sim_fpu_is_infinity (&b)) | |
| { | |
| if (sa == sb) | |
| sim_fpu_32to (&d, 0x3f800000); | |
| else | |
| sim_fpu_32to (&d, 0xbf800000); | |
| sim_fpu_to32 (&w, &d); | |
| } | |
| else if (sa == sb) { | |
| if (ei > 254) { | |
| w = EV_PMAX; | |
| EV_SET_SPEFSCR_BITS(over); | |
| } else if (ei <= 1) { | |
| d = sim_fpu_zero; | |
| sim_fpu_to32 (&w, &d); | |
| w &= 0x7fffffff; /* Clear sign bit. */ | |
| } else { | |
| goto normal_div; | |
| } | |
| } else { | |
| if (ei > 254) { | |
| w = EV_NMAX; | |
| EV_SET_SPEFSCR_BITS(over); | |
| } else if (ei <= 1) { | |
| d = sim_fpu_zero; | |
| sim_fpu_to32 (&w, &d); | |
| w |= 0x80000000; /* Set sign bit. */ | |
| } else { | |
| normal_div: | |
| if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b)) | |
| EV_SET_SPEFSCR_BITS(inv); | |
| if (sim_fpu_is_zero (&b)) | |
| { | |
| if (sim_fpu_is_zero (&a)) | |
| EV_SET_SPEFSCR_BITS(dbz); | |
| else | |
| EV_SET_SPEFSCR_BITS(inv); | |
| w = sa ? EV_NMAX : EV_PMAX; | |
| } | |
| else | |
| { | |
| sim_fpu_div (&d, &a, &b); | |
| sim_fpu_to32 (&w, &d); | |
| ev_check_guard(&d, fg, fx, processor); | |
| } | |
| } | |
| } | |
| return w; | |
| # | |
| # 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 | |
| uint32_t w1, w2; | |
| w1 = *rBh + *rAh; | |
| w2 = *rB + *rA; | |
| EV_SET_REG2(*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); | |
| 0.4,6.RS,11.IMM,16.RB,21.514:X:e500:evaddiw %RS,%RB,%IMM:Vector Add Immediate Word | |
| uint32_t w1, w2; | |
| w1 = *rBh + IMM; | |
| w2 = *rB + IMM; | |
| EV_SET_REG2(*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); | |
| 0.4,6.RS,11.RA,16.RB,21.516:X:e500:evsubfw %RS,%RA,%RB:Vector Subtract from Word | |
| uint32_t w1, w2; | |
| w1 = *rBh - *rAh; | |
| w2 = *rB - *rA; | |
| EV_SET_REG2(*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); | |
| 0.4,6.RS,11.IMM,16.RB,21.518:X:e500:evsubifw %RS,%RB,%IMM:Vector Subtract Immediate from Word | |
| uint32_t w1, w2; | |
| w1 = *rBh - IMM; | |
| w2 = *rB - IMM; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| //printf("evsubifw: *rSh = %08x; *rS = %08x; IMM = %d\n", *rSh, *rS, IMM); | |
| 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 | |
| int32_t w1, w2; | |
| w1 = *rAh; | |
| if (w1 < 0 && w1 != 0x80000000) | |
| w1 = -w1; | |
| w2 = *rA; | |
| if (w2 < 0 && w2 != 0x80000000) | |
| w2 = -w2; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int32_t w1, w2; | |
| w1 = *rAh; | |
| /* the negative most negative number is the most negative number */ | |
| if (w1 != 0x80000000) | |
| w1 = -w1; | |
| w2 = *rA; | |
| if (w2 != 0x80000000) | |
| w2 = -w2; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint64_t w1, w2; | |
| w1 = *rAh & 0xff; | |
| if (w1 & 0x80) | |
| w1 |= 0xffffff00; | |
| w2 = *rA & 0xff; | |
| if (w2 & 0x80) | |
| w2 |= 0xffffff00; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint64_t w1, w2; | |
| w1 = *rAh & 0xffff; | |
| if (w1 & 0x8000) | |
| w1 |= 0xffff0000; | |
| w2 = *rA & 0xffff; | |
| if (w2 & 0x8000) | |
| w2 |= 0xffff0000; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rBh & *rAh; | |
| w2 = *rB & *rA; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rBh | *rAh; | |
| w2 = *rB | *rA; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rBh ^ *rAh; | |
| w2 = *rB ^ *rA; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = ~(*rBh & *rAh); | |
| w2 = ~(*rB & *rA); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = ~(*rBh | *rAh); | |
| w2 = ~(*rB | *rA); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = (~*rBh) ^ *rAh; | |
| w2 = (~*rB) ^ *rA; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = (~*rBh) & *rAh; | |
| w2 = (~*rB) & *rA; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| //printf("evandc: *rSh = %08x; *rS = %08x\n", *rSh, *rS); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = (~*rBh) | *rAh; | |
| w2 = (~*rB) | *rA; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| //printf("evorc: *rSh = %08x; *rS = %08x\n", *rSh, *rS); | |
| 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 | |
| uint32_t nh, nl, w1, w2; | |
| nh = *rBh & 0x1f; | |
| nl = *rB & 0x1f; | |
| w1 = ((uint32_t)*rAh) << nh | ((uint32_t)*rAh) >> (32 - nh); | |
| w2 = ((uint32_t)*rA) << nl | ((uint32_t)*rA) >> (32 - nl); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| //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); | |
| 0.4,6.RS,11.RA,16.UIMM,21.554:X:e500:evrlwi %RS,%RA,%UIMM:Vector Rotate Left Word Immediate | |
| uint32_t w1, w2, imm; | |
| imm = (uint32_t)UIMM; | |
| w1 = ((uint32_t)*rAh) << imm | ((uint32_t)*rAh) >> (32 - imm); | |
| w2 = ((uint32_t)*rA) << imm | ((uint32_t)*rA) >> (32 - imm); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t nh, nl, w1, w2; | |
| nh = *rBh & 0x1f; | |
| nl = *rB & 0x1f; | |
| w1 = ((uint32_t)*rAh) << nh; | |
| w2 = ((uint32_t)*rA) << nl; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2, imm = UIMM; | |
| w1 = ((uint32_t)*rAh) << imm; | |
| w2 = ((uint32_t)*rA) << imm; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int32_t w1, w2; | |
| uint32_t nh, nl; | |
| nh = *rBh & 0x1f; | |
| nl = *rB & 0x1f; | |
| w1 = ((int32_t)*rAh) >> nh; | |
| w2 = ((int32_t)*rA) >> nl; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| //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); | |
| 0.4,6.RS,11.RA,16.RB,21.544:X:e500:evsrwu %RS,%RA,%RB:Vector Shift Right Word Unsigned | |
| uint32_t w1, w2, nh, nl; | |
| nh = *rBh & 0x1f; | |
| nl = *rB & 0x1f; | |
| w1 = ((uint32_t)*rAh) >> nh; | |
| w2 = ((uint32_t)*rA) >> nl; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int32_t w1, w2; | |
| uint32_t imm = UIMM; | |
| w1 = ((int32_t)*rAh) >> imm; | |
| w2 = ((int32_t)*rA) >> imm; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2, imm = UIMM; | |
| w1 = ((uint32_t)*rAh) >> imm; | |
| w2 = ((uint32_t)*rA) >> imm; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2, mask, c1, c2; | |
| for (c1 = 0, mask = 0x80000000, w1 = *rAh; | |
| !(w1 & mask) && mask != 0; mask >>= 1) | |
| c1++; | |
| for (c2 = 0, mask = 0x80000000, w2 = *rA; | |
| !(w2 & mask) && mask != 0; mask >>= 1) | |
| c2++; | |
| EV_SET_REG2(*rSh, *rS, c1, c2); | |
| 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 | |
| uint32_t w1, w2, mask, sign_bit, c1, c2; | |
| for (c1 = 0, mask = 0x80000000, w1 = *rAh, sign_bit = w1 & mask; | |
| ((w1 & mask) == sign_bit) && mask != 0; | |
| mask >>= 1, sign_bit >>= 1) | |
| c1++; | |
| for (c2 = 0, mask = 0x80000000, w2 = *rA, sign_bit = w2 & mask; | |
| ((w2 & mask) == sign_bit) && mask != 0; | |
| mask >>= 1, sign_bit >>= 1) | |
| c2++; | |
| EV_SET_REG2(*rSh, *rS, c1, c2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = ((uint32_t)*rAh + 0x8000) & 0xffff0000; | |
| w2 = ((uint32_t)*rA + 0x8000) & 0xffff0000; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| //printf("evrndw: *rSh = %08x; *rS = %08x\n", *rSh, *rS); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rAh; | |
| w2 = *rBh; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rA; | |
| w2 = *rB; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rA; | |
| w2 = *rBh; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rAh; | |
| w2 = *rB; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w; | |
| w = SIMM & 0x1f; | |
| if (w & 0x10) | |
| w |= 0xffffffe0; | |
| EV_SET_REG2(*rSh, *rS, w, w); | |
| 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 | |
| uint32_t w; | |
| w = SIMM << 27; | |
| EV_SET_REG2(*rSh, *rS, w, w); | |
| 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 | |
| int32_t ah, al, bh, bl; | |
| int w, ch, cl; | |
| ah = *rAh; | |
| al = *rA; | |
| bh = *rBh; | |
| bl = *rB; | |
| if (ah > bh) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (al > bl) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| uint32_t ah, al, bh, bl; | |
| int w, ch, cl; | |
| ah = *rAh; | |
| al = *rA; | |
| bh = *rBh; | |
| bl = *rB; | |
| if (ah > bh) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (al > bl) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| int32_t ah, al, bh, bl; | |
| int w, ch, cl; | |
| ah = *rAh; | |
| al = *rA; | |
| bh = *rBh; | |
| bl = *rB; | |
| if (ah < bh) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (al < bl) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| uint32_t ah, al, bh, bl; | |
| int w, ch, cl; | |
| ah = *rAh; | |
| al = *rA; | |
| bh = *rBh; | |
| bl = *rB; | |
| if (ah < bh) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (al < bl) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| uint32_t ah, al, bh, bl; | |
| int w, ch, cl; | |
| ah = *rAh; | |
| al = *rA; | |
| bh = *rBh; | |
| bl = *rB; | |
| if (ah == bh) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (al == bl) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| //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); | |
| 0.4,6.RS,11.RA,16.RB,21.79,29.CRFS:X:e500:evsel %RS,%RA,%RB,%CRFS:Vector Select | |
| uint32_t w1, w2; | |
| int cr; | |
| cr = CR_FIELD(CRFS); | |
| if (cr & 8) | |
| w1 = *rAh; | |
| else | |
| w1 = *rBh; | |
| if (cr & 4) | |
| w2 = *rA; | |
| else | |
| w2 = *rB; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2, a, d, mask; | |
| mask = (*rB) & 0xffff; | |
| a = (*rA) & 0xffff; | |
| d = EV_BITREVERSE16(1 + EV_BITREVERSE16(a | ~mask)); | |
| *rS = ((*rA) & 0xffff0000) | (d & 0xffff); | |
| //printf("brinc: *rS = %08x\n", *rS); | |
| PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0); | |
| # | |
| # 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t tl, th; | |
| int movl, movh; | |
| al = (int16_t) EV_LOHALF (*rA); | |
| ah = (int16_t) EV_LOHALF (*rAh); | |
| bl = (int16_t) EV_LOHALF (*rB); | |
| bh = (int16_t) EV_LOHALF (*rBh); | |
| tl = ev_multiply16_ssf (al, bl, &movl); | |
| th = ev_multiply16_ssf (ah, bh, &movh); | |
| EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th), | |
| EV_SATURATE (movl, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV (movl, movh); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t tl, th; | |
| int movl, movh; | |
| al = (int16_t) EV_LOHALF (*rA); | |
| ah = (int16_t) EV_LOHALF (*rAh); | |
| bl = (int16_t) EV_LOHALF (*rB); | |
| bh = (int16_t) EV_LOHALF (*rBh); | |
| tl = ev_multiply16_ssf (al, bl, &movl); | |
| th = ev_multiply16_ssf (ah, bh, &movh); | |
| EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th), | |
| EV_SATURATE (movl, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV (movl, movh); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t tl, th; | |
| int dummy; | |
| al = (int16_t) EV_LOHALF (*rA); | |
| ah = (int16_t) EV_LOHALF (*rAh); | |
| bl = (int16_t) EV_LOHALF (*rB); | |
| bh = (int16_t) EV_LOHALF (*rBh); | |
| tl = ev_multiply16_smf (al, bl, & dummy); | |
| th = ev_multiply16_smf (ah, bh, & dummy); | |
| EV_SET_REG2 (*rSh, *rS, th, tl); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int32_t tl, th; | |
| int dummy; | |
| al = (int16_t) EV_LOHALF (*rA); | |
| ah = (int16_t) EV_LOHALF (*rAh); | |
| bl = (int16_t) EV_LOHALF (*rB); | |
| bh = (int16_t) EV_LOHALF (*rBh); | |
| tl = ev_multiply16_smf (al, bl, & dummy); | |
| th = ev_multiply16_smf (ah, bh, & dummy); | |
| EV_SET_REG2_ACC (*rSh, *rS, th, tl); | |
| 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 | |
| int32_t al, ah, bl, bh, tl, th; | |
| al = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_LOHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_LOHALF(*rBh); | |
| tl = al * bl; | |
| th = ah * bh; | |
| EV_SET_REG2(*rSh, *rS, th, tl); | |
| //printf("evmhosmi: *rSh = %08x; *rS = %08x\n", *rSh, *rS); | |
| 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 | |
| int32_t al, ah, bl, bh, tl, th; | |
| al = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_LOHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_LOHALF(*rBh); | |
| tl = al * bl; | |
| th = ah * bh; | |
| EV_SET_REG2_ACC(*rSh, *rS, th, tl); | |
| //printf("evmhosmia: ACC = %08x; *rSh = %08x; *rS = %08x\n", ACC, *rSh, *rS); | |
| 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 | |
| uint32_t al, ah, bl, bh, tl, th; | |
| al = (uint32_t)(uint16_t)EV_LOHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_LOHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_LOHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_LOHALF(*rBh); | |
| tl = al * bl; | |
| th = ah * bh; | |
| EV_SET_REG2(*rSh, *rS, th, tl); | |
| 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 | |
| uint32_t al, ah, bl, bh, tl, th; | |
| al = (uint32_t)(uint16_t)EV_LOHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_LOHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_LOHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_LOHALF(*rBh); | |
| tl = al * bl; | |
| th = ah * bh; | |
| EV_SET_REG2_ACC(*rSh, *rS, th, tl); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t tl, th; | |
| int movl, movh; | |
| al = (int16_t) EV_HIHALF (*rA); | |
| ah = (int16_t) EV_HIHALF (*rAh); | |
| bl = (int16_t) EV_HIHALF (*rB); | |
| bh = (int16_t) EV_HIHALF (*rBh); | |
| tl = ev_multiply16_ssf (al, bl, &movl); | |
| th = ev_multiply16_ssf (ah, bh, &movh); | |
| EV_SET_REG2 (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th), | |
| EV_SATURATE (movl, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV (movl, movh); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t tl, th; | |
| int movl, movh; | |
| al = (int16_t) EV_HIHALF (*rA); | |
| ah = (int16_t) EV_HIHALF (*rAh); | |
| bl = (int16_t) EV_HIHALF (*rB); | |
| bh = (int16_t) EV_HIHALF (*rBh); | |
| tl = ev_multiply16_ssf (al, bl, &movl); | |
| th = ev_multiply16_ssf (ah, bh, &movh); | |
| EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE (movh, 0x7fffffff, th), | |
| EV_SATURATE (movl, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV (movl, movh); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int64_t tl, th; | |
| int movl, movh; | |
| al = (int16_t) EV_HIHALF (*rA); | |
| ah = (int16_t) EV_HIHALF (*rAh); | |
| bl = (int16_t) EV_HIHALF (*rB); | |
| bh = (int16_t) EV_HIHALF (*rBh); | |
| tl = ev_multiply16_smf (al, bl, &movl); | |
| th = ev_multiply16_smf (ah, bh, &movh); | |
| EV_SET_REG2 (*rSh, *rS, th, tl); | |
| EV_SET_SPEFSCR_OV (movl, movh); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t tl, th; | |
| int dummy; | |
| al = (int16_t) EV_HIHALF (*rA); | |
| ah = (int16_t) EV_HIHALF (*rAh); | |
| bl = (int16_t) EV_HIHALF (*rB); | |
| bh = (int16_t) EV_HIHALF (*rBh); | |
| tl = ev_multiply16_smf (al, bl, & dummy); | |
| th = ev_multiply16_smf (ah, bh, & dummy); | |
| EV_SET_REG2_ACC (*rSh, *rS, th, tl); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t tl, th; | |
| al = (int16_t) EV_HIHALF (*rA); | |
| ah = (int16_t) EV_HIHALF (*rAh); | |
| bl = (int16_t) EV_HIHALF (*rB); | |
| bh = (int16_t) EV_HIHALF (*rBh); | |
| tl = al * bl; | |
| th = ah * bh; | |
| EV_SET_REG2 (*rSh, *rS, th, tl); | |
| 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 | |
| int32_t al, ah, bl, bh, tl, th; | |
| al = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_HIHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_HIHALF(*rBh); | |
| tl = al * bl; | |
| th = ah * bh; | |
| EV_SET_REG2_ACC(*rSh, *rS, th, tl); | |
| 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 | |
| uint32_t al, ah, bl, bh, tl, th; | |
| al = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_HIHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_HIHALF(*rBh); | |
| tl = al * bl; | |
| th = ah * bh; | |
| EV_SET_REG2(*rSh, *rS, th, tl); | |
| 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 | |
| uint32_t al, ah, bl, bh, tl, th; | |
| al = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_HIHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_HIHALF(*rBh); | |
| tl = al * bl; | |
| th = ah * bh; | |
| EV_SET_REG2_ACC(*rSh, *rS, th, tl); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t t1, t2; | |
| int64_t tl, th; | |
| int movl, movh, ovl, ovh; | |
| al = (int16_t) EV_LOHALF (*rA); | |
| ah = (int16_t) EV_LOHALF (*rAh); | |
| bl = (int16_t) EV_LOHALF (*rB); | |
| bh = (int16_t) EV_LOHALF (*rBh); | |
| t1 = ev_multiply16_ssf (ah, bh, &movh); | |
| t2 = ev_multiply16_ssf (al, bl, &movl); | |
| th = EV_ACCHIGH + EV_SATURATE (movh, 0x7fffffff, t1); | |
| tl = EV_ACCLOW + EV_SATURATE (movl, 0x7fffffff, t2); | |
| ovh = EV_SAT_P_S32 (th); | |
| ovl = EV_SAT_P_S32 (tl); | |
| EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| int ovl, ovh; | |
| al = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_LOHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_LOHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH + t1; | |
| tl = EV_ACCLOW + t2; | |
| ovh = EV_SAT_P_S32(th); | |
| ovl = EV_SAT_P_S32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th), | |
| 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: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| al = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_LOHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_LOHALF(*rBh); | |
| t1 = ((int64_t)ah * bh) << 1; | |
| t2 = ((int64_t)al * bl) << 1; | |
| th = EV_ACCHIGH + (t1 & 0xffffffff); | |
| tl = EV_ACCLOW + (t2 & 0xffffffff); | |
| EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| al = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_LOHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_LOHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH + t1; | |
| tl = EV_ACCLOW + t2; | |
| 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: 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); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| int64_t tl, th; | |
| int ovl, ovh; | |
| al = (uint32_t)(uint16_t)EV_LOHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_LOHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_LOHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_LOHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = (int64_t)EV_ACCHIGH + (int64_t)t1; | |
| tl = (int64_t)EV_ACCLOW + (int64_t)t2; | |
| ovh = EV_SAT_P_U32(th); | |
| ovl = EV_SAT_P_U32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th), | |
| 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: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint32_t t1, t2; | |
| int64_t tl, th; | |
| al = (uint32_t)(uint16_t)EV_LOHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_LOHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_LOHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_LOHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH + t1; | |
| tl = EV_ACCLOW + t2; | |
| 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: 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); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t t1, t2; | |
| int64_t tl, th; | |
| int movl, movh, ovl, ovh; | |
| al = (int16_t) EV_HIHALF (*rA); | |
| ah = (int16_t) EV_HIHALF (*rAh); | |
| bl = (int16_t) EV_HIHALF (*rB); | |
| bh = (int16_t) EV_HIHALF (*rBh); | |
| t1 = ev_multiply16_ssf (ah, bh, &movh); | |
| t2 = ev_multiply16_ssf (al, bl, &movl); | |
| th = EV_ACCHIGH + EV_SATURATE (movh, 0x7fffffff, t1); | |
| tl = EV_ACCLOW + EV_SATURATE (movl, 0x7fffffff, t2); | |
| ovh = EV_SAT_P_S32 (th); | |
| ovl = EV_SAT_P_S32 (tl); | |
| EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| int ovl, ovh; | |
| al = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_HIHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_HIHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH + t1; | |
| tl = EV_ACCLOW + t2; | |
| ovh = EV_SAT_P_S32(th); | |
| ovl = EV_SAT_P_S32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th), | |
| 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: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t t1, t2, th, tl; | |
| int dummy; | |
| al = (int16_t)EV_HIHALF(*rA); | |
| ah = (int16_t)EV_HIHALF(*rAh); | |
| bl = (int16_t)EV_HIHALF(*rB); | |
| bh = (int16_t)EV_HIHALF(*rBh); | |
| t1 = ev_multiply16_smf (ah, bh, &dummy); | |
| t2 = ev_multiply16_smf (al, bl, &dummy); | |
| th = EV_ACCHIGH + t1; | |
| tl = EV_ACCLOW + t2; | |
| EV_SET_REG2_ACC(*rSh, *rS, th, tl); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| al = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_HIHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_HIHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH + t1; | |
| tl = EV_ACCLOW + t2; | |
| EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| int64_t tl, th; | |
| int ovl, ovh; | |
| al = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_HIHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_HIHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = (int64_t)EV_ACCHIGH + (int64_t)t1; | |
| tl = (int64_t)EV_ACCLOW + (int64_t)t2; | |
| ovh = EV_SAT_P_U32(th); | |
| ovl = EV_SAT_P_U32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th), | |
| EV_SATURATE_ACC(ovl, tl, 0, 0xffffffff, tl)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint32_t t1, t2; | |
| uint64_t tl, th; | |
| al = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_HIHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_HIHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH + t1; | |
| tl = EV_ACCLOW + t2; | |
| EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t t1, t2; | |
| int64_t tl, th; | |
| int movl, movh, ovl, ovh; | |
| al = (int16_t) EV_LOHALF (*rA); | |
| ah = (int16_t) EV_LOHALF (*rAh); | |
| bl = (int16_t) EV_LOHALF (*rB); | |
| bh = (int16_t) EV_LOHALF (*rBh); | |
| t1 = ev_multiply16_ssf (ah, bh, &movh); | |
| t2 = ev_multiply16_ssf (al, bl, &movl); | |
| th = EV_ACCHIGH - EV_SATURATE (movh, 0x7fffffff, t1); | |
| tl = EV_ACCLOW - EV_SATURATE (movl, 0x7fffffff, t2); | |
| ovh = EV_SAT_P_S32 (th); | |
| ovl = EV_SAT_P_S32 (tl); | |
| EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| int ovl, ovh; | |
| al = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_LOHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_LOHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH - t1; | |
| tl = EV_ACCLOW - t2; | |
| ovh = EV_SAT_P_S32(th); | |
| ovl = EV_SAT_P_S32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| //printf("evmhossianw: ACC = %08x; *rSh = %08x; *rS = %08x\n", ACC, *rSh, *rS); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| al = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_LOHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_LOHALF(*rBh); | |
| t1 = ((int64_t)ah * bh) << 1; | |
| t2 = ((int64_t)al * bl) << 1; | |
| th = EV_ACCHIGH - (t1 & 0xffffffff); | |
| tl = EV_ACCLOW - (t2 & 0xffffffff); | |
| EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| al = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_LOHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_LOHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH - t1; | |
| tl = EV_ACCLOW - t2; | |
| EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| int64_t tl, th; | |
| int ovl, ovh; | |
| al = (uint32_t)(uint16_t)EV_LOHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_LOHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_LOHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_LOHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = (int64_t)EV_ACCHIGH - (int64_t)t1; | |
| tl = (int64_t)EV_ACCLOW - (int64_t)t2; | |
| ovl = EV_SAT_P_U32(tl); | |
| ovh = EV_SAT_P_U32(th); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th), | |
| 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("evmoussianw: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint32_t t1, t2; | |
| uint64_t tl, th; | |
| al = (uint32_t)(uint16_t)EV_LOHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_LOHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_LOHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_LOHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH - t1; | |
| tl = EV_ACCLOW - t2; | |
| EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff); | |
| 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 | |
| int16_t al, ah, bl, bh; | |
| int32_t t1, t2; | |
| int64_t tl, th; | |
| int movl, movh, ovl, ovh; | |
| al = (int16_t) EV_HIHALF (*rA); | |
| ah = (int16_t) EV_HIHALF (*rAh); | |
| bl = (int16_t) EV_HIHALF (*rB); | |
| bh = (int16_t) EV_HIHALF (*rBh); | |
| t1 = ev_multiply16_ssf (ah, bh, &movh); | |
| t2 = ev_multiply16_ssf (al, bl, &movl); | |
| th = EV_ACCHIGH - EV_SATURATE (movh, 0x7fffffff, t1); | |
| tl = EV_ACCLOW - EV_SATURATE (movl, 0x7fffffff, t2); | |
| ovh = EV_SAT_P_S32 (th); | |
| ovl = EV_SAT_P_S32 (tl); | |
| EV_SET_REG2_ACC (*rSh, *rS, EV_SATURATE_ACC (ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC (ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV (movl | ovl, movh | ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| int ovl, ovh; | |
| al = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_HIHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_HIHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH - t1; | |
| tl = EV_ACCLOW - t2; | |
| ovh = EV_SAT_P_S32(th); | |
| ovl = EV_SAT_P_S32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| al = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_HIHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_HIHALF(*rBh); | |
| t1 = ((int64_t)ah * bh) << 1; | |
| t2 = ((int64_t)al * bl) << 1; | |
| th = EV_ACCHIGH - (t1 & 0xffffffff); | |
| tl = EV_ACCLOW - (t2 & 0xffffffff); | |
| EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| al = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| ah = (int32_t)(int16_t)EV_HIHALF(*rAh); | |
| bl = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| bh = (int32_t)(int16_t)EV_HIHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH - t1; | |
| tl = EV_ACCLOW - t2; | |
| 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: 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); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| int64_t tl, th; | |
| int ovl, ovh; | |
| al = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_HIHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_HIHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = (int64_t)EV_ACCHIGH - (int64_t)t1; | |
| tl = (int64_t)EV_ACCLOW - (int64_t)t2; | |
| ovl = EV_SAT_P_U32(tl); | |
| ovh = EV_SAT_P_U32(th); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0, 0xffffffff, th), | |
| 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: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint32_t t1, t2; | |
| uint64_t tl, th; | |
| al = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| ah = (uint32_t)(uint16_t)EV_HIHALF(*rAh); | |
| bl = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| bh = (uint32_t)(uint16_t)EV_HIHALF(*rBh); | |
| t1 = ah * bh; | |
| t2 = al * bl; | |
| th = EV_ACCHIGH - t1; | |
| tl = EV_ACCLOW - t2; | |
| EV_SET_REG2_ACC(*rSh, *rS, th & 0xffffffff, tl & 0xffffffff); | |
| 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 | |
| int32_t a, b; | |
| int64_t t1, t2; | |
| a = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| b = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| t1 = EV_MUL16_SSF(a, b); | |
| if (t1 & ((uint64_t)1 << 32)) | |
| t1 |= 0xfffffffe00000000; | |
| t2 = ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int32_t a, b; | |
| int64_t t1, t2; | |
| a = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| b = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| t1 = (int64_t)a * (int64_t)b; | |
| t2 = (int64_t)ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, 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); | |
| 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 | |
| uint32_t a, b; | |
| uint64_t t1, t2; | |
| a = (uint32_t)(uint16_t)EV_LOHALF(*rA); | |
| b = (uint32_t)(uint16_t)EV_LOHALF(*rB); | |
| t1 = a * b; | |
| t2 = ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int32_t a, b; | |
| int64_t t1, t2; | |
| a = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| b = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| t1 = EV_MUL16_SSF(a, b); | |
| if (t1 & ((uint64_t)1 << 32)) | |
| t1 |= 0xfffffffe00000000; | |
| t2 = ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int32_t a, b; | |
| int64_t t1, t2; | |
| a = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| b = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| t1 = (int64_t)(a * b); | |
| t2 = ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| uint32_t a, b; | |
| uint64_t t1, t2; | |
| a = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| b = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| t1 = a * b; | |
| t2 = ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int32_t a, b; | |
| int64_t t1, t2; | |
| a = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| b = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| t1 = EV_MUL16_SSF(a, b); | |
| if (t1 & ((uint64_t)1 << 32)) | |
| t1 |= 0xfffffffe00000000; | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int32_t a, b; | |
| int64_t t1, t2; | |
| a = (int32_t)(int16_t)EV_LOHALF(*rA); | |
| b = (int32_t)(int16_t)EV_LOHALF(*rB); | |
| t1 = (int64_t)a * (int64_t)b; | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, 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); | |
| 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 | |
| uint32_t a, b; | |
| uint64_t t1, t2; | |
| a = (uint32_t)(uint16_t)EV_LOHALF(*rA); | |
| b = (uint32_t)(uint16_t)EV_LOHALF(*rB); | |
| t1 = (uint64_t)a * (uint64_t)b; | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int32_t a, b; | |
| int64_t t1, t2; | |
| a = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| b = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| t1 = EV_MUL16_SSF(a, b); | |
| if (t1 & ((uint64_t)1 << 32)) | |
| t1 |= 0xfffffffe00000000; | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int32_t a, b; | |
| int64_t t1, t2; | |
| a = (int32_t)(int16_t)EV_HIHALF(*rA); | |
| b = (int32_t)(int16_t)EV_HIHALF(*rB); | |
| t1 = (int64_t)a * (int64_t)b; | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| uint32_t a, b; | |
| uint64_t t1, t2; | |
| a = (uint32_t)(uint16_t)EV_HIHALF(*rA); | |
| b = (uint32_t)(uint16_t)EV_HIHALF(*rB); | |
| t1 = (uint64_t)a * (uint64_t)b; | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| int movl, movh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = ev_multiply32_ssf(al, bl, &movl); | |
| t2 = ev_multiply32_ssf(ah, bh, &movh); | |
| EV_SET_REG2(*rSh, *rS, EV_SATURATE(movh, 0x7fffffff, t2 >> 32), | |
| EV_SATURATE(movl, 0x7fffffff, t1 >> 32)); | |
| EV_SET_SPEFSCR_OV(movl, movh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| int movl, movh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = ev_multiply32_ssf(al, bl, &movl); | |
| t2 = ev_multiply32_ssf(ah, bh, &movh); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(movh, 0x7fffffff, t2 >> 32), | |
| EV_SATURATE(movl, 0x7fffffff, t1 >> 32)); | |
| EV_SET_SPEFSCR_OV(movl, movh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = EV_MUL32_SSF(al, bl); | |
| t2 = EV_MUL32_SSF(ah, bh); | |
| EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = EV_MUL32_SSF(al, bl); | |
| t2 = EV_MUL32_SSF(ah, bh); | |
| EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (int64_t)al * (int64_t)bl; | |
| t2 = (int64_t)ah * (int64_t)bh; | |
| EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (int64_t)al * (int64_t)bl; | |
| t2 = (int64_t)ah * (int64_t)bh; | |
| EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (uint64_t)al * (uint64_t)bl; | |
| t2 = (uint64_t)ah * (uint64_t)bh; | |
| EV_SET_REG2(*rSh, *rS, t2 >> 32, t1 >> 32); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (uint64_t)al * (uint64_t)bl; | |
| t2 = (uint64_t)ah * (uint64_t)bh; | |
| EV_SET_REG2_ACC(*rSh, *rS, t2 >> 32, t1 >> 32); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| int movl, movh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = ev_multiply32_ssf(al, bl, &movl); | |
| t2 = ev_multiply32_ssf(ah, bh, &movh); | |
| EV_SET_REG2(*rSh, *rS, EV_SATURATE(movh, 0xffffffff, t2), | |
| EV_SATURATE(movl, 0xffffffff, t1)); | |
| EV_SET_SPEFSCR_OV(movl, movh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| int movl, movh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = ev_multiply32_ssf(al, bl, &movl); | |
| t2 = ev_multiply32_ssf(ah, bh, &movh); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(movh, 0xffffffff, t2), | |
| EV_SATURATE(movl, 0xffffffff, t1)); | |
| EV_SET_SPEFSCR_OV(movl, movh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = EV_MUL32_SSF(al, bl); | |
| t2 = EV_MUL32_SSF(ah, bh); | |
| EV_SET_REG2(*rSh, *rS, t2, t1); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = EV_MUL32_SSF(al, bl); | |
| t2 = EV_MUL32_SSF(ah, bh); | |
| EV_SET_REG2_ACC(*rSh, *rS, t2, t1); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (uint64_t)al * (uint64_t)bl; | |
| t2 = (uint64_t)ah * (uint64_t)bh; | |
| EV_SET_REG2(*rSh, *rS, t2, t1); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (uint64_t)al * (uint64_t)bl; | |
| t2 = (uint64_t)ah * (uint64_t)bh; | |
| EV_SET_REG2_ACC(*rSh, *rS, t2, t1); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| int movl, movh, ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = ev_multiply32_ssf(ah, bh, &movh); | |
| t2 = ev_multiply32_ssf(al, bl, &movl); | |
| th = EV_ACCHIGH + EV_SATURATE(movh, 0xffffffff, t1); | |
| tl = EV_ACCLOW + EV_SATURATE(movl, 0xffffffff, t2); | |
| ovh = EV_SAT_P_S32(th); | |
| ovl = EV_SAT_P_S32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV(movl | ovl, movh | ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| int ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (int64_t)ah * (int64_t)bh; | |
| t2 = (int64_t)al * (int64_t)bl; | |
| th = EV_ACCHIGH + (t1 & 0xffffffff); | |
| tl = EV_ACCLOW + (t2 & 0xffffffff); | |
| ovh = EV_SAT_P_S32(th); | |
| ovl = EV_SAT_P_S32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| int mov; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = ev_multiply32_smf(ah, bh, &mov); | |
| t2 = ev_multiply32_smf(al, bl, &mov); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 0xffffffff), | |
| EV_ACCLOW + (t2 & 0xffffffff)); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (int64_t)ah * (int64_t)bh; | |
| t2 = (int64_t)al * (int64_t)bl; | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 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: *rSh = %08x; *rS = %08x\n", *rSh, *rS); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2, tl, th; | |
| int ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (uint64_t)ah * (uint64_t)bh; | |
| t2 = (uint64_t)al * (uint64_t)bl; | |
| th = EV_ACCHIGH + (t1 & 0xffffffff); | |
| tl = EV_ACCLOW + (t2 & 0xffffffff); | |
| ovh = (th >> 32); | |
| ovl = (tl >> 32); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, th), | |
| EV_SATURATE(ovl, 0xffffffff, tl)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (uint64_t)ah * (uint64_t)bh; | |
| t2 = (uint64_t)al * (uint64_t)bl; | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH + (t1 & 0xffffffff), | |
| EV_ACCLOW + (t2 & 0xffffffff)); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| int movl, movh, ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = ev_multiply32_ssf(ah, bh, &movh); | |
| t2 = ev_multiply32_ssf(al, bl, &movl); | |
| th = EV_ACCHIGH - EV_SATURATE(movh, 0xffffffff, t1); | |
| tl = EV_ACCLOW - EV_SATURATE(movl, 0xffffffff, t2); | |
| ovh = EV_SAT_P_S32(th); | |
| ovl = EV_SAT_P_S32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV(movl | ovl, movh | ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2, tl, th; | |
| int ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (int64_t)ah * (int64_t)bh; | |
| t2 = (int64_t)al * (int64_t)bl; | |
| th = EV_ACCHIGH - (t1 & 0xffffffff); | |
| tl = EV_ACCLOW - (t2 & 0xffffffff); | |
| ovh = EV_SAT_P_S32(th); | |
| ovl = EV_SAT_P_S32(tl); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, th, 0x80000000, 0x7fffffff, th), | |
| EV_SATURATE_ACC(ovl, tl, 0x80000000, 0x7fffffff, tl)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| int mov; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = ev_multiply32_smf(ah, bh, &mov); | |
| t2 = ev_multiply32_smf(al, bl, &mov); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff), | |
| EV_ACCLOW - (t2 & 0xffffffff)); | |
| 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 | |
| int32_t al, ah, bl, bh; | |
| int64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (int64_t)ah * (int64_t)bh; | |
| t2 = (int64_t)al * (int64_t)bl; | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff), | |
| EV_ACCLOW - (t2 & 0xffffffff)); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2, tl, th; | |
| int ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (uint64_t)ah * (uint64_t)bh; | |
| t2 = (uint64_t)al * (uint64_t)bl; | |
| th = EV_ACCHIGH - (t1 & 0xffffffff); | |
| tl = EV_ACCLOW - (t2 & 0xffffffff); | |
| ovh = (th >> 32); | |
| ovl = (tl >> 32); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, th), | |
| 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: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint32_t al, ah, bl, bh; | |
| uint64_t t1, t2; | |
| al = *rA; | |
| ah = *rAh; | |
| bl = *rB; | |
| bh = *rBh; | |
| t1 = (uint64_t)ah * (uint64_t)bh; | |
| t2 = (uint64_t)al * (uint64_t)bl; | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_ACCHIGH - (t1 & 0xffffffff), | |
| EV_ACCLOW - (t2 & 0xffffffff)); | |
| 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 | |
| int32_t a, b; | |
| int64_t t; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t = ev_multiply32_ssf(a, b, &movl); | |
| EV_SET_REG1(*rSh, *rS, EV_SATURATE(movl, 0x7fffffffffffffff, t)); | |
| EV_SET_SPEFSCR_OV(movl, 0); | |
| 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 | |
| int32_t a, b; | |
| int64_t t; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t = ev_multiply32_ssf(a, b, &movl); | |
| EV_SET_REG1_ACC(*rSh, *rS, EV_SATURATE(movl, 0x7fffffffffffffff, t)); | |
| EV_SET_SPEFSCR_OV(movl, 0); | |
| 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 | |
| int32_t a, b; | |
| int64_t t; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t = ev_multiply32_smf(a, b, &movl); | |
| EV_SET_REG1(*rSh, *rS, t); | |
| 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 | |
| int32_t a, b; | |
| int64_t t; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t = ev_multiply32_smf(a, b, &movl); | |
| EV_SET_REG1_ACC(*rSh, *rS, t); | |
| 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 | |
| int32_t a, b; | |
| int64_t t; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t = (int64_t)a * (int64_t)b; | |
| EV_SET_REG1(*rSh, *rS, t); | |
| 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 | |
| int32_t a, b; | |
| int64_t t; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t = (int64_t)a * (int64_t)b; | |
| EV_SET_REG1_ACC(*rSh, *rS, t); | |
| 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 | |
| uint32_t a, b; | |
| uint64_t t; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t = (int64_t)a * (int64_t)b; | |
| EV_SET_REG1(*rSh, *rS, t); | |
| 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 | |
| uint32_t a, b; | |
| uint64_t t; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t = (int64_t)a * (int64_t)b; | |
| EV_SET_REG1_ACC(*rSh, *rS, t); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t a, b; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t1 = ev_multiply32_ssf(a, b, &movl); | |
| t2 = ACC + EV_SATURATE(movl, 0x7fffffffffffffff, t1); | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| EV_SET_SPEFSCR_OV(movl, 0); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t a, b; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t1 = ev_multiply32_smf(a, b, &movl); | |
| t2 = ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t a, b; | |
| a = *rA; | |
| b = *rB; | |
| t1 = (int64_t)a * (int64_t)b; | |
| t2 = ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| uint64_t t1, t2; | |
| uint32_t a, b; | |
| a = *rA; | |
| b = *rB; | |
| t1 = (uint64_t)a * (uint64_t)b; | |
| t2 = ACC + t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t a, b; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t1 = ev_multiply32_ssf(a, b, &movl); | |
| t2 = ACC - EV_SATURATE(movl, 0x7fffffffffffffff, t1); | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| EV_SET_SPEFSCR_OV(movl, 0); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t a, b; | |
| int movl; | |
| a = *rA; | |
| b = *rB; | |
| t1 = ev_multiply32_smf(a, b, &movl); | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t a, b; | |
| a = *rA; | |
| b = *rB; | |
| t1 = (int64_t)a * (int64_t)b; | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| uint64_t t1, t2; | |
| uint32_t a, b; | |
| a = *rA; | |
| b = *rB; | |
| t1 = (uint64_t)a * (uint64_t)b; | |
| t2 = ACC - t1; | |
| EV_SET_REG1_ACC(*rSh, *rS, t2); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t al, ah; | |
| int ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| t1 = (int64_t)EV_ACCHIGH + (int64_t)ah; | |
| t2 = (int64_t)EV_ACCLOW + (int64_t)al; | |
| ovh = EV_SAT_P_S32(t1); | |
| ovl = EV_SAT_P_S32(t2); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, t1 & ((uint64_t)1 << 32), 0x80000000, 0x7fffffff, t1), | |
| EV_SATURATE_ACC(ovl, t2 & ((uint64_t)1 << 32), 0x80000000, 0x7fffffff, t2)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t al, ah; | |
| al = *rA; | |
| ah = *rAh; | |
| t1 = (int64_t)EV_ACCHIGH + (int64_t)ah; | |
| t2 = (int64_t)EV_ACCLOW + (int64_t)al; | |
| 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: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS); | |
| 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 | |
| int64_t t1, t2; | |
| uint32_t al, ah; | |
| int ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| t1 = (int64_t)EV_ACCHIGH + (int64_t)ah; | |
| t2 = (int64_t)EV_ACCLOW + (int64_t)al; | |
| ovh = EV_SAT_P_U32(t1); | |
| ovl = EV_SAT_P_U32(t2); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0xffffffff, t1), | |
| 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: ACC = %08x.%08x; *rSh = %08x; *rS = %08x\n", (int)(ACC >> 32), (int)ACC, *rSh, *rS); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint64_t t1, t2; | |
| uint32_t al, ah; | |
| al = *rA; | |
| ah = *rAh; | |
| t1 = (uint64_t)EV_ACCHIGH + (uint64_t)ah; | |
| t2 = EV_ACCLOW + al; | |
| EV_SET_REG2_ACC(*rSh, *rS, t1, t2); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t al, ah; | |
| int ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| t1 = (int64_t)EV_ACCHIGH - (int64_t)ah; | |
| t2 = (int64_t)EV_ACCLOW - (int64_t)al; | |
| ovh = EV_SAT_P_S32(t1); | |
| ovl = EV_SAT_P_S32(t2); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE_ACC(ovh, t1, 0x80000000, 0x7fffffff, t1), | |
| EV_SATURATE_ACC(ovl, t2, 0x80000000, 0x7fffffff, t2)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| int64_t t1, t2; | |
| int32_t al, ah; | |
| al = *rA; | |
| ah = *rAh; | |
| t1 = (int64_t)EV_ACCHIGH - (int64_t)ah; | |
| t2 = (int64_t)EV_ACCLOW - (int64_t)al; | |
| EV_SET_REG2_ACC(*rSh, *rS, t1, t2); | |
| 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 | |
| int64_t t1, t2; | |
| uint32_t al, ah; | |
| int ovl, ovh; | |
| al = *rA; | |
| ah = *rAh; | |
| t1 = (int64_t)EV_ACCHIGH - (int64_t)ah; | |
| t2 = (int64_t)EV_ACCLOW - (int64_t)al; | |
| ovh = EV_SAT_P_U32(t1); | |
| ovl = EV_SAT_P_U32(t2); | |
| EV_SET_REG2_ACC(*rSh, *rS, EV_SATURATE(ovh, 0, t1), | |
| EV_SATURATE(ovl, 0, t2)); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint64_t t1, t2; | |
| uint32_t al, ah; | |
| al = *rA; | |
| ah = *rAh; | |
| t1 = (uint64_t)EV_ACCHIGH - (uint64_t)ah; | |
| t2 = (uint64_t)EV_ACCLOW - (uint64_t)al; | |
| EV_SET_REG2_ACC(*rSh, *rS, t1, t2); | |
| 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 | |
| EV_SET_REG2_ACC(*rSh, *rS, *rAh, *rA); | |
| 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 | |
| int32_t dividendh, dividendl, divisorh, divisorl; | |
| int32_t w1, w2; | |
| int ovh, ovl; | |
| dividendh = *rAh; | |
| dividendl = *rA; | |
| divisorh = *rBh; | |
| divisorl = *rB; | |
| if (dividendh < 0 && divisorh == 0) { | |
| w1 = 0x80000000; | |
| ovh = 1; | |
| } else if (dividendh > 0 && divisorh == 0) { | |
| w1 = 0x7fffffff; | |
| ovh = 1; | |
| } else if (dividendh == 0x80000000 && divisorh == -1) { | |
| w1 = 0x7fffffff; | |
| ovh = 1; | |
| } else { | |
| w1 = dividendh / divisorh; | |
| ovh = 0; | |
| } | |
| if (dividendl < 0 && divisorl == 0) { | |
| w2 = 0x80000000; | |
| ovl = 1; | |
| } else if (dividendl > 0 && divisorl == 0) { | |
| w2 = 0x7fffffff; | |
| ovl = 1; | |
| } else if (dividendl == 0x80000000 && divisorl == -1) { | |
| w2 = 0x7fffffff; | |
| ovl = 1; | |
| } else { | |
| w2 = dividendl / divisorl; | |
| ovl = 0; | |
| } | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| 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 | |
| uint32_t dividendh, dividendl, divisorh, divisorl; | |
| uint32_t w1, w2; | |
| int ovh, ovl; | |
| dividendh = *rAh; | |
| dividendl = *rA; | |
| divisorh = *rBh; | |
| divisorl = *rB; | |
| if (divisorh == 0) { | |
| w1 = 0xffffffff; | |
| ovh = 1; | |
| } else { | |
| w1 = dividendh / divisorh; | |
| ovh = 0; | |
| } | |
| if (divisorl == 0) { | |
| w2 = 0xffffffff; | |
| ovl = 1; | |
| } else { | |
| w2 = dividendl / divisorl; | |
| ovl = 0; | |
| } | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| EV_SET_SPEFSCR_OV(ovl, ovh); | |
| PPC_INSN_INT_SPR(RS_BITMASK, RA_BITMASK, spr_spefscr); | |
| # | |
| # 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 | |
| uint32_t w1, w2; | |
| w1 = *rAh & 0x7fffffff; | |
| w2 = *rA & 0x7fffffff; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rAh | 0x80000000; | |
| w2 = *rA | 0x80000000; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rAh; | |
| w2 = *rA; | |
| w1 = (w1 & 0x7fffffff) | ((~w1) & 0x80000000); | |
| w2 = (w2 & 0x7fffffff) | ((~w2) & 0x80000000); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| 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); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| 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); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| 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); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int32_t w1, w2; | |
| 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); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| sim_fpu al, ah, bl, bh; | |
| int w, ch, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&ah, *rAh); | |
| sim_fpu_32to (&bl, *rB); | |
| sim_fpu_32to (&bh, *rBh); | |
| if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finv); | |
| if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finvh); | |
| if (sim_fpu_is_gt(&ah, &bh)) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (sim_fpu_is_gt(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, ah, bl, bh; | |
| int w, ch, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&ah, *rAh); | |
| sim_fpu_32to (&bl, *rB); | |
| sim_fpu_32to (&bh, *rBh); | |
| if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finv); | |
| if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finvh); | |
| if (sim_fpu_is_lt(&ah, &bh)) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (sim_fpu_is_lt(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, ah, bl, bh; | |
| int w, ch, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&ah, *rAh); | |
| sim_fpu_32to (&bl, *rB); | |
| sim_fpu_32to (&bh, *rBh); | |
| if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finv); | |
| if (EV_IS_INFDENORMNAN(&ah) || EV_IS_INFDENORMNAN(&bh)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finvh); | |
| if (sim_fpu_is_eq(&ah, &bh)) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (sim_fpu_is_eq(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, ah, bl, bh; | |
| int w, ch, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&ah, *rAh); | |
| sim_fpu_32to (&bl, *rB); | |
| sim_fpu_32to (&bh, *rBh); | |
| if (sim_fpu_is_gt(&ah, &bh)) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (sim_fpu_is_gt(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, ah, bl, bh; | |
| int w, ch, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&ah, *rAh); | |
| sim_fpu_32to (&bl, *rB); | |
| sim_fpu_32to (&bh, *rBh); | |
| if (sim_fpu_is_lt(&ah, &bh)) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (sim_fpu_is_lt(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, ah, bl, bh; | |
| int w, ch, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&ah, *rAh); | |
| sim_fpu_32to (&bl, *rB); | |
| sim_fpu_32to (&bh, *rBh); | |
| if (sim_fpu_is_eq(&ah, &bh)) | |
| ch = 1; | |
| else | |
| ch = 0; | |
| if (sim_fpu_is_eq(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = ch << 3 | cl << 2 | (ch | cl) << 1 | (ch & cl); | |
| CR_SET(BF, w); | |
| 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 | |
| uint32_t f, w1, w2; | |
| sim_fpu b; | |
| sim_fpu_u32to (&b, *rBh, sim_fpu_round_default); | |
| sim_fpu_to32 (&w1, &b); | |
| sim_fpu_u32to (&b, *rB, sim_fpu_round_default); | |
| sim_fpu_to32 (&w2, &b); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| sim_fpu b; | |
| sim_fpu_32to (&b, *rBh); | |
| sim_fpu_to32u (&w1, &b, sim_fpu_round_zero); | |
| sim_fpu_32to (&b, *rB); | |
| sim_fpu_to32u (&w2, &b, sim_fpu_round_zero); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int32_t w1, w2; | |
| sim_fpu b, x, y; | |
| sim_fpu_i32to (&b, *rBh, sim_fpu_round_default); | |
| sim_fpu_to32 (&w1, &b); | |
| sim_fpu_i32to (&b, *rB, sim_fpu_round_default); | |
| sim_fpu_to32 (&w2, &b); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2, bh, bl; | |
| sim_fpu b, x, y; | |
| bh = *rBh; | |
| if (bh == 0xffffffff) | |
| sim_fpu_to32 (&w1, &sim_fpu_one); | |
| else { | |
| sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default); | |
| sim_fpu_u32to (&y, bh, sim_fpu_round_default); | |
| sim_fpu_div (&b, &y, &x); | |
| sim_fpu_to32 (&w1, &b); | |
| } | |
| bl = *rB; | |
| if (bl == 0xffffffff) | |
| sim_fpu_to32 (&w2, &sim_fpu_one); | |
| else { | |
| sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default); | |
| sim_fpu_u32to (&y, bl, sim_fpu_round_default); | |
| sim_fpu_div (&b, &y, &x); | |
| sim_fpu_to32 (&w2, &b); | |
| } | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| sim_fpu b, x, y; | |
| sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default); | |
| sim_fpu_i32to (&y, *rBh, sim_fpu_round_default); | |
| sim_fpu_div (&b, &y, &x); | |
| sim_fpu_to32 (&w1, &b); | |
| sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default); | |
| sim_fpu_i32to (&y, *rB, sim_fpu_round_default); | |
| sim_fpu_div (&b, &y, &x); | |
| sim_fpu_to32 (&w2, &b); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| sim_fpu b; | |
| sim_fpu_32to (&b, *rBh); | |
| sim_fpu_to32u (&w1, &b, sim_fpu_round_default); | |
| sim_fpu_32to (&b, *rB); | |
| sim_fpu_to32u (&w2, &b, sim_fpu_round_default); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int32_t w1, w2; | |
| sim_fpu b; | |
| sim_fpu_32to (&b, *rBh); | |
| sim_fpu_to32i (&w1, &b, sim_fpu_round_default); | |
| sim_fpu_32to (&b, *rB); | |
| sim_fpu_to32i (&w2, &b, sim_fpu_round_default); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int32_t w1, w2; | |
| sim_fpu b; | |
| sim_fpu_32to (&b, *rBh); | |
| sim_fpu_to32i (&w1, &b, sim_fpu_round_zero); | |
| sim_fpu_32to (&b, *rB); | |
| sim_fpu_to32i (&w2, &b, sim_fpu_round_zero); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| sim_fpu b, x, y; | |
| sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default); | |
| sim_fpu_32to (&y, *rBh); | |
| sim_fpu_mul (&b, &y, &x); | |
| sim_fpu_to32u (&w1, &b, sim_fpu_round_default); | |
| sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default); | |
| sim_fpu_32to (&y, *rB); | |
| sim_fpu_mul (&b, &y, &x); | |
| sim_fpu_to32u (&w2, &b, sim_fpu_round_default); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int32_t w1, w2; | |
| sim_fpu b, x, y; | |
| sim_fpu_32to (&y, *rBh); | |
| sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default); | |
| sim_fpu_mul (&b, &y, &x); | |
| sim_fpu_to32i (&w1, &b, sim_fpu_round_near); | |
| sim_fpu_32to (&y, *rB); | |
| sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default); | |
| sim_fpu_mul (&b, &y, &x); | |
| sim_fpu_to32i (&w2, &b, sim_fpu_round_near); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rSh; | |
| w2 = *rA & 0x7fffffff; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rSh; | |
| w2 = *rA | 0x80000000; | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| w1 = *rSh; | |
| w2 = (*rA & 0x7fffffff) | ((~*rA) & 0x80000000); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w; | |
| w = ev_fs_add (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor); | |
| EV_SET_REG(*rS, w); | |
| 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 | |
| uint32_t w; | |
| w = ev_fs_sub (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor); | |
| EV_SET_REG(*rS, w); | |
| 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 | |
| uint32_t w; | |
| w = ev_fs_mul (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fgh, spefscr_fxh, processor); | |
| EV_SET_REG(*rS, w); | |
| 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 | |
| uint32_t w; | |
| w = ev_fs_div (*rA, *rB, spefscr_finv, spefscr_fovf, spefscr_funf, spefscr_fdbz, spefscr_fg, spefscr_fx, processor); | |
| EV_SET_REG(*rS, w); | |
| 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 | |
| sim_fpu a, b; | |
| int w, cl; | |
| sim_fpu_32to (&a, *rA); | |
| sim_fpu_32to (&b, *rB); | |
| if (EV_IS_INFDENORMNAN(&a) || EV_IS_INFDENORMNAN(&b)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finv); | |
| if (sim_fpu_is_gt(&a, &b)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = cl << 2 | cl << 1; | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, bl; | |
| int w, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&bl, *rB); | |
| if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finv); | |
| if (sim_fpu_is_lt(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = cl << 2 | cl << 1; | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, bl; | |
| int w, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&bl, *rB); | |
| if (EV_IS_INFDENORMNAN(&al) || EV_IS_INFDENORMNAN(&bl)) | |
| EV_SET_SPEFSCR_BITS(spefscr_finv); | |
| if (sim_fpu_is_eq(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = cl << 2 | cl << 1; | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, bl; | |
| int w, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&bl, *rB); | |
| if (sim_fpu_is_gt(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = cl << 2 | cl << 1; | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, bl; | |
| int w, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&bl, *rB); | |
| if (sim_fpu_is_lt(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = cl << 2 | cl << 1; | |
| CR_SET(BF, w); | |
| 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 | |
| sim_fpu al, bl; | |
| int w, cl; | |
| sim_fpu_32to (&al, *rA); | |
| sim_fpu_32to (&bl, *rB); | |
| if (sim_fpu_is_eq(&al, &bl)) | |
| cl = 1; | |
| else | |
| cl = 0; | |
| w = cl << 2 | cl << 1; | |
| CR_SET(BF, w); | |
| 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 | |
| int32_t f, w1, w2; | |
| sim_fpu b; | |
| w1 = *rSh; | |
| sim_fpu_i32to (&b, *rB, sim_fpu_round_default); | |
| sim_fpu_to32 (&w2, &b); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| sim_fpu b; | |
| w1 = *rSh; | |
| sim_fpu_u32to (&b, *rB, sim_fpu_round_default); | |
| sim_fpu_to32 (&w2, &b); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| sim_fpu b, x, y; | |
| w1 = *rSh; | |
| sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default); | |
| sim_fpu_i32to (&y, *rB, sim_fpu_round_default); | |
| sim_fpu_div (&b, &y, &x); | |
| sim_fpu_to32 (&w2, &b); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2, bl; | |
| sim_fpu b, x, y; | |
| w1 = *rSh; | |
| bl = *rB; | |
| if (bl == 0xffffffff) | |
| sim_fpu_to32 (&w2, &sim_fpu_one); | |
| else { | |
| sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default); | |
| sim_fpu_u32to (&y, bl, sim_fpu_round_default); | |
| sim_fpu_div (&b, &y, &x); | |
| sim_fpu_to32 (&w2, &b); | |
| } | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int64_t temp; | |
| int32_t w1, w2; | |
| sim_fpu b; | |
| w1 = *rSh; | |
| sim_fpu_32to (&b, *rB); | |
| sim_fpu_to32i (&w2, &b, sim_fpu_round_default); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| int64_t temp; | |
| int32_t w1, w2; | |
| sim_fpu b; | |
| w1 = *rSh; | |
| sim_fpu_32to (&b, *rB); | |
| sim_fpu_to32i (&w2, &b, sim_fpu_round_zero); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint64_t temp; | |
| int32_t w1, w2; | |
| sim_fpu b; | |
| w1 = *rSh; | |
| sim_fpu_32to (&b, *rB); | |
| sim_fpu_to32u (&w2, &b, sim_fpu_round_default); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint64_t temp; | |
| int32_t w1, w2; | |
| sim_fpu b; | |
| w1 = *rSh; | |
| sim_fpu_32to (&b, *rB); | |
| sim_fpu_to32u (&w2, &b, sim_fpu_round_zero); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| sim_fpu b, x, y; | |
| w1 = *rSh; | |
| sim_fpu_32to (&y, *rB); | |
| sim_fpu_u32to (&x, 0x80000000, sim_fpu_round_default); | |
| sim_fpu_mul (&b, &y, &x); | |
| sim_fpu_to32i (&w2, &b, sim_fpu_round_default); | |
| sim_fpu_to32 (&w2, &b); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| uint32_t w1, w2; | |
| sim_fpu b, x, y; | |
| w1 = *rSh; | |
| sim_fpu_u64to (&x, 0x100000000, sim_fpu_round_default); | |
| sim_fpu_32to (&y, *rB); | |
| sim_fpu_mul (&b, &y, &x); | |
| sim_fpu_to32u (&w2, &b, sim_fpu_round_default); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| PPC_INSN_INT(RS_BITMASK, RB_BITMASK, 0); | |
| # | |
| # 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 | |
| uint64_t m; | |
| unsigned_word b; | |
| unsigned_word EA; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| m = MEM(unsigned, EA, 8); | |
| 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); | |
| 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 | |
| uint64_t m; | |
| unsigned_word b; | |
| unsigned_word EA; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| m = MEM(unsigned, EA, 8); | |
| EV_SET_REG1(*rSh, *rS, m); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w1, w2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| w1 = MEM(unsigned, EA, 4); | |
| w2 = MEM(unsigned, EA + 4, 4); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w1, w2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| w1 = MEM(unsigned, EA, 4); | |
| w2 = MEM(unsigned, EA + 4, 4); | |
| EV_SET_REG2(*rSh, *rS, w1, w2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| h1 = MEM(unsigned, EA, 2); | |
| h2 = MEM(unsigned, EA + 2, 2); | |
| h3 = MEM(unsigned, EA + 4, 2); | |
| h4 = MEM(unsigned, EA + 6, 2); | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h1 = MEM(unsigned, EA, 2); | |
| h2 = MEM(unsigned, EA + 2, 2); | |
| h3 = MEM(unsigned, EA + 4, 2); | |
| h4 = MEM(unsigned, EA + 6, 2); | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 2); | |
| h1 = MEM(unsigned, EA, 2); | |
| h2 = 0; | |
| h3 = MEM(unsigned, EA + 2, 2); | |
| h4 = 0; | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h1 = MEM(unsigned, EA, 2); | |
| h2 = 0; | |
| h3 = MEM(unsigned, EA + 2, 2); | |
| h4 = 0; | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 2); | |
| h1 = 0; | |
| h2 = MEM(unsigned, EA, 2); | |
| h3 = 0; | |
| h4 = MEM(unsigned, EA + 2, 2); | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h1 = 0; | |
| h2 = MEM(unsigned, EA, 2); | |
| h3 = 0; | |
| h4 = MEM(unsigned, EA + 2, 2); | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 2); | |
| h2 = MEM(unsigned, EA, 2); | |
| if (h2 & 0x8000) | |
| h1 = 0xffff; | |
| else | |
| h1 = 0; | |
| h4 = MEM(unsigned, EA + 2, 2); | |
| if (h4 & 0x8000) | |
| h3 = 0xffff; | |
| else | |
| h3 = 0; | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h2 = MEM(unsigned, EA, 2); | |
| if (h2 & 0x8000) | |
| h1 = 0xffff; | |
| else | |
| h1 = 0; | |
| h4 = MEM(unsigned, EA + 2, 2); | |
| if (h4 & 0x8000) | |
| h3 = 0xffff; | |
| else | |
| h3 = 0; | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h3, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w1; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 2); | |
| w1 = MEM(unsigned, EA, 4); | |
| EV_SET_REG2(*rSh, *rS, w1, w1); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w1; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| w1 = MEM(unsigned, EA, 4); | |
| EV_SET_REG2(*rSh, *rS, w1, w1); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 2); | |
| h1 = MEM(unsigned, EA, 2); | |
| h2 = MEM(unsigned, EA + 2, 2); | |
| EV_SET_REG4(*rSh, *rS, h1, h1, h2, h2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h1 = MEM(unsigned, EA, 2); | |
| h2 = MEM(unsigned, EA + 2, 2); | |
| EV_SET_REG4(*rSh, *rS, h1, h1, h2, h2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 1); | |
| h = MEM(unsigned, EA, 2); | |
| EV_SET_REG4(*rSh, *rS, h, 0, h, 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h = MEM(unsigned, EA, 2); | |
| EV_SET_REG4(*rSh, *rS, h, 0, h, 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 1); | |
| h = MEM(unsigned, EA, 2); | |
| EV_SET_REG4(*rSh, *rS, 0, h, 0, h); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h = MEM(unsigned, EA, 2); | |
| EV_SET_REG4(*rSh, *rS, 0, h, 0, h); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 1); | |
| h2 = MEM(unsigned, EA, 2); | |
| if (h2 & 0x8000) | |
| h1 = 0xffff; | |
| else | |
| h1 = 0; | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h1, h2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h2 = MEM(unsigned, EA, 2); | |
| if (h2 & 0x8000) | |
| h1 = 0xffff; | |
| else | |
| h1 = 0; | |
| EV_SET_REG4(*rSh, *rS, h1, h2, h1, h2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| STORE(EA, 4, (*rSh)); | |
| STORE(EA + 4, 4, (*rS)); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| STORE(EA, 4, (*rSh)); | |
| STORE(EA + 4, 4, (*rS)); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w1, w2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| w1 = *rSh; | |
| w2 = *rS; | |
| STORE(EA + 0, 4, w1); | |
| STORE(EA + 4, 4, w2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w1, w2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| w1 = *rSh; | |
| w2 = *rS; | |
| STORE(EA + 0, 4, w1); | |
| STORE(EA + 4, 4, w2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| h1 = EV_HIHALF(*rSh); | |
| h2 = EV_LOHALF(*rSh); | |
| h3 = EV_HIHALF(*rS); | |
| h4 = EV_LOHALF(*rS); | |
| STORE(EA + 0, 2, h1); | |
| STORE(EA + 2, 2, h2); | |
| STORE(EA + 4, 2, h3); | |
| STORE(EA + 6, 2, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2, h3, h4; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h1 = EV_HIHALF(*rSh); | |
| h2 = EV_LOHALF(*rSh); | |
| h3 = EV_HIHALF(*rS); | |
| h4 = EV_LOHALF(*rS); | |
| STORE(EA + 0, 2, h1); | |
| STORE(EA + 2, 2, h2); | |
| STORE(EA + 4, 2, h3); | |
| STORE(EA + 6, 2, h4); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| w = *rSh; | |
| STORE(EA, 4, w); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| w = *rSh; | |
| STORE(EA, 4, w); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| w = *rS; | |
| STORE(EA, 4, w); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint32_t w; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| w = *rS; | |
| STORE(EA, 4, w); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| h1 = EV_HIHALF(*rSh); | |
| h2 = EV_HIHALF(*rS); | |
| STORE(EA + 0, 2, h1); | |
| STORE(EA + 2, 2, h2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h1 = EV_HIHALF(*rSh); | |
| h2 = EV_HIHALF(*rS); | |
| STORE(EA + 0, 2, h1); | |
| STORE(EA + 2, 2, h2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + (UIMM << 3); | |
| h1 = EV_LOHALF(*rSh); | |
| h2 = EV_LOHALF(*rS); | |
| STORE(EA + 0, 2, h1); | |
| STORE(EA + 2, 2, h2); | |
| 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 | |
| unsigned_word b; | |
| unsigned_word EA; | |
| uint16_t h1, h2; | |
| if (RA_is_0) b = 0; | |
| else b = *rA; | |
| EA = b + *rB; | |
| h1 = EV_LOHALF(*rSh); | |
| h2 = EV_LOHALF(*rS); | |
| STORE(EA + 0, 2, h1); | |
| STORE(EA + 2, 2, h2); | |
| PPC_INSN_INT(RS_BITMASK, (RA_BITMASK & ~1) | RB_BITMASK, 0); | |
| # | |
| # 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 | |
| if (CR & (1 << (31 - (unsigned)CRB))) | |
| if (RA_is_0) | |
| EV_SET_REG1(*rSh, *rS, 0); | |
| else | |
| EV_SET_REG2(*rSh, *rS, *rAh, *rA); | |
| else | |
| EV_SET_REG2(*rSh, *rS, *rBh, *rB); | |
| PPC_INSN_INT(RS_BITMASK, RA_BITMASK | RB_BITMASK, 0); |