From: cacao Date: Wed, 18 Nov 1998 14:57:48 +0000 (+0000) Subject: mips codegenerator added X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=commitdiff_plain;h=686f2a7e72f12a4681dc4ae4bfcf729337e790ab;p=cacao.git mips codegenerator added --- diff --git a/mips/calling.doc b/mips/calling.doc index 95d3ce390..59d7a0125 100644 --- a/mips/calling.doc +++ b/mips/calling.doc @@ -53,23 +53,25 @@ R12-R15 ... temporary registers (destroyed by called method) R16-R23 ... saved registers (left unchanged by called method) -R24 ....... pointer to 'methodinfo' structure. This register has to be set +R24 ....... temporary register (destroyed by called method) + +R25 ....... pointer to 'methodinfo' structure. This register has to be set correctly, because it is needed in the case the jit is invoked. Also used as code generator temporary register. It is destroyed by called method) -R25 (pv) .. procedure vector, points to the first instruction of the called - method. This vector is used for addressing the entries in the - data segment. The ov of the caller is recomputed from the ra. - Therefore it is necessary that a return is always done using ra. - R26-R27 ... reserved register (reserved for kernel) -R28 ....... saved registers (left unchanged by called method) +R28 (pv) .. procedure vector, points to the first instruction of the called + method. This vector is used for addressing the entries in the + data segment. The pv of the caller is recomputed from the ra in + Java methods. R30 is callee saved in the MIPS ABI. So pv is not + recomputed if builtin functions are called. For Java methods it + is necessary that a return is always done using ra. R29 (sp) .. stack pointer. The stack grows from high to low. -R30 ....... saved register (left unchanged by called method) +R30 ....... saved registers (left unchanged by called method) R31 (ra) .. return address (left unchanged by called method) diff --git a/mips/disass.c b/mips/disass.c index 88e6b1d12..d2dc344a2 100644 --- a/mips/disass.c +++ b/mips/disass.c @@ -24,94 +24,95 @@ #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} }; @@ -119,77 +120,77 @@ static struct {char *name; int itype;} ops[] = { 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} }; @@ -197,41 +198,41 @@ static struct {char *name; int ftype;} regops[] = { 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} }; @@ -239,23 +240,23 @@ static struct {char *name; int ftype;} regimms[] = { 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}, @@ -267,20 +268,20 @@ static struct {char *name; char *fill; int ftype;} fops[] = { /* 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}, @@ -293,35 +294,35 @@ static struct {char *name; char *fill; int ftype;} fops[] = { /* 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 */ ".?" }; @@ -330,13 +331,99 @@ static char *fmt[] = { /* 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' @@ -360,74 +447,97 @@ static void disassinstr(int c, int pos) 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: @@ -441,33 +551,30 @@ static void disassinstr(int c, int pos) } 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); } } diff --git a/mips/ngen.c b/mips/ngen.c index ea2f50d04..58c181279 100644 --- a/mips/ngen.c +++ b/mips/ngen.c @@ -60,6 +60,7 @@ in the documention file: calling.doc if (checknull) {\ M_BEQZ((objreg), 0);\ mcode_addxnullrefs(mcodeptr);\ + M_NOP;\ } #else #define gen_nullptr_check(objreg) @@ -84,7 +85,7 @@ in the documention file: calling.doc 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: @@ -195,42 +196,9 @@ static int reg_of_var(stackptr v, int tempregnum) /* 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; @@ -239,14 +207,17 @@ void catch_NullPointerException(int sig, int code, sigctx_struct *sigctx) /* 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); @@ -256,34 +227,8 @@ void catch_NullPointerException(int sig, int code, sigctx_struct *sigctx) } -#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 - -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) { @@ -425,8 +370,9 @@ static void gen_mcode() */ 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); @@ -434,22 +380,27 @@ static void gen_mcode() 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); @@ -457,15 +408,19 @@ static void gen_mcode() 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 */ @@ -523,9 +478,9 @@ static void gen_mcode() 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); } @@ -534,10 +489,9 @@ static void gen_mcode() #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 } @@ -621,14 +575,17 @@ static void gen_mcode() 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 */ @@ -855,13 +812,8 @@ static void gen_mcode() 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; @@ -877,13 +829,8 @@ static void gen_mcode() 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; @@ -902,7 +849,7 @@ static void gen_mcode() 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 { @@ -926,7 +873,7 @@ static void gen_mcode() 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 { @@ -950,8 +897,8 @@ static void gen_mcode() 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); @@ -974,8 +921,8 @@ static void gen_mcode() 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); @@ -989,7 +936,10 @@ static void gen_mcode() 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; @@ -998,13 +948,11 @@ static void gen_mcode() 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; @@ -1013,7 +961,10 @@ static void gen_mcode() 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; @@ -1022,31 +973,123 @@ static void gen_mcode() 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; @@ -1055,9 +1098,7 @@ static void gen_mcode() 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; @@ -1066,8 +1107,7 @@ static void gen_mcode() 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; @@ -1076,8 +1116,7 @@ static void gen_mcode() 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; @@ -1086,7 +1125,7 @@ static void gen_mcode() 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; @@ -1095,10 +1134,7 @@ static void gen_mcode() 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; @@ -1107,9 +1143,7 @@ static void gen_mcode() 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; @@ -1118,7 +1152,7 @@ static void gen_mcode() 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; @@ -1127,7 +1161,7 @@ static void gen_mcode() 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; @@ -1136,7 +1170,7 @@ static void gen_mcode() 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; @@ -1145,7 +1179,7 @@ static void gen_mcode() 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; @@ -1154,7 +1188,7 @@ static void gen_mcode() 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; @@ -1163,7 +1197,7 @@ static void gen_mcode() 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; @@ -1182,15 +1216,9 @@ static void gen_mcode() 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); @@ -1207,28 +1235,18 @@ static void gen_mcode() 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); } @@ -1249,27 +1267,20 @@ static void gen_mcode() 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; @@ -1278,27 +1289,9 @@ static void gen_mcode() 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); @@ -1315,52 +1308,18 @@ static void gen_mcode() 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); } @@ -1372,34 +1331,12 @@ static void gen_mcode() 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; @@ -1418,7 +1355,7 @@ static void gen_mcode() 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 { @@ -1433,7 +1370,7 @@ static void gen_mcode() 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 { @@ -1458,7 +1395,7 @@ static void gen_mcode() 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 { @@ -1473,7 +1410,7 @@ static void gen_mcode() 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 { @@ -1506,16 +1443,7 @@ static void gen_mcode() } 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; @@ -1780,6 +1708,7 @@ static void gen_mcode() M_CMPULT(s2, REG_ITMP3, REG_ITMP3);\ M_BEQZ(REG_ITMP3, 0);\ mcode_addxboundrefs(mcodeptr);\ + M_NOP;\ } case ICMD_ARRAYLENGTH: /* ..., arrayref ==> ..., length */ @@ -1798,32 +1727,35 @@ static void gen_mcode() 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; @@ -1834,7 +1766,8 @@ static void gen_mcode() 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; @@ -1846,7 +1779,8 @@ static void gen_mcode() 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; @@ -1858,18 +1792,9 @@ static void gen_mcode() 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; @@ -1880,20 +1805,9 @@ static void gen_mcode() 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; @@ -1904,18 +1818,8 @@ static void gen_mcode() 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; @@ -1927,30 +1831,33 @@ static void gen_mcode() 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 ==> ... */ @@ -1960,8 +1867,9 @@ static void gen_mcode() 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 ==> ... */ @@ -1971,34 +1879,12 @@ static void gen_mcode() 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); @@ -2006,21 +1892,9 @@ static void gen_mcode() 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 ==> ... */ @@ -2030,19 +1904,8 @@ static void gen_mcode() 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; @@ -2207,6 +2070,7 @@ static void gen_mcode() a = dseg_addaddress(asm_handle_exception); M_ALD(REG_ITMP2, REG_PV, a); M_JSR(REG_ITMP2_XPC, REG_ITMP2); + M_NOP; ALIGNCODENOP; break; @@ -2214,14 +2078,17 @@ static void gen_mcode() /* 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: /* ... ==> ... */ @@ -2234,6 +2101,7 @@ static void gen_mcode() } else M_RET(var->regoff); + M_NOP; ALIGNCODENOP; break; @@ -2243,6 +2111,7 @@ static void gen_mcode() 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 ==> ... */ @@ -2251,6 +2120,7 @@ static void gen_mcode() 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 ==> ... */ @@ -2261,16 +2131,11 @@ static void gen_mcode() 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 ==> ... */ @@ -2281,7 +2146,7 @@ static void gen_mcode() 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 { @@ -2291,6 +2156,7 @@ static void gen_mcode() M_BNEZ(REG_ITMP1, 0); } mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + M_NOP; break; case ICMD_IFLE: /* ..., value ==> ... */ @@ -2301,16 +2167,18 @@ static void gen_mcode() 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 ==> ... */ @@ -2321,16 +2189,11 @@ static void gen_mcode() 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 ==> ... */ @@ -2341,16 +2204,18 @@ static void gen_mcode() 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 ==> ... */ @@ -2361,7 +2226,7 @@ static void gen_mcode() 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 { @@ -2371,6 +2236,7 @@ static void gen_mcode() M_BEQZ(REG_ITMP1, 0); } mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + M_NOP; break; case ICMD_IF_LEQ: /* ..., value ==> ... */ @@ -2381,16 +2247,11 @@ static void gen_mcode() 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 ==> ... */ @@ -2401,7 +2262,7 @@ static void gen_mcode() 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 { @@ -2411,6 +2272,7 @@ static void gen_mcode() M_BNEZ(REG_ITMP1, 0); } mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + M_NOP; break; case ICMD_IF_LLE: /* ..., value ==> ... */ @@ -2421,16 +2283,18 @@ static void gen_mcode() 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 ==> ... */ @@ -2441,16 +2305,11 @@ static void gen_mcode() 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 ==> ... */ @@ -2461,16 +2320,18 @@ static void gen_mcode() 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 ==> ... */ @@ -2481,7 +2342,7 @@ static void gen_mcode() 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 { @@ -2491,6 +2352,7 @@ static void gen_mcode() M_BEQZ(REG_ITMP1, 0); } mcode_addreference(BlockPtrOfPC(iptr->op1), mcodeptr); + M_NOP; break; case ICMD_IF_ICMPEQ: /* ..., value, value ==> ... */ @@ -2499,9 +2361,9 @@ static void gen_mcode() 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 ==> ... */ @@ -2510,9 +2372,9 @@ static void gen_mcode() 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 ==> ... */ @@ -2523,6 +2385,7 @@ static void gen_mcode() 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 ==> ... */ @@ -2530,9 +2393,10 @@ static void gen_mcode() 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 ==> ... */ @@ -2540,9 +2404,10 @@ static void gen_mcode() 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 ==> ... */ @@ -2553,8 +2418,10 @@ static void gen_mcode() 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 */ @@ -2759,6 +2626,7 @@ static void gen_mcode() } store_reg_to_var_int(iptr->dst, d); break; +#endif case ICMD_IRETURN: /* ..., retvalue ==> ... */ @@ -2768,10 +2636,9 @@ static void gen_mcode() #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); @@ -2784,10 +2651,9 @@ static void gen_mcode() #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); @@ -2799,10 +2665,9 @@ static void gen_mcode() #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 @@ -2824,11 +2689,6 @@ nowperformreturn: 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) { @@ -2839,25 +2699,25 @@ nowperformreturn: 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; @@ -2874,20 +2734,21 @@ nowperformreturn: 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 */ @@ -2899,9 +2760,10 @@ nowperformreturn: /* 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; @@ -2916,28 +2778,25 @@ nowperformreturn: 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; } @@ -3012,16 +2871,17 @@ gen_method: { 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; @@ -3061,18 +2921,18 @@ gen_method: { 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) { @@ -3121,11 +2981,13 @@ makeactualcall: 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*)); @@ -3133,16 +2995,12 @@ makeactualcall: } 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 @@ -3176,37 +3034,37 @@ makeactualcall: 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 @@ -3221,6 +3079,7 @@ makeactualcall: var_to_reg_int(s1, src, REG_ITMP1); M_BLTZ(s1, 0); mcode_addxcheckarefs(mcodeptr); + M_NOP; break; case ICMD_MULTIANEWARRAY:/* ..., cnt1, [cnt2, ...] ==> ..., arrayref */ @@ -3234,6 +3093,7 @@ makeactualcall: 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) */ @@ -3244,7 +3104,7 @@ makeactualcall: /* a0 = dimension count */ - M_LDA(argintregs[0], REG_ZERO, iptr->op1); + ICONST(argintregs[0], iptr->op1); /* a1 = arraydescriptor */ @@ -3256,17 +3116,9 @@ makeactualcall: 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); @@ -3334,6 +3186,7 @@ makeactualcall: if (xcodeptr != NULL) { M_BR((xcodeptr-mcodeptr)-1); + M_NOP; } else { xcodeptr = mcodeptr; @@ -3345,6 +3198,7 @@ makeactualcall: M_ALD(REG_ITMP3, REG_PV, a); M_JMP(REG_ITMP3); + M_NOP; } } @@ -3368,6 +3222,7 @@ makeactualcall: if (xcodeptr != NULL) { M_BR((xcodeptr-mcodeptr)-1); + M_NOP; } else { xcodeptr = mcodeptr; @@ -3379,6 +3234,7 @@ makeactualcall: M_ALD(REG_ITMP3, REG_PV, a); M_JMP(REG_ITMP3); + M_NOP; } } @@ -3402,6 +3258,7 @@ makeactualcall: if (xcodeptr != NULL) { M_BR((xcodeptr-mcodeptr)-1); + M_NOP; } else { xcodeptr = mcodeptr; @@ -3413,6 +3270,7 @@ makeactualcall: M_ALD(REG_ITMP3, REG_PV, a); M_JMP(REG_ITMP3); + M_NOP; } } @@ -3439,6 +3297,7 @@ makeactualcall: if (xcodeptr != NULL) { M_BR((xcodeptr-mcodeptr)-1); + M_NOP; } else { xcodeptr = mcodeptr; @@ -3450,6 +3309,7 @@ makeactualcall: M_ALD(REG_ITMP3, REG_PV, a); M_JMP(REG_ITMP3); + M_NOP; } } @@ -3474,19 +3334,17 @@ in a locally defined array. 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 ************************************************* @@ -3495,7 +3353,7 @@ This makes sense only for the stub-generation-routines below. *******************************************************************************/ -#define COMPSTUBSIZE 3 +#define COMPSTUBSIZE 4 u1 *createcompilerstub (methodinfo *m) { @@ -3503,11 +3361,14 @@ 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; @@ -3542,29 +3403,30 @@ u1 *createnativestub (functionptr f, methodinfo *m) 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 */ diff --git a/mips/ngen.h b/mips/ngen.h index 9f525be53..89dd712d2 100644 --- a/mips/ngen.h +++ b/mips/ngen.h @@ -30,8 +30,8 @@ #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 */ @@ -60,10 +60,10 @@ int nregdescint[] = { 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 */ @@ -113,13 +113,13 @@ int parentargs_base; /* offset in stackframe for the parameter from the caller*/ #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) @@ -149,20 +149,6 @@ int parentargs_base; /* offset in stackframe for the parameter from the caller*/ #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 */ @@ -225,12 +211,12 @@ int parentargs_base; /* offset in stackframe for the parameter from the caller*/ #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 */ @@ -249,9 +235,7 @@ int parentargs_base; /* offset in stackframe for the parameter from the caller*/ #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 */ @@ -260,12 +244,16 @@ int parentargs_base; /* offset in stackframe for the parameter from the caller*/ #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) */ @@ -305,19 +293,19 @@ int parentargs_base; /* offset in stackframe for the parameter from the caller*/ #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 */ @@ -341,6 +329,26 @@ int parentargs_base; /* offset in stackframe for the parameter from the caller*/ #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