X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana2%2Fpto_init.c;h=781cfd8d9adcf2daad21399ba0b3d9ddc86b87a2;hb=c53a503e81f6e7c0995fbbcc451c2178ad9083bd;hp=462bb118fa5d7332d8318ff7a28517771927eaa5;hpb=89981f36217c42aefbffb58285b9db994e7dc77f;p=libfirm diff --git a/ir/ana2/pto_init.c b/ir/ana2/pto_init.c index 462bb118f..781cfd8d9 100644 --- a/ir/ana2/pto_init.c +++ b/ir/ana2/pto_init.c @@ -12,16 +12,22 @@ Licence: This file is protected by the GPL - GNU GENERAL PUBLIC LICENSE. */ -# ifdef HAVE_CONFIG_H -# include -# endif +#ifdef HAVE_CONFIG_H +# include "config.h" +#endif /* pto_init: Initialisation Functions */ +# include # include +#ifdef HAVE_STRING_H # include +#endif +#ifdef HAVE_STRINGS_H +# include +#endif # include "pto.h" # include "pto_init.h" @@ -32,8 +38,11 @@ # include "typewalk.h" # include "irgwalk.h" +# include "tv.h" # include "xmalloc.h" +# include "gnu_ext.h" + /* Local Defines: */ # define obstack_chunk_alloc xmalloc # define obstack_chunk_free free @@ -59,7 +68,7 @@ static struct obstack *pto_obst = NULL; /* all pto_t's go onto this one */ /* =================================================== Local Implementation: =================================================== */ -/* Allocate a new pto */ +/** Allocate a new pto */ static pto_t *new_pto (ir_node *node) { pto_t *pto = obstack_alloc (pto_obst, sizeof (pto_t)); @@ -68,19 +77,21 @@ static pto_t *new_pto (ir_node *node) return (pto); } -/* Allocate a new alloc_pto */ +/** Allocate a new alloc_pto */ static alloc_pto_t *new_alloc_pto (ir_node *alloc, int n_ctxs) { - assert (iro_Alloc == get_irn_opcode (alloc)); - int i; alloc_pto_t *alloc_pto = obstack_alloc (pto_obst, sizeof (alloc_pto_t)); - type *tp = get_Alloc_type (alloc); + type *tp; + + assert (op_Alloc == get_irn_op(alloc)); + + tp = get_Alloc_type (alloc); alloc_pto->ptos = (pto_t**) obstack_alloc (pto_obst, n_ctxs * sizeof (pto_t*)); for (i = 0; i < n_ctxs; i ++) { - desc_t *desc = new_name (tp, alloc); + desc_t *desc = new_name (tp, alloc, i); alloc_pto->ptos [i] = new_pto (alloc); qset_insert (alloc_pto->ptos [i]->values, desc); } @@ -88,23 +99,31 @@ static alloc_pto_t *new_alloc_pto (ir_node *alloc, int n_ctxs) return (alloc_pto); } -/* Allocate a new pto for a symconst */ +/** Allocate a new pto for a symconst */ static pto_t* new_symconst_pto (ir_node *symconst) { - assert (iro_SymConst == get_irn_opcode (symconst)); - - pto_t *pto = new_pto (symconst); - entity *ent = get_SymConst_entity (symconst); + pto_t *pto; + entity *ent; desc_t *desc = NULL; - /* ok, so if the symconst has a pointer-to-mumble, it's some address + assert (op_SymConst == get_irn_op(symconst)); + + pto = new_pto (symconst); + ent = get_SymConst_entity (symconst); + + /* + const char *ent_name = (char*) get_entity_name (ent); + const char *own_name = (char*) get_type_name (get_entity_owner (ent)); + HERE3 ("start", own_name, ent_name); + */ + /* Ok, so if the symconst has a pointer-to-mumble, it's some address calculation, but if it's the mumble itself, it's just the same, except it's presumably a constant of mumble. In any case, we need to branch on this. "How's that for object fucking oriented? --jwz" */ - if (is_pointer_type (get_entity_type (ent))) { + if (is_Pointer_type (get_entity_type (ent))) { desc = new_ent_name (ent); - } else if (is_class_type (get_entity_type (ent))) { - desc = new_name (get_entity_type (ent), symconst); + } else if (is_Class_type (get_entity_type (ent))) { + desc = new_name (get_entity_type (ent), symconst, -1); } else { fprintf (stderr, "%s: not handled: %s[%li] (\"%s\")\n", __FUNCTION__, @@ -116,41 +135,21 @@ static pto_t* new_symconst_pto (ir_node *symconst) qset_insert (pto->values, desc); - return (pto); -} - -/* Allocate a new pto for a constant */ -static pto_t *new_const_pto (ir_node *cnst) -{ - assert (iro_Const == get_irn_opcode (cnst)); - assert (mode_P == get_irn_mode (cnst)); - - static pto_t *cnst_pto = NULL; - - /* since 'store's and 'load's via a NULL pointer are hardly ever - successful, we get away with an empty set */ - - tarval *tv = get_Const_tarval (cnst); - - assert (tv == get_tarval_null (mode_P)); + /* HERE3 ("end", own_name, ent_name); */ - if (NULL == cnst_pto) { - cnst_pto = new_pto (cnst); - } - - return (cnst_pto); + return (pto); } - /* Helper to pto_init --- clear the link fields of class types */ -static void clear_type_link (type_or_ent *thing, void *__unused) +static void clear_type_link (type_or_ent *thing, void *_unused) { if (is_type (thing)) { type *tp = (type*) thing; - if (is_class_type (tp)) { + if (is_Class_type (tp)) { DBGPRINT (1, (stdout, "%s (\"%s\")\n", - __FUNCTION__, get_type_name (tp))); + __FUNCTION__, + get_type_name (tp))); set_type_link (tp, NULL); } @@ -158,87 +157,110 @@ static void clear_type_link (type_or_ent *thing, void *__unused) entity *ent = (entity*) thing; DBGPRINT (1, (stdout, "%s (\"%s\")\n", - __FUNCTION__, get_entity_name (ent))); + __FUNCTION__, + get_entity_name (ent))); set_entity_link (ent, NULL); } } -/* Helper to pto_init_graph --- clear the links of the given node */ -static void clear_node_link (ir_node *node, void *__unused) +/** Helper to pto_init_graph --- clear the links of the given node */ +static void clear_node_link (ir_node *node, void *_unused) { set_irn_link (node, NULL); } -/* Helper to pto_init_graph --- clear the links of all nodes */ +/** Helper to pto_init_graph --- clear the links of all nodes */ static void clear_graph_links (ir_graph *graph) { irg_walk_graph (graph, clear_node_link, NULL, NULL); } -/* Reset ALL the pto values for a new pass */ +/** Reset ALL the pto values for a new pass */ static void reset_node_pto (ir_node *node, void *env) { reset_env_t *reset_env = (reset_env_t*) env; int ctx_idx = reset_env->ctx_idx; - const opcode op = get_irn_opcode (node); + opcode op = get_irn_opcode (node); + + /* HERE ("start"); */ switch (op) { case (iro_Load): - /* case (iro_SymConst): */ /* WHY? */ - case (iro_Const): case (iro_Call): case (iro_Block): /* END BLOCK only */ case (iro_Phi): { /* allocate 'empty' pto values */ pto_t *pto = new_pto (node); set_node_pto (node, pto); - } break; + } break; case (iro_Alloc): { /* set alloc to 'right' current pto */ alloc_pto_t *alloc_pto = (alloc_pto_t*) get_irn_link (node); alloc_pto->curr_pto = alloc_pto->ptos [ctx_idx]; + + DBGPRINT (1, (stdout, "%s: setting pto of \"%s[%li]\" for ctx %i\n", + __FUNCTION__, + OPNAME (node), + OPNUM (node), + ctx_idx)); + + assert (alloc_pto->curr_pto); + } break; + case (iro_Const): + case (iro_SymConst): { + /* nothing, leave as-is */ } break; default: { - /* nothing */ + /* basically, nothing */ + DBGPRINT (2, (stdout, "%s: resetting pto of \"%s[%li]\"\n", + __FUNCTION__, + OPNAME (node), + OPNUM (node))); + set_node_pto (node, NULL); } break; } + + /* HERE ("end"); */ } -/* Temporary fix until we get 'real' ptos: Allocate some dummy for pto */ +/** Initialise primary name sources */ static void init_pto (ir_node *node, void *env) { init_env_t *init_env = (init_env_t*) env; int n_ctxs = init_env->n_ctxs; - const opcode op = get_irn_opcode (node); + opcode op = get_irn_opcode (node); switch (op) { case (iro_SymConst): { - if (mode_P == get_irn_mode (node)) { - /* debugging only */ + if (mode_is_reference (get_irn_mode (node))) { entity *ent = get_SymConst_entity (node); - if (is_class_type (get_entity_type (ent)) || - is_pointer_type (get_entity_type (ent))) { - DBGPRINT (0, (stdout, "%s: new name \"%s\" for \"%s[%li]\"\n", + type *tp = get_entity_type (ent); + if (is_Class_type (tp) || is_Pointer_type (tp)) { + pto_t *symconst_pto = new_symconst_pto (node); + set_node_pto (node, symconst_pto); + + /* debugging only */ + DBGPRINT (1, (stdout, "%s: new name \"%s\" for \"%s[%li]\"\n", __FUNCTION__, get_entity_name (ent), OPNAME (node), OPNUM (node))); - - pto_t *symconst_pto = new_symconst_pto (node); - set_node_pto (node, symconst_pto); } } } break; + case (iro_Alloc): { - type *tp = get_Alloc_type (node); /* debugging only */ alloc_pto_t *alloc_pto = new_alloc_pto (node, n_ctxs); + type *tp; + set_alloc_pto (node, alloc_pto); - DBGPRINT (0, (stdout, "%s: %i names \"%s\" for \"%s[%li]\"\n", + tp = get_Alloc_type (node); /* debugging only */ + DBGPRINT (1, (stdout, "%s: %i names \"%s\" for \"%s[%li]\"\n", __FUNCTION__, n_ctxs, get_type_name (tp), @@ -247,12 +269,16 @@ static void init_pto (ir_node *node, void *env) } break; case (iro_Const): { - if (mode_P == get_irn_mode (node)) { - pto_t *pto = new_const_pto (node); - set_node_pto (node, pto); + tarval *tv = get_Const_tarval (node); + + /* only need 'NULL' pointer constants */ + if (mode_P == get_tarval_mode (tv)) { + if (get_tarval_null (mode_P) == tv) { + pto_t *pto = new_pto (node); + set_node_pto (node, pto); + } } } break; - case (iro_Load): case (iro_Call): case (iro_Phi): @@ -265,23 +291,22 @@ static void init_pto (ir_node *node, void *env) } -/* Initialise the given graph for a new pass run */ +/** Initialise the given graph for a new pass run */ static void pto_init_graph_allocs (ir_graph *graph) { graph_info_t *ginfo = ecg_get_info (graph); - int n_ctxs = ginfo->n_ctxs; + init_env_t *init_env; - init_env_t *init_env = xmalloc (sizeof (init_env_t)); - init_env->n_ctxs = n_ctxs; + init_env = xmalloc (sizeof (init_env_t)); + init_env->n_ctxs = ginfo->n_ctxs; - HERE ("start"); + /* HERE ("start"); */ irg_walk_graph (graph, init_pto, NULL, init_env); + /* HERE ("end"); */ memset (init_env, 0x00, sizeof (init_env_t)); free (init_env); - - HERE ("end"); } /* =================================================== @@ -290,48 +315,54 @@ static void pto_init_graph_allocs (ir_graph *graph) /* "Fake" the arguments to the main method */ void fake_main_args (ir_graph *graph) { - HERE ("start"); + /* HERE ("start"); */ entity *ent = get_irg_entity (graph); type *mtp = get_entity_type (ent); ir_node **args = find_irg_args (graph); type *ctp = get_method_param_type (mtp, 1); /* ctp == char[]*[]* */ + desc_t *arg_desc; + pto_t *arg_pto; /* 'main' has signature 'void(int, char[]*[]*)' */ assert (NULL == args [2]); - assert (is_pointer_type (ctp)); + assert (is_Pointer_type (ctp)); ctp = get_pointer_points_to_type (ctp); /* ctp == char[]*[] */ - assert (is_array_type (ctp)); + assert (is_Array_type (ctp)); - desc_t *arg_desc = new_name (ctp, args [1]); - pto_t *arg_pto = new_pto (args [1]); + arg_desc = new_name (ctp, args [1], -1); + arg_pto = new_pto (args [1]); /* todo: simulate 'store' to arg1[] ?!? */ qset_insert (arg_pto->values, arg_desc); set_node_pto (args [1], arg_pto); + DBGPRINT (1, (stdout, "%s:%i (%s[%li])\n", + __FUNCTION__, __LINE__, + OPNAME (args [1]), OPNUM (args [1]))); + # ifdef TEST_MAIN_TYPE ctp = get_array_element_type (ctp); /* ctp == char[]* */ - assert (is_pointer_type (ctp)); + assert (is_Pointer_type (ctp)); ctp = get_pointer_points_to_type (ctp); /* ctp == char[] */ - assert (is_array_type (ctp)); + assert (is_Array_type (ctp)); ctp = get_array_element_type (ctp); /* ctp == char */ assert (is_primitive_type (ctp)); # endif /* defined TEST_MAIN_TYPE */ - HERE ("end"); + /* HERE ("end"); */ } /* Initialise the Init module */ -void pto_init_init () +void pto_init_init (void) { pto_obst = (struct obstack*) xmalloc (sizeof (struct obstack)); @@ -339,7 +370,7 @@ void pto_init_init () } /* Cleanup the Init module */ -void pto_init_cleanup () +void pto_init_cleanup (void) { obstack_free (pto_obst, NULL); memset (pto_obst, 0x00, sizeof (struct obstack)); @@ -349,16 +380,17 @@ void pto_init_cleanup () /* Initialise the Names of the Types/Entities */ -void pto_init_type_names () +void pto_init_type_names (void) { - HERE ("start"); + /* HERE ("start"); */ type_walk (clear_type_link, NULL, NULL); - HERE ("end"); + /* HERE ("end"); */ } /* Initialise the given graph for a new pass run */ void pto_init_graph (ir_graph *graph) { + ir_node **proj_args; graph_info_t *ginfo = ecg_get_info (graph); const int n_ctxs = ginfo->n_ctxs; @@ -367,35 +399,89 @@ void pto_init_graph (ir_graph *graph) const char *ent_name = (char*) get_entity_name (ent); const char *own_name = (char*) get_type_name (get_entity_owner (ent)); - DBGPRINT (0, (stdout, "%s: init \"%s.%s\" for %i ctxs\n", __FUNCTION__, + DBGPRINT (2, (stdout, "%s: init \"%s.%s\" for %i ctxs\n", + __FUNCTION__, own_name, ent_name, n_ctxs)); - HERE ("start"); + /* HERE ("start"); */ clear_graph_links (graph); pto_init_graph_allocs (graph); - HERE ("end"); + /* HERE ("end"); */ + + assert (NULL == get_irg_proj_args (graph)); + proj_args = find_irg_args (graph); + set_irg_proj_args (graph, proj_args); + assert (proj_args == get_irg_proj_args (graph)); } /* Reset the given graph for a new pass run */ void pto_reset_graph_pto (ir_graph *graph, int ctx_idx) { - HERE ("start"); + reset_env_t *reset_env; - reset_env_t *reset_env = (reset_env_t*) xmalloc (sizeof (reset_env_t)); + reset_env = (reset_env_t*) xmalloc (sizeof (reset_env_t)); reset_env->ctx_idx = ctx_idx; + /* HERE ("start"); */ + irg_walk_graph (graph, reset_node_pto, NULL, reset_env); + /* HERE ("end"); */ memset (reset_env, 0x00, sizeof (reset_env_t)); free (reset_env); - HERE ("end"); } /* $Log$ + Revision 1.20 2005/12/05 12:19:54 beck + added missing include (not anymore included in libFirm) + + Revision 1.19 2005/06/17 17:42:32 beck + added doxygen docu + fixed (void) function headers + + Revision 1.18 2005/02/16 13:27:52 beck + added needed tv.h include + + Revision 1.17 2005/01/14 14:12:51 liekweg + prepare gnu extension fix + + Revision 1.16 2005/01/14 13:36:50 liekweg + don't put environments on the stack; handle consts + + Revision 1.15 2005/01/10 17:26:34 liekweg + fixup printfs, don't put environments on the stack + + Revision 1.14 2005/01/05 14:25:54 beck + renames all is_x*_type() functions to is_X*_type() to prevent name clash with EDG fronten + + Revision 1.13 2004/12/21 15:07:55 beck + removed C99 contructs + removed unnecessary allocation + removed use of mode_P, use mode_is_reference() instead + removed handling of Const with pointer tarvals, these constructs are removed + + Revision 1.12 2004/12/20 17:41:14 liekweg + __unused -> _unused + + Revision 1.11 2004/12/20 17:34:35 liekweg + fix recursion handling + + Revision 1.10 2004/12/15 13:31:00 liekweg + store ctx idx in names + + Revision 1.9 2004/12/15 09:18:18 liekweg + pto_name.c + + Revision 1.8 2004/12/02 16:17:51 beck + fixed config.h include + + Revision 1.7 2004/11/30 14:47:54 liekweg + fix initialisation; do correct iteration + Revision 1.6 2004/11/26 16:00:41 liekweg recognize class consts vs. ptr-to-class consts