2 * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief Walker that touches all Firm data structures
23 * @author Sebastian Felis
47 /** obstack for firm walker */
48 static struct obstack fw_obst;
50 /** This map stores all types of firm */
51 static pmap *type_map = NULL;
52 /** This map stores all entities of firm */
53 static pmap *entity_map = NULL;
55 /** Internal data structure of firm walker to collect
56 * some information of firm ir. The collected data will be stored
57 * into the link field of ir node. All graphs have a list of its
58 * blocks and all blocks have a list of their nodes. */
60 ir_node **list; /**< List of blocks or nodes */
61 void *link; /**< Public link field. The public link field of firm nodes
62 is wrapped by set_firm_walk_link and
63 get_firm_walk_link. */
67 /** Access macros to fw_data structure */
68 #define FW_GET_DATA_LIST(s) ((s)->list)
69 #define FW_SET_DATA_LIST(s, t) ((s)->list = (t))
70 #define FW_GET_DATA_LINK(s) ((s)->link)
71 #define FW_SET_DATA_LINK(s, t) ((s)->link = (t))
74 /** Returns own data struct of the firm walker.
76 * If no structure defined (firm link is NULL) allocate a new
77 * struct to the fgd obstack. Only ir graph and block nodes
78 * will allocate this structure.
79 * - ir graph collect its block
80 * - block collect its nodes
83 fw_data *fw_get_data(void *thing)
88 switch (get_kind(thing)) {
90 data = get_irg_link(thing);
91 /* init block list of graph */
94 /* allocate new firm walk structure */
95 data = obstack_alloc(&fw_obst, sizeof(fw_data));
96 memset(data, 0, sizeof(fw_data));
97 set_irg_link(thing, data);
98 /* allocate block list */
99 FW_GET_DATA_LIST(data) = NEW_ARR_F(ir_node *, 0);
103 /* init node list of block */
106 data = get_irn_link(thing);
109 /* allocate new firm walk structure */
110 data = obstack_alloc(&fw_obst, sizeof(fw_data));
111 memset(data, 0, sizeof(fw_data));
112 set_irn_link(thing, data);
113 /* allocate node list */
114 FW_GET_DATA_LIST(data) = NEW_ARR_F(ir_node *, 0);
118 default: {} /* other kinds of firm nodes */
124 /** Free all collected data in ir graphs and nodes.
125 * An ir graph or an ir block node has a list as a
126 * dynamic array, which will be deleted here. */
128 void fw_free_data(void *thing)
130 fw_data *data = NULL;
134 switch (get_kind(thing)) {
136 data = get_irg_link(thing);
137 /* delete block list of graph */
140 DEL_ARR_F(FW_GET_DATA_LIST(data));
141 set_irg_link(thing, NULL);
145 /* delete node list of block */
148 data = get_irn_link(thing);
151 DEL_ARR_F(FW_GET_DATA_LIST(data));
152 set_irn_link(thing, NULL);
156 default: {} /* other kinds of firm nodes */
160 /* documentation in header file */
161 void set_firm_walk_link(void *thing, void *link)
166 switch (get_kind(thing)) {
168 set_entity_link(thing, link);
171 set_type_link(thing, link);
174 data = fw_get_data(thing);
175 FW_SET_DATA_LINK(data, link);
180 data = fw_get_data(thing);
181 FW_SET_DATA_LINK(data, link);
184 set_irn_link(thing, link);
187 set_mode_link(thing, link);
189 default: {} /* other kinds of firm nodes */
193 /* documentation in header file */
194 void *get_firm_walk_link(void *thing)
198 switch (get_kind(thing)) {
200 return get_entity_link(thing);
202 return get_type_link(thing);
204 data = fw_get_data(thing);
205 return FW_GET_DATA_LINK(data);
209 data = fw_get_data(thing);
210 return FW_GET_DATA_LINK(data);
213 return get_irn_link(thing);
215 return get_mode_link(thing);
221 /** Fill maps of type and entity.
222 * This function will be called by the firm walk initializer
223 * to collect all types and entities of program's firm ir.
224 * All types will be collected in the hash table type_map
225 * and all entity are stored in entity_map. The mode of an
226 * type will be collected as well.
228 * @param tore Type or entity
229 * @param env Environment pointer (currently unused)
232 void fw_collect_tore(type_or_ent *tore, void *env)
237 switch (get_kind(tore)) {
239 ent = (ir_entity *)tore;
240 /* append entity to list */
241 set_entity_link(ent, NULL);
242 if (!pmap_contains(entity_map, ent))
243 pmap_insert(entity_map, ent, env);
246 tp = (ir_type *)tore;
248 /* append type to list */
249 set_type_link(tp, NULL);
250 if (!pmap_contains(type_map, tp))
251 pmap_insert(type_map, tp, env);
257 /** Collect all data from nodes. Block appends itself to
258 * the corresponding ir graph and other nodes appends itself
259 * to block list. Collects also the modes of each node to get
262 * @param irn IR node pointer.
263 * @param env Environment pointer (currently unused)
266 void fw_collect_irn(ir_node *irn, void *env)
272 /* add this block to ir graph's block list */
273 data = fw_get_data(get_current_ir_graph());
274 ARR_APP1(ir_node *, FW_GET_DATA_LIST(data), irn);
276 /* non block nodes */
278 /* add this node to block's node list */
279 ir_node *block = get_nodes_block(irn);
280 data = fw_get_data(block);
281 ARR_APP1(ir_node *, FW_GET_DATA_LIST(data), irn);
285 /** Irg walker function to free all collected data from nodes */
287 void fw_free_colleted_data(ir_node *irn, void *env)
289 /* Free node list from blocks */
296 /** Initialize all walking data.
298 * Collect all specific data like types, entities, ir graphs, blocks, nodes
299 * from current firm structures.
301 void firm_walk_init(firm_walk_flags flags)
306 obstack_init(&fw_obst);
308 /* Init map of type and entity. If map or list
309 already exists, free it. */
311 pmap_destroy(type_map);
312 type_map = pmap_create();
315 pmap_destroy(entity_map);
316 entity_map = pmap_create();
318 /* Collect all types (also unused types) if flag is set */
319 if (FW_WITH_ALL_TYPES & flags)
320 type_walk(fw_collect_tore, NULL, NULL);
322 /* for each ir graph */
323 for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
324 ir_graph *irg = get_irp_irg(i);
325 set_irg_link(irg, NULL);
327 type_walk_irg(irg, fw_collect_tore, NULL, NULL);
329 irg_walk_graph(irg, firm_clear_link, fw_collect_irn, NULL);
333 /** This function should call after using the firm walker to free
334 * all collected data and frees the used obstack */
335 void firm_walk_finalize(void)
339 /* free all used maps and lists */
340 pmap_destroy(type_map);
342 pmap_destroy(entity_map);
345 /* free all collected data from ir graphs and nodes */
346 for (i = 0; i < get_irp_n_irgs(); i++)
348 ir_graph *irg = get_irp_irg(i);
350 irg_walk_graph(get_irp_irg(i), NULL, fw_free_colleted_data, NULL);
354 obstack_free(&fw_obst, NULL);
357 /** Dumps the firm ir.
359 * After initializing the firm walker by calling firm_walk_init()
360 * the firm structure could be accessed by defining the firm walk interface
361 * wif. This function could be called several times to customize the
362 * walk order or definitions.
364 * @param wif Walk interface which contains the callback function
366 * @see firm_walk_interface */
367 void firm_walk(firm_walk_interface *wif)
369 int mode_i, irg_i, block_i, block_list_len, irn_i, irn_list_len;
372 ir_node *block, **block_list, **irn_list;
373 ir_graph *saved_irg = current_ir_graph;
375 assert(wif && "firm_walk() in firmwalk.c: No walking interface defined!");
377 /* walk over all modes */
378 if (wif->do_mode_init) wif->do_mode_init(wif->env);
381 for (mode_i = get_irp_n_modes() - 1; mode_i >= 0; --mode_i)
382 wif->do_mode(get_irp_mode(mode_i), wif->env);
384 if (wif->do_mode_finalize) wif->do_mode_finalize(wif->env);
386 /* walk over all types */
387 if (wif->do_type_init) wif->do_type_init(wif->env);
390 for (entry = pmap_first(type_map); entry; entry = pmap_next(type_map))
391 wif->do_type((ir_type *)entry->key, wif->env);
393 if (wif->do_type_finalize) wif->do_type_finalize(wif->env);
395 /* walk over all entities */
396 if (wif->do_entity_init) wif->do_entity_init(wif->env);
399 for (entry = pmap_first(entity_map); entry; entry = pmap_next(entity_map))
400 wif->do_entity((ir_entity *)entry->key, wif->env);
402 if (wif->do_entity_finalize) wif->do_entity_finalize(wif->env);
405 /* Dump graphs ================================================= */
406 if (wif->do_graph_init) wif->do_graph_init(wif->env);
408 for (irg_i = 0; irg_i < get_irp_n_irgs(); irg_i++)
410 current_ir_graph = get_irp_irg(irg_i);
412 /* walk over all ir graph */
413 if (wif->do_graph) wif->do_graph(current_ir_graph, wif->env);
415 /* walk over all irg's block nested ========================== */
416 data = fw_get_data(current_ir_graph);
417 block_list = FW_GET_DATA_LIST(data);
418 block_list_len = ARR_LEN(block_list);
419 for (block_i = 0; block_i < block_list_len; block_i++)
421 if (wif->do_block_init) wif->do_block_init(current_ir_graph, wif->env);
423 block = (ir_node *)block_list[block_i];
424 if (wif->do_block) wif->do_block(block, wif->env);
426 /* walk over all block's ir nodes nested =================== */
427 data = fw_get_data(block);
428 irn_list = FW_GET_DATA_LIST(data);
429 irn_list_len = ARR_LEN(irn_list);
431 /* call block as prefix ir node */
432 if ((wif->do_node) &&
433 (wif->flags & (FW_DUMP_BLOCK_AS_IRN | FW_DUMP_IRN_IN_PREFIX)))
434 wif->do_node(block, wif->env);
436 /* do ir nodes in prefix or postfix order? */
437 if (wif->flags & FW_DUMP_IRN_IN_PREFIX)
438 irn_i = irn_list_len-1;
442 while (irn_i >= 0 && irn_i < irn_list_len)
444 if (wif->do_node) wif->do_node((ir_node *)irn_list[irn_i], wif->env);
446 /* do ir nodes in prefix or postfix order? */
447 if (wif->flags & FW_DUMP_IRN_IN_PREFIX)
452 /* call block as postfix ir node */
453 if ((wif->do_node) &&
454 ((wif->flags & (FW_DUMP_BLOCK_AS_IRN | FW_DUMP_IRN_IN_PREFIX))
455 == FW_DUMP_BLOCK_AS_IRN))
456 wif->do_node(block, wif->env);
458 /* wall over all block's ir nodes nested end =============== */
460 if(wif->do_block_post)
461 wif->do_block_post(block, wif->env);
463 } /* for each block */
465 if (wif->do_block_finalize)
466 wif->do_block_finalize(current_ir_graph, wif->env);
468 /* walk over all irg's block nested end ====================== */
469 if(wif->do_graph_post)
470 wif->do_graph_post(current_ir_graph, wif->env);
472 } /* for each ir graph irg */
474 if(wif->do_graph_finalize)
475 wif->do_graph_finalize(wif->env);
477 /** ### ToDo: Dump const_code_irg ?? No! Dump const code with entities, types etc. */
479 /* restore the state of current_ir_graph */
480 current_ir_graph = saved_irg;