CACAO
jit.hpp
Go to the documentation of this file.
1 /* src/vm/jit/jit.hpp - Just-In-Time compiler
2 
3  Copyright (C) 1996-2013
4  CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
5 
6  This file is part of CACAO.
7 
8  This program is free software; you can redistribute it and/or
9  modify it under the terms of the GNU General Public License as
10  published by the Free Software Foundation; either version 2, or (at
11  your option) any later version.
12 
13  This program is distributed in the hope that it will be useful, but
14  WITHOUT ANY WARRANTY; without even the implied warranty of
15  MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the GNU
16  General Public License for more details.
17 
18  You should have received a copy of the GNU General Public License
19  along with this program; if not, write to the Free Software
20  Foundation, Inc., 51 Franklin Street, Fifth Floor, Boston, MA
21  02110-1301, USA.
22 
23 */
24 
25 
26 #ifndef JIT_HPP_
27 #define JIT_HPP_ 1
28 
29 #include <stddef.h> // for NULL
30 #include "arch.hpp" // for JIT_COMPILER_VIA_SIGNAL
31 #include "config.h" // for ENABLE_SSA, ENABLE_INLINING, etc
32 #include "vm/jit/ir/icmd.hpp"
33 #include "vm/jit/optimizing/lsra.hpp" // for lsradata
34 #include "vm/jit/reg.hpp" // for varinfo
35 #include "vm/jit/stack.hpp" // for PREALLOC
36 #include "vm/references.hpp" // for classref_or_classinfo
37 #include "vm/statistics.hpp"
38 #include "vm/types.hpp" // for s4, u1, u4
39 
40 #if defined(ENABLE_INLINING)
41 # include "vm/jit/inline/inline.hpp"
42 #endif
43 
44 #if defined(ENABLE_LOOP)
45 # include "vm/jit/loop/loop.hpp"
46 #endif
47 
48 #if defined(ENABLE_SSA)
50 #endif
51 
52 #if defined(ENABLE_LSRA)
53 # include "vm/jit/allocator/lsra.hpp"
54 #endif
55 
56 struct basicblock;
57 struct branchref;
58 struct codegendata;
59 struct codeinfo;
60 struct exception_entry;
61 struct insinfo_inline;
62 struct instruction;
63 struct interface_info;
64 struct jitdata;
65 struct methodinfo;
66 struct registerdata;
67 struct stackelement_t;
68 
69 
70 STAT_DECLARE_VAR(int,count_spills_write_ila,0)
71 STAT_DECLARE_VAR(int,count_spills_write_flt,0)
72 STAT_DECLARE_VAR(int,count_spills_write_dbl,0)
73 
74 STAT_DECLARE_VAR(int,count_spills_read_ila,0)
75 STAT_DECLARE_VAR(int,count_spills_read_flt,0)
76 STAT_DECLARE_VAR(int,count_spills_read_dbl,0)
77 
78 
79 /* common jit/codegen macros **************************************************/
80 
81 #if defined(ENABLE_STATISTICS)
82 //# define COUNT(x) (x)++
83 # define COUNT_SPILLS /* use COUNT_(READ|WRITE)_SPILLS instead */
84 # define COUNT_READ_SPILLS(var) \
85  switch(var->type) { \
86  case TYPE_FLT: count_spills_read_flt++; break; \
87  case TYPE_DBL: count_spills_read_dbl++; break; \
88  default: count_spills_read_ila++; break; \
89  switch(var->type) { \
90  case TYPE_FLT: count_spills_read_flt++; break; \
91  case TYPE_DBL: count_spills_read_dbl++; break; \
92  default: count_spills_read_ila++; break; \
93  }
94 
95 # define COUNT_WRITE_SPILLS(var) \
96  switch(var->type) { \
97  case TYPE_FLT: count_spills_write_flt++; break; \
98  case TYPE_DBL: count_spills_write_dbl++; break; \
99  default: count_spills_write_ila++; break; \
100  switch(var->type) { \
101  case TYPE_FLT: count_spills_write_flt++; break; \
102  case TYPE_DBL: count_spills_write_dbl++; break; \
103  default: count_spills_write_ila++; break; \
104  }
105 
106 #else
107 # define COUNT(x) /* nothing */
108 # define COUNT_SPILLS /* nothing */
109 # define COUNT_READ_SPILLS(x) /* nothing */
110 # define COUNT_WRITE_SPILLS(x) /* nothing */
111 #endif
112 
114 
118 };
119 
120 
121 /* jitdata ********************************************************************/
122 
123 // Defined by OpenJDK 7
124 #undef UNUSED
125 
126 struct jitdata {
127  methodinfo *m; /* methodinfo of the method compiled */
131 #if defined(ENABLE_LOOP)
132  MethodLoopData *ld;
133 #endif
134 #if defined(ENABLE_SSA) || defined(ENABLE_LSRA)
135  lsradata *ls;
136 #endif
137 
138  u4 flags; /* contains JIT compiler flags */
139 
140  instruction *instructions; /* ICMDs, valid between parse and stack */
141  basicblock *basicblocks; /* start of basic block list */
142  stackelement_t *stack; /* XXX should become stack.c internal */
143  s4 instructioncount;/* XXX remove this? */
144  s4 basicblockcount; /* number of basic blocks */
145  s4 stackcount; /* number of stackelements to allocate */
146  /* (passed from parse to stack) */
147 
148  varinfo *var; /* array of variables */
149  s4 vartop; /* next free index in var array */
150 
151  s4 varcount; /* number of variables in var array */
152  s4 localcount; /* number of locals at start of var ar. */
153  s4 *local_map; /* map for renaming (de-coallescing) */
154  /* locals and keeping the coalescing info for simplereg. */
155  /* local_map[javaindex * 5 + type] = */
156  /* >= 0......index into jd->var, or */
157  /* UNUSED....this (javaindex,type) pair is not used */
158 
159  s4 *reverselocalmap; /* map from CACAO varindex to javaindex */
160  /* (varindex must be < localcount) */
161 
162  s4 maxlocals; /* max. number of javalocals */
163 
164  interface_info *interface_map; /* interface variables (for simplereg) */
165  s4 maxinterfaces; /* max. number of interface variables */
166 
167  s4 exceptiontablelength; /* exceptiontable length */
168  exception_entry *exceptiontable; /* the exceptiontable */
169 
170  basicblock *returnblock; /* block containing the *RETURN */
171  /* (only use if returncount==1) */
172  s4 returncount; /* number of return instructions */
173  bool branchtoentry; /* true if first block is a target */
174  bool branchtoend; /* true if end dummy is a target */
175 
176  enum {
177  UNUSED = -1
178  };
179 };
180 
181 #define FOR_EACH_BASICBLOCK(jd, it) \
182  for ((it) = (jd)->basicblocks; (it) != NULL; (it) = (it)->next)
183 
184 #define JITDATA_FLAG_PARSE 0x00000001
185 #define JITDATA_FLAG_VERIFY 0x00000002
186 
187 #define JITDATA_FLAG_INSTRUMENT 0x00000004
188 
189 #define JITDATA_FLAG_IFCONV 0x00000008
190 #define JITDATA_FLAG_REORDER 0x00000010
191 #define JITDATA_FLAG_INLINE 0x00000020
192 
193 /* Indicates that a method should be instrumented with countdown traps. */
194 #define JITDATA_FLAG_COUNTDOWN 0x00000100
195 
196 /* Indicates that deoptimization information has to be generated. */
197 #define JITDATA_FLAG_DEOPTIMIZE 0x00000200
198 
199 #define JITDATA_FLAG_SHOWINTERMEDIATE 0x20000000
200 #define JITDATA_FLAG_SHOWDISASSEMBLE 0x40000000
201 #define JITDATA_FLAG_VERBOSECALL 0x80000000
202 
203 
204 #define JITDATA_HAS_FLAG_PARSE(jd) \
205  ((jd)->flags & JITDATA_FLAG_PARSE)
206 
207 #define JITDATA_HAS_FLAG_VERIFY(jd) \
208  ((jd)->flags & JITDATA_FLAG_VERIFY)
209 
210 #define JITDATA_HAS_FLAG_INSTRUMENT(jd) \
211  ((jd)->flags & JITDATA_FLAG_INSTRUMENT)
212 
213 #define JITDATA_HAS_FLAG_IFCONV(jd) \
214  ((jd)->flags & JITDATA_FLAG_IFCONV)
215 
216 #define JITDATA_HAS_FLAG_REORDER(jd) \
217  ((jd)->flags & JITDATA_FLAG_REORDER)
218 
219 #define JITDATA_HAS_FLAG_INLINE(jd) \
220  ((jd)->flags & JITDATA_FLAG_INLINE)
221 
222 #define JITDATA_HAS_FLAG_COUNTDOWN(jd) \
223  ((jd)->flags & JITDATA_FLAG_COUNTDOWN)
224 
225 #define JITDATA_HAS_FLAG_DEOPTIMIZE(jd) \
226  ((jd)->flags & JITDATA_FLAG_DEOPTIMIZE)
227 
228 #define JITDATA_HAS_FLAG_SHOWINTERMEDIATE(jd) \
229  ((jd)->flags & JITDATA_FLAG_SHOWINTERMEDIATE)
230 
231 #define JITDATA_HAS_FLAG_SHOWDISASSEMBLE(jd) \
232  ((jd)->flags & JITDATA_FLAG_SHOWDISASSEMBLE)
233 
234 #define JITDATA_HAS_FLAG_VERBOSECALL(jd) \
235  ((jd)->flags & JITDATA_FLAG_VERBOSECALL)
236 
237 
238 /* exception_entry ************************************************************/
239 
244  classref_or_classinfo catchtype; /* catchtype of exc. (NULL == catchall) */
245  exception_entry *next; /* next in list of exceptions when */
246  /* loops are copied */
247  exception_entry *down; /* next exception_entry */
248 };
249 
250 
251 /* macros for accessing variables *********************************************
252 
253  Use VAROP for s1, s2, s3 and dst operands (eg. VAROP(iptr->s1)),
254  use VAR if you have the variable index (eg. VAR(iptr->sx.s23.s2.args[0])).
255 
256 ******************************************************************************/
257 
258 #define VAROP(v) (jd->var + (v).varindex)
259 #define VAR(i) (jd->var + (i))
260 
261 static inline bool var_is_local(const jitdata *jd, s4 i) {
262  return (i < jd->localcount);
263 }
264 
265 static inline bool var_is_prealloc(const jitdata *jd, s4 i) {
266  return ((i >= jd->localcount) && (jd->var[i].flags & PREALLOC));
267 }
268 
269 static inline bool var_is_inout(const jitdata *jd, s4 i) {
270  const varinfo *v = jd->var + i;
271  return (
272  (i >= jd->localcount) && (
273  (!(v->flags & PREALLOC) && (v->flags & INOUT)) ||
274  /* special case of TYPE_RET, used with JSR */
275  ((v->flags & PREALLOC) && (v->flags & INOUT) && (v->type == TYPE_RET))
276  )
277  );
278 }
279 
280 static inline bool var_is_temp(const jitdata *jd, s4 i) {
281  const varinfo *v = jd->var + i;
282  return ((i >= jd->localcount) && !(v->flags & PREALLOC) && !(v->flags & INOUT));
283 }
284 
285 static inline bool var_is_saved(const jitdata *jd, s4 i) {
286  return (jd->var[i].flags & SAVEDVAR);
287 }
288 
289 
290 /* basicblock *****************************************************************/
291 
292 #define BBFLAG_REPLACEMENT 0x01 /* put a replacement point at the start */
293 
294 /* XXX basicblock wastes quite a lot of memory by having four flag fields */
295 /* (flags, bitflags, type and lflags). Probably the last three could be */
296 /* combined without loss of efficiency. The first one could be combined with */
297 /* the others by using bitfields. */
298 
299 struct basicblock {
300  /**
301  * State of block during stack analysis.
302  */
303  enum State {
304  DELETED = -2,
305  UNDEF = -1,
306  REACHED = 0,
307  FINISHED = 1,
308 
311  };
312 
313  enum Type {
314  TYPE_STD = 0, // standard basic block type
315  TYPE_EXH = 1, // exception handler basic block type
316  TYPE_SBR = 2 // subroutine basic block type
317  };
318 
319  s4 nr; /* basic block number */
320  State state; /* used during stack analysis, init with -1 */
321  s4 bitflags; /* OR of BBFLAG_... constants, init with 0 */
322  Type type; /* basic block type (std, xhandler, subroutine*/
323  s4 lflags; /* used during loop copying, init with 0 */
324 
325  s4 icount; /* number of intermediate code instructions */
326  instruction *iinstr; /* pointer to intermediate code instructions */
327 
328  varinfo *inlocals; /* copy of locals on block entry */
329  s4 *javalocals; /* map from java locals to cacao variables[+] */
330  s4 *invars; /* array of in-variables at begin of block */
331  s4 *outvars; /* array of out-variables at end of block */
332  s4 indepth; /* stack depth at begin of basic block */
333  s4 outdepth; /* stack depth end of basic block */
334  s4 varstart; /* index of first non-invar block variable */
335  s4 varcount; /* number of non-invar block variables */
336 
339  basicblock **predecessors; /* array of predecessor basic blocks */
340  basicblock **successors; /* array of successor basic blocks */
341 
342  branchref *branchrefs; /* list of branches to be patched */
343 
344  basicblock *next; /* used to build a BB list (instead of array) */
345  basicblock *copied_to; /* points to the copy of this basic block */
346  /* when loop nodes are copied */
347  basicblock *original; /* block of which this block is a clone */
348  /* NULL for the original block itself */
349  methodinfo *method; /* method this block belongs to */
350  insinfo_inline *inlineinfo; /* inlineinfo for the start of this block */
351 
352  s4 mpc; /* machine code pc at start of block */
353 
354 #if defined(ENABLE_LOOP)
355  BasicblockLoopData *ld;
356 #endif
357 
358  /* TODO: those fields are probably usefull for other passes as well. */
359 
360 #if defined(ENABLE_SSA)
361  basicblock *idom; /* Immediate dominator, parent in dominator tree */
362  basicblock **domsuccessors;/* Children in dominator tree */
363  s4 domsuccessorcount;
364 
365  basicblock **domfrontier; /* Dominance frontier */
366  s4 domfrontiercount;
367 
368  basicblock **exhandlers; /* Exception handlers for this block */
369  s4 exhandlercount;
370  basicblock **expredecessors; /* Blocks this block is exception handler for */
371  s4 expredecessorcount;
372  s4 exouts; /* Number of exceptional exits */
373 
374  instruction *phis; /* Phi functions */
375  s4 phicount; /* Number of phi functions */
376 
377  void *vp; /* Freely used by different passes */
378 #endif
379 };
380 
381 #define FOR_EACH_SUCCESSOR(bptr, it) \
382  for ((it) = (bptr)->successors; (it) != (bptr)->successors + (bptr)->successorcount; ++(it))
383 
384 #define FOR_EACH_PREDECESSOR(bptr, it) \
385  for ( \
386  (it) = (bptr)->predecessors; \
387  (it) != (bptr)->predecessors + ((bptr)->predecessorcount < 0 ? 0 : (bptr)->predecessorcount); \
388  ++(it) \
389  )
390 
391 #define FOR_EACH_INSTRUCTION(bptr, it) \
392  for ((it) = (bptr)->iinstr; (it) != (bptr)->iinstr + (bptr)->icount; ++(it))
393 
394 #define FOR_EACH_INSTRUCTION_REV(bptr, it) \
395  for ((it) = (bptr)->iinstr + (bptr)->icount - 1; (it) != (bptr)->iinstr - 1; --(it))
396 
397 #if defined(ENABLE_SSA)
398 
399 #define FOR_EACH_EXHANDLER(bptr, it) \
400  for ((it) = (bptr)->exhandlers; (it) != (bptr)->exhandlers + (bptr)->exhandlercount; ++(it))
401 
402 #define FOR_EACH_EXPREDECESSOR(bptr, it) \
403  for ((it) = (bptr)->expredecessors; (it) != (bptr)->expredecessors + (bptr)->expredecessorcount; ++(it))
404 
405 #endif
406 
407 /* [+]...the javalocals array: This array is indexed by the javaindex (the */
408 /* local variable index ocurring in the original bytecode). An element */
409 /* javalocals[javaindex] encodes where to find the contents of the */
410 /* original variable at this point in the program. */
411 /* There are three cases for javalocals[javaindex]: */
412 /* >= 0.......it's an index into the jd->var array, where the */
413 /* CACAO variable corresponding to the original local */
414 /* can be found. */
415 /* UNUSED.....the original variable is not live at this point */
416 /* < UNUSED...the original variable contains a returnAddress at */
417 /* this point. The number of the block to return to can */
418 /* be calculated using RETADDR_FROM_JAVALOCAL: */
419 /* */
420 /* javalocals[javaindex] == JAVALOCAL_FROM_RETADDR(nr) */
421 /* RETADDR_FROM_JAVALOCAL(javalocals[javaindex]) == nr */
422 
423 #define JAVALOCAL_FROM_RETADDR(nr) (jitdata::UNUSED - (1 + (nr)))
424 #define RETADDR_FROM_JAVALOCAL(jl) (jitdata::UNUSED - (1 + (jl)))
425 
426 
427 /* Macro for initializing newly allocated basic block's. It does not
428  need to zero fields, as we zero out the whole basic block array. */
429 
430 #define BASICBLOCK_INIT(bptr,m) \
431  do { \
432  bptr->mpc = -1; \
433  bptr->state = basicblock::UNDEF; \
434  bptr->type = basicblock::TYPE_STD; \
435  bptr->method = (m); \
436  } while (0)
437 
438 static inline bool basicblock_reached(const basicblock *bptr) {
439  return (bptr->state >= basicblock::REACHED);
440 }
441 
442 
443 
444 /***************************** register types *********************************/
445 
446 #define REG_RES 0 /* reserved register for OS or code generator */
447 #define REG_RET 1 /* return value register */
448 #define REG_EXC 2 /* exception value register */
449 #define REG_SAV 3 /* (callee) saved register */
450 #define REG_TMP 4 /* scratch temporary register (caller saved) */
451 #define REG_ARG 5 /* argument register (caller saved) */
452 
453 #define REG_END -1 /* last entry in tables */
454 
455 #define PARAMMODE_NUMBERED 0
456 #define PARAMMODE_STUFFED 1
457 
458 
459 /* function prototypes ********************************************************/
460 
461 /* compiler initialisation */
462 void jit_init(void);
463 
464 /* compiler finalisation */
465 void jit_close(void);
466 
467 /* create a new jitdata */
469 
471 
472 /* compile a method with jit compiler */
476 
480 
481 /* patch the method entrypoint */
482 #if !defined(JIT_COMPILER_VIA_SIGNAL)
483 void *jit_asm_compile(methodinfo *m, void* mptr, void* sp, void* ra);
484 #endif
485 void *jit_compile_handle(methodinfo *m, void *pv, void *ra, void *mptr);
486 
488 
490 #if !defined(NDEBUG)
492 #endif
493 
494 
495 /* machine dependent functions ************************************************/
496 
497 #if defined(ENABLE_JIT)
498 void md_init(void);
499 #endif
500 
501 #if defined(ENABLE_INTRP)
502 void intrp_md_init(void);
503 #endif
504 
505 void *md_jit_method_patch_address(void *pv, void *ra, void *mptr);
506 
507 #endif // JIT_HPP_
508 
509 
510 /*
511  * These are local overrides for various environment variables in Emacs.
512  * Please do not remove this and leave it at the end of the file, where
513  * Emacs will automagically detect them.
514  * ---------------------------------------------------------------------
515  * Local variables:
516  * mode: c++
517  * indent-tabs-mode: t
518  * c-basic-offset: 4
519  * tab-width: 4
520  * End:
521  * vim:noexpandtab:sw=4:ts=4:
522  */
State
State of block during stack analysis.
Definition: jit.hpp:303
#define pv
Definition: md-asm.hpp:65
#define mptr
Definition: md-asm.hpp:66
s4 exceptiontablelength
Definition: jit.hpp:167
codeinfo * jit_get_current_code(methodinfo *m)
Definition: jit.cpp:992
basicblock * basicblocks
Definition: jit.hpp:141
Definition: jit.hpp:126
#define ra
Definition: md-asm.hpp:62
Definition: stack.hpp:46
basicblock * returnblock
Definition: jit.hpp:170
s4 localcount
Definition: jit.hpp:152
exception_entry * exceptiontable
Definition: jit.hpp:168
void * jit_compile_handle(methodinfo *m, void *pv, void *ra, void *mptr)
Definition: jit.cpp:1088
s4 bitflags
Definition: jit.hpp:321
State state
Definition: jit.hpp:320
s4 maxlocals
Definition: jit.hpp:162
s4 * invars
Definition: jit.hpp:330
basicblock * next
Definition: jit.hpp:344
void jit_jitdata_init_for_recompilation(jitdata *jd)
Definition: jit.cpp:442
static bool var_is_saved(const jitdata *jd, s4 i)
Definition: jit.hpp:285
codeinfo * code
Definition: jit.hpp:128
insinfo_inline * inlineinfo
Definition: jit.hpp:350
s4 outdepth
Definition: jit.hpp:333
varinfo * var
Definition: jit.hpp:148
s4 successorcount
Definition: jit.hpp:338
s4 mpc
Definition: jit.hpp:352
codegendata * cd
Definition: jit.hpp:129
u4 flags
Definition: jit.hpp:138
s4 vartop
Definition: jit.hpp:149
u1 * jit_compile(methodinfo *m)
Definition: jit.cpp:274
uint8_t u1
Definition: types.hpp:40
Type type
Definition: reg.hpp:44
varinfo * inlocals
Definition: jit.hpp:328
branchref * branchrefs
Definition: jit.hpp:342
s4 varcount
Definition: jit.hpp:335
instruction * iinstr
Definition: jit.hpp:326
Definition: reg.hpp:43
s4 icount
Definition: jit.hpp:325
void jit_request_optimization(methodinfo *m)
Definition: jit.cpp:967
static bool var_is_local(const jitdata *jd, s4 i)
Definition: jit.hpp:261
stackelement_t * stack
Definition: jit.hpp:142
void intrp_md_init(void)
Definition: md.c:58
s4 varcount
Definition: jit.hpp:151
s4 * javalocals
Definition: jit.hpp:329
void jit_renumber_basicblocks(jitdata *jd)
Definition: jit.cpp:1181
void jit_invalidate_code(methodinfo *m)
Definition: jit.cpp:934
struct MethodLoopData MethodLoopData
Definition: loop.hpp:29
basicblock ** predecessors
Definition: jit.hpp:339
jitdata * jit_jitdata_new(methodinfo *m)
Definition: jit.cpp:217
basicblock * start
Definition: jit.hpp:241
This file contains the statistics framework.
s4 predecessorcount
Definition: jit.hpp:337
basicblock * handler
Definition: jit.hpp:243
s4 returncount
Definition: jit.hpp:172
exception_entry * next
Definition: jit.hpp:245
u1 * jit_recompile(methodinfo *m)
Definition: jit.cpp:477
classref_or_classinfo catchtype
Definition: jit.hpp:244
s4 indepth
Definition: jit.hpp:332
void jit_init(void)
Definition: jit.cpp:151
s4 * local_map
Definition: jit.hpp:153
void jit_close(void)
Definition: jit.cpp:197
MIIterator i
bool branchtoentry
Definition: jit.hpp:173
basicblock * copied_to
Definition: jit.hpp:345
int32_t s4
Definition: types.hpp:45
s4 lflags
Definition: jit.hpp:323
ICMD
Definition: icmd.hpp:37
registerdata * rd
Definition: jit.hpp:130
s4 * outvars
Definition: jit.hpp:331
s4 instructioncount
Definition: jit.hpp:143
exception_entry * down
Definition: jit.hpp:247
s4 varstart
Definition: jit.hpp:334
void * md_jit_method_patch_address(void *pv, void *ra, void *mptr)
Definition: md.cpp:83
uint32_t u4
Definition: types.hpp:46
struct BasicblockLoopData BasicblockLoopData
Definition: loop.hpp:30
#define sp
Definition: md-asm.hpp:81
static bool var_is_prealloc(const jitdata *jd, s4 i)
Definition: jit.hpp:265
methodinfo * m
Definition: jit.hpp:127
static bool var_is_temp(const jitdata *jd, s4 i)
Definition: jit.hpp:280
s4 maxinterfaces
Definition: jit.hpp:165
basicblock * end
Definition: jit.hpp:242
interface_info * interface_map
Definition: jit.hpp:164
methodinfo * method
Definition: jit.hpp:349
static bool var_is_inout(const jitdata *jd, s4 i)
Definition: jit.hpp:269
s4 flags
Definition: reg.hpp:45
s4 nr
Definition: jit.hpp:319
static bool basicblock_reached(const basicblock *bptr)
Definition: jit.hpp:438
s4 basicblockcount
Definition: jit.hpp:144
basicblock * original
Definition: jit.hpp:347
bool branchtoend
Definition: jit.hpp:174
basicblock ** successors
Definition: jit.hpp:340
void jit_check_basicblock_numbers(jitdata *jd)
Definition: jit.cpp:1212
#define jit_asm_compile
Definition: md-asm.hpp:103
ICMD jit_complement_condition(ICMD opcode)
Definition: jit.cpp:1152
Definition: jit.hpp:240
s4 stackcount
Definition: jit.hpp:145
void md_init(void)
Definition: md.cpp:48
#define STAT_DECLARE_VAR(type, var, init)
Declare an external statistics variable.
Definition: statistics.hpp:963
u1 * jit_recompile_for_deoptimization(methodinfo *m)
Definition: jit.cpp:538
instruction * instructions
Definition: jit.hpp:140
Type type
Definition: jit.hpp:322
s4 * reverselocalmap
Definition: jit.hpp:159