OpenE2K
/
binutils-gdb
12
0
Fork 0
Code Issues Pull Requests Releases Wiki Activity
binutils-gdb/sim/mips/mdmx.igen

1368 lines
27 KiB
C
Raw Blame History

// -*- C -*-
// Media Instructions
// ------------------
// Ref: http://www.sgi.com/MIPS/arch/ISA5/MDMXspec.pdf
// Note: For OB instructions, the sel field is deduced by special
// handling of the "vt" operand.
// If vt is:
// of the form $vt[0], then sel is 0000
// of the form $vt[1], then sel is 0001
// of the form $vt[2], then sel is 0010
// of the form $vt[3], then sel is 0011
// of the form $vt[4], then sel is 0100
// of the form $vt[5], then sel is 0101
// of the form $vt[6], then sel is 0110
// of the form $vt[7], then sel is 0111
// Normal register specifier, then sel is 1011
// Constant, then sel is 1111
//
// VecAcc is the Vector Accumulator.
// This accumulator is organized as 8X24 bit (192 bit) register.
// This accumulator holds only signed values.
// Verify that the instruction is valid for the curent Architecture
// If valid, return the scale (log nr bits) of a vector element
// as determined by SEL.
:function:64,f::int:get_scale:int sel
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
#if 0
switch (my_index X STATE_ARCHITECTURE)
{
}
#endif
switch (sel & 0x7)
{
case 0:
case 2:
case 4:
case 6:
/* octal byte - ssss0 */
return 0;
case 1:
case 5:
/* quad halfword - sss01 */
return 1;
case 3:
/* bi word - ss011 */
semantic_illegal (CPU_, cia);
return 2;
case 7:
/* long - ss111 */
semantic_illegal (CPU_, cia);
return 3;
default:
abort ();
return -1;
}
}
// Fetch/Store VALUE in ELEMENT of vector register FPR.
// The the of the element determined by SCALE.
:function:64,f::signed:value_vr:int scale, int fpr, int el
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
switch (FPR_STATE[fpr])
{
case fmt_uninterpreted:
FPR_STATE[fpr] = fmt_long;
break;
case fmt_long:
case fmt_unknown:
break;
default:
sim_io_eprintf (SD, "Vector %d format invalid (PC = 0x%08lx)\n",
fpr, (long) CIA);
FPR_STATE[fpr] = fmt_unknown;
}
switch (scale)
{
case 0:
{
signed8 value = *A1_8 (&FGR[fpr], 7 - el);
return value;
}
case 1:
{
signed16 value = *A2_8 (&FGR[fpr], 3 - el);
return value;
}
default:
abort;
}
return 0;
}
:function:64,f::void:store_vr:int scale, int fpr, int element, signed value
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
switch (FPR_STATE[fpr])
{
case fmt_uninterpreted:
FPR_STATE[fpr] = fmt_long;
break;
case fmt_long:
case fmt_unknown:
break;
default:
sim_io_eprintf (SD, "Vector %d format invalid (PC = 0x%08lx)\n",
fpr, (long) cia);
FPR_STATE[fpr] = fmt_unknown;
}
switch (scale)
{
case 0:
{
*A1_8 (&FGR[fpr], 7 - element) = value;
break;
}
case 1:
{
*A2_8 (&FGR[fpr], 3 - element) = value;
break;
}
default:
abort ();
}
}
// Select a value from onr of FGR[VT][ELEMENT], VT and GFR[VT][CONST]
// according to SEL
:function:64,f::unsigned:select_vr:int sel, int vt, int element
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
switch (sel)
{
/* element select - 0xxxx */
case 0x00: /* 0 xxx 0 */
case 0x02:
case 0x04:
case 0x06:
case 0x08:
case 0x0a:
case 0x0c:
case 0x0e:
return value_vr (SD_, 0, vt, sel >> 1);
case 0x01: /* 0 xx 01 */
case 0x05:
case 0x09:
case 0x0d:
return value_vr (SD_, 1, vt, sel >> 2);
case 0x03: /* 0 x 011 */
case 0x0b:
return value_vr (SD_, 2, vt, sel >> 3);
case 0x07: /* 0 x 111 */
case 0x0f:
return value_vr (SD_, 3, vt, sel >> 4);
/* select vector - 10xxx */
case 0x16: /* 10 11 0 */
return value_vr (SD_, 0, vt, element);
case 0x15: /* 10 1 01 */
return value_vr (SD_, 1, vt, element);
case 0x13: /* 10 011 */
return value_vr (SD_, 2, vt, element);
case 0x17: /* 10 111 */
return value_vr (SD_, 3, vt, element);
/* select immediate - 11xxx */
case 0x1e: /* 11 11 0 */
case 0x1d: /* 11 1 01 */
case 0x1b: /* 11 011 */
case 0x1f: /* 11 111 */
return vt;
}
return 0;
}
// Saturate (clamp) the signed value to (8 << SCALE) bits.
:function:64,f::signed:Clamp:int scale, signed value
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
switch (scale)
{
case 0:
{
if (value != (signed8) value)
{
if (value > 0)
return 0x7f;
else
return 0x80;
}
return value & 0xff;
}
case 1:
{
if (value != (signed16) value)
{
if (value > 0)
return 0x7fff;
else
return 0x8000;
}
return value & 0xffff;
}
default:
abort ();
return 0;
}
}
// Access a single bit of the floating point CC register.
:function:64,f::void:store_cc:int i, int value
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
SETFCC (i, value);
}
:function:64,f::int:value_cc:int i
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
return GETFCC (i);
}
// Read/write the accumulator
:function:64,f::signed64:value_acc:int scale, int element
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
signed64 value = 0;
switch (scale)
{
case 0:
value |= (unsigned64) (unsigned8) CPU->acc [element * 3 + 0];
value |= (unsigned64) (unsigned8) CPU->acc [element * 3 + 1] << 8;
value |= (signed64) (signed8) CPU->acc [element * 3 + 2] << 16;
break;
case 1:
value |= (unsigned64) (unsigned8) CPU->acc [element * 3 + 0];
value |= (unsigned64) (unsigned8) CPU->acc [element * 3 + 1] << 8;
value |= (unsigned64) (unsigned8) CPU->acc [element * 3 + 2] << 16;
value |= (unsigned64) (unsigned8) CPU->acc [element * 3 + 3] << 24;
value |= (unsigned64) (unsigned8) CPU->acc [element * 3 + 4] << 32;
value |= (signed64) (signed8) CPU->acc [element * 3 + 5] << 40;
break;
}
return value;
}
:function:64,f::void:store_acc:int scale, int element, signed64 value
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
switch (scale)
{
case 0:
CPU->acc [element * 3 + 0] = value >> 0;
CPU->acc [element * 3 + 1] = value >> 8;
CPU->acc [element * 3 + 2] = value >> 16;
break;
case 1:
CPU->acc [element * 3 + 0] = value >> 0;
CPU->acc [element * 3 + 1] = value >> 8;
CPU->acc [element * 3 + 2] = value >> 16;
CPU->acc [element * 3 + 3] = value >> 24;
CPU->acc [element * 3 + 4] = value >> 32;
CPU->acc [element * 3 + 5] = value >> 40;
break;
}
}
// Formatting
:%s:64,f:::VT:int sel, int vt
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
static char buf[20];
if (sel < 8)
sprintf (buf, "v%d[%d]", vt, sel);
else if (sel == 0x13)
sprintf (buf, "v%d", vt);
else if (sel == 0x1f)
sprintf (buf, "%d", vt);
else
sprintf (buf, "(invalid)");
return buf;
}
:%s:64,f:::SEL:int sel
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
switch (sel & 7)
{
case 0:
case 2:
case 4:
case 6:
return "ob";
case 1:
case 5:
return "qh";
case 3:
return "bw";
default:
return "l";
}
}
// Vector Add.
010010,5.SEL,5.VT,5.VS,5.VD,001011::64,f::ADD.fmt
"add.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
Clamp (SD_, scale,
(value_vr (SD_, scale, VS, i)
+ select_vr (SD_, SEL, VT, i))));
}
// Accumulate Vector Add
010010,5.SEL,5.VT,5.VS,1,0000,110111::64,f::ADDA.fmt
"adda.%s<SEL> v<VD>, v<VS>"
*mdmx:
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, i,
(value_acc (SD_, scale, i)
+ (signed64) value_vr (SD_, scale, VS, i)
+ (signed64) select_vr (SD_, SEL, VT, i)));
}
// Load Vector Add
010010,5.SEL,5.VT,5.VS,0,0000,110111::64,f::ADDA.fmt
"addl.%s<SEL> v<VD>, v<VS>"
*mdmx:
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, i,
((signed64) value_vr (SD_, scale, VS, i)
+ (signed64) select_vr (SD_, SEL, VT, i)));
}
// Vector align, Constant Alignment
:function:64,f::void:ByteAlign:int vd, int imm, int vs, int vt
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int s = imm * 8;
unsigned64 rs = ValueFPR (vs, fmt_long);
unsigned64 rt = ValueFPR (vt, fmt_long);
unsigned64 rd;
if (BigEndianCPU)
{
/* (vs || vt) [127 - S .. 64 - S] */
if (s == 0)
rd = rs;
else
rd = (MOVED64 (rs, 64 - s, 0, 63, s)
| EXTRACTED64 (rt, 63, 64 - s));
}
else
{
/* (vs || vt) [63 + S .. S] */
if (s == 0)
rd = rt;
else
rd = (MOVED64 (rs, s, 0, 63, 64 - s)
| EXTRACTED64 (rt, 63, s));
}
StoreFPR (vd, fmt_long, rd);
}
010010,00,3.IMM,5.VT,5.VS,5.VD,0110,X,0::64,f::ALNI.fmt
"alni.%s<FMT#X> v<VD>, v<VS>, v<VT>, <IMM>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
ByteAlign (SD_, VD, IMM, VS, VT);
}
// Vector align, Variable Alignment
010010,5.RS,5.VT,5.VS,5.VD,0110,X,1::64,f::ALNV.fmt
"alnv.%s<FMT#X> v<VD>, v<VS>, v<VT>, r<RS>"
*mdmx:
{
ByteAlign (SD_, VD, GPR[RS], VS, VT);
}
// Vector And.
010010,5.SEL,5.VT,5.VS,5.VD,001100::64,f::AND.fmt
"and.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
(value_vr (SD_, scale, VS, i)
& select_vr (SD_, SEL, VT, i)));
}
// Vector Compare Equal.
010010,5.SEL,5.VT,5.VS,00000,000001::64,f::C.EQ.fmt
"c.EQ.%s<SEL> v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_cc (SD_, i,
(value_vr (SD_, scale, VS, i)
== select_vr (SD_, SEL, VT, i)));
}
// Vector Compare Less Than or Equal.
010010,5.SEL,5.VT,5.VS,00000,000101::64,f::C.LE.fmt
"c.le.%s<SEL> v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_cc (SD_, i,
(value_vr (SD_, scale, VS, i)
<= select_vr (SD_, SEL, VT, i)));
}
// Vector Compare Less Than.
010010,5.SEL,5.VT,5.VS,00000,000100::64,f::C.LT.fmt
"c.lt.%s<SEL> v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_cc (SD_, i,
(value_vr (SD_, scale, VS, i)
< select_vr (SD_, SEL, VT, i)));
}
// Vector Maximum.
:function:64,f::signed:Maxi:int scale, signed l, signed r
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
if (l < r)
return r;
else
return l;
}
010010,5.SEL,5.VT,5.VS,5.VD,000111::64,f::MAX.fmt
"max.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
Maxi (SD_, scale,
value_vr (SD_, scale, VS, i),
select_vr (SD_, SEL, VT, i)));
}
// Vector Minimum.
:function:64,f::signed:Mini:int scale, signed l, signed r
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
if (l < r)
return l;
else
return r;
}
010010,5.SEL,5.VT,5.VS,5.VD,000110::64,f::MIN.fmt
"min.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
Mini (SD_, scale,
value_vr (SD_, scale, VS, i),
select_vr (SD_, SEL, VT, i)));
}
// Vector Sign.
:function:64,f::signed:Sign:int scale, signed l, signed r
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
if (l >= 0)
return r;
else if (r >= 0)
return -r;
else
{
/* watch for overflow of MIN_INT */
switch (scale)
{
case 0:
if ((r & 0xff) == 0x80)
return 0x7ff;
else
return -r;
case 1:
if ((r & 0xffff) == 0x8000)
return 0x7ffff;
else
return -r;
default:
abort ();
}
return -r;
}
}
010010,5.SEL,5.VT,5.VS,5.VD,000110::64,f::MSGN.fmt
"msgn.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
{
int i;
int scale = get_scale (SD_, SEL);
if ((SEL & 1) != 1)
/* only QH allowed */
semantic_illegal (sd, cia);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
Sign (SD_, scale,
value_vr (SD_, scale, VS, i),
select_vr (SD_, SEL, VT, i)));
}
// Vector Multiply.
010010,5.SEL,5.VT,5.VS,5.VD,110000::64,f::MUL.fmt
"mul.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
Clamp (SD_, scale,
(value_vr (SD_, scale, VS, i)
* select_vr (SD_, SEL, VT, i))));
}
// Accumulate Vector Multiply
010010,5.SEL,5.VT,5.VS,00000,110011::64,f::MULA.fmt
"mula.%s<SEL> v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, i,
(value_acc (SD_, scale, i)
+ ((signed64) value_vr (SD_, scale, VS, i)
* (signed64) select_vr (SD_, SEL, VT, i))));
}
// Add Vector Multiply to Accumulator.
010010,5.SEL,5.VT,5.VS,10000,110011::64,f::MULL.fmt
"mull.%s<SEL> v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, i,
((signed64) value_vr (SD_, scale, VS, i)
* (signed64) select_vr (SD_, SEL, VT, i)));
}
// Subtract Vector Multiply from Accumulator
010010,5.SEL,5.VT,5.VS,00000,110010::64,f::MULS.fmt
"muls.%s<SEL> v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, i,
(value_acc (SD_, scale, i)
- ((signed64) value_vr (SD_, scale, VS, i)
* (signed64) select_vr (SD_, SEL, VT, i))));
}
// Load Negative Vector Multiply
010010,5.SEL,5.VT,5.VS,10000,110010::64,f::MULSL.fmt
"mulsl.%s<SEL> v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, i,
- ((signed64) value_vr (SD_, scale, VS, i)
* (signed64) select_vr (SD_, SEL, VT, i)));
}
// Vector Nor.
010010,5.SEL,5.VT,5.VS,5.VD,001111::64,f::NOR.fmt
"nor.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
~(value_vr (SD_, scale, VS, i)
| select_vr (SD_, SEL, VT, i)));
}
// Vector Or.
010010,5.SEL,5.VT,5.VS,5.VD,001110::64,f::OR.fmt
"or.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
(value_vr (SD_, scale, VS, i)
| select_vr (SD_, SEL, VT, i)));
}
// Select Vector Elements - False
010010,5.SEL,5.VT,5.VS,5.VD,000010::64,f::PICKF.fmt
"pickf.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
(value_cc (SD_, i) == 0
? value_vr (SD_, scale, VS, i)
: select_vr (SD_, SEL, VT, i)));
}
// Select Vector Elements - True
010010,5.SEL,5.VT,5.VS,5.VD,000011::64,f::PICKT.fmt
"pickt.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
(value_cc (SD_, i) != 0
? value_vr (SD_, scale, VS, i)
: select_vr (SD_, SEL, VT, i)));
}
// Scale, Round and Clamp Accumulator
:%s:64,f:::RND:int rnd
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
switch (rnd)
{
case 0:
return "zu";
case 1:
return "nau";
case 2:
return "neu";
case 4:
return "rzs";
case 5:
return "nas";
case 6:
return "nes";
default:
return "(invalid)";
}
}
:function:64,f::signed:ScaleRoundClamp:int scale, int rnd, signed val, signed shift
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int halfway = (1 << (shift - 1));
/* must be positive */
if (shift < 0)
return 0;
/* too much shift? */
switch (scale)
{
case 0:
if (shift >= 24)
return 0;
break;
case 1:
if (shift >= 48)
return 0;
break;
default:
abort ();
}
/* round */
switch (rnd & 3)
{
case 0: /* round towards zero */
break;
case 1: /* nearest, halfaway rounds away from zero */
if (val >= 0)
val += halfway;
else
val -= halfway;
break;
case 2: /* nearest, halfway rounds to even! */
if (val >= 0)
{
if (val & (halfway << 1))
val += halfway;
else
val += (halfway - 1);
}
else
{
if (val & (halfway << 1))
val -= halfway;
else
val -= (halfway - 1);
}
default:
abort ();
}
/* shift */
val >>= shift;
/* clamp */
switch (rnd & 4)
{
case 0:
/* unsigned clamp */
if (val < 0)
val = 0;
else
switch (scale)
{
case 0:
if (val > 0xff)
val = 0xff;
break;
case 1:
if (val > 0xffff)
val = 0xffff;
break;
}
break;
case 8:
/* normal signed clamp */
val = Clamp (_SD, scale, val);
break;
}
return val;
}
010010,5.SEL,5.VT,00000,5.VD,100,3.RND::64,f::Rx.fmt
"r%s<RND>.%s<SEL> v<VD>, v<VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
ScaleRoundClamp (SD_, scale, RND,
value_acc (SD_, scale, i),
select_vr (SD_, SEL, VT, i)));
}
// Vector Read Accumulator Low.
010010,0000,1.SEL,00000,00000,5.VD,111111::64,f::RACL.fmt
"racl.%s<SEL> v<VD>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
EXTRACTED (value_acc (SD_, scale, i),
(8 << scale) - 1,
0));
}
// Vector Read Accumulator Middle.
010010,0100,1.SEL,00000,00000,5.VD,111111::64,f::RACM.fmt
"racm.%s<SEL> v<VD>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
EXTRACTED (value_acc (SD_, scale, i),
(16 << scale) - 1,
(8 << scale) - 0));
}
// Vector Read Accumulator High.
010010,1000,1.SEL,00000,00000,5.VD,111111::64,f::RACH.fmt
"rach.%s<SEL> v<VD>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
EXTRACTED (value_acc (SD_, scale, i),
(24 << scale) - 1,
(16 << scale) - 0));
}
// Vector Element Shuffle.
010010,0000,0,5.VT,5.VS,5.VD,011111::64,f::SHFL.UPUH.fmt
"shfl.upuh.%s<SEL> v<VD>, v<VS>, <VT>"
*mdmx:
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < 4; i++)
{
store_vr (SD_, 1, VD, i,
value_vr (SD_, 0, VS, i + 4) & 0xff);
}
}
010010,0001,0,5.VT,5.VS,5.VD,011111::64,f::SHFL.UPUL.fmt
"shfl.upul.%s<SEL> v<VD>, v<VS>, <VT>"
*mdmx:
{
int i;
for (i = 0; i < 4; i++)
{
store_vr (SD_, 1, VD, i,
value_vr (SD_, 0, VS, i) & 0xff);
}
}
010010,0000,0,5.VT,5.VS,5.VD,011111::64,f::SHFL.UPSH.fmt
"shfl.upsh.%s<SEL> v<VD>, v<VS>, <VT>"
*mdmx:
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < 4; i++)
{
store_vr (SD_, 1, VD, i,
value_vr (SD_, 0, VS, i + 4));
}
}
010010,0001,0,5.VT,5.VS,5.VD,011111::64,f::SHFL.UPSL.fmt
"shfl.upsl.%s<SEL> v<VD>, v<VS>, <VT>"
*mdmx:
{
int i;
for (i = 0; i < 4; i++)
{
store_vr (SD_, 1, VD, i,
value_vr (SD_, 0, VS, i));
}
}
010010,0100,1.SEL,5.VT,5.VS,5.VD,011111::64,f::SHFL.PACH.fmt
"shfl.pach.%s<SEL> v<VD>, v<VS>, <VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (4 >> scale); i++)
{
store_vr (SD_, scale, VD, i,
value_vr (SD_, scale, VT, i * 2 + 1));
store_vr (SD_, scale, VD, 1 + (4 >> scale),
value_vr (SD_, scale, VS, i * 2 + 1));
}
}
010010,0101,1.SEL,5.VT,5.VS,5.VD,011111::64,f::SHFL.PACL.fmt
"shfl.pacl.%s<SEL> v<VD>, v<VS>, <VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (4 >> scale); i++)
{
store_vr (SD_, scale, VD, i,
value_vr (SD_, scale, VT, i * 2));
store_vr (SD_, scale, VD, 1 + (4 >> scale),
value_vr (SD_, scale, VS, i * 2));
}
}
010010,0110,1.SEL,5.VT,5.VS,5.VD,011111::64,f::SHFL.MIXH.fmt
"shfl.mixh.%s<SEL> v<VD>, v<VS>, <VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (4 >> scale); i++)
{
store_vr (SD_, scale, VD, i * 2,
value_vr (SD_, scale, VT, i + (4 >> scale)));
store_vr (SD_, scale, VD, i * 2 + 1,
value_vr (SD_, scale, VS, i + (4 >> scale)));
}
}
010010,0111,1.SEL,5.VT,5.VS,5.VD,011111::64,f::SHFL.MIXL.fmt
"shfl.mixl.%s<SEL> v<VD>, v<VS>, <VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (4 >> scale); i++)
{
store_vr (SD_, scale, VD, i * 2,
value_vr (SD_, scale, VT, i));
store_vr (SD_, scale, VD, i * 2 + 1,
value_vr (SD_, scale, VS, i));
}
}
010010,100,01,5.VT,5.VS,5.VD,011111::64,f::SHFL.BFLA.fmt
"shfl.bfla.qh v<VD>, v<VS>, <VT>"
*mdmx:
{
store_vr (SD_, 1, VD, 0,
value_vr (SD_, 1, VT, 1));
store_vr (SD_, 1, VD, 1,
value_vr (SD_, 1, VS, 0));
store_vr (SD_, 1, VD, 2,
value_vr (SD_, 1, VT, 3));
store_vr (SD_, 1, VD, 3,
value_vr (SD_, 1, VS, 2));
}
010010,101,01,5.VT,5.VS,5.VD,011111::64,f::SHFL.BFLB.fmt
"shfl.bflb.qh v<VD>, v<VS>, <VT>"
*mdmx:
{
store_vr (SD_, 1, VD, 0,
value_vr (SD_, 1, VT, 3));
store_vr (SD_, 1, VD, 1,
value_vr (SD_, 1, VS, 2));
store_vr (SD_, 1, VD, 2,
value_vr (SD_, 1, VT, 1));
store_vr (SD_, 1, VD, 3,
value_vr (SD_, 1, VS, 0));
}
010010,101,01,5.VT,5.VS,5.VD,011111::64,f::SHFL.REPA.fmt
"shfl.repa.qh v<VD>, v<VS>, <VT>"
*mdmx:
{
store_vr (SD_, 1, VD, 0,
value_vr (SD_, 1, VT, 2));
store_vr (SD_, 1, VD, 1,
value_vr (SD_, 1, VT, 3));
store_vr (SD_, 1, VD, 2,
value_vr (SD_, 1, VS, 2));
store_vr (SD_, 1, VD, 3,
value_vr (SD_, 1, VS, 3));
}
010010,101,01,5.VT,5.VS,5.VD,011111::64,f::SHFL.REPB.fmt
"shfl.repb.qh v<VD>, v<VS>, <VT>"
*mdmx:
{
store_vr (SD_, 1, VD, 0,
value_vr (SD_, 1, VT, 0));
store_vr (SD_, 1, VD, 1,
value_vr (SD_, 1, VT, 1));
store_vr (SD_, 1, VD, 2,
value_vr (SD_, 1, VS, 0));
store_vr (SD_, 1, VD, 3,
value_vr (SD_, 1, VS, 1));
}
// Vector Shift Left Logical
010010,5.SEL,5.VT,5.VS,5.VD,010000::64,f::SLL.fmt
"sll.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
int mask = (4 << scale) - 1;
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
(value_vr (SD_, scale, VS, i)
<< (select_vr (SD_, SEL, VT, i) & mask)));
}
// Vector Shift Right Arithmetic
010010,5.SEL,5.VT,5.VS,5.VD,010011::64,f::SRA.fmt
"sra.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
{
int i;
int mask = (4 << scale) - 1;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
(value_vr (SD_, scale, VS, i)
>> (select_vr (SD_, SEL, VT, i) & mask)));
}
// Vector Shift Right Logical.
010010,5.SEL,5.VT,5.VS,5.VD,010010::64,f::SRL.fmt
"srl.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
int mask = (4 << scale) - 1;
int zeros = (1 << (8 << scale)) - 1;
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
((value_vr (SD_, scale, VS, i) & zeros)
>> (select_vr (SD_, SEL, VT, i) & mask)));
}
// Vector Subtract.
010010,5.SEL,5.VT,5.VS,5.VD,001010::64,f::SUB.fmt
"sub.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
(value_vr (SD_, scale, VS, i)
- select_vr (SD_, SEL, VT, i)));
}
// Accumulate Vector Difference
010010,5.SEL,5.VT,5.VS,0,0000,110110::64,f::SUBA.fmt
"suba.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, VD, i,
(value_acc (SD, scale, i)
+ (signed64) value_vr (SD_, scale, VS, i)
- (signed64) select_vr (SD_, SEL, VT, i)));
}
// Load Vector Difference
010010,5.SEL,5.VT,5.VS,1,0000,110110::64,f::SUBL.fmt
"subl.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, VD, i,
((signed64) value_vr (SD_, scale, VS, i)
- (signed64) select_vr (SD_, SEL, VT, i)));
}
// Write Accumulator High.
010010,1000,1.SEL,00000,5.VS,00000,111110::64,f::WACH.fmt
"wach.%s<SEL> v<VS>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, i,
(((signed64) value_vr (SD_, scale, VS, i) << (16 << scale))
| MASKED (value_acc (SD_, scale, i), (16 << scale) - 1, 0)));
}
// Vector Write Accumulator Low.
010010,0000,1.SEL,5.VT,5.VS,00000,111110::64,f::WACL.fmt
"wacl.%s<SEL> v<VS>, <VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_acc (SD_, scale, i,
(((signed64) value_vr (SD_, scale, VS, i) << (16 << scale))
| MASKED (value_vr (SD_, scale, VT, i),
(16 << scale) - 1, 0)));
}
// Vector Xor.
010010,5.SEL,5.VT,5.VS,5.VD,001101::64,f::XOR.fmt
"xor.%s<SEL> v<VD>, v<VS>, %s<VT#SEL,VT>"
*mdmx:
// start-sanitize-vr5400
*vr5400:
// end-sanitize-vr5400
{
int i;
int scale = get_scale (SD_, SEL);
for (i = 0; i < (8 >> scale); i++)
store_vr (SD_, scale, VD, i,
(value_vr (SD_, scale, VS, i)
^ select_vr (SD_, SEL, VT, i)));
}
Reference in New Issue View Git Blame Copy Permalink