From 44fec44bd47ef88ae276179866d4a65cda6e0253 Mon Sep 17 00:00:00 2001 From: Michael Beck Date: Fri, 13 Jan 2006 22:58:52 +0000 Subject: [PATCH] renamed all types 'type' to 'ir_type' [r7237] --- ir/ana2/ecg.c | 7 +++- ir/ana2/pto_name.c | 19 +++++---- ir/ir/ircons.c | 90 ++++++++++++++++++++--------------------- ir/ir/irdump.c | 28 ++++++------- ir/ir/irdump.h | 4 +- ir/ir/irdump_t.h | 4 +- ir/ir/irdumptxt.c | 40 +++++++++--------- ir/ir/irgopt.c | 10 ++--- ir/ir/irgraph.h | 4 +- ir/ir/irgwalk.c | 2 +- ir/ir/irhooks.h | 2 +- ir/ir/irprog.c | 16 ++++---- ir/ir/irprog.h | 10 ++--- ir/ir/irvrfy.c | 22 +++++----- ir/opt/opt_polymorphy.c | 6 +-- ir/opt/proc_cloning.c | 8 ++-- ir/opt/scalar_replace.c | 6 +-- 17 files changed, 142 insertions(+), 136 deletions(-) diff --git a/ir/ana2/ecg.c b/ir/ana2/ecg.c index bb5a277ca..7195428b0 100644 --- a/ir/ana2/ecg.c +++ b/ir/ana2/ecg.c @@ -86,7 +86,7 @@ void set_main_ctx (ctx_info_t*); /* ==================== Alloc stuff ==================== */ -static void append_alloc (graph_info_t *ginfo, ir_node *alloc, type *tp) +static void append_alloc (graph_info_t *ginfo, ir_node *alloc, ir_type *tp) { alloc_info_t *ainfo = xmalloc (sizeof (alloc_info_t)); @@ -419,7 +419,7 @@ static void ecg_calls_act (ir_node *node, void *env) assert (0 && "Unexpected address expression"); } } else if (op_Alloc == op) { - type *tp = get_Alloc_type (node); + ir_type *tp = get_Alloc_type (node); /* const char *name = get_type_name (tp); */ append_alloc (graph_info, node, tp); @@ -1267,6 +1267,9 @@ void ecg_ecg (void) /* $Log$ + Revision 1.22 2006/01/13 22:55:03 beck + renamed all types 'type' to 'ir_type' + Revision 1.21 2005/12/31 15:58:57 beck added missing includes diff --git a/ir/ana2/pto_name.c b/ir/ana2/pto_name.c index 10271141c..50cfec7fb 100644 --- a/ir/ana2/pto_name.c +++ b/ir/ana2/pto_name.c @@ -202,7 +202,7 @@ static void pto_name_alloc_colors (void) /* See whether the given entity is a field. */ static int is_field (entity *ent) { - type *tp = get_entity_type (ent); + ir_type *tp = get_entity_type (ent); if (is_Primitive_type (tp) || is_Pointer_type (tp)) { /* actually, we don't get by by restricting ourselves to pointer types */ @@ -212,9 +212,9 @@ static int is_field (entity *ent) } } -/* Helper to collect_fields(type*): collect all fields of the given +/* Helper to collect_fields(ir_type*): collect all fields of the given clazz and its super classes into the given obstack. */ -static void _collect_fields (type *clazz, struct obstack *obst) +static void _collect_fields (ir_type *clazz, struct obstack *obst) { int n_members = get_class_n_members (clazz); int n_supers = get_class_n_supertypes (clazz); @@ -231,7 +231,7 @@ static void _collect_fields (type *clazz, struct obstack *obst) } for (i = 0; i < n_supers; i ++) { - type *s_clazz = get_class_supertype (clazz, i); + ir_type *s_clazz = get_class_supertype (clazz, i); _collect_fields (s_clazz, obst); } @@ -239,7 +239,7 @@ static void _collect_fields (type *clazz, struct obstack *obst) /* Collect the fields of the given class and its super classes into an array. The last entry of the array is written NULL. */ -static entity **collect_fields (type *clazz) +static entity **collect_fields (ir_type *clazz) { struct obstack obst; int n_fields; @@ -302,7 +302,7 @@ static void pto_name_dump_finish (FILE *stream) /* Write a node for the given descriptor into the given stream */ static void pto_name_dump_desc (desc_t *desc, FILE *stream) { - type *tp = desc->tp; + ir_type *tp = desc->tp; const char *tp_name = get_type_name (tp); ir_node *nd; @@ -473,7 +473,7 @@ qset_t *get_entry (desc_t *desc, entity *ent) /* get a new descriptor for the given type at the given node */ -desc_t *new_name (type *tp, ir_node *node, int ctx) +desc_t *new_name (ir_type *tp, ir_node *node, int ctx) { desc_t *desc = NULL; @@ -535,7 +535,7 @@ desc_t *new_ent_name (entity *ent) { int i; int missing = TRUE; - type *tp = get_entity_type (ent); + ir_type *tp = get_entity_type (ent); assert (is_Pointer_type (tp)); tp = get_pointer_points_to_type (tp); @@ -658,6 +658,9 @@ void pto_name_cleanup (void) /* $Log$ + Revision 1.18 2006/01/13 22:56:21 beck + renamed all types 'type' to 'ir_type' + Revision 1.17 2005/12/16 16:59:54 grund *** empty log message *** diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index 085ee137b..99e888d4e 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -150,7 +150,7 @@ new_bd_Phi (dbg_info *db, ir_node *block, int arity, ir_node **in, ir_mode *mode } static ir_node * -new_bd_Const_type (dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, type *tp) +new_bd_Const_type (dbg_info *db, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp) { ir_node *res; ir_graph *irg = current_ir_graph; @@ -241,7 +241,7 @@ new_bd_Conv (dbg_info *db, ir_node *block, ir_node *op, ir_mode *mode) } static ir_node * -new_bd_Cast (dbg_info *db, ir_node *block, ir_node *op, type *to_tp) +new_bd_Cast (dbg_info *db, ir_node *block, ir_node *op, ir_type *to_tp) { ir_node *res; ir_graph *irg = current_ir_graph; @@ -596,7 +596,7 @@ new_bd_Cond (dbg_info *db, ir_node *block, ir_node *c) static ir_node * new_bd_Call (dbg_info *db, ir_node *block, ir_node *store, - ir_node *callee, int arity, ir_node **in, type *tp) + ir_node *callee, int arity, ir_node **in, ir_type *tp) { ir_node **r_in; ir_node *res; @@ -694,7 +694,7 @@ new_bd_Store (dbg_info *db, ir_node *block, static ir_node * new_bd_Alloc (dbg_info *db, ir_node *block, ir_node *store, - ir_node *size, type *alloc_type, where_alloc where) + ir_node *size, ir_type *alloc_type, where_alloc where) { ir_node *in[2]; ir_node *res; @@ -713,7 +713,7 @@ new_bd_Alloc (dbg_info *db, ir_node *block, ir_node *store, static ir_node * new_bd_Free (dbg_info *db, ir_node *block, ir_node *store, - ir_node *ptr, ir_node *size, type *free_type, where_alloc where) + ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) { ir_node *in[3]; ir_node *res; @@ -758,7 +758,7 @@ new_bd_Sel (dbg_info *db, ir_node *block, ir_node *store, ir_node *objptr, static ir_node * new_bd_InstOf (dbg_info *db, ir_node *block, ir_node *store, - ir_node *objptr, type *ent) + ir_node *objptr, ir_type *ent) { ir_node **r_in; ir_node *res; @@ -780,7 +780,7 @@ new_bd_InstOf (dbg_info *db, ir_node *block, ir_node *store, static ir_node * new_bd_SymConst_type (dbg_info *db, ir_node *block, symconst_symbol value, - symconst_kind symkind, type *tp) { + symconst_kind symkind, ir_type *tp) { ir_node *res; ir_mode *mode; ir_graph *irg = current_ir_graph; @@ -945,7 +945,7 @@ new_bd_Mux (dbg_info *db, ir_node *block, static ir_node * new_bd_CopyB (dbg_info *db, ir_node *block, - ir_node *store, ir_node *dst, ir_node *src, type *data_type) + ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) { ir_node *in[3]; ir_node *res; @@ -1047,7 +1047,7 @@ new_rd_Phi (dbg_info *db, ir_graph *irg, ir_node *block, int arity, ir_node **in } ir_node * -new_rd_Const_type (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, type *tp) +new_rd_Const_type (dbg_info *db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, ir_type *tp) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1133,7 +1133,7 @@ new_rd_Conv (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode * } ir_node * -new_rd_Cast (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) +new_rd_Cast (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1451,7 +1451,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 *tp) + ir_node *callee, int arity, ir_node **in, ir_type *tp) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1520,7 +1520,7 @@ new_rd_Store (dbg_info *db, ir_graph *irg, ir_node *block, ir_node * new_rd_Alloc (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, - ir_node *size, type *alloc_type, where_alloc where) + ir_node *size, ir_type *alloc_type, where_alloc where) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1534,7 +1534,7 @@ new_rd_Alloc (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node * new_rd_Free (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, - ir_node *ptr, ir_node *size, type *free_type, where_alloc where) + ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1576,7 +1576,7 @@ new_rd_Sel (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node ir_node * new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, - ir_node *objptr, type *ent) + ir_node *objptr, ir_type *ent) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1590,7 +1590,7 @@ new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node * new_rd_SymConst_type (dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol value, - symconst_kind symkind, type *tp) + symconst_kind symkind, ir_type *tp) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1610,23 +1610,23 @@ new_rd_SymConst (dbg_info *db, ir_graph *irg, ir_node *block, symconst_symbol va return res; } -ir_node *new_rd_SymConst_addr_ent (dbg_info *db, ir_graph *irg, entity *symbol, type *tp) +ir_node *new_rd_SymConst_addr_ent (dbg_info *db, ir_graph *irg, entity *symbol, ir_type *tp) { - symconst_symbol sym = {(type *)symbol}; + symconst_symbol sym = {(ir_type *)symbol}; return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_addr_ent, tp); } -ir_node *new_rd_SymConst_addr_name (dbg_info *db, ir_graph *irg, ident *symbol, type *tp) { - symconst_symbol sym = {(type *)symbol}; +ir_node *new_rd_SymConst_addr_name (dbg_info *db, ir_graph *irg, ident *symbol, ir_type *tp) { + symconst_symbol sym = {(ir_type *)symbol}; return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_addr_name, tp); } -ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, type *symbol, type *tp) { +ir_node *new_rd_SymConst_type_tag (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) { symconst_symbol sym = {symbol}; return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_type_tag, tp); } -ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, type *symbol, type *tp) { +ir_node *new_rd_SymConst_size (dbg_info *db, ir_graph *irg, ir_type *symbol, ir_type *tp) { symconst_symbol sym = {symbol}; return new_rd_SymConst_type(db, irg, irg->start_block, sym, symconst_size, tp); } @@ -1759,7 +1759,7 @@ new_rd_Mux (dbg_info *db, ir_graph *irg, ir_node *block, } ir_node *new_rd_CopyB(dbg_info *db, ir_graph *irg, ir_node *block, - ir_node *store, ir_node *dst, ir_node *src, type *data_type) + ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) { ir_node *res; ir_graph *rem = current_ir_graph; @@ -1821,7 +1821,7 @@ ir_node *new_r_Const_long(ir_graph *irg, ir_node *block, } ir_node *new_r_Const_type(ir_graph *irg, ir_node *block, - ir_mode *mode, tarval *con, type *tp) { + ir_mode *mode, tarval *con, ir_type *tp) { return new_rd_Const_type(NULL, irg, block, mode, con, tp); } @@ -1835,12 +1835,12 @@ ir_node *new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent); } ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr, - type *ent) { + ir_type *ent) { return (new_rd_InstOf (NULL, irg, block, store, objptr, ent)); } ir_node *new_r_Call (ir_graph *irg, ir_node *block, ir_node *store, ir_node *callee, int arity, ir_node **in, - type *tp) { + ir_type *tp) { return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp); } ir_node *new_r_Add (ir_graph *irg, ir_node *block, @@ -1919,7 +1919,7 @@ ir_node *new_r_Conv (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode) { return new_rd_Conv(NULL, irg, block, op, mode); } -ir_node *new_r_Cast (ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) { +ir_node *new_r_Cast (ir_graph *irg, ir_node *block, ir_node *op, ir_type *to_tp) { return new_rd_Cast(NULL, irg, block, op, to_tp); } ir_node *new_r_Phi (ir_graph *irg, ir_node *block, int arity, @@ -1935,11 +1935,11 @@ ir_node *new_r_Store (ir_graph *irg, ir_node *block, return new_rd_Store(NULL, irg, block, store, adr, val); } ir_node *new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store, - ir_node *size, type *alloc_type, where_alloc where) { + ir_node *size, ir_type *alloc_type, where_alloc where) { return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where); } ir_node *new_r_Free (ir_graph *irg, ir_node *block, ir_node *store, - ir_node *ptr, ir_node *size, type *free_type, where_alloc where) { + ir_node *ptr, ir_node *size, ir_type *free_type, where_alloc where) { return new_rd_Free(NULL, irg, block, store, ptr, size, free_type, where); } ir_node *new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in) { @@ -1994,7 +1994,7 @@ ir_node *new_r_Mux (ir_graph *irg, ir_node *block, return new_rd_Mux(NULL, irg, block, sel, ir_false, ir_true, mode); } ir_node *new_r_CopyB(ir_graph *irg, ir_node *block, - ir_node *store, ir_node *dst, ir_node *src, type *data_type) { + ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) { return new_rd_CopyB(NULL, irg, block, store, dst, src, data_type); } ir_node *new_r_Bound(ir_graph *irg, ir_node *block, @@ -2909,7 +2909,7 @@ new_d_Const_long(dbg_info *db, ir_mode *mode, long value) } ir_node * -new_d_Const_type (dbg_info *db, ir_mode *mode, tarval *con, type *tp) +new_d_Const_type (dbg_info *db, ir_mode *mode, tarval *con, ir_type *tp) { return new_bd_Const_type(db, current_ir_graph->start_block, mode, con, tp); @@ -2949,7 +2949,7 @@ new_d_Conv (dbg_info *db, ir_node *op, ir_mode *mode) } ir_node * -new_d_Cast (dbg_info *db, ir_node *op, type *to_tp) +new_d_Cast (dbg_info *db, ir_node *op, ir_type *to_tp) { return new_bd_Cast(db, current_ir_graph->current_block, op, to_tp); } @@ -3150,7 +3150,7 @@ 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 *tp) + ir_type *tp) { ir_node *res; res = new_bd_Call (db, current_ir_graph->current_block, @@ -3203,7 +3203,7 @@ new_d_Store (dbg_info *db, ir_node *store, ir_node *addr, ir_node *val) } ir_node * -new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, type *alloc_type, +new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, ir_type *alloc_type, where_alloc where) { ir_node *res; @@ -3218,7 +3218,7 @@ new_d_Alloc (dbg_info *db, ir_node *store, ir_node *size, type *alloc_type, ir_node * new_d_Free (dbg_info *db, ir_node *store, ir_node *ptr, - ir_node *size, type *free_type, where_alloc where) + ir_node *size, ir_type *free_type, where_alloc where) { return new_bd_Free (db, current_ir_graph->current_block, store, ptr, size, free_type, where); @@ -3241,14 +3241,14 @@ new_d_Sel (dbg_info *db, ir_node *store, ir_node *objptr, int n_index, ir_node * } ir_node * -new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, type *ent) +new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, ir_type *ent) { return (new_bd_InstOf (db, current_ir_graph->current_block, store, objptr, ent)); } ir_node * -new_d_SymConst_type (dbg_info *db, symconst_symbol value, symconst_kind kind, type *tp) +new_d_SymConst_type (dbg_info *db, symconst_symbol value, symconst_kind kind, ir_type *tp) { return new_bd_SymConst_type (db, current_ir_graph->start_block, value, kind, tp); @@ -3338,7 +3338,7 @@ new_d_Mux (dbg_info *db, ir_node *sel, ir_node *ir_false, } ir_node *new_d_CopyB(dbg_info *db,ir_node *store, - ir_node *dst, ir_node *src, type *data_type) { + ir_node *dst, ir_node *src, ir_type *data_type) { ir_node *res; res = new_bd_CopyB(db, current_ir_graph->current_block, store, dst, src, data_type); @@ -3478,7 +3478,7 @@ ir_node *get_cur_block(void) { } /* Returns the frame type of the current graph */ -type *get_cur_frame_type(void) { +ir_type *get_cur_frame_type(void) { return get_irg_frame_type(current_ir_graph); } @@ -3544,7 +3544,7 @@ ir_node *new_Const_long(ir_mode *mode, long value) return new_d_Const_long(NULL, mode, value); } -ir_node *new_Const_type(tarval *con, type *tp) { +ir_node *new_Const_type(tarval *con, ir_type *tp) { return new_d_Const_type(NULL, get_type_mode(tp), con, tp); } @@ -3558,11 +3558,11 @@ ir_node *new_Sel (ir_node *store, ir_node *objptr, int arity, ir_node **in, entity *ent) { return new_d_Sel(NULL, store, objptr, arity, in, ent); } -ir_node *new_InstOf (ir_node *store, ir_node *objptr, type *ent) { +ir_node *new_InstOf (ir_node *store, ir_node *objptr, ir_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 *tp) { + ir_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) { @@ -3622,7 +3622,7 @@ ir_node *new_Cmp (ir_node *op1, ir_node *op2) { ir_node *new_Conv (ir_node *op, ir_mode *mode) { return new_d_Conv(NULL, op, mode); } -ir_node *new_Cast (ir_node *op, type *to_tp) { +ir_node *new_Cast (ir_node *op, ir_type *to_tp) { return new_d_Cast(NULL, op, to_tp); } ir_node *new_Phi (int arity, ir_node **in, ir_mode *mode) { @@ -3634,12 +3634,12 @@ ir_node *new_Load (ir_node *store, ir_node *addr, ir_mode *mode) { ir_node *new_Store (ir_node *store, ir_node *addr, ir_node *val) { return new_d_Store(NULL, store, addr, val); } -ir_node *new_Alloc (ir_node *store, ir_node *size, type *alloc_type, +ir_node *new_Alloc (ir_node *store, ir_node *size, ir_type *alloc_type, where_alloc where) { return new_d_Alloc(NULL, store, size, alloc_type, where); } ir_node *new_Free (ir_node *store, ir_node *ptr, ir_node *size, - type *free_type, where_alloc where) { + ir_type *free_type, where_alloc where) { return new_d_Free(NULL, store, ptr, size, free_type, where); } ir_node *new_Sync (int arity, ir_node **in) { @@ -3687,7 +3687,7 @@ ir_node *new_NoMem (void) { ir_node *new_Mux (ir_node *sel, ir_node *ir_false, ir_node *ir_true, ir_mode *mode) { return new_d_Mux(NULL, sel, ir_false, ir_true, mode); } -ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, type *data_type) { +ir_node *new_CopyB(ir_node *store, ir_node *dst, ir_node *src, ir_type *data_type) { return new_d_CopyB(NULL, store, dst, src, data_type); } ir_node *new_Bound(ir_node *store, ir_node *idx, ir_node *lower, ir_node *upper) { diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index 31030bfbd..8a818c2b7 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -219,7 +219,7 @@ const char *get_mode_name_ex(ir_mode *mode, int *bad) * returns the name of a type or if mode is NOT a mode object. * in the later case, sets bad */ -const char *get_type_name_ex(type *tp, int *bad) +const char *get_type_name_ex(ir_type *tp, int *bad) { if (is_type(tp)) return get_type_name(tp); @@ -250,7 +250,7 @@ static void print_vcg_color(FILE *F, dumper_colors color) { * prints the edge from a type S to a type T with additional info fmt, ... * to the file F */ -static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ...) +static void print_type_type_edge(FILE *F, ir_type *S, ir_type *T, const char *fmt, ...) { va_list ap; @@ -266,7 +266,7 @@ static void print_type_type_edge(FILE *F, type *S, type *T, const char *fmt, ... * prints the edge from a type T to an entity E with additional info fmt, ... * to the file F */ -static void print_type_ent_edge(FILE *F, type *T, entity *E, const char *fmt, ...) +static void print_type_ent_edge(FILE *F, ir_type *T, entity *E, const char *fmt, ...) { va_list ap; @@ -302,7 +302,7 @@ static void print_ent_ent_edge(FILE *F, entity *E, entity *T, int backedge, cons * prints the edge from an entity E to a type T with additional info fmt, ... * to the file F */ -static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, ...) +static void print_ent_type_edge(FILE *F, entity *E, ir_type *T, const char *fmt, ...) { va_list ap; @@ -318,7 +318,7 @@ static void print_ent_type_edge(FILE *F, entity *E, type *T, const char *fmt, .. * prints the edge from a node N to a type T with additional info fmt, ... * to the file F */ -static void print_node_type_edge(FILE *F, const ir_node *N, type *T, const char *fmt, ...) +static void print_node_type_edge(FILE *F, const ir_node *N, ir_type *T, const char *fmt, ...) { va_list ap; @@ -367,7 +367,7 @@ static void print_ent_node_edge(FILE *F, entity *E, const ir_node *N, const char * prints the edge from a type E to an enumeration item item with additional info fmt, ... * to the file F */ -static void print_enum_item_edge(FILE *F, type *E, int item, const char *fmt, ...) +static void print_enum_item_edge(FILE *F, ir_type *E, int item, const char *fmt, ...) { va_list ap; @@ -742,7 +742,7 @@ static int dump_node_typeinfo(FILE *F, ir_node *n) { if (opt_dump_analysed_type_info) { if (get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_consistent || get_irg_typeinfo_state(current_ir_graph) == ir_typeinfo_inconsistent) { - type *tp = get_irn_typeinfo_type(n); + ir_type *tp = get_irn_typeinfo_type(n); if (tp != firm_none_type) fprintf(F, "[%s] ", get_type_name_ex(tp, &bad)); else @@ -1693,7 +1693,7 @@ static void dump_node2type_edges(ir_node *n, void *env) } #if 0 -static int print_type_info(FILE *F, type *tp) { +static int print_type_info(FILE *F, ir_type *tp) { int bad = 0; if (get_type_state(tp) == layout_undefined) { @@ -1708,7 +1708,7 @@ static int print_type_info(FILE *F, type *tp) { return bad; } -static void print_typespecific_info(FILE *F, type *tp) { +static void print_typespecific_info(FILE *F, ir_type *tp) { switch (get_type_tpop_code(tp)) { case tpo_class: { @@ -1743,7 +1743,7 @@ static void print_typespecific_info(FILE *F, type *tp) { } #endif -static void print_typespecific_vcgattr(FILE *F, type *tp) { +static void print_typespecific_vcgattr(FILE *F, ir_type *tp) { switch (get_type_tpop_code(tp)) { case tpo_class: { @@ -1779,7 +1779,7 @@ static void print_typespecific_vcgattr(FILE *F, type *tp) { } -int dump_type_node(FILE *F, type *tp) +int dump_type_node(FILE *F, ir_type *tp) { int bad = 0; @@ -1824,7 +1824,7 @@ void dump_entity_node(FILE *F, entity *ent, int color) } #undef X -static void dump_enum_item(FILE *F, type *tp, int pos) +static void dump_enum_item(FILE *F, ir_type *tp, int pos) { char buf[1024]; ident *id = get_enumeration_nameid(tp, pos); @@ -1892,7 +1892,7 @@ dump_type_info(type_or_ent *tore, void *env) { } break; case k_type: { - type *tp = (type *)tore; + ir_type *tp = (ir_type *)tore; dump_type_node(F, tp); /* and now the edges */ switch (get_type_tpop_code(tp)) { @@ -1991,7 +1991,7 @@ dump_class_hierarchy_node (type_or_ent *tore, void *ctx) { } break; /* case k_entity */ case k_type: { - type *tp = (type *)tore; + ir_type *tp = (ir_type *)tore; if (tp == get_glob_type()) break; switch (get_type_tpop_code(tp)) { case tpo_class: { diff --git a/ir/ir/irdump.h b/ir/ir/irdump.h index e1c111753..96a9b6cce 100644 --- a/ir/ir/irdump.h +++ b/ir/ir/irdump.h @@ -510,11 +510,11 @@ void dump_entity (entity *ent); /** Write the type and all its attributes to the file passed. * */ -void dump_type_to_file (FILE *f, type *tp, dump_verbosity verbosity); +void dump_type_to_file (FILE *f, ir_type *tp, dump_verbosity verbosity); /** Write the type and all its attributes to stdout. * */ -void dump_type (type *tp); +void dump_type (ir_type *tp); /** Dump type information as text. diff --git a/ir/ir/irdump_t.h b/ir/ir/irdump_t.h index 17700f5c8..23eed8bc5 100644 --- a/ir/ir/irdump_t.h +++ b/ir/ir/irdump_t.h @@ -70,7 +70,7 @@ void vcg_close (FILE *F); const char *get_ent_dump_name(entity *ent); -const char *get_type_name_ex(type *tp, int *bad); +const char *get_type_name_ex(ir_type *tp, int *bad); const char *get_mode_name_ex(ir_mode *mode, int *bad); /** * dump the name of a node n to the File F. @@ -82,6 +82,6 @@ int dump_node_label(FILE *F, ir_node *n); /** Writes vcg representation with title "PRINT_TYPEID(tp)" to file F. */ -int dump_type_node(FILE *F, type *tp); +int dump_type_node(FILE *F, ir_type *tp); #endif /* __IRDUMPT_T_H__ */ diff --git a/ir/ir/irdumptxt.c b/ir/ir/irdumptxt.c index 0f05dbd6f..44100ae44 100644 --- a/ir/ir/irdumptxt.c +++ b/ir/ir/irdumptxt.c @@ -189,7 +189,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) { /* not dumped: mature */ } break; case iro_Start: { - type *tp = get_entity_type(get_irg_entity(get_irn_irg(n))); + ir_type *tp = get_entity_type(get_irg_entity(get_irn_irg(n))); fprintf(F, " start of method of type %s \n", get_type_name_ex(tp, &bad)); for (i = 0; i < get_method_n_params(tp); ++i) fprintf(F, " param %d type: %s \n", i, get_type_name_ex(get_method_param_type(tp, i), &bad)); @@ -231,7 +231,7 @@ int dump_irnode_to_file(FILE *F, ir_node *n) { } } break; case iro_Call: { - type *tp = get_Call_type(n); + ir_type *tp = get_Call_type(n); fprintf(F, " calling method of type %s \n", get_type_name_ex(tp, &bad)); if(get_unknown_type() != tp) { for (i = 0; i < get_method_n_params(tp); ++i) @@ -261,14 +261,14 @@ int dump_irnode_to_file(FILE *F, ir_node *n) { } break; case iro_Return: { if (!get_interprocedural_view()) { - type *tp = get_entity_type(get_irg_entity(get_irn_irg(n))); + ir_type *tp = get_entity_type(get_irg_entity(get_irn_irg(n))); fprintf(F, " return in method of type %s \n", get_type_name_ex(tp, &bad)); for (i = 0; i < get_method_n_ress(tp); ++i) fprintf(F, " res %d type: %s \n", i, get_type_name_ex(get_method_res_type(tp, i), &bad)); } } break; case iro_Const: { - type *tp = get_Const_type(n); + ir_type *tp = get_Const_type(n); assert(tp != firm_none_type); fprintf(F, " Const of type %s \n", get_type_name_ex(get_Const_type(n), &bad)); } break; @@ -438,9 +438,9 @@ static void dump_node_list(FILE *F, firm_kind *k, char *prefix, * "prefix" node8, ... node15,\n * "prefix" node16, node17\n */ -static void dump_type_list(FILE *F, type *tp, char *prefix, - int (*get_n_types)(type *tp), - type *(*get_type)(type *tp, int pos), +static void dump_type_list(FILE *F, ir_type *tp, char *prefix, + int (*get_n_types)(ir_type *tp), + ir_type *(*get_type)(ir_type *tp, int pos), char *name) { int i, n_nodes = get_n_types(tp); char *comma = ""; @@ -461,7 +461,7 @@ static void dump_type_list(FILE *F, type *tp, char *prefix, #define X(a) case a: fprintf(F, #a); break void dump_entity_to_file_prefix (FILE *F, entity *ent, char *prefix, unsigned verbosity) { int i, j; - type *owner, *type; + ir_type *owner, *type; assert(is_entity(ent)); owner = get_entity_owner(ent); @@ -868,7 +868,7 @@ void dump_entitycsv_to_file_prefix (FILE *F, entity *ent, char *prefix, unsig } /* A fast hack to dump a csv. */ -void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const char *comma) { +void dump_typecsv_to_file(FILE *F, ir_type *tp, dump_verbosity verbosity, const char *comma) { int i; char buf[1024 + 10]; if (!is_Class_type(tp)) return; // we also want array types. Stupid, these are classes in java. @@ -953,7 +953,7 @@ void dump_typecsv_to_file(FILE *F, type *tp, dump_verbosity verbosity, const cha } } -void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { +void dump_type_to_file (FILE *F, ir_type *tp, dump_verbosity verbosity) { int i; if ((is_Class_type(tp)) && (verbosity & dump_verbosity_noClassTypes)) return; @@ -986,17 +986,17 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { if (verbosity & dump_verbosity_typeattrs) { fprintf(F, " supertypes: "); for (i = 0; i < get_class_n_supertypes(tp); ++i) { - type *stp = get_class_supertype(tp, i); + ir_type *stp = get_class_supertype(tp, i); fprintf(F, "\n %s", get_type_name(stp)); } fprintf(F, "\n subtypes: "); for (i = 0; i < get_class_n_subtypes(tp); ++i) { - type *stp = get_class_subtype(tp, i); + ir_type *stp = get_class_subtype(tp, i); fprintf(F, "\n %s", get_type_name(stp)); } if (get_irp_inh_transitive_closure_state() != inh_transitive_closure_none) { - type *stp; + ir_type *stp; fprintf(F, "\n transitive supertypes: "); for (stp = get_class_trans_supertype_first(tp); stp; @@ -1030,7 +1030,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { case tpo_array: if (verbosity & dump_verbosity_typeattrs) { int i, n_dim; - type *elem_tp = get_array_element_type(tp); + ir_type *elem_tp = get_array_element_type(tp); fprintf(F, "\n array "); @@ -1074,7 +1074,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { case tpo_pointer: if (verbosity & dump_verbosity_typeattrs) { - type *tt = get_pointer_points_to_type(tp); + ir_type *tt = get_pointer_points_to_type(tp); fprintf(F, "\n points to %s (%ld)\n", get_type_name(tt), get_type_nr(tt)); } break; @@ -1084,13 +1084,13 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { fprintf(F, "\n variadicity: %s", get_variadicity_name(get_method_variadicity(tp))); fprintf(F, "\n return types: %d", get_method_n_ress(tp)); for (i = 0; i < get_method_n_ress(tp); ++i) { - type *rtp = get_method_res_type(tp, i); + ir_type *rtp = get_method_res_type(tp, i); fprintf(F, "\n %s", get_type_name(rtp)); } fprintf(F, "\n parameter types: %d", get_method_n_params(tp)); for (i = 0; i < get_method_n_params(tp); ++i) { - type *ptp = get_method_param_type(tp, i); + ir_type *ptp = get_method_param_type(tp, i); fprintf(F, "\n %s", get_type_name(ptp)); } if (get_method_variadicity(tp)) { @@ -1183,7 +1183,7 @@ void dump_type_to_file (FILE *F, type *tp, dump_verbosity verbosity) { fprintf(F, "\n\n"); } -void dump_type(type *tp) { +void dump_type(ir_type *tp) { dump_type_to_file (stdout, tp, dump_verbosity_max); } @@ -1202,7 +1202,7 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) { } for (i = 0; i < n_types; ++i) { - type *t = get_irp_type(i); + ir_type *t = get_irp_type(i); //if (is_jack_rts_class(t)) continue; @@ -1220,7 +1220,7 @@ void dump_types_as_text(unsigned verbosity, const char *suffix) { void dump_globals_as_text(unsigned verbosity, const char *suffix) { const char *basename; FILE *F, *CSV = NULL; - type *g = get_glob_type(); + ir_type *g = get_glob_type(); int i, n_mems = get_class_n_members(g); basename = irp_prog_name_is_set() ? get_irp_prog_name() : "TextGlobals"; diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c index 8bf933a37..48a25f6fb 100644 --- a/ir/ir/irgopt.c +++ b/ir/ir/irgopt.c @@ -675,7 +675,7 @@ void remove_bad_predecessors(ir_graph *irg) { static INLINE void copy_node_inline (ir_node *n, void *env) { ir_node *new; - type *frame_tp = (type *)env; + ir_type *frame_tp = (ir_type *)env; copy_node(n, NULL); if (get_irn_op(n) == op_Sel) { @@ -707,7 +707,7 @@ static void find_addr(ir_node *node, void *env) */ static int can_inline(ir_node *call, ir_graph *called_graph) { - type *call_type = get_Call_type(call); + ir_type *call_type = get_Call_type(call); int params, ress, i, res; assert(is_Method_type(call_type)); @@ -716,7 +716,7 @@ static int can_inline(ir_node *call, ir_graph *called_graph) /* check params */ for (i = 0; i < params; ++i) { - type *p_type = get_method_param_type(call_type, i); + ir_type *p_type = get_method_param_type(call_type, i); if (is_compound_type(p_type)) return 0; @@ -724,7 +724,7 @@ static int can_inline(ir_node *call, ir_graph *called_graph) /* check res */ for (i = 0; i < ress; ++i) { - type *r_type = get_method_res_type(call_type, i); + ir_type *r_type = get_method_res_type(call_type, i); if (is_compound_type(r_type)) return 0; @@ -746,7 +746,7 @@ int inline_method(ir_node *call, ir_graph *called_graph) { ir_node *ret, *phi; int arity, n_ret, n_exc, n_res, i, j, rem_opt, irn_arity; int exc_handling; - type *called_frame; + ir_type *called_frame; irg_inline_property prop = get_irg_inline_property(called_graph); if ( (prop != irg_inline_forced) && diff --git a/ir/ir/irgraph.h b/ir/ir/irgraph.h index 32905bc95..bb612fd73 100644 --- a/ir/ir/irgraph.h +++ b/ir/ir/irgraph.h @@ -186,8 +186,8 @@ int is_ir_graph(const void *thing); entity *get_irg_entity (const ir_graph *irg); void set_irg_entity (ir_graph *irg, entity *ent); -type *get_irg_frame_type (ir_graph *irg); -void set_irg_frame_type (ir_graph *irg, type *ftp); +ir_type *get_irg_frame_type (ir_graph *irg); +void set_irg_frame_type (ir_graph *irg, ir_type *ftp); ir_node *get_irg_start_block (const ir_graph *irg); void set_irg_start_block (ir_graph *irg, ir_node *node); diff --git a/ir/ir/irgwalk.c b/ir/ir/irgwalk.c index c4016f929..2b775b312 100644 --- a/ir/ir/irgwalk.c +++ b/ir/ir/irgwalk.c @@ -551,7 +551,7 @@ void walk_const_code(irg_walk_func *pre, irg_walk_func *post, void *env) { /* Walk constant array bounds. */ for (i = 0; i < get_irp_n_types(); i++) { - type *tp = get_irp_type(i); + ir_type *tp = get_irp_type(i); if (is_Array_type(tp)) { for (j = 0; j < get_array_n_dimensions(tp); j++) { ir_node *n = get_array_lower_bound(tp, j); diff --git a/ir/ir/irhooks.h b/ir/ir/irhooks.h index f85bbfc49..ae20a4ae8 100644 --- a/ir/ir/irhooks.h +++ b/ir/ir/irhooks.h @@ -152,7 +152,7 @@ typedef struct hook_entry { void (*_hook_new_entity)(void *context, entity *ent); /** This hook is called after a new type was created. */ - void (*_hook_new_type)(void *context, type *tp); + void (*_hook_new_type)(void *context, ir_type *tp); } hook; /** the context for every hook */ diff --git a/ir/ir/irprog.c b/ir/ir/irprog.c index f29c5278a..06d79f44a 100644 --- a/ir/ir/irprog.c +++ b/ir/ir/irprog.c @@ -45,7 +45,7 @@ static ir_prog *new_incomplete_ir_prog (void) { res->kind = k_ir_prog; res->graphs = NEW_ARR_F(ir_graph *, 0); res->pseudo_graphs = NEW_ARR_F(ir_graph *, 0); - res->types = NEW_ARR_F(type *, 0); + res->types = NEW_ARR_F(ir_type *, 0); res->modes = NEW_ARR_F(ir_mode *, 0); #ifdef DEBUG_libfirm @@ -122,7 +122,7 @@ void set_irp_main_irg(ir_graph *main_irg) { irp->main_irg = main_irg; } -type *(get_glob_type)(void) { +ir_type *(get_glob_type)(void) { return _get_glob_type(); } @@ -200,14 +200,14 @@ ir_graph *get_irp_allirg(int pos) { } /* Adds type to the list of types in irp. */ -void add_irp_type(type *typ) { +void add_irp_type(ir_type *typ) { assert (typ != NULL); assert(irp); - ARR_APP1 (type *, irp->types, typ); + ARR_APP1 (ir_type *, irp->types, typ); } /* Remove type form the list of types in irp. */ -void remove_irp_type(type *typ) { +void remove_irp_type(ir_type *typ) { int i; assert(typ); @@ -216,7 +216,7 @@ void remove_irp_type(type *typ) { for(; i < (ARR_LEN(irp->types)) - 1; i++) { irp->types[i] = irp->types[i+1]; } - ARR_SETLEN(type *, irp->types, (ARR_LEN(irp->types)) - 1); + ARR_SETLEN(ir_type *, irp->types, (ARR_LEN(irp->types)) - 1); break; } } @@ -226,11 +226,11 @@ int (get_irp_n_types) (void) { return _get_irp_n_types(); } -type *(get_irp_type) (int pos) { +ir_type *(get_irp_type) (int pos) { return _get_irp_type(pos); } -void set_irp_type(int pos, type *typ) { +void set_irp_type(int pos, ir_type *typ) { assert (irp && typ); assert (pos < (ARR_LEN((irp)->types))); irp->types[pos] = typ; diff --git a/ir/ir/irprog.h b/ir/ir/irprog.h index ba8903f31..52f8b4b97 100644 --- a/ir/ir/irprog.h +++ b/ir/ir/irprog.h @@ -133,23 +133,23 @@ ir_graph *get_irp_allirg(int pos); /** Returns the "global" type of the irp. */ -type *get_glob_type(void); +ir_type *get_glob_type(void); /** Adds type to the list of types in irp. */ -void add_irp_type(type *typ); +void add_irp_type(ir_type *typ); /** Removes type from the list of types, deallocates it and shrinks the list by one. */ -void remove_irp_type(type *typ); +void remove_irp_type(ir_type *typ); /** Returns the number of all types in the irp. */ int get_irp_n_types(void); /** Returns the type at position pos in the irp. */ -type *get_irp_type(int pos); +ir_type *get_irp_type(int pos); /** Overwrites the type at position pos with another type. */ -void set_irp_type(int pos, type *typ); +void set_irp_type(int pos, ir_type *typ); /** Returns the number of all modes in the irp. */ int get_irp_n_modes(void); diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c index d366cf60b..080e30b7d 100644 --- a/ir/ir/irvrfy.c +++ b/ir/ir/irvrfy.c @@ -67,7 +67,7 @@ static void show_entity_failure(ir_node *node) entity *ent = get_irg_entity(irg); if (ent) { - type *ent_type = get_entity_owner(ent); + ir_type *ent_type = get_entity_owner(ent); if (ent_type) { if (ent_type == get_glob_type()) @@ -166,7 +166,7 @@ static void show_proj_failure(ir_node *n) /** * Prints a failure message for a proj from Start */ -static void show_proj_mode_failure(ir_node *n, type *ty) +static void show_proj_mode_failure(ir_node *n, ir_type *ty) { long proj = get_Proj_proj(n); ir_mode *m = get_type_mode(ty); @@ -209,7 +209,7 @@ static void show_node_on_graph(ir_graph *irg, ir_node *n) /** * Show call parameters */ -static void show_call_param(ir_node *n, type *mt) +static void show_call_param(ir_node *n, ir_type *mt) { int i; @@ -230,7 +230,7 @@ static void show_call_param(ir_node *n, type *mt) /** * Show return modes */ -static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i) +static void show_return_modes(ir_graph *irg, ir_node *n, ir_type *mt, int i) { entity *ent = get_irg_entity(irg); @@ -245,7 +245,7 @@ static void show_return_modes(ir_graph *irg, ir_node *n, type *mt, int i) /** * Show return number of results */ -static void show_return_nres(ir_graph *irg, ir_node *n, type *mt) +static void show_return_nres(ir_graph *irg, ir_node *n, ir_type *mt) { entity *ent = get_irg_entity(irg); @@ -590,7 +590,7 @@ static int verify_node_Proj_Proj(ir_node *pred, ir_node *p) { ir_mode *mode = get_irn_mode(p); long proj = get_Proj_proj(p); long nr = get_Proj_proj(pred); - type *mt; /* A method type */ + ir_type *mt; /* A method type */ pred = skip_Id(get_Proj_pred(pred)); ASSERT_AND_RET((get_irn_mode(pred) == mode_T), "Proj from something not a tuple", 0); @@ -868,7 +868,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) { int i; ir_mode *mymode = get_irn_mode(n); ir_mode *mem_mode = get_irn_mode(get_Return_mem(n)); - type *mt; + ir_type *mt; /* Return: BB x M x data1 x ... x datan --> X */ @@ -884,7 +884,7 @@ static int verify_node_Return(ir_node *n, ir_graph *irg) { "Number of results for Return doesn't match number of results in type.", 0, show_return_nres(irg, n, mt);); for (i = get_Return_n_ress(n) - 1; i >= 0; --i) { - type *res_type = get_method_res_type(mt, i); + ir_type *res_type = get_method_res_type(mt, i); if (is_atomic_type(res_type)) { ASSERT_AND_RET_DBG( @@ -1003,7 +1003,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) { ir_mode *mymode = get_irn_mode(n); ir_mode *op1mode = get_irn_mode(get_Call_mem(n)); ir_mode *op2mode = get_irn_mode(get_Call_ptr(n)); - type *mt; + ir_type *mt; int i; /* Call: BB x M x ref x data1 x ... x datan @@ -1045,7 +1045,7 @@ static int verify_node_Call(ir_node *n, ir_graph *irg) { } for (i = 0; i < get_method_n_params(mt); i++) { - type *t = get_method_param_type(mt, i); + ir_type *t = get_method_param_type(mt, i); if (is_atomic_type(t)) { ASSERT_AND_RET_DBG( @@ -1599,7 +1599,7 @@ static int verify_node_CopyB(ir_node *n, ir_graph *irg) { ir_mode *op1mode = get_irn_mode(get_CopyB_mem(n)); ir_mode *op2mode = get_irn_mode(get_CopyB_dst(n)); ir_mode *op3mode = get_irn_mode(get_CopyB_src(n)); - type *t = get_CopyB_type(n); + ir_type *t = get_CopyB_type(n); /* CopyB: BB x M x ref x ref --> M x X */ ASSERT_AND_RET( diff --git a/ir/opt/opt_polymorphy.c b/ir/opt/opt_polymorphy.c index 1d31f68c9..4845a8fdc 100644 --- a/ir/opt/opt_polymorphy.c +++ b/ir/opt/opt_polymorphy.c @@ -28,7 +28,7 @@ * If we find a dynamic type this means that the pointer always points * to an object of this type during runtime. We resolved polymorphy. */ -static type *get_dynamic_type(ir_node *ptr) { +static ir_type *get_dynamic_type(ir_node *ptr) { ptr = skip_Cast(skip_Proj(ptr)); if (get_irn_op(ptr) == op_Alloc) return get_Alloc_type(ptr); @@ -41,7 +41,7 @@ static type *get_dynamic_type(ir_node *ptr) { ir_node *transform_node_Sel(ir_node *node) { ir_node *new_node, *ptr; - type *dyn_tp; + ir_type *dyn_tp; entity *ent = get_Sel_entity(node); if (get_irp_phase_state() == phase_building) return node; @@ -108,7 +108,7 @@ ir_node *transform_node_Load(ir_node *n) { ir_node *field_ptr, *new_node, *ptr; entity *ent; - type *dyn_tp; + ir_type *dyn_tp; if (!(get_opt_optimize() && get_opt_dyn_meth_dispatch())) return n; diff --git a/ir/opt/proc_cloning.c b/ir/opt/proc_cloning.c index 35fad986f..9f1940435 100644 --- a/ir/opt/proc_cloning.c +++ b/ir/opt/proc_cloning.c @@ -115,7 +115,7 @@ static void kill_entry(entry_t *entry) { */ static void process_call(ir_node *call, entity *callee, q_set *hmap) { - type *mtp; + ir_type *mtp; entry_t *key, *entry; ir_node *call_param; int i, n_params; @@ -384,8 +384,8 @@ static void create_clone_proc_irg(entity *ent, quad_t *q) **/ static void change_entity_type(quad_t *q, entity *ent, unsigned *nr) { - type *mtp, *new_mtp, *tp; - ident *tp_name; + ir_type *mtp, *new_mtp, *tp; + ident *tp_name; int i, n_params, n_ress, pos = 0; mtp = get_entity_type(q->ent); @@ -473,7 +473,7 @@ static entity *clone_method(quad_t *q) static ir_node *new_cl_Call(ir_node *call, entity *new_entity, int pos) { ir_node **in; - type *mtp; + ir_type *mtp; int i, n_params, new_params = 0; ir_node *callee; symconst_symbol sym; diff --git a/ir/opt/scalar_replace.c b/ir/opt/scalar_replace.c index 7f6ed79d9..8ffa6da3f 100644 --- a/ir/opt/scalar_replace.c +++ b/ir/opt/scalar_replace.c @@ -64,7 +64,7 @@ typedef struct _path_t { typedef struct _scalars_t { entity *ent; /**< A entity for scalar replacement. */ - type *ent_owner; /**< The owner of this entity. */ + ir_type *ent_owner; /**< The owner of this entity. */ } scalars_t; @@ -268,7 +268,7 @@ static int find_possible_replacements(ir_graph *irg) if (get_irn_op(succ) == op_Sel) { entity *ent = get_Sel_entity(succ); - type *ent_type; + ir_type *ent_type; if (get_entity_link(ent) == ADDRESS_TAKEN) continue; @@ -674,7 +674,7 @@ void scalar_replacement_opt(ir_graph *irg) ir_mode **modes; set *set_ent; pset *sels; - type *ent_type; + ir_type *ent_type; ir_graph *rem; if (! get_opt_scalar_replacement()) -- 2.20.1