/* src/vm/jit/optimizing/lsra.inc - linear scan register allocator
- Copyright (C) 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
+ Copyright (C) 2005, 2006, 2008
+ CACAOVM - Verein zur Foerderung der freien virtuellen Maschine CACAO
This file is part of CACAO.
Foundation, Inc., 59 Temple Place - Suite 330, Boston, MA
02111-1307, USA.
- Contact: cacao@complang.tuwien.ac.at
-
- Authors: Christian Ullrich
+*/
- $Id: lsra.c $
-*/
#include "config.h"
#include <stdio.h>
#include "arch.h"
#include "md-abi.h"
-#include "mm/memory.h"
+#include "mm/memory.hpp"
#include "toolbox/bitvector.h"
-#include "vmcore/statistics.h"
-#include "vmcore/options.h"
-#include "vmcore/method.h"
+#include "vm/statistics.h"
+#include "vm/options.h"
+#include "vm/method.hpp"
#include "vm/jit/abi.h"
#include "vm/jit/reg.h"
-#include "vm/jit/jit.h"
-
+#include "vm/jit/jit.hpp"
#include "vm/jit/optimizing/graph.h"
#include "vm/jit/optimizing/lifetimes.h"
#include "vm/jit/optimizing/lsra.h"
-#ifdef LSRA_TESTLT
-# include "vm/resolve.h"
-#include "vm/builtin.h"
-#endif
-
-
-#include "toolbox/logging.h"
+#include "toolbox/logging.hpp"
extern const char *string_java_lang_InternalError;
/* function prototypes */
-void lsra_init(jitdata *);
-graphdata *lsra_setup(jitdata *);
+void lsra_setup(jitdata *);
void lsra_main(jitdata *);
#ifdef LSRA_DEBUG_VERBOSE
-void lsra_dump_stack(stackptr );
+void lsra_dump_stack(stackelement_t*);
void print_lifetimes(jitdata *, int *, int);
void print_all_lifetimes(jitdata *);
#endif
codegendata *cd;
registerdata *rd;
lsradata *ls;
- graphdata *gd;
#if defined(ENABLE_STATISTICS)
int locals_start;
int i,j;
#if defined(LSRA_DEBUG_CHECK)
#if 0
int b_index;
- stackptr in,out;
+ stackelement_t* in,out;
int ind, outd;
#endif
#endif
#if defined(LSRA_DEBUG_CHECK) || defined(LSRA_DEBUG_VERBOSE)
#if defined(LSRA_DEBUG_VERBOSE)
if (compileverbose) {
- printf("%s %s ",m->class->name->text, m->name->text);
- if (jd->isleafmethod)
+ printf("%s %s ",m->clazz->name->text, m->name->text);
+ if (code_is_leafmethod(jd->code))
printf("**Leafmethod**");
printf("\n");
}
#endif
- if (strcmp(m->class->name->text,"java/lang/String")==0)
+ if (strcmp(m->clazz->name->text,"java/lang/String")==0)
if (strcmp(m->name->text,"toLowerCase")==0)
#if defined(LSRA_DEBUG_VERBOSE)
if (compileverbose)
{ int dummy=1; dummy++; }
#endif
#endif
-
- lsra_init(jd);
- gd = lsra_setup(jd);
+
+ lsra_setup(jd);
#if defined(ENABLE_STATISTICS)
/* find conflicts between locals for statistics */
#endif
/* Run LSRA */
lsra_main(jd);
-#ifdef LSRA_TESTLT
- test_lifetimes( jd, gd );
-#endif
+
fflush(stdout);
}
-void lsra_init(jitdata *jd)
-{
- lsradata *ls = jd->ls;
-
- /* Init LSRA Data Structures */
- /* allocate lifetimes for all Basicblocks */
-
- ls->v_index = -1;
-}
-
-graphdata *lsra_setup(jitdata *jd)
+void lsra_setup(jitdata *jd)
{
methodinfo *m;
codegendata *cd;
registerdata *rd;
lsradata *ls;
- graphdata *gd;
#if defined(ENABLE_LOOPS)
/* Loop optimization "destroys" the basicblock array */
rd = jd->rd;
ls = jd->ls;
- ssa_init(jd);
-
- /* Setup LSRA Data structures */
-
- /* Generate the Control Flow Graph */
- /* Add one for a Basic Block 0 to be inserted, so lateron */
- /* with SSA Parameter initialization is handled right */
- gd = graph_init(jd->basicblockcount + 1);
- graph_make_cfg(jd, gd);
- ssa(jd, gd);
- lt_lifeness_analysis(jd, gd);
-
#ifdef LSRA_DEBUG_VERBOSE
if (compileverbose) {
printf("Lifetimes after LifenessAnalyse: \n");
printf("Basicblockcount: %4i\n",ls->basicblockcount);
}
#endif
- return gd;
}
void lsra_reg_setup(jitdata *jd,
int_reg->nregdesc = nregdescint;
flt_reg->nregdesc = nregdescfloat;
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(jd->code)) {
/* Temp and Argumentregister can be used as saved registers */
int_reg->sav_top = INT_ARG_CNT + INT_TMP_CNT + INT_SAV_CNT;
int param_count;
int i,j,tmp;
- /* count number of parameters ( .i_start == -1) */
+ /* count number of parameters ( .i_start == 0) */
for (param_count=0; (param_count < lifetime_count) &&
-/* (ls->lifetime[lifetime[param_count]].i_start == -1); param_count++); */
(ls->lifetime[lifetime[param_count]].i_start == 0); param_count++);
if (param_count > 0) {
struct lifetime *lt;
struct freemem *fmem;
int lt_index;
-#ifdef HAS_4BYTE_STACKSLOT
- struct freemem *fmem_2;
-#endif
methodinfo *m;
registerdata *rd;
lsradata *ls;
fmem=DNEW(struct freemem);
fmem->off=-1;
fmem->next=NULL;
-#ifdef HAS_4BYTE_STACKSLOT
- fmem_2=DNEW(struct freemem);
- fmem_2->off=-1;
- fmem_2->next=NULL;
-#endif
for (lt_index = 0; lt_index < lifetimecount; lt_index ++) {
lt = ls->lifetime + lifet[lt_index];
#endif
if (lt->regoff == -1) {
flags = INMEMORY;
-#ifdef HAS_4BYTE_STACKSLOT
- if (IS_2_WORD_TYPE(lt->type))
- regoff = lsra_getmem(lt, fmem_2, mem_use);
- else
-#endif
regoff = lsra_getmem(lt, fmem, mem_use);
} else {
flags = lt->savedvar;
/* no memmory allocated till now, or all other are still live */
if ((fmem->next == NULL) || (fmem->next->end > lt->i_start)) {
/* if (1) { */
-#ifdef HAS_4BYTE_STACKSLOT
- if (IS_2_WORD_TYPE(lt->type))
- if ( (*mem_use)&1 ) /* align memory location for 2 Word Types */
- (*mem_use)++;
fm=lsra_getnewmem(mem_use);
- if (IS_2_WORD_TYPE(lt->type))
- /* allocate a second following Slot for 2 Word Types */
- (*mem_use)++;
-#else
- fm=lsra_getnewmem(mem_use);
-#endif
} else {
/* Speicherstelle frei */
fm=fmem->next;
for (p=fmem; (p->next!=NULL) && (p->next->end < fm->end); p=p->next);
fm->next=p->next;
p->next=fm;
- return fm->off;
+ /* HACK: stackslots are 8 bytes on all architectures for now, I hope.
+ * -- pm
+ */
+ return fm->off * 8;
}
struct freemem *lsra_getnewmem(int *mem_use)
#ifdef LSRA_SAVEDVAR
lt->savedvar = SAVEDVAR;
#endif
- if (lt->savedvar || jd->isleafmethod) {
+ if (lt->savedvar || code_is_leafmethod(jd->code)) {
/* use Saved Reg (in case of leafmethod all regs are saved regs) */
if (reg->sav_top > regsneeded) {
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
if (active[i]->i_end > lt->i_start) break;
/* make active[i]->reg available again */
- if (jd->isleafmethod) {
+ if (code_is_leafmethod(jd->code)) {
/* leafmethod -> don't care about type -> put all again into */
/* reg->sav_reg */
#if defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
ls = jd->ls;
- if (lt->savedvar || jd->isleafmethod) {
+ if (lt->savedvar || code_is_leafmethod(jd->code)) {
_spill_at_intervall(lt, ls->active_sav, &(ls->active_sav_top));
} else {
_spill_at_intervall(lt, ls->active_tmp, &(ls->active_tmp_top));
switch (lt->type) {
case TYPE_LNG:
-#if defined(HAS_4BYTE_STACKSLOT) && !defined(SUPPORT_COMBINE_INTEGER_REGISTERS)
+#if defined (__I386__)
flags = 0;
#else
flags = 1;
projects / cacao.git / blobdiff