--- /dev/null
+/****************************************************************************/
+/* */
+/* Sony Computer Entertainment CONFIDENTIAL */
+/* (C) 1997 Sony Computer Entertainment Inc. All Rights Reserved */
+/* */
+/* VU simulator */
+/* */
+/****************************************************************************/
+
+#include "vpe.h"
+#include "libvpe.h"
+#include <stdio.h>
+#include <strings.h>
+
+unsigned long _ITOP;
+unsigned long _TOP;
+unsigned long _vpepc;
+int _is_dbg;
+int _is_verb;
+int _is_dump;
+int _pgpuif;
+FILE *_fp_gpu;
+
+int _GIF_SIM_OFF;
+int _GIF_BUSY;
+int _GIF_VUCALL;
+int _GIF_VUADDR;
+
+
+/****************************************************************************/
+
+/* Some external declarations ... */
+void GpuIfKick(VectorUnitState *state, int addr);
+void opcode_analyze(u_long *opcode);
+
+#define VF state->regs.VF
+#define VI state->regs.VI
+
+void initvpe(VectorUnitState *state)
+{
+/*
+[name] initvpe
+[desc] Initialize internal status of VU simulator.
+[args] void
+[return] void
+*/
+ int i, j;
+
+ _fp_gpu = stdout;
+ VF[0][0] = 0.0;
+ VF[0][1] = 0.5;
+ VF[0][2] = -1.0;
+ VF[0][3] = 1.0;
+ VI[0] = 0;
+ eflag = 0;
+ jflag = 0;
+ peflag = 0;
+ sflag = 0;
+ pc = _vpepc;
+ jaddr = 0;
+ bp = 0xffffffff;
+ for (i = 0; i < 4; i++) {
+ for (j = 0; j < 2; j++) {
+ pipe[i][j].flag = 0;
+ }
+ }
+ for (i = 0; i < 7; i++) {
+ qpipe[i].flag = 0;
+ }
+ for (i = 0; i < 13; i++) {
+ rqpipe[i].flag = 0;
+ }
+ ipipe[0].flag = 0;
+ ipipe[1].flag = 0;
+ apipe.flag = 0;
+ Ipipe.flag = 0;
+
+ spipe.no = 0;
+ spipe.flag = 0;
+ for (i = 1; i < 16; i++) {
+ VI[i] = 0;
+ }
+ for (i = 1; i < 32; i++) {
+ for (j = 0; j < 4; j++) {
+ VF[i][j] = 0.0;
+ }
+ }
+ /* EFU internal regstars */
+ VN[8] = 1.0;
+ VN[9] = 1.0; /* S1 */
+ VN[10] = -0.166666567325592; /* S2 */
+ VN[11] = 0.008333025500178; /* S3 */
+ VN[12] = -0.000198074136279; /* S4 */
+ VN[13] = 0.000002601886990; /* S5 */
+ VN[14] = 0.999999344348907; /* T1 */
+ VN[15] = -0.333298563957214; /* T2 */
+ VN[16] = 0.199465364217758; /* T3 */
+ VN[17] = -0.139085337519646; /* T4 */
+ VN[18] = 0.096420042216778; /* T5 */
+ VN[19] = -0.055909886956215; /* T6 */
+ VN[20] = 0.021861229091883; /* T7 */
+ VN[21] = -0.004054057877511; /* T8 */
+ VN[22] = 0.7853981633974483; /* PI/4 */
+ VN[23] = 0.2499986842; /* E1 */
+ VN[24] = 0.0312575832; /* E2 */
+ VN[25] = 0.0025913712; /* E3 */
+ VN[26] = 0.0001715620; /* E4 */
+ VN[27] = 0.0000054302; /* E5 */
+ VN[28] = 0.0000006906; /* E6 */
+
+ _GIF_SIM_OFF = 0;
+ _GIF_BUSY = 0;
+ _GIF_VUCALL = 0;
+ _GIF_VUADDR = 0;
+ intr_mode = _is_dbg;
+ ecount = 0;
+}
+
+int get_dest(u_long opcode)
+{
+/*
+[name] get_dest
+[desc.] get dest field of instruction.
+[args] opcode: instruction(32bits)
+[return] dest field value(4bits)
+*/
+ return ((int) ((opcode >> 21) & 0xf));
+}
+
+int get_ft(u_long opcode)
+{
+/*
+[name] get_ft
+[desc.] get ft field of instruction
+[args] opcode: instruction(32bits)
+[return] ft field value(5bits)
+*/
+ return ((int) ((opcode >> 16) & 0x1f));
+}
+
+int get_fs(u_long opcode)
+{
+/*
+[name] get_fs
+[desc.] get fs field of instruction
+[args] opcode: instruction(32bits)
+[return] fs field value(5bits)
+*/
+ return ((int) ((opcode >> 11) & 0x1f));
+}
+
+int get_fd(u_long opcode)
+{
+/*
+[name] get_fd
+[desc.] get fd field of instruction
+[args] opcode: instruction(32bits)
+[return] fd field value(5bits)
+*/
+ return ((int) ((opcode >> 6) & 0x1f));
+}
+
+int get_bc(u_long opcode)
+{
+/*
+[name] get_bc
+[desc.] get bc field of instruction
+[args] opcode: instruction(32bit)
+[return] bc field value(2bits);
+*/
+ return ((int) (opcode & 0x3));
+}
+
+int get_ic(u_long opcode)
+{
+/*
+[name] get_ic
+[desc.] get bit25 and bit26 in instruction
+[args] opcode: instruction(32bit)
+[return] bit 25 and bit26 value(2bits)
+*/
+ return ((int) ((opcode >> 25) & 0x3));
+}
+
+int get_fsf(u_long opcode)
+{
+/*
+[name] get_fsf
+[desc.] get fsf field of instruction
+[args] opcode: instruction(32bit)
+[return] fsf field value(2bits)
+*/
+ return ((opcode >> 21) & 0x3);
+}
+
+int get_ftf(u_long opcode)
+{
+/*
+[name] get_ftf
+[desc.] get ftf field of instruction
+[args] opcode: instruction(32bit)
+[return] ftf field value(2bits)
+*/
+ return ((opcode >> 23) & 0x3);
+}
+
+void statuscheck(float arg, u_long * status, int no)
+{
+/*
+[name] statuscheck
+[desc.] FMAC status decide when FMAC calculates.
+[args] arg: calculated value by FMAC.
+ status: FMAC status pointer.
+ no: FMAC number
+[return] void
+*/
+ /* write status flag's value */
+ if (arg == 0.0)
+ *status = *status | 1;
+ if (arg < 0.0)
+ *status = *status | 2;
+ /* write MACflag's value */
+ switch (no) {
+ case 0:
+ if (arg == 0.0)
+ *status |= 0x80000;
+ if (arg < 0.0)
+ *status |= 0x800000;
+ break;
+ case 1:
+ if (arg == 0.0)
+ *status |= 0x40000;
+ if (arg < 0.0)
+ *status |= 0x400000;
+ break;
+ case 2:
+ if (arg == 0.0)
+ *status |= 0x20000;
+ if (arg < 0.0)
+ *status |= 0x200000;
+ break;
+ case 3:
+ if (arg == 0.0)
+ *status |= 0x10000;
+ if (arg < 0.0)
+ *status |= 0x100000;
+ break;
+ }
+}
+
+int hazardcheck(int fs, int ft, int dest, int type)
+{
+/*
+[name] hazardcheck
+
+ If destinatin registers in pipeline is same as source register,
+ data hazard occured.
+[args] fs: If fs field assigns source register, set source register number
+ in this argment.
+ ft: If ft field assigns source register, set souce register number
+ in this argment
+ dest: specify which units calculate
+ type: source register type
+ 1: source register is ft field
+ 2: source register is fs field
+ 3: source registers are ft and fs field
+[return] 0: hazard not occured
+ 1: hazard occured
+*/
+
+ int i, j;
+
+ for (i = 3; i >= 0; i--) {
+ for (j = 0; j < 2; j++) {
+ if (pipe[i][j].flag == 1) {
+ if (type & 0x1) {
+ if ((pipe[i][j].no == ft) && (pipe[i][j].mask | dest)) {
+ sflag = 1;
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n", pc - 1, ft);
+ return 1;
+ }
+ }
+ if (type & 0x2) {
+ if ((pipe[i][j].no == fs) && (pipe[i][j].mask | dest)) {
+ sflag = 1;
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n", pc - 1, fs);
+ return 1;
+ }
+ }
+ }
+ if (pipe[i][j].flag == 6) {
+ if (type & 0x1) {
+ if ((pipe[i][j].no == ft) && (pipe[i][j].mask | dest)) {
+ sflag = 1;
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n", pc - 1, ft);
+ return 1;
+ }
+ }
+ if (type & 0x2) {
+ if ((pipe[i][j].no == fs) && (pipe[i][j].mask | dest)) {
+ sflag = 1;
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n", pc - 1, fs);
+ return 1;
+ }
+ }
+ }
+ }
+ }
+ sflag = 0;
+ return 0;
+}
+
+int hazardcheckVI(int fs, int ft, int type)
+{
+/*
+[name] hazardcheckVI
+[desc.] data hazarde check. (VI register)
+ If destinatin registers in pipeline is same as source register,
+ data hazard occured.
+[args] fs: If fs field assigns source register, set source register number
+ in this argment.
+ ft: If ft field assigns source register, set souce register number
+ in this argment
+ type: source register type
+ 1: source register is ft field
+ 2: source register is fs field
+ 3: source registers are ft and fs field
+[return] 0: hazard not occured
+ 1: hazard occured
+*/
+
+ int i;
+
+ for (i = 1; i >= 0; i--) {
+ if (ipipe[i].flag == 1) {
+ if (type & 0x1) {
+ if (ipipe[i].no == ft) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VI%02d]\n", pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ }
+ if (type & 0x2) {
+ if (ipipe[i].no == fs) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VI%02d]\n", pc - 1, fs);
+ sflag = 1;
+ return 1;
+ }
+ }
+ }
+ }
+ sflag = 0;
+ return 0;
+}
+
+int hazardcheckFTF(int fs, int ft, int fsf, int ftf, int type)
+{
+/*
+[name] hazardcheckFTF
+[desc.] data hazarde check. (VF register)
+ If destinatin registers in pipeline is same as source register,
+ data hazard occured.
+[args] fs: If fs field assigns source register, set source register number
+ in this argment.
+ ft: If ft field assigns source register, set souce register number
+ in this argment
+ fsf: If fsf field assigns source register, set source register
+ number in this argment.
+ ftf: If ftf field assigns source register, set souce register
+ number in this argment
+ type: source register type
+ 1: source register is ft field
+ 2: source register is fs field
+ 3: source registers are ft and fs field
+[return] 0: hazard not occured
+ 1: hazard occured
+*/
+
+ int i, j;
+
+ for (i = 3; i >= 0; i--) {
+ for (j = 0; j < 2; j++) {
+ if (pipe[i][j].flag == 1) {
+ if (type & 0x1) {
+ if (pipe[i][j].no == ft) {
+ switch (ftf) {
+ case 0:
+ if (pipe[i][j].mask & DEST_X) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 1:
+ if (pipe[i][j].mask & DEST_Y) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 2:
+ if (pipe[i][j].mask & DEST_Z) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 3:
+ if (pipe[i][j].mask & DEST_W) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ }
+ }
+ }
+ if (type & 0x2) {
+ if (pipe[i][j].no == fs) {
+ switch (fsf) {
+ case 0:
+ if (pipe[i][j].mask & DEST_X) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, fs);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 1:
+ if (pipe[i][j].mask & DEST_Y) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, fs);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 2:
+ if (pipe[i][j].mask & DEST_Z) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, fs);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 3:
+ if (pipe[i][j].mask & DEST_W) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, fs);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ }
+ }
+ }
+ }
+ }
+ }
+ sflag = 0;
+ return 0;
+}
+
+int hazardcheckBC(int fs, int ft, int dest, int bc, int type)
+{
+/*
+[name] hazardcheckBC
+[desc.] data hazarde check. (VF register)
+ If destinatin registers in pipeline is same as source register,
+ data hazard occured.
+[args] fs: If fs field assigns source register, set source register number
+ in this argment.
+ ft: If ft field assigns source register, set souce register number
+ in this argment
+ dest: specify which units calculate
+ bc: specify which broadcast units
+ type: source register type
+ 1: source register is ft field
+ 2: source register is fs field
+ 3: source registers are ft and fs field
+[return] 0: hazard not occured
+ 1: hazard occured
+*/
+
+ int i, j;
+
+ for (i = 3; i >= 0; i--) {
+ for (j = 0; j < 2; j++) {
+ if ((pipe[i][j].flag == 1) || (pipe[i][j].flag == 7)) {
+ if (type & 0x1) {
+ if (pipe[i][j].no == ft) {
+ switch (bc) {
+ case 0:
+ if (pipe[i][j].mask & DEST_X) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 1:
+ if (pipe[i][j].mask & DEST_Y) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 2:
+ if (pipe[i][j].mask & DEST_Z) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ case 3:
+ if (pipe[i][j].mask & DEST_W) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n",
+ pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ break;
+ }
+ }
+ }
+ if (type & 0x2) {
+ if ((pipe[i][j].no == fs) && (pipe[i][j].mask | dest)) {
+ hc_count++;
+ if (verb_mode)
+ printf("[data hazard %04d:VF%02d]\n", pc - 1, ft);
+ sflag = 1;
+ return 1;
+ }
+ }
+ }
+ }
+ }
+ sflag = 0;
+ return 0;
+}
+
+int hazardcheckQ(void)
+{
+/*
+[name] hazardcheckQ
+[desc.] resource hazarde check. (FDIV unit)
+ If instruction use FDIV unit when FDIV is calculating,
+ resource hazard occured.
+[args] void
+[return] 0: hazard not occured
+ 1: hazard occured
+*/
+ int i;
+
+ for (i = 5; i >= 0; i--) {
+ if (qpipe[i].flag == 1) {
+ hc_count++;
+ if (verb_mode)
+ printf("[resource hazard %04d:FDIV]\n", pc - 1);
+ sflag = 1;
+ return 1;
+ }
+ }
+ for (i = 11; i >= 0; i--) {
+ if (rqpipe[i].flag == 1) {
+ hc_count++;
+ if (verb_mode)
+ printf("[resource hazard %04d:FDIV]\n", pc - 1);
+ sflag = 1;
+ return 1;
+ }
+ }
+ sflag = 0;
+ return 0;
+}
+
+int hazardcheckP(void)
+{
+/*
+[name] hazardcheckP
+[desc.] resource hazarde check. (EFU)
+ If instruction use EFU unit when EFU is calculating,
+ resource hazard occured.
+[args] void
+[return] 0: hazard not occured
+ 1: hazard occured
+*/
+ if (spipe.no != 0) {
+ hc_count++;
+ if (verb_mode)
+ printf("[resource hazard %04d:EFU]\n", pc - 1);
+ sflag = 1;
+ return 1;
+ }
+ sflag = 0;
+ return 0;
+}
+
+int Lower_special(VectorUnitState *state, u_long iL)
+{
+/*
+[name] Lower_special
+[desc.] Micro Special OPCODE (Lower instruction) execute
+[args] iL: lower instruction(32bits)
+[return] 0: executed
+ 1: stall ( hazard occured)
+*/
+
+ double dval, ddval;
+ float fval;
+ u_long ival;
+
+ switch ((iL >> 6) & 0x1f) {
+ case 12: /* MOVE, MR32, ---, --- */
+ switch (get_bc(iL)) {
+ case 0: /* MOVE */
+ if ((get_fs(iL) != 0) || (get_ft(iL) != 0)) {
+ if (hazardcheck(get_fs(iL), 0, get_dest(iL), 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "MOVE");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = VF[get_fs(iL)][0];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = VF[get_fs(iL)][1];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = VF[get_fs(iL)][2];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = VF[get_fs(iL)][3];
+ }
+ break;
+ case 1: /* MR32 */
+ if (hazardcheck(get_fs(iL), 0, get_dest(iL), 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "MR32");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = VF[get_fs(iL)][1];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = VF[get_fs(iL)][2];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = VF[get_fs(iL)][3];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = VF[get_fs(iL)][0];
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(%08x)\n", iL);
+ exit(1);
+ }
+ break;
+ case 13: /* LQI, SQI, LQD, SQD */
+ switch (get_bc(iL)) {
+ case 0: /* LQI */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "LQI");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = *(float *) &state->MEM[VI[get_fs(iL)]][0];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = *(float *) &state->MEM[VI[get_fs(iL)]][1];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = *(float *) &state->MEM[VI[get_fs(iL)]][2];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = *(float *) &state->MEM[VI[get_fs(iL)]][3];
+ VI[get_fs(iL)] += 1;
+ break;
+ case 1: /* SQI */
+/*printf("SQI\n");
+printpipe();
+printf("fs:%d ft:%d dest:%d)\n", get_fs(iL), get_ft(iL), get_dest(iL));
+printf("hazardcheck(%d, %d, %d, %d)\n", 0, get_ft(iL), get_dest(iL), 1); */
+ //if (hazardcheck(0, get_ft(iL), get_dest(iL), 1) ||
+ //hazardcheckVI(get_fs(iL), 0, 2)) {
+ if (hazardcheck(0, get_fs(iL), get_dest(iL), 1) ||
+ hazardcheckVI(get_ft(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 2;
+ pipe[0][1].addr = VI[get_ft(iL)];
+ strcpy(pipe[0][1].code, "SQI");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = VF[get_fs(iL)][0];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = VF[get_fs(iL)][1];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = VF[get_fs(iL)][2];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = VF[get_fs(iL)][3];
+ VI[get_ft(iL)] += 1;
+ break;
+ case 2: /* LQD */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "LQD");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] =
+ *(float *) &state->MEM[VI[get_fs(iL)] - 1][0];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] =
+ *(float *) &state->MEM[VI[get_fs(iL)] - 1][1];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] =
+ *(float *) &state->MEM[VI[get_fs(iL)] - 1][2];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] =
+ *(float *) &state->MEM[VI[get_fs(iL)] - 1][3];
+ VI[get_fs(iL)] -= 1;
+ break;
+ case 3: /* SQD */
+ if (hazardcheck(0, get_ft(iL), get_dest(iL), 1) ||
+ hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 2;
+ pipe[0][1].addr = VI[get_ft(iL)] - 1;
+ strcpy(pipe[0][1].code, "SQD");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = VF[get_fs(iL)][0];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = VF[get_fs(iL)][1];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = VF[get_fs(iL)][2];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = VF[get_fs(iL)][3];
+ VI[get_ft(iL)] -= 1;
+ break;
+ }
+ break;
+ case 14: /* DIV, SQRT, RSQRT, WAITQ */
+ switch (get_bc(iL)) {
+ case 0: /* DIV */
+ if (hazardcheckFTF(get_fs(iL), get_ft(iL),
+ get_fsf(iL), get_ftf(iL), 3) ||
+ hazardcheckQ()) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ qpipe[0].flag = 1;
+ if(VF[get_ft(iL)][get_ftf(iL)] == 0){
+ *(u_long *)&qpipe[0].vf[0] = 0x7fffffff;
+ if(VF[get_fs(iL)][get_fsf(iL)] == 0)
+ qpipe[0].status |= 0x10;
+ else
+ qpipe[0].status |= 0x20;
+ }else{
+ qpipe[0].vf[0] = VF[get_fs(iL)][get_fsf(iL)] /
+ VF[get_ft(iL)][get_ftf(iL)];
+ qpipe[0].status = 0;
+ }
+ strcpy(qpipe[0].code, "DIV");
+ break;
+ case 1: /* SQRT */
+ if (hazardcheckFTF(0, get_ft(iL), 0, get_ftf(iL), 1) ||
+ hazardcheckQ()) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ qpipe[0].flag = 1;
+ dval = (double) VF[get_ft(iL)][get_ftf(iL)];
+ if(dval < 0){
+ dval = 0 - dval;
+ qpipe[0].status |= 0x10;
+ }else{
+ qpipe[0].status = 0;
+ }
+ ddval = sqrt(dval);
+ qpipe[0].vf[0] = (float) ddval;
+ strcpy(qpipe[0].code, "SQRT");
+ break;
+ case 2: /* RSQRT */
+ if (hazardcheckFTF(0, get_ft(iL), 0, get_ftf(iL), 1) ||
+ hazardcheckQ()) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ rqpipe[0].flag = 1;
+ dval = (double) (VF[get_ft(iL)][get_ftf(iL)]);
+ if(dval < 0){
+ dval = 0 - dval;
+ qpipe[0].status |= 0x10;
+ }
+ ddval = sqrt(dval);
+ dval = (double) (VF[get_fs(iL)][get_fsf(iL)]);
+ if(ddval < 0){
+ qpipe[0].status |= 0x20;
+ *(u_long *)&rqpipe[0].vf[0] = 0x7fffffff;
+ }else{
+ rqpipe[0].vf[0] = (float) (dval / ddval);
+ }
+ break;
+ case 3: /* WAITQ */
+ if (hazardcheckQ()) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ break;
+ }
+ break;
+ case 15: /* MTIR, MFIR, ILWR, ISWR */
+ switch (get_bc(iL)) {
+ case 0: /* MTIR */
+ if (hazardcheck(get_fs(iL), 0, get_dest(iL), 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL) + 32;
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "MTIR");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = VF[get_fs(iL)][0];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = VF[get_fs(iL)][1];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = VF[get_fs(iL)][2];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = VF[get_fs(iL)][3];
+ break;
+ case 1: /* MFIR */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "MFIR");
+ ival = VI[get_fs(iL)];
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = *(float *) &ival;
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = *(float *) &ival;
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = *(float *) &ival;
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = *(float *) &ival;
+ break;
+ case 2: /* ILWR */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL) + 32;
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "ILWR");
+ if (get_dest(iL) & DEST_X)
+ *(long *) &pipe[0][1].vf[0] = state->MEM[VI[get_fs(iL)]][0];
+ if (get_dest(iL) & DEST_Y)
+ *(long *) &pipe[0][1].vf[1] = state->MEM[VI[get_fs(iL)]][1];
+ if (get_dest(iL) & DEST_Z)
+ *(long *) &pipe[0][1].vf[2] = state->MEM[VI[get_fs(iL)]][2];
+ if (get_dest(iL) & DEST_W)
+ *(long *) &pipe[0][1].vf[3] = state->MEM[VI[get_fs(iL)]][3];
+ break;
+ case 3: /* ISWR */
+ if (hazardcheckVI(get_fs(iL), get_ft(iL), 3)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 2;
+ pipe[0][1].addr = VI[get_fs(iL)];
+ strcpy(pipe[0][1].code, "ISWR");
+ if (get_dest(iL) & DEST_X)
+ *(long *) &pipe[0][1].vf[0] = (VI[get_ft(iL)]) & 0xffff;
+ if (get_dest(iL) & DEST_Y)
+ *(long *) &pipe[0][1].vf[1] = (VI[get_ft(iL)]) & 0xffff;
+ if (get_dest(iL) & DEST_Z)
+ *(long *) &pipe[0][1].vf[2] = (VI[get_ft(iL)]) & 0xffff;
+ if (get_dest(iL) & DEST_W)
+ *(long *) &pipe[0][1].vf[3] = (VI[get_ft(iL)]) & 0xffff;
+ break;
+ }
+ break;
+ case 16: /* RNEXT, RGET, RINIT, RXOR */
+ switch (get_bc(iL)) {
+ case 0: /* RNEXT */
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "RNEXT");
+ ival = 0;
+ if(((R >> 22) & 0x1) ^ ((R >> 4) & 0x1))
+ ival = 1;
+ R = ((R << 1) + ival) & 0x007fffff;
+ if (get_dest(iL) & DEST_X)
+ *(u_long *)&pipe[0][1].vf[0] = 0x3f800000 | R;
+ if (get_dest(iL) & DEST_Y)
+ *(u_long *)&pipe[0][1].vf[1] = 0x3f800000 | R;
+ if (get_dest(iL) & DEST_Z)
+ *(u_long *)&pipe[0][1].vf[2] = 0x3f800000 | R;
+ if (get_dest(iL) & DEST_W)
+ *(u_long *)&pipe[0][1].vf[3] = 0x3f800000 | R;
+ break;
+ case 1: /* RGET */
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "RGET");
+ if (get_dest(iL) & DEST_X)
+ *(u_long *)&pipe[0][1].vf[0] = 0x3f800000 | R;
+ if (get_dest(iL) & DEST_Y)
+ *(u_long *)&pipe[0][1].vf[1] = 0x3f800000 | R;
+ if (get_dest(iL) & DEST_Z)
+ *(u_long *)&pipe[0][1].vf[2] = 0x3f800000 | R;
+ if (get_dest(iL) & DEST_W)
+ *(u_long *)&pipe[0][1].vf[3] = 0x3f800000 | R;
+ break;
+ case 2: /* RINIT */
+ if (hazardcheckFTF(get_fs(iL), 0, get_fsf(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ R = *(u_long *)&VF[get_fs(iL)][get_fsf(iL)] & 0x7fffff;
+ break;
+ case 3: /* RXOR */
+ if (hazardcheckFTF(get_fs(iL), 0, get_fsf(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ R = R ^ (*(u_long *)&VF[get_fs(iL)][get_fsf(iL)] & 0x7fffff);
+ break;
+ }
+ break;
+ case 25: /* MFP, ---, ---, --- */
+ switch (get_bc(iL)) {
+ case 0: /* MFP */
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 7;
+ strcpy(pipe[0][1].code, "MFP");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = VN[4];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = VN[4];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = VN[4];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = VN[4];
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08x)\n", iL);
+ exit(1);
+ break;
+ }
+ break;
+ case 26: /* XITOP, XTOP */
+ switch (get_bc(iL)) {
+ case 0: /* XTOP */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = (short) _TOP;
+ strcpy(ipipe[0].code, "XTOP");
+ break;
+ case 1: /* XITOP */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = (short) _ITOP;
+ strcpy(ipipe[0].code, "XITOP");
+ break;
+ }
+ break;
+ case 27: /* XGKICK */
+ GpuIfKick(state, VI[get_fs(iL)]);
+ break;
+ case 28: /* ESADD, ERSADD, ELENG, ERLENG */
+ switch (get_bc(iL)) {
+ case 0: /* ESADD */
+ if (hazardcheckP() || hazardcheck(0, get_ft(iL), 0xe, 1)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][0];
+ VN[1] = VF[get_fs(iL)][1];
+ VN[2] = VF[get_fs(iL)][2];
+ spipe.vn = VN[0] * VN[0] + VN[1] * VN[1] + VN[2] * VN[2];
+ spipe.no = 9;
+ break;
+ case 1: /* ERSADD */
+ if (hazardcheckP() || hazardcheck(0, get_ft(iL), 0xe, 1)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][0];
+ VN[1] = VF[get_fs(iL)][1];
+ VN[2] = VF[get_fs(iL)][2];
+ VN[5] = VN[0] * VN[0] + VN[1] * VN[1] + VN[2] * VN[2];
+ spipe.vn = 1.0 / VN[5];
+ spipe.no = 16;
+ break;
+ case 2: /* ELENG */
+ if (hazardcheckP() || hazardcheck(0, get_ft(iL), 0xe, 1)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][0];
+ VN[1] = VF[get_fs(iL)][1];
+ VN[2] = VF[get_fs(iL)][2];
+ dval = (double) (VN[0] * VN[0] + VN[1] * VN[1] + VN[2] * VN[2]);
+ spipe.vn = (float) sqrt(dval);
+ spipe.no = 16;
+ break;
+ case 3: /* ERLENG */
+ if (hazardcheckP() || hazardcheck(0, get_ft(iL), 0xe, 1)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][0];
+ VN[1] = VF[get_fs(iL)][1];
+ VN[2] = VF[get_fs(iL)][2];
+ dval = (double) (VN[0] * VN[0] + VN[1] * VN[1] + VN[2] * VN[2]);
+ spipe.vn = 1.0 / (float) sqrt(dval);
+ spipe.no = 22;
+ break;
+ }
+ break;
+ case 29: /* EATANxy, EATANxz, ESUM, --- */
+ switch (get_bc(iL)) {
+ case 0: /* EATANxy */
+ if (hazardcheckP() || hazardcheck(0, get_ft(iL), 0xc, 1)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][0];
+ VN[1] = VF[get_fs(iL)][1];
+ VN[5] = (VN[1] - VN[0]) / (VN[1] + VN[0]);
+ fval = VN[5];
+ spipe.vn = VN[14] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[15] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[16] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[17] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[18] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[19] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[20] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[21] * fval;
+ spipe.no = 52;
+ break;
+ case 1: /* EATANxz */
+ if (hazardcheckP() || hazardcheck(0, get_ft(iL), 0xa, 1)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][0];
+ VN[2] = VF[get_fs(iL)][2];
+ VN[5] = (VN[2] - VN[0]) / (VN[2] + VN[0]);
+ fval = VN[5];
+ spipe.vn = VN[14] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[15] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[16] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[17] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[18] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[19] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[20] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[21] * fval;
+ spipe.no = 52;
+ break;
+ case 2: /* ESUM */
+ if (hazardcheckP() || hazardcheck(0, get_ft(iL), 0xf, 1)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ spipe.vn = VF[get_fs(iL)][0] + VF[get_fs(iL)][1]
+ + VF[get_fs(iL)][2] + VF[get_fs(iL)][3];
+ spipe.no = 10;
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08x)\n", iL);
+ exit(1);
+ break;
+ }
+ break;
+ case 30: /* ESQRT, ERSQRT, ERCPR, WAITP */
+ switch (get_bc(iL)) {
+ case 0: /* ESQRT */
+ if (hazardcheckP() ||
+ hazardcheckFTF(get_fs(iL), 0, get_fsf(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][get_fsf(iL)];
+ dval = (double) VN[0];
+ spipe.vn = (float) sqrt(dval);
+ spipe.no = 10;
+ break;
+ case 1: /* ERSQRT */
+ if (hazardcheckP() ||
+ hazardcheckFTF(get_fs(iL), 0, get_fsf(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][get_fsf(iL)];
+ dval = (double) VN[0];
+ spipe.vn = 1.0 / (float) sqrt(dval);
+ spipe.no = 16;
+ break;
+ case 2: /* ERCPR */
+ if (hazardcheckP() ||
+ hazardcheckFTF(get_fs(iL), 0, get_fsf(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][get_fsf(iL)];
+ spipe.vn = 1.0 / VN[0];
+ spipe.no = 10;
+ break;
+ case 3: /* WAITP */
+ if (hazardcheckP()) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ break;
+ }
+ break;
+ case 31: /* ESIN, EATAN, EEXP, --- */
+ switch (get_bc(iL)) {
+ case 0: /* SIN */
+ if (hazardcheckP() ||
+ hazardcheckFTF(get_fs(iL), 0, get_fsf(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][get_fsf(iL)];
+ fval = VN[0];
+ spipe.vn = VN[9] * fval;
+ fval = fval * VN[0] * VN[0];
+ spipe.vn += VN[10] * fval;
+ fval = fval * VN[0] * VN[0];
+ spipe.vn += VN[11] * fval;
+ fval = fval * VN[0] * VN[0];
+ spipe.vn += VN[12] * fval;
+ fval = fval * VN[0] * VN[0];
+ spipe.vn += VN[13] * fval;
+ spipe.no = 27;
+ break;
+ case 1: /* EATAN */
+ if (hazardcheckP() ||
+ hazardcheckFTF(get_fs(iL), 0, get_fsf(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][get_fsf(iL)];
+ VN[5] = (VN[0] - 1.0) / (VN[0] + 1.0);
+ fval = VN[5];
+ spipe.vn = VN[14] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[15] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[16] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[17] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[18] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[19] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[20] * fval;
+ fval = fval * VN[5] * VN[5];
+ spipe.vn += VN[21] * fval;
+ spipe.no = 52;
+ break;
+ case 2: /* EEXP */
+ if (hazardcheckP() ||
+ hazardcheckFTF(get_fs(iL), 0, get_fsf(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ VN[0] = VF[get_fs(iL)][get_fsf(iL)];
+ fval = 0.0 - VN[0];
+ VN[5] = fval;
+ VN[6] = 1.0;
+ VN[6] += VN[23] * VN[5];
+ VN[5] *= fval;
+ VN[6] += VN[24] * VN[5];
+ VN[5] *= fval;
+ VN[6] += VN[25] * VN[5];
+ VN[5] *= fval;
+ VN[6] += VN[26] * VN[5];
+ VN[5] *= fval;
+ VN[6] += VN[27] * VN[5];
+ VN[5] *= fval;
+ VN[6] += VN[28] * VN[5];
+ fval = VN[6] * VN[6] * VN[6] * VN[6];
+ spipe.vn = 1.0 / fval;
+ spipe.no = 42;
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08x)\n", iL);
+ exit(1);
+ break;
+ }
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08x)\n", iL);
+ exit(1);
+ }
+ return 0;
+}
+
+int Upper_special(VectorUnitState *state, u_long iH, u_long iL)
+{
+/*
+[name] Upper_special
+[desc.] Micro Special OPCODE (Upper instruction) execute
+[args] iH: Upper instruction(32bits)
+ iL: lower instruction(32bits)
+[return] 0: executed
+ 1: stall ( hazard occured)
+*/
+
+ float w;
+ double dval, dval2;
+ long ix, iy, iz, iw;
+
+ switch ((iH >> 6) & 0x1f) { /* bit42-38 */
+ case 0: /* ADDAx, ADDAy, ADDAz, ADDAw */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "ADDA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] + VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] + VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] + VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] + VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* SUBAx, SUBAy, SUBAz, SUBAw */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "SUBA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] - VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] - VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] - VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] - VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* MADDAx, MADDAy, MADDAz, MADDAw */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MADDA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = ACC[0] +
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = ACC[1] +
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = ACC[2] +
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = ACC[3] +
+ VF[get_fs(iH)][3] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3: /* MSUBAx, MSUBAy, MSUBAz, MSUBAw */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MSUBA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = ACC[0] -
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = ACC[1] -
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = ACC[2] -
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = ACC[3] -
+ VF[get_fs(iH)][3] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 4: /* ITOF0, ITOF4, ITOF12, ITOF15 */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_ft(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ switch (get_bc(iH)) {
+ case 0: /* ITOF0 */
+ strcpy(pipe[0][0].code, "ITOF0");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = *(long *) &VF[get_fs(iH)][0] / 1.0;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = *(long *) &VF[get_fs(iH)][1] / 1.0;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = *(long *) &VF[get_fs(iH)][2] / 1.0;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = *(long *) &VF[get_fs(iH)][3] / 1.0;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* ITOF4 */
+ strcpy(pipe[0][0].code, "ITOF4");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = *(long *) &VF[get_fs(iH)][0] / 16.0;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = *(long *) &VF[get_fs(iH)][1] / 16.0;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = *(long *) &VF[get_fs(iH)][2] / 16.0;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = *(long *) &VF[get_fs(iH)][3] / 16.0;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* ITOF12 */
+ strcpy(pipe[0][0].code, "ITOF12");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = *(long *)&VF[get_fs(iH)][0] / 4096.0;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = *(long *)&VF[get_fs(iH)][1] / 4096.0;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = *(long *)&VF[get_fs(iH)][2] / 4096.0;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = *(long *)&VF[get_fs(iH)][3] / 4096.0;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3: /* ITOF15 */
+ strcpy(pipe[0][0].code, "ITOF15");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] =
+ *(long *) &VF[get_fs(iH)][0] / 32768.0;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] =
+ *(long *) &VF[get_fs(iH)][1] / 32768.0;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] =
+ *(long *) &VF[get_fs(iH)][2] / 32768.0;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] =
+ *(long *) &VF[get_fs(iH)][3] / 32768.0;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ }
+ break;
+ case 5: /* FTOI0, FTOI4, FTOI12, FTOI15 */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_ft(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ switch (get_bc(iH)) {
+ case 0: /* FTOI0 */
+ strcpy(pipe[0][0].code, "FTOI0");
+ if (get_dest(iH) & DEST_X) {
+ ix = VF[get_fs(iH)][0];
+ *(long *) &pipe[0][0].vf[0] = ix;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ iy = VF[get_fs(iH)][1];
+ *(long *) &pipe[0][0].vf[1] = iy;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ iz = VF[get_fs(iH)][2];
+ *(long *) &pipe[0][0].vf[2] = iz;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ iw = VF[get_fs(iH)][3];
+ *(long *) &pipe[0][0].vf[3] = iw;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* FTOI4 */
+ strcpy(pipe[0][0].code, "FTOI4");
+ if (get_dest(iH) & DEST_X) {
+ ix = VF[get_fs(iH)][0] * 16;
+ *(long *) &pipe[0][0].vf[0] = ix;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ iy = VF[get_fs(iH)][1] * 16;
+ *(long *) &pipe[0][0].vf[1] = iy;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ iz = VF[get_fs(iH)][2] * 16;
+ *(long *) &pipe[0][0].vf[2] = iz;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ iw = VF[get_fs(iH)][3] * 16;
+ *(long *) &pipe[0][0].vf[3] = iw;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* FTOI12 */
+ strcpy(pipe[0][0].code, "FTOI12");
+ if (get_dest(iH) & DEST_X) {
+ ix = VF[get_fs(iH)][0] * 4096;
+ *(long *) &pipe[0][0].vf[0] = ix;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ iy = VF[get_fs(iH)][1] * 4096;
+ *(long *) &pipe[0][0].vf[1] = iy;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ iz = VF[get_fs(iH)][2] * 4096;
+ *(long *) &pipe[0][0].vf[2] = iz;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ iw = VF[get_fs(iH)][3] * 4096;
+ *(long *) &pipe[0][0].vf[3] = iw;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3: /* FTOI15 */
+ strcpy(pipe[0][0].code, "FTOI15");
+ if (get_dest(iH) & DEST_X) {
+ ix = VF[get_fs(iH)][0] * 32768;
+ *(long *) &pipe[0][0].vf[0] = ix;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ iy = VF[get_fs(iH)][1] * 32768;
+ *(long *) &pipe[0][0].vf[1] = iy;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ iz = VF[get_fs(iH)][2] * 32768;
+ *(long *) &pipe[0][0].vf[2] = iz;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ iw = VF[get_fs(iH)][3] * 32768;
+ *(long *) &pipe[0][0].vf[3] = iw;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ }
+ break;
+ case 6: /* MULAx, MULAy, MULAz, MULAw */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MULA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 7: /* MULAq, ABS, MULAi, CLIP */
+ switch (get_bc(iH)) {
+ case 0: /* MULAq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MULAq");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] * Q;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] * Q;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] * Q;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] * Q;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* ABS */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_ft(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "ABS");
+ if (get_dest(iH) & DEST_X) {
+ if (VF[get_fs(iH)][0] > 0) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0];
+ } else {
+ pipe[0][0].vf[0] = 0 - VF[get_fs(iH)][0];
+ }
+ statuscheck(VF[get_ft(iH)][0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ if (VF[get_fs(iH)][1] > 0) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1];
+ } else {
+ pipe[0][0].vf[1] = 0 - VF[get_fs(iH)][1];
+ }
+ statuscheck(VF[get_ft(iH)][1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ if (VF[get_fs(iH)][2] > 0) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2];
+ } else {
+ pipe[0][0].vf[2] = 0 - VF[get_fs(iH)][2];
+ }
+ statuscheck(VF[get_ft(iH)][2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ if (VF[get_fs(iH)][3] > 0) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3];
+ } else {
+ pipe[0][0].vf[3] = 0 - VF[get_fs(iH)][3];
+ }
+ statuscheck(VF[get_ft(iH)][3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* MULAi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MULAi");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (iH & 0x80000000) {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] * (*(float *) &iL);
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] * (*(float *) &iL);
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] * (*(float *) &iL);
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] * (*(float *) &iL);
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ } else {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] * I;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] * I;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] * I;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] * I;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ }
+ break;
+ case 3: /* CLIP */
+ if (hazardcheck(get_fs(iH), 0, 0xf, 2))
+ return 1;
+ pipe[0][0].flag = 5;
+ pipe[0][0].status = 0;
+ strcpy(pipe[0][0].code, "CLIP");
+ if (VF[get_ft(iH)][3] < 0)
+ w = 0 - VF[get_ft(iH)][3];
+ else
+ w = VF[get_ft(iH)][3];
+ if (VF[get_fs(iH)][0] > w)
+ pipe[0][0].status |= 0x1;
+ if (VF[get_fs(iH)][0] < (0 - w))
+ pipe[0][0].status |= 0x2;
+ if (VF[get_fs(iH)][1] > w)
+ pipe[0][0].status |= 0x4;
+ if (VF[get_fs(iH)][1] < (0 - w))
+ pipe[0][0].status |= 0x8;
+ if (VF[get_fs(iH)][2] > w)
+ pipe[0][0].status |= 0x10;
+ if (VF[get_fs(iH)][2] < (0 - w))
+ pipe[0][0].status |= 0x20;
+ break;
+ }
+ break;
+ case 8: /* ADDAq, MADDAq, ADDAi, MADDAi */
+ switch (get_bc(iH)) {
+ case 0: /* ADDAq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "ADDAq");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] + Q;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] + Q;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] + Q;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] + Q;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MADDAq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MADDAq");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = ACC[0] + VF[get_fs(iH)][0] * Q;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = ACC[1] + VF[get_fs(iH)][1] * Q;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = ACC[2] + VF[get_fs(iH)][2] * Q;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = ACC[3] + VF[get_fs(iH)][3] * Q;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* ADDAi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "ADDAi");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (iH & 0x80000000) {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] + (*(float *) &iL);
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] + (*(float *) &iL);
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] + (*(float *) &iL);
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] + (*(float *) &iL);
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ } else {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] + I;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] + I;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] + I;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] + I;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ }
+ break;
+ case 3: /* MADDAi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MADDAi");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (iH & 0x80000000) {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] =
+ ACC[0] + VF[get_fs(iH)][0] * (*(float *) &iL);
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] =
+ ACC[1] + VF[get_fs(iH)][1] * (*(float *) &iL);
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] =
+ ACC[2] + VF[get_fs(iH)][2] * (*(float *) &iL);
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] =
+ ACC[3] + VF[get_fs(iH)][3] * (*(float *) &iL);
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ } else {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = ACC[0] + VF[get_fs(iH)][0] * I;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = ACC[1] + VF[get_fs(iH)][1] * I;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = ACC[2] + VF[get_fs(iH)][2] * I;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = ACC[3] + VF[get_fs(iH)][3] * I;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ }
+ break;
+ }
+ break;
+ case 9: /* SUBAq, MSUBAq, SUBAi, MSUBAi */
+ switch (get_bc(iH)) {
+ case 0: /* SUBAq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "SUBAq");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] - Q;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] - Q;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] - Q;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] - Q;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MSUBAq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MSUBAq");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = ACC[0] - VF[get_fs(iH)][0] * Q;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = ACC[1] - VF[get_fs(iH)][1] * Q;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = ACC[2] - VF[get_fs(iH)][2] * Q;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = ACC[3] - VF[get_fs(iH)][3] * Q;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* SUBAi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "SUBAi");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (iH & 0x80000000) {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] - (*(float *) &iL);
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] - (*(float *) &iL);
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] - (*(float *) &iL);
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] - (*(float *) &iL);
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ } else {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] - I;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] - I;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] - I;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] - I;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ }
+ break;
+ case 3: /* MSUBAi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MSUBAi");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (iH & 0x80000000) {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] =
+ ACC[0] - VF[get_fs(iH)][0] * (*(float *) &iL);
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] =
+ ACC[1] - VF[get_fs(iH)][1] * (*(float *) &iL);
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] =
+ ACC[2] - VF[get_fs(iH)][2] * (*(float *) &iL);
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] =
+ ACC[3] - VF[get_fs(iH)][3] * (*(float *) &iL);
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ } else {
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = ACC[0] - VF[get_fs(iH)][0] * I;
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = ACC[1] - VF[get_fs(iH)][1] * I;
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = ACC[2] - VF[get_fs(iH)][2] * I;
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = ACC[3] - VF[get_fs(iH)][3] * I;
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ }
+ break;
+ }
+ break;
+ case 10: /* ADDA, MADDA, MULA, --- */
+ switch (get_bc(iH)) {
+ case 0: /* ADDA */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "ADDA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] + VF[get_ft(iH)][0];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] + VF[get_ft(iH)][1];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] + VF[get_ft(iH)][2];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] + VF[get_ft(iH)][3];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MADDA */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MADDA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] =
+ ACC[0] + VF[get_fs(iH)][0] * VF[get_ft(iH)][0];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] =
+ ACC[1] + VF[get_fs(iH)][1] * VF[get_ft(iH)][1];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] =
+ ACC[2] + VF[get_fs(iH)][2] * VF[get_ft(iH)][2];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] =
+ ACC[3] + VF[get_fs(iH)][3] * VF[get_ft(iH)][3];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* MULA */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MULA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] * VF[get_ft(iH)][0];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] * VF[get_ft(iH)][1];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] * VF[get_ft(iH)][2];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] * VF[get_ft(iH)][3];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3:
+ fprintf(stderr, "Undefined opcode(UpperOp:%08x)\n", iH);
+ break;
+ }
+ break;
+ case 11: /* SUBA, MSUBA, OPMULA, NOP */
+ switch (get_bc(iH)) {
+ case 0: /* SUBA */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "SUBA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] = VF[get_fs(iH)][0] - VF[get_ft(iH)][0];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] = VF[get_fs(iH)][1] - VF[get_ft(iH)][1];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] = VF[get_fs(iH)][2] - VF[get_ft(iH)][2];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] = VF[get_fs(iH)][3] - VF[get_ft(iH)][3];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MSUBA */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ strcpy(pipe[0][0].code, "MSUBA");
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ if (get_dest(iH) & DEST_X) {
+ apipe.acc[0] =
+ ACC[0] - VF[get_fs(iH)][0] * VF[get_ft(iH)][0];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ apipe.acc[1] =
+ ACC[1] - VF[get_fs(iH)][1] * VF[get_ft(iH)][1];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ apipe.acc[2] =
+ ACC[2] - VF[get_fs(iH)][2] * VF[get_ft(iH)][2];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ apipe.acc[3] =
+ ACC[3] - VF[get_fs(iH)][3] * VF[get_ft(iH)][3];
+ statuscheck(apipe.acc[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* OPMULA */
+ if (hazardcheck(get_fs(iH), get_ft(iH), 0xe, 3))
+ return 1;
+ pipe[0][0].flag = 4;
+ apipe.flag = 1;
+ apipe.mask = get_dest(iH);
+ strcpy(pipe[0][0].code, "OPMULA");
+ apipe.acc[0] = VF[get_fs(iH)][1] * VF[get_ft(iH)][2];
+ statuscheck(apipe.acc[0], &pipe[0][0].status, 0);
+ apipe.acc[1] = VF[get_fs(iH)][2] * VF[get_ft(iH)][0];
+ statuscheck(apipe.acc[1], &pipe[0][0].status, 1);
+ apipe.acc[2] = VF[get_fs(iH)][0] * VF[get_ft(iH)][1];
+ statuscheck(apipe.acc[2], &pipe[0][0].status, 2);
+ break;
+ case 3: /* NOP */
+ break;
+ }
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(%08x)\n", iH);
+ exit(1);
+ }
+ return 0;
+}
+
+int exec_inst(VectorUnitState *state)
+{
+/*
+[name] exec_inst
+[desc.] execute instruction ( second stage of pipeline)
+[args] void
+[return] 0: finished
+ 1: stall (hazard occured)
+ 2: executed
+*/
+ double dval;
+ float fval;
+ u_long iH, iL;
+ long imm12, imm11, imm15, imm5, imm24;
+
+ if (peflag == -1)
+ return 0;
+
+ if (peflag == 1)
+ peflag = -1;
+ if (instbuf[0] & 0x40000000)
+ eflag = 1;
+
+ iH = instbuf[0];
+ iL = instbuf[1];
+
+ pipe[0][0].status = 0;
+ pipe[0][1].status = 0;
+ qpipe[0].status = 0;
+ rqpipe[0].status = 0;
+
+ if (iH & 0x80000000) {
+ Ipipe.flag = 1;
+ Ipipe.val = *(float *) &iL;
+ /* pipe[0][1].flag = 3;
+ pipe[0][1].vf[0] = *(float *)&iL; */
+ }
+ /* UpperOp execute */
+ switch ((iH >> 2) & 0xf) { /* bit37-34 */
+ case 0: /* ADDx,y,z,w */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "ADD");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] =
+ VF[get_fs(iH)][0] + VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] =
+ VF[get_fs(iH)][1] + VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] =
+ VF[get_fs(iH)][2] + VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] =
+ VF[get_fs(iH)][3] + VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 0);
+ }
+ break;
+ case 1: /* SUBx,y,z,w */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "SUB");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] =
+ VF[get_fs(iH)][0] - VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] =
+ VF[get_fs(iH)][1] - VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] =
+ VF[get_fs(iH)][2] - VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] =
+ VF[get_fs(iH)][3] - VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* MADDx,y,z,w */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MADD");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = ACC[0] +
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = ACC[1] +
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = ACC[2] +
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = ACC[3] +
+ VF[get_fs(iH)][3] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3: /* MSUBx,y,z,w */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MSUB");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = ACC[0] -
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = ACC[1] -
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = ACC[2] -
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = ACC[3] -
+ VF[get_fs(iH)][3] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 4: /* MAXx,y,z,w */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MAX");
+ if (get_dest(iH) & DEST_X) {
+ if (VF[get_fs(iH)][0] > VF[get_ft(iH)][get_bc(iH)])
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0];
+ else
+ pipe[0][0].vf[0] = VF[get_ft(iH)][get_bc(iH)];
+ }
+ if (get_dest(iH) & DEST_Y) {
+ if (VF[get_fs(iH)][1] > VF[get_ft(iH)][get_bc(iH)])
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1];
+ else
+ pipe[0][0].vf[1] = VF[get_ft(iH)][get_bc(iH)];
+ }
+ if (get_dest(iH) & DEST_Z) {
+ if (VF[get_fs(iH)][2] > VF[get_ft(iH)][get_bc(iH)])
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2];
+ else
+ pipe[0][0].vf[2] = VF[get_ft(iH)][get_bc(iH)];
+ }
+ if (get_dest(iH) & DEST_W) {
+ if (VF[get_fs(iH)][3] > VF[get_ft(iH)][get_bc(iH)])
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3];
+ else
+ pipe[0][0].vf[3] = VF[get_ft(iH)][get_bc(iH)];
+ }
+ break;
+ case 5: /* MINIx,y,z,w */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MINI");
+ if (get_dest(iH) & DEST_X) {
+ if (VF[get_fs(iH)][0] < VF[get_ft(iH)][get_bc(iH)])
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0];
+ else
+ pipe[0][0].vf[0] = VF[get_ft(iH)][get_bc(iH)];
+ }
+ if (get_dest(iH) & DEST_Y) {
+ if (VF[get_fs(iH)][1] < VF[get_ft(iH)][get_bc(iH)])
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1];
+ else
+ pipe[0][0].vf[1] = VF[get_ft(iH)][get_bc(iH)];
+ }
+ if (get_dest(iH) & DEST_Z) {
+ if (VF[get_fs(iH)][2] < VF[get_ft(iH)][get_bc(iH)])
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2];
+ else
+ pipe[0][0].vf[2] = VF[get_ft(iH)][get_bc(iH)];
+ }
+ if (get_dest(iH) & DEST_W) {
+ if (VF[get_fs(iH)][3] < VF[get_ft(iH)][get_bc(iH)])
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3];
+ else
+ pipe[0][0].vf[3] = VF[get_ft(iH)][get_bc(iH)];
+ }
+ break;
+ case 6: /* MULx,y,z,w */
+ if (hazardcheckBC(get_fs(iH), get_ft(iH), get_dest(iH), get_bc(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MUL");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] =
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] =
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] =
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] =
+ VF[get_fs(iH)][3] * VF[get_ft(iH)][get_bc(iH)];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 7: /* MULq, MAXi, MULi, MINIi */
+ switch (get_bc(iH)) {
+ case 0: /* MULq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MULq");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0] * Q;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1] * Q;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2] * Q;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3] * Q;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MAXi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MAXi");
+ fval = I;
+ if (get_dest(iH) & DEST_X) {
+ if (VF[get_fs(iH)][0] > fval) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0];
+ } else {
+ pipe[0][0].vf[0] = fval;
+ }
+ }
+ if (get_dest(iH) & DEST_Y) {
+ if (VF[get_fs(iH)][1] > fval) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1];
+ } else {
+ pipe[0][0].vf[1] = fval;
+ }
+ }
+ if (get_dest(iH) & DEST_Z) {
+ if (VF[get_fs(iH)][2] > fval) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2];
+ } else {
+ pipe[0][0].vf[2] = fval;
+ }
+ }
+ if (get_dest(iH) & DEST_W) {
+ if (VF[get_fs(iH)][3] > fval) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3];
+ } else {
+ pipe[0][0].vf[3] = fval;
+ }
+ }
+ break;
+ case 2: /* MULi */
+ /* if(iH & 0x80000000){
+ if(hazardcheckI())
+ return 1;
+ } */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MULi");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0] * I;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1] * I;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2] * I;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3] * I;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3: /* MINIi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MINIi");
+ fval = I;
+ if (get_dest(iH) & DEST_X) {
+ if (VF[get_fs(iH)][0] < fval) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0];
+ } else {
+ pipe[0][0].vf[0] = fval;
+ }
+ }
+ if (get_dest(iH) & DEST_Y) {
+ if (VF[get_fs(iH)][1] < fval) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1];
+ } else {
+ pipe[0][0].vf[1] = fval;
+ }
+ }
+ if (get_dest(iH) & DEST_Z) {
+ if (VF[get_fs(iH)][2] < fval) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2];
+ } else {
+ pipe[0][0].vf[2] = fval;
+ }
+ }
+ if (get_dest(iH) & DEST_W) {
+ if (VF[get_fs(iH)][3] < fval) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3];
+ } else {
+ pipe[0][0].vf[3] = fval;
+ }
+ }
+ break;
+ }
+ break;
+ case 8: /* ADDq, MADDq, ADDi, MADDi */
+ switch (get_bc(iH)) {
+ case 0: /* ADDq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "ADDq");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0] + Q;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1] + Q;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2] + Q;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3] + Q;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MADDq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MADDq");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = ACC[0] + VF[get_fs(iH)][0] * Q;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = ACC[1] + VF[get_fs(iH)][1] * Q;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = ACC[2] + VF[get_fs(iH)][2] * Q;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = ACC[3] + VF[get_fs(iH)][3] * Q;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* ADDi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "ADDi");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0] + I;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1] + I;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2] + I;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3] + I;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3: /* MADDi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MADDi");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = ACC[0] + VF[get_fs(iH)][0] * I;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = ACC[1] + VF[get_fs(iH)][1] * I;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = ACC[2] + VF[get_fs(iH)][2] * I;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = ACC[3] + VF[get_fs(iH)][3] * I;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ }
+ break;
+ case 9: /* SUBq, MSUBq, SUBi, MSUBi */
+ switch (get_bc(iH)) {
+ case 0: /* SUBq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "SUBq");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0] - Q;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1] - Q;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2] - Q;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3] - Q;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MSUBq */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MSUBq");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = ACC[0] - VF[get_fs(iH)][0] * Q;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = ACC[1] - VF[get_fs(iH)][1] * Q;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = ACC[2] - VF[get_fs(iH)][2] * Q;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = ACC[3] - VF[get_fs(iH)][3] * Q;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* SUBi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "SUBi");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0] - I;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1] - I;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2] - I;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3] - I;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3: /* MSUBi */
+ if (hazardcheck(get_fs(iH), 0, get_dest(iH), 2))
+ return 1;
+
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MSUBi");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = ACC[0] - VF[get_fs(iH)][0] * I;
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = ACC[1] - VF[get_fs(iH)][1] * I;
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = ACC[2] - VF[get_fs(iH)][2] * I;
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = ACC[3] - VF[get_fs(iH)][3] * I;
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ }
+ break;
+ case 10: /* ADD, MADD, MUL, MAX */
+ switch (get_bc(iH)) {
+ case 0: /* ADD */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "ADD");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] =
+ VF[get_fs(iH)][0] + VF[get_ft(iH)][0];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] =
+ VF[get_fs(iH)][1] + VF[get_ft(iH)][1];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] =
+ VF[get_fs(iH)][2] + VF[get_ft(iH)][2];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] =
+ VF[get_fs(iH)][3] + VF[get_ft(iH)][3];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MADD */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MADD");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = ACC[0] +
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][0];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = ACC[1] +
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][1];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = ACC[2] +
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][2];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = ACC[3] +
+ VF[get_fs(iH)][3] * VF[get_ft(iH)][3];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* MUL */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MUL");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] =
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][0];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] =
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][1];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] =
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][2];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] =
+ VF[get_fs(iH)][3] * VF[get_ft(iH)][3];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 3: /* MAX */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MAX");
+ if (get_dest(iH) & DEST_X) {
+ if (VF[get_fs(iH)][0] > VF[get_ft(iH)][0]) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0];
+ } else {
+ pipe[0][0].vf[0] = VF[get_ft(iH)][0];
+ }
+ }
+ if (get_dest(iH) & DEST_Y) {
+ if (VF[get_fs(iH)][1] > VF[get_ft(iH)][1]) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1];
+ } else {
+ pipe[0][0].vf[1] = VF[get_ft(iH)][1];
+ }
+ }
+ if (get_dest(iH) & DEST_Z) {
+ if (VF[get_fs(iH)][2] > VF[get_ft(iH)][2]) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2];
+ } else {
+ pipe[0][0].vf[2] = VF[get_ft(iH)][2];
+ }
+ }
+ if (get_dest(iH) & DEST_W) {
+ if (VF[get_fs(iH)][3] > VF[get_ft(iH)][3]) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3];
+ } else {
+ pipe[0][0].vf[3] = VF[get_ft(iH)][3];
+ }
+ }
+ break;
+ }
+ break;
+ case 11: /* SUB, MSUB, OPMSUB, MINI */
+ switch (get_bc(iH)) {
+ case 0: /* SUB */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "SUB");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] =
+ VF[get_fs(iH)][0] - VF[get_ft(iH)][0];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] =
+ VF[get_fs(iH)][1] - VF[get_ft(iH)][1];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] =
+ VF[get_fs(iH)][2] - VF[get_ft(iH)][2];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] =
+ VF[get_fs(iH)][3] - VF[get_ft(iH)][3];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 1: /* MSUB */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "MSUB");
+ if (get_dest(iH) & DEST_X) {
+ pipe[0][0].vf[0] = ACC[0] -
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][0];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ }
+ if (get_dest(iH) & DEST_Y) {
+ pipe[0][0].vf[1] = ACC[1] -
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][1];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ }
+ if (get_dest(iH) & DEST_Z) {
+ pipe[0][0].vf[2] = ACC[2] -
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][2];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ }
+ if (get_dest(iH) & DEST_W) {
+ pipe[0][0].vf[3] = ACC[3] -
+ VF[get_fs(iH)][3] * VF[get_ft(iH)][3];
+ statuscheck(pipe[0][0].vf[3], &pipe[0][0].status, 3);
+ }
+ break;
+ case 2: /* OPMSUB */
+ if (hazardcheck(get_fs(iH), get_ft(iH), 0xe, 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = 0xe;
+ pipe[0][0].flag = 1;
+ strcpy(pipe[0][0].code, "OPMSUB");
+ pipe[0][0].vf[0] = ACC[0] -
+ VF[get_fs(iH)][1] * VF[get_ft(iH)][2];
+ statuscheck(pipe[0][0].vf[0], &pipe[0][0].status, 0);
+ pipe[0][0].vf[1] = ACC[1] -
+ VF[get_fs(iH)][2] * VF[get_ft(iH)][0];
+ statuscheck(pipe[0][0].vf[1], &pipe[0][0].status, 1);
+ pipe[0][0].vf[2] = ACC[2] -
+ VF[get_fs(iH)][0] * VF[get_ft(iH)][1];
+ statuscheck(pipe[0][0].vf[2], &pipe[0][0].status, 2);
+ break;
+ case 3: /* MINI */
+ if (hazardcheck(get_fs(iH), get_ft(iH), get_dest(iH), 3))
+ return 1;
+ pipe[0][0].no = get_fd(iH);
+ pipe[0][0].mask = get_dest(iH);
+ pipe[0][0].flag = 1;
+ if (get_dest(iH) & DEST_X) {
+ if (VF[get_fs(iH)][0] < VF[get_ft(iH)][0]) {
+ pipe[0][0].vf[0] = VF[get_fs(iH)][0];
+ } else {
+ pipe[0][0].vf[0] = VF[get_ft(iH)][0];
+ }
+ }
+ if (get_dest(iH) & DEST_Y) {
+ if (VF[get_fs(iH)][1] < VF[get_ft(iH)][1]) {
+ pipe[0][0].vf[1] = VF[get_fs(iH)][1];
+ } else {
+ pipe[0][0].vf[1] = VF[get_ft(iH)][1];
+ }
+ }
+ if (get_dest(iH) & DEST_Z) {
+ if (VF[get_fs(iH)][2] < VF[get_ft(iH)][2]) {
+ pipe[0][0].vf[2] = VF[get_fs(iH)][2];
+ } else {
+ pipe[0][0].vf[2] = VF[get_ft(iH)][2];
+ }
+ }
+ if (get_dest(iH) & DEST_W) {
+ if (VF[get_fs(iH)][3] < VF[get_ft(iH)][3]) {
+ pipe[0][0].vf[3] = VF[get_fs(iH)][3];
+ } else {
+ pipe[0][0].vf[3] = VF[get_ft(iH)][3];
+ }
+ }
+ break;
+ }
+ break;
+ case 15:
+ if (Upper_special(state, iH, iL))
+ return 1;
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(%08x)\n", iH);
+ exit(1);
+ }
+
+ if (iH & 0x80000000)
+ return 1;
+ if (iH & 0x04000000) {
+ /* DEBUG PRINT */
+ if (dpr_mode)
+ printf("\"%08lx\"\n", iL);
+ return 1;
+ }
+ /* LowerOp execute */
+ switch ((iL >> 27) & 0x1f) {
+ case 0: /* LQ, SQ, ---, --- */
+ if (iL & 0x00000400)
+ imm11 = (iL & 0x07ff) | 0xfffff800;
+ else
+ imm11 = iL & 0x07ff;
+ switch (get_ic(iL)) {
+ case 0: /* LQ */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL);
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "LQ");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] =
+ *(float *) &state->MEM[imm11 + VI[get_fs(iL)]][0];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] =
+ *(float *) &state->MEM[imm11 + VI[get_fs(iL)]][1];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] =
+ *(float *) &state->MEM[imm11 + VI[get_fs(iL)]][2];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] =
+ *(float *) &state->MEM[imm11 + VI[get_fs(iL)]][3];
+ break;
+ case 1: /* SQ */
+ if (hazardcheck(0, get_ft(iL), get_dest(iL), 1) ||
+ hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 2;
+ pipe[0][1].addr = imm11 + VI[get_ft(iL)];
+ strcpy(pipe[0][1].code, "SQ");
+ if (get_dest(iL) & DEST_X)
+ pipe[0][1].vf[0] = VF[get_fs(iL)][0];
+ if (get_dest(iL) & DEST_Y)
+ pipe[0][1].vf[1] = VF[get_fs(iL)][1];
+ if (get_dest(iL) & DEST_Z)
+ pipe[0][1].vf[2] = VF[get_fs(iL)][2];
+ if (get_dest(iL) & DEST_W)
+ pipe[0][1].vf[3] = VF[get_fs(iL)][3];
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ case 1: /* ILW, ISW, ---, --- */
+ if (iL & 0x00000400)
+ imm11 = (iL & 0x07ff) | 0xfffff800;
+ else
+ imm11 = iL & 0x07ff;
+ switch (get_ic(iL)) {
+ case 0: /* ILW */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].no = get_ft(iL) + 32;
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 1;
+ strcpy(pipe[0][1].code, "ILW");
+ if (get_dest(iL) & DEST_X)
+ *(long *) &pipe[0][1].vf[0] =
+ state->MEM[imm11 + VI[get_fs(iL)]][0];
+ if (get_dest(iL) & DEST_Y)
+ *(long *) &pipe[0][1].vf[1] =
+ state->MEM[imm11 + VI[get_fs(iL)]][1];
+ if (get_dest(iL) & DEST_Z)
+ *(long *) &pipe[0][1].vf[2] =
+ state->MEM[imm11 + VI[get_fs(iL)]][2];
+ if (get_dest(iL) & DEST_W)
+ *(long *) &pipe[0][1].vf[3] =
+ state->MEM[imm11 + VI[get_fs(iL)]][3];
+ break;
+ case 1: /* ISW */
+ if (hazardcheckVI(get_fs(iL), get_ft(iL), 3)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ pipe[0][1].mask = get_dest(iL);
+ pipe[0][1].flag = 2;
+ pipe[0][1].addr = imm11 + VI[get_fs(iL)];
+ strcpy(pipe[0][1].code, "ISW");
+ if (get_dest(iL) & DEST_X)
+ *(long *) &pipe[0][1].vf[0] = (VI[get_ft(iL)]) & 0xffff;
+ if (get_dest(iL) & DEST_Y)
+ *(long *) &pipe[0][1].vf[1] = (VI[get_ft(iL)]) & 0xffff;
+ if (get_dest(iL) & DEST_Z)
+ *(long *) &pipe[0][1].vf[2] = (VI[get_ft(iL)]) & 0xffff;
+ if (get_dest(iL) & DEST_W)
+ *(long *) &pipe[0][1].vf[3] = (VI[get_ft(iL)]) & 0xffff;
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ case 2: /* IADDIU, ISUBIU, ---, --- */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ imm15 = ((iL >> 10) & 0x7800) | (iL & 0x7ff);
+ switch (get_ic(iL)) {
+ case 0: /* IADDIU */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = VI[get_fs(iL)] + imm15;
+ strcpy(ipipe[0].code, "IADDIU");
+ break;
+ case 1: /* ISUBIU */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = VI[get_fs(iL)] - imm15;
+ strcpy(ipipe[0].code, "ISUBIU");
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ case 3:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08lx)\n", iL);
+ exit(1);
+ break;
+ case 4: /* FCEQ, FCSET, FCAND, FCOR */
+ imm24 = iL & 0x00ffffff;
+ switch (get_ic(iL)) {
+ case 0: /* FCEQ */
+ ipipe[0].no = 1;
+ ipipe[0].flag = 1;
+ if(clipflag == imm24)
+ ipipe[0].vi = 1;
+ else
+ ipipe[0].vi = 0;
+ strcpy(ipipe[0].code, "FCEQ");
+ break;
+ case 1: /* FCSET */
+ pipe[0][1].flag = 5;
+ pipe[0][1].status = imm24;
+ strcpy(pipe[0][1].code, "FCSET");
+ break;
+ case 2: /* FCAND */
+ ipipe[0].no = 1;
+ ipipe[0].flag = 1;
+ if(clipflag & imm24)
+ ipipe[0].vi = 1;
+ else
+ ipipe[0].vi = 0;
+ strcpy(ipipe[0].code, "FCAND");
+ break;
+ case 3: /* FCOR */
+ ipipe[0].no = 1;
+ ipipe[0].flag = 1;
+ if((clipflag | imm24) == 0x00ffffff)
+ ipipe[0].vi = 1;
+ else
+ ipipe[0].vi = 0;
+ strcpy(ipipe[0].code, "FCOR");
+ break;
+ }
+ break;
+ case 5: /* FSEQ, FSSET, FSAND, FSOR */
+ imm12 = ((iL >> 10) & 0x0800) | (iL & 0x7ff);
+ switch (get_ic(iL)) {
+ case 0: /* FSEQ */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ if(statusflag == imm12)
+ ipipe[0].vi = 1;
+ else
+ ipipe[0].vi = 0;
+ strcpy(ipipe[0].code, "FSEQ");
+ break;
+ case 1: /* FSSET */
+ pipe[0][1].flag = 4;
+ pipe[0][1].status = imm12 & 0xfc0;
+ strcpy(pipe[0][1].code, "FSSET");
+ break;
+ case 2: /* FSAND */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = statusflag & imm12;
+ strcpy(ipipe[0].code, "FSAND");
+ break;
+ case 3: /* FSOR */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = statusflag | imm12;
+ strcpy(ipipe[0].code, "FSOR");
+ break;
+ }
+ break;
+ case 6: /* FMEQ, NULL, FMAND, FMOR */
+ switch (get_ic(iL)) {
+ case 0: /* FMEQ */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ if ((short) MACflag == VI[get_fs(iL)])
+ ipipe[0].vi = 1;
+ else
+ ipipe[0].vi = 0;
+ strcpy(ipipe[0].code, "FMEQ");
+ break;
+ case 2: /* FMAND */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = (MACflag & 0xffff) & VI[get_fs(iL)];
+ strcpy(ipipe[0].code, "FMAND");
+ break;
+ case 3: /* FMOR */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = (MACflag & 0xffff) | VI[get_fs(iL)];
+ strcpy(ipipe[0].code, "FMOR");
+ break;
+ }
+ break;
+ case 7: /* FCGET, ---, ---, --- */
+ switch (get_ic(iL)) {
+ case 0: /* FCGET */
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = clipflag & 0x0fff;
+ strcpy(ipipe[0].code, "FCGET");
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ case 8: /* B, BAL, ---, --- */
+ if (iL & 0x00000400)
+ imm11 = (iL & 0x07ff) | 0xfffff800;
+ else
+ imm11 = iL & 0x07ff;
+ switch (get_ic(iL)) {
+ case 0: /* B */
+ jaddr = pc + imm11;
+ jflag = 1;
+ break;
+ case 1: /* BAL */
+ jaddr = pc + imm11;
+ jflag = 1;
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = pc + 1;
+ strcpy(ipipe[0].code, "BAL");
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ case 9: /* JR, JALR, ---, --- */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ switch (get_ic(iL)) {
+ case 0: /* JR */
+ jaddr = VI[get_fs(iL)];
+ jflag = 1;
+ break;
+ case 1: /* JALR */
+ jaddr = VI[get_fs(iL)];
+ jflag = 1;
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = pc + 1;
+ strcpy(ipipe[0].code, "JAL");
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ case 10: /* IBEQ, IBNE, NULL, NULL */
+ if (iL & 0x00000400)
+ imm11 = (iL & 0x07ff) | 0xfffff800;
+ else
+ imm11 = iL & 0x07ff;
+ if (hazardcheckVI(get_fs(iL), get_ft(iL), 3)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ switch (get_ic(iL)) {
+ case 0: /* IBEQ */
+ if (VI[get_ft(iL)] == VI[get_fs(iL)]) {
+ jaddr = pc + imm11;
+ jflag = 1;
+ }
+ break;
+ case 1: /* IBNE */
+ if (VI[get_ft(iL)] != VI[get_fs(iL)]) {
+ jaddr = pc + imm11;
+ jflag = 1;
+ }
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(LowerOp:%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ case 11: /* IBLTZ, IBGTZ, IBLEZ, IBGEZ */
+ if (iL & 0x00000400)
+ imm11 = (iL & 0x07ff) | 0xfffff800;
+ else
+ imm11 = iL & 0x07ff;
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ switch (get_ic(iL)) {
+ case 0: /* IBLTZ */
+ if (VI[get_fs(iL)] < 0) {
+ jaddr = pc + imm11;
+ jflag = 1;
+ }
+ break;
+ case 1: /* IBGTZ */
+ if (VI[get_fs(iL)] > 0) {
+ jaddr = pc + imm11;
+ jflag = 1;
+ }
+ break;
+ case 2: /* IBLEZ */
+ if (VI[get_fs(iL)] <= 0) {
+ jaddr = pc + imm11;
+ jflag = 1;
+ }
+ break;
+ case 3: /* IBGEZ */
+ if (VI[get_fs(iL)] >= 0) {
+ jaddr = pc + imm11;
+ jflag = 1;
+ }
+ break;
+ }
+ break;
+ case 16:
+ switch ((iL >> 2) & 0xf) {
+ case 12: /* IADD, ISUB, IADDI, --- */
+ switch (get_bc(iL)) {
+ case 0: /* IADD */
+ if (hazardcheckVI(get_fs(iL), get_ft(iL), 3)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ ipipe[0].no = get_fd(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = VI[get_fs(iL)] + VI[get_ft(iL)];
+ strcpy(ipipe[0].code, "IADD");
+ break;
+ case 1: /* ISUB */
+ if (hazardcheckVI(get_fs(iL), get_ft(iL), 3)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ ipipe[0].no = get_fd(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = VI[get_fs(iL)] - VI[get_ft(iL)];
+ strcpy(ipipe[0].code, "ISUB");
+ break;
+ case 2: /* IADDI */
+ if (hazardcheckVI(get_fs(iL), 0, 2)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ if (iL & 0x00000400)
+ imm5 = ((iL >> 6) & 0x1f) | 0xffffffe0;
+ else
+ imm5 = (iL >> 6) & 0x1f;
+ ipipe[0].no = get_ft(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = VI[get_fs(iL)] + imm5;
+ strcpy(ipipe[0].code, "IADDI");
+ break;
+ default:
+ fprintf(stderr,
+ "Undefined opcode(LowerOp:%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ case 13: /* IAND, IOR */
+ switch (get_bc(iL)) {
+ case 0: /* IAND */
+ if (hazardcheckVI(get_fs(iL), get_ft(iL), 3)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ ipipe[0].no = get_fd(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = VI[get_fs(iL)] & VI[get_ft(iL)];
+ strcpy(ipipe[0].code, "IAND");
+ break;
+ case 1: /* IOR */
+ if (hazardcheckVI(get_fs(iL), get_ft(iL), 3)) {
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ return 1;
+ }
+ ipipe[0].no = get_fd(iL);
+ ipipe[0].flag = 1;
+ ipipe[0].vi = VI[get_fs(iL)] | VI[get_ft(iL)];
+ strcpy(ipipe[0].code, "IOR");
+ break;
+ }
+ break;
+ case 15:
+ if (Lower_special(state, iL))
+ return 1;
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(%08lx)\n", iL);
+ exit(1);
+ }
+ break;
+ default:
+ fprintf(stderr, "Undefined opcode(%08lx)\n", iL);
+ exit(1);
+ }
+
+ return 2;
+}
+
+int fetch_inst(VectorUnitState *state)
+{
+/*
+[name] fetch_inst
+[desc.] instruction fetchs on Micro memory
+[args] void
+[return] 0: finished
+ 1: fetched
+*/
+ if (eflag != -1) {
+ if (sflag != 1) {
+ opc = pc;
+ instbuf[0] = state->uMEM[pc][0];
+ instbuf[1] = state->uMEM[pc][1];
+
+/* ihc */
+
+ printf("%04d: ", pc);
+ opcode_analyze(instbuf);
+ putchar('\n');
+
+/* -=ihc=- */
+ if (jflag == 1) {
+ pc = jaddr;
+ jflag = 0;
+ } else
+ if (eflag == 1) {
+ eflag = -1;
+ peflag = 1;
+ } else {
+ pc++;
+ }
+ }
+ return 1;
+ }
+ return 0;
+}
+
+/* move pipeline stage */
+int move_pipe(VectorUnitState *state)
+{
+/*
+[name] move_pipe
+[desc.] move value to next pipeline stage.
+[args] void
+[return] 0: no value exist in all pipeline stage
+ 1: some values exist in pipeline stage
+*/
+
+ int i, j, move = 0;
+
+ if (apipe.flag != 0) {
+ if (apipe.mask & DEST_X) {
+ ACC[0] = apipe.acc[0];
+ }
+ if (apipe.mask & DEST_Y) {
+ ACC[1] = apipe.acc[1];
+ }
+ if (apipe.mask & DEST_Z) {
+ ACC[2] = apipe.acc[2];
+ }
+ if (apipe.mask & DEST_W) {
+ ACC[3] = apipe.acc[3];
+ }
+ apipe.flag = 0;
+ }
+ if (ipipe[0].flag != 0) {
+ ipipe[0].flag = 0;
+ VI[ipipe[0].no] = ipipe[0].vi;
+ }
+ if (ipipe[0].flag != 0) {
+ ipipe[1].no = ipipe[0].no;
+ ipipe[1].flag = ipipe[0].flag;
+ ipipe[0].flag = 0;
+ ipipe[1].vi = ipipe[0].vi;
+ strcpy(ipipe[1].code, ipipe[0].code);
+ move = 1;
+ }
+
+ if (pipe[3][0].flag != 0) {
+ switch (pipe[3][0].flag) {
+ case 1:/* move to VF-reg */
+ if (pipe[3][0].mask & DEST_X) {
+ VF[pipe[3][0].no][0] = pipe[3][0].vf[0];
+ }
+ if (pipe[3][0].mask & DEST_Y) {
+ VF[pipe[3][0].no][1] = pipe[3][0].vf[1];
+ }
+ if (pipe[3][0].mask & DEST_Z) {
+ VF[pipe[3][0].no][2] = pipe[3][0].vf[2];
+ }
+ if (pipe[3][0].mask & DEST_W) {
+ VF[pipe[3][0].no][3] = pipe[3][0].vf[3];
+ }
+ statusflag = (statusflag & 0x00000ff0) |
+ ((pipe[3][0].status & 0x0f) << 6) |
+ (pipe[3][0].status & 0x0f);
+ MACflag = (pipe[3][0].status >> 16) & 0xffff;
+ break;
+ case 2:/* store from VF-reg */
+ if (pipe[3][0].mask & DEST_X) {
+ state->MEM[pipe[3][0].addr][0] = pipe[3][0].vf[0];
+ }
+ if (pipe[3][0].mask & DEST_Y) {
+ state->MEM[pipe[3][0].addr][1] = pipe[3][0].vf[1];
+ }
+ if (pipe[3][0].mask & DEST_Z) {
+ state->MEM[pipe[3][0].addr][2] = pipe[3][0].vf[2];
+ }
+ if (pipe[3][0].mask & DEST_W) {
+ state->MEM[pipe[3][0].addr][3] = pipe[3][0].vf[3];
+ }
+ break;
+ case 3:/* move to I-reg */
+ I = pipe[3][0].vf[0];
+ break;
+ case 4:/* status only */
+ statusflag = (statusflag & 0x00000ff0) |
+ ((pipe[3][0].status & 0x0f) << 6) |
+ (pipe[3][0].status & 0x0f);
+ MACflag = (pipe[3][0].status >> 16) & 0xffff;
+ case 5:
+ clipflag = (clipflag << 6) & 0x00ffffc0 |
+ (pipe[3][0].status & 0x3f);
+ break;
+ }
+ pipe[3][0].flag = 0;
+ }
+ if (qpipe[6].flag != 0) {
+ qpipe[6].flag = 0;
+ Q = qpipe[6].vf[0];
+ statusflag = (statusflag & 0xfcf) |
+ (qpipe[6].status << 6) | qpipe[6].status;
+ }
+ for (i = 5; i >= 0; i--) {
+ if (qpipe[i].flag != 0) {
+ qpipe[i + 1].vf[0] = qpipe[i].vf[0];
+ qpipe[i + 1].flag = qpipe[i].flag;
+ qpipe[i + 1].status = qpipe[i].status;
+ qpipe[i].flag = 0;
+ strcpy(qpipe[i + 1].code, qpipe[i].code);
+ move = 1;
+ }
+ }
+
+ if (rqpipe[12].flag != 0) {
+ rqpipe[12].flag = 0;
+ Q = rqpipe[12].vf[0];
+ statusflag = (statusflag & 0xfcf) |
+ (rqpipe[12].status << 6) | rqpipe[12].status;
+ }
+ for (i = 11; i >= 0; i--) {
+ if (rqpipe[i].flag != 0) {
+ rqpipe[i + 1].vf[0] = rqpipe[i].vf[0];
+ rqpipe[i + 1].flag = rqpipe[i].flag;
+ rqpipe[i + 1].status = rqpipe[i].status;
+ rqpipe[i].flag = 0;
+ move = 1;
+ }
+ }
+ if (pipe[3][1].flag != 0) {
+ switch (pipe[3][1].flag) {
+ case 1:
+ if (pipe[3][1].no > 31) {
+ if (pipe[3][1].mask & DEST_X) {
+ VI[(pipe[3][1].no) & 0x1f] =
+ *(long *) &pipe[3][1].vf[0] & 0xffff;
+ }
+ if (pipe[3][1].mask & DEST_Y) {
+ VI[(pipe[3][1].no) & 0x1f] =
+ *(long *) &pipe[3][1].vf[1] & 0xffff;
+ }
+ if (pipe[3][1].mask & DEST_Z) {
+ VI[(pipe[3][1].no) & 0x1f] =
+ *(long *) &pipe[3][1].vf[2] & 0xffff;
+ }
+ if (pipe[3][1].mask & DEST_W) {
+ VI[(pipe[3][1].no) & 0x1f] =
+ *(long *) &pipe[3][1].vf[3] & 0xffff;
+ }
+ } else {
+ if (pipe[3][1].mask & DEST_X) {
+ VF[pipe[3][1].no][0] = pipe[3][1].vf[0];
+ }
+ if (pipe[3][1].mask & DEST_Y) {
+ VF[pipe[3][1].no][1] = pipe[3][1].vf[1];
+ }
+ if (pipe[3][1].mask & DEST_Z) {
+ VF[pipe[3][1].no][2] = pipe[3][1].vf[2];
+ }
+ if (pipe[3][1].mask & DEST_W) {
+ VF[pipe[3][1].no][3] = pipe[3][1].vf[3];
+ }
+ }
+ break;
+ case 2:
+ if (strcmp(pipe[3][1].code, "ISW") == 0) {
+ if (pipe[3][1].mask & DEST_X) {
+ state->MEM[pipe[3][1].addr][0] =
+ (*(long *) &pipe[3][1].vf[0]) & 0xffff;
+ }
+ if (pipe[3][1].mask & DEST_Y) {
+ state->MEM[pipe[3][1].addr][1] =
+ (*(long *) &pipe[3][1].vf[1]) & 0xffff;
+ }
+ if (pipe[3][1].mask & DEST_Z) {
+ state->MEM[pipe[3][1].addr][2] =
+ (*(long *) &pipe[3][1].vf[2]) & 0xffff;
+ }
+ if (pipe[3][1].mask & DEST_W) {
+ state->MEM[pipe[3][1].addr][3] =
+ (*(long *) &pipe[3][1].vf[3]) & 0xffff;
+ }
+ } else {
+ if (pipe[3][1].mask & DEST_X) {
+ state->MEM[pipe[3][1].addr][0] = *(long *) &pipe[3][1].vf[0];
+ }
+ if (pipe[3][1].mask & DEST_Y) {
+ state->MEM[pipe[3][1].addr][1] = *(long *) &pipe[3][1].vf[1];
+ }
+ if (pipe[3][1].mask & DEST_Z) {
+ state->MEM[pipe[3][1].addr][2] = *(long *) &pipe[3][1].vf[2];
+ }
+ if (pipe[3][1].mask & DEST_W) {
+ state->MEM[pipe[3][1].addr][3] = *(long *) &pipe[3][1].vf[3];
+ }
+ }
+ break;
+ case 3:/* move to I-reg */
+ I = pipe[3][1].vf[0];
+ break;
+ case 4:
+ statusflag = pipe[3][1].status;
+ break;
+ case 5:
+ clipflag = pipe[3][1].status;
+ break;
+ case 6:
+ if (pipe[3][1].mask & DEST_X) {
+ VN[0] = pipe[3][1].vf[0];
+ }
+ if (pipe[3][1].mask & DEST_Y) {
+ VN[1] = pipe[3][1].vf[1];
+ }
+ if (pipe[3][1].mask & DEST_Z) {
+ VN[2] = pipe[3][1].vf[2];
+ }
+ if (pipe[3][1].mask & DEST_W) {
+ VN[3] = pipe[3][1].vf[3];
+ }
+ break;
+ case 7:
+ if (pipe[3][1].mask & DEST_X) {
+ VF[pipe[3][1].no][0] = pipe[3][1].vf[0];
+ }
+ if (pipe[3][1].mask & DEST_Y) {
+ VF[pipe[3][1].no][1] = pipe[3][1].vf[1];
+ }
+ if (pipe[3][1].mask & DEST_Z) {
+ VF[pipe[3][1].no][2] = pipe[3][1].vf[2];
+ }
+ if (pipe[3][1].mask & DEST_W) {
+ VF[pipe[3][1].no][3] = pipe[3][1].vf[3];
+ }
+ break;
+ }
+ pipe[3][1].flag = 0;
+ }
+ for (i = 2; i >= 0; i--) {
+ if (pipe[i][0].flag != 0) {
+ move = 1;
+ pipe[i + 1][0].flag = pipe[i][0].flag;
+ pipe[i][0].flag = 0;
+ for (j = 0; j < 4; j++) {
+ pipe[i + 1][0].vf[j] = pipe[i][0].vf[j];
+ }
+ pipe[i + 1][0].no = pipe[i][0].no;
+ pipe[i + 1][0].mask = pipe[i][0].mask;
+ pipe[i + 1][0].addr = pipe[i][0].addr;
+ pipe[i + 1][0].status = pipe[i][0].status;
+ pipe[i][0].status = 0;
+ strcpy(pipe[i + 1][0].code, pipe[i][0].code);
+ }
+ if (pipe[i][1].flag != 0) {
+ move = 1;
+ pipe[i + 1][1].flag = pipe[i][1].flag;
+ pipe[i][1].flag = 0;
+ for (j = 0; j < 4; j++) {
+ pipe[i + 1][1].vf[j] = pipe[i][1].vf[j];
+ }
+ pipe[i + 1][1].no = pipe[i][1].no;
+ pipe[i + 1][1].mask = pipe[i][1].mask;
+ pipe[i + 1][1].addr = pipe[i][1].addr;
+ pipe[i + 1][1].status = pipe[i][1].status;
+ pipe[i][1].status = 0;
+ strcpy(pipe[i + 1][1].code, pipe[i][1].code);
+ }
+ }
+ if (spipe.no != 0) {
+ if (spipe.no == 1) {
+ spipe.no = 0;
+ if (spipe.flag == 1) {
+ VN[0] = spipe.vn;
+ } else {
+ VN[4] = spipe.vn;
+ }
+ spipe.flag = 0;
+ } else {
+ spipe.no--;
+ }
+ }
+ if (Ipipe.flag) {
+ I = Ipipe.val;
+ Ipipe.flag = 0;
+ }
+ return move;
+}
+
+void printpipe(void)
+{
+/*
+[name] printpipe
+[desc.] print out pipeline status to stdout. (for debug mode)
+[args] void
+[return] void
+*/
+
+ int i;
+ for (i = 0; i < 4; i++) {
+ switch (pipe[i][0].flag) {
+ case 0:/* not charged */
+ printf("Up:%d(nocharge)\n", i);
+ break;
+ case 1:/* move to reg */
+ printf("Up:%d(%s) -> VF%02d\n",
+ i, pipe[i][0].code, pipe[i][0].no);
+ if (pipe[i][0].mask & DEST_W)
+ printf("<%f>", pipe[i][0].vf[3]);
+ else
+ printf("<--->");
+ if (pipe[i][0].mask & DEST_Z)
+ printf("<%f>", pipe[i][0].vf[2]);
+ else
+ printf("<--->");
+ if (pipe[i][0].mask & DEST_Y)
+ printf("<%f>", pipe[i][0].vf[1]);
+ else
+ printf("<--->");
+ if (pipe[i][0].mask & DEST_X)
+ printf("<%f>\n", pipe[i][0].vf[0]);
+ else
+ printf("<--->\n");
+ break;
+ case 2:/* store from reg */
+ printf("Up:%d(%s) -> 0x%x\n",
+ i, pipe[i][0].code, pipe[i][0].addr);
+ break;
+ case 4:/* only status */
+ printf("Up:%d(%s) -> status <0x%08x>\n",
+ i, pipe[i][0].code, pipe[i][0].status);
+ break;
+ case 5:/* only clip */
+ printf("Up:%d(%s) -> clip <0x%04x>\n",
+ i, pipe[i][0].code, pipe[i][0].status);
+ break;
+ }
+ }
+ for (i = 0; i < 4; i++) {
+ switch (pipe[i][1].flag) {
+ case 1:/* move to reg */
+ if (pipe[i][1].no > 31) {
+ printf("Lo:%d(%s) -> VI%02d",
+ i, pipe[i][1].code, pipe[i][1].no - 32);
+ if (pipe[i][1].mask & DEST_X)
+ printf(" <%f>\n", pipe[i][1].vf[0]);
+ if (pipe[i][1].mask & DEST_Y)
+ printf(" <%f>\n", pipe[i][1].vf[1]);
+ if (pipe[i][1].mask & DEST_Z)
+ printf(" <%f>\n", pipe[i][1].vf[2]);
+ if (pipe[i][1].mask & DEST_W)
+ printf(" <%f>\n", pipe[i][1].vf[3]);
+ } else {
+ printf("Lo:%d(%s) -> VF%02d\n",
+ i, pipe[i][1].code, pipe[i][1].no);
+ if (pipe[i][1].mask & DEST_W)
+ printf("<%f>", pipe[i][1].vf[3]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_Z)
+ printf("<%f>", pipe[i][1].vf[2]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_Y)
+ printf("<%f>", pipe[i][1].vf[1]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_X)
+ printf("<%f>\n", pipe[i][1].vf[0]);
+ else
+ printf("<--->\n");
+ }
+ break;
+ case 2:/* store from reg */
+ printf("Lo:%d(%s) -> 0x%x\n",
+ i, pipe[i][1].code, pipe[i][1].addr);
+ if (pipe[i][1].mask & DEST_W)
+ printf("<%f>", pipe[i][1].vf[3]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_Z)
+ printf("<%f>", pipe[i][1].vf[2]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_Y)
+ printf("<%f>", pipe[i][1].vf[1]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_X)
+ printf("<%f>\n", pipe[i][1].vf[0]);
+ else
+ printf("<--->\n");
+ break;
+ case 3:/* move to I-reg */
+ printf("Lo:%d(LOI) -> I <%f>\n", i, pipe[i][1].vf[0]);
+ case 4:/* only status */
+ printf("Lo:%d(%s) -> status <0x%08x>\n",
+ i, pipe[i][1].code, pipe[i][1].status);
+ break;
+ case 5:/* only clip */
+ printf("Lo:%d(%s) -> clip <0x%04x>\n",
+ i, pipe[i][1].code, pipe[i][1].status);
+ break;
+ case 6:/* move to EFU */
+ printf("EFU:%d(MFP)\n", i);
+ if (pipe[i][1].mask & DEST_W)
+ printf("<%f>", pipe[i][1].vf[3]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_Z)
+ printf("<%f>", pipe[i][1].vf[2]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_Y)
+ printf("<%f>", pipe[i][1].vf[1]);
+ else
+ printf("<--->");
+ if (pipe[i][1].mask & DEST_X)
+ printf("<%f>\n", pipe[i][1].vf[0]);
+ else
+ printf("<--->\n");
+ break;
+ case 7:/* move from EFU */
+ printf("EFU:%d(MFP->VF%02d)", i, pipe[i][1].no);
+ if (pipe[i][1].mask & DEST_W)
+ printf("<%f>", pipe[i][1].vf[3]);
+ if (pipe[i][1].mask & DEST_Z)
+ printf("<%f>", pipe[i][1].vf[2]);
+ if (pipe[i][1].mask & DEST_Y)
+ printf("<%f>", pipe[i][1].vf[1]);
+ if (pipe[i][1].mask & DEST_X)
+ printf("<%f>", pipe[i][1].vf[0]);
+ printf("\n");
+ break;
+ }
+ }
+ for (i = 0; i < 2; i++) {
+ if (ipipe[i].flag) {
+ printf("Lo:%d(%s) -> VI%02d <%d>\n",
+ i, ipipe[i].code, ipipe[i].no, ipipe[i].vi);
+ }
+ }
+ if (spipe.no != 0) {
+ printf("EFU(%d): <%f>\n", spipe.no, spipe.vn);
+ }
+ for (i = 0; i < 7; i++) {
+ if (qpipe[i].flag) {
+ printf("q_pipe(%d)<%s> -> %f\n",
+ 6 - i, qpipe[i].code, qpipe[i].vf[0]);
+ }
+ }
+}
+
+
+void printlist(VectorUnitState *state, char *buf)
+{
+/*
+[name] printlist
+[desc.] print out instruction list to stdout (for debug mode)
+[args] buf: input data from debug mode command line
+[return] void
+*/
+
+ char dmy[32];
+ int no, i;
+ u_long inst[2];
+
+ if (index(buf, ' ') != (char *) NULL) {
+ sscanf(buf, "%s %d", dmy, &no);
+ } else {
+ no = opc;
+ }
+ for (i = 0; i < 10; i++) {
+ inst[0] = state->uMEM[no + i][0];
+ inst[1] = state->uMEM[no + i][1];
+ printf("%04d: ", no + i);
+ opcode_analyze(inst);
+ putchar('\n');
+ }
+}
+
+void printreg(VectorUnitState *state, char *buf)
+{
+/*
+[name] printreg
+[desc.] print out register values(float or int) to stdout
+[args] buf: input data from debug mode command line
+[return] void
+*/
+
+ int i;
+ char dmy[32];
+
+ if (buf[1] == 'F') {
+ if(buf[2] == 0){
+ for(i = 0; i < 32; i++){
+ printf("VF%02d <%f> <%f> <%f> <%f>\n",
+ i, VF[i][3], VF[i][2], VF[i][1], VF[i][0]);
+ }
+ }else{
+ sscanf(buf, "VF%d", &i);
+ printf("VF%02d <%f> <%f> <%f> <%f>\n",
+ i, VF[i][3], VF[i][2], VF[i][1], VF[i][0]);
+ }
+ } else {
+ if (buf[1] == 'I') {
+ if (buf[2] == 0){
+ for(i = 0; i < 16; i++){
+ printf("VI%02d <%d>\n", i, VI[i]);
+ }
+ }else{
+ sscanf(buf, "VI%d", &i);
+ printf("VI%02d <%d>\n", i, VI[i]);
+ }
+ }
+ }
+}
+
+void printregI(VectorUnitState *state, char *buf)
+{
+/*
+[name] printreg
+[desc.] print out register values(hex) to stdout
+[args] buf: input data from debug mode command line
+[return] void
+*/
+
+ int i;
+ char dmy[32];
+
+ if (buf[1] == 'f') {
+ if(buf[2] == 0) {
+ for(i = 0; i < 32; i++){
+ printf("VF%02d <%08lx> <%08lx> <%08lx> <%08lx>\n",
+ i, *(u_long *) & (VF[i][3]), *(u_long *) & (VF[i][2]),
+ *(u_long *) & (VF[i][1]), *(u_long *) & (VF[i][0]));
+ }
+ }else{
+ sscanf(buf, "vf%d", &i);
+ printf("VF%02d <%08lx> <%08lx> <%08lx> <%08lx>\n",
+ i, *(u_long *) & (VF[i][3]), *(u_long *) & (VF[i][2]),
+ *(u_long *) & (VF[i][1]), *(u_long *) & (VF[i][0]));
+ }
+ } else {
+ if (buf[1] == 'i') {
+ if (buf[2] == 0){
+ for(i = 0; i < 16; i++){
+ printf("VI%02d <%x>\n", i, VI[i]);
+ }
+ }else{
+ sscanf(buf, "vi%d", &i);
+ printf("VI%02d <%x>\n", i, VI[i]);
+ }
+ }
+ }
+}
+
+void setVFreg(VectorUnitState *state, char *buf)
+{
+/*
+[name] setVFreg
+[desc.] set value to VF regster (for debug mode)
+[args] buf: input data from debug mode command line
+[return] void
+*/
+
+ int no;
+ float val0, val1, val2, val3;
+
+ sscanf(buf, "F%d %f %f %f %f\n", &no, &val0, &val1, &val2, &val3);
+ if ((no <= 0) || (no > 31)) {
+ printf("cannot set value VF%02d\n", no);
+ } else {
+ VF[no][0] = val3;
+ VF[no][1] = val2;
+ VF[no][2] = val1;
+ VF[no][3] = val0;
+ printf("VF%02d <%f> <%f> <%f> <%f>\n",
+ no, VF[no][3], VF[no][2], VF[no][1], VF[no][0]);
+ }
+}
+
+void setVIreg(VectorUnitState *state, char *buf)
+{
+/*
+[name] setVIreg
+[desc.] set value to VI regster (for debug mode)
+[args] buf: input data from debug mode command line
+[return] void
+*/
+
+ int no, val;
+
+ sscanf(buf, "I%d %d\n", &no, &val);
+ if ((no <= 0) || (no > 24)) {
+ printf("cannot set value VI%02d\n", no);
+ } else {
+ VI[no] = val;
+ printf("VI%02d <%d>\n", no, VI[no]);
+ }
+}
+
+void interactive(VectorUnitState *state)
+{
+/*
+[name] interactive
+[desc.] debug mode monitor
+[args] void
+[return] void
+*/
+
+ int stat = 1;
+ char buf[128];
+ char dmy[32];
+ int addr;
+
+ printf("%04d: ", opc);
+ opcode_analyze(instbuf);
+ putchar('\n');
+ while (stat) {
+ printf(">", opc);
+ gets(buf);
+ switch (buf[0]) {
+ case 'b': /* breakpoint */
+ sscanf(buf, "%s %d", dmy, &bp);
+ break;
+ case 'p': /* pipe */
+ printpipe();
+ break;
+ case 'r': /* run */
+ sscanf(buf, "%s %d", dmy, &pc);
+ intr_mode = 1;
+ stat = 0;
+ break;
+ case 'e': /* end count */
+ sscanf(buf, "%s %d", dmy, &ecount);
+ intr_mode = 4;
+ stat = 0;
+ break;
+ case 'd': /* dump state->MEM by hex */
+ sscanf(buf, "%s %d", dmy, &addr);
+ printf("%04d %08lx %08lx %08lx %08lx\n", addr,
+ state->MEM[addr][3], state->MEM[addr][2], state->MEM[addr][1], state->MEM[addr][0]);
+ break;
+ case 'D': /* dump state->MEM by float */
+ sscanf(buf, "%s %d", dmy, &addr);
+ printf("%04d %f %f %f %f\n", addr,
+ *(float *) &state->MEM[addr][3], *(float *) &state->MEM[addr][2],
+ *(float *) &state->MEM[addr][1], *(float *) &state->MEM[addr][0]);
+ break;
+ case 'l': /* list */
+ printlist(state, buf);
+ break;
+ case 's': /* step */
+ intr_mode = 2;
+ stat = 0;
+ break;
+ case 'c': /* continue */
+ intr_mode = 3;
+ stat = 0;
+ break;
+ case 'i': /* print I */
+ printf("I : %f\n", I);
+ break;
+ case 'V': /* print reg */
+ printreg(state, buf);
+ break;
+ case 'v': /* print reg */
+ printregI(state, buf);
+ break;
+ case 'F': /* set val to VF reg */
+ setVFreg(state, buf);
+ break;
+ case 'I': /* set val to VI reg */
+ setVIreg(state, buf);
+ break;
+ case 'Q': /* print Q */
+ printf("Q : %f\n", Q);
+ break;
+ case 'P': /* print P */
+ printf("P : %f\n", VN[4]);
+ break;
+ case 'R': /* print R */
+ printf("R : 0x%08lx\n", R);
+ break;
+ case 'A': /* print ACC */
+ printf("ACC:<%f> <%f> <%f> <%f>\n",
+ ACC[0], ACC[1], ACC[2], ACC[3]);
+ break;
+ case 'M': /* print MAC flag */
+ printf("MAC:<%04lx>\n", MACflag);
+ break;
+ case 'S': /* print status flag */
+ printf("status:<%03lx>\n", statusflag);
+ break;
+ case 'C': /* print clip flag */
+ printf("clip:<%03lx>\n", clipflag);
+ break;
+ case 'h': /* help */
+ printf("COMMAND LIST\n");
+ printf("r[un]\n");
+ printf("b[reakpoint] <addr>\n");
+ printf("c[ontinue]\n");
+ printf("s[tep]\n");
+ printf("l[ist] <addr>\n");
+ printf("p[ipe]\n");
+ printf("VF<num>(float)\n");
+ printf("vf<num>(hex)\n");
+ printf("VI<num>\n");
+ printf("F<num> <val> <val> <val> <val>\n");
+ printf("I<num> <val>\n");
+ printf("Q\n");
+ printf("P\n");
+ printf("R\n");
+ printf("M[ac flag]\n");
+ printf("S[tatus flag]\n");
+ printf("C[lip flag]\n");
+ printf("d[ump state->MEM(hex)] <addr>\n");
+ printf("D[ump state->MEM(float)] <addr>\n");
+ printf("e[nd count] <num>\n");
+ printf("h[elp]\n");
+ break;
+ default:
+ break;
+ }
+ }
+}
+
+
+void simvpe(VectorUnitState *state)
+{
+/*
+[name] simvpe
+[desc.] VU simulation main routine.
+ Need to set below variables and call initvpe,
+ befor call this routine.
+ _ITOP, _TOP, _vpepc, _is_dbg, _is_verb, _isdump, _pgpuif
+[args] void
+[return] void
+*/
+
+ int stat = 1;
+
+ eflag = 0;
+ jflag = 0;
+ peflag = 0;
+ sflag = 0;
+ verb_mode = _is_verb;
+ dpr_mode = _is_dump;
+ pc = _vpepc;
+ if ((intr_mode > 0) && (intr_mode < 3)) {
+ printf("simvpe interactive mode\n");
+ bp = _vpepc + 1;
+ }
+ if ((intr_mode == 4) && (ecount == 0)){
+ bp = _vpepc + 1;
+ }
+ fetch_inst(state);
+ while (stat) {
+ stat = 0;
+ all_count++;
+ if (((intr_mode == 1) && (pc == bp)) ||
+ ((intr_mode == 3) && (pc == bp)) ||
+ ((intr_mode == 4) && (pc == bp)) ||
+ (intr_mode == 2)) {
+ interactive(state);
+ }
+ if (exec_inst(state))
+ stat += 1;
+ if (fetch_inst(state))
+ stat += 2;
+ if (move_pipe(state))
+ stat += 8;
+ }
+ _vpepc = pc + 1;
+ ecount--;
+
+ if (verb_mode) {
+ printf("\n>> all cycles = %d cycle\n", all_count);
+ printf(">> all hazard stall cycles = %d cycle\n", hc_count);
+ }
+}
+
+void LoadVUMem(VectorUnitState *state, int dst_addr, u_long * src_addr, int qsize)
+{
+/*
+[name] LoadVUMem
+[desc.] Set values to VU memory
+[args] dst_addr: destination address of VU memory to set values.
+ (The byte order of destination values is big endian.)
+ src_addr: source address of values to set.
+ (The byte order of source values is little endian)
+ qsize: count of values to set ( quad ward )
+[return] void
+*/
+
+ int i;
+ u_long eldata[4];
+
+ for (i = 0; i < qsize; i++) {
+ /* convert little endian to bigendian. */
+ eldata[3] = src_addr[0] << 24 | ((src_addr[0] << 8) & 0xff0000) |
+ ((src_addr[0] >> 8) & 0xff00) | ((src_addr[0] >> 24) & 0xff);
+ eldata[2] = src_addr[1] << 24 | ((src_addr[1] << 8) & 0xff0000) |
+ ((src_addr[1] >> 8) & 0xff00) | ((src_addr[1] >> 24) & 0xff);
+ eldata[1] = src_addr[2] << 24 | ((src_addr[2] << 8) & 0xff0000) |
+ ((src_addr[2] >> 8) & 0xff00) | ((src_addr[2] >> 24) & 0xff);
+ eldata[0] = src_addr[3] << 24 | ((src_addr[3] << 8) & 0xff0000) |
+ ((src_addr[3] >> 8) & 0xff00) | ((src_addr[3] >> 24) & 0xff);
+ state->MEM[dst_addr + i][0] = eldata[0];
+ state->MEM[dst_addr + i][1] = eldata[1];
+ state->MEM[dst_addr + i][2] = eldata[2];
+ state->MEM[dst_addr + i][3] = eldata[3];
+ src_addr += 4;
+ }
+}
+
+void LoadMMem(VectorUnitState *state, int dst_addr, u_long * src_addr, int dwsize)
+{
+/*
+[name] LoadMMem
+[desc.] Set instructions to Micro memory
+[args] dst_addr: destination address of Micro memory
+ to set instructions
+ (The byte order of destination values is big endian.)
+ src_addr: source address of instructions to set
+ (The byte order of source values is little endian.)
+ dwsize: count of values to set ( double ward )
+[return] void
+*/
+
+ int i;
+ u_long elop[2];
+
+ for (i = 0; i < dwsize; i++) {
+ /* convert little endian to big endian. */
+ elop[1] = src_addr[0] << 24 | ((src_addr[0] << 8) & 0xff0000) |
+ ((src_addr[0] >> 8) & 0xff00) | ((src_addr[0] >> 24) & 0xff);
+ elop[0] = src_addr[1] << 24 | ((src_addr[1] << 8) & 0xff0000) |
+ ((src_addr[1] >> 8) & 0xff00) | ((src_addr[1] >> 24) & 0xff);
+ state->uMEM[dst_addr + i][0] = elop[0];
+ state->uMEM[dst_addr + i][1] = elop[1];
+ src_addr += 2;
+ }
+}
+
+void StoreVUMem(VectorUnitState *state, int src_addr, u_long * dst_addr, int qsize)
+{
+/*
+[name] StoreVUMem
+[desc.] Get values from VU memory
+[args] src_addr: source address of VU memory to get values
+ (The byte order of source values is big endian.)
+ dst_addr: destination address of values to get
+ (The byte order of destination values is little endian.)
+ qsize: count of values to get (quad ward)
+[return] void
+*/
+
+ int i;
+ u_long data[4];
+
+ for (i = 0; i < qsize; i++) {
+ data[3] = state->MEM[src_addr + i][0];
+ data[2] = state->MEM[src_addr + i][1];
+ data[1] = state->MEM[src_addr + i][2];
+ data[0] = state->MEM[src_addr + i][3];
+ /* convert big endian to little endian. */
+ dst_addr[3] = data[3] << 24 | ((data[3] << 8) & 0xff0000) |
+ ((data[3] >> 8) & 0xff00) | ((data[3] >> 24) & 0xff);
+ dst_addr[2] = data[2] << 24 | ((data[2] << 8) & 0xff0000) |
+ ((data[2] >> 8) & 0xff00) | ((data[2] >> 24) & 0xff);
+ dst_addr[1] = data[1] << 24 | ((data[1] << 8) & 0xff0000) |
+ ((data[1] >> 8) & 0xff00) | ((data[1] >> 24) & 0xff);
+ dst_addr[0] = data[0] << 24 | ((data[0] << 8) & 0xff0000) |
+ ((data[0] >> 8) & 0xff00) | ((data[0] >> 24) & 0xff);
+
+ dst_addr += 4;
+ }
+}
+
+void StoreMMem(VectorUnitState *state, int src_addr, u_long * dst_addr, int dwsize)
+{
+/*
+[name] StoreMMem
+[desc.] Get instructions from Micro memory
+[args] src_addr: source address of Micro memory to get instructions
+ (The byte order of source values is big endian.)
+ dst_addr: destination address of instructions to get
+ (The byte order of destination values is little endian.)
+ qsize: count of instructions to get (quad ward)
+[return] void
+*/
+
+ int i;
+ u_long data[2];
+
+ for (i = 0; i < dwsize; i++) {
+ data[1] = state->uMEM[src_addr + i][0];
+ data[0] = state->uMEM[src_addr + i][1];
+ /* convert big endian to little endian. */
+ dst_addr[1] = data[1] << 24 | ((data[1] << 8) & 0xff0000) |
+ ((data[1] >> 8) & 0xff00) | ((data[1] >> 24) & 0xff);
+ dst_addr[0] = data[0] << 24 | ((data[0] << 8) & 0xff0000) |
+ ((data[0] >> 8) & 0xff00) | ((data[0] >> 24) & 0xff);
+ dst_addr += 2;
+ }
+}
+
+void vpecallms_init(VectorUnitState *state)
+{
+/*
+[name] vpecallms_init
+[desc.] Initialize internal status of VU simulator
+ when start to execute a Micro program.
+ This routine doesn't use with simvpe().
+ This routine use with vpecallms_cycle() and initvpe().
+[args] void
+[return] void
+*/
+
+ eflag = 0;
+ jflag = 0;
+ peflag = 0;
+ sflag = 0;
+ intr_mode = _is_dbg;
+ verb_mode = _is_verb;
+ dpr_mode = _is_dump;
+ pc = _vpepc;
+}
+
+void vpecallms_cycle(VectorUnitState* state)
+{
+/*
+[name] vpecallms_cycle
+[desc.] VU simulator execute 1cycle.
+[args] void
+[return] !0: VU is busy
+ 0: VU is idle
+*/
+ int stat = 0;
+
+ if (fetch_inst(state)) stat = 1;
+ if (exec_inst(state)) stat = 2;
+ if (move_pipe(state)) stat = 4;
+ _vpepc = pc + 1;
+
+ if (stat) {
+ state->regs.VPE_STAT.vbs = 1;
+ } else {
+ state->regs.VPE_STAT.vbs = 0;
+ }
+}
+
+#if 0
+void simvpe2(VectorUnitState *state)
+{
+/*
+[name] simvpe2
+[desc.] VU simulate same as simvpe(). ( sample routine )
+[args] void
+[return] void
+*/
+
+ vpecallms_init(state);
+ while (vpecallms_cycle(state));
+}
+#endif
+
+/*--------------------------------------------------------------------------*/
+
+/****************************************************************************/
+/* */
+/* Sony Computer Entertainment CONFIDENTIAL */
+/* (C) 1997 Sony Computer Entertainment Inc. All Rights Reserved */
+/* */
+/* Experimental disassembler */
+/* */
+/****************************************************************************/
+
+#include <sys/types.h>
+
+void p_bc(u_long opcode)
+{
+ switch(opcode&0x3){
+ case 0:
+ putchar('x'); break;
+ case 1:
+ putchar('y'); break;
+ case 2:
+ putchar('z'); break;
+ case 3:
+ putchar('w'); break;
+ }
+}
+
+void p_dest(u_long opcode)
+{
+ switch((opcode >> 21) & 0xf){
+ case 1:
+ printf("w"); break;
+ case 2:
+ printf("z"); break;
+ case 3:
+ printf("wz"); break;
+ case 4:
+ printf("y"); break;
+ case 5:
+ printf("yw"); break;
+ case 6:
+ printf("yz"); break;
+ case 7:
+ printf("yzw"); break;
+ case 8:
+ printf("x"); break;
+ case 9:
+ printf("xw"); break;
+ case 10:
+ printf("xz"); break;
+ case 11:
+ printf("xzw"); break;
+ case 12:
+ printf("xy"); break;
+ case 13:
+ printf("xyw"); break;
+ case 14:
+ printf("xyz"); break;
+ case 15:
+ printf("xyzw"); break;
+ }
+}
+
+void bc_reg(u_long opcode)
+{
+ putchar('/'); p_dest(opcode);
+
+ printf(" VF%02d", (opcode >> 6) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_bc(opcode);
+}
+
+void par_reg3(u_long opcode)
+{
+ printf(" VF%02d", (opcode >> 6) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+}
+
+void par_reg_ds(u_long opcode)
+{
+ printf(" VF%02d", (opcode >> 6) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+}
+
+void mul_q(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("MULq/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", Q");
+ break;
+ case 1:
+ printf("MAXi/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", I");
+ break;
+ case 2:
+ printf("MULi/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", I");
+ break;
+ case 3:
+ printf("MINIi/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", I");
+ break;
+ }
+}
+
+void add_q(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("ADDq/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", Q");
+ break;
+ case 1:
+ printf("MADDq/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", Q");
+ break;
+ case 2:
+ printf("ADDi/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", I");
+ break;
+ case 3:
+ printf("MADDi/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", I");
+ break;
+ }
+}
+
+void sub_q(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("SUBq/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", Q");
+ break;
+ case 1:
+ printf("MSUBq/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", Q");
+ break;
+ case 2:
+ printf("SUBi/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", I");
+ break;
+ case 3:
+ printf("MSUBi/"); p_dest(opcode);
+ par_reg_ds(opcode);
+ printf(", I");
+ break;
+ }
+}
+
+void add(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("ADD/"); p_dest(opcode);
+ par_reg3(opcode);
+ break;
+ case 1:
+ printf("MADD/"); p_dest(opcode);
+ par_reg3(opcode);
+ break;
+ case 2:
+ printf("MUL/"); p_dest(opcode);
+ par_reg3(opcode);
+ break;
+ case 3:
+ printf("MAX/"); p_dest(opcode);
+ par_reg3(opcode);
+ break;
+ }
+}
+
+void sub(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("SUB/"); p_dest(opcode);
+ par_reg3(opcode);
+ break;
+ case 1:
+ printf("MSUB/"); p_dest(opcode);
+ par_reg3(opcode);
+ break;
+ case 2:
+ printf("OPMSUB/xyz, VF%02dxyz", (opcode >> 6) & 0x1f);
+ printf(", VF%02dxyz, VF%02dxyz", (opcode >> 11) & 0x1f,
+ (opcode >> 16) & 0x1f);
+ break;
+ case 3:
+ printf("MINI/"); p_dest(opcode);
+ par_reg3(opcode);
+ break;
+ }
+}
+
+void bc_acc(u_long opcode)
+{
+ putchar('/'); p_dest(opcode);
+
+ printf(" ACC"); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_bc(opcode);
+}
+
+void itof(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("0/"); break;
+ case 1:
+ printf("4/"); break;
+ case 2:
+ printf("12/"); break;
+ case 3:
+ printf("15/"); break;
+ }
+ p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+}
+
+void par_reg_s(u_long opcode)
+{
+ printf(" ACC"); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+}
+
+void mula_q(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("MULAq/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", Q");
+ break;
+ case 1:
+ printf("ABS/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ break;
+ case 2:
+ printf("MULAi/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", I");
+ break;
+ case 3:
+ printf("CLIPw/xyz");
+ printf(" VF%02dxyz", (opcode >> 11) & 0x1f);
+ printf(", VF%02dw", (opcode >> 16) & 0x1f);
+ break;
+ }
+}
+
+void adda_q(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("ADDAq/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", Q");
+ break;
+ case 1:
+ printf("MADDAq/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", Q");
+ break;
+ case 2:
+ printf("ADDAi/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", I");
+ break;
+ case 3:
+ printf("MADDAi/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", I");
+ break;
+ }
+}
+
+void suba_q(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("SUBAq/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", Q");
+ break;
+ case 1:
+ printf("MSUBAq/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", Q");
+ break;
+ case 2:
+ printf("SUBAi/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", I");
+ break;
+ case 3:
+ printf("MSUBAi/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", I");
+ break;
+ }
+}
+
+void adda(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("ADDA/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ break;
+ case 1:
+ printf("MADDA/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ break;
+ case 2:
+ printf("MULA/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ break;
+ case 3:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void suba(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("SUBA/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ break;
+ case 1:
+ printf("MSUBA/"); p_dest(opcode);
+ par_reg_s(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ break;
+ case 2:
+ printf("OPMULA/xyz ACCxyz, VF%02d", (opcode >> 11) & 0x1f);
+ p_dest(opcode);
+ printf(", VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ break;
+ case 3:
+ printf("NOP");
+ break;
+ }
+}
+
+void special(u_long opcode)
+{
+ switch((opcode >> 6) & 0xf) { /* bit41-38 */
+ case 0:
+ printf("ADDA"); p_bc(opcode);
+ bc_acc(opcode); break;
+ case 1:
+ printf("SUBA"); p_bc(opcode);
+ bc_acc(opcode); break;
+ case 2:
+ printf("MADDA"); p_bc(opcode);
+ bc_acc(opcode); break;
+ case 3:
+ printf("MSUBA"); p_bc(opcode);
+ bc_acc(opcode); break;
+ case 4:
+ printf("ITOF");
+ itof(opcode); break;
+ case 5:
+ printf("FTOI");
+ itof(opcode); break;
+ case 6:
+ printf("MULA"); p_bc(opcode);
+ bc_acc(opcode); break;
+ case 7:
+ mula_q(opcode); break;
+ case 8:
+ adda_q(opcode); break;
+ case 9:
+ suba_q(opcode); break;
+ case 10:
+ adda(opcode); break;
+ case 11:
+ suba(opcode); break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void quad_load(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("LQ/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", %d(VI%02d)", opcode & 0x7ff, (opcode >> 11) & 0x1f);
+ break;
+ case 1:
+ printf("SQ/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ printf(", %d(VI%02d)", opcode & 0x7ff, (opcode >> 16) & 0x1f);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void int_load(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("ILW/"); p_dest(opcode);
+ printf(" VI%02d", (opcode >> 16) & 0x1f);
+ printf(", %d(VI%02d)", opcode & 0x7ff, (opcode >> 11) & 0x1f);
+ break;
+ case 1:
+ printf("ISW/"); p_dest(opcode);
+ printf(" VI%02d", (opcode >> 16) & 0x1f);
+ printf(", %d(VI%02d)", opcode & 0x7ff, (opcode >> 11) & 0x1f);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void int_br(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("IBEQ");
+ printf(" VI%02d, VI%02d, 0x%x",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f, opcode & 0x7ff);
+ break;
+ case 1:
+ printf("IBNE");
+ printf(" VI%02d, VI%02d, 0x%x",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f, opcode & 0x7ff);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void cond_int_br(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("IBLTZ");
+ printf(" VI%02d, 0x%x", (opcode >> 11) & 0x1f, opcode & 0x7ff);
+ break;
+ case 1:
+ printf("IBGTZ");
+ printf(" VI%02d, 0x%x", (opcode >> 11) & 0x1f, opcode & 0x7ff);
+ break;
+ case 2:
+ printf("IBLEZ");
+ printf(" VI%02d, 0x%x", (opcode >> 11) & 0x1f, opcode & 0x7ff);
+ break;
+ case 3:
+ printf("IBGEZ");
+ printf(" VI%02d, 0x%x", (opcode >> 11) & 0x1f, opcode & 0x7ff);
+ break;
+ }
+}
+
+void br(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("B 0x%x", opcode & 0x7ff);
+ break;
+ case 1:
+ printf("BAL VI%02d, 0x%x", (opcode >> 16) & 0x1f, opcode & 0x7ff);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void jr(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("JR VI%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 1:
+ printf("JALR VI%02d, VI%02d",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void uint_add(u_long opcode)
+{
+ u_int imm;
+
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("IADDIU");
+ imm = ((opcode >> 10) & 0x7800) | (opcode & 0x7ff);
+ printf(" VI%02d, VI%02d, %d",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f, imm);
+ break;
+ case 1:
+ printf("ISUBIU");
+ imm = ((opcode >> 10) & 0x7800) | (opcode & 0x7ff);
+ printf(" VI%02d, VI%02d, %d",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f, imm);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void fceq(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("FCEQ 0x%x", opcode & 0x00ffffff);
+ break;
+ case 1:
+ printf("FCSET 0x%x", opcode & 0x00ffffff);
+ break;
+ case 2:
+ printf("FCAND 0x%x", opcode & 0x00ffffff);
+ break;
+ case 3:
+ printf("FCOR 0x%x", opcode & 0x00ffffff);
+ break;
+ }
+}
+
+void fseq(u_long opcode)
+{
+ u_long imm12;
+
+ imm12 = ((opcode & 0x00200000) >> 10) |
+ (opcode & 0x7ff);
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("FSEQ VI%02d, 0x%x", (opcode >> 16) & 0x1f, imm12);
+ break;
+ case 1:
+ printf("FSSET 0x%x", imm12);
+ break;
+ case 2:
+ printf("FSAND VI%02d, 0x%x", (opcode >> 16) & 0x1f, imm12);
+ break;
+ case 3:
+ printf("FSOR VI%02d, 0x%x", (opcode >> 16) & 0x1f, imm12);
+ break;
+ }
+}
+
+void fcget(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("FCGET VI%02d", (opcode >> 16) & 0x1f);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void fmand(u_long opcode)
+{
+ switch((opcode >> 25) & 0x3){
+ case 0:
+ printf("FMEQ VI%02d, VI%02d",
+ (opcode >> 11) & 0x1f, (opcode >> 16) & 0x1f);
+ break;
+ case 2:
+ printf("FMAND VI%02d, VI%02d",
+ (opcode >> 11) & 0x1f, (opcode >> 16) & 0x1f);
+ break;
+ case 3:
+ printf("FMOR VI%02d, VI%02d",
+ (opcode >> 11) & 0x1f, (opcode >> 16) & 0x1f);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void iand(u_long opcode)
+{
+ int imm5;
+ switch(opcode & 0x3){
+ case 0:
+ printf("IAND VI%02d, VI%02d, VI%02d",
+ (opcode >> 6) & 0x1f, (opcode >> 11) & 0x1f,
+ (opcode >> 16) & 0x1f);
+ break;
+ case 1:
+ printf("IOR VI%02d, VI%02d, VI%02d",
+ (opcode >> 6) & 0x1f, (opcode >> 11) & 0x1f,
+ (opcode >> 16) & 0x1f);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+void iadd(u_long opcode)
+{
+ int imm5;
+ switch(opcode & 0x3){
+ case 0:
+ printf("IADD VI%02d, VI%02d, VI%02d",
+ (opcode >> 6) & 0x1f, (opcode >> 11) & 0x1f,
+ (opcode >> 16) & 0x1f);
+ break;
+ case 1:
+ printf("ISUB VI%02d, VI%02d, VI%02d",
+ (opcode >> 6) & 0x1f, (opcode >> 11) & 0x1f,
+ (opcode >> 16) & 0x1f);
+ break;
+ case 2:
+ if(opcode & 0x0400){
+ imm5 = ((opcode >> 6) & 0x1f) | 0xffffffe0;
+ }else
+ imm5 = ((opcode >> 6) & 0x1f);
+ printf("IADDI VI%02d, VI%02d, %d",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f, imm5);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void move(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ if(((opcode >> 11 & 0x1f) == 0) && ((opcode >> 16) & 0x1f) == 0){
+ printf("NOP");
+ }else{
+ printf("MOVE/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ }
+ break;
+ case 1:
+ printf("MR32/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+}
+
+void pinc_load(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("LQI/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", VI%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 1:
+ printf("SQI/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ printf(", VI%02d", (opcode >> 16) & 0x1f);
+ break;
+ case 2:
+ printf("LQD/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", VI%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 3:
+ printf("SQD/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 11) & 0x1f); p_dest(opcode);
+ printf(", VI%02d", (opcode >> 16) & 0x1f);
+ break;
+ }
+}
+
+void p_ftf(u_long ftf)
+{
+ switch(ftf){
+ case 0:
+ putchar('x');
+ break;
+ case 1:
+ putchar('y');
+ break;
+ case 2:
+ putchar('z');
+ break;
+ case 3:
+ putchar('w');
+ break;
+ }
+}
+
+void mftir(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("MTIR/"); p_dest(opcode);
+ printf(" VI%02d, VF%02d",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f);
+ p_dest(opcode);
+ break;
+ case 1:
+ printf("MFIR/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", VI%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 2:
+ printf("ILWR/"); p_dest(opcode);
+ printf(" VI%02d, VI%02d",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f);
+ break;
+ case 3:
+ printf("ISWR/"); p_dest(opcode);
+ printf(" VI%02d, VI%02d",
+ (opcode >> 16) & 0x1f, (opcode >> 11) & 0x1f);
+ break;
+ }
+}
+
+void div(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("DIV Q, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ printf(", VF%02d", (opcode >> 16) & 0x1f);
+ p_ftf((opcode >> 23) & 0x3);
+ break;
+ case 1:
+ printf("SQRT Q, VF%02d", (opcode >> 16) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ case 2:
+ printf("RSQRT Q, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ printf(", VF%02d", (opcode >> 16) & 0x1f);
+ p_ftf((opcode >> 23) & 0x3);
+ break;
+ case 3:
+ printf("WAITQ");
+ break;
+ }
+}
+
+void esadd_ersadd(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("ESADD");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 1:
+ printf("ERSADD");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 2:
+ printf("ELENG");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 3:
+ printf("ERLENG");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ break;
+ }
+}
+
+void esrsqrt(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("ESQRT");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ case 1:
+ printf("ERSQRT");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ case 2:
+ printf("ERCPR");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ case 3:
+ printf("WAITP");break;
+ }
+}
+
+void eatanxyz(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("EATANxy");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 1:
+ printf("EATANxz");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ break;
+ case 2:
+ printf("ESUM");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ break;
+ }
+}
+
+void esinatan(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("ESIN");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ case 1:
+ printf("EATAN");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ case 2:
+ printf("EEXP");
+ printf(" P, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ }
+}
+
+void mfp(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("MFP/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", P");
+ break;
+ }
+}
+
+void xgkick(u_long opcode)
+{
+ printf("XGKICK VI%02d", (opcode >> 11) &0x1f);
+}
+
+void xitop(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("XTOP VI%02d", (opcode >> 16) & 0x1f);
+ break;
+ case 1:
+ printf("XITOP VI%02d", (opcode >> 16) & 0x1f);
+ break;
+ }
+}
+
+void rand(u_long opcode)
+{
+ switch(opcode & 0x3){
+ case 0:
+ printf("RNEXT/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", R");
+ break;
+ case 1:
+ printf("RGET/"); p_dest(opcode);
+ printf(" VF%02d", (opcode >> 16) & 0x1f); p_dest(opcode);
+ printf(", R");
+ break;
+ case 2:
+ printf("RINIT R, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ case 3:
+ printf("RXOR R, VF%02d", (opcode >> 11) & 0x1f);
+ p_ftf((opcode >> 21) & 0x3);
+ break;
+ }
+}
+
+void Special_Low(u_long opcode)
+{
+ switch((opcode >> 6) & 0x1f){
+ case 12:
+ move(opcode); break;
+ case 13:
+ pinc_load(opcode); break;
+ case 14:
+ div(opcode); break;
+ case 15:
+ mftir(opcode); break;
+ case 16:
+ rand(opcode); break;
+ case 25:
+ mfp(opcode); break;
+ case 26:
+ xitop(opcode); break;
+ case 27:
+ xgkick(opcode); break;
+ case 28:
+ esadd_ersadd(opcode); break;
+ case 29:
+ eatanxyz(opcode); break;
+ case 30:
+ esrsqrt(opcode); break;
+ case 31:
+ esinatan(opcode); break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode);
+ break;
+ }
+
+}
+
+void maj_spcial(u_long opcode)
+{
+ if(((opcode >> 2) & 0xf) == 12){
+ iadd(opcode);
+ }else
+ if(((opcode >> 2) & 0xf) == 13){
+ iand(opcode);
+ }else
+ if(((opcode >> 2) & 0xf) == 15){
+ Special_Low(opcode);
+ }else{
+ printf("Undefined opcode(%08lx)", opcode);
+ }
+}
+
+void opcode_analyze(u_long *opcode)
+{
+ /* UpperOp */
+ switch((opcode[0] >> 2) & 0xf){ /* bit37-34 */
+ case 0:
+ printf("ADD"); p_bc(opcode[0]);
+ bc_reg(opcode[0]); break;
+ case 1:
+ printf("SUB"); p_bc(opcode[0]);
+ bc_reg(opcode[0]); break;
+ case 2:
+ printf("MADD"); p_bc(opcode[0]);
+ bc_reg(opcode[0]); break;
+ case 3:
+ printf("MSUB"); p_bc(opcode[0]);
+ bc_reg(opcode[0]); break;
+ case 4:
+ printf("MAX"); p_bc(opcode[0]);
+ bc_reg(opcode[0]); break;
+ case 5:
+ printf("MINI"); p_bc(opcode[0]);
+ bc_reg(opcode[0]); break;
+ case 6:
+ printf("MUL"); p_bc(opcode[0]);
+ bc_reg(opcode[0]); break;
+ case 7:
+ mul_q(opcode[0]); break;
+ case 8:
+ add_q(opcode[0]); break;
+ case 9:
+ sub_q(opcode[0]); break;
+ case 10:
+ add(opcode[0]); break;
+ case 11:
+ sub(opcode[0]); break;
+ case 15:
+ special(opcode[0]); break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode[0]);
+ break;
+ }
+
+ printf(" | ");
+
+ /* LowerOp */
+ if(opcode[0]&0x80000000){
+ printf("LOI %f", *(float *)&opcode[1]);
+ }else
+ if(opcode[0]&0x40000000){
+ printf("END");
+ }else
+ if(opcode[0]&0x04000000){
+ printf("PRT %08lx", opcode[1]);
+ }else{
+ switch((opcode[1] >> 27) & 0x1f){
+ case 0:
+ quad_load(opcode[1]); break;
+ case 1:
+ int_load(opcode[1]); break;
+ case 2:
+ uint_add(opcode[1]); break;
+ case 4:
+ fceq(opcode[1]); break;
+ case 5:
+ fseq(opcode[1]); break;
+ case 6:
+ fmand(opcode[1]); break;
+ case 7:
+ fcget(opcode[1]); break;
+ case 8:
+ br(opcode[1]); break;
+ case 9:
+ jr(opcode[1]); break;
+ case 10:
+ int_br(opcode[1]); break;
+ case 11:
+ cond_int_br(opcode[1]); break;
+ case 16:
+ maj_spcial(opcode[1]); break;
+ default:
+ printf("Undefined opcode(%08lx)", opcode[1]);
+ break;
+ }
+ }
+
+}
+
+#if 0
+void main(int argc, char **argv)
+{
+ FILE *fpr;
+ char rfilename[64];
+ u_long opcode[2];
+ u_long elop[2];
+ int count = 0;
+
+ if(argc < 2){
+ fprintf(stderr, "Usage: dpppasm filename\n");
+ exit(1);
+ }
+ strcpy(rfilename, argv[1]);
+ if((fpr = fopen(rfilename, "r")) == NULL){
+ fprintf(stderr, "can not open %s\n", rfilename);
+ exit(1);
+ }
+
+ while(fread(&elop[0], 4, 2, fpr) != 0){
+ opcode[0] = (elop[1] << 24 ) | ((elop[1] << 8) & 0xff0000) |
+ ((elop[1] >> 8) & 0xff00) | ((elop[1] >> 24) & 0xff);
+ opcode[1] = (elop[0] << 24 ) | ((elop[0] << 8) & 0xff0000) |
+ ((elop[0] >> 8) & 0xff00) | ((elop[0] >> 24) & 0xff);
+ printf("%04d: ", count++);
+ opcode_analyze(opcode);
+ putchar('\n');
+ }
+
+ fclose(fpr);
+}
+#endif
+
+/****************************************************************************/
+/* */
+/* Sony Computer Entertainment CONFIDENTIAL */
+/* (C) 1997 Sony Computer Entertainment Inc. All Rights Reserved */
+/* */
+/* Psuedo GPUIF simulator (handle only PATH1) */
+/* */
+/****************************************************************************/
+
+#define PRIM 0x00
+#define RGBAQ 0x01
+#define ST 0x02
+#define UV 0x03
+#define XYZF2 0x04
+#define XYZ2 0x05
+#define TEX0_1 0x06
+#define TEX0_2 0x07
+#define CLAMP_1 0x08
+#define CLAMP_2 0x09
+#define XYZF 0x0a
+#define XYZF3 0x0c
+#define XYZ3 0x0d
+#define A_D 0x0e
+#define GPUNOP 0x0f
+
+#define NOOUT 0
+#define PRTGPUIF 1
+#define PRTGPU 2
+#define PRTGPI 3
+
+extern int _GIF_SIM_OFF;
+extern int _GIF_BUSY;
+extern int _GIF_VUCALL;
+extern int _GIF_VUADDR;
+
+static u_long stQ;
+extern int _pgpuif;
+extern FILE *_fp_gpu;
+
+void GPU2_Put_gpu(int addr, u_long reg1, u_long reg0)
+{
+ float xx, yy;
+
+ fprintf(_fp_gpu,"%02x %08lx %08lx\n", addr, reg1, reg0);
+}
+
+void GPU2_Put_gpi(int addr, u_long reg1, u_long reg0)
+{
+ float xx, yy;
+ int ctxt, fst, aa1, abe, fge, tme, iip, prim;
+
+ switch(addr){
+ case PRIM:
+ fprintf(_fp_gpu, "PRIM PRIM=%d ", (reg0 & 0x7));
+ if(reg0 & 0x200)
+ fprintf(_fp_gpu, "CTXT=1 ");
+ if(reg0 & 0x100)
+ fprintf(_fp_gpu, "FST=1 ");
+ if(reg0 & 0x80)
+ fprintf(_fp_gpu, "AA1=1 ");
+ if(reg0 & 0x40)
+ fprintf(_fp_gpu, "ABE=1 ");
+ if(reg0 & 0x20)
+ fprintf(_fp_gpu, "FGE=1 ");
+ if(reg0 & 0x10)
+ fprintf(_fp_gpu, "TME=1 ");
+ if(reg0 & 0x8)
+ fprintf(_fp_gpu, "IIP=1 ");
+ fprintf(_fp_gpu, "\n");
+ break;
+ case RGBAQ:
+ xx = *(float *)®1;
+ fprintf(_fp_gpu, "RGBAQ %d %d %d %d %e\n", reg0&0xff, (reg0>>8)&0xff,
+ (reg0>>16)&0xff, (reg0>>24)&0xff, xx);
+ break;
+ case ST:
+ xx = *(float *)®0;
+ yy = *(float *)®1;
+ fprintf(_fp_gpu, "ST %e %e\n", xx, yy);
+ break;
+ case UV:
+ xx = (float)(reg0 & 0xffff)/16.0;
+ yy = (float)((reg0 >> 16) & 0xffff)/16.0;
+ fprintf(_fp_gpu, "UV %f %f\n", xx, yy);
+ break;
+ case XYZF2:
+ xx = (float)(reg0&0xffff)/16.0;
+ yy = (float)((reg0 >> 16)&0xffff)/16.0;
+ fprintf(_fp_gpu, "XYZF2 %f %f %d %d\n", xx, yy,
+ reg1&0xffffff, (reg1>>24)&0xff);
+ break;
+ case XYZ2:
+ xx = (float)(reg0&0xffff)/16.0;
+ yy = (float)((reg0 >> 16)&0xffff)/16.0;
+ fprintf(_fp_gpu, "XYZ2 %f %f %d \n", xx, yy, reg1);
+ break;
+ case XYZF:
+ xx = (float)(reg0&0xffff)/16.0;
+ yy = (float)((reg0 >> 16)&0xffff)/16.0;
+ fprintf(_fp_gpu, "XYZF %f %f %d %d\n", xx, yy,
+ reg1&0xffffff, (reg1>>24)&0xff);
+ break;
+ case XYZF3:
+ xx = (float)(reg0&0xffff)/16.0;
+ yy = (float)((reg0 >> 16)&0xffff)/16.0;
+ fprintf(_fp_gpu, "XYZF3 %f %f %d %d\n", xx, yy,
+ reg1&0xffffff, (reg1>>24)&0xff);
+ break;
+ case XYZ3:
+ xx = (float)(reg0&0xffff)/16.0;
+ yy = (float)((reg0 >> 16)&0xffff)/16.0;
+ fprintf(_fp_gpu, "XYZ3 %f %f %d\n", xx, yy, reg1);
+ break;
+ case A_D:
+ fprintf(_fp_gpu, "!%02x %08lx %08lx\n", addr, reg1, reg0);
+ break;
+ case GPUNOP:
+ break;
+ default:
+ fprintf(_fp_gpu, "!%02x %08lx %08lx\n", addr, reg1, reg0);
+ break;
+ }
+}
+
+void to_gpu(VectorUnitState *state, int regno, int addr)
+{
+ u_long reg0, reg1;
+
+ switch(regno){
+ case RGBAQ:
+ reg0 = (state->MEM[addr][0] & 0xff) | ((state->MEM[addr][1] & 0xff) << 8) |
+ ((state->MEM[addr][2] & 0xff) << 16) | ((state->MEM[addr][3] & 0xff) << 24);
+ switch(_pgpuif){
+ case NOOUT:
+ break;
+ case PRTGPUIF:
+ break;
+ case PRTGPU:
+ GPU2_Put_gpu(RGBAQ, stQ, reg0);
+ break;
+ case PRTGPI:
+ GPU2_Put_gpi(RGBAQ, stQ, reg0);
+ break;
+ }
+ break;
+ case UV:
+ reg0 = (state->MEM[addr][0] & 0xffff) | ((state->MEM[addr][1] & 0xffff) << 16);
+ switch(_pgpuif){
+ case NOOUT:
+ break;
+ case PRTGPUIF:
+ break;
+ case PRTGPU:
+ GPU2_Put_gpu(UV, 0, reg0);
+ break;
+ case PRTGPI:
+ GPU2_Put_gpi(UV, 0, reg0);
+ break;
+ }
+ break;
+ case XYZF2:
+ case XYZF3:
+ reg0 = (state->MEM[addr][0] & 0xffff) | ((state->MEM[addr][1] & 0xffff) << 16);
+ reg1 = ((state->MEM[addr][2]>>4) & 0xffffff) |
+ (((state->MEM[addr][3]>>4) & 0xff) << 24);
+ switch(_pgpuif){
+ case NOOUT:
+ break;
+ case PRTGPUIF:
+ break;
+ case PRTGPU:
+ if(state->MEM[addr][3] & 0x8000)
+ GPU2_Put_gpu(XYZF3, reg1, reg0);
+ else
+ GPU2_Put_gpu(XYZF2, reg1, reg0);
+ break;
+ case PRTGPI:
+ if(state->MEM[addr][3] & 0x8000)
+ GPU2_Put_gpi(XYZF3, reg1, reg0);
+ else
+ GPU2_Put_gpi(XYZF2, reg1, reg0);
+ break;
+ }
+ break;
+ case ST:
+ stQ = state->MEM[addr][2];
+ case PRIM:
+ case TEX0_1:
+ case TEX0_2:
+ case CLAMP_1:
+ case CLAMP_2:
+ switch(_pgpuif){
+ case NOOUT:
+ break;
+ case PRTGPUIF:
+ break;
+ case PRTGPU:
+ GPU2_Put_gpu(regno, state->MEM[addr][1], state->MEM[addr][0]);
+ break;
+ case PRTGPI:
+ GPU2_Put_gpi(regno, state->MEM[addr][1], state->MEM[addr][0]);
+ break;
+ }
+ break;
+ case A_D:
+ switch(_pgpuif){
+ case NOOUT:
+ break;
+ case PRTGPUIF:
+ break;
+ case PRTGPU:
+ GPU2_Put_gpu(state->MEM[addr][2] & 0xff, state->MEM[addr][1], state->MEM[addr][0]);
+ break;
+ case PRTGPI:
+ GPU2_Put_gpi(state->MEM[addr][2] & 0xff, state->MEM[addr][1], state->MEM[addr][0]);
+ break;
+ }
+ break;
+ }
+}
+
+void GpuIfKick(VectorUnitState *state, int addr)
+{
+ int nreg, flg, prim, pre, nloop;
+ int regs[16], i, j;
+ u_long tag0;
+
+ if(_GIF_SIM_OFF){
+ if(_GIF_BUSY){
+ sflag = 1;
+ hc_count++;
+ pipe[0][0].flag = 0;
+ apipe.flag = 0;
+ }else{
+ _GIF_VUCALL = 1;
+ _GIF_VUADDR = addr;
+ _GIF_BUSY = 1;
+ sflag = 0;
+ }
+ }else{
+ tag0 = state->MEM[addr][0];
+ nreg = (state->MEM[addr][1] >> 28) & 0xf;
+ flg = (state->MEM[addr][1] >> 26) & 0x3;
+ prim = (state->MEM[addr][1] >> 15) & 0x7ff;
+ pre = (state->MEM[addr][1] >> 14) & 0x1;
+ nloop = state->MEM[addr][0] & 0x7fff;
+ do {
+ tag0 = state->MEM[addr][0];
+ nreg = (state->MEM[addr][1] >> 28) & 0xf;
+ flg = (state->MEM[addr][1] >> 26) & 0x3;
+ prim = (state->MEM[addr][1] >> 15) & 0x7ff;
+ pre = (state->MEM[addr][1] >> 14) & 0x1;
+ nloop = state->MEM[addr][0] & 0x7fff;
+
+ if(nreg == 0) nreg = 16;
+ if(flg != 0){
+ fprintf(stderr, "GIF: not support FLG(%d)<%d>\n", flg, addr);
+ return;
+ }
+ for(i = 0; i < 8; i++)
+ regs[i] = (state->MEM[addr][2] >> (i * 4)) & 0xf;
+
+ for(i = 8; i < 16; i++)
+ regs[i] = (state->MEM[addr][3] >> ((i - 8) * 4)) & 0xf;
+
+ if(pre){
+ switch(_pgpuif){
+ case NOOUT:
+ case PRTGPUIF:
+ break;
+ case PRTGPU:
+ GPU2_Put_gpu(PRIM, 0, (u_long)prim);
+ break;
+ case PRTGPI:
+ GPU2_Put_gpi(PRIM, 0, (u_long)prim);
+ break;
+ }
+ }
+
+ if(_pgpuif == PRTGPUIF)
+ fprintf(_fp_gpu, "%08lx %08lx %08lx %08lx\n",
+ state->MEM[addr][3], state->MEM[addr][2], state->MEM[addr][1], state->MEM[addr][0]);
+
+ addr++;
+ for(i = 0; i < nloop; i++){
+ for(j = 0; j < nreg; j++){
+ if(_pgpuif == PRTGPUIF){
+ fprintf(_fp_gpu, "%08lx %08lx %08lx %08lx\n",
+ state->MEM[addr][3], state->MEM[addr][2], state->MEM[addr][1], state->MEM[addr][0]);
+ }else{
+ to_gpu(state, regs[j], addr);
+ }
+ addr++;
+ }
+ }
+ }while((tag0 & 0x8000) == 0);
+ }
+
+}
projects / external / binutils.git / commitdiff