#define ITYPE_JMP 1 /* jump instructions */
#define ITYPE_IMM 2 /* immediate instructions */
#define ITYPE_MEM 3 /* memory instructions */
-#define ITYPE_BRA 4 /* branch instructions */
-#define ITYPE_RIMM 5 /* special/branch instructions */
-#define ITYPE_OP 6 /* integer instructions */
-#define ITYPE_TRAP 7 /* trap instructions */
-#define ITYPE_DIVMUL 8 /* integer divide/multiply instructions */
-#define ITYPE_MTOJR 9 /* move to and jump register instructions */
-#define ITYPE_MFROM 10 /* move from instructions */
-#define ITYPE_SYS 11 /* operating system instructions */
-#define ITYPE_FOP 12 /* floating point instructions */
-#define ITYPE_FOP2 13 /* 2 operand floating point instructions */
-#define ITYPE_FCMP 14 /* floating point compare instructions */
+#define ITYPE_FMEM 4 /* floating point memory instructions */
+#define ITYPE_BRA 5 /* branch instructions */
+#define ITYPE_RIMM 6 /* special/branch instructions */
+#define ITYPE_OP 7 /* integer instructions */
+#define ITYPE_TRAP 8 /* trap instructions */
+#define ITYPE_DIVMUL 9 /* integer divide/multiply instructions */
+#define ITYPE_MTOJR 10 /* move to and jump register instructions */
+#define ITYPE_MFROM 11 /* move from instructions */
+#define ITYPE_SYS 12 /* operating system instructions */
+#define ITYPE_FOP 13 /* floating point instructions */
+#define ITYPE_FOP2 14 /* 2 operand floating point instructions */
+#define ITYPE_FCMP 15 /* floating point compare instructions */
/* instruction decode table for 6 bit op codes */
static struct {char *name; int itype;} ops[] = {
- /* 0x00 */ {"SPECIAL ", ITYPE_OP},
- /* 0x01 */ {"REGIMM ", ITYPE_RIMM},
- /* 0x02 */ {"J ", ITYPE_JMP},
- /* 0x03 */ {"JAL ", ITYPE_JMP},
- /* 0x04 */ {"BEQ ", ITYPE_BRA},
- /* 0x05 */ {"BNE ", ITYPE_BRA},
- /* 0x06 */ {"BLEZ ", ITYPE_BRA},
- /* 0x07 */ {"BGTZ ", ITYPE_BRA},
-
- /* 0x08 */ {"ADDI ", ITYPE_IMM},
- /* 0x09 */ {"ADDIU ", ITYPE_IMM},
- /* 0x0a */ {"SLTI ", ITYPE_IMM},
- /* 0x0b */ {"SLTIU ", ITYPE_IMM},
- /* 0x0c */ {"ANDI ", ITYPE_IMM},
- /* 0x0d */ {"ORI ", ITYPE_IMM},
- /* 0x0e */ {"XORI ", ITYPE_IMM},
- /* 0x0f */ {"LUI ", ITYPE_IMM},
-
- /* 0x10 */ {"COP0 ", ITYPE_OP},
- /* 0x11 */ {"COP1 ", ITYPE_FOP},
- /* 0x12 */ {"COP2 ", ITYPE_OP},
+ /* 0x00 */ {"special ", ITYPE_OP},
+ /* 0x01 */ {"regimm ", ITYPE_RIMM},
+ /* 0x02 */ {"j ", ITYPE_JMP},
+ /* 0x03 */ {"jal ", ITYPE_JMP},
+ /* 0x04 */ {"beq ", ITYPE_BRA},
+ /* 0x05 */ {"bne ", ITYPE_BRA},
+ /* 0x06 */ {"blez ", ITYPE_BRA},
+ /* 0x07 */ {"bgtz ", ITYPE_BRA},
+
+ /* 0x08 */ {"addi ", ITYPE_IMM},
+ /* 0x09 */ {"addiu ", ITYPE_IMM},
+ /* 0x0a */ {"slti ", ITYPE_IMM},
+ /* 0x0b */ {"sltiu ", ITYPE_IMM},
+ /* 0x0c */ {"andi ", ITYPE_IMM},
+ /* 0x0d */ {"ori ", ITYPE_IMM},
+ /* 0x0e */ {"xori ", ITYPE_IMM},
+ /* 0x0f */ {"lui ", ITYPE_IMM},
+
+ /* 0x10 */ {"cop0 ", ITYPE_OP},
+ /* 0x11 */ {"cop1 ", ITYPE_FOP},
+ /* 0x12 */ {"cop2 ", ITYPE_OP},
/* 0x13 */ {"", ITYPE_UNDEF},
- /* 0x14 */ {"BEQL ", ITYPE_BRA},
- /* 0x15 */ {"BNEL ", ITYPE_BRA},
- /* 0x16 */ {"BLEZL ", ITYPE_BRA},
- /* 0x17 */ {"BGTZL ", ITYPE_BRA},
-
- /* 0x18 */ {"DADDI ", ITYPE_IMM},
- /* 0x19 */ {"DADDIU ", ITYPE_IMM},
- /* 0x1a */ {"LDL ", ITYPE_MEM},
- /* 0x1b */ {"LDR ", ITYPE_MEM},
+ /* 0x14 */ {"beql ", ITYPE_BRA},
+ /* 0x15 */ {"bnel ", ITYPE_BRA},
+ /* 0x16 */ {"blezl ", ITYPE_BRA},
+ /* 0x17 */ {"bgtzl ", ITYPE_BRA},
+
+ /* 0x18 */ {"daddi ", ITYPE_IMM},
+ /* 0x19 */ {"daddiu ", ITYPE_IMM},
+ /* 0x1a */ {"ldl ", ITYPE_MEM},
+ /* 0x1b */ {"ldr ", ITYPE_MEM},
/* 0x1c */ {"", ITYPE_UNDEF},
/* 0x1d */ {"", ITYPE_UNDEF},
/* 0x1e */ {"", ITYPE_UNDEF},
/* 0x1f */ {"", ITYPE_UNDEF},
- /* 0x20 */ {"LB ", ITYPE_MEM},
- /* 0x21 */ {"LH ", ITYPE_MEM},
- /* 0x22 */ {"LWL ", ITYPE_MEM},
- /* 0x23 */ {"LW ", ITYPE_MEM},
- /* 0x24 */ {"LBU ", ITYPE_MEM},
- /* 0x25 */ {"LHU ", ITYPE_MEM},
- /* 0x26 */ {"LWR ", ITYPE_MEM},
- /* 0x27 */ {"LWU ", ITYPE_MEM},
-
- /* 0x28 */ {"SB ", ITYPE_MEM},
- /* 0x29 */ {"SH ", ITYPE_MEM},
- /* 0x2a */ {"SWL ", ITYPE_MEM},
- /* 0x2b */ {"SW ", ITYPE_MEM},
- /* 0x2c */ {"SDL ", ITYPE_MEM},
- /* 0x2d */ {"SDR ", ITYPE_MEM},
- /* 0x2e */ {"SWR ", ITYPE_MEM},
- /* 0x2f */ {"CACHE ", ITYPE_MEM},
-
- /* 0x30 */ {"LL ", ITYPE_MEM},
- /* 0x31 */ {"LWC1 ", ITYPE_MEM},
- /* 0x32 */ {"LWC2 ", ITYPE_MEM},
+ /* 0x20 */ {"lb ", ITYPE_MEM},
+ /* 0x21 */ {"lh ", ITYPE_MEM},
+ /* 0x22 */ {"lwl ", ITYPE_MEM},
+ /* 0x23 */ {"lw ", ITYPE_MEM},
+ /* 0x24 */ {"lbu ", ITYPE_MEM},
+ /* 0x25 */ {"lhu ", ITYPE_MEM},
+ /* 0x26 */ {"lwr ", ITYPE_MEM},
+ /* 0x27 */ {"lwu ", ITYPE_MEM},
+
+ /* 0x28 */ {"sb ", ITYPE_MEM},
+ /* 0x29 */ {"sh ", ITYPE_MEM},
+ /* 0x2a */ {"swl ", ITYPE_MEM},
+ /* 0x2b */ {"sw ", ITYPE_MEM},
+ /* 0x2c */ {"sdl ", ITYPE_MEM},
+ /* 0x2d */ {"sdr ", ITYPE_MEM},
+ /* 0x2e */ {"swr ", ITYPE_MEM},
+ /* 0x2f */ {"cache ", ITYPE_MEM},
+
+ /* 0x30 */ {"ll ", ITYPE_MEM},
+ /* 0x31 */ {"lwc1 ", ITYPE_FMEM},
+ /* 0x32 */ {"lwc2 ", ITYPE_MEM},
/* 0x33 */ {"", ITYPE_UNDEF},
- /* 0x34 */ {"LLD ", ITYPE_MEM},
- /* 0x35 */ {"LDC1 ", ITYPE_MEM},
- /* 0x36 */ {"LDC2 ", ITYPE_MEM},
- /* 0x37 */ {"LD ", ITYPE_MEM},
-
- /* 0x38 */ {"SC ", ITYPE_MEM},
- /* 0x39 */ {"SWC1 ", ITYPE_MEM},
- /* 0x3a */ {"SWC2 ", ITYPE_MEM},
+ /* 0x34 */ {"lld ", ITYPE_MEM},
+ /* 0x35 */ {"ldc1 ", ITYPE_FMEM},
+ /* 0x36 */ {"ldc2 ", ITYPE_MEM},
+ /* 0x37 */ {"ld ", ITYPE_MEM},
+
+ /* 0x38 */ {"sc ", ITYPE_MEM},
+ /* 0x39 */ {"swc1 ", ITYPE_FMEM},
+ /* 0x3a */ {"swc2 ", ITYPE_MEM},
/* 0x3b */ {"", ITYPE_UNDEF},
- /* 0x3c */ {"SLD ", ITYPE_MEM},
- /* 0x3d */ {"SDC1 ", ITYPE_MEM},
- /* 0x3e */ {"SDC2 ", ITYPE_MEM},
- /* 0x3f */ {"SD ", ITYPE_MEM}
+ /* 0x3c */ {"sld ", ITYPE_MEM},
+ /* 0x3d */ {"sdc1 ", ITYPE_FMEM},
+ /* 0x3e */ {"sdc2 ", ITYPE_MEM},
+ /* 0x3f */ {"sd ", ITYPE_MEM}
};
static struct {char *name; int ftype;} regops[] = {
- /* 0x00 */ {"SLL ", ITYPE_IMM},
+ /* 0x00 */ {"sll ", ITYPE_IMM},
/* 0x01 */ {"" , ITYPE_UNDEF},
- /* 0x02 */ {"SRL ", ITYPE_IMM},
- /* 0x03 */ {"SRA ", ITYPE_IMM},
- /* 0x04 */ {"SLLV ", ITYPE_OP},
+ /* 0x02 */ {"srl ", ITYPE_IMM},
+ /* 0x03 */ {"sra ", ITYPE_IMM},
+ /* 0x04 */ {"sllv ", ITYPE_OP},
/* 0x05 */ {"" , ITYPE_UNDEF},
- /* 0x06 */ {"SRLV ", ITYPE_OP},
- /* 0x07 */ {"SRAV ", ITYPE_OP},
+ /* 0x06 */ {"srlv ", ITYPE_OP},
+ /* 0x07 */ {"srav ", ITYPE_OP},
- /* 0x08 */ {"JR ", ITYPE_MTOJR},
- /* 0x09 */ {"JALR ", ITYPE_JMP},
+ /* 0x08 */ {"jr ", ITYPE_MTOJR},
+ /* 0x09 */ {"jalr ", ITYPE_JMP},
/* 0x0a */ {"" , ITYPE_UNDEF},
/* 0x0b */ {"" , ITYPE_UNDEF},
- /* 0x0c */ {"SYSCALL ", ITYPE_SYS},
- /* 0x0d */ {"BREAK ", ITYPE_SYS},
+ /* 0x0c */ {"syscall ", ITYPE_SYS},
+ /* 0x0d */ {"break ", ITYPE_SYS},
/* 0x0e */ {"" , ITYPE_UNDEF},
- /* 0x0f */ {"SYNC ", ITYPE_SYS},
+ /* 0x0f */ {"sync ", ITYPE_SYS},
- /* 0x10 */ {"MFHI ", ITYPE_MFROM},
- /* 0x11 */ {"MTHI ", ITYPE_MTOJR},
- /* 0x12 */ {"MFLO ", ITYPE_MFROM},
- /* 0x13 */ {"MTLO ", ITYPE_MTOJR},
- /* 0x14 */ {"DSLLV ", ITYPE_OP},
+ /* 0x10 */ {"mfhi ", ITYPE_MFROM},
+ /* 0x11 */ {"mthi ", ITYPE_MTOJR},
+ /* 0x12 */ {"mflo ", ITYPE_MFROM},
+ /* 0x13 */ {"mtlo ", ITYPE_MTOJR},
+ /* 0x14 */ {"dsllv ", ITYPE_OP},
/* 0x15 */ {"" , ITYPE_UNDEF},
- /* 0x16 */ {"DSLRV ", ITYPE_OP},
- /* 0x17 */ {"DSRAV ", ITYPE_OP},
-
- /* 0x18 */ {"MULT ",ITYPE_DIVMUL},
- /* 0x19 */ {"MULTU ",ITYPE_DIVMUL},
- /* 0x1a */ {"DIV ",ITYPE_DIVMUL},
- /* 0x1b */ {"DIVU ",ITYPE_DIVMUL},
- /* 0x1c */ {"DMULT ",ITYPE_DIVMUL},
- /* 0x1d */ {"DMULTU ",ITYPE_DIVMUL},
- /* 0x1e */ {"DDIV ",ITYPE_DIVMUL},
- /* 0x1f */ {"DDIVU ",ITYPE_DIVMUL},
-
- /* 0x20 */ {"ADD ", ITYPE_OP},
- /* 0x21 */ {"ADDU ", ITYPE_OP},
- /* 0x22 */ {"SUB ", ITYPE_OP},
- /* 0x23 */ {"SUBU ", ITYPE_OP},
- /* 0x24 */ {"AND ", ITYPE_OP},
- /* 0x25 */ {"OR ", ITYPE_OP},
- /* 0x26 */ {"XOR ", ITYPE_OP},
- /* 0x27 */ {"NOR ", ITYPE_OP},
+ /* 0x16 */ {"dslrv ", ITYPE_OP},
+ /* 0x17 */ {"dsrav ", ITYPE_OP},
+
+ /* 0x18 */ {"mult ",ITYPE_DIVMUL},
+ /* 0x19 */ {"multu ",ITYPE_DIVMUL},
+ /* 0x1a */ {"div ",ITYPE_DIVMUL},
+ /* 0x1b */ {"divu ",ITYPE_DIVMUL},
+ /* 0x1c */ {"dmult ",ITYPE_DIVMUL},
+ /* 0x1d */ {"dmultu ",ITYPE_DIVMUL},
+ /* 0x1e */ {"ddiv ",ITYPE_DIVMUL},
+ /* 0x1f */ {"ddivu ",ITYPE_DIVMUL},
+
+ /* 0x20 */ {"add ", ITYPE_OP},
+ /* 0x21 */ {"addu ", ITYPE_OP},
+ /* 0x22 */ {"sub ", ITYPE_OP},
+ /* 0x23 */ {"subu ", ITYPE_OP},
+ /* 0x24 */ {"and ", ITYPE_OP},
+ /* 0x25 */ {"or ", ITYPE_OP},
+ /* 0x26 */ {"xor ", ITYPE_OP},
+ /* 0x27 */ {"nor ", ITYPE_OP},
/* 0x28 */ {"" , ITYPE_UNDEF},
/* 0x29 */ {"" , ITYPE_UNDEF},
- /* 0x2a */ {"SLT ", ITYPE_OP},
- /* 0x2b */ {"SLTU ", ITYPE_OP},
- /* 0x2c */ {"DADD ", ITYPE_OP},
- /* 0x2d */ {"DADDU ", ITYPE_OP},
- /* 0x2e */ {"DSUB ", ITYPE_OP},
- /* 0x2f */ {"DSUBU ", ITYPE_OP},
-
- /* 0x30 */ {"TGE ", ITYPE_TRAP},
- /* 0x31 */ {"TGEU ", ITYPE_TRAP},
- /* 0x32 */ {"TLT ", ITYPE_TRAP},
- /* 0x33 */ {"TLTU ", ITYPE_TRAP},
- /* 0x34 */ {"TEQ ", ITYPE_TRAP},
+ /* 0x2a */ {"slt ", ITYPE_OP},
+ /* 0x2b */ {"sltu ", ITYPE_OP},
+ /* 0x2c */ {"dadd ", ITYPE_OP},
+ /* 0x2d */ {"daddu ", ITYPE_OP},
+ /* 0x2e */ {"dsub ", ITYPE_OP},
+ /* 0x2f */ {"dsubu ", ITYPE_OP},
+
+ /* 0x30 */ {"tge ", ITYPE_TRAP},
+ /* 0x31 */ {"tgeu ", ITYPE_TRAP},
+ /* 0x32 */ {"tlt ", ITYPE_TRAP},
+ /* 0x33 */ {"tltu ", ITYPE_TRAP},
+ /* 0x34 */ {"teq ", ITYPE_TRAP},
/* 0x35 */ {"" , ITYPE_UNDEF},
- /* 0x36 */ {"TNE ", ITYPE_TRAP},
+ /* 0x36 */ {"tne ", ITYPE_TRAP},
/* 0x37 */ {"" , ITYPE_UNDEF},
- /* 0x38 */ {"DSLL ", ITYPE_IMM},
+ /* 0x38 */ {"dsll ", ITYPE_IMM},
/* 0x39 */ {"" , ITYPE_UNDEF},
- /* 0x3a */ {"DSLR ", ITYPE_IMM},
- /* 0x3b */ {"DSRA ", ITYPE_IMM},
- /* 0x3c */ {"DSLL32 ", ITYPE_IMM},
+ /* 0x3a */ {"dslr ", ITYPE_IMM},
+ /* 0x3b */ {"dsra ", ITYPE_IMM},
+ /* 0x3c */ {"dsll32 ", ITYPE_IMM},
/* 0x3d */ {"" , ITYPE_UNDEF},
- /* 0x3e */ {"DSLR32 ", ITYPE_IMM},
- /* 0x3f */ {"DSRA32 ", ITYPE_IMM}
+ /* 0x3e */ {"dslr32 ", ITYPE_IMM},
+ /* 0x3f */ {"dsra32 ", ITYPE_IMM}
};
static struct {char *name; int ftype;} regimms[] = {
- /* 0x00 */ {"BLTZ ", ITYPE_BRA},
- /* 0x01 */ {"BGEZ ", ITYPE_BRA},
- /* 0x02 */ {"BLTZL ", ITYPE_BRA},
- /* 0x03 */ {"BGEZL ", ITYPE_BRA},
- /* 0x04 */ {"", ITYPE_UNDEF},
- /* 0x05 */ {"", ITYPE_UNDEF},
- /* 0x06 */ {"", ITYPE_UNDEF},
- /* 0x07 */ {"", ITYPE_UNDEF},
-
- /* 0x08 */ {"TGEI ", ITYPE_IMM},
- /* 0x09 */ {"DGEIU ", ITYPE_IMM},
- /* 0x0a */ {"TLTI ", ITYPE_IMM},
- /* 0x0b */ {"TLTIU ", ITYPE_IMM},
- /* 0x0c */ {"TEQI ", ITYPE_IMM},
- /* 0x0d */ {"" , ITYPE_UNDEF},
- /* 0x0e */ {"TNEI ", ITYPE_IMM},
- /* 0x0f */ {"" , ITYPE_UNDEF},
-
- /* 0x10 */ {"BLTZAL ", ITYPE_BRA},
- /* 0x11 */ {"BGEZAL ", ITYPE_BRA},
- /* 0x12 */ {"BLTZALL", ITYPE_BRA},
- /* 0x13 */ {"BGEZALL", ITYPE_BRA},
- /* 0x14 */ {"", ITYPE_UNDEF},
- /* 0x15 */ {"", ITYPE_UNDEF},
- /* 0x16 */ {"", ITYPE_UNDEF},
- /* 0x17 */ {"", ITYPE_UNDEF},
-
- /* 0x18 */ {"", ITYPE_UNDEF},
- /* 0x19 */ {"", ITYPE_UNDEF},
- /* 0x1a */ {"", ITYPE_UNDEF},
- /* 0x1b */ {"", ITYPE_UNDEF},
- /* 0x1c */ {"", ITYPE_UNDEF},
- /* 0x1d */ {"", ITYPE_UNDEF},
- /* 0x1e */ {"", ITYPE_UNDEF},
- /* 0x1f */ {"", ITYPE_UNDEF}
+ /* 0x00 */ {"bltz ", ITYPE_BRA},
+ /* 0x01 */ {"bgez ", ITYPE_BRA},
+ /* 0x02 */ {"bltzl ", ITYPE_BRA},
+ /* 0x03 */ {"bgezl ", ITYPE_BRA},
+ /* 0x04 */ {"", ITYPE_UNDEF},
+ /* 0x05 */ {"", ITYPE_UNDEF},
+ /* 0x06 */ {"", ITYPE_UNDEF},
+ /* 0x07 */ {"", ITYPE_UNDEF},
+
+ /* 0x08 */ {"tgei ", ITYPE_IMM},
+ /* 0x09 */ {"dgeiu ", ITYPE_IMM},
+ /* 0x0a */ {"tlti ", ITYPE_IMM},
+ /* 0x0b */ {"tltiu ", ITYPE_IMM},
+ /* 0x0c */ {"teqi ", ITYPE_IMM},
+ /* 0x0d */ {"", ITYPE_UNDEF},
+ /* 0x0e */ {"tnei ", ITYPE_IMM},
+ /* 0x0f */ {"", ITYPE_UNDEF},
+
+ /* 0x10 */ {"bltzal ", ITYPE_BRA},
+ /* 0x11 */ {"bgezal ", ITYPE_BRA},
+ /* 0x12 */ {"bltzall ", ITYPE_BRA},
+ /* 0x13 */ {"bgezall ", ITYPE_BRA},
+ /* 0x14 */ {"", ITYPE_UNDEF},
+ /* 0x15 */ {"", ITYPE_UNDEF},
+ /* 0x16 */ {"", ITYPE_UNDEF},
+ /* 0x17 */ {"", ITYPE_UNDEF},
+
+ /* 0x18 */ {"", ITYPE_UNDEF},
+ /* 0x19 */ {"", ITYPE_UNDEF},
+ /* 0x1a */ {"", ITYPE_UNDEF},
+ /* 0x1b */ {"", ITYPE_UNDEF},
+ /* 0x1c */ {"", ITYPE_UNDEF},
+ /* 0x1d */ {"", ITYPE_UNDEF},
+ /* 0x1e */ {"", ITYPE_UNDEF},
+ /* 0x1f */ {"", ITYPE_UNDEF}
};
static struct {char *name; char *fill; int ftype;} fops[] = {
- /* 0x00 */ {"ADD", " ", ITYPE_FOP},
- /* 0x01 */ {"SUB", " ", ITYPE_FOP},
- /* 0x02 */ {"MUL", " ", ITYPE_FOP},
- /* 0x03 */ {"DIV", " ", ITYPE_FOP},
- /* 0x04 */ {"SQRT", " ", ITYPE_FOP},
- /* 0x05 */ {"ABS", " ", ITYPE_FOP2},
- /* 0x06 */ {"MOV", " ", ITYPE_FOP2},
- /* 0x07 */ {"NEG", " ", ITYPE_FOP2},
-
- /* 0x08 */ {"ROUNDL", "", ITYPE_FOP2},
- /* 0x09 */ {"TRUNCL", "", ITYPE_FOP2},
- /* 0x0a */ {"CEILL", " ", ITYPE_FOP2},
- /* 0x0b */ {"FLOORL", "", ITYPE_FOP2},
- /* 0x0c */ {"ROUND", " ", ITYPE_FOP2},
- /* 0x0d */ {"TRUNC", " ", ITYPE_FOP2},
- /* 0x0e */ {"CEIL", " ", ITYPE_FOP2},
- /* 0x0f */ {"FLOOR", " ", ITYPE_FOP2},
+ /* 0x00 */ {"add", " ", ITYPE_FOP},
+ /* 0x01 */ {"sub", " ", ITYPE_FOP},
+ /* 0x02 */ {"mul", " ", ITYPE_FOP},
+ /* 0x03 */ {"div", " ", ITYPE_FOP},
+ /* 0x04 */ {"sqrt", " ", ITYPE_FOP},
+ /* 0x05 */ {"abs", " ", ITYPE_FOP2},
+ /* 0x06 */ {"mov", " ", ITYPE_FOP2},
+ /* 0x07 */ {"neg", " ", ITYPE_FOP2},
+
+ /* 0x08 */ {"roundl", "", ITYPE_FOP2},
+ /* 0x09 */ {"truncl", "", ITYPE_FOP2},
+ /* 0x0a */ {"ceill", " ", ITYPE_FOP2},
+ /* 0x0b */ {"floorl", "", ITYPE_FOP2},
+ /* 0x0c */ {"round", " ", ITYPE_FOP2},
+ /* 0x0d */ {"trunc", " ", ITYPE_FOP2},
+ /* 0x0e */ {"ceil", " ", ITYPE_FOP2},
+ /* 0x0f */ {"floor", " ", ITYPE_FOP2},
/* 0x10 */ {"", "", ITYPE_UNDEF},
/* 0x11 */ {"", "", ITYPE_UNDEF},
/* 0x17 */ {"", "", ITYPE_UNDEF},
/* 0x18 */ {"", "", ITYPE_UNDEF},
- /* 0x19 */ {"RECIP", " ", ITYPE_FOP2},
- /* 0x1a */ {"RSQRT", " ", ITYPE_FOP2},
+ /* 0x19 */ {"recip", " ", ITYPE_FOP2},
+ /* 0x1a */ {"rsqrt", " ", ITYPE_FOP2},
/* 0x1b */ {"", "", ITYPE_UNDEF},
/* 0x1c */ {"", "", ITYPE_UNDEF},
/* 0x1d */ {"", "", ITYPE_UNDEF},
/* 0x1e */ {"", "", ITYPE_UNDEF},
/* 0x1f */ {"", "", ITYPE_UNDEF},
- /* 0x20 */ {"CVTS", " ", ITYPE_FOP2},
- /* 0x21 */ {"CVTD", " ", ITYPE_FOP2},
- /* 0x22 */ {"CVTX", " ", ITYPE_FOP2},
- /* 0x23 */ {"CVTQ", " ", ITYPE_FOP2},
- /* 0x24 */ {"CVTW", " ", ITYPE_FOP2},
- /* 0x25 */ {"CVTL", " ", ITYPE_FOP2},
+ /* 0x20 */ {"cvts", " ", ITYPE_FOP2},
+ /* 0x21 */ {"cvtd", " ", ITYPE_FOP2},
+ /* 0x22 */ {"cvtx", " ", ITYPE_FOP2},
+ /* 0x23 */ {"cvtq", " ", ITYPE_FOP2},
+ /* 0x24 */ {"cvtw", " ", ITYPE_FOP2},
+ /* 0x25 */ {"cvtl", " ", ITYPE_FOP2},
/* 0x26 */ {"", "", ITYPE_UNDEF},
/* 0x27 */ {"", "", ITYPE_UNDEF},
/* 0x2e */ {"", "", ITYPE_UNDEF},
/* 0x2f */ {"", "", ITYPE_UNDEF},
- /* 0x30 */ {"C.F", " ", ITYPE_FCMP},
- /* 0x31 */ {"C.UN", " ", ITYPE_FCMP},
- /* 0x32 */ {"C.EQ", " ", ITYPE_FCMP},
- /* 0x33 */ {"C.UEQ", " ", ITYPE_FCMP},
- /* 0x34 */ {"C.OLT", " ", ITYPE_FCMP},
- /* 0x35 */ {"C.ULT", " ", ITYPE_FCMP},
- /* 0x36 */ {"C.OLE", " ", ITYPE_FCMP},
- /* 0x37 */ {"C.ULE", " ", ITYPE_FCMP},
-
- /* 0x38 */ {"C.SF", " ", ITYPE_FCMP},
- /* 0x39 */ {"C.NGLE", "", ITYPE_FCMP},
- /* 0x3a */ {"C.SEQ", " ", ITYPE_FCMP},
- /* 0x3b */ {"C.NGL", " ", ITYPE_FCMP},
- /* 0x3c */ {"C.LT", " ", ITYPE_FCMP},
- /* 0x3d */ {"C.NGE", " ", ITYPE_FCMP},
- /* 0x3e */ {"C.LE", " ", ITYPE_FCMP},
- /* 0x3f */ {"C.NGT", " ", ITYPE_FCMP}
+ /* 0x30 */ {"c.f", " ", ITYPE_FCMP},
+ /* 0x31 */ {"c.un", " ", ITYPE_FCMP},
+ /* 0x32 */ {"c.eq", " ", ITYPE_FCMP},
+ /* 0x33 */ {"c.ueq", " ", ITYPE_FCMP},
+ /* 0x34 */ {"c.olt", " ", ITYPE_FCMP},
+ /* 0x35 */ {"c.ult", " ", ITYPE_FCMP},
+ /* 0x36 */ {"c.ole", " ", ITYPE_FCMP},
+ /* 0x37 */ {"c.ule", " ", ITYPE_FCMP},
+
+ /* 0x38 */ {"c.sf", " ", ITYPE_FCMP},
+ /* 0x39 */ {"c.ngle", "", ITYPE_FCMP},
+ /* 0x3a */ {"c.seq", " ", ITYPE_FCMP},
+ /* 0x3b */ {"c.ngl", " ", ITYPE_FCMP},
+ /* 0x3c */ {"c.lt", " ", ITYPE_FCMP},
+ /* 0x3d */ {"c.nge", " ", ITYPE_FCMP},
+ /* 0x3e */ {"c.le", " ", ITYPE_FCMP},
+ /* 0x3f */ {"c.ngt", " ", ITYPE_FCMP}
};
/* format decode table for 3 bit floating point format codes */
static char *fmt[] = {
- /* 0x00 */ ".S",
- /* 0x01 */ ".D",
- /* 0x02 */ ".X",
- /* 0x03 */ ".Q",
- /* 0x04 */ ".W",
- /* 0x05 */ ".L",
+ /* 0x00 */ ".s",
+ /* 0x01 */ ".d",
+ /* 0x02 */ ".x",
+ /* 0x03 */ ".q",
+ /* 0x04 */ ".w",
+ /* 0x05 */ ".l",
/* 0x06 */ ".?",
/* 0x07 */ ".?"
};
/* format decode table for 2 bit floating point branch codes */
static char *fbra[] = {
- /* 0x00 */ "BC1F ",
- /* 0x01 */ "BC1T ",
- /* 0x02 */ "BC1FL ",
- /* 0x03 */ "BC1TL "
+ /* 0x00 */ "bc1f ",
+ /* 0x01 */ "bc1t ",
+ /* 0x02 */ "bc1fl ",
+ /* 0x03 */ "bc1tl "
+};
+
+
+/* instruction decode table for 32 integer registers */
+
+static char *regs[] = {
+
+ /* 0x00 */ "zero", /* "$0", */
+ /* 0x01 */ "at", /* "$1", */
+ /* 0x02 */ "v0", /* "$2", */
+ /* 0x03 */ "v1", /* "$3", */
+ /* 0x04 */ "a0", /* "$4", */
+ /* 0x05 */ "a1", /* "$5", */
+ /* 0x06 */ "a2", /* "$6", */
+ /* 0x07 */ "a3", /* "$7", */
+
+ /* 0x08 */ "a4", /* "$8", */
+ /* 0x09 */ "a5", /* "$9", */
+ /* 0x0a */ "a6", /* "$10", */
+ /* 0x0b */ "a7", /* "$11", */
+ /* 0x0c */ "t0", /* "$12", */
+ /* 0x0d */ "t1", /* "$13", */
+ /* 0x0e */ "t2", /* "$14", */
+ /* 0x0f */ "t3", /* "$15", */
+
+ /* 0x10 */ "s0", /* "$16", */
+ /* 0x11 */ "s1", /* "$17", */
+ /* 0x12 */ "s2", /* "$18", */
+ /* 0x13 */ "s3", /* "$19", */
+ /* 0x14 */ "s4", /* "$20", */
+ /* 0x15 */ "s5", /* "$21", */
+ /* 0x16 */ "s6", /* "$22", */
+ /* 0x17 */ "s7", /* "$23", */
+
+ /* 0x18 */ "t8", /* "$24", */
+ /* 0x19 */ "t9", /* "$25", */
+ /* 0x1a */ "k0", /* "$26", */
+ /* 0x1b */ "k1", /* "$27", */
+ /* 0x1c */ "gp", /* "$28", */
+ /* 0x1d */ "sp", /* "$29", */
+ /* 0x1e */ "s8", /* "$30", */
+ /* 0x1f */ "ra" /* "$31" */
};
+/* instruction decode table for 32 floating point registers */
+
+#if 0
+static char *fregs[] = {
+
+ /* 0x00 */ "fv0", /* "$f0", */
+ /* 0x01 */ "ft16", /* "$f1", */
+ /* 0x02 */ "fv1", /* "$f2", */
+ /* 0x03 */ "ft17", /* "$f3", */
+ /* 0x04 */ "ft0", /* "$f4", */
+ /* 0x05 */ "ft1", /* "$f5", */
+ /* 0x06 */ "ft2", /* "$f6", */
+ /* 0x07 */ "ft3", /* "$f7", */
+
+ /* 0x08 */ "ft4", /* "$f8", */
+ /* 0x09 */ "ft5", /* "$f9", */
+ /* 0x0a */ "ft6", /* "$f10", */
+ /* 0x0b */ "ft7", /* "$f11", */
+ /* 0x0c */ "fa0", /* "$f12", */
+ /* 0x0d */ "fa1", /* "$f13", */
+ /* 0x0e */ "fa2", /* "$f14", */
+ /* 0x0f */ "fa3", /* "$f15", */
+
+ /* 0x10 */ "fa4", /* "$f16", */
+ /* 0x11 */ "fa5", /* "$f17", */
+ /* 0x12 */ "fa6", /* "$f18", */
+ /* 0x13 */ "fa7", /* "$f19", */
+ /* 0x14 */ "ft8", /* "$f20", */
+ /* 0x15 */ "ft9", /* "$f21", */
+ /* 0x16 */ "ft10", /* "$f22", */
+ /* 0x17 */ "ft11", /* "$f23", */
+
+ /* 0x18 */ "fs0", /* "$f24", */
+ /* 0x19 */ "ft12", /* "$f25", */
+ /* 0x1a */ "fs1", /* "$f26", */
+ /* 0x1b */ "ft13", /* "$f27", */
+ /* 0x1c */ "fs2", /* "$f28", */
+ /* 0x1d */ "ft14", /* "$f29", */
+ /* 0x1e */ "fs3", /* "$f30", */
+ /* 0x1f */ "ft15" /* "$f31" */
+};
+#endif
+
+
/* function disassinstr ********************************************************
outputs a disassembler listing of one machine code instruction on 'stdout'
rd = (c >> 11) & 0x1f; /* 5 bit destination register specifier */
shift = (c >> 6) & 0x1f; /* 5 bit unsigned shift amount */
- printf ("%6x: %#8x ", pos, c);
+ printf ("%6x: 0x%08x ", pos, c);
switch (ops[op].itype) {
case ITYPE_JMP: /* 26 bit unsigned jump offset */
- printf ("%s %#7x\n", ops[op].name, (c & 0x3ffffff) << 2);
+ printf ("%s %#09x\n", ops[op].name, (c & 0x3ffffff) << 2);
break;
case ITYPE_IMM: /* 16 bit signed immediate value */
- printf ("%s $%d,$%d,%d\n", ops[op].name, rt, rs, (c << 16) >> 16);
+ printf ("%s %s,%s,%d\n", ops[op].name, regs[rt],
+ regs[rs], (c << 16) >> 16);
break;
case ITYPE_MEM: /* 16 bit signed memory offset */
- printf ("%s $%d,%d($%d)\n", ops[op].name, rt, (c << 16) >> 16, rs);
+ printf ("%s %s,%d(%s)\n", ops[op].name, regs[rt],
+ (c << 16) >> 16, regs[rs]);
+ break;
+
+ case ITYPE_FMEM: /* 16 bit signed memory offset */
+ printf ("%s $f%d,%d(%s)\n", ops[op].name, rt,
+ (c << 16) >> 16, regs[rs]);
break;
case ITYPE_BRA: /* 16 bit signed branch offset */
- printf("%s $%d,$%d,%x\n", ops[op].name, rs, rt,
+ if (op == 0x04 && rs == 0 && rt == 0) {
+ printf("b 0x%x\n", pos + 4 + ((c << 16) >> 14));
+ break;
+ }
+ printf("%s %s,%s,0x%x\n", ops[op].name, regs[rs], regs[rt],
pos + 4 + ((c << 16) >> 14));
break;
case ITYPE_RIMM:
if (regimms[rt].ftype == ITYPE_IMM)
- printf("%s $%d,#%d\n", regimms[rt].name, rs, (c << 16) >> 16);
+ printf("%s %s,%d\n", regimms[rt].name, regs[rs],
+ (c << 16) >> 16);
else if (regimms[rt].ftype == ITYPE_BRA)
- printf("%s $%d,%x\n", regimms[rt].name, rs,
- pos + 4 + ((c << 16) >> 14));
+ printf("%s %s,%x\n", regimms[rt].name, regs[rs],
+ pos + 4 + ((c << 16) >> 14));
else
- printf("REGIMM %#2x,$%d,%d\n", rt, rs, (c << 16) >> 16);
+ printf("regimm %#04x,$%d,%d\n", rt, rs, (c << 16) >> 16);
break;
case ITYPE_OP:
- if (opfun == 0x25 && rs == rt) {
- if (rs == 0 && rd == 0)
- printf("NOP\n");
- else if (rs == 0)
- printf("CLR $%d\n", rd);
+ if (c == 0) {
+ printf("nop\n");
+ return;
+ }
+ if (opfun == 0x25 && rt == 0) {
+ if (rs == 0)
+ printf("clr %s\n", regs[rd]);
else
- printf("MOV $%d,$%d\n", rs, rd);
+ printf("move %s,%s\n", regs[rd], regs[rs]);
return;
}
switch (regops[opfun].ftype) {
case ITYPE_OP:
- printf("%s $%d,$%d,$%d\n", regops[opfun].name, rd, rs, rt);
+ printf("%s %s,%s,%s\n", regops[opfun].name, regs[rd],
+ regs[rs], regs[rt]);
break;
case ITYPE_IMM: /* immediate instruction */
- printf("%s $%d,$%d,#%d\n",
- regops[opfun].name, rd, rt, shift);
+ printf("%s %s,%s,%d\n",
+ regops[opfun].name, regs[rd], regs[rt], shift);
break;
case ITYPE_TRAP:
- printf("%s $%d,$%d,#%d\n",
- regops[opfun].name, rs, rt, (c << 16) >> 22);
+ printf("%s %s,%s,%d\n", regops[opfun].name,
+ regs[rs], regs[rt], (c << 16) >> 22);
break;
case ITYPE_DIVMUL: /* div/mul instruction */
- printf("%s $%d,$%d\n", regops[opfun].name, rs, rt);
+ printf("%s %s,%s\n", regops[opfun].name, regs[rs], regs[rt]);
break;
case ITYPE_JMP:
- printf("%s $%d,$%d\n", regops[opfun].name, rd, rs);
+ if (rd == 31) {
+ printf("%s %s\n", regops[opfun].name, regs[rs]);
+ break;
+ }
+ printf("%s %s,%s\n", regops[opfun].name, regs[rd], regs[rs]);
break;
case ITYPE_MTOJR:
- printf("%s $%d\n", regops[opfun].name, rs);
+ if (opfun == 8 && rs == 31) {
+ printf("ret\n");
+ break;
+ }
+ printf("%s %s\n", regops[opfun].name, regs[rs]);
break;
case ITYPE_MFROM:
- printf("%s $%d\n", regops[opfun].name, rd);
+ printf("%s %s\n", regops[opfun].name, regs[rd]);
break;
case ITYPE_SYS:
printf("%s\n", regops[opfun].name);
default:
- printf("SPECIAL (%#2x) $%d,$%d,$%d\n", opfun, rd, rs, rt);
+ printf("special (%#04x) $%d,$%d,$%d\n", opfun, rd, rs, rt);
}
break;
case ITYPE_FOP:
}
if (rs == 1) { /* double move from */
- printf("MFC1 $%d,$f%d\n", rt, fs);
+ printf("dmfc1 %s,$f%d\n", regs[rt], fs);
break;
}
if (rs == 5) { /* double move to */
- printf("MTC1 ,$%d,$f%d\n", rt, fs);
+ printf("dmtc1 %s,$f%d\n", regs[rt], fs);
break;
}
rs = rs & 7; /* truncate to 3 bit format specifier */
if (fops[opfun].ftype == ITYPE_FOP)
- printf("%s%s%s $%d,$%d,$%d\n", fops[opfun].name, fmt[rs],
+ printf("%s%s%s $f%d,$f%d,$f%d\n", fops[opfun].name, fmt[rs],
fops[opfun].fill, fd, fs, ft);
else if (fops[opfun].ftype == ITYPE_FOP2)
- printf("%s%s%s $%d,$%d\n", fops[opfun].name, fmt[rs],
+ printf("%s%s%s $f%d,$f%d\n", fops[opfun].name, fmt[rs],
fops[opfun].fill, fd, fs);
- else if (fops[opfun].ftype == ITYPE_FOP2)
- printf("%s%s%s $%d,$%d\n", fops[opfun].name, fmt[rs],
- fops[opfun].fill, fs, ft);
else
- printf("COP1 (%#2x) $%d,$%d,$%d\n", opfun, fd, fs, ft);
+ printf("cop1 (%#04x) $f%d,$f%d,$f%d\n", opfun, fd, fs, ft);
break;
default:
- printf("UNDEF %#2x(%#2x) $%d,$%d,$%d\n", op, opfun, rd, rs, rt);
+ printf("undef %#04x(%#04x) $%d,$%d,$%d\n", op, opfun, rd, rs, rt);
}
}
if (checknull) {\
M_BEQZ((objreg), 0);\
mcode_addxnullrefs(mcodeptr);\
+ M_NOP;\
}
#else
#define gen_nullptr_check(objreg)
if a and b are the same float-register, no code will be generated
*/
-#define M_FLTMOVE(a,b) if(a!=b){M_FMOV(a,b);}
+#define M_FLTMOVE(a,b) if(a!=b){M_DMOV(a,b);}
/* var_to_reg_xxx:
/* NullPointerException handlers and exception handling initialisation */
-typedef struct sigctx_struct {
-
- long sc_onstack; /* sigstack state to restore */
- long sc_mask; /* signal mask to restore */
- long sc_pc; /* pc at time of signal */
- long sc_ps; /* psl to retore */
- long sc_regs[32]; /* processor regs 0 to 31 */
- long sc_ownedfp; /* fp has been used */
- long sc_fpregs[32]; /* fp regs 0 to 31 */
- unsigned long sc_fpcr; /* floating point control register */
- unsigned long sc_fp_control; /* software fpcr */
- /* rest is unused */
- unsigned long sc_reserved1, sc_reserved2;
- unsigned long sc_ssize;
- char *sc_sbase;
- unsigned long sc_traparg_a0;
- unsigned long sc_traparg_a1;
- unsigned long sc_traparg_a2;
- unsigned long sc_fp_trap_pc;
- unsigned long sc_fp_trigger_sum;
- unsigned long sc_fp_trigger_inst;
- unsigned long sc_retcode[2];
-} sigctx_struct;
-
-
-/* asm_signal_exception passes exception pointer and the signal context
- structure (contains the saved registers) to the assembler handler which
- restores registers and walks through the Java exception tables.
-*/
-
-void asm_signal_exception(void *xptr, void *sigctx);
-
-
/* NullPointerException signal handler for hardware null pointer check */
-void catch_NullPointerException(int sig, int code, sigctx_struct *sigctx)
+void catch_NullPointerException(int sig, int code, struct sigcontext *sigctx)
{
sigset_t nsig;
int instr;
/* Reset signal handler - necessary for SysV, does no harm for BSD */
instr = *((int*)(sigctx->sc_pc));
- faultaddr = sigctx->sc_regs[(instr >> 16) & 0x1f];
+ faultaddr = sigctx->sc_regs[(instr >> 21) & 0x1f];
if (faultaddr == 0) {
signal(sig, (void*) catch_NullPointerException); /* reinstall handler */
sigemptyset(&nsig);
sigaddset(&nsig, sig);
sigprocmask(SIG_UNBLOCK, &nsig, NULL); /* unblock signal */
- asm_signal_exception(proto_java_lang_NullPointerException, sigctx);
+ sigctx->sc_regs[REG_ITMP1_XPTR] =
+ (long) proto_java_lang_NullPointerException;
+ sigctx->sc_regs[REG_ITMP2_XPC] = sigctx->sc_pc;
+ sigctx->sc_pc = (long) asm_handle_nat_exception;
}
else {
faultaddr += (long) ((instr << 16) >> 16);
}
-#ifdef __osf__
-
void init_exceptions(void)
{
-
-#else /* Linux */
-
-/* Linux on Digital Alpha needs an initialisation of the ieee floating point
- control for IEEE compliant arithmetic (option -mieee of GCC). Under
- Digital Unix this is done automatically.
-*/
-
-#include <asm/fpu.h>
-
-extern unsigned long ieee_get_fp_control();
-extern void ieee_set_fp_control(unsigned long fp_control);
-
-void init_exceptions(void)
-{
-/* initialize floating point control */
-
-ieee_set_fp_control(ieee_get_fp_control()
- & ~IEEE_TRAP_ENABLE_INV
- & ~IEEE_TRAP_ENABLE_DZE
-/* & ~IEEE_TRAP_ENABLE_UNF we dont want underflow */
- & ~IEEE_TRAP_ENABLE_OVF);
-#endif
-
/* install signal handlers we need to convert to exceptions */
if (!checknull) {
*/
if (runverbose && isleafmethod) {
- M_LDA (REG_SP, REG_SP, -(14*8));
- M_AST(REG_RA, REG_SP, 1*8);
+ M_LDA (REG_SP, REG_SP, -(18*8));
+
+ M_AST(REG_RA, REG_SP, 1*8);
M_LST(argintregs[0], REG_SP, 2*8);
M_LST(argintregs[1], REG_SP, 3*8);
M_LST(argintregs[3], REG_SP, 5*8);
M_LST(argintregs[4], REG_SP, 6*8);
M_LST(argintregs[5], REG_SP, 7*8);
-
- M_DST(argfltregs[0], REG_SP, 8*8);
- M_DST(argfltregs[1], REG_SP, 9*8);
- M_DST(argfltregs[2], REG_SP, 10*8);
- M_DST(argfltregs[3], REG_SP, 11*8);
- M_DST(argfltregs[4], REG_SP, 12*8);
- M_DST(argfltregs[5], REG_SP, 13*8);
+ M_LST(argintregs[6], REG_SP, 8*8);
+ M_LST(argintregs[7], REG_SP, 9*8);
+
+ M_DST(argfltregs[0], REG_SP, 10*8);
+ M_DST(argfltregs[1], REG_SP, 11*8);
+ M_DST(argfltregs[2], REG_SP, 12*8);
+ M_DST(argfltregs[3], REG_SP, 13*8);
+ M_DST(argfltregs[4], REG_SP, 14*8);
+ M_DST(argfltregs[5], REG_SP, 15*8);
+ M_DST(argfltregs[6], REG_SP, 16*8);
+ M_DST(argfltregs[7], REG_SP, 17*8);
p = dseg_addaddress (method);
M_ALD(REG_ITMP1, REG_PV, p);
- M_AST(REG_ITMP1, REG_SP, 0);
+ M_LST(REG_ITMP1, REG_SP, 0);
p = dseg_addaddress ((void*) (builtin_trace_args));
- M_ALD(REG_PV, REG_PV, p);
- M_JSR(REG_RA, REG_PV);
- M_LDA(REG_PV, REG_RA, -(int)((u1*) mcodeptr - mcodebase));
- M_ALD(REG_RA, REG_SP, 1*8);
+ M_ALD(REG_ITMP1, REG_PV, p);
+ M_JSR(REG_RA, REG_ITMP1);
+ M_NOP;
+
+ M_ALD(REG_RA, REG_SP, 1*8);
M_LLD(argintregs[0], REG_SP, 2*8);
M_LLD(argintregs[1], REG_SP, 3*8);
M_LLD(argintregs[3], REG_SP, 5*8);
M_LLD(argintregs[4], REG_SP, 6*8);
M_LLD(argintregs[5], REG_SP, 7*8);
-
- M_DLD(argfltregs[0], REG_SP, 8*8);
- M_DLD(argfltregs[1], REG_SP, 9*8);
- M_DLD(argfltregs[2], REG_SP, 10*8);
- M_DLD(argfltregs[3], REG_SP, 11*8);
- M_DLD(argfltregs[4], REG_SP, 12*8);
- M_DLD(argfltregs[5], REG_SP, 13*8);
-
- M_LDA (REG_SP, REG_SP, 14*8);
+ M_LLD(argintregs[6], REG_SP, 8*8);
+ M_LLD(argintregs[7], REG_SP, 9*8);
+
+ M_DLD(argfltregs[0], REG_SP, 10*8);
+ M_DLD(argfltregs[1], REG_SP, 11*8);
+ M_DLD(argfltregs[2], REG_SP, 12*8);
+ M_DLD(argfltregs[3], REG_SP, 13*8);
+ M_DLD(argfltregs[4], REG_SP, 14*8);
+ M_DLD(argfltregs[5], REG_SP, 15*8);
+ M_DLD(argfltregs[6], REG_SP, 16*8);
+ M_DLD(argfltregs[7], REG_SP, 17*8);
+
+ M_LDA (REG_SP, REG_SP, 18*8);
}
/* take arguments out of register or stack frame */
M_ALD(REG_ITMP1, REG_PV, p);
M_AST(REG_ITMP1, REG_SP, 0);
p = dseg_addaddress ((void*) (builtin_trace_args));
- M_ALD(REG_PV, REG_PV, p);
- M_JSR(REG_RA, REG_PV);
- M_LDA(REG_PV, REG_RA, -(int)((u1*) mcodeptr - mcodebase));
+ M_ALD(REG_ITMP1, REG_PV, p);
+ M_JSR(REG_RA, REG_ITMP1);
+ M_NOP;
M_LDA(REG_SP, REG_SP, 8);
}
#ifdef USE_THREADS
if (checksync && (method->flags & ACC_SYNCHRONIZED)) {
p = dseg_addaddress ((void*) (builtin_monitorenter));
- M_ALD(REG_PV, REG_PV, p);
+ M_ALD(REG_ITMP1, REG_PV, p);
+ M_JSR(REG_RA, REG_ITMP1);
M_ALD(argintregs[0], REG_SP, 8 * maxmemuse);
- M_JSR(REG_RA, REG_PV);
- M_LDA(REG_PV, REG_RA, -(int)((u1*) mcodeptr - mcodebase));
}
#endif
}
var_to_reg_int(s1, src, REG_ITMP1);
M_BEQZ(s1, 0);
mcode_addxnullrefs(mcodeptr);
+ M_NOP;
break;
/* constant operations ************************************************/
-#define ICONST(r,c) if(((c)>=-32768)&&((c)<= 32767)){M_LDA(r,REG_ZERO,c);} \
+#define ICONST(r,c) if(((c)>=-32768)&&((c)<= 32767)){M_IADD_IMM(REG_ZERO,c,r);} \
+ else if(((c)>=0)&&((c)<=0xffff)){M_OR_IMM(REG_ZERO,c,r);} \
else{a=dseg_adds4(c);M_ILD(r,REG_PV,a);}
-#define LCONST(r,c) if(((c)>=-32768)&&((c)<= 32767)){M_LDA(r,REG_ZERO,c);} \
+#define LCONST(r,c) if(((c)>=-32768)&&((c)<= 32767)){M_LADD_IMM(REG_ZERO,c,r);} \
+ else if(((c)>=0)&&((c)<=0xffff)){M_OR_IMM(REG_ZERO,c,r);} \
else{a=dseg_adds8(c);M_LLD(r,REG_PV,a);}
case ICMD_ICONST: /* ... ==> ..., constant */
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if (has_ext_instr_set) {
- M_BSEXT(s1, d);
- }
- else {
- M_SLL_IMM(s1, 56, d);
- M_SRA_IMM( d, 56, d);
- }
+ M_LSLL_IMM(s1, 56, d);
+ M_LSRA_IMM( d, 56, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if (has_ext_instr_set) {
- M_SSEXT(s1, d);
- }
- else {
- M_SLL_IMM(s1, 48, d);
- M_SRA_IMM( d, 48, d);
- }
+ M_LSLL_IMM(s1, 48, d);
+ M_LSRA_IMM( d, 48, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
+ if ((iptr->val.i >= -32768) && (iptr->val.i <= 32767)) {
M_IADD_IMM(s1, iptr->val.i, d);
}
else {
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
+ if ((iptr->val.l >= -32768) && (iptr->val.l <= 32767)) {
M_LADD_IMM(s1, iptr->val.l, d);
}
else {
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
- M_ISUB_IMM(s1, iptr->val.i, d);
+ if ((iptr->val.i >= -32767) && (iptr->val.i <= 32768)) {
+ M_IADD_IMM(s1, -iptr->val.i, d);
}
else {
ICONST(REG_ITMP2, iptr->val.i);
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
- M_LSUB_IMM(s1, iptr->val.l, d);
+ if ((iptr->val.l >= -32767) && (iptr->val.l <= 32768)) {
+ M_LADD_IMM(s1, -iptr->val.l, d);
}
else {
LCONST(REG_ITMP2, iptr->val.l);
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_IMUL(s1, s2, d);
+ M_IMUL(s1, s2);
+ M_MFLO(d);
+ M_NOP;
+ M_NOP;
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
- M_IMUL_IMM(s1, iptr->val.i, d);
- }
- else {
- ICONST(REG_ITMP2, iptr->val.i);
- M_IMUL(s1, REG_ITMP2, d);
- }
+ ICONST(REG_ITMP2, iptr->val.i);
+ M_IMUL(s1, REG_ITMP2);
+ M_MFLO(d);
+ M_NOP;
+ M_NOP;
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_LMUL (s1, s2, d);
+ M_LMUL(s1, s2);
+ M_MFLO(d);
+ M_NOP;
+ M_NOP;
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
- M_LMUL_IMM(s1, iptr->val.l, d);
- }
- else {
- LCONST(REG_ITMP2, iptr->val.l);
- M_LMUL(s1, REG_ITMP2, d);
- }
+ LCONST(REG_ITMP2, iptr->val.l);
+ M_LMUL(s1, REG_ITMP2);
+ M_MFLO(d);
+ M_NOP;
+ M_NOP;
+ store_reg_to_var_int(iptr->dst, d);
+ break;
+
+ case ICMD_IDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
+
+ var_to_reg_int(s1, src->prev, REG_ITMP1);
+ var_to_reg_int(s2, src, REG_ITMP2);
+ d = reg_of_var(iptr->dst, REG_ITMP3);
+ M_IDIV(s1, s2);
+ M_MFLO(d);
+ M_NOP;
+ M_NOP;
+ store_reg_to_var_int(iptr->dst, d);
+ break;
+#if 0
+ case ICMD_IDIVCONST: /* ..., value ==> ..., value / constant */
+ /* val.i = constant */
+
+ var_to_reg_int(s1, src, REG_ITMP1);
+ d = reg_of_var(iptr->dst, REG_ITMP3);
+ ICONST(REG_ITMP2, iptr->val.i);
+ M_IDIV(s1, REG_ITMP2);
+ M_MFLO(d);
+ M_NOP;
+ M_NOP;
+ store_reg_to_var_int(iptr->dst, d);
+ break;
+#endif
+ case ICMD_LDIV: /* ..., val1, val2 ==> ..., val1 / val2 */
+
+ var_to_reg_int(s1, src->prev, REG_ITMP1);
+ var_to_reg_int(s2, src, REG_ITMP2);
+ d = reg_of_var(iptr->dst, REG_ITMP3);
+ M_LDIV(s1, s2);
+ M_MFLO(d);
+ M_NOP;
+ M_NOP;
+ store_reg_to_var_int(iptr->dst, d);
+ break;
+#if 0
+ case ICMD_LDIVCONST: /* ..., value ==> ..., value / constant */
+ /* val.l = constant */
+
+ var_to_reg_int(s1, src, REG_ITMP1);
+ d = reg_of_var(iptr->dst, REG_ITMP3);
+ LCONST(REG_ITMP2, iptr->val.l);
+ M_LDIV(s1, REG_ITMP2);
+ M_MFLO(d);
+ M_NOP;
+ M_NOP;
store_reg_to_var_int(iptr->dst, d);
break;
+#endif
+ case ICMD_IREM: /* ..., val1, val2 ==> ..., val1 % val2 */
+ var_to_reg_int(s1, src->prev, REG_ITMP1);
+ var_to_reg_int(s2, src, REG_ITMP2);
+ d = reg_of_var(iptr->dst, REG_ITMP3);
+ M_IDIV(s1, s2);
+ M_MFHI(d);
+ M_NOP;
+ M_NOP;
+ store_reg_to_var_int(iptr->dst, d);
+ break;
+#if 0
+ case ICMD_IREMCONST: /* ..., value ==> ..., value % constant */
+ /* val.i = constant */
+
+ var_to_reg_int(s1, src, REG_ITMP1);
+ d = reg_of_var(iptr->dst, REG_ITMP3);
+ ICONST(REG_ITMP2, iptr->val.i);
+ M_IDIV(s1, REG_ITMP2);
+ M_MFHI(d);
+ M_NOP;
+ M_NOP;
+ store_reg_to_var_int(iptr->dst, d);
+ break;
+#endif
+ case ICMD_LREM: /* ..., val1, val2 ==> ..., val1 % val2 */
+
+ var_to_reg_int(s1, src->prev, REG_ITMP1);
+ var_to_reg_int(s2, src, REG_ITMP2);
+ d = reg_of_var(iptr->dst, REG_ITMP3);
+ M_LDIV(s1, s2);
+ M_MFHI(d);
+ M_NOP;
+ M_NOP;
+ store_reg_to_var_int(iptr->dst, d);
+ break;
+#if 0
+ case ICMD_LREMCONST: /* ..., value ==> ..., value % constant */
+ /* val.l = constant */
+
+ var_to_reg_int(s1, src, REG_ITMP1);
+ d = reg_of_var(iptr->dst, REG_ITMP3);
+ LCONST(REG_ITMP2, iptr->val.l);
+ M_LDIV(s1, REG_ITMP2);
+ M_MFHI(d);
+ M_NOP;
+ M_NOP;
+ store_reg_to_var_int(iptr->dst, d);
+ break;
+#endif
case ICMD_IDIVPOW2: /* ..., value ==> ..., value << constant */
case ICMD_LDIVPOW2: /* val.i = constant */
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if (iptr->val.i <= 15) {
- M_LDA(REG_ITMP2, s1, (1 << iptr->val.i) -1);
- M_CMOVGE(s1, s1, REG_ITMP2);
- }
- else {
- M_SRA_IMM(s1, 63, REG_ITMP2);
- M_SRL_IMM(REG_ITMP2, 64 - iptr->val.i, REG_ITMP2);
- M_LADD(s1, REG_ITMP2, REG_ITMP2);
- }
- M_SRA_IMM(REG_ITMP2, iptr->val.i, d);
+ M_LSRA_IMM(s1, 63, REG_ITMP2);
+ M_LSRL_IMM(REG_ITMP2, 64 - iptr->val.i, REG_ITMP2);
+ M_LADD(s1, REG_ITMP2, REG_ITMP2);
+ M_LSRA_IMM(REG_ITMP2, iptr->val.i, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_AND_IMM(s2, 0x1f, REG_ITMP3);
- M_SLL(s1, REG_ITMP3, d);
- M_IADD(d, REG_ZERO, d);
+ M_ISLL(s1, s2, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_SLL_IMM(s1, iptr->val.i & 0x1f, d);
- M_IADD(d, REG_ZERO, d);
+ M_ISLL_IMM(s1, iptr->val.i, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_AND_IMM(s2, 0x1f, REG_ITMP3);
- M_SRA(s1, REG_ITMP3, d);
+ M_ISRA(s1, s2, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_SRA_IMM(s1, iptr->val.i & 0x1f, d);
+ M_ISRA_IMM(s1, iptr->val.i, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_AND_IMM(s2, 0x1f, REG_ITMP2);
- M_IZEXT(s1, d);
- M_SRL(d, REG_ITMP2, d);
- M_IADD(d, REG_ZERO, d);
+ M_ISRL(s1, s2, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_IZEXT(s1, d);
- M_SRL_IMM(d, iptr->val.i & 0x1f, d);
- M_IADD(d, REG_ZERO, d);
+ M_ISRL_IMM(s1, iptr->val.i, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_SLL(s1, s2, d);
+ M_LSLL(s1, s2, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_SLL_IMM(s1, iptr->val.l & 0x3f, d);
+ M_LSLL_IMM(s1, iptr->val.l, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_SRA(s1, s2, d);
+ M_LSRA(s1, s2, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_SRA_IMM(s1, iptr->val.l & 0x3f, d);
+ M_LSRA_IMM(s1, iptr->val.l, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_SRL(s1, s2, d);
+ M_LSRL(s1, s2, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- M_SRL_IMM(s1, iptr->val.l & 0x3f, d);
+ M_LSRL_IMM(s1, iptr->val.l, d);
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
+ if ((iptr->val.i >= 0) && (iptr->val.i <= 0xffff)) {
M_AND_IMM(s1, iptr->val.i, d);
}
- else if (iptr->val.i == 0xffff) {
- M_CZEXT(s1, d);
- }
- else if (iptr->val.i == 0xffffff) {
- M_ZAPNOT_IMM(s1, 0x07, d);
- }
else {
ICONST(REG_ITMP2, iptr->val.i);
M_AND(s1, REG_ITMP2, d);
M_MOV(s1, REG_ITMP1);
s1 = REG_ITMP1;
}
- if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
+ if ((iptr->val.i >= 0) && (iptr->val.i <= 0xffff)) {
M_AND_IMM(s1, iptr->val.i, d);
- M_BGEZ(s1, 3);
+ M_BGEZ(s1, 4);
+ M_NOP;
M_ISUB(REG_ZERO, s1, d);
M_AND_IMM(d, iptr->val.i, d);
}
- else if (iptr->val.i == 0xffff) {
- M_CZEXT(s1, d);
- M_BGEZ(s1, 3);
- M_ISUB(REG_ZERO, s1, d);
- M_CZEXT(d, d);
- }
- else if (iptr->val.i == 0xffffff) {
- M_ZAPNOT_IMM(s1, 0x07, d);
- M_BGEZ(s1, 3);
- M_ISUB(REG_ZERO, s1, d);
- M_ZAPNOT_IMM(d, 0x07, d);
- }
else {
ICONST(REG_ITMP2, iptr->val.i);
M_AND(s1, REG_ITMP2, d);
- M_BGEZ(s1, 3);
+ M_BGEZ(s1, 4);
+ M_NOP;
M_ISUB(REG_ZERO, s1, d);
M_AND(d, REG_ITMP2, d);
}
s1 = REG_ITMP3;
}
M_BLTZ(s1, 7);
- M_CZEXT(s1, REG_ITMP2);
- M_SRA_IMM(s1, 16, d);
- M_CMPLT(REG_ITMP2, d, REG_ITMP1);
- M_ISUB(REG_ITMP2, d, d);
- M_CZEXT(d, d);
- M_IADD(d, REG_ITMP1, d);
- M_BR(11 + (s1 == REG_ITMP1));
- M_ISUB(REG_ZERO, s1, REG_ITMP1);
- M_CZEXT(REG_ITMP1, REG_ITMP2);
- M_SRA_IMM(REG_ITMP1, 16, d);
+ M_CZEXT(s1, REG_ITMP2); /* delay slot */
+ M_ISRA_IMM(s1, 16, d);
M_CMPLT(REG_ITMP2, d, REG_ITMP1);
M_ISUB(REG_ITMP2, d, d);
M_CZEXT(d, d);
- M_IADD(d, REG_ITMP1, d);
- M_ISUB(REG_ZERO, d, d);
- if (s1 == REG_ITMP1) {
- var_to_reg_int(s1, src, REG_ITMP1);
- }
- M_SLL_IMM(s1, 33, REG_ITMP2);
- M_CMPEQ(REG_ITMP2, REG_ZERO, REG_ITMP2);
- M_ISUB(d, REG_ITMP2, d);
+ M_BR(7);
+ M_IADD(d, REG_ITMP1, d); /* delay slot */
+
+ M_LUI(REG_ITMP2, 1);
+ M_IADD_IMM(REG_ITMP2, 1, REG_ITMP2);
+ M_IDIV(s1, REG_ITMP2);
+ M_MFHI(d);
+ M_NOP;
+ M_NOP;
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
+ if ((iptr->val.l >= 0) && (iptr->val.l <= 0xffff)) {
M_AND_IMM(s1, iptr->val.l, d);
}
- else if (iptr->val.l == 0xffffL) {
- M_CZEXT(s1, d);
- }
- else if (iptr->val.l == 0xffffffL) {
- M_ZAPNOT_IMM(s1, 0x07, d);
- }
- else if (iptr->val.l == 0xffffffffL) {
- M_IZEXT(s1, d);
- }
- else if (iptr->val.l == 0xffffffffffL) {
- M_ZAPNOT_IMM(s1, 0x1f, d);
- }
- else if (iptr->val.l == 0xffffffffffffL) {
- M_ZAPNOT_IMM(s1, 0x3f, d);
- }
- else if (iptr->val.l == 0xffffffffffffffL) {
- M_ZAPNOT_IMM(s1, 0x7f, d);
- }
else {
LCONST(REG_ITMP2, iptr->val.l);
M_AND(s1, REG_ITMP2, d);
M_MOV(s1, REG_ITMP1);
s1 = REG_ITMP1;
}
- if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
+ if ((iptr->val.l >= 0) && (iptr->val.l <= 0xffff)) {
M_AND_IMM(s1, iptr->val.l, d);
- M_BGEZ(s1, 3);
+ M_BGEZ(s1, 4);
+ M_NOP;
M_LSUB(REG_ZERO, s1, d);
M_AND_IMM(d, iptr->val.l, d);
}
- else if (iptr->val.l == 0xffffL) {
- M_CZEXT(s1, d);
- M_BGEZ(s1, 3);
- M_LSUB(REG_ZERO, s1, d);
- M_CZEXT(d, d);
- }
- else if (iptr->val.l == 0xffffffL) {
- M_ZAPNOT_IMM(s1, 0x07, d);
- M_BGEZ(s1, 3);
- M_LSUB(REG_ZERO, s1, d);
- M_ZAPNOT_IMM(d, 0x07, d);
- }
- else if (iptr->val.l == 0xffffffffL) {
- M_IZEXT(s1, d);
- M_BGEZ(s1, 3);
- M_LSUB(REG_ZERO, s1, d);
- M_IZEXT(d, d);
- }
- else if (iptr->val.l == 0xffffffffffL) {
- M_ZAPNOT_IMM(s1, 0x1f, d);
- M_BGEZ(s1, 3);
- M_LSUB(REG_ZERO, s1, d);
- M_ZAPNOT_IMM(d, 0x1f, d);
- }
- else if (iptr->val.l == 0xffffffffffffL) {
- M_ZAPNOT_IMM(s1, 0x3f, d);
- M_BGEZ(s1, 3);
- M_LSUB(REG_ZERO, s1, d);
- M_ZAPNOT_IMM(d, 0x3f, d);
- }
- else if (iptr->val.l == 0xffffffffffffffL) {
- M_ZAPNOT_IMM(s1, 0x7f, d);
- M_BGEZ(s1, 3);
- M_LSUB(REG_ZERO, s1, d);
- M_ZAPNOT_IMM(d, 0x7f, d);
- }
else {
LCONST(REG_ITMP2, iptr->val.l);
M_AND(s1, REG_ITMP2, d);
- M_BGEZ(s1, 3);
+ M_BGEZ(s1, 4);
+ M_NOP;
M_LSUB(REG_ZERO, s1, d);
M_AND(d, REG_ITMP2, d);
}
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if (s1 == d) {
- M_MOV(s1, REG_ITMP3);
- s1 = REG_ITMP3;
- }
- M_CZEXT(s1, REG_ITMP2);
- M_SRA_IMM(s1, 16, d);
- M_CMPLT(REG_ITMP2, d, REG_ITMP1);
- M_LSUB(REG_ITMP2, d, d);
- M_CZEXT(d, d);
- M_LADD(d, REG_ITMP1, d);
- M_LDA(REG_ITMP2, REG_ZERO, -1);
- M_SRL_IMM(REG_ITMP2, 33, REG_ITMP2);
- if (s1 == REG_ITMP1) {
- var_to_reg_int(s1, src, REG_ITMP1);
- }
- M_CMPULT(s1, REG_ITMP2, REG_ITMP2);
- M_BNEZ(REG_ITMP2, 11);
- M_LDA(d, REG_ZERO, -257);
- M_ZAPNOT_IMM(d, 0xcd, d);
- M_LSUB(REG_ZERO, s1, REG_ITMP2);
- M_CMOVGE(s1, s1, REG_ITMP2);
- M_UMULH(REG_ITMP2, d, REG_ITMP2);
- M_SRL_IMM(REG_ITMP2, 16, REG_ITMP2);
- M_LSUB(REG_ZERO, REG_ITMP2, d);
- M_CMOVGE(s1, REG_ITMP2, d);
- M_SLL_IMM(d, 16, REG_ITMP2);
- M_LADD(d, REG_ITMP2, d);
- M_LSUB(s1, d, d);
+ M_LUI(REG_ITMP2, 1);
+ M_LADD_IMM(REG_ITMP2, 1, REG_ITMP2);
+ M_LDIV(s1, REG_ITMP2);
+ M_MFHI(d);
+ M_NOP;
+ M_NOP;
store_reg_to_var_int(iptr->dst, d);
break;
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
+ if ((iptr->val.i >= 0) && (iptr->val.i <= 0xffff)) {
M_OR_IMM(s1, iptr->val.i, d);
}
else {
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
+ if ((iptr->val.l >= 0) && (iptr->val.l <= 0xffff)) {
M_OR_IMM(s1, iptr->val.l, d);
}
else {
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
+ if ((iptr->val.i >= 0) && (iptr->val.i <= 0xffff)) {
M_XOR_IMM(s1, iptr->val.i, d);
}
else {
var_to_reg_int(s1, src, REG_ITMP1);
d = reg_of_var(iptr->dst, REG_ITMP3);
- if ((iptr->val.l >= 0) && (iptr->val.l <= 255)) {
+ if ((iptr->val.l >= 0) && (iptr->val.l <= 0xffff)) {
M_XOR_IMM(s1, iptr->val.l, d);
}
else {
}
else
s1 = var->regoff;
- if ((iptr->val.i >= 0) && (iptr->val.i <= 255)) {
- M_IADD_IMM(s1, iptr->val.i, s1);
- }
- else if ((iptr->val.i > -256) && (iptr->val.i < 0)) {
- M_ISUB_IMM(s1, (-iptr->val.i), s1);
- }
- else {
- M_LDA (s1, s1, iptr->val.i);
- M_IADD(s1, REG_ZERO, s1);
- }
+ M_IADD_IMM(s1, iptr->val.i, s1);
if (var->flags & INMEMORY)
M_LST(s1, REG_SP, 8 * var->regoff);
break;
M_CMPULT(s2, REG_ITMP3, REG_ITMP3);\
M_BEQZ(REG_ITMP3, 0);\
mcode_addxboundrefs(mcodeptr);\
+ M_NOP;\
}
case ICMD_ARRAYLENGTH: /* ..., arrayref ==> ..., length */
d = reg_of_var(iptr->dst, REG_ITMP3);
gen_nullptr_check(s1);
gen_bound_check;
- M_SAADDQ(s2, s1, REG_ITMP1);
- M_ALD( d, REG_ITMP1, OFFSET(java_objectarray, data[0]));
+ M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
+ M_ALD(d, REG_ITMP1, OFFSET(java_objectarray, data[0]));
store_reg_to_var_int(iptr->dst, d);
break;
- case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */
+ case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
gen_nullptr_check(s1);
gen_bound_check;
- M_S8ADDQ(s2, s1, REG_ITMP1);
- M_LLD(d, REG_ITMP1, OFFSET(java_longarray, data[0]));
+ M_ASLL_IMM(s2, 2, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
+ M_ILD(d, REG_ITMP1, OFFSET(java_intarray, data[0]));
store_reg_to_var_int(iptr->dst, d);
break;
- case ICMD_IALOAD: /* ..., arrayref, index ==> ..., value */
+ case ICMD_LALOAD: /* ..., arrayref, index ==> ..., value */
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
d = reg_of_var(iptr->dst, REG_ITMP3);
gen_nullptr_check(s1);
gen_bound_check;
- M_S4ADDQ(s2, s1, REG_ITMP1);
- M_ILD(d, REG_ITMP1, OFFSET(java_intarray, data[0]));
+ M_ASLL_IMM(s2, 3, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
+ M_LLD(d, REG_ITMP1, OFFSET(java_longarray, data[0]));
store_reg_to_var_int(iptr->dst, d);
break;
d = reg_of_var(iptr->dst, REG_FTMP3);
gen_nullptr_check(s1);
gen_bound_check;
- M_S4ADDQ(s2, s1, REG_ITMP1);
+ M_ASLL_IMM(s2, 2, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
M_FLD(d, REG_ITMP1, OFFSET(java_floatarray, data[0]));
store_reg_to_var_flt(iptr->dst, d);
break;
d = reg_of_var(iptr->dst, REG_FTMP3);
gen_nullptr_check(s1);
gen_bound_check;
- M_S8ADDQ(s2, s1, REG_ITMP1);
+ M_ASLL_IMM(s2, 3, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
M_DLD(d, REG_ITMP1, OFFSET(java_doublearray, data[0]));
store_reg_to_var_flt(iptr->dst, d);
break;
d = reg_of_var(iptr->dst, REG_ITMP3);
gen_nullptr_check(s1);
gen_bound_check;
- if (has_ext_instr_set) {
- M_LADD(s2, s1, REG_ITMP1);
- M_LADD(s2, REG_ITMP1, REG_ITMP1);
- M_SLDU(d, REG_ITMP1, OFFSET(java_chararray, data[0]));
- }
- else {
- M_LADD (s2, s1, REG_ITMP1);
- M_LADD (s2, REG_ITMP1, REG_ITMP1);
- M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_chararray, data[0]));
- M_LDA (REG_ITMP1, REG_ITMP1, OFFSET(java_chararray, data[0]));
- M_EXTWL(REG_ITMP2, REG_ITMP1, d);
- }
+ M_AADD(s2, s1, REG_ITMP1);
+ M_AADD(s2, REG_ITMP1, REG_ITMP1);
+ M_SLDU(d, REG_ITMP1, OFFSET(java_chararray, data[0]));
store_reg_to_var_int(iptr->dst, d);
break;
d = reg_of_var(iptr->dst, REG_ITMP3);
gen_nullptr_check(s1);
gen_bound_check;
- if (has_ext_instr_set) {
- M_LADD(s2, s1, REG_ITMP1);
- M_LADD(s2, REG_ITMP1, REG_ITMP1);
- M_SLDU( d, REG_ITMP1, OFFSET (java_shortarray, data[0]));
- M_SSEXT(d, d);
- }
- else {
- M_LADD(s2, s1, REG_ITMP1);
- M_LADD(s2, REG_ITMP1, REG_ITMP1);
- M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_shortarray, data[0]));
- M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_shortarray, data[0])+2);
- M_EXTQH(REG_ITMP2, REG_ITMP1, d);
- M_SRA_IMM(d, 48, d);
- }
+ M_AADD(s2, s1, REG_ITMP1);
+ M_AADD(s2, REG_ITMP1, REG_ITMP1);
+ M_SLDS(d, REG_ITMP1, OFFSET(java_chararray, data[0]));
store_reg_to_var_int(iptr->dst, d);
break;
d = reg_of_var(iptr->dst, REG_ITMP3);
gen_nullptr_check(s1);
gen_bound_check;
- if (has_ext_instr_set) {
- M_LADD (s2, s1, REG_ITMP1);
- M_BLDU (d, REG_ITMP1, OFFSET (java_shortarray, data[0]));
- M_BSEXT (d, d);
- }
- else {
- M_LADD(s2, s1, REG_ITMP1);
- M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_bytearray, data[0]));
- M_LDA(REG_ITMP1, REG_ITMP1, OFFSET(java_bytearray, data[0])+1);
- M_EXTQH(REG_ITMP2, REG_ITMP1, d);
- M_SRA_IMM(d, 56, d);
- }
+ M_AADD(s2, s1, REG_ITMP1);
+ M_BLDS(d, REG_ITMP1, OFFSET(java_chararray, data[0]));
store_reg_to_var_int(iptr->dst, d);
break;
gen_nullptr_check(s1);
gen_bound_check;
var_to_reg_int(s3, src, REG_ITMP3);
- M_SAADDQ(s2, s1, REG_ITMP1);
- M_AST (s3, REG_ITMP1, OFFSET(java_objectarray, data[0]));
+ M_ASLL_IMM(s2, POINTERSHIFT, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
+ M_AST(s3, REG_ITMP1, OFFSET(java_objectarray, data[0]));
break;
- case ICMD_LASTORE: /* ..., arrayref, index, value ==> ... */
+ case ICMD_IASTORE: /* ..., arrayref, index, value ==> ... */
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
var_to_reg_int(s2, src->prev, REG_ITMP2);
gen_nullptr_check(s1);
gen_bound_check;
var_to_reg_int(s3, src, REG_ITMP3);
- M_S8ADDQ(s2, s1, REG_ITMP1);
- M_LST (s3, REG_ITMP1, OFFSET(java_longarray, data[0]));
+ M_ASLL_IMM(s2, 2, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
+ M_IST(s3, REG_ITMP1, OFFSET(java_intarray, data[0]));
break;
- case ICMD_IASTORE: /* ..., arrayref, index, value ==> ... */
+ case ICMD_LASTORE: /* ..., arrayref, index, value ==> ... */
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
var_to_reg_int(s2, src->prev, REG_ITMP2);
gen_nullptr_check(s1);
gen_bound_check;
var_to_reg_int(s3, src, REG_ITMP3);
- M_S4ADDQ(s2, s1, REG_ITMP1);
- M_IST (s3, REG_ITMP1, OFFSET(java_intarray, data[0]));
+ M_ASLL_IMM(s2, 3, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
+ M_LST(s3, REG_ITMP1, OFFSET(java_longarray, data[0]));
break;
case ICMD_FASTORE: /* ..., arrayref, index, value ==> ... */
gen_nullptr_check(s1);
gen_bound_check;
var_to_reg_flt(s3, src, REG_FTMP3);
- M_S4ADDQ(s2, s1, REG_ITMP1);
- M_FST (s3, REG_ITMP1, OFFSET(java_floatarray, data[0]));
+ M_ASLL_IMM(s2, 2, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
+ M_FST(s3, REG_ITMP1, OFFSET(java_floatarray, data[0]));
break;
case ICMD_DASTORE: /* ..., arrayref, index, value ==> ... */
gen_nullptr_check(s1);
gen_bound_check;
var_to_reg_flt(s3, src, REG_FTMP3);
- M_S8ADDQ(s2, s1, REG_ITMP1);
- M_DST (s3, REG_ITMP1, OFFSET(java_doublearray, data[0]));
+ M_ASLL_IMM(s2, 3, REG_ITMP2);
+ M_AADD(REG_ITMP2, s1, REG_ITMP1);
+ M_DST(s3, REG_ITMP1, OFFSET(java_doublearray, data[0]));
break;
case ICMD_CASTORE: /* ..., arrayref, index, value ==> ... */
-
- var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
- var_to_reg_int(s2, src->prev, REG_ITMP2);
- gen_nullptr_check(s1);
- gen_bound_check;
- var_to_reg_int(s3, src, REG_ITMP3);
- if (has_ext_instr_set) {
- M_LADD(s2, s1, REG_ITMP1);
- M_LADD(s2, REG_ITMP1, REG_ITMP1);
- M_SST (s3, REG_ITMP1, OFFSET(java_chararray, data[0]));
- }
- else {
- M_LADD (s2, s1, REG_ITMP1);
- M_LADD (s2, REG_ITMP1, REG_ITMP1);
- M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_chararray, data[0]));
- M_LDA (REG_ITMP1, REG_ITMP1, OFFSET(java_chararray, data[0]));
- M_INSWL(s3, REG_ITMP1, REG_ITMP3);
- M_MSKWL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
- M_OR (REG_ITMP2, REG_ITMP3, REG_ITMP2);
- M_LST_U(REG_ITMP2, REG_ITMP1, 0);
- }
- break;
-
case ICMD_SASTORE: /* ..., arrayref, index, value ==> ... */
var_to_reg_int(s1, src->prev->prev, REG_ITMP1);
gen_nullptr_check(s1);
gen_bound_check;
var_to_reg_int(s3, src, REG_ITMP3);
- if (has_ext_instr_set) {
- M_LADD(s2, s1, REG_ITMP1);
- M_LADD(s2, REG_ITMP1, REG_ITMP1);
- M_SST (s3, REG_ITMP1, OFFSET(java_shortarray, data[0]));
- }
- else {
- M_LADD (s2, s1, REG_ITMP1);
- M_LADD (s2, REG_ITMP1, REG_ITMP1);
- M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_shortarray, data[0]));
- M_LDA (REG_ITMP1, REG_ITMP1, OFFSET(java_shortarray, data[0]));
- M_INSWL(s3, REG_ITMP1, REG_ITMP3);
- M_MSKWL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
- M_OR (REG_ITMP2, REG_ITMP3, REG_ITMP2);
- M_LST_U(REG_ITMP2, REG_ITMP1, 0);
- }
+ M_AADD(s2, s1, REG_ITMP1);
+ M_AADD(s2, REG_ITMP1, REG_ITMP1);
+ M_SST(s3, REG_ITMP1, OFFSET(java_chararray, data[0]));
break;
case ICMD_BASTORE: /* ..., arrayref, index, value ==> ... */
gen_nullptr_check(s1);
gen_bound_check;
var_to_reg_int(s3, src, REG_ITMP3);
- if (has_ext_instr_set) {
- M_LADD(s2, s1, REG_ITMP1);
- M_BST (s3, REG_ITMP1, OFFSET(java_bytearray, data[0]));
- }
- else {
- M_LADD (s2, s1, REG_ITMP1);
- M_LLD_U(REG_ITMP2, REG_ITMP1, OFFSET(java_bytearray, data[0]));
- M_LDA (REG_ITMP1, REG_ITMP1, OFFSET(java_bytearray, data[0]));
- M_INSBL(s3, REG_ITMP1, REG_ITMP3);
- M_MSKBL(REG_ITMP2, REG_ITMP1, REG_ITMP2);
- M_OR (REG_ITMP2, REG_ITMP3, REG_ITMP2);
- M_LST_U(REG_ITMP2, REG_ITMP1, 0);
- }
+ M_AADD(s2, s1, REG_ITMP1);
+ M_BST(s3, REG_ITMP1, OFFSET(java_bytearray, data[0]));
break;
a = dseg_addaddress(asm_handle_exception);
M_ALD(REG_ITMP2, REG_PV, a);
M_JSR(REG_ITMP2_XPC, REG_ITMP2);
+ M_NOP;
ALIGNCODENOP;
break;
/* op1 = target JavaVM pc */
M_BR(0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
ALIGNCODENOP;
break;
case ICMD_JSR: /* ... ==> ... */
/* op1 = target JavaVM pc */
- M_BSR(REG_ITMP1, 0);
- mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ dseg_addtarget(BlockPtrOfPC(iptr->op1));
+ M_ALD(REG_ITMP1, REG_PV, -dseglen);
+ M_JSR(REG_ITMP1, REG_ITMP1); /* REG_ITMP1 = return address */
+ M_NOP;
break;
case ICMD_RET: /* ... ==> ... */
}
else
M_RET(var->regoff);
+ M_NOP;
ALIGNCODENOP;
break;
var_to_reg_int(s1, src, REG_ITMP1);
M_BEQZ(s1, 0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IFNONNULL: /* ..., value ==> ... */
var_to_reg_int(s1, src, REG_ITMP1);
M_BNEZ(s1, 0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IFEQ: /* ..., value ==> ... */
M_BEQZ(s1, 0);
}
else {
- if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
- M_CMPEQ_IMM(s1, iptr->val.i, REG_ITMP1);
- }
- else {
- ICONST(REG_ITMP2, iptr->val.i);
- M_CMPEQ(s1, REG_ITMP2, REG_ITMP1);
- }
- M_BNEZ(REG_ITMP1, 0);
+ ICONST(REG_ITMP2, iptr->val.i);
+ M_BEQ(s1, REG_ITMP2, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IFLT: /* ..., value ==> ... */
M_BLTZ(s1, 0);
}
else {
- if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
+ if ((iptr->val.i >= -32768) && (iptr->val.i <= 32767)) {
M_CMPLT_IMM(s1, iptr->val.i, REG_ITMP1);
}
else {
M_BNEZ(REG_ITMP1, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IFLE: /* ..., value ==> ... */
M_BLEZ(s1, 0);
}
else {
- if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
- M_CMPLE_IMM(s1, iptr->val.i, REG_ITMP1);
+ if ((iptr->val.i >= -32769) && (iptr->val.i <= 32766)) {
+ M_CMPLT_IMM(s1, iptr->val.i + 1, REG_ITMP1);
+ M_BNEZ(REG_ITMP1, 0);
}
else {
ICONST(REG_ITMP2, iptr->val.i);
- M_CMPLE(s1, REG_ITMP2, REG_ITMP1);
+ M_CMPGT(s1, REG_ITMP2, REG_ITMP1);
+ M_BEQZ(REG_ITMP1, 0);
}
- M_BNEZ(REG_ITMP1, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IFNE: /* ..., value ==> ... */
M_BNEZ(s1, 0);
}
else {
- if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
- M_CMPEQ_IMM(s1, iptr->val.i, REG_ITMP1);
- }
- else {
- ICONST(REG_ITMP2, iptr->val.i);
- M_CMPEQ(s1, REG_ITMP2, REG_ITMP1);
- }
- M_BEQZ(REG_ITMP1, 0);
+ ICONST(REG_ITMP2, iptr->val.i);
+ M_BNE(s1, REG_ITMP2, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IFGT: /* ..., value ==> ... */
M_BGTZ(s1, 0);
}
else {
- if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
- M_CMPLE_IMM(s1, iptr->val.i, REG_ITMP1);
+ if ((iptr->val.i >= -32769) && (iptr->val.i <= 32766)) {
+ M_CMPLT_IMM(s1, iptr->val.i + 1, REG_ITMP1);
+ M_BEQZ(REG_ITMP1, 0);
}
else {
ICONST(REG_ITMP2, iptr->val.i);
- M_CMPLE(s1, REG_ITMP2, REG_ITMP1);
+ M_CMPGT(s1, REG_ITMP2, REG_ITMP1);
+ M_BNEZ(REG_ITMP1, 0);
}
- M_BEQZ(REG_ITMP1, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IFGE: /* ..., value ==> ... */
M_BGEZ(s1, 0);
}
else {
- if ((iptr->val.i > 0) && (iptr->val.i <= 255)) {
+ if ((iptr->val.i >= -32768) && (iptr->val.i <= 32767)) {
M_CMPLT_IMM(s1, iptr->val.i, REG_ITMP1);
}
else {
M_BEQZ(REG_ITMP1, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_LEQ: /* ..., value ==> ... */
M_BEQZ(s1, 0);
}
else {
- if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
- M_CMPEQ_IMM(s1, iptr->val.l, REG_ITMP1);
- }
- else {
- LCONST(REG_ITMP2, iptr->val.l);
- M_CMPEQ(s1, REG_ITMP2, REG_ITMP1);
- }
- M_BNEZ(REG_ITMP1, 0);
+ LCONST(REG_ITMP2, iptr->val.l);
+ M_BEQ(s1, REG_ITMP2, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_LLT: /* ..., value ==> ... */
M_BLTZ(s1, 0);
}
else {
- if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
+ if ((iptr->val.l >= -32768) && (iptr->val.l <= 32767)) {
M_CMPLT_IMM(s1, iptr->val.l, REG_ITMP1);
}
else {
M_BNEZ(REG_ITMP1, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_LLE: /* ..., value ==> ... */
M_BLEZ(s1, 0);
}
else {
- if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
- M_CMPLE_IMM(s1, iptr->val.l, REG_ITMP1);
+ if ((iptr->val.l >= -32769) && (iptr->val.l <= 32766)) {
+ M_CMPLT_IMM(s1, iptr->val.l + 1, REG_ITMP1);
+ M_BNEZ(REG_ITMP1, 0);
}
else {
LCONST(REG_ITMP2, iptr->val.l);
- M_CMPLE(s1, REG_ITMP2, REG_ITMP1);
+ M_CMPGT(s1, REG_ITMP2, REG_ITMP1);
+ M_BEQZ(REG_ITMP1, 0);
}
- M_BNEZ(REG_ITMP1, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_LNE: /* ..., value ==> ... */
M_BNEZ(s1, 0);
}
else {
- if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
- M_CMPEQ_IMM(s1, iptr->val.l, REG_ITMP1);
- }
- else {
- LCONST(REG_ITMP2, iptr->val.l);
- M_CMPEQ(s1, REG_ITMP2, REG_ITMP1);
- }
- M_BEQZ(REG_ITMP1, 0);
+ LCONST(REG_ITMP2, iptr->val.l);
+ M_BNE(s1, REG_ITMP2, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_LGT: /* ..., value ==> ... */
M_BGTZ(s1, 0);
}
else {
- if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
- M_CMPLE_IMM(s1, iptr->val.l, REG_ITMP1);
+ if ((iptr->val.l >= -32769) && (iptr->val.l <= 32766)) {
+ M_CMPLT_IMM(s1, iptr->val.l + 1, REG_ITMP1);
+ M_BEQZ(REG_ITMP1, 0);
}
else {
LCONST(REG_ITMP2, iptr->val.l);
- M_CMPLE(s1, REG_ITMP2, REG_ITMP1);
+ M_CMPGT(s1, REG_ITMP2, REG_ITMP1);
+ M_BNEZ(REG_ITMP1, 0);
}
- M_BEQZ(REG_ITMP1, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_LGE: /* ..., value ==> ... */
M_BGEZ(s1, 0);
}
else {
- if ((iptr->val.l > 0) && (iptr->val.l <= 255)) {
+ if ((iptr->val.l >= -32768) && (iptr->val.l <= 32767)) {
M_CMPLT_IMM(s1, iptr->val.l, REG_ITMP1);
}
else {
M_BEQZ(REG_ITMP1, 0);
}
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_ICMPEQ: /* ..., value, value ==> ... */
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
- M_CMPEQ(s1, s2, REG_ITMP1);
- M_BNEZ(REG_ITMP1, 0);
+ M_BEQ(s1, s2, 0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_ICMPNE: /* ..., value, value ==> ... */
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
- M_CMPEQ(s1, s2, REG_ITMP1);
- M_BEQZ(REG_ITMP1, 0);
+ M_BNE(s1, s2, 0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_ICMPLT: /* ..., value, value ==> ... */
M_CMPLT(s1, s2, REG_ITMP1);
M_BNEZ(REG_ITMP1, 0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_ICMPGT: /* ..., value, value ==> ... */
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
- M_CMPLE(s1, s2, REG_ITMP1);
- M_BEQZ(REG_ITMP1, 0);
+ M_CMPGT(s1, s2, REG_ITMP1);
+ M_BNEZ(REG_ITMP1, 0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_ICMPLE: /* ..., value, value ==> ... */
var_to_reg_int(s1, src->prev, REG_ITMP1);
var_to_reg_int(s2, src, REG_ITMP2);
- M_CMPLE(s1, s2, REG_ITMP1);
- M_BNEZ(REG_ITMP1, 0);
+ M_CMPGT(s1, s2, REG_ITMP1);
+ M_BEQZ(REG_ITMP1, 0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
case ICMD_IF_ICMPGE: /* ..., value, value ==> ... */
M_CMPLT(s1, s2, REG_ITMP1);
M_BEQZ(REG_ITMP1, 0);
mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr);
+ M_NOP;
break;
+#ifdef CONDITIONAL_LOADCONST
/* (value xx 0) ? IFxx_ICONST : ELSE_ICONST */
case ICMD_ELSE_ICONST: /* handled by IFxx_ICONST */
}
store_reg_to_var_int(iptr->dst, d);
break;
+#endif
case ICMD_IRETURN: /* ..., retvalue ==> ... */
#ifdef USE_THREADS
if (checksync && (method->flags & ACC_SYNCHRONIZED)) {
a = dseg_addaddress ((void*) (builtin_monitorexit));
- M_ALD(REG_PV, REG_PV, a);
- M_ALD(argintregs[0], REG_SP, 8 * maxmemuse);
- M_JSR(REG_RA, REG_PV);
- M_LDA(REG_PV, REG_RA, -(int)((u1*) mcodeptr - mcodebase));
+ M_ALD(REG_ITMP1, REG_PV, a);
+ M_JSR(REG_RA, REG_ITMP1);
+ M_ALD(argintregs[0], REG_SP, 8 * maxmemuse); /* delay slot */
}
#endif
var_to_reg_int(s1, src, REG_RESULT);
#ifdef USE_THREADS
if (checksync && (method->flags & ACC_SYNCHRONIZED)) {
a = dseg_addaddress ((void*) (builtin_monitorexit));
- M_ALD(REG_PV, REG_PV, a);
- M_ALD(argintregs[0], REG_SP, 8 * maxmemuse);
- M_JSR(REG_RA, REG_PV);
- M_LDA(REG_PV, REG_RA, -(int)((u1*) mcodeptr - mcodebase));
+ M_ALD(REG_ITMP1, REG_PV, a);
+ M_JSR(REG_RA, REG_ITMP1);
+ M_ALD(argintregs[0], REG_SP, 8 * maxmemuse); /* delay slot */
}
#endif
var_to_reg_flt(s1, src, REG_FRESULT);
#ifdef USE_THREADS
if (checksync && (method->flags & ACC_SYNCHRONIZED)) {
a = dseg_addaddress ((void*) (builtin_monitorexit));
- M_ALD(REG_PV, REG_PV, a);
- M_ALD(argintregs[0], REG_SP, 8 * maxmemuse);
- M_JSR(REG_RA, REG_PV);
- M_LDA(REG_PV, REG_RA, -(int)((u1*) mcodeptr - mcodebase));
+ M_ALD(REG_ITMP1, REG_PV, a);
+ M_JSR(REG_RA, REG_ITMP1);
+ M_ALD(argintregs[0], REG_SP, 8 * maxmemuse); /* delay slot */
}
#endif
for (r = savfltregcnt - 1; r >= maxsavfltreguse; r--)
{p--; M_DLD(savfltregs[r], REG_SP, 8 * p);}
- /* deallocate stack */
-
- if (parentargs_base)
- {M_LDA(REG_SP, REG_SP, parentargs_base*8);}
-
/* call trace function */
if (runverbose) {
a = dseg_addaddress (method);
M_ALD(argintregs[0], REG_PV, a);
M_MOV(REG_RESULT, argintregs[1]);
- M_FLTMOVE(REG_FRESULT, argfltregs[2]);
a = dseg_addaddress ((void*) (builtin_displaymethodstop));
- M_ALD(REG_PV, REG_PV, a);
- M_JSR (REG_RA, REG_PV);
- s1 = (int)((u1*) mcodeptr - mcodebase);
- if (s1<=32768) M_LDA (REG_PV, REG_RA, -s1);
- else {
- s4 ml=-s1, mh=0;
- while (ml<-32768) { ml+=65536; mh--; }
- M_LDA (REG_PV, REG_RA, ml );
- M_LDAH (REG_PV, REG_PV, mh );
- }
- M_DLD(REG_FRESULT, REG_SP,16);
- M_LLD(REG_RESULT, REG_SP, 8);
+ M_ALD(REG_ITMP1, REG_PV, a);
+ M_JSR (REG_RA, REG_ITMP1);
+ M_FLTMOVE(REG_FRESULT, argfltregs[2]); /* delay slot */
+
M_ALD(REG_RA, REG_SP, 0);
+ M_LLD(REG_RESULT, REG_SP, 8);
+ M_DLD(REG_FRESULT, REG_SP,16);
M_LDA (REG_SP, REG_SP, 24);
}
M_RET(REG_RA);
+
+ /* deallocate stack */
+
+ if (parentargs_base)
+ {M_LDA(REG_SP, REG_SP, parentargs_base*8);}
+ else
+ {M_NOP;}
ALIGNCODENOP;
}
break;
var_to_reg_int(s1, src, REG_ITMP1);
if (l == 0)
{M_INTMOVE(s1, REG_ITMP1);}
- else
- M_LDA(REG_ITMP1, s1, -l);
+ else if (l <= 32768) {
+ M_IADD_IMM(s1, -l, REG_ITMP1);
+ }
+ else {
+ ICONST(REG_ITMP2, l);
+ M_ISUB(s1, REG_ITMP2, REG_ITMP1);
+ }
i = i - l + 1;
/* range check */
- if (i <= 256)
- M_CMPULE_IMM(REG_ITMP1, i - 1, REG_ITMP2);
- else {
- M_LDA(REG_ITMP2, REG_ZERO, i - 1);
- M_CMPULE(REG_ITMP1, REG_ITMP2, REG_ITMP2);
- }
+ M_CMPULT_IMM(REG_ITMP1, i, REG_ITMP2);
M_BEQZ(REG_ITMP2, 0);
mcode_addreference(BlockPtrOfPC(s4ptr[0]), mcodeptr);
+ M_ASLL_IMM(REG_ITMP1, POINTERSHIFT, REG_ITMP1); /* delay slot*/
/* build jump table top down and use address of lowest entry */
/* length of dataseg after last dseg_addtarget is used by load */
- M_SAADDQ(REG_ITMP1, REG_PV, REG_ITMP2);
+ M_AADD(REG_ITMP1, REG_PV, REG_ITMP2);
M_ALD(REG_ITMP2, REG_ITMP2, -dseglen);
M_JMP(REG_ITMP2);
+ M_NOP;
ALIGNCODENOP;
break;
MCODECHECK((i<<2)+8);
var_to_reg_int(s1, src, REG_ITMP1);
- while (--i >= 0) {
+ if (i > 0) {
s4ptr += 2;
val = s4ptr[0];
- if ((val >= 0) && (val <= 255)) {
- M_CMPEQ_IMM(s1, val, REG_ITMP2);
+ ICONST(REG_ITMP2, val);
+ while (--i > 0) {
+ M_BEQ(s1, REG_ITMP2, 0);
+ mcode_addreference(BlockPtrOfPC(s4ptr[1]), mcodeptr);
+ s4ptr += 2;
+ val = s4ptr[0];
+ ICONST(REG_ITMP2, val);
}
- else {
- if ((val >= -32768) && (val <= 32767)) {
- M_LDA(REG_ITMP2, REG_ZERO, val);
- }
- else {
- a = dseg_adds4 (val);
- M_ILD(REG_ITMP2, REG_PV, a);
- }
- M_CMPEQ(s1, REG_ITMP2, REG_ITMP2);
- }
- M_BNEZ(REG_ITMP2, 0);
+ M_BEQ(s1, REG_ITMP2, 0);
mcode_addreference(BlockPtrOfPC(s4ptr[1]), mcodeptr);
+ M_NOP;
}
M_BR(0);
mcode_addreference(BlockPtrOfPC(l), mcodeptr);
+ M_NOP;
ALIGNCODENOP;
break;
}
case ICMD_BUILTIN2:
case ICMD_BUILTIN1:
a = dseg_addaddress ((void*) (m));
-
- M_ALD(REG_PV, REG_PV, a); /* Pointer to built-in-function */
- d = iptr->op1;
- goto makeactualcall;
+ M_ALD(REG_ITMP1, REG_PV, a); /* built-in-function pointer */
+ M_JSR (REG_RA, REG_ITMP1);
+ M_NOP;
+ d = iptr->op1; /* return type */
+ goto afteractualcall;
case ICMD_INVOKESTATIC:
case ICMD_INVOKESPECIAL:
a = dseg_addaddress (m->stubroutine);
- M_ALD(REG_PV, REG_PV, a ); /* method pointer in r27 */
+ M_ALD(REG_PV, REG_PV, a ); /* method pointer in pv */
d = m->returntype;
goto makeactualcall;
makeactualcall:
M_JSR (REG_RA, REG_PV);
+ M_NOP;
/* recompute pv */
s1 = (int)((u1*) mcodeptr - mcodebase);
if (s1<=32768) M_LDA (REG_PV, REG_RA, -s1);
else {
- s4 ml=-s1, mh=0;
- while (ml<-32768) { ml+=65536; mh--; }
- M_LDA (REG_PV, REG_RA, ml );
- M_LDAH (REG_PV, REG_PV, mh );
+ panic("method to big");
}
+afteractualcall:
+
/* d contains return type */
if (d != TYPE_VOID) {
M_CLR(d);
if (iptr->op1) { /* class/interface */
if (super->flags & ACC_INTERFACE) { /* interface */
- M_BEQZ(s1, 6);
+ M_BEQZ(s1, 8);
+ M_NOP;
M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
M_ILD(REG_ITMP2, REG_ITMP1, OFFSET(vftbl, interfacetablelength));
- M_LDA(REG_ITMP2, REG_ITMP2, - super->index);
- M_BLEZ(REG_ITMP2, 2);
+ M_IADD_IMM(REG_ITMP2, - super->index, REG_ITMP2);
+ M_BLEZ(REG_ITMP2, 3);
+ M_NOP;
M_ALD(REG_ITMP1, REG_ITMP1,
OFFSET(vftbl, interfacetable[0]) -
super->index * sizeof(methodptr*));
}
else { /* class */
s2 = super->vftbl->diffval;
- M_BEQZ(s1, 4 + (s2 > 255));
+ M_BEQZ(s1, 5);
+ M_NOP;
M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl, baseval));
- M_LDA(REG_ITMP1, REG_ITMP1, - super->vftbl->baseval);
- if (s2 <= 255)
- M_CMPULE_IMM(REG_ITMP1, s2, d);
- else {
- M_LDA(REG_ITMP2, REG_ZERO, s2);
- M_CMPULE(REG_ITMP1, REG_ITMP2, d);
- }
+ M_IADD_IMM(REG_ITMP1, - super->vftbl->baseval, REG_ITMP1);
+ M_CMPULT_IMM(REG_ITMP1, s2 + 1, d);
}
}
else
var_to_reg_int(s1, src, d);
if (iptr->op1) { /* class/interface */
if (super->flags & ACC_INTERFACE) { /* interface */
- M_BEQZ(s1, 6);
+ M_BEQZ(s1, 9);
+ M_NOP;
M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
M_ILD(REG_ITMP2, REG_ITMP1, OFFSET(vftbl, interfacetablelength));
- M_LDA(REG_ITMP2, REG_ITMP2, - super->index);
+ M_IADD_IMM(REG_ITMP2, - super->index, REG_ITMP2);
M_BLEZ(REG_ITMP2, 0);
mcode_addxcastrefs(mcodeptr);
+ M_NOP;
M_ALD(REG_ITMP2, REG_ITMP1,
OFFSET(vftbl, interfacetable[0]) -
super->index * sizeof(methodptr*));
M_BEQZ(REG_ITMP2, 0);
mcode_addxcastrefs(mcodeptr);
+ M_NOP;
}
else { /* class */
s2 = super->vftbl->diffval;
- M_BEQZ(s1, 4 + (s2 != 0) + (s2 > 255));
+ M_BEQZ(s1, 6 + (s2 != 0));
+ M_NOP;
M_ALD(REG_ITMP1, s1, OFFSET(java_objectheader, vftbl));
M_ILD(REG_ITMP1, REG_ITMP1, OFFSET(vftbl, baseval));
- M_LDA(REG_ITMP1, REG_ITMP1, - super->vftbl->baseval);
+ M_IADD_IMM(REG_ITMP1, - super->vftbl->baseval, REG_ITMP1);
if (s2 == 0) {
M_BNEZ(REG_ITMP1, 0);
}
- else if (s2 <= 255) {
- M_CMPULE_IMM(REG_ITMP1, s2, REG_ITMP2);
- M_BEQZ(REG_ITMP2, 0);
- }
- else {
- M_LDA(REG_ITMP2, REG_ZERO, s2);
- M_CMPULE(REG_ITMP1, REG_ITMP2, REG_ITMP2);
+ else{
+ M_CMPULT_IMM(REG_ITMP1, s2 + 1, REG_ITMP2);
M_BEQZ(REG_ITMP2, 0);
}
mcode_addxcastrefs(mcodeptr);
+ M_NOP;
}
}
else
var_to_reg_int(s1, src, REG_ITMP1);
M_BLTZ(s1, 0);
mcode_addxcheckarefs(mcodeptr);
+ M_NOP;
break;
case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref */
var_to_reg_int(s2, src, REG_ITMP1);
M_BLTZ(s2, 0);
mcode_addxcheckarefs(mcodeptr);
+ M_NOP;
/* copy sizes to stack (argument numbers >= INT_ARG_CNT) */
/* a0 = dimension count */
- M_LDA(argintregs[0], REG_ZERO, iptr->op1);
+ ICONST(argintregs[0], iptr->op1);
/* a1 = arraydescriptor */
M_INTMOVE(REG_SP, argintregs[2]);
a = dseg_addaddress((void*) (builtin_nmultianewarray));
- M_ALD(REG_PV, REG_PV, a);
- M_JSR(REG_RA, REG_PV);
- s1 = (int)((u1*) mcodeptr - mcodebase);
- if (s1 <= 32768)
- M_LDA (REG_PV, REG_RA, -s1);
- else {
- s4 ml = -s1, mh = 0;
- while (ml < -32768) {ml += 65536; mh--;}
- M_LDA(REG_PV, REG_RA, ml);
- M_LDAH(REG_PV, REG_PV, mh);
- }
+ M_ALD(REG_ITMP1, REG_PV, a);
+ M_JSR(REG_RA, REG_ITMP1);
+ M_NOP;
s1 = reg_of_var(iptr->dst, REG_RESULT);
M_INTMOVE(REG_RESULT, s1);
store_reg_to_var_int(iptr->dst, s1);
if (xcodeptr != NULL) {
M_BR((xcodeptr-mcodeptr)-1);
+ M_NOP;
}
else {
xcodeptr = mcodeptr;
M_ALD(REG_ITMP3, REG_PV, a);
M_JMP(REG_ITMP3);
+ M_NOP;
}
}
if (xcodeptr != NULL) {
M_BR((xcodeptr-mcodeptr)-1);
+ M_NOP;
}
else {
xcodeptr = mcodeptr;
M_ALD(REG_ITMP3, REG_PV, a);
M_JMP(REG_ITMP3);
+ M_NOP;
}
}
if (xcodeptr != NULL) {
M_BR((xcodeptr-mcodeptr)-1);
+ M_NOP;
}
else {
xcodeptr = mcodeptr;
M_ALD(REG_ITMP3, REG_PV, a);
M_JMP(REG_ITMP3);
+ M_NOP;
}
}
if (xcodeptr != NULL) {
M_BR((xcodeptr-mcodeptr)-1);
+ M_NOP;
}
else {
xcodeptr = mcodeptr;
M_ALD(REG_ITMP3, REG_PV, a);
M_JMP(REG_ITMP3);
+ M_NOP;
}
}
This makes sense only for the stub-generation-routines below.
*/
-#undef M_OP3
-#define M_OP3(op,fu,a,b,c,const) \
- *(p++) = ( (((s4)(op))<<26)|((a)<<21)|((b)<<(16-3*(const)))| \
- ((const)<<12)|((fu)<<5)|((c)) )
-#undef M_FOP3
-#define M_FOP3(op,fu,a,b,c) \
- *(p++) = ( (((s4)(op))<<26)|((a)<<21)|((b)<<16)|((fu)<<5)|(c) )
-#undef M_BRA
-#define M_BRA(op,a,disp) \
- *(p++) = ( (((s4)(op))<<26)|((a)<<21)|((disp)&0x1fffff) )
-#undef M_MEM
-#define M_MEM(op,a,b,disp) \
- *(p++) = ( (((s4)(op))<<26)|((a)<<21)|((b)<<16)|((disp)&0xffff) )
+#undef M_ITYPE
+#define M_ITYPE(op, rs, rt, imm)\
+ *(p++) = (((op)<<26)|((rs)<<21)|((rt)<<16)|((imm)&0xffff))
+
+#undef M_JTYPE
+#define M_JTYPE(op, imm)\
+ *(p++) = (((op)<<26)|((off)&0x3ffffff))
+
+#undef M_RTYPE
+#define M_RTYPE(op, rs, rt, rd, sa, fu)\
+ *(p++) = (((op)<<26)|((rs)<<21)|((rt)<<16)|((rd)<<11)|((sa)<<6)|(fu))
/* function createcompilerstub *************************************************
*******************************************************************************/
-#define COMPSTUBSIZE 3
+#define COMPSTUBSIZE 4
u1 *createcompilerstub (methodinfo *m)
{
s4 *p = (s4*) s; /* code generation pointer */
/* code for the stub */
- M_ALD (REG_PV, REG_PV, 16); /* load pointer to the compiler */
- M_JSR (0, REG_PV); /* jump to the compiler, return address
- in reg 0 is used as method pointer */
- s[1] = (u8) m; /* literals to be adressed */
- s[2] = (u8) asm_call_jit_compiler; /* jump directly via PV from above */
+ M_ALD(REG_PV, REG_PV, 16); /* load pointer to the compiler */
+ M_JSR(REG_ITMP1, REG_PV); /* jump to the compiler, return address
+ in itmp1 is used as method pointer */
+ M_NOP;
+ M_NOP;
+
+ s[2] = (u8) m; /* literals to be adressed */
+ s[3] = (u8) asm_call_jit_compiler; /* jump directly via PV from above */
#ifdef STATISTICS
count_cstub_len += COMPSTUBSIZE * 8;
u8 *s = CNEW (u8, NATIVESTUBSIZE); /* memory to hold the stub */
s4 *p = (s4*) s; /* code generation pointer */
+ M_ALD (REG_ITMP1, REG_PV, 8*8); /* load adress of native method */
M_LDA (REG_SP, REG_SP, -8); /* build up stackframe */
- M_AST (REG_RA, REG_SP, 0); /* store return address */
- M_ALD (REG_PV, REG_PV, 8*8); /* load adress of native method */
- M_JSR (REG_RA, REG_PV); /* call native method */
+ M_AST (REG_RA, REG_SP, 0); /* store return address */
+ M_JSR (REG_RA, REG_ITMP1); /* call native method */
- M_LDA (REG_PV, REG_RA, -4*4); /* recompute pv from ra */
+ M_NOP; /* delay slot */
M_ALD (REG_ITMP3, REG_PV, 9*8); /* get address of exceptionptr */
M_ALD (REG_RA, REG_SP, 0); /* load return address */
M_ALD (REG_ITMP1, REG_ITMP3, 0); /* load exception into reg. itmp1 */
- M_LDA (REG_SP, REG_SP, 8); /* remove stackframe */
- M_BNEZ (REG_ITMP1, 1); /* if no exception then return */
+ M_BNEZ (REG_ITMP1, 2); /* if no exception then return */
+ M_LDA (REG_SP, REG_SP, 8); /* remove stackframe, delay slot */
M_RET (REG_RA); /* return to caller */
+ M_NOP; /* delay slot */
M_AST (REG_ZERO, REG_ITMP3, 0); /* store NULL into exceptionptr */
- M_LDA (REG_ITMP2, REG_RA, -4); /* move fault address into reg. itmp2 */
-
M_ALD (REG_ITMP3, REG_PV,10*8); /* load asm exception handler address */
- M_JMP (REG_ITMP3); /* jump to asm exception handler */
+ M_JMP (REG_ITMP3); /* jump to asm exception handler */
+ M_LDA (REG_ITMP2, REG_RA, -4); /* move fault address into reg. itmp2 */
+ /* delay slot */
s[8] = (u8) f; /* address of native method */
s[9] = (u8) (&exceptionptr); /* address of exceptionptr */
#define REG_RA 31 /* return address */
#define REG_SP 29 /* stack pointer */
-#define REG_PV 25 /* procedure vector, must be provided by caller */
-#define REG_METHODPTR 24 /* pointer to the place from where the procedure */
+#define REG_PV 28 /* procedure vector, must be provided by caller */
+#define REG_METHODPTR 25 /* pointer to the place from where the procedure */
/* vector has been fetched */
#define REG_ITMP1_XPTR 1 /* exception pointer = temporary register 1 */
#define REG_ITMP2_XPC 3 /* exception pc = temporary register 2 */
REG_RES, REG_RES, REG_RET, REG_RES, REG_ARG, REG_ARG, REG_ARG, REG_ARG,
REG_ARG, REG_ARG, REG_ARG, REG_ARG, REG_TMP, REG_TMP, REG_TMP, REG_TMP,
REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV, REG_SAV,
- REG_RES, REG_RES, REG_RES, REG_RES, REG_SAV, REG_RES, REG_SAV, REG_RES,
+ REG_TMP, REG_RES, REG_RES, REG_RES, REG_RES, REG_RES, REG_SAV, REG_RES,
REG_END };
-#define INT_SAV_CNT 10 /* number of int callee saved registers */
+#define INT_SAV_CNT 9 /* number of int callee saved registers */
#define INT_ARG_CNT 8 /* number of int argument registers */
/* for use of reserved registers, see comment above */
#define M_ITYPE(op, rs, rt, imm)\
- *(mcodeptr++) = (((op)<<26)|((rs)<<21)|((rt)<<16)|((off)&0xffff))
+ *(mcodeptr++) = (((op)<<26)|((rs)<<21)|((rt)<<16)|((imm)&0xffff))
#define M_JTYPE(op, imm)\
*(mcodeptr++) = (((op)<<26)|((off)&0x3ffffff))
#define M_RTYPE(op, rs, rt, rd, sa, fu)\
- *(mcodeptr++) = (((op)<<26)|((rs)<<21)|((rt)<<16)|((rd)<<11)|((sa)<<6)|(fu)
+ *(mcodeptr++) = (((op)<<26)|((rs)<<21)|((rt)<<16)|((rd)<<11)|((sa)<<6)|(fu))
#define M_FP2(fu, fmt, fs, fd) M_RTYPE(0x11, fmt, 0, fs, fd, fu)
#define M_FP3(fu, fmt, fs, ft, fd) M_RTYPE(0x11, fmt, ft, fs, fd, fu)
#define M_FST(a,b,disp) M_ITYPE(0x39,b,a,disp) /* store flt */
#define M_DST(a,b,disp) M_ITYPE(0x3d,b,a,disp) /* store dbl */
-/*
- * Load Address pseudo instruction:
- * -n32 addressing mode -> 32 bit addrs, -64 addressing mode -> 64 bit addrs
- */
-#if POINTERSIZE==8
-#define POINTERSHIFT 3
-#define M_ALD(a,b,disp) M_LLD(a,b,disp)
-#define M_AST(a,b,disp) M_LST(a,b,disp)
-#else
-#define POINTERSHIFT 2
-#define M_ALD(a,b,disp) M_ILD(a,b,disp)
-#define M_AST(a,b,disp) M_IST(a,b,disp)
-#endif
-
#define M_BEQ(a,b,disp) M_ITYPE(0x04,a,b,disp) /* br a == b */
#define M_BNE(a,b,disp) M_ITYPE(0x05,a,b,disp) /* br a != b */
#define M_BEQZ(a,disp) M_ITYPE(0x04,a,0,disp) /* br a == 0 */
#define M_MFLO(a) M_RTYPE(0,0,0,a,0,0x12) /* quotient */
#define M_MFHI(a) M_RTYPE(0,0,0,a,0,0x10) /* remainder */
-#define M_IADD_IMM(a,b,c) M_ITYPE(0x08,a,c,b) /* 32 add */
-#define M_LADD_IMM(a,b,c) M_ITYPE(0x18,a,c,b) /* 64 add */
-#define M_ISUB_IMM(a,b,c) M_ITYPE(0x08,a,c,-(b)) /* 32 sub */
-#define M_LSUB_IMM(a,b,c) M_ITYPE(0x18,a,c,-(b)) /* 64 sub */
+#define M_IADD_IMM(a,b,c) M_ITYPE(0x09,a,c,b) /* 32 add */
+#define M_LADD_IMM(a,b,c) M_ITYPE(0x19,a,c,b) /* 64 add */
+#define M_ISUB_IMM(a,b,c) M_ITYPE(0x09,a,c,-(b)) /* 32 sub */
+#define M_LSUB_IMM(a,b,c) M_ITYPE(0x19,a,c,-(b)) /* 64 sub */
-#define M_LDA(a,b,disp) M_LADD_IMM(b,disp,a) /* a = b+disp */
+#define M_LUI(a,imm) M_ITYPE(0x0f,0,a,imm) /* a = imm<<16*/
#define M_CMPLT(a,b,c) M_RTYPE(0,a,b,c,0,0x2a) /* c = a < b */
#define M_CMPGT(a,b,c) M_RTYPE(0,b,a,c,0,0x2a) /* c = a > b */
#define M_OR_IMM( a,b,c) M_ITYPE(0x0d,a,c,b) /* c = a | b */
#define M_XOR_IMM(a,b,c) M_ITYPE(0x0e,a,c,b) /* c = a ^ b */
-#define M_MOV(a,c) M_OR(a,a,c) /* c = a */
-#define M_CLR(c) M_OR(0,0,c) /* c = 0 */
-#define M_NOP M_OR(0,0,0) /* ; */
+#define M_CZEXT(a,c) M_AND_IMM(a,0xffff,c) /* c = zext(a)*/
#define M_ISLL(a,b,c) M_RTYPE(0,b,a,c,0,0x04) /* c = a << b */
#define M_ISRL(a,b,c) M_RTYPE(0,b,a,c,0,0x06) /* c = a >>>b */
#define M_LSRL(a,b,c) M_RTYPE(0,b,a,c,0,0x16) /* c = a >>>b */
#define M_LSRA(a,b,c) M_RTYPE(0,b,a,c,0,0x17) /* c = a >> b */
-#define M_ISLL_IMM(a,b,c) M_RTYPE(0,0,a,c,b&1f,0x00) /* c = a << b */
-#define M_ISRL_IMM(a,b,c) M_RTYPE(0,0,a,c,b&1f,0x02) /* c = a >>>b */
-#define M_ISRA_IMM(a,b,c) M_RTYPE(0,0,a,c,b&1f,0x03) /* c = a >> b */
-#define M_LSLL_IMM(a,b,c) M_RTYPE(0,0,a,c,b&1f,0x38+4*(b&x020)) /* c = a << b */
-#define M_LSRL_IMM(a,b,c) M_RTYPE(0,0,a,c,b&1f,0x3a+4*(b&x020)) /* c = a >>>b */
-#define M_LSRA_IMM(a,b,c) M_RTYPE(0,0,a,c,b&1f,0x3b+4*(b&x020)) /* c = a >> b */
+#define M_ISLL_IMM(a,b,c) M_RTYPE(0,0,a,c,(b)&31,0x00) /* c = a << b */
+#define M_ISRL_IMM(a,b,c) M_RTYPE(0,0,a,c,(b)&31,0x02) /* c = a >>>b */
+#define M_ISRA_IMM(a,b,c) M_RTYPE(0,0,a,c,(b)&31,0x03) /* c = a >> b */
+#define M_LSLL_IMM(a,b,c) M_RTYPE(0,0,a,c,(b)&31,0x38+4*((b)&32)) /*c = a << b*/
+#define M_LSRL_IMM(a,b,c) M_RTYPE(0,0,a,c,(b)&31,0x3a+4*((b)&32)) /*c = a >>>b*/
+#define M_LSRA_IMM(a,b,c) M_RTYPE(0,0,a,c,(b)&31,0x3b+4*((b)&32)) /*c = a >> b*/
+
+#define M_MOV(a,c) M_OR(a,0,c) /* c = a */
+#define M_CLR(c) M_OR(0,0,c) /* c = 0 */
+#define M_NOP M_ISLL_IMM(0,0,0) /* ; */
/* floating point macros use the form OPERATION(source, source, dest) */
#define M_FLOORFL(a,c) M_FP2(0x0b,FMT_F,a,c) /* flt truncl */
#define M_FLOORDL(a,c) M_FP2(0x0b,FMT_D,a,c) /* dbl truncl */
-#define M_CVTDF(b,c) M_FP2(0x20,FMT_D,a,c) /* dbl2flt */
-#define M_CVTIF(b,c) M_FP2(0x20,FMT_I,a,c) /* int2flt */
-#define M_CVTLF(b,c) M_FP2(0x20,FMT_L,a,c) /* long2flt */
-#define M_CVTFD(b,c) M_FP2(0x21,FMT_F,a,c) /* flt2dbl */
-#define M_CVTID(b,c) M_FP2(0x21,FMT_I,a,c) /* int2dbl */
-#define M_CVTLD(b,c) M_FP2(0x21,FMT_L,a,c) /* long2dbl */
-#define M_CVTFI(b,c) M_FP2(0x24,FMT_F,a,c) /* flt2int */
-#define M_CVTDI(b,c) M_FP2(0x24,FMT_D,a,c) /* dbl2int */
-#define M_CVTFL(b,c) M_FP2(0x25,FMT_F,a,c) /* flt2long */
-#define M_CVTDL(b,c) M_FP2(0x25,FMT_D,a,c) /* dbl2long */
+#define M_CVTDF(a,c) M_FP2(0x20,FMT_D,a,c) /* dbl2flt */
+#define M_CVTIF(a,c) M_FP2(0x20,FMT_I,a,c) /* int2flt */
+#define M_CVTLF(a,c) M_FP2(0x20,FMT_L,a,c) /* long2flt */
+#define M_CVTFD(a,c) M_FP2(0x21,FMT_F,a,c) /* flt2dbl */
+#define M_CVTID(a,c) M_FP2(0x21,FMT_I,a,c) /* int2dbl */
+#define M_CVTLD(a,c) M_FP2(0x21,FMT_L,a,c) /* long2dbl */
+#define M_CVTFI(a,c) M_FP2(0x24,FMT_F,a,c) /* flt2int */
+#define M_CVTDI(a,c) M_FP2(0x24,FMT_D,a,c) /* dbl2int */
+#define M_CVTFL(a,c) M_FP2(0x25,FMT_F,a,c) /* flt2long */
+#define M_CVTDL(a,c) M_FP2(0x25,FMT_D,a,c) /* dbl2long */
-#define M_MOVDL(d,l) M_FP3(0,1,l,d,0) /* l = d */
-#define M_MOVLD(l,d) M_FP3(0,5,l,d,0) /* d = l */
+#define M_MOVDL(d,l) M_FP3(0,1,d,l,0) /* l = d */
+#define M_MOVLD(l,d) M_FP3(0,5,d,l,0) /* d = l */
#define M_FCMPFF(a,b) M_FP3(0x30,FMT_F,a,b,0) /* c = a == b */
#define M_FCMPFD(a,b) M_FP3(0x30,FMT_D,a,b,0) /* c = a == b */
#define M_FBFL(disp) M_ITYPE(0x11,8,2,disp) /* br false */
#define M_FBTL(disp) M_ITYPE(0x11,8,3,disp) /* br true */
+/*
+ * Load Address pseudo instruction:
+ * -n32 addressing mode -> 32 bit addrs, -64 addressing mode -> 64 bit addrs
+ */
+#if POINTERSIZE==8
+#define POINTERSHIFT 3
+#define M_ALD(a,b,disp) M_LLD(a,b,disp)
+#define M_AST(a,b,disp) M_LST(a,b,disp)
+#define M_AADD(a,b,c) M_LADD(a,b,c)
+#define M_ASLL_IMM(a,b,c) M_LSLL_IMM(a,b,c)
+#define M_LDA(a,b,disp) M_LADD_IMM(b,disp,a) /* a = b+disp */
+#else
+#define POINTERSHIFT 2
+#define M_ALD(a,b,disp) M_ILD(a,b,disp)
+#define M_AST(a,b,disp) M_IST(a,b,disp)
+#define M_AADD(a,b,c) M_IADD(a,b,c)
+#define M_ASLL_IMM(a,b,c) M_ISLL_IMM(a,b,c)
+#define M_LDA(a,b,disp) M_IADD_IMM(b,disp,a) /* a = b+disp */
+#endif
+
/* macros for special commands (see an Alpha-manual for description) **********/
#if 0
projects / cacao.git / commitdiff