X-Git-Url: http://wien.tomnetworks.com/gitweb/?a=blobdiff_plain;f=src%2Fvm%2Fjit%2Fjit.h;h=9449b95fa710ba6c28549760de18b07a5c451e15;hb=785bd445eb253c9e56c62d38405a619c81407be0;hp=8c128be32b7b34654e3bed8f18c75d2c49b707f1;hpb=a5e50b963d8361674a679587d9d246bf9fc20d98;p=cacao.git diff --git a/src/vm/jit/jit.h b/src/vm/jit/jit.h index 8c128be32..9449b95fa 100644 --- a/src/vm/jit/jit.h +++ b/src/vm/jit/jit.h @@ -1,9 +1,9 @@ -/* jit/jit.h - code generation header +/* src/vm/jit/jit.h - code generation header - Copyright (C) 1996, 1997, 1998, 1999, 2000, 2001, 2002, 2003 - R. Grafl, A. Krall, C. Kruegel, C. Oates, R. Obermaisser, - M. Probst, S. Ring, E. Steiner, C. Thalinger, D. Thuernbeck, - P. Tomsich, J. Wenninger + Copyright (C) 1996-2005, 2006 R. Grafl, A. Krall, C. Kruegel, + C. Oates, R. Obermaisser, M. Platter, M. Probst, S. Ring, + E. Steiner, C. Thalinger, D. Thuernbeck, P. Tomsich, C. Ullrich, + J. Wenninger, Institut f. Computersprachen - TU Wien This file is part of CACAO. @@ -19,17 +19,18 @@ You should have received a copy of the GNU General Public License along with this program; if not, write to the Free Software - Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA - 02111-1307, USA. + Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA + 02110-1301, USA. - Contact: cacao@complang.tuwien.ac.at + Contact: cacao@cacaojvm.org Authors: Andreas Krall Reinhard Grafl Changes: Christian Thalinger + Edwin Steiner - $Id: jit.h 1494 2004-11-12 13:34:26Z twisti $ + $Id: jit.h 5210 2006-08-07 11:10:01Z twisti $ */ @@ -37,45 +38,129 @@ #ifndef _JIT_H #define _JIT_H -#include "global.h" -#include "builtin.h" -#include "typeinfo.h" -#include "jit/codegen.inc.h" -#include "toolbox/chain.h" - - -/**************************** resolve typedef-cycles **************************/ +/* forward typedefs ***********************************************************/ +typedef struct jitdata jitdata; typedef struct stackelement stackelement; typedef stackelement *stackptr; typedef struct basicblock basicblock; +typedef struct branchref branchref; typedef struct instruction instruction; -typedef struct subroutineinfo subroutineinfo; +typedef struct new_instruction new_instruction; +typedef struct insinfo_inline insinfo_inline; -/************************** stack element structure ***************************/ +#include "config.h" +#include "vm/types.h" + +#include "toolbox/chain.h" +#include "vm/global.h" +#include "vm/method.h" +#include "vm/references.h" +#include "vm/resolve.h" +#include "vm/statistics.h" +#include "vm/jit/codegen-common.h" +#include "vm/jit/reg.h" +#include "vm/jit/stacktrace.h" + +#if defined(ENABLE_INLINING) +# include "vm/jit/inline/inline.h" +#endif -/* slot types */ +#if defined(ENABLE_LOOP) +# include "vm/jit/loop/loop.h" +#endif -/* Unified these with longer names. Maybe someday use only - * one set of names? -Edwin - */ -/*#define TYPE_INT 0*/ /* the stack slot types must numbered in the */ -#define TYPE_LNG TYPE_LONG /*1*/ /* same order as the ICMD_Ixxx to ICMD_Axxx */ -#define TYPE_FLT TYPE_FLOAT /*2*/ /* instructions (LOAD and STORE) */ -#define TYPE_DBL TYPE_DOUBLE /*3*/ /* integer, long, float, double, address */ -#define TYPE_ADR TYPE_ADDRESS /*4*/ +#include "vm/jit/verify/typeinfo.h" + + +/* common jit/codegen macros **************************************************/ + +#if defined(ENABLE_STATISTICS) +# define COUNT(x) (x)++ +# define COUNT_SPILLS count_spills++ +#else +# define COUNT(x) /* nothing */ +# define COUNT_SPILLS /* nothing */ +#endif + + +/* jitdata ********************************************************************/ + +struct jitdata { + methodinfo *m; /* methodinfo of the method compiled */ + codeinfo *code; + codegendata *cd; + registerdata *rd; +#if defined(ENABLE_LOOP) + loopdata *ld; +#endif + + u4 flags; /* contains JIT compiler flags */ + bool isleafmethod; /* does method call subroutines */ + + new_instruction *new_instructions; + basicblock *new_basicblocks; + s4 *new_basicblockindex; + stackelement *new_stack; + s4 new_instructioncount; + s4 new_basicblockcount; + s4 new_stackcount; + s4 new_c_debug_nr; + registerdata *new_rd; +}; -#define IS_INT_LNG_TYPE(a) (!((a)&TYPE_FLT)) -#define IS_FLT_DBL_TYPE(a) ((a)&TYPE_FLT) -#define IS_2_WORD_TYPE(a) ((a)&TYPE_LNG) +#define JITDATA_FLAG_PARSE 0x00000001 +#define JITDATA_FLAG_VERIFY 0x00000002 + +#define JITDATA_FLAG_INSTRUMENT 0x00000004 + +#define JITDATA_FLAG_IFCONV 0x00000008 +#define JITDATA_FLAG_REORDER 0x00000010 + +#define JITDATA_FLAG_SHOWINTERMEDIATE 0x20000000 +#define JITDATA_FLAG_SHOWDISASSEMBLE 0x40000000 +#define JITDATA_FLAG_VERBOSECALL 0x80000000 + + +#define JITDATA_HAS_FLAG_PARSE(jd) \ + ((jd)->flags & JITDATA_FLAG_PARSE) + +#define JITDATA_HAS_FLAG_VERIFY(jd) \ + ((jd)->flags & JITDATA_FLAG_VERIFY) + +#define JITDATA_HAS_FLAG_INSTRUMENT(jd) \ + ((jd)->flags & JITDATA_FLAG_INSTRUMENT) + +#define JITDATA_HAS_FLAG_IFCONV(jd) \ + ((jd)->flags & JITDATA_FLAG_IFCONV) + +#define JITDATA_HAS_FLAG_REORDER(jd) \ + ((jd)->flags & JITDATA_FLAG_REORDER) + +#define JITDATA_HAS_FLAG_SHOWINTERMEDIATE(jd) \ + ((jd)->flags & JITDATA_FLAG_SHOWINTERMEDIATE) + +#define JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd) \ + ((jd)->flags & JITDATA_FLAG_SHOWDISASSEMBLE) + +#define JITDATA_HAS_FLAG_VERBOSECALL(jd) \ + ((jd)->flags & JITDATA_FLAG_VERBOSECALL) + + +/************************** stack element structure ***************************/ /* flags */ #define SAVEDVAR 1 /* variable has to survive method invocations */ #define INMEMORY 2 /* variable stored in memory */ #define SAVEDTMP 4 /* temporary variable using a saved register */ +#define TMPARG 8 /* temporary variable using a arg register */ +#define STCOPY 16 /* there is another stackslot alive "below" */ + /* using the same register/memory location */ +#define STKEEP 32 /* to prevent reg_mark_copy to free this */ + /* stackslot */ /* variable kinds */ @@ -89,7 +174,7 @@ typedef struct subroutineinfo subroutineinfo; struct stackelement { stackptr prev; /* pointer to next element towards bottom */ s4 type; /* slot type of stack element */ -#ifdef CACAO_TYPECHECK +#ifdef ENABLE_VERIFIER typeinfo typeinfo; /* info on reference types */ #endif s4 flags; /* flags (SAVED, INMEMORY) */ @@ -101,6 +186,140 @@ struct stackelement { /**************************** instruction structure ***************************/ +/* branch_target_t: used in TABLESWITCH tables */ + +typedef union { + s4 insindex; /* used between parse and stack */ + basicblock *block; /* used from stack analysis onwards */ +} branch_target_t; + +/* lookup_target_t: used in LOOKUPSWITCH tables */ + +typedef struct { + s4 value; /* case value */ + branch_target_t target; /* branch target, see above */ +} lookup_target_t; + +/*** s1 operand ***/ + +typedef union { + stackptr var; + s4 localindex; + s4 argcount; +} s1_operand_t; + +/*** s2 operand ***/ + +typedef union { + stackptr var; + stackptr *args; + classref_or_classinfo c; + unresolved_class *uc; + ptrint constval; /* for PUT*CONST */ + s4 tablelow; /* for TABLESWITCH */ + u4 lookupcount; /* for LOOKUPSWITCH */ +} s2_operand_t; + +/*** s3 operand ***/ + +typedef union { + stackptr var; + ptrint constval; + classref_or_classinfo c; + constant_FMIref *fmiref; + unresolved_method *um; + unresolved_field *uf; + insinfo_inline *inlineinfo; /* for INLINE_START/END */ + s4 tablehigh; /* for TABLESWITCH */ + branch_target_t lookupdefault; /* for LOOKUPSWITCH */ + branch_target_t jsrtarget; /* for JSR */ + struct builtintable_entry *bte; +} s3_operand_t; + +/*** val operand ***/ + +typedef union { + s4 i; + s8 l; + float f; + double d; + void *anyptr; + java_objectheader *stringconst; /* for ACONST with string */ + classref_or_classinfo c; /* for ACONST with class */ +} val_operand_t; + +/*** dst operand ***/ + +typedef union { + stackptr var; + s4 localindex; + basicblock *block; /* valid after stack analysis */ + branch_target_t *table; /* for TABLESWITCH */ + lookup_target_t *lookup; /* for LOOKUPSWITCH */ + s4 insindex; /* used between parse and stack */ + stackptr *dupslots; /* for SWAP, DUP* except DUP */ +} dst_operand_t; + +/*** flags (32 bits) ***/ + +#define INS_FLAG_UNRESOLVED 0x01 /* contains unresolved field/meth/class*/ +#define INS_FLAG_CLASS 0x02 /* for ACONST with class */ +#define INS_FLAG_ARRAY 0x04 /* for CHECKCAST/INSTANCEOF with array */ +#define INS_FLAG_NOCHECK 0x08 + +typedef union { + u4 bits; + struct { /* fields: */ + + union { + u1 type; /* TYPE_* constant for fields */ + u1 argcount; /* XXX does u1 suffice? */ + /* for MULTIANEWARRAY and */ + /* INVOKE* */ + } f; /* XXX these could be made smaller */ + /* only MULTIANEWARRAY needs the argcount */ + + bool predicated:1; + int condition :3; + bool unresolved:1; /* field/method is unresolved */ + bool nocheck :1; /* don't check array access */ + bool branch :1; /* branch to dst.target */ + + int tmpreg1 :5; + int tmpreg2 :5; + int tmpreg3 :5; + + int unused :2; + + } fields; +} flags_operand_t; + +/*** instruction ***/ + +/* The new instruction format for the intermediate representation: */ + +struct new_instruction { + u2 opc; /* opcode */ + u2 line; /* line number */ +#if SIZEOF_VOID_P == 8 + flags_operand_t flags; /* 4 bytes */ +#endif + s1_operand_t s1; /* pointer-size */ + union { + struct { + s2_operand_t s2; /* pointer-size */ + s3_operand_t s3; /* pointer-size */ + } s23; /* XOR */ + val_operand_t val; /* long-size */ + } sx; + dst_operand_t dst; /* pointer-size */ +#if SIZEOF_VOID_P == 4 + flags_operand_t flags; /* 4 bytes */ +#endif +}; + +/* XXX This instruction format will become obsolete. */ + struct instruction { stackptr dst; /* stack index of destination operand stack */ u2 opc; /* opcode of intermediate code command */ @@ -110,47 +329,201 @@ struct instruction { /* and as address for list of targets for */ /* statements */ u2 line; /* line number in source file */ - methodinfo *method; /* needed for inlining. can't be done on */ - /* basic block level, since an inlined */ - /* function doesn't start necessarily start */ - /* a new block */ }; +#define INSTRUCTION_IS_RESOLVED(iptr) \ + (!((ptrint)(iptr)->target & 0x01)) /* XXX target used temporarily as flag */ + +#define INSTRUCTION_IS_UNRESOLVED(iptr) \ + ((ptrint)(iptr)->target & 0x01) /* XXX target used temporarily as flag */ + +#define NEW_INSTRUCTION_GET_FIELDREF(iptr,fref) \ + do { \ + if (iptr->flags.bits & INS_FLAG_UNRESOLVED) \ + fref = iptr->sx.s23.s3.uf->fieldref; \ + else \ + fref = iptr->sx.s23.s3.fmiref; \ + } while (0) + +#define INSTRUCTION_GET_FIELDREF(iptr,fref) \ + do { \ + if (INSTRUCTION_IS_UNRESOLVED(iptr)) \ + fref = ((unresolved_field *) (iptr)->val.a)->fieldref; \ + else \ + fref = ((constant_FMIref *)(iptr)->val.a); \ + } while (0) + +#define NEW_INSTRUCTION_GET_METHODREF(iptr,mref) \ + do { \ + if (iptr->flags.bits & INS_FLAG_UNRESOLVED) \ + mref = iptr->sx.s23.s3.um->methodref; \ + else \ + mref = iptr->sx.s23.s3.fmiref; \ + } while (0) + +#define INSTRUCTION_GET_METHODREF(iptr,mref) \ + do { \ + if (INSTRUCTION_IS_UNRESOLVED(iptr)) \ + mref = ((unresolved_method *) (iptr)->val.a)->methodref; \ + else \ + mref = ((constant_FMIref *)(iptr)->val.a); \ + } while (0) + +#define INSTRUCTION_GET_FIELDDESC(iptr,fd) \ + do { \ + if (INSTRUCTION_IS_UNRESOLVED(iptr)) \ + fd = ((unresolved_field *)(iptr)->val.a)->fieldref->parseddesc.fd; \ + else \ + fd = ((constant_FMIref *)(iptr)->val.a)->parseddesc.fd; \ + } while (0) + +#define NEW_INSTRUCTION_GET_METHODDESC(iptr, md) \ + do { \ + if (iptr->flags.bits & INS_FLAG_UNRESOLVED) \ + md = iptr->sx.s23.s3.um->methodref->parseddesc.md; \ + else \ + md = iptr->sx.s23.s3.fmiref->parseddesc.md; \ + } while (0) + +#define INSTRUCTION_GET_METHODDESC(iptr,md) \ + do { \ + if (INSTRUCTION_IS_UNRESOLVED(iptr)) \ + md = ((unresolved_method *) (iptr)->val.a)->methodref->parseddesc.md; \ + else \ + md = ((constant_FMIref *)(iptr)->val.a)->parseddesc.md; \ + } while (0) + +#define INSTRUCTION_UNRESOLVED_CLASS(iptr) \ + ((unresolved_class *) (iptr)->val.a) + +#define INSTRUCTION_UNRESOLVED_METHOD(iptr) \ + ((unresolved_method *) (iptr)->val.a) + +#define INSTRUCTION_UNRESOLVED_FIELD(iptr) \ + ((unresolved_field *) (iptr)->val.a) + +#define INSTRUCTION_RESOLVED_FMIREF(iptr) \ + ((constant_FMIref *)(iptr)->val.a) + +#define INSTRUCTION_RESOLVED_FIELDINFO(iptr) \ + (INSTRUCTION_RESOLVED_FMIREF(iptr)->p.field) + +#define INSTRUCTION_RESOLVED_METHODINFO(iptr) \ + (INSTRUCTION_RESOLVED_FMIREF(iptr)->p.method) + +#define INSTRUCTION_PUTCONST_TYPE(iptr) \ + ((iptr)[0].op1) + +#define INSTRUCTION_PUTCONST_VALUE_ADR(iptr) \ + ((iptr)[0].val.a) + +#define INSTRUCTION_PUTCONST_FIELDINFO(iptr) \ + ((fieldinfo *)((iptr)[1].val.a)) + +#define INSTRUCTION_PUTCONST_FIELDINFO_PTR(iptr) \ + ((fieldinfo **) &((iptr)[1].val.a)) + +#define INSTRUCTION_PUTCONST_FIELDREF(iptr) \ + ((unresolved_field *)((iptr)[1].target)) + +/* for ICMD_ACONST */ + +#define ICMD_ACONST_IS_CLASS(iptr) \ + ((ptrint)(iptr)->target & 0x02) /* XXX target used temporarily as flag */ + +#define ICMD_ACONST_CLASSREF_OR_CLASSINFO(iptr) \ +(CLASSREF_OR_CLASSINFO((iptr)->val.a)) + +#define ICMD_ACONST_RESOLVED_CLASSINFO(iptr) \ + ((classinfo *) (iptr)->val.a) + +#define ICMD_ACONST_UNRESOLVED_CLASSREF(iptr) \ + ((constant_classref *) (iptr)->val.a) + + +/* additional info structs for special instructions ***************************/ + +/* for ICMD_INLINE_START and ICMD_INLINE_END */ + +struct insinfo_inline { + methodinfo *method; /* the inlined method starting/ending here */ + methodinfo *outer; /* the outer method suspended/resumed here */ + s4 startmpc; /* machine code offset of start of inlining */ + s4 synclocal; /* local index used for synchronization */ + bool synchronize; /* true if synchronization is needed */ +}; -/**************************** basic block structure ***************************/ +/* basicblock *****************************************************************/ -/* flags */ +/* flags */ + +#define BBDELETED -2 +#define BBUNDEF -1 +#define BBREACHED 0 +#define BBFINISHED 1 -#define BBDELETED -2 -#define BBUNDEF -1 -#define BBREACHED 0 -#define BBFINISHED 1 #define BBTYPECHECK_UNDEF 2 #define BBTYPECHECK_REACHED 3 -#define BBTYPE_STD 0 /* standard basic block type */ -#define BBTYPE_EXH 1 /* exception handler basic block type */ -#define BBTYPE_SBR 2 /* subroutine basic block type */ +#define BBTYPE_STD 0 /* standard basic block type */ +#define BBTYPE_EXH 1 /* exception handler basic block type */ +#define BBTYPE_SBR 2 /* subroutine basic block type */ +#define BBFLAG_REPLACEMENT 0x01 /* put a replacement point at the start */ + +/* XXX basicblock wastes quite a lot of memory by having four flag fields */ +/* (flags, bitflags, type and lflags). Probably the last three could be */ +/* combined without loss of efficiency. The first one could be combined with */ +/* the others by using bitfields. */ struct basicblock { - int flags; /* used during stack analysis, init with -1 */ - int type; /* basic block type (std, xhandler, subroutine*/ - instruction *iinstr; /* pointer to intermediate code instructions */ - int icount; /* number of intermediate code instructions */ - int mpc; /* machine code pc at start of block */ - stackptr instack; /* stack at begin of basic block */ - stackptr outstack; /* stack at end of basic block */ - int indepth; /* stack depth at begin of basic block */ - int outdepth; /* stack depth end of basic block */ - int pre_count; /* count of predecessor basic blocks */ - struct branchref *branchrefs; /* list of branches to be patched */ - - basicblock *next; /* used to build a BB list (instead of array) */ - int lflags; /* used during loop copying, init with 0 */ - basicblock *copied_to; /* points to the copy of this basic block */ + s4 debug_nr; /* basic block number */ + s4 flags; /* used during stack analysis, init with -1 */ + s4 bitflags; /* OR of BBFLAG_... constants, init with 0 */ + s4 type; /* basic block type (std, xhandler, subroutine*/ + instruction *iinstr; /* pointer to intermediate code instructions */ + s4 icount; /* number of intermediate code instructions */ + s4 mpc; /* machine code pc at start of block */ + stackptr instack; /* stack at begin of basic block */ + stackptr outstack; /* stack at end of basic block */ + s4 indepth; /* stack depth at begin of basic block */ + s4 outdepth; /* stack depth end of basic block */ + + s4 predecessorcount; + s4 successorcount; + basicblock **predecessors; /* array of predecessor basic blocks */ + basicblock **successors; /* array of successor basic blocks */ + + branchref *branchrefs; /* list of branches to be patched */ + + basicblock *next; /* used to build a BB list (instead of array) */ + s4 lflags; /* used during loop copying, init with 0 */ + basicblock *copied_to; /* points to the copy of this basic block */ /* when loop nodes are copied */ - int debug_nr; + stackptr stack; /* start of stack array for this block */ + /* (see doc/stack.txt) */ + methodinfo *method; /* method this block belongs to */ +}; + + +/* Macro for initializing newly allocated basic block's. It does not + need to zero fields, as we zero out the whole basic block array. */ + +#define BASICBLOCK_INIT(bptr,m) \ + do { \ + bptr->mpc = -1; \ + bptr->flags = -1; \ + bptr->type = BBTYPE_STD; \ + bptr->method = (m); \ + bptr->debug_nr = (m)->c_debug_nr++; \ + } while (0) + + +/* branchref *****************************************************************/ + +struct branchref { + s4 branchpos; /* patching position in code segment */ + branchref *next; /* next element in branchref list */ }; @@ -159,6 +532,7 @@ struct basicblock { #define ACONST_LOAD 0 /* ACONST_NULL or LDC instruction */ #define ACONST_BUILTIN 1 /* constant argument for a builtin function call */ + /********** JavaVM operation codes (sorted) and instruction lengths ***********/ extern char *icmd_names[256]; @@ -172,12 +546,13 @@ extern int jcommandsize[256]; #define ICMD_ACONST 1 /* val.a = constant */ #define JAVA_ICONST_M1 2 -#define ICMD_NULLCHECKPOP 2 +#define ICMD_CHECKNULL 2 #define JAVA_ICONST_0 3 #define ICMD_ICONST 3 /* val.i = constant */ #define JAVA_ICONST_1 4 +#define ICMD_CHECKNULL_POP 4 #define JAVA_ICONST_2 5 #define ICMD_IDIVPOW2 5 /* val.i = constant */ @@ -201,31 +576,24 @@ extern int jcommandsize[256]; #define JAVA_FCONST_1 12 #define JAVA_FCONST_2 13 -#define ICMD_ELSE_ICONST 13 #define JAVA_DCONST_0 14 #define ICMD_DCONST 14 /* val.d = constant */ #define JAVA_DCONST_1 15 -#define ICMD_IFEQ_ICONST 15 #define JAVA_BIPUSH 16 -#define ICMD_IFNE_ICONST 16 #define JAVA_SIPUSH 17 -#define ICMD_IFLT_ICONST 17 #define JAVA_LDC1 18 -#define ICMD_IFGE_ICONST 18 #define JAVA_LDC2 19 -#define ICMD_IFGT_ICONST 19 #define JAVA_LDC2W 20 -#define ICMD_IFLE_ICONST 20 /* order of LOAD instructions must be */ - /* equal to order of TYPE_XXX defines */ + /* equal to order of TYPE_* defines */ #define JAVA_ILOAD 21 #define ICMD_ILOAD 21 /* op1 = local variable */ @@ -326,7 +694,7 @@ extern int jcommandsize[256]; #define ICMD_SALOAD 53 /* order of STORE instructions must be*/ - /* equal to order of TYPE_XXX defines */ + /* equal to order of TYPE_* defines */ #define JAVA_ISTORE 54 #define ICMD_ISTORE 54 /* op1 = local variable */ @@ -715,7 +1083,7 @@ extern int jcommandsize[256]; #define JAVA_INVOKEINTERFACE 185 #define ICMD_INVOKEINTERFACE 185 /* val.a = method info pointer */ -#define ICMD_CHECKASIZE 186 /* */ +/* UNDEF186 */ #define JAVA_NEW 187 #define ICMD_NEW 187 /* op1 = 1, val.a = class pointer */ @@ -761,38 +1129,58 @@ extern int jcommandsize[256]; #define JAVA_BREAKPOINT 202 -#define ICMD_CHECKEXCEPTION 203 /* check for an exception */ +/* UNDEF203 */ #define ICMD_IASTORECONST 204 - #define ICMD_LASTORECONST 205 - #define ICMD_FASTORECONST 206 - #define ICMD_DASTORECONST 207 - #define ICMD_AASTORECONST 208 - #define ICMD_BASTORECONST 209 - #define ICMD_CASTORECONST 210 - #define ICMD_SASTORECONST 211 -#define ICMD_BUILTIN3 253 /* internal opcode */ -#define ICMD_BUILTIN2 254 /* internal opcode */ -#define ICMD_BUILTIN1 255 /* internal opcode */ -#define ICMD_READONLY_ARG 1024 /* used for inlining, opcodes 1024-1028 are used */ -#define ICMD_CLEAR_ARGREN 1029 /* indicates the start of a new inlined method argument renaming must be reset */ +#define ICMD_PUTSTATICCONST 212 +#define ICMD_PUTFIELDCONST 213 +#define ICMD_IMULPOW2 214 +#define ICMD_LMULPOW2 215 -/******************* description of JavaVM instructions ***********************/ +#define ICMD_IF_FCMPEQ 216 +#define ICMD_IF_FCMPNE 217 + +#define ICMD_IF_FCMPL_LT 218 +#define ICMD_IF_FCMPL_GE 219 +#define ICMD_IF_FCMPL_GT 220 +#define ICMD_IF_FCMPL_LE 221 + +#define ICMD_IF_FCMPG_LT 222 +#define ICMD_IF_FCMPG_GE 223 +#define ICMD_IF_FCMPG_GT 224 +#define ICMD_IF_FCMPG_LE 225 + +#define ICMD_IF_DCMPEQ 226 +#define ICMD_IF_DCMPNE 227 + +#define ICMD_IF_DCMPL_LT 228 +#define ICMD_IF_DCMPL_GE 229 +#define ICMD_IF_DCMPL_GT 230 +#define ICMD_IF_DCMPL_LE 231 -#if defined(USEBUILTINTABLE) +#define ICMD_IF_DCMPG_LT 232 +#define ICMD_IF_DCMPG_GE 233 +#define ICMD_IF_DCMPG_GT 234 +#define ICMD_IF_DCMPG_LE 235 -builtin_descriptor *find_builtin(int opcode); +#define ICMD_INLINE_START 251 /* instruction before inlined method */ +#define ICMD_INLINE_END 252 /* instruction after inlined method */ +#define ICMD_INLINE_GOTO 253 /* jump to caller of inlined method */ + +#define ICMD_BUILTIN 255 /* internal opcode */ + + +/******************* description of JavaVM instructions ***********************/ -#endif /* USEBUILTINTABLE */ /***************************** register types *********************************/ @@ -815,26 +1203,37 @@ builtin_descriptor *find_builtin(int opcode); extern int stackreq[256]; -#if defined(__I386__) -extern bool method_uses_ecx; -extern bool method_uses_edx; -#endif +/* function prototypes ********************************************************/ +/* compiler initialisation */ +void jit_init(void); -/* function prototypes */ +/* compiler finalisation */ +void jit_close(void); -functionptr jit_compile(methodinfo *m); /* compile a method with jit compiler */ +/* compile a method with jit compiler */ +u1 *jit_compile(methodinfo *m); +u1 *jit_recompile(methodinfo *m); -void jit_init(); /* compiler initialisation */ -void jit_close(); /* compiler finalisation */ +/* patch the method entrypoint */ +u1 *jit_asm_compile(methodinfo *m, u1 *mptr, u1 *sp, u1 *ra); -void compile_all_class_methods(classinfo *c); +s4 jit_complement_condition(s4 opcode); -u1 *createcompilerstub(methodinfo *m); -u1 *createnativestub(functionptr f, methodinfo *m); +/* machine dependent functions */ +#if defined(ENABLE_JIT) +void md_init(void); -void removecompilerstub(u1 *stub); -void removenativestub(u1 *stub); +u1 *md_get_method_patch_address(u1 *ra, stackframeinfo *sfi, u1 *mptr); + +void md_cacheflush(u1 *addr, s4 nbytes); +void md_icacheflush(u1 *addr, s4 nbytes); +void md_dcacheflush(u1 *addr, s4 nbytes); +#endif + +#if defined(ENABLE_INTRP) +void intrp_md_init(void); +#endif #endif /* _JIT_H */ @@ -850,4 +1249,5 @@ void removenativestub(u1 *stub); * c-basic-offset: 4 * tab-width: 4 * End: + * vim:noexpandtab:sw=4:ts=4: */