X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fana%2Fcdep.c;h=4d35b2e04d4e6c304e026003f55f51ce4b1c1406;hb=dee4107044b8f1be361d35c405371e083cc740c3;hp=7ca868aec15d04e7aa9863b3d449c2f8dec93d77;hpb=3ea053779e18f3a0a2fcead621f7d610de8531c1;p=libfirm diff --git a/ir/ana/cdep.c b/ir/ana/cdep.c index 7ca868aec..4d35b2e04 100644 --- a/ir/ana/cdep.c +++ b/ir/ana/cdep.c @@ -1,3 +1,27 @@ +/* + * Copyright (C) 1995-2007 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 Implementation of cdep + * @version $Id$ + */ #include #include #include "irdom.h" @@ -5,50 +29,54 @@ #include "irgwalk.h" #include "irnode.h" #include "pmap.h" +#include "obst.h" #include "xmalloc.h" #include "cdep.h" #include "irprintf.h" +#include "irdump.h" -typedef unsigned int uint; +typedef struct cdep_info { + pmap *cdep_map; /**< A map to find the list of all control dependence nodes for a block. */ + struct obstack obst; /**< An obstack where all cdep data lives on. */ +} cdep_info; -static pmap *cdep_map; +static cdep_info *cdep_data; -cdep *find_cdep(const ir_node *block) -{ - return pmap_get(cdep_map, (void *)block); +/* Return a list of all control dependences of a block. */ +ir_cdep *find_cdep(const ir_node *block) { + return pmap_get(cdep_data->cdep_map, (void *)block); } - -void exchange_cdep(ir_node *old, const ir_node *nw) -{ - cdep *cdep = find_cdep(nw); - - pmap_insert(cdep_map, old, cdep); +/* Replace the control dependence info of old by the info of nw. */ +void exchange_cdep(ir_node *old, const ir_node *nw) { + ir_cdep *cdep = find_cdep(nw); + pmap_insert(cdep_data->cdep_map, old, cdep); } - -static void add_cdep(ir_node* node, ir_node* dep_on) -{ - cdep *dep = find_cdep(node); +/** + * Adds a control dependence from node to dep_on. + */ +static void add_cdep(ir_node *node, ir_node *dep_on) { + ir_cdep *dep = find_cdep(node); #if 0 ir_fprintf(stderr, "Adding cdep of %+F on %+F\n", node, dep_on); #endif if (dep == NULL) { - cdep *newdep = xmalloc(sizeof(*newdep)); + ir_cdep *newdep = obstack_alloc(&cdep_data->obst, sizeof(*newdep)); newdep->node = dep_on; newdep->next = NULL; - pmap_insert(cdep_map, node, newdep); + pmap_insert(cdep_data->cdep_map, node, newdep); } else { - cdep *newdep; + ir_cdep *newdep; for (;;) { if (dep->node == dep_on) return; if (dep->next == NULL) break; dep = dep->next; } - newdep = xmalloc(sizeof(*newdep)); + newdep = obstack_alloc(&cdep_data->obst, sizeof(*newdep)); newdep->node = dep_on; newdep->next = NULL; dep->next = newdep; @@ -63,11 +91,10 @@ typedef struct cdep_env { /** * Pre-block-walker: calculate the control dependence */ -static void cdep_pre(ir_node *node, void *ctx) -{ +static void cdep_pre(ir_node *node, void *ctx) { cdep_env *env = ctx; - uint n; - uint i; + unsigned int n; + unsigned int i; /* special case: * start and end block have no control dependency @@ -92,14 +119,12 @@ static void cdep_pre(ir_node *node, void *ctx) } -#include "irdump.h" - /** * A block edge hook: add all cdep edges of block. */ static int cdep_edge_hook(FILE *F, ir_node *block) { - cdep *cd; + ir_cdep *cd; #if 0 ir_node *pdom = get_Block_ipostdom(block); @@ -124,17 +149,23 @@ static int cdep_edge_hook(FILE *F, ir_node *block) return 0; } - -void compute_cdep(ir_graph *irg) -{ +/* Compute the control dependence graph for a graph. */ +void compute_cdep(ir_graph *irg) { ir_node *start_block, *rem; cdep_env env; - cdep_map = pmap_create(); + free_cdep(irg); + cdep_data = xmalloc(sizeof(*cdep_data)); + obstack_init(&cdep_data->obst); + + cdep_data->cdep_map = pmap_create(); assure_postdoms(irg); - /* we must temporary change the post dominator relation */ + /* we must temporary change the post dominator relation: + the ipdom of the startblock is the end block. + Firm does NOT add the phantom edge from Start to End. + */ start_block = get_irg_start_block(irg); rem = get_Block_ipostdom(start_block); set_Block_ipostdom(start_block, get_irg_end_block(irg)); @@ -155,16 +186,20 @@ void compute_cdep(ir_graph *irg) set_Block_ipostdom(start_block, rem); } - -void free_cdep(ir_graph *irg) -{ - // TODO atm leaking more memory than a small memory leaking animal +/* Free the control dependence info. */ +void free_cdep(ir_graph *irg) { + (void) irg; + if (cdep_data != NULL) { + pmap_destroy(cdep_data->cdep_map); + obstack_free(&cdep_data->obst, NULL); + xfree(cdep_data); + cdep_data = NULL; + } } - -int is_cdep_on(const ir_node *dependee, const ir_node *candidate) -{ - const cdep *dep; +/* Check whether dependee is (directly) control dependent on candidate. */ +int is_cdep_on(const ir_node *dependee, const ir_node *candidate) { + const ir_cdep *dep; for (dep = find_cdep(dependee); dep != NULL; dep = dep->next) { if (dep->node == candidate) return 1; @@ -172,10 +207,9 @@ int is_cdep_on(const ir_node *dependee, const ir_node *candidate) return 0; } - -int is_iterated_cdep_on(ir_node *dependee, ir_node *candidate) -{ - const cdep *dep; +/* Check whether dependee is (possible iterated) control dependent on candidate. */ +int is_iterated_cdep_on(ir_node *dependee, ir_node *candidate) { + const ir_cdep *dep; while ((dep = find_cdep(dependee)) != NULL) { if (dep->next != NULL) return 0; @@ -185,18 +219,16 @@ int is_iterated_cdep_on(ir_node *dependee, ir_node *candidate) return 0; } - -ir_node *get_unique_cdep(const ir_node *block) -{ - cdep *cdep = find_cdep(block); +/* If block is control dependent on exactly one node, return this node, else NULL. */ +ir_node *get_unique_cdep(const ir_node *block) { + ir_cdep *cdep = find_cdep(block); return cdep != NULL && cdep->next == NULL ? cdep->node : NULL; } - -int has_multiple_cdep(const ir_node *block) -{ - cdep *cdep = find_cdep(block); +/* Check if the given block is control dependent of more than one node. */ +int has_multiple_cdep(const ir_node *block) { + ir_cdep *cdep = find_cdep(block); return cdep != NULL && cdep->next != NULL; }