X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fexternal%2Fread.c;h=955841385c3fd1bfef642c67b4524e4656664f49;hb=00894f1e0b6e74ca6c12d253dd30f7d873808977;hp=5feddc5e4b2a4ba120ea9a78bc1886b7bee9af6c;hpb=860e1ae18c83927ca4ff3751813efd08491dd77e;p=libfirm diff --git a/ir/external/read.c b/ir/external/read.c index 5feddc5e4..955841385 100644 --- a/ir/external/read.c +++ b/ir/external/read.c @@ -1,43 +1,63 @@ -/* -*- c -*- */ - /* - * Project: libFIRM - * File name: ir/external/read.c - * Purpose: Read descriptions of external effects - * Author: Florian - * Modified by: Boris Boesler - * Created: 11.10.2004 - * CVS-ID: $Id$ - * Copyright: (c) 1999-2004 Universität Karlsruhe - * Licence: This file is protected by GPL - GNU GENERAL PUBLIC LICENSE. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. + * + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. + * + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. */ +/** + * @file + * @brief Read descriptions of external effects + * @author Florian, Boris Boesler + * @date 11.10.2004 + * @version $Id$ + */ #ifdef HAVE_CONFIG_H # include "config.h" #endif -/* get prototype for alloca somehow */ -#ifdef HAVE_ALLOCA_H -# include -#endif -#ifdef HAVE_STDLIB_H -# include -#endif +#include +#include +#include -# include +#include +#include +#include #include "read_t.h" #include "read.h" #include "irprog.h" #include "irgraph.h" +#include "pseudo_irg.h" #include "ircons.h" #include "irmode.h" #include "irdump.h" #include "irvrfy.h" -#include "type.h" +#include "typerep.h" #include "tv.h" +#include "xmalloc.h" + +# define MY_ENCODING "ISO-8859-1" + +# define CHECK(ptr,msg) assert (ptr && msg) -#define VERBOSE_PRINTING 1 +# define NODE_NAME(n, m) (0 == xmlStrcmp (n->name, (const xmlChar*) #m)) +# define CHECK_NAME(n, m) assert (0 == xmlStrcmp (n->name, (const xmlChar*) #m)) + + +#define VERBOSE_PRINTING 0 #if VERBOSE_PRINTING # define VERBOSE_PRINT(s) fprintf s @@ -57,7 +77,7 @@ static module_t *current_module = NULL; #if VERBOSE_PRINTING /* this is only used inside a VERBOSE_PRINT() call */ -static char *effect_string[] = { +static const char *effect_string[] = { "arg", "valref", "select", @@ -72,7 +92,7 @@ static char *effect_string[] = { }; #endif /* defined VERBOSE_PRINTING */ -static const ident* +static ident* getNodeModuleIdent (xmlNodePtr node) { const char *mod_str = (const char*) xmlGetProp (node, BAD_CAST "module"); @@ -80,7 +100,7 @@ getNodeModuleIdent (xmlNodePtr node) if (NULL == mod_str) { return (NULL); } else { - const ident *res = new_id_from_str (mod_str); + ident *res = new_id_from_str (mod_str); return (res); } } @@ -93,6 +113,7 @@ getNodeProcName (xmlNodePtr node) return (proc_str); } +# ifdef NEEDED static char* getNodeClassName (xmlNodePtr node) { @@ -100,6 +121,7 @@ getNodeClassName (xmlNodePtr node) assert (proc_str); return ( (proc_str)); } +# endif /* defined NEEDED */ static const char* getNodeId (xmlNodePtr node) @@ -144,7 +166,7 @@ getNodeOwnerStr (xmlNodePtr node) static const char *getNodeEntityStr (xmlNodePtr node) { - const char *ent_str = (char*) xmlGetProp (node, BAD_CAST "entity"); + const char *ent_str = (char*) xmlGetProp (node, BAD_CAST "ir_entity"); assert (ent_str); return (ent_str); @@ -154,8 +176,9 @@ static const char /* was Public Interface */ +# ifdef NEEDED static -type_t *getTypeByIdent (const ident *id) +type_t *getTypeByIdent (ident *id) { type_t *curr = types; // @@@ TODO module -> types @@ -168,9 +191,11 @@ type_t *getTypeByIdent (const ident *id) return (NULL); } +# endif /* defined NEEDED */ +# ifdef NEEDED static -type_t *getTypeById (const ident *id) +type_t *getTypeById (ident *id) { type_t *curr = types; // which ones? @@ -183,9 +208,11 @@ type_t *getTypeById (const ident *id) return (NULL); } +# endif /* defined NEEDED */ +# ifdef NEEDED static -entity_t *getEntityByIdents (const ident *name, const ident *tp_ident) +entity_t *getEntityByIdents (ident *name, ident *tp_ident) { entity_t *curr = entities; // TODO module -> entities @@ -199,9 +226,10 @@ entity_t *getEntityByIdents (const ident *name, const ident *tp_ident) return (NULL); } +# endif /* defined NEEDED */ static -entity_t *getEntityById (const ident *id) +entity_t *getEntityById (ident *id) { entity_t *curr = entities; @@ -215,8 +243,9 @@ entity_t *getEntityById (const ident *id) return (NULL); } +# ifdef NEEDED static -proc_t *getEffectByName (const ident *proc_ident) +proc_t *getEffectByName (ident *proc_ident) { proc_t *curr_effs = procs; @@ -229,6 +258,7 @@ proc_t *getEffectByName (const ident *proc_ident) return (NULL); } +# endif /* defined NEEDED */ static xmlNodePtr get_any_valid_child(xmlNodePtr elem) @@ -264,6 +294,7 @@ parseArg (xmlDocPtr doc, xmlNodePtr argelm) int num; char *num_str; eff_t *arg; + (void) doc; CHECK_NAME (argelm, arg); VERBOSE_PRINT ((stdout, "arg node \t0x%08x\n", (int) argelm)); @@ -276,7 +307,7 @@ parseArg (xmlDocPtr doc, xmlNodePtr argelm) typeid = getNodeTypeStr (argelm); - arg = NEW (eff_t); + arg = XMALLOC(eff_t); arg -> kind = eff_arg; arg -> id = new_id_from_str(id); arg -> effect.arg.num = num; @@ -290,6 +321,7 @@ parseValref (xmlDocPtr doc, xmlNodePtr valelm) { const char *ref_id; eff_t *valref; + (void) doc; CHECK_NAME (valelm, valref); VERBOSE_PRINT ((stdout, "valref node \t0x%08x\n", (int) valelm)); @@ -297,7 +329,7 @@ parseValref (xmlDocPtr doc, xmlNodePtr valelm) ref_id = getNodeRefId (valelm); VERBOSE_PRINT ((stdout, "val->refid = \"%s\"\n", ref_id)); - valref = NEW (eff_t); + valref = XMALLOC(eff_t); valref->kind = eff_valref; valref-> id = new_id_from_str(ref_id); @@ -307,19 +339,19 @@ parseValref (xmlDocPtr doc, xmlNodePtr valelm) static eff_t* parseSelect (xmlDocPtr doc, xmlNodePtr selelm) { - const ident *entity_id = new_id_from_str(getNodeEntityStr (selelm)); + ident *entity_id = new_id_from_str(getNodeEntityStr (selelm)); entity_t *ent; xmlNodePtr child; eff_t *valref = NULL; - eff_t *sel = NEW (eff_t); + eff_t *sel = XMALLOC(eff_t); sel->kind = eff_select; CHECK_NAME (selelm, select); VERBOSE_PRINT ((stdout, "select node \t0x%08x\n", (int) selelm)); ent = getEntityById (entity_id); - assert(ent && "entity not found"); - VERBOSE_PRINT ((stdout, "select entity %s\n", get_id_str(ent -> ent_ident))); + assert(ent && "ir_entity not found"); + VERBOSE_PRINT ((stdout, "select ir_entity %s\n", get_id_str(ent -> ent_ident))); child = selelm->xmlChildrenNode; @@ -340,10 +372,10 @@ parseSelect (xmlDocPtr doc, xmlNodePtr selelm) static eff_t* parseLoad (xmlDocPtr doc, xmlNodePtr loadelm) { - const ident *id; + ident *id; xmlNodePtr child; eff_t *sel; - eff_t *load = NEW (eff_t); + eff_t *load = XMALLOC(eff_t); load->kind = eff_load; CHECK_NAME (loadelm, load); @@ -354,7 +386,7 @@ parseLoad (xmlDocPtr doc, xmlNodePtr loadelm) if(NODE_NAME (child, select)) { sel = parseSelect (doc, child); load-> effect.load.ent = sel-> effect.select.ent; - VERBOSE_PRINT ((stdout, "load entity \t%s\n", + VERBOSE_PRINT ((stdout, "load ir_entity \t%s\n", get_id_str(load -> effect.load.ent -> ent_ident))); } else { @@ -376,7 +408,7 @@ parseStore (xmlDocPtr doc, xmlNodePtr storeelm) xmlNodePtr child; eff_t *sel; eff_t *valref; - eff_t *store = NEW (eff_t); + eff_t *store = XMALLOC(eff_t); store->kind = eff_store; CHECK_NAME (storeelm, store); @@ -407,10 +439,11 @@ parseStore (xmlDocPtr doc, xmlNodePtr storeelm) static eff_t* parseAlloc (xmlDocPtr doc, xmlNodePtr allocelm) { - const ident *id; - const ident *type_id; - eff_t *alloc = NEW (eff_t); /* ...! */ + ident *id; + ident *type_id; + eff_t *alloc = XMALLOC(eff_t); /* ...! */ alloc->kind = eff_alloc; + (void) doc; CHECK_NAME (allocelm, alloc); VERBOSE_PRINT ((stdout, "alloc node \t0x%08x\n", (int) allocelm)); @@ -428,12 +461,12 @@ parseAlloc (xmlDocPtr doc, xmlNodePtr allocelm) static eff_t* parseCall (xmlDocPtr doc, xmlNodePtr callelm) { - const ident *id; + ident *id; xmlNodePtr child; eff_t *sel; xmlNodePtr arg; int n_args; - eff_t *call = NEW (eff_t); + eff_t *call = XMALLOC(eff_t); call->kind = eff_call; CHECK_NAME (callelm, call); @@ -467,7 +500,7 @@ parseCall (xmlDocPtr doc, xmlNodePtr callelm) free (sel); if (0 != n_args) { - const ident **args = (const ident**) malloc(n_args * sizeof(const ident*)); + ident **args = XMALLOCN(ident*, n_args); int i = 0; while (NULL != arg) { @@ -486,12 +519,12 @@ parseCall (xmlDocPtr doc, xmlNodePtr callelm) static eff_t* parseJoin (xmlDocPtr doc, xmlNodePtr joinelm) { - const ident *id; + ident *id; int n_ins; - const ident **ins; + ident **ins; int i; xmlNodePtr child; - eff_t *join = NEW (eff_t); + eff_t *join = XMALLOC(eff_t); join->kind = eff_join; CHECK_NAME (joinelm, join); @@ -507,7 +540,7 @@ parseJoin (xmlDocPtr doc, xmlNodePtr joinelm) child = child->next; } - ins = (const ident **) malloc (n_ins * sizeof (const ident *) ); + ins = XMALLOCN(ident*, n_ins); i = 0; child = get_valid_child(joinelm); @@ -528,9 +561,10 @@ parseJoin (xmlDocPtr doc, xmlNodePtr joinelm) static eff_t* parseUnknown (xmlDocPtr doc, xmlNodePtr unknownelm) { - const ident *id; - eff_t *unknown = NEW (eff_t); + ident *id; + eff_t *unknown = XMALLOC(eff_t); unknown->kind = eff_unknown; + (void) doc; CHECK_NAME (unknownelm, unknown); VERBOSE_PRINT ((stdout, "unknown node \t0x%08x\n", (int) unknownelm)); @@ -544,7 +578,7 @@ static eff_t* parseReturn (xmlDocPtr doc, xmlNodePtr retelm) { xmlNodePtr child; - eff_t *ret = NEW (eff_t); + eff_t *ret = XMALLOC(eff_t); ret->kind = eff_ret; CHECK_NAME (retelm, ret); @@ -569,7 +603,7 @@ parseRaise (xmlDocPtr doc, xmlNodePtr raiseelm) const char *tp_id; eff_t *valref; xmlNodePtr child; - eff_t *raise = NEW (eff_t); + eff_t *raise = XMALLOC(eff_t); raise->kind = eff_raise; CHECK_NAME (raiseelm, raise); @@ -601,8 +635,9 @@ parseType (xmlDocPtr doc, xmlNodePtr typeelm) const char *tp_id = getNodeId (typeelm); VERBOSE_PRINT ((stdout, "type node \t0x%08x (%s)\n", (int) typeelm, tp_id)); VERBOSE_PRINT ((stdout, "type = \"%s\"\n", getNodeTypeStr (typeelm))); + (void) doc; - type = (type_t*) malloc (sizeof (type_t)); + type = XMALLOC(type_t); type -> type_ident = new_id_from_str(getNodeTypeStr (typeelm)); type -> id = new_id_from_str(tp_id); @@ -610,15 +645,16 @@ parseType (xmlDocPtr doc, xmlNodePtr typeelm) types = type; } -/** parse an entity node and insert it into the list */ +/** parse an ir_entity node and insert it into the list */ static void parseEntity (xmlDocPtr doc, xmlNodePtr entelm) { - entity_t *ent = NEW (entity_t); + entity_t *ent = XMALLOC(entity_t); + (void) doc; /* parse it */ const char *ent_id = getNodeId (entelm); - /* fprintf (stdout, "entity node \t0x%08x (%d)\n", (int) entelm, ent_id); */ + /* fprintf (stdout, "ir_entity node \t0x%08x (%d)\n", (int) entelm, ent_id); */ VERBOSE_PRINT ((stdout, "ent = \"%s.%s\"\n", getNodeTypeStr (entelm), getNodeEntityStr (entelm))); @@ -653,10 +689,10 @@ parseEffect (xmlDocPtr doc, xmlNodePtr effelm) } VERBOSE_PRINT ((stdout, "has %d effects\n", n_effs)); - curr_effs = NEW (proc_t); + curr_effs = XMALLOC(proc_t); curr_effs -> proc_ident = new_id_from_str(procname); curr_effs -> ownerid = new_id_from_str(ownerid); - curr_effs->effs = (eff_t**) malloc (n_effs * sizeof (eff_t*)); + curr_effs->effs = XMALLOCN(eff_t*, n_effs); cur = effelm -> xmlChildrenNode; while (NULL != cur) { @@ -701,7 +737,7 @@ parseEffect (xmlDocPtr doc, xmlNodePtr effelm) static -void read_extern (const char *filename) +int read_extern (const char *filename) { /* xmlNsPtr ns = NULL; */ /* no namespace for us */ xmlDocPtr doc; /* whole document */ @@ -714,7 +750,8 @@ void read_extern (const char *filename) LIBXML_TEST_VERSION xmlKeepBlanksDefault (0); VERBOSE_PRINT((stdout, "read file %s\n", filename)); doc = xmlParseFile (filename); - CHECK (doc, "xmlParseFile"); + if (! doc) + return 0; cur = xmlDocGetRootElement (doc); CHECK (cur, "xmlDocGetRootElement"); @@ -739,7 +776,7 @@ void read_extern (const char *filename) while (cur != NULL) { if (NODE_NAME (cur, type)) { parseType (doc, cur); - } else if (NODE_NAME (cur, entity)) { + } else if (NODE_NAME (cur, ir_entity)) { parseEntity (doc, cur); } else if (NODE_NAME (cur, effect)) { parseEffect (doc, cur); @@ -752,7 +789,7 @@ void read_extern (const char *filename) cur = cur->next; } - module = NEW(module_t); + module = XMALLOC(module_t); module -> id = mod_id; module -> types = types; module -> entities = entities; @@ -764,6 +801,8 @@ void read_extern (const char *filename) module -> next = modules; modules = module; + + return 1; } /********************************************************************/ @@ -776,7 +815,6 @@ void freeArg (eff_t *arg) { VERBOSE_PRINT ((stdout, "free arg node \t0x%08x\n", (int) arg)); free(arg); - return; } static @@ -784,7 +822,6 @@ void freeValref (eff_t *valref) { VERBOSE_PRINT ((stdout, "free valref node \t0x%08x\n", (int) valref)); free(valref); - return; } static @@ -792,7 +829,6 @@ void freeSelect (eff_t *sel) { VERBOSE_PRINT ((stdout, "free select node \t0x%08x\n", (int) sel)); free(sel); - return; } static @@ -800,7 +836,6 @@ void freeLoad (eff_t *load) { VERBOSE_PRINT ((stdout, "free load node \t0x%08x\n", (int) load)); free (load); - return; } static @@ -808,7 +843,6 @@ void freeStore (eff_t *store) { VERBOSE_PRINT ((stdout, "free store node \t0x%08x\n", (int) store)); free (store); - return; } static @@ -816,7 +850,6 @@ void freeAlloc (eff_t *alloc) { VERBOSE_PRINT ((stdout, "free alloc node \t0x%08x\n", (int) alloc)); free(alloc); - return; } static @@ -825,7 +858,6 @@ void freeCall (eff_t *call) VERBOSE_PRINT ((stdout, "free call node \t0x%08x\n", (int) call)); free(call -> effect.call.args); free(call); - return; } static @@ -834,7 +866,6 @@ void freeJoin (eff_t *join) VERBOSE_PRINT ((stdout, "free join node \t0x%08x\n", (int) join)); free(join -> effect.join.ins); free(join); - return; } static @@ -842,7 +873,6 @@ void freeUnknown (eff_t *unknown) { VERBOSE_PRINT ((stdout, "free unknown node \t0x%08x\n", (int) unknown)); free(unknown); - return; } static @@ -850,7 +880,6 @@ void freeReturn (eff_t *ret) { VERBOSE_PRINT ((stdout, "free ret node \t0x%08x\n", (int) ret)); free(ret); - return; } static @@ -858,7 +887,6 @@ void freeRaise (eff_t *raise) { VERBOSE_PRINT ((stdout, "free raise node \t0x%08x\n", (int) raise)); free (raise); - return; } @@ -950,7 +978,7 @@ void free_data(void) /********************************************************************/ static -type_t *find_type_in_module(module_t *module, const ident *typeid) +type_t *find_type_in_module(module_t *module, ident *typeid) { type_t *type; @@ -974,7 +1002,7 @@ static void add_value_to_proc(proc_t *proc, eff_t *eff) } -eff_t *find_valueid_in_proc_effects(const ident *id, proc_t *proc) +eff_t *find_valueid_in_proc_effects(ident *id, proc_t *proc) { eff_t *val; @@ -1023,9 +1051,9 @@ static void create_abstract_return(ir_graph *irg, proc_t *proc, eff_t *eff) static void create_abstract_arg(ir_graph *irg, proc_t *proc, eff_t *eff) { ir_node *arg; - entity *ent; + ir_entity *ent; ir_mode *mode; - type *typ; + ir_type *typ; int num; VERBOSE_PRINT((stdout, "create effect:arg %d in %s\n", @@ -1049,9 +1077,10 @@ static void create_abstract_arg(ir_graph *irg, proc_t *proc, eff_t *eff) static void create_abstract_load(ir_graph *irg, proc_t *proc, eff_t *eff) { ir_node *sel, *load; - entity *ent; + ir_entity *ent; ir_mode *mode; eff_t *addr; + (void) irg; VERBOSE_PRINT((stdout, "create load in %s\n", get_id_str(proc -> proc_ident))); @@ -1091,15 +1120,16 @@ static void create_abstract_load(ir_graph *irg, proc_t *proc, eff_t *eff) static void create_abstract_store(ir_graph *irg, proc_t *proc, eff_t *eff) { ir_node *sel, *store; - entity *ent; + ir_entity *ent; eff_t *addr, *val; + (void) irg; VERBOSE_PRINT((stdout, "create store in %s\n", get_id_str(proc -> proc_ident))); if(eff -> effect.store.ent) { ent = eff -> effect.store.ent -> f_ent; - VERBOSE_PRINT((stdout, "store to entity %s\n", get_entity_name(ent))); + VERBOSE_PRINT((stdout, "store to ir_entity %s\n", get_entity_name(ent))); } else { VERBOSE_PRINT((stdout, "store to memory\n")); @@ -1134,10 +1164,11 @@ static void create_abstract_store(ir_graph *irg, proc_t *proc, eff_t *eff) static void create_abstract_alloc(ir_graph *irg, proc_t *proc, eff_t *eff) { - type *ftype; + ir_type *ftype; ir_node *alloc; type_t *xtype; symconst_symbol sym; + (void) irg; VERBOSE_PRINT((stdout, "create alloc in %s\n", get_id_str(proc -> proc_ident))); @@ -1147,7 +1178,7 @@ static void create_abstract_alloc(ir_graph *irg, proc_t *proc, eff_t *eff) ftype = xtype -> f_tp; sym.type_p = ftype; - alloc = new_Alloc(get_store(), new_SymConst(sym, symconst_size), ftype, + alloc = new_Alloc(get_store(), new_SymConst(mode_Is, sym, symconst_type_size), ftype, heap_alloc); set_store(new_Proj(alloc, mode_M, 0)); eff -> firmnode = new_Proj(alloc, mode_P, 2); @@ -1159,6 +1190,7 @@ static void create_abstract_alloc(ir_graph *irg, proc_t *proc, eff_t *eff) static void create_abstract_unknown(ir_graph *irg, proc_t *proc, eff_t *eff) { ir_node *unknown; + (void) irg; VERBOSE_PRINT((stdout, "create unknown in %s\n", get_id_str(proc -> proc_ident))); @@ -1173,12 +1205,13 @@ static void create_abstract_unknown(ir_graph *irg, proc_t *proc, eff_t *eff) static void create_abstract_call(ir_graph *irg, proc_t *proc, eff_t *eff) { ir_node *sel, *call; - entity *ent; + ir_entity *ent; eff_t *addr; ir_node **irns; int i, num; - type *mtype; + ir_type *mtype; int mik; /* is method somehow known? */ + (void) irg; VERBOSE_PRINT((stdout, "create call in %s\n", get_id_str(proc -> proc_ident))); @@ -1194,7 +1227,7 @@ static void create_abstract_call(ir_graph *irg, proc_t *proc, eff_t *eff) addr = find_valueid_in_proc_effects(eff -> effect.call.valrefid, proc); assert(addr && "no address for load"); - /* if addr is Unknown, set propper mode */ + /* if addr is Unknown, set proper mode */ if(iro_Unknown == get_irn_opcode(addr -> firmnode)) { set_irn_mode(addr -> firmnode, mode_P); } @@ -1202,16 +1235,16 @@ static void create_abstract_call(ir_graph *irg, proc_t *proc, eff_t *eff) if(ent) { /* the address */ sel = new_simpleSel(get_store(), addr -> firmnode, ent); - /* mthod type */ + /* method type */ mtype = get_entity_type(ent); - mik = true; + mik = 1; } else { /* the address */ sel = addr -> firmnode; - /* mthod type */ + /* method type */ mtype = get_unknown_type(); - mik = false; + mik = 0; } /* the args */ @@ -1247,71 +1280,18 @@ static void create_abstract_call(ir_graph *irg, proc_t *proc, eff_t *eff) } } -static void create_abstract_join2 (ir_graph *irg, proc_t *proc, eff_t *eff) -{ - ir_node *unknown = NULL; - ir_node *cond = NULL; - ir_node *phi = NULL; - - ir_node *ins [2]; - ir_node *block [2]; - ir_node *projX [2]; - ir_node *jmp [2]; - - eff_t *in_eff = NULL; - int n_ins = -1; - - VERBOSE_PRINT((stdout, "create join2 in %s\n", - get_id_str(proc -> proc_ident))); - - assert (eff_join == eff->kind); - - n_ins = eff->effect.join.n_ins; - assert (2 == n_ins); - - in_eff = find_valueid_in_proc_effects (eff->effect.join.ins [0], proc); - ins [0] = in_eff->firmnode; - in_eff = find_valueid_in_proc_effects (eff->effect.join.ins [1], proc); - ins [1] = in_eff->firmnode; - - unknown = new_Unknown (mode_Iu); - cond = new_Cond (unknown); - - projX [0] = new_Proj (cond, mode_X, 0); - projX [1] = new_Proj (cond, mode_X, 1); - - mature_immBlock (get_cur_block ()); - - block [0] = new_immBlock (); - add_immBlock_pred (block [0], projX [0]); - jmp [0] = new_Jmp (); - mature_immBlock (block [0]); - - block [1] = new_immBlock (); - add_immBlock_pred (block [1], projX [1]); - jmp [1] = new_Jmp (); - mature_immBlock (block [1]); - - new_Block (2, jmp); - - phi = new_Phi (2, ins, get_irn_mode (ins [0])); - VERBOSE_PRINT ((stdout, "%s: phi.nr = %li\n", __FUNCTION__, get_irn_node_nr (phi))); - - eff->firmnode = phi; - - add_value_to_proc (proc, eff); -} - static void create_abstract_join (ir_graph *irg, proc_t *proc, eff_t *eff) { ir_node **ins = NULL; ir_node *unknown = NULL; ir_node *cond = NULL; ir_node *block = NULL; + ir_node *c_block = NULL; ir_node *phi = NULL; ir_mode *join_md = mode_ANY; int n_ins = -1; int i; + (void) irg; VERBOSE_PRINT((stdout, "create join in %s\n", get_id_str(proc -> proc_ident))); @@ -1319,43 +1299,53 @@ static void create_abstract_join (ir_graph *irg, proc_t *proc, eff_t *eff) assert (eff_join == eff->kind); n_ins = eff->effect.join.n_ins; - /* hmm ... special-case n_ins==2? */ - assert (2 == n_ins); - if (2 == n_ins) { - create_abstract_join2 (irg, proc, eff); - return; - } + /* seems like current_block is not always mature at this point */ + mature_immBlock (get_cur_block ()); + block = get_cur_block (); /* remember this so we can put the ProjXs into it */ + + /* jump based on an unknown condition so all values are possible */ unknown = new_Unknown (mode_Iu); cond = new_Cond (unknown); - block = new_immBlock (); - ins = (ir_node**) malloc (n_ins * sizeof (ir_node*)); + c_block = new_immBlock (); /* for the Phi after the branch(es) */ + + ins = XMALLOCN(ir_node*, n_ins); for (i = 0; i < n_ins; i ++) { - ir_node *s_block = new_immBlock (); - ir_node *projX = new_Proj (cond, mode_X, (long) i); + ir_node *projX = NULL; + ir_node *s_block = NULL; ir_node *jmp = NULL; eff_t *in_eff; + /* make sure the projX is in the 'switch' block */ + set_cur_block (block); + projX = new_Proj (cond, mode_X, (long) i); + + /* this also sets current_block, so the rest of the code ends up there: */ + s_block = new_immBlock (); + add_immBlock_pred (s_block, projX); mature_immBlock (s_block); in_eff = find_valueid_in_proc_effects (eff->effect.join.ins [i], proc); ins [i] = in_eff->firmnode; + + /* need to find a suitable mode for the Phi node */ if (mode_ANY != get_irn_mode (ins [i])) { join_md = get_irn_mode (ins [i]); } jmp = new_Jmp (); - add_immBlock_pred (block, jmp); + add_immBlock_pred (c_block, jmp); } - mature_immBlock (block); - set_cur_block (block); + set_cur_block (c_block); + phi = new_Phi (n_ins, ins, join_md); - memset (ins, 0x00, n_ins * sizeof (ir_node*)); + + mature_immBlock (c_block); free (ins); eff->firmnode = phi; @@ -1363,21 +1353,72 @@ static void create_abstract_join (ir_graph *irg, proc_t *proc, eff_t *eff) add_value_to_proc (proc, eff); } +static void create_abstract_raise (ir_graph *irg, proc_t *proc, eff_t *eff) +{ + ir_node *block = NULL; + ir_node *unknown = NULL; + ir_node *cond = NULL; + + /* seems like current_block is not always mature at this point */ + mature_immBlock (get_cur_block ()); + block = get_cur_block (); /* remember this so we can put the ProjXs into it */ + + /* jump based on an unknown condition so both values are possible */ + unknown = new_Unknown (mode_Iu); + cond = new_Cond (unknown); + + /* one branch for 'throw-exception' case */ + { + ir_node *projX = new_Proj (cond, mode_X, 1L); + ir_node *b_exc = new_immBlock (); + ir_node *obj = NULL; + ir_node *thrw = NULL; + eff_t *thrw_eff = NULL; + + add_immBlock_pred (b_exc, projX); + + thrw_eff = find_valueid_in_proc_effects (eff->effect.raise.valref, proc); + obj = thrw_eff->firmnode; -static void create_abstract_firm(module_t *module, proc_t *proc, entity *fent) + thrw = new_Raise (get_store (), obj); + /* exc-jump to end block */ + thrw = new_Proj (thrw, mode_X, 0L); + + add_immBlock_pred (get_irg_end_block (irg), thrw); + mature_immBlock (get_cur_block ()); + } + + set_cur_block (block); /* back to the first block */ + + /* one branch for 'non-exception' case */ + { + ir_node *projX = new_Proj (cond, mode_X, 0); + new_immBlock (); /* also sets current_block */ + add_immBlock_pred (get_cur_block (), projX); + mature_immBlock (get_cur_block ()); + /* continue building in current_block */ + } + +} + +static void create_abstract_firm(module_t *module, proc_t *proc, ir_entity *fent) { eff_t *eff; ir_graph *irg; int i, num; + (void) module; - /* test entity */ + /* test ir_entity */ assert(visibility_external_allocated == get_entity_visibility(fent) && peculiarity_existent == get_entity_peculiarity(fent) - && "not an abstract entity"); - /* create irg in entity */ - irg = new_ir_graph(fent, 0); + && "not an abstract ir_entity"); + /* create irg in ir_entity */ + irg = new_pseudo_ir_graph(fent, 0); set_irg_inline_property(irg, irg_inline_forbidden); + /* @@@ If the spec says so: */ + set_entity_visibility(fent, visibility_local); + VERBOSE_PRINT((stdout, "create effects for %s\n", get_id_str(proc -> proc_ident))); @@ -1412,13 +1453,16 @@ static void create_abstract_firm(module_t *module, proc_t *proc, entity *fent) case eff_join: create_abstract_join(irg, proc, eff); break; + case eff_raise: + create_abstract_raise(irg, proc, eff); + break; default: assert(0 && "effect not implemented"); break; } } - /* close irg in entity */ + /* close irg in ir_entity */ /* Now we can mature the end block as all it's predecessors are known. */ mature_immBlock (get_irg_end_block(irg)); @@ -1426,7 +1470,7 @@ static void create_abstract_firm(module_t *module, proc_t *proc, entity *fent) VERBOSE_PRINT((stdout, "verify graph\n")); irg_vrfy(irg); VERBOSE_PRINT((stdout, "finalize construction\n")); - finalize_cons (irg); + irg_finalize_cons (irg); } /********************************************************************/ @@ -1435,23 +1479,23 @@ static void assign_firm_entity(module_t *module, entity_t *xmlent) { int i, num; type_t *typ; - type *type; - entity *ent; + ir_type *type; + ir_entity *ent; - VERBOSE_PRINT((stdout, "assign entity %s to typeid %s\n", + VERBOSE_PRINT((stdout, "assign ir_entity %s to typeid %s\n", get_id_str(xmlent -> ent_ident), get_id_str(xmlent -> owner))); typ = find_type_in_module(module, xmlent -> owner); assert(typ && "class not found in module"); type = typ -> f_tp; - assert(is_class_type(type)); + assert(is_Class_type(type)); num = get_class_n_members(type); ent = NULL; for(i = 0; i < num; i++) { ent = get_class_member(type, i); - VERBOSE_PRINT((stdout, "compare entity %s and %s\n", + VERBOSE_PRINT((stdout, "compare ir_entity %s and %s\n", get_id_str(xmlent -> ent_ident), get_entity_name(ent))); if(get_entity_ident(ent) == xmlent -> ent_ident) { @@ -1459,7 +1503,7 @@ static void assign_firm_entity(module_t *module, entity_t *xmlent) } ent = NULL; } - assert(ent && "did not find a entity"); + assert(ent && "did not find a ir_entity"); xmlent -> f_ent = ent; } @@ -1469,7 +1513,7 @@ static void assign_firm_entity(module_t *module, entity_t *xmlent) static void assign_firm_type(type_t *xmltype) { int i; - type *typ = NULL; + ir_type *typ = NULL; int num; VERBOSE_PRINT((stdout, "assign firm type to type %s\n", @@ -1502,9 +1546,9 @@ static void create_abstract_proc_effect(module_t *module, proc_t *proc) { int i, num; - type *class_typ = NULL; + ir_type *class_typ = NULL; type_t *type; - entity *fent; + ir_entity *fent; /* find the class of a procedure */ VERBOSE_PRINT((stdout, "do find owner id %s\n", get_id_str(proc -> ownerid))); @@ -1519,11 +1563,11 @@ void create_abstract_proc_effect(module_t *module, proc_t *proc) for(i = 0; i < num; i++) { class_typ = get_irp_type(i); VERBOSE_PRINT((stdout, "test type %s\n", get_type_name(class_typ))); - if(is_class_type(class_typ) - && (type -> type_ident == get_type_ident(class_typ))) { - /* found class type */ - VERBOSE_PRINT((stdout, "found type %s\n", get_type_name(class_typ))); - break; + if (is_Class_type(class_typ) + && (type -> type_ident == get_type_ident(class_typ))) { + /* found class type */ + VERBOSE_PRINT((stdout, "found type %s\n", get_type_name(class_typ))); + break; } class_typ = NULL; } @@ -1532,10 +1576,10 @@ void create_abstract_proc_effect(module_t *module, proc_t *proc) VERBOSE_PRINT((stdout, "found global type %s\n", get_type_name(class_typ))); } assert(class_typ && "type not found"); - assert(is_class_type(class_typ) && "is not a class type"); + assert(is_Class_type(class_typ) && "is not a class type"); type -> f_tp = class_typ; - /* find entity for procedure in class */ + /* find ir_entity for procedure in class */ VERBOSE_PRINT((stdout, "find method %s\n", get_id_str(proc -> proc_ident))); @@ -1550,13 +1594,22 @@ void create_abstract_proc_effect(module_t *module, proc_t *proc) /* @@@ TODO check args types - not in xml yet */ /* create Firm stuff */ create_abstract_firm(module, proc, fent); - break; + return; } else { fent = NULL; } } - assert(fent && "procedure not found in class"); + + /* fail */ + fprintf(stderr, + "method %s not found\nNo effects generated\nCandidates are:\n", + get_id_str(proc -> proc_ident)); + for(i = 0; i < num; i++) { + fent = get_class_member(class_typ, i); + fprintf(stderr, "%s\n", get_entity_name(fent)); + } + //assert(fent && "procedure not found in class"); } static @@ -1587,12 +1640,13 @@ void create_abstract_module(module_t *module) } -void create_abstraction(const char *filename) +int create_abstraction(const char *filename) { module_t *module; /* read and parse XML file */ - read_extern(filename); + if (! read_extern(filename)) + return 0; /* finished reading and parsing here */ /* build FIRM graphs */ @@ -1611,13 +1665,73 @@ void create_abstraction(const char *filename) entities = NULL; procs = NULL; modules = NULL; + + return 1; } + +void free_abstraction(void) { + int i, n_pseudo_irgs = get_irp_n_pseudo_irgs(); + for (i = 0; i < n_pseudo_irgs; ++i) { + ir_graph *p_irg = get_irp_pseudo_irg(i); + set_entity_visibility(get_irg_entity(p_irg), visibility_external_allocated); + // @@@ free_pseudo_ir_graph(p_irg); + } +} + + /********************************************************************/ /* * $Log$ + * Revision 1.27 2007/02/02 12:38:35 matze + * entity is ir_entity now + * + * Revision 1.26 2006/12/15 12:37:40 matze + * fix warnings + * + * Revision 1.25 2006/06/09 11:26:35 firm + * renamed type to ir_type + * + * Revision 1.24 2006/05/29 13:34:49 beck + * renamed symconst_size to symconst_type_size + * + * Revision 1.22 2005/08/16 10:18:35 beck + * create_abstraction() now returns an error code if the file could not + * be opened. + * + * Revision 1.21 2005/03/10 10:05:38 goetz + * chanmged method name + * + * Revision 1.20 2005/01/05 14:28:35 beck + * renames all is_x*_type() functions to is_X*_type() to prevent name clash with EDG frontend + * + * Revision 1.19 2004/12/10 15:14:34 beck + * used xmalloc instead of malloc + * + * Revision 1.18 2004/12/02 16:21:42 beck + * fixed config.h include + * + * Revision 1.17 2004/11/23 14:17:31 liekweg + * fenced out currently unneeded static functions + * + * Revision 1.16 2004/11/11 12:24:52 goetz + * fixes + * + * Revision 1.15 2004/11/11 09:28:32 goetz + * treat pseudo irgs special + * parse 'local' from xml files + * + * Revision 1.14 2004/11/10 14:42:00 boesler + * be more helpful if a method does not exist + * + * Revision 1.13 2004/11/05 14:00:53 liekweg + * added raise + * + * Revision 1.12 2004/11/02 14:30:31 liekweg + * fixed multi-input join (thx, Boris) --flo + * * Revision 1.11 2004/10/29 18:51:53 liekweg * Added Join *