5 * File name: ir/ana2/pto.c
9 * Created: Mon 18 Oct 2004
11 * Copyright: (c) 1999-2004 Universität Karlsruhe
12 * Licence: This file is protected by GPL - GNU GENERAL PUBLIC LICENSE.
21 # include "pto_util.h"
22 # include "pto_init.h"
29 /* # include "eset.h" */
37 # include "typewalk.h"
38 # include "irmemwalk.h"
40 # define DBGPRINT(lvl, msg) if (get_pto_verbose () > lvl) { fprintf msg; }
41 # define DBGEXE(lvl, cmd) if (get_pto_verbose () > lvl) { cmd; }
46 static void pto_node (ir_node*, void*);
47 static void pto_node_pre (ir_node*, void*);
48 static void pto_node_post (ir_node*, void*);
51 Get the pto infos of a node
53 static pto_t *get_pto (ir_node *node)
57 return ((pto_t*) get_irn_link (node));
61 Propagate pto values up to the given node, and return the propagated
62 value. This recursion has to stop at important nodes, such as
63 loads and allocs, where pto is computed differently (albeit this may
64 involve more calls to this function for a different ptr value).
66 static pto_t *compute_pto (ir_node *node, void *env)
68 pto_t *node_pto = get_pto (node);
70 if ((NULL != node_pto) && (pto_is_dummy (node_pto))) {
71 /* weed out initialisation data as good as possible */
73 DBGPRINT (0, (stdout, "%s: dummy pto for (%s[%li])\n",
75 get_op_name (get_irn_op (node)),
76 get_irn_node_nr (node)));
78 pto_delete (node_pto);
82 if (NULL == node_pto) {
83 DBGPRINT (1, (stdout, "%s: must compute pto for %s[%li]\n",
85 get_op_name (get_irn_op (node)),
86 get_irn_node_nr (node)));
90 node_pto = get_pto (node);
99 Transfer the actual arguments to the given call's formal arguments
101 static void set_call_args (ir_node *call, ir_graph *graph, void *env)
103 ir_node **args = find_irg_args (graph);
106 const int n_call_args = get_irn_arity (call);
108 /* call: M x meth_ptr x Arg x Arg x ... x Arg */
109 /* projT(start): Arg x Arg x ... x Arg */
110 /* projM(start): M */
112 for (i = 2; i < n_call_args; i ++) {
113 if (NULL != args [i-2]) {
114 if (mode_P == get_irn_mode (args [i-2])) {
115 pto_t *arg_pto = compute_pto (get_irn_n (call, i), env);
116 /* off-by-two because of ProjT bd */
117 set_pto (args [i-2], arg_pto);
119 /* not a pointer value */
127 Transfer the return value of a call to the callR node
129 static void get_call_ret (ir_node *call, ir_graph *graph, void *env)
131 entity *ent = get_irg_ent (graph);
132 type *ent_tp = get_entity_type (ent);
134 if (NULL != get_pto (call)) {
135 pto_t *old = get_pto (call);
137 if (pto_is_dummy (old)) {
138 DBGPRINT (2, (stdout, "%s: dummy pto (0x%08x) from call[%li]\n",
139 __FUNCTION__, (int) old, get_irn_node_nr (call)));
145 if (0 != get_method_n_ress (ent_tp)) {
146 type *ent_ret_tp = get_method_res_type (ent_tp, 0);
148 if (mode_P == get_type_mode (ent_ret_tp)) {
149 pto_t *res_pto = get_pto (get_irg_end_block (graph));
151 set_pto (call, res_pto);
158 Take care of a single proj node. Basically a multiplex/dispatch for the
159 different node types that a proj can have as a predecessor.
161 static void pto_node_proj (ir_node *proj, void *env)
164 pto for proj({proj(start),load,call,alloc,raise?,...}) node
166 ir_node *in = get_Proj_pred (proj);
167 const opcode in_op = get_irn_opcode (in);
168 const long proj_proj = get_Proj_proj (proj);
170 DBGPRINT (3, (stdout, "%s: --> Proj[%li] (%s)\n",
172 get_irn_node_nr (proj),
173 get_op_name (get_irn_op (in))));
177 /* nothing (handled by proj(proj)) */
182 if (pn_Load_res == proj_proj) {
183 set_pto (proj, compute_pto (in, env));
185 /* ProjM(load) or ProjX(load) - do nothing */
190 /* ProjM (store) or ProjX (store) - nothing */
194 /* copy from alloc */
195 if (pn_Alloc_res == proj_proj) {
196 set_pto (proj, compute_pto (in, env));
198 /* ProjM(alloc) or ProjX (alloc) -- nothing */
203 /* ProjX (raise), ProjM (raise) -- nothing */
207 if (pn_Call_M_regular == proj_proj) {
208 /* ProjM(call) -- nothing */
209 } else if (pn_Call_T_result == proj_proj) {
210 /* copy return value of call */
211 pto_t *call_pto = get_pto (in); /* get result from call */
213 set_pto (proj, call_pto);
214 } else if (pn_Call_P_value_res_base == proj_proj) {
216 assert (0 && "what's with pn_Call_P_value_res_base?");
218 /* ProjX (call) or ProjM_exc (call) -- nothing */
224 const ir_node *in_in = get_Proj_pred (in);
225 const opcode in_in_op = get_irn_opcode (in_in);
229 /* projP (projT (call)) */
230 /* copy from projT to projP */
231 pto_t *in_pto = compute_pto (in, env);
232 set_pto (proj, in_pto);
235 /* proj(proj(start)) - make sure the arguments are initialised */
236 assert (get_pto (proj));
239 DBGPRINT (1, (stdout, "%s:%i: proj(proj(%s)) not handled\n",
240 __FILE__, __LINE__, get_op_name (get_irn_op (in_in))));
247 /* make sure the input has been analysed */
248 pto_t *cast_pto = compute_pto (in, env);
249 set_pto (proj, cast_pto);
254 fprintf (stderr, "%s: opcode %s of Node %ld not handled\n",
256 get_op_name (get_irn_op (in)),
257 get_irn_node_nr (in));
259 assert (0 && "something not handled");
263 DBGPRINT (2, (stdout, "%s: Proj (%s)\n",
265 get_op_name (get_irn_op (in))));
268 static void pto_node_obj_load (ir_node *load, ir_node *ptr,
269 entity *ent, void *env)
272 pto for obj load node
279 const char *ent_name = (char*) get_entity_name (ent);
280 const char *own_name = (char*) get_type_name (get_entity_owner (ent));
282 DBGPRINT (1, (stdout, "%s for (%s[%li])\n",
284 get_op_name (get_irn_op (ptr)),
285 get_irn_node_nr (ptr)));
287 if (! is_pointer_type (get_entity_type (ent))) {
291 if (NULL != get_pto (load)) {
292 pto_t *old = get_pto (load);
294 if (pto_is_dummy (old)) {
295 DBGPRINT (1, (stdout, "%s: dummy pto (0x%08x) from load[%li]\n",
296 __FUNCTION__, (int) old, get_irn_node_nr (load)));
302 DBGPRINT (1, (stdout, "%s: obj load from ent (0x%08x) \"%s.%s\"\n",
308 pto_t *ptr_objs = compute_pto (ptr, env);
309 qset_t *objs = ptr_objs->objs;
310 pto_t *res = pto_new_empty (load);
311 obj_desc_t *obj_desc = (obj_desc_t*) qset_start (objs);
313 DBGPRINT (1, (stdout, "%s: ptr_pto = ", __FUNCTION__));
314 DBGEXE (1, qset_print (objs, stdout));
316 while (NULL != obj_desc) {
317 qset_t *cnts = pto_lookup (obj_desc, ent);
319 DBGPRINT (1, (stdout, "%s: cnts = ", __FUNCTION__));
320 DBGEXE (1, qset_print (cnts, stdout));
322 pto_add_all_names (res, cnts);
324 obj_desc = (obj_desc_t*) qset_next (objs);
329 DBGPRINT (1, (stdout, "%s\n", __FUNCTION__));
332 static void pto_node_arr_load (ir_node *load, ir_node *ptr,
333 entity *ent, void *env)
336 pto for array load node
339 load.ptr analysed or can be computed on-the-fly
343 const char *ent_name = (char*) get_entity_name (ent);
344 const char *own_name = (char*) get_type_name (get_entity_owner (ent));
346 /* load from array */
347 DBGPRINT (1, (stdout, "%s for (%s[%li])\n",
349 get_op_name (get_irn_op (ptr)),
350 get_irn_node_nr (ptr)));
352 if (! is_pointer_type (get_entity_type (ent))) {
356 DBGPRINT (1, (stdout, "%s: array load from ent (0x%08x) \"%s.%s\"\n",
362 pto_t *ptr_objs = compute_pto (ptr, env);
363 qset_t *objs = ptr_objs->objs;
364 pto_t *res = pto_new_empty (load);
366 obj_desc_t *obj_desc = (obj_desc_t*) qset_start (objs);
368 while (NULL != obj_desc) {
369 qset_t *cnts = pto_lookup (obj_desc, NULL);
371 pto_add_all_names (res, cnts);
373 obj_desc = (obj_desc_t*) qset_next (objs);
379 static void pto_node_load (ir_node *load, void *env)
385 load.ptr analysed or can be computed on-the-fly
389 ir_node *ptr = get_Load_ptr (load);
390 const opcode op = get_irn_opcode (ptr);
393 /* check the funny cases */
394 if (iro_Proj == op) {
395 /* then it's an unused Load(this) (or whatever) and we don't need to look at it */
396 DBGPRINT (1, (stderr, "%s: %s[%li] ignored\n",
398 get_op_name (get_irn_op (ptr)),
399 get_irn_node_nr (ptr)));
401 } else if (iro_Cast == op) {
402 /* then it's (whatever) and we don't know where to look at */
403 DBGPRINT (1, (stderr, "%s: %s[%li] ignored\n",
405 get_op_name (get_irn_op (ptr)),
406 get_irn_node_nr (ptr)));
410 ent = get_ptr_ent (ptr);
414 /* array load or obj load? */
415 if ((iro_Sel == op) && (3 == get_irn_arity (ptr))) {
416 pto_node_arr_load (load, ptr, ent, env);
418 pto_node_obj_load (load, ptr, ent, env);
423 static void pto_node_obj_store (ir_node *store,
430 pto for obj store node
432 so far: ptr analysed or can be computed on-the-fly
438 const char *ent_name = (char*) get_entity_name (ent);
439 const char *own_name = (char*) get_type_name (get_entity_owner (ent));
441 DBGPRINT (1, (stdout, "%s: obj store to ent (0x%08x) \"%s.%s\"\n",
443 (int) ent, own_name, ent_name));
445 pto_t *ptr_pto = compute_pto (ptr, env);
446 pto_t *val_pto = compute_pto (val, env);
447 qset_t *objs = ptr_pto->objs;
448 qset_t *vals = val_pto->objs;
450 obj_desc_t *obj_desc = (obj_desc_t*) qset_start (objs);
452 DBGPRINT (1, (stdout, "%s: ptr_pto = ", __FUNCTION__));
453 DBGEXE (1, qset_print (objs, stdout));
455 DBGPRINT (1, (stdout, "%s: ptr_val = ", __FUNCTION__));
456 DBGEXE (1, qset_print (vals, stdout));
458 while (NULL != obj_desc) {
459 qset_t *cnts = pto_lookup (obj_desc, ent);
461 qset_insert_all (cnts, vals);
463 DBGPRINT (1, (stdout, "%s: cnts = ", __FUNCTION__));
464 DBGEXE (1, qset_print (cnts, stdout));
466 obj_desc = (obj_desc_t*) qset_next (objs);
469 DBGPRINT (1, (stdout, "%s\n", __FUNCTION__));
472 static void pto_node_arr_store (ir_node *store,
479 pto for array store node
481 so far: ptr analysed or can be computed on-the-fly
486 const char *ent_name = (char*) get_entity_name (ent);
487 const char *own_name = (char*) get_type_name (get_entity_owner (ent));
489 DBGPRINT (1, (stdout, "%s: array store to ent (0x%08x) \"%s.%s\"\n",
491 (int) ent, own_name, ent_name));
493 pto_t *ptr_pto = compute_pto (ptr, env);
494 pto_t *val_pto = compute_pto (val, env);
495 qset_t *objs = ptr_pto->objs;
496 qset_t *vals = val_pto->objs;
498 obj_desc_t *obj_desc = (obj_desc_t*) qset_start (objs);
500 while (NULL != obj_desc) {
501 qset_t *cnts = pto_lookup (obj_desc, NULL);
503 qset_insert_all (cnts, vals);
505 obj_desc = (obj_desc_t*) qset_next (objs);
509 static void pto_node_store (ir_node *store, void *env)
514 so far: ptr analysed or can be computed on-the-fly
519 ir_node *ptr = get_Store_ptr (store);
520 ir_node *val = get_Store_value (store);
521 const opcode op = get_irn_opcode (ptr);
522 entity *ent = get_ptr_ent (ptr);
524 if (mode_P != get_irn_mode (val)) {
528 /* array load or obj load? */
529 if ((iro_Sel == op) && (3 == get_irn_arity (ptr))) {
530 pto_node_arr_store (store, ptr, ent, val, env);
532 pto_node_obj_store (store, ptr, ent, val, env);
537 static void pto_node_alloc (ir_node *alloc, void *env)
542 so far: nothing to do
547 if (NULL == get_pto (alloc)) {
548 type *tp = get_Alloc_type (alloc);
550 pto_t *alloc_pto = pto_new_name (alloc, tp);
551 set_pto (alloc, alloc_pto);
552 DBGPRINT (0, (stdout, "%s (%s[%li]): new pto\n",
554 get_op_name (get_irn_op (alloc)),
555 get_irn_node_nr (alloc)));
557 DBGPRINT (0, (stdout, "%s (%s[%li]): reusing pto\n",
559 get_op_name (get_irn_op (alloc)),
560 get_irn_node_nr (alloc)));
565 static void pto_node_free (ir_node *free, void *env)
570 so far: ptr analysed or can be computed on-the-fly
574 /* still, copy somthing */
575 ir_node *ptr = get_Free_ptr (free);
577 pto_t *ptr_pto = compute_pto (ptr, env);
578 set_pto (free, ptr_pto);
581 static void pto_node_raise (ir_node *raise, void *env)
586 so far: ptr analysed or can be computed on-the-fly
591 /* right now, just copy something */
592 ir_node *ptr = get_Raise_exo_ptr (raise);
594 pto_t *ptr_pto = compute_pto (ptr, env);
596 set_pto (raise, ptr_pto);
599 static void pto_node_sel (ir_node *sel, void *env)
604 so far: input selected or can be computed on-the-fly
606 just copy (the selected entity is used in the load/store)
609 ir_node *sel_in = get_Sel_ptr (sel);
610 pto_t *sel_pto = compute_pto (sel_in, env);
612 if (NULL == sel_pto) {
613 fprintf (stdout, "%s:%i: sel.in = %s[%li]\n",
614 __FUNCTION__, __LINE__,
615 get_op_name (get_irn_op (sel_in)),
616 get_irn_node_nr (sel_in));
620 set_pto (sel, sel_pto);
623 static void pto_node_call (ir_node *call, void *env)
625 ir_graph *graph = NULL;
626 ir_node *ptr = get_Call_ptr (call);
627 entity *ent = get_ptr_ent (ptr);
629 DBGPRINT (1, (stdout, "%s (%s[%li])\n",
631 get_op_name (get_irn_op (call)),
632 get_irn_node_nr (call)));
635 const char *ent_name = (char*) get_entity_name (ent);
636 const char *own_name = (char*) get_type_name (get_entity_owner (ent));
638 /* Todo: Iterate over all graphs in 'get_implementing_graphs' */
639 graph = get_entity_irg (ent);
641 if (! get_irg_is_mem_visited (graph)) {
642 DBGPRINT (1, (stdout, " -> visit graph (0x%08x) of \"%s.%s\"\n",
643 (int) graph, own_name, ent_name));
645 /* compute call arguments */
646 set_call_args (call, graph, env);
647 /* traverse callEd */
648 irg_walk_mem (graph, pto_node_pre, pto_node_post, NULL);
649 /* maybe get result from called graph */
650 get_call_ret (call, graph, env);
653 DBGPRINT (0, (stdout, "%s:%i: Warning: no graph for ent \"%s.%s\" in call[%li]\n",
654 __FILE__, __LINE__, own_name, ent_name, get_irn_node_nr (call)));
658 static void pto_node_ret (ir_node *ret, void *env)
664 input should be availlable
669 if ((0 != get_Return_n_ress (ret)) &&
670 (mode_P == get_irn_mode (get_Return_res (ret, 0)))) {
671 ir_node *ret_in = get_Return_res (ret, 0);
673 pto_t *ret_pto = compute_pto (ret_in, env);
675 DBGPRINT (4, (stdout, "--> Return Node (%ld) (%s)\n",
676 get_irn_node_nr (ret),
677 get_op_name (get_irn_op (ret))));
679 set_pto (ret, ret_pto);
685 static void pto_node_phi (ir_node *phi, void *env)
691 all ins present or can be computed on-the-fly
697 int n_ins = get_irn_arity (phi);
700 if (mode_P != get_irn_mode (phi)) {
704 assert (0 && "test phi");
706 pto_t *phi_pto = get_pto (phi);
708 if (NULL == phi_pto) {
709 phi_pto = pto_new_empty (phi);
710 set_pto (phi, phi_pto);
713 for (i = 0; i < n_ins; i ++) {
714 in = get_irn_n (phi, i);
716 pto_t *in_pto = compute_pto (in, env);
718 DBGPRINT (0, (stdout, "%s: IN PHI Node (%ld) (%s) (pto = 0x%08x)\n",
720 get_irn_node_nr (in),
721 get_op_name (get_irn_op (in)),
724 qset_insert_all (phi_pto->objs, in_pto->objs);
728 static void pto_node_cnst (ir_node *cnst, void *env)
735 if this represents something nameable, name it
737 type *tp = get_Const_type (cnst);
738 pto_t *cnst_pto = pto_new_name (cnst, tp); /* WRONG */
741 set_pto (cnst, cnst_pto);
744 static void pto_node_sym_cnst (ir_node *sym_cnst, void *env)
751 if this represents something nameable, name it
753 entity *ent = get_SymConst_entity (sym_cnst);
754 type *tp = get_entity_type (ent);
756 if (is_pointer_type (tp)) {
757 tp = get_pointer_points_to_type (tp);
758 pto_t *sym_cnst_pto = (pto_t*) get_entity_link (ent);
760 DBGPRINT (2, (stdout, "%s: SymConst (%ld) (%s)\n",
762 get_irn_node_nr (sym_cnst),
763 get_op_name (get_irn_op (sym_cnst))));
766 if (NULL == sym_cnst_pto) {
767 sym_cnst_pto = pto_new_name (sym_cnst, tp);
769 DBGPRINT (1, (stdout, "%s: SymConst (%ld) (%s): NEW PTO\n",
771 get_irn_node_nr (sym_cnst),
772 get_op_name (get_irn_op (sym_cnst))));
774 set_entity_link (ent, sym_cnst_pto);
776 DBGPRINT (1, (stdout, "%s: SymConst (%ld) (%s): reusing pto\n",
778 get_irn_node_nr (sym_cnst),
779 get_op_name (get_irn_op (sym_cnst))));
782 set_pto (sym_cnst, sym_cnst_pto);
788 static void pto_node_end_block (ir_node *end, void *env)
793 so far: all returns are set or can be computed on-the-fly
795 collect results, set to node.
797 entity *ent = get_irg_entity (get_irn_irg (end));
798 type *tp = get_entity_type (ent);
800 DBGPRINT (2, (stdout, "%s: End Block (%ld) (%s)\n",
802 get_irn_node_nr (end),
803 get_op_name (get_irn_op (end))));
805 if (0 != get_method_n_ress (tp)) {
806 tp = get_method_res_type (tp, 0);
808 if (mode_P == get_type_mode (tp)) {
810 int n_ins = get_irn_arity (end);
811 pto_t *end_pto = pto_new_empty (end);
813 for (i = 0; i < n_ins; i ++) {
814 ir_node *ret = get_irn_n (end, i);
816 if (iro_Return == get_irn_opcode (ret)) {
817 pto_t *ret_pto = get_pto (ret);
820 pto_add_all_names (end_pto, ret_pto->objs);
824 set_pto (end, end_pto);
830 Take care of a single node. Basically a multiplex/dispatch for the
831 different node types.
833 static void pto_node (ir_node *node, void *env)
835 const opcode op = get_irn_opcode (node);
837 DBGPRINT (1, (stdout, "%s (%s[%li])\n",
839 get_op_name (get_irn_op (node)),
840 get_irn_node_nr (node)));
844 /* pto_node_start (node, env); */
849 pto_node_load (node, env);
853 pto_node_store (node, env);
857 pto_node_alloc (node, env);
861 pto_node_free (node, env);
865 pto_node_raise (node, env);
869 pto_node_sel (node, env);
873 /* assert (0 && "calls must be handled in main loop"); */
874 pto_node_call (node, env);
877 if (0 < get_Return_n_ress (node)) {
878 pto_node_ret (node, env);
882 pto_node_proj (node, env);
885 pto_node_phi (node, env);
888 pto_node_cnst (node, env);
890 case (iro_SymConst): {
891 pto_node_sym_cnst (node, env);
894 pto_t *cast_pto = compute_pto (get_Cast_op (node), env);
895 set_pto (node, cast_pto);
899 pto_node_end_block (node, env);
901 /* all the uninteresting stuff */
906 set_pto (node, NULL);
909 /* stopgap measure */
910 DBGPRINT (0, (stdout, "%s: not handled: node[%li].op = %s\n",
912 get_irn_node_nr (node),
913 get_op_name (get_irn_op (node))));
914 assert (0 && "something not handled");
918 static void pto_node_pre (ir_node *node, void *env)
920 DBGPRINT (1, (stdout, "%s (%s[%li])\n",
922 get_op_name (get_irn_op (node)),
923 get_irn_node_nr (node)));
925 pto_init_node (node);
928 static void pto_node_post (ir_node *node, void *env)
930 DBGPRINT (1, (stdout, "%s (%s[%li])\n",
932 get_op_name (get_irn_op (node)),
933 get_irn_node_nr (node)));
935 pto_node (node, env);
938 static int pto_verbose = 0;
941 Helper to pto_init --- clear the link fields of class types
943 static void clear_type_link (type_or_ent *thing, void *__unused)
945 if (is_type (thing)) {
946 type *tp = (type*) thing;
948 if (is_class_type (tp)) {
949 DBGPRINT (1, (stdout, "%s (\"%s\")\n",
950 __FUNCTION__, get_type_name (tp)));
952 set_type_link (tp, NULL);
954 } else if (is_entity (thing)) {
955 entity *ent = (entity*) thing;
957 DBGPRINT (1, (stdout, "%s (\"%s\")\n",
958 __FUNCTION__, get_entity_name (ent)));
960 set_entity_link (ent, NULL);
965 Helper to pto_cleanup --- deallocate the field closure lists and clear the link fields of class types
967 static void free_field_list (type_or_ent *thing, void *__unused)
970 type *tp = (type*) thing;
972 if (is_class_type (tp)) {
973 if (NULL != get_type_link (tp)) {
974 entity **fields = (entity**) get_type_link (tp);
979 set_type_link (tp, NULL);
985 void set_pto (ir_node *node, pto_t *pto)
989 set_irn_link (node, (void*) pto);
992 int get_pto_verbose ()
994 return (pto_verbose);
997 void set_pto_verbose (int verbose)
999 pto_verbose = verbose;
1007 type_walk (clear_type_link, NULL, NULL);
1014 void pto_run (int do_verbose)
1017 set_pto_verbose (do_verbose);
1018 set_pto_verbose (2);
1020 DBGPRINT (0, (stdout, "START PTO\n"));
1022 ir_graph *graph = get_irp_main_irg ();
1024 DBGPRINT (0, (stdout, "START GRAPH (0x%08x) of \"%s.%s\"\n",
1026 get_type_name (get_entity_owner (get_irg_entity (graph))),
1027 get_entity_name (get_irg_entity (graph))));
1029 /* Set args for main graph */
1031 type *meth_tp = get_entity_type (get_irg_entity (graph));
1032 type *param_tp = get_method_param_type (meth_tp, 1);
1033 param_tp = get_pointer_points_to_type (param_tp);
1035 const long n_args = /* wtf? */
1036 get_method_n_params (meth_tp);
1037 ir_node **args = find_irg_args (graph);
1038 pto_t *main_pto = pto_new_name (args [1], param_tp);
1041 for (i = 0; i < n_args; i ++) {
1042 DBGPRINT (2, (stdout, "arg [%i] = %s[%ld]\n",
1044 args [i] ? get_op_name (get_irn_op (args [i])) : "none",
1045 args [i] ? get_irn_node_nr (args [i]) : -1));
1047 set_pto (args [1], main_pto);
1052 irg_walk_mem (graph, pto_node_pre, pto_node_post, NULL);
1054 DBGPRINT (0, (stdout, "END GRAPH (0x%08x)\n", (int) graph));
1055 DBGPRINT (0, (stdout, "END PTO\n"));
1057 obj_desc_list_all (NULL);
1065 type_walk (free_field_list, NULL, NULL);
1072 * Revision 1.6 2004/11/09 16:47:09 liekweg
1073 * fix SymConst handling
1075 * Revision 1.5 2004/11/08 12:33:06 liekweg
1076 * initialisation; sanitize print levels, misc fixes
1078 * Revision 1.4 2004/11/04 14:58:38 liekweg
1079 * expanded pto, added initialisation, added debugging printing
1081 * Revision 1.3 2004/10/25 11:59:45 liekweg
1084 * Revision 1.2 2004/10/21 11:09:37 liekweg
1085 * Moved memwalk stuf into irmemwalk
1086 * Moved lset stuff into lset
1087 * Moved typalise stuff into typalise
1089 * Revision 1.1 2004/10/20 14:59:42 liekweg
1090 * Added ana2, added ecg and pto