normalized various syntactic constructs for firm jni.

changed functiontype in irgwalk to not include the pointer *.
This can be removed if crecoder includes a type analysis so that
it can find out whether a typedef is a pointer.

[r509]

TODO

+  * 29.10.2002 Goetz
+    Representation of value compounds is not good, especially with
+    calls.
+
+  * 29.10.2002 Goetz
+    We can not represent bitfield members of structs in C.
+    A struct can have fields with n bits, n e.g. set to 3...
+
+  * 29.10.2002 Goetz
+    If parameter variables are dereferenced they must be represented
+    by an entity in the stack frame type.  We need a mechanism to
+    find out which fields were parameters so that the parameter
+    passing space on the frame can be used for the parameters.
+
   + 19.11.2001 Goetz
     SymConst mit ident taugt nicht:  Wenn man z.B. die Prozedur kennt
     sollte man die entitaet der Prozedur angeben koennen.  Ermoeglicht

ir/ana/cgana.c

@@ -239,7 +239,7 @@ static void sel_methods_init(void) {
       pmap_insert(ldname_map, (void *) get_entity_ld_ident(ent), ent);
     }
   }
-  all_irg_walk((irg_walk_func) sel_methods_walker, NULL, ldname_map);
+  all_irg_walk((irg_walk_func *) sel_methods_walker, NULL, ldname_map);
   pmap_destroy(ldname_map);
 }
 
@@ -622,7 +622,7 @@ static entity ** get_free_methods(void) {
     if (get_entity_visibility(ent) != local) {
       eset_insert(set, ent);
     }
-    irg_walk_graph(irg, NULL, (irg_walk_func) free_ana_walker, set);
+    irg_walk_graph(irg, NULL, (irg_walk_func *) free_ana_walker, set);
   }
   /* Hauptprogramm ist auch frei, auch wenn es nicht "external
    * visible" ist. */
@@ -676,7 +676,7 @@ void opt_call_addrs(void) {
       pmap_insert(ldname_map, (void *) get_entity_ld_ident(ent), ent);
     }
   }
-  all_irg_walk((irg_walk_func) sel_methods_walker, NULL, ldname_map);
+  all_irg_walk((irg_walk_func *) sel_methods_walker, NULL, ldname_map);
   pmap_destroy(ldname_map);
 #endif
 }

ir/ana/irloop_t.h

@@ -8,7 +8,7 @@
 
 /* $Id$ */
 
-#include "common.h"
+#include "firm_common.h"
 #include "irloop.h"
 
 #ifndef _IRLOOP_T_H_

ir/ana/irouts.c

@@ -64,8 +64,8 @@ INLINE ir_node *get_Block_cfg_out  (ir_node *bl, int pos) {
   return NULL;
 }
 
-void irg_out_walk_2(ir_node *node,  void (pre)(ir_node*, void*),
-		    void (post)(ir_node*, void*), void *env) {
+void irg_out_walk_2(ir_node *node,  irg_walk_func *pre,
+		    irg_walk_func *post, void *env) {
   int i;
   ir_node *succ;
 

ir/ana/irouts.h

@@ -15,7 +15,6 @@
 # include "irgraph.h"
 # include "irnode.h"
 
-
 /**********************************************************************/
 /** Accessing the out datastructures.                                **/
 /** These routines only work properly if the ir_graph is in state    **/
@@ -37,18 +36,22 @@ int             get_Block_n_cfg_outs (ir_node *node);
 /* Access predecessor n. */
 INLINE ir_node *get_Block_cfg_out  (ir_node *node, int pos);
 
+#ifndef _IRG_WALK_FUNC_TYPEDEF_
+#define _IRG_WALK_FUNC_TYPEDEF_
+typedef void (irg_walk_func)(ir_node *, void *);
+#endif
 
 /* Walks over the graph starting at node.  Walks also if graph is in state
    "outs_inconsistent".  Assumes current_ir_graph is set properly. */
 void irg_out_walk(ir_node *node,
-		  void (pre)(ir_node*, void*), void (post)(ir_node*, void*),
+		  irg_walk_func *pre, irg_walk_func *post,
 		  void *env);
 
 /* Walks only over Block nodes in the graph.  Has it's own visited
    flag, so that it can be interleaved with the other walker.
    node must be either op_Block or mode_X.  */
 void irg_out_block_walk(ir_node *node,
-			void (pre)(ir_node*, void*), void (post)(ir_node*, void*),
+			irg_walk_func *pre, irg_walk_func *post,
 			void *env);
 
 /**********************************************************************/

ir/debug/dbginfo.h

@@ -27,9 +27,9 @@
 typedef struct ir_node ir_node;
 #endif
 
+/* to resolve recursion between entity.h and type.h */
 #ifndef _ENTITY_TYPEDEF_
 #define _ENTITY_TYPEDEF_
-/* to resolve recursion between entity.h and type.h */
 typedef struct entity entity;
 #endif
 
@@ -150,11 +150,12 @@ static const char* dbg_action_2_str(dbg_action a) {
  *   No result.
  ***
  */
-void dbg_init( void (merge_pair)(ir_node *nw, ir_node *old, dbg_action info),
-	       void (merge_sets)(ir_node **new_nodes, int n_new_nodes,
-				 ir_node **old_nodes, int n_old_nodes,
-				 dbg_action info)
-	       );
+
+
+typedef void (merge_pair_func)(ir_node *, ir_node *, dbg_action);
+typedef void (merge_sets_func)(ir_node **, int, ir_node **, int, dbg_action);
+
+void dbg_init(merge_pair_func *mpf, merge_sets_func *msf);
 
 
 #endif /* _DBGINFO_H_ */

ir/ident/ident.h

@@ -14,7 +14,7 @@
 
 # include <stdio.h>
 # include <assert.h>
-# include "common.h"
+# include "firm_common.h"
 
 /****h* libfirm/ident
  *

ir/ir/ircgcons.c

@@ -132,7 +132,7 @@ static void collect_phicallproj(void) {
     link(start, get_irg_frame(irg));
     link(start, get_irg_globals(irg));
     /* walk */
-    irg_walk_graph(irg, clear_link, (irg_walk_func) collect_phicallproj_walker, &end);
+    irg_walk_graph(irg, clear_link, (irg_walk_func *) collect_phicallproj_walker, &end);
   }
 }
 

ir/ir/ircgopt.c

@@ -47,7 +47,7 @@ void gc_irgs(int n_keep, entity ** keep_arr) {
       ir_graph * irg = get_entity_irg(marked[i]);
       ir_node * node = get_irg_end(irg);
       /* collect calls */
-      irg_walk_graph(irg, clear_link, (irg_walk_func) collect_call, node);
+      irg_walk_graph(irg, clear_link, (irg_walk_func *) collect_call, node);
       /* iterate calls */
       for (node = get_irn_link(node); node; node = get_irn_link(node)) {
 	int i;

ir/ir/ircons.c

@@ -19,7 +19,7 @@
 # include "irnode_t.h"
 # include "irmode_t.h"
 # include "ircons.h"
-# include "common_t.h"
+# include "firm_common_t.h"
 # include "irvrfy.h"
 # include "irop.h"
 # include "iropt_t.h"
@@ -434,7 +434,7 @@ new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
 
 ir_node *
 new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
-	    ir_node *callee, int arity, ir_node **in, type *type)
+	    ir_node *callee, int arity, ir_node **in, type *tp)
 {
   ir_node **r_in;
   ir_node *res;
@@ -448,8 +448,8 @@ new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
 
   res = new_ir_node (db, irg, block, op_Call, mode_T, r_arity, r_in);
 
-  assert(is_method_type(type));
-  set_Call_type(res, type);
+  assert(is_method_type(tp));
+  set_Call_type(res, tp);
   res->attr.call.callee_arr = NULL;
   res = optimize (res);
   irn_vrfy (res);
@@ -750,8 +750,8 @@ INLINE ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_
 }
 INLINE ir_node *new_r_Call   (ir_graph *irg, ir_node *block, ir_node *store,
 		       ir_node *callee, int arity, ir_node **in,
-		       type *type) {
-  return new_rd_Call(NULL, irg, block, store, callee, arity, in, type);
+		       type *tp) {
+  return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
 }
 INLINE ir_node *new_r_Add    (ir_graph *irg, ir_node *block,
 		       ir_node *op1, ir_node *op2, ir_mode *mode) {
@@ -1914,11 +1914,11 @@ new_d_Cond (dbg_info* db, ir_node *c)
 
 ir_node *
 new_d_Call (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node **in,
-	  type *type)
+	  type *tp)
 {
   ir_node *res;
   res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block,
-		     store, callee, arity, in, type);
+		     store, callee, arity, in, tp);
 #if PRECISE_EXC_CONTEXT
   if ((current_ir_graph->phase_state == phase_building) &&
       (get_irn_op(res) == op_Call))  /* Could be optimized away. */
@@ -2236,7 +2236,7 @@ ir_node *new_Jmp    (void) {
 ir_node *new_Cond   (ir_node *c) {
   return new_d_Cond(NULL, c);
 }
-ir_node *new_Return (ir_node *store, int arity, ir_node **in) {
+ir_node *new_Return (ir_node *store, int arity, ir_node *in[]) {
   return new_d_Return(NULL, store, arity, in);
 }
 ir_node *new_Raise  (ir_node *store, ir_node *obj) {
@@ -2259,8 +2259,8 @@ ir_node *new_InstOf (ir_node *store, ir_node *objptr, type *ent) {
   return (new_d_InstOf (NULL, store, objptr, ent));
 }
 ir_node *new_Call   (ir_node *store, ir_node *callee, int arity, ir_node **in,
-		     type *type) {
-  return new_d_Call(NULL, store, callee, arity, in, type);
+		     type *tp) {
+  return new_d_Call(NULL, store, callee, arity, in, tp);
 }
 ir_node *new_Add    (ir_node *op1, ir_node *op2, ir_mode *mode) {
   return new_d_Add(NULL, op1, op2, mode);

ir/ir/ircons.h

@@ -583,7 +583,7 @@
  *      attr.con   A tarval* pointer to the proper entry in the constant
  *                 table.
  *
- *    ir_node *new_SymConst (type *type, symconst_kind kind)
+ *    ir_node *new_SymConst (type *tp, symconst_kind kind)
  *    ------------------------------------------------------------
  *
  *    There are three kinds of symbolic constants:
@@ -1074,7 +1074,7 @@
 # ifndef _IRCONS_H_
 # define _IRCONS_H_
 
-# include "common.h"
+# include "firm_common.h"
 # include "irgraph.h"
 # include "irnode.h"
 # include "irmode.h"
@@ -1108,7 +1108,7 @@ ir_node *new_rd_Sel    (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *st
 		       entity *ent);
 ir_node *new_rd_Call   (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
 		       ir_node *callee, int arity, ir_node **in,
-		       type *type);
+		       type *tp);
 ir_node *new_rd_Add    (dbg_info *db, ir_graph *irg, ir_node *block,
 		       ir_node *op1, ir_node *op2, ir_mode *mode);
 ir_node *new_rd_Sub    (dbg_info *db, ir_graph *irg, ir_node *block,
@@ -1200,7 +1200,7 @@ ir_node *new_r_Sel    (ir_graph *irg, ir_node *block, ir_node *store,
 		       entity *ent);
 ir_node *new_r_Call   (ir_graph *irg, ir_node *block, ir_node *store,
 		       ir_node *callee, int arity, ir_node **in,
-		       type *type);
+		       type *tp);
 ir_node *new_r_Add    (ir_graph *irg, ir_node *block,
 		       ir_node *op1, ir_node *op2, ir_mode *mode);
 ir_node *new_r_Sub    (ir_graph *irg, ir_node *block,
@@ -1293,7 +1293,7 @@ ir_node *new_d_simpleSel(dbg_info* db, ir_node *store, ir_node *objptr, entity *
 ir_node *new_d_Sel    (dbg_info* db, ir_node *store, ir_node *objptr, int arity, ir_node **in,
                      entity *ent);
 ir_node *new_d_Call   (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node **in,
-		     type *type);
+		     type *tp);
 ir_node *new_d_Add    (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode);
 ir_node *new_d_Sub    (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode);
 ir_node *new_d_Minus  (dbg_info* db, ir_node *op,  ir_mode *mode);
@@ -1360,7 +1360,7 @@ ir_node *new_Sel    (ir_node *store, ir_node *objptr, int arity, ir_node **in,
                      entity *ent);
 ir_node *new_InstOf (ir_node *store, ir_node *objptr, type *ent);
 ir_node *new_Call   (ir_node *store, ir_node *callee, int arity, ir_node **in,
-		     type *type);
+		     type *tp);
 ir_node *new_CallBegin(ir_node *callee);
 ir_node *new_Add    (ir_node *op1, ir_node *op2, ir_mode *mode);
 ir_node *new_Sub    (ir_node *op1, ir_node *op2, ir_mode *mode);

ir/ir/irdump.c

@@ -28,7 +28,7 @@
 # include "typewalk.h"
 # include "irouts.h"
 # include "irdom.h"
-# include "common_t.h"
+# include "firm_common_t.h"
 # include  "irloop.h"
 
 # include "exc.h"
@@ -1501,7 +1501,7 @@ void dump_cg_block_graph(ir_graph * irg) {
 
   vcg_open(irg, "");
 
-  irg_walk_graph(irg, clear_link, (irg_walk_func) collect_blocks_floats_cg, map);
+  irg_walk_graph(irg, clear_link, (irg_walk_func *) collect_blocks_floats_cg, map);
   for (entry = pmap_first(map); entry; entry = pmap_next(map))
     pmap_insert(map2, entry->key, entry->value);
   for (entry = pmap_first(map); entry; entry = pmap_next(map)) {
@@ -1574,7 +1574,7 @@ void dump_cg_graph(ir_graph * irg) {
   pmap_entry * entry;
   vcg_open(irg, "");
 
-  irg_walk_graph(irg, clear_link, (irg_walk_func) collect_blocks_floats_cg, map);
+  irg_walk_graph(irg, clear_link, (irg_walk_func *) collect_blocks_floats_cg, map);
   for (entry = pmap_first(map); entry; entry = pmap_next(map))
     pmap_insert(map2, entry->key, entry->value);
   for (entry = pmap_first(map); entry; entry = pmap_next(map)) {

ir/ir/irdump.h

@@ -247,7 +247,8 @@ void dump_all_cg_block_graph();
  *  turn_of_edge_labels
  ***
  */
-void dump_all_ir_graphs (void dump_graph(ir_graph*));
+typedef void (dump_graph_func)(ir_graph *);
+void dump_all_ir_graphs (dump_graph_func *dump_graph);
 
 /****m* irdump/turn_off_edge_labels
  *

ir/ir/irflag.c

@@ -13,7 +13,7 @@
 #endif
 
 #include "irflag.h"
-#include "common.h"
+#include "firm_common.h"
 
 
 /* 0 - don't do this optimization

ir/ir/irgraph.h

@@ -122,6 +122,7 @@ void     set_irg_end (ir_graph *irg, ir_node *node);
 /* @@@ oblivious, no more supported. */
 ir_node *get_irg_cstore (ir_graph *irg);
 void     set_irg_cstore (ir_graph *irg, ir_node *node);
+/* end oblivious */
 
 ir_node *get_irg_frame (ir_graph *irg);
 void     set_irg_frame (ir_graph *irg, ir_node *node);
@@ -165,6 +166,7 @@ typedef enum {
   phase_high,
   phase_low
 } irg_phase_state;
+
 irg_phase_state get_irg_phase_state (ir_graph *irg);
 void set_irg_phase_low(ir_graph *irg);
 
@@ -212,14 +214,14 @@ void set_irg_dom_inconsistent(ir_graph *irg);
 /* state: loopinfo_state
    Loop information describes the loops within the control and
    data flow of the procedure.
-typedef enum {
+tpedef enum {   @@@ make unrecognizable for jni script!!!
   no_loopinfo,
   loopinfo_consistent,
   loopinfo_inconsistent
 } irg_loopinfo_state;
 irg_loopinfo_state get_irg_loopinfo_state(ir_graph *irg);
 void set_irg_loopinfo_inconsistent(ir_graph *irg);
-*/
+
 
 /* A void * field to link arbritary information to the node. */
 void set_irg_link (ir_graph *irg, void *thing);

ir/ir/irgraph_t.h

@@ -13,7 +13,7 @@
 # include "obst.h"
 # include "pset.h"
 # include "irgraph.h"
-# include "common_t.h"
+# include "firm_common_t.h"
 
 #define FRAME_TP_SUFFIX "frame_tp"
 

ir/ir/irgwalk.c

@@ -26,7 +26,7 @@
 
 /* walk over an interprocedural graph (callgraph). Visits only graphs in irg_set. */
 static void irg_walk_cg(ir_node * node, int visited, eset * irg_set,
-			irg_walk_func pre, irg_walk_func post, void * env) {
+			irg_walk_func *pre, irg_walk_func *post, void * env) {
   int i;
   ir_graph * rem = current_ir_graph;
   ir_node * pred;
@@ -98,13 +98,13 @@ static void collect_irgs(ir_node * node, eset * irg_set) {
       ir_graph * irg = ent ? get_entity_irg(ent) : NULL;
       if (irg && !eset_contains(irg_set, irg)) {
 	eset_insert(irg_set, irg);
-	irg_walk_graph(irg, (irg_walk_func) collect_irgs, NULL, irg_set);
+	irg_walk_graph(irg, (irg_walk_func *) collect_irgs, NULL, irg_set);
       }
     }
   }
 }
 
-void irg_walk_2(ir_node *node, irg_walk_func pre, irg_walk_func post, void * env)
+void irg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env)
 {
   int i;
   assert(node);
@@ -125,7 +125,7 @@ void irg_walk_2(ir_node *node, irg_walk_func pre, irg_walk_func post, void * env
 }
 
 
-void irg_walk(ir_node *node, irg_walk_func pre, irg_walk_func post, void *env)
+void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 {
   assert(node);
   if (interprocedural_view) {
@@ -134,7 +134,7 @@ void irg_walk(ir_node *node, irg_walk_func pre, irg_walk_func post, void *env)
     ir_graph * irg;
     interprocedural_view = false;
     eset_insert(irg_set, current_ir_graph);
-    irg_walk(node, (irg_walk_func) collect_irgs, NULL, irg_set);
+    irg_walk(node, (irg_walk_func *) collect_irgs, NULL, irg_set);
     interprocedural_view = true;
     visited = get_max_irg_visited() + 1;
     irg_walk_cg(node, visited, irg_set, pre, post, env);
@@ -150,7 +150,7 @@ void irg_walk(ir_node *node, irg_walk_func pre, irg_walk_func post, void *env)
 }
 
 
-void irg_walk_graph(ir_graph *irg, irg_walk_func pre, irg_walk_func post, void *env) {
+void irg_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env) {
   ir_graph * rem = current_ir_graph;
   current_ir_graph = irg;
   irg_walk(get_irg_end(irg), pre, post, env);
@@ -160,7 +160,7 @@ void irg_walk_graph(ir_graph *irg, irg_walk_func pre, irg_walk_func post, void *
 /* Executes irg_walk(end, pre, post, env) for all irgraphs in irprog.
    Sets current_ir_graph properly for each walk.  Conserves current
    current_ir_graph. */
-void all_irg_walk(irg_walk_func pre, irg_walk_func post, void *env) {
+void all_irg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
   int i;
   ir_graph *irg, *rem;
 
@@ -197,7 +197,7 @@ switch_irg (ir_node *n, int index) {
   return old_current;
 }
 
-void cg_walk_2(ir_node *node, irg_walk_func pre, irg_walk_func post, void * env)
+void cg_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void * env)
 {
   int i;
   ir_graph *rem = NULL;
@@ -223,7 +223,7 @@ void cg_walk_2(ir_node *node, irg_walk_func pre, irg_walk_func post, void * env)
 
 
 /* Walks all irgs in interprocedural view.  Visits each node only once. */
-void cg_walk(irg_walk_func pre, irg_walk_func post, void *env) {
+void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env) {
   int i;
   ir_graph *rem = current_ir_graph;
   int rem_view = interprocedural_view;
@@ -268,7 +268,7 @@ ir_node *get_cf_op(ir_node *n) {
   return skip_Proj(n);
 }
 
-void irg_block_walk_2(ir_node *node, irg_walk_func pre, irg_walk_func post, void *env)
+void irg_block_walk_2(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 {
   int i;
   assert(get_irn_opcode(node) == iro_Block);
@@ -299,7 +299,7 @@ void irg_block_walk_2(ir_node *node, irg_walk_func pre, irg_walk_func post, void
 
 /* walks only over Block nodes in the graph.  Has it's own visited
    flag, so that it can be interleaved with the other walker.         */
-void irg_block_walk(ir_node *node, irg_walk_func pre, irg_walk_func post, void *env)
+void irg_block_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env)
 {
   ir_node *block, *pred;
   int i;
@@ -323,8 +323,8 @@ void irg_block_walk(ir_node *node, irg_walk_func pre, irg_walk_func post, void *
 }
 
 
-void irg_block_walk_graph(ir_graph *irg, irg_walk_func pre,
-			  irg_walk_func post, void *env) {
+void irg_block_walk_graph(ir_graph *irg, irg_walk_func *pre,
+			  irg_walk_func *post, void *env) {
   ir_graph * rem = current_ir_graph;
   current_ir_graph = irg;
   irg_block_walk(get_irg_end(irg), pre, post, env);
@@ -355,7 +355,7 @@ void walk_entity(entity *ent, void *env) {
 }
 
 /* Walks over all code in const_code_irg. */
-void walk_const_code(irg_walk_func pre, irg_walk_func post, void *env) {
+void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env) {
   int i, j;
   walk_env my_env;
 

ir/ir/irgwalk.h

@@ -19,7 +19,10 @@
 # include "irnode.h"
 
 /* type of callback function for ir_graph walk */
-typedef void (* irg_walk_func)(ir_node *, void *);
+#ifndef _IRG_WALK_FUNC_TYPEDEF_
+#define _IRG_WALK_FUNC_TYPEDEF_
+typedef void (irg_walk_func)(ir_node *, void *);
+#endif
 
 /* Walks over the ir graph, starting at the node given as first argument.
    Executes pre before visiting the predecessor of a node, post after.
@@ -28,36 +31,36 @@ typedef void (* irg_walk_func)(ir_node *, void *);
    flag.  It marks the node as visited before executing pre.
    The void* env can be used to pass status information between the
    pre and post functions.  */
-void irg_walk(ir_node *node, irg_walk_func pre, irg_walk_func post, void *env);
+void irg_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env);
 
 /* Like "irg_walk", but walks over all reachable nodes in the ir
  * graph, starting at the end operation. During the walk current_ir_graph
  * is set to irg. */
-void irg_walk_graph(ir_graph *irg, irg_walk_func pre, irg_walk_func post, void *env);
+void irg_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
 
 /* Executes irg_walk(end, pre, post, env) for all irgraphs in irprog.
    Sets current_ir_graph properly for each walk.  Conserves current
    current_ir_graph.  In interprocedural view nodes can be visited several
    times. */
-void all_irg_walk(irg_walk_func pre, irg_walk_func post, void *env);
+void all_irg_walk(irg_walk_func *pre, irg_walk_func *post, void *env);
 
 /* Walks all irgs in interprocedural view.  Visits each node only once.
    Sets current_ir_graph properly. */
-void cg_walk(irg_walk_func pre, irg_walk_func post, void *env);
+void cg_walk(irg_walk_func *pre, irg_walk_func *post, void *env);
 
 /* Walks only over Block nodes in the graph.  Has it's own visited
    flag, so that it can be interleaved with the other walker.
    If a none block is passed, starts at the block this node belongs to.
    If end is passed also visites kept alive blocks. */
-void irg_block_walk(ir_node *node, irg_walk_func pre, irg_walk_func post, void *env);
+void irg_block_walk(ir_node *node, irg_walk_func *pre, irg_walk_func *post, void *env);
 
 /* Like "irg_block_walk", but walks over all reachable blocks in the
  * ir graph, starting at the end block. */
-void irg_block_walk_graph(ir_graph *irg, irg_walk_func pre, irg_walk_func post, void *env);
+void irg_block_walk_graph(ir_graph *irg, irg_walk_func *pre, irg_walk_func *post, void *env);
 
 /* Walks over all code in const_code_irg.
    Uses visited flag in const_code_irg. */
-void walk_const_code(irg_walk_func pre, irg_walk_func post, void *env);
+void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env);
 
 
 # endif /* _IRGWALK_H_ */

ir/ir/irmode.c

@@ -38,26 +38,26 @@ ir_mode *mode_M;
 ir_mode *mode_R;
 ir_mode *mode_Z;
 
-INLINE ir_mode *get_mode_T() { return mode_T; }
-INLINE ir_mode *get_mode_f() { return mode_f; }
-INLINE ir_mode *get_mode_d() { return mode_d; }
-INLINE ir_mode *get_mode_c() { return mode_c; }
-INLINE ir_mode *get_mode_C() { return mode_C; }
-INLINE ir_mode *get_mode_h() { return mode_h; }
-INLINE ir_mode *get_mode_H() { return mode_H; }
-INLINE ir_mode *get_mode_i() { return mode_i; }
-INLINE ir_mode *get_mode_I() { return mode_I; }
-INLINE ir_mode *get_mode_l() { return mode_l; }
-INLINE ir_mode *get_mode_L() { return mode_L; }
-INLINE ir_mode *get_mode_B() { return mode_B; }
-INLINE ir_mode *get_mode_p() { return mode_b; }
-INLINE ir_mode *get_mode_b() { return mode_p; }
-INLINE ir_mode *get_mode_s() { return mode_s; }
-INLINE ir_mode *get_mode_S() { return mode_S; }
-INLINE ir_mode *get_mode_X() { return mode_X; }
-INLINE ir_mode *get_mode_M() { return mode_M; }
-INLINE ir_mode *get_mode_R() { return mode_R; }
-INLINE ir_mode *get_mode_Z() { return mode_Z; }
+INLINE ir_mode *get_modeT() { return mode_T; }
+INLINE ir_mode *get_modef() { return mode_f; }
+INLINE ir_mode *get_moded() { return mode_d; }
+INLINE ir_mode *get_modec() { return mode_c; }
+INLINE ir_mode *get_modeC() { return mode_C; }
+INLINE ir_mode *get_modeh() { return mode_h; }
+INLINE ir_mode *get_modeH() { return mode_H; }
+INLINE ir_mode *get_modei() { return mode_i; }
+INLINE ir_mode *get_modeI() { return mode_I; }
+INLINE ir_mode *get_model() { return mode_l; }
+INLINE ir_mode *get_modeL() { return mode_L; }
+INLINE ir_mode *get_modeB() { return mode_B; }
+INLINE ir_mode *get_modep() { return mode_b; }
+INLINE ir_mode *get_modeb() { return mode_p; }
+INLINE ir_mode *get_modes() { return mode_s; }
+INLINE ir_mode *get_modeS() { return mode_S; }
+INLINE ir_mode *get_modeX() { return mode_X; }
+INLINE ir_mode *get_modeM() { return mode_M; }
+INLINE ir_mode *get_modeR() { return mode_R; }
+INLINE ir_mode *get_modeZ() { return mode_Z; }
 
 void
 init_mode (void)

ir/ir/irmode.h

@@ -79,26 +79,26 @@ extern ir_mode *mode_R; /* block */
 extern ir_mode *mode_Z; /* infinit integers */ /* oblivious */
 
 /* Access routines for JNI Interface */
-ir_mode *get_mode_T();
-ir_mode *get_mode_f();
-ir_mode *get_mode_d();
-ir_mode *get_mode_c();
-ir_mode *get_mode_C();
-ir_mode *get_mode_h();
-ir_mode *get_mode_H();
-ir_mode *get_mode_i();
-ir_mode *get_mode_I();
-ir_mode *get_mode_l();
-ir_mode *get_mode_L();
-ir_mode *get_mode_B();
-ir_mode *get_mode_p();
-ir_mode *get_mode_b();
-ir_mode *get_mode_s();
-ir_mode *get_mode_S();
-ir_mode *get_mode_X();
-ir_mode *get_mode_M();
-ir_mode *get_mode_R();