From: Florian Liekweg Date: Thu, 29 Apr 2004 13:59:12 +0000 (+0000) Subject: Removed C++-Style comments --flo X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=493a2be714558086f03e0e2d17285e039c83a011;p=libfirm Removed C++-Style comments --flo [r2822] --- diff --git a/firmjni/auxilliary/Heapanal.c b/firmjni/auxilliary/Heapanal.c index da735d4aa..a3e3e4011 100644 --- a/firmjni/auxilliary/Heapanal.c +++ b/firmjni/auxilliary/Heapanal.c @@ -7,13 +7,13 @@ # include "src/heapanal.h" # include "src/interprete.h" -// boilerplate stuff: +/* boilerplate stuff: */ #include "libfirm/irvrfy.h" #include "libfirm/trvrfy.h" #include "libfirm/irdump.h" -// I/O: +/* I/O: */ # include /* @@ -23,7 +23,7 @@ */ void Java_firmjni_Heapanal_initAnal (JNIEnv *env, jclass clazz) { - // from interprete.c: + /* from interprete.c: */ init_interprete (); } @@ -61,28 +61,28 @@ void Java_firmjni_Heapanal_analHeap__ (JNIEnv *env, jclass clazz) fprintf (stdout, "Ajacs Boilerplate:\n"); { - entity **free_methods = 0; - int arr_len = 0; + entity **free_methods = 0; + int arr_len = 0; /* replace static constant fields by constants @@@ This corrects some code that is invalid Firm!!! Execute before irg_vrfy(). */ - // ??? - // opt_load_const_static(); + /* ??? */ + /* opt_load_const_static(); */ - /* dump graphs as they come out of the front end */ - dump_file_suffix = "-fe"; - dump_all_types (); - dump_class_hierarchy (true); - dump_all_ir_graphs(dump_ir_block_graph); - dump_all_ir_graphs(dump_ir_block_graph_w_types); - dump_all_ir_graphs(dump_cfg); + /* dump graphs as they come out of the front end */ + dump_file_suffix = "-fe"; + dump_all_types (); + dump_class_hierarchy (true); + dump_all_ir_graphs(dump_ir_block_graph); + dump_all_ir_graphs(dump_ir_block_graph_w_types); + dump_all_ir_graphs(dump_cfg); /* verify constructed graphs */ for (i = 0; i < get_irp_n_irgs(); i++) - irg_vrfy(get_irp_irg(i)); + irg_vrfy(get_irp_irg(i)); - /* verify something */ + /* verify something */ tr_vrfy(); @@ -90,20 +90,20 @@ void Java_firmjni_Heapanal_analHeap__ (JNIEnv *env, jclass clazz) * test loop construction intraprocedural */ for (i = 0; i < get_irp_n_irgs(); i++) { - construct_backedges(get_irp_irg(i)); + construct_backedges(get_irp_irg(i)); if (1) { - dump_loop_information(); - dump_file_suffix = "-1.2-intra-loop"; - dump_ir_block_graph(get_irp_irg(i)); - dont_dump_loop_information(); - dump_loop_tree(get_irp_irg(i), "-1.2-intra"); + dump_loop_information(); + dump_file_suffix = "-1.2-intra-loop"; + dump_ir_block_graph(get_irp_irg(i)); + dont_dump_loop_information(); + dump_loop_tree(get_irp_irg(i), "-1.2-intra"); } } - DDMG (get_irp_main_irg ()); - assert(get_irp_main_irg()); - assert(get_irg_ent(get_irp_main_irg())); + DDMG (get_irp_main_irg ()); + assert(get_irp_main_irg()); + assert(get_irg_ent(get_irp_main_irg())); /** Do interprocedural optimizations **/ @@ -112,43 +112,43 @@ void Java_firmjni_Heapanal_analHeap__ (JNIEnv *env, jclass clazz) Optimizes polymorphic calls.*/ cgana(&arr_len, &free_methods); /* Remove methods that are never called. */ - // gc_irgs(arr_len, free_methods); + /* gc_irgs(arr_len, free_methods); */ /* Build the interprocedural dataflow representation */ cg_construct(arr_len, free_methods); /* Test construction of interprocedural loop information */ - // construct_ip_backedges(); + /* construct_ip_backedges(); */ - dump_loop_information(); - dump_file_suffix = "-1.2-inter-loop"; - dump_all_cg_block_graph(); - dont_dump_loop_information(); - dump_loop_tree(get_irp_main_irg(), "-1.2-inter"); + dump_loop_information(); + dump_file_suffix = "-1.2-inter-loop"; + dump_all_cg_block_graph(); + dont_dump_loop_information(); + dump_loop_tree(get_irp_main_irg(), "-1.2-inter"); - fprintf (stdout, "HA:\n"); - DDMG (get_irp_main_irg ()); + fprintf (stdout, "HA:\n"); + DDMG (get_irp_main_irg ()); - set_max_chi_height(8); /* change ad lib */ - set_initial_context_depth(4); /* change as needed */ - ha_analyse_heap(get_irg_ent(get_irp_main_irg()), 1); + set_max_chi_height(8); /* change ad lib */ + set_initial_context_depth(4); /* change as needed */ + ha_analyse_heap(get_irg_ent(get_irp_main_irg()), 1); /* Remove the interprocedural dataflow representation */ - free(free_methods); - cg_destruct(); + free(free_methods); + cg_destruct(); - /* verify optimized graphs */ - for (i = 0; i < get_irp_n_irgs(); i++) { - irg_vrfy(get_irp_irg(i)); - } + /* verify optimized graphs */ + for (i = 0; i < get_irp_n_irgs(); i++) { + irg_vrfy(get_irp_irg(i)); + } - tr_vrfy(); + tr_vrfy(); } set_opt_dump_abstvals (1); - // ToDo: Dump ??? + /* ToDo: Dump ??? */ fprintf (stdout, "Bye, Heap!\n"); } @@ -157,6 +157,9 @@ void Java_firmjni_Heapanal_analHeap__ (JNIEnv *env, jclass clazz) /* * $Log$ + * Revision 1.2 2004/04/29 13:59:11 liekweg + * Removed C++-Style comments --flo + * * Revision 1.1 2004/04/29 12:11:36 liekweg * Moved ... to aux --flo * diff --git a/ir/ana/irscc.c b/ir/ana/irscc.c index fab28267f..eb3d6a059 100644 --- a/ir/ana/irscc.c +++ b/ir/ana/irscc.c @@ -53,7 +53,7 @@ typedef struct scc_info { bool in_stack; /* Marks whether node is on the stack. */ int dfn; /* Depth first search number. */ int uplink; /* dfn number of ancestor. */ - // ir_loop *loop; /* Refers to the containing loop. */ + /* ir_loop *loop; *//* Refers to the containing loop. */ /* struct section *section; xset def; @@ -70,56 +70,56 @@ static INLINE scc_info* new_scc_info(void) { static INLINE void mark_irn_in_stack (ir_node *n) { assert(get_irn_link(n)); - // to slow - //((scc_info *)get_irn_link(n))->in_stack = true; + /* to slow */ + /* ((scc_info *)get_irn_link(n))->in_stack = true; */ ((scc_info *)n->link)->in_stack = true; } static INLINE void mark_irn_not_in_stack (ir_node *n) { assert(get_irn_link(n)); - // to slow - //((scc_info *)get_irn_link(n))->in_stack = false; + /* to slow */ + /* ((scc_info *)get_irn_link(n))->in_stack = false; */ ((scc_info *)n->link)->in_stack = false; } static INLINE bool irn_is_in_stack (ir_node *n) { assert(get_irn_link(n)); - // to slow - //return ((scc_info *)get_irn_link(n))->in_stack; + /* to slow */ + /* return ((scc_info *)get_irn_link(n))->in_stack; */ return ((scc_info *)n->link)->in_stack; } static INLINE void set_irn_uplink (ir_node *n, int uplink) { assert(get_irn_link(n)); - // to slow - //((scc_info *)get_irn_link(n))->uplink = uplink; + /* to slow */ + /* ((scc_info *)get_irn_link(n))->uplink = uplink; */ ((scc_info *)n->link)->uplink = uplink; } static INLINE int get_irn_uplink (ir_node *n) { assert(get_irn_link(n)); - // to slow - //return ((scc_info *)get_irn_link(n))->uplink; + /* from fast to slow */ + /* return ((scc_info *)get_irn_link(n))->uplink; */ return ((scc_info *)n->link)->uplink; } static INLINE void set_irn_dfn (ir_node *n, int dfn) { assert(get_irn_link(n)); - // to slow - //((scc_info *)get_irn_link(n))->dfn = dfn; + /* to slow */ + /* ((scc_info *)get_irn_link(n))->dfn = dfn; */ ((scc_info *)n->link)->dfn = dfn; } static INLINE int get_irn_dfn (ir_node *n) { assert(get_irn_link(n)); - // to slow - //return ((scc_info *)get_irn_link(n))->dfn; + /* to slow */ + /* return ((scc_info *)get_irn_link(n))->dfn; */ return ((scc_info *)n->link)->dfn; } @@ -529,8 +529,8 @@ init_node (ir_node *n, void *env) { The mem is not lost as its on the obstack. */ ir_node *cb = get_Proj_pred(n); if ((intern_get_irn_op(cb) == op_CallBegin) || - (intern_get_irn_op(cb) == op_EndReg) || - (intern_get_irn_op(cb) == op_EndExcept)) { + (intern_get_irn_op(cb) == op_EndReg) || + (intern_get_irn_op(cb) == op_EndExcept)) { init_node(cb, NULL); init_node(get_nodes_Block(cb), NULL); } @@ -637,21 +637,21 @@ find_irg_on_stack (ir_node *n) { m = stack[i]; /*printf(" Visiting %d ", i); DDMN(m);*/ if (is_ip_cfop(m)) { - current_ir_graph = get_irn_irg(m); - break; + current_ir_graph = get_irn_irg(m); + break; } if (intern_get_irn_op(m) == op_Filter) { - /* Find the corresponding ip_cfop */ - ir_node *pred = stack[i+1]; - int j; - for (j = 0; j < get_Filter_n_cg_preds(m); j++) - if (get_Filter_cg_pred(m, j) == pred) break; - if (j >= get_Filter_n_cg_preds(m)) - /* It is a filter we didn't pass as the predecessors are marked. */ - continue; - assert(get_Filter_cg_pred(m, j) == pred); - switch_irg(m, j); - break; + /* Find the corresponding ip_cfop */ + ir_node *pred = stack[i+1]; + int j; + for (j = 0; j < get_Filter_n_cg_preds(m); j++) + if (get_Filter_cg_pred(m, j) == pred) break; + if (j >= get_Filter_n_cg_preds(m)) + /* It is a filter we didn't pass as the predecessors are marked. */ + continue; + assert(get_Filter_cg_pred(m, j) == pred); + switch_irg(m, j); + break; } } } @@ -825,7 +825,7 @@ static void scc (ir_node *n) { if (is_backedge(n, i)) continue; m = intern_get_irn_n(n, i); /* get_irn_ip_pred(n, i); */ - //if ((!m) || (intern_get_irn_op(m) == op_Unknown)) continue; + /* if ((!m) || (intern_get_irn_op(m) == op_Unknown)) continue; */ scc (m); if (irn_is_in_stack(m)) { /* Uplink of m is smaller if n->m is a backedge. @@ -868,10 +868,10 @@ static void scc (ir_node *n) { pop_scc_unmark_visit (n); /* and recompute it in a better order; and so that it goes into the new loop. */ - // GL @@@ remove experimental stuff rem = find_irg_on_stack(tail); + /* GL @@@ remove experimental stuff rem = find_irg_on_stack(tail); */ scc (tail); - // GL @@@ remove experimental stuff current_ir_graph = rem; + /* GL @@@ remove experimental stuff current_ir_graph = rem; */ assert (irn_visited(n)); #if NO_LOOPS_WITHOUT_HEAD diff --git a/ir/ana/irsimpletype.c b/ir/ana/irsimpletype.c index 696d3398f..a8546ed9a 100644 --- a/ir/ana/irsimpletype.c +++ b/ir/ana/irsimpletype.c @@ -95,7 +95,7 @@ static type *find_type_for_Proj(ir_node *n) { tp = find_pointer_type_to(get_glob_type()); else if (get_Proj_proj(n) == pns_value_arg_base) { VERBOSE_UNKNOWN_TYPE(("Value arg base proj %ld from Start: unknown type\n", get_irn_node_nr(n))); - tp = unknown_type; //find_pointer_type_to(get....(get_entity_type(get_irg_ent(get_Start_irg(pred))))); + tp = unknown_type; /* find_pointer_type_to(get....(get_entity_type(get_irg_ent(get_Start_irg(pred))))); */ } else { VERBOSE_UNKNOWN_TYPE(("Proj %ld %ld from Start: unknown type\n", get_Proj_proj(n), get_irn_node_nr(n))); tp = unknown_type; @@ -105,7 +105,7 @@ static type *find_type_for_Proj(ir_node *n) { /* value args pointer */ if (get_Proj_proj(n) == pncl_value_res_base) { VERBOSE_UNKNOWN_TYPE(("Value res base Proj %ld from Call: unknown type\n", get_irn_node_nr(n))); - tp = unknown_type; //find_pointer_type_to(get....get_Call_type(pred)); + tp = unknown_type; /* find_pointer_type_to(get....get_Call_type(pred)); */ } else { VERBOSE_UNKNOWN_TYPE(("Proj %ld %ld from Call: unknown type\n", get_Proj_proj(n), get_irn_node_nr(n))); tp = unknown_type; @@ -123,7 +123,7 @@ static type *find_type_for_node(ir_node *n) { type *tp1 = NULL, *tp2 = NULL; ir_node *a = NULL, *b = NULL; - //DDMN(n); + /* DDMN(n); */ if (is_unop(n)) { a = get_unop_op(n); @@ -153,8 +153,8 @@ static type *find_type_for_node(ir_node *n) { type *ana_res_type = get_irn_type(get_Return_res(n, i)); if (ana_res_type == unknown_type) continue; if (res_type != ana_res_type && "return value has wrong type") { - DDMN(n); - assert(res_type == ana_res_type && "return value has wrong type"); + DDMN(n); + assert(res_type == ana_res_type && "return value has wrong type"); } } */ @@ -206,7 +206,7 @@ static type *find_type_for_node(ir_node *n) { tp1 = compute_irn_type(get_Phi_pred(n, i)); assert(tp1 != initial_type); if ((tp1 != phi_cycle_type) && (tp1 != none_type)) - break; + break; } /* find a second real type */ @@ -214,18 +214,18 @@ static type *find_type_for_node(ir_node *n) { for (; (i < n_preds); ++i) { tp2 = compute_irn_type(get_Phi_pred(n, i)); if ((tp2 == phi_cycle_type) || (tp2 == none_type)) { - tp2 = tp1; - continue; + tp2 = tp1; + continue; } if (tp2 != tp1) break; } - //printf("Types in Phi %s and %s \n", get_type_name(tp1), get_type_name(tp2)); + /* printf("Types in Phi %s and %s \n", get_type_name(tp1), get_type_name(tp2)); */ if (tp1 == tp2) { tp = tp1; break; } VERBOSE_UNKNOWN_TYPE(("Phi %ld with two different types: %s, %s: unknown type.\n", get_irn_node_nr(n), - get_type_name(tp1), get_type_name(tp2))); + get_type_name(tp1), get_type_name(tp2))); tp = unknown_type; } break; case iro_Load: { @@ -233,7 +233,7 @@ static type *find_type_for_node(ir_node *n) { if (intern_get_irn_op(a) == op_Sel) tp = get_entity_type(get_Sel_entity(a)); else if ((intern_get_irn_op(a) == op_Const) && - (tarval_is_entity(get_Const_tarval(a)))) + (tarval_is_entity(get_Const_tarval(a)))) tp = get_entity_type(tarval_to_entity(get_Const_tarval(a))); else if (is_pointer_type(compute_irn_type(a))) { tp = get_pointer_points_to_type(get_irn_type(a)); @@ -257,21 +257,21 @@ static type *find_type_for_node(ir_node *n) { /* catch special cases with fallthrough to binop/unop cases in default. */ case iro_Sub: { if (mode_is_int(intern_get_irn_mode(n)) && - mode_is_reference(intern_get_irn_mode(a)) && - mode_is_reference(intern_get_irn_mode(b)) ) { + mode_is_reference(intern_get_irn_mode(a)) && + mode_is_reference(intern_get_irn_mode(b)) ) { VERBOSE_UNKNOWN_TYPE(("Sub %ld ptr - ptr = int: unknown type\n", get_irn_node_nr(n))); tp = unknown_type; break; } } /* fall through to Add. */ case iro_Add: { if (mode_is_reference(intern_get_irn_mode(n)) && - mode_is_reference(intern_get_irn_mode(a)) && - mode_is_int(intern_get_irn_mode(b)) ) { + mode_is_reference(intern_get_irn_mode(a)) && + mode_is_int(intern_get_irn_mode(b)) ) { tp = tp1; break; } if (mode_is_reference(intern_get_irn_mode(n)) && - mode_is_int(intern_get_irn_mode(a)) && - mode_is_reference(intern_get_irn_mode(b)) ) { + mode_is_int(intern_get_irn_mode(a)) && + mode_is_reference(intern_get_irn_mode(b)) ) { tp = tp2; break; } goto default_code; @@ -295,15 +295,15 @@ static type *find_type_for_node(ir_node *n) { if (is_binop(n)) { if (tp1 == tp2) { - tp = tp1; - break; + tp = tp1; + break; } if((tp1 == phi_cycle_type) || (tp2 == phi_cycle_type)) { - tp = phi_cycle_type; - break; + tp = phi_cycle_type; + break; } VERBOSE_UNKNOWN_TYPE(("Binop %ld with two different types: %s, %s: unknown type \n", get_irn_node_nr(n), - get_type_name(tp1), get_type_name(tp2))); + get_type_name(tp1), get_type_name(tp2))); tp = unknown_type; break; } @@ -312,14 +312,14 @@ static type *find_type_for_node(ir_node *n) { } break; /* default */ } /* end switch */ - //printf (" found %s ", get_type_name(tp)); DDM; + /* printf (" found %s ", get_type_name(tp)); DDM; */ return tp; } static type* compute_irn_type(ir_node *n) { - //DDMN(n); + /* DDMN(n); */ type *tp = get_irn_type(n); @@ -328,7 +328,7 @@ static type* compute_irn_type(ir_node *n) { set_irn_type(n, tp); } - //printf (" found %s ", get_type_name(tp)); DDM; + /* printf (" found %s ", get_type_name(tp)); DDM; */ return tp; } @@ -337,7 +337,7 @@ static void compute_type(ir_node *n, void *env) { type *tp = get_irn_type(n); if (tp == phi_cycle_type) { - //printf(" recomputing for phi_cycle_type "); DDMN(n); + /* printf(" recomputing for phi_cycle_type "); DDMN(n); */ set_irn_type(n, initial_type); } diff --git a/ir/ana/irsimpletype.h b/ir/ana/irsimpletype.h index 9f7517463..d52a89807 100644 --- a/ir/ana/irsimpletype.h +++ b/ir/ana/irsimpletype.h @@ -65,6 +65,6 @@ void free_simple_type_information(void); * Not yet implemented, but I guess we want this for iropt, to find the * type for newly allocated constants. */ -//type *analyse_irn_type(ir_node *node); +/* type *analyse_irn_type(ir_node *node); */ #endif /* _IRSIMPLETYPE_H_ */ diff --git a/ir/common/firmwalk.c b/ir/common/firmwalk.c index 0f8442409..2d5925553 100644 --- a/ir/common/firmwalk.c +++ b/ir/common/firmwalk.c @@ -45,13 +45,13 @@ typedef struct { get_firm_walk_link. */ } fw_data; -//@{ +/*@{ */ /** Access macros to fw_data structure */ #define FW_GET_DATA_LIST(s) ((s)->list) #define FW_SET_DATA_LIST(s, t) ((s)->list = (t)) #define FW_GET_DATA_LINK(s) ((s)->link) #define FW_SET_DATA_LINK(s, t) ((s)->link = (t)) -//@} +/*@} */ /** Returns own data struct of the firm walker. * @@ -97,7 +97,7 @@ fw_data *fw_get_data(void *thing) } } break; - default: {} // other kinds of firm nodes + default: {} /* other kinds of firm nodes */ } return data; @@ -135,11 +135,11 @@ void fw_free_data(void *thing) } } break; - default: {} // other kinds of firm nodes + default: {} /* other kinds of firm nodes */ } } -// documentation in header file +/* documentation in header file */ void set_firm_walk_link(void *thing, void *link) { fw_data *data; @@ -168,11 +168,11 @@ void set_firm_walk_link(void *thing, void *link) case k_ir_mode: set_mode_link(thing, link); break; - default: {} // other kinds of firm nodes + default: {} /* other kinds of firm nodes */ } } -// documentation in header file +/* documentation in header file */ void *get_firm_walk_link(void *thing) { fw_data *data; @@ -227,7 +227,7 @@ void fw_collect_tore(type_or_ent *tore, void *env) switch (get_kind(tore)) { case k_entity: ent = (entity *)tore; - // append entity to list + /* append entity to list */ set_entity_link(ent, NULL); if (!pmap_contains(entity_map, ent)) pmap_insert(entity_map, ent, env); @@ -235,7 +235,7 @@ void fw_collect_tore(type_or_ent *tore, void *env) case k_type: tp = (type *)tore; mode = get_type_mode(tp); - // append type to list + /* append type to list */ set_type_link(tp, NULL); if (!pmap_contains(type_map, tp)) pmap_insert(type_map, tp, env); @@ -345,11 +345,11 @@ void firm_walk_init(firm_walk_flags flags) pmap_insert(mode_map, mode_b, NULL); */ - // Collect all types (also unused types) if flag is set + /* Collect all types (also unused types) if flag is set */ if (FW_WITH_ALL_TYPES & flags) type_walk(fw_collect_tore, NULL, NULL); - // for each ir graph + /* for each ir graph */ for (i = 0; i < get_irp_n_irgs(); i++) { ir_graph *irg = get_irp_irg(i); @@ -375,7 +375,7 @@ void firm_walk_finalize(void) pmap_destroy(entity_map); entity_map = NULL; - // free all collected data from ir graphs and nodes + /* free all collected data from ir graphs and nodes */ for (i = 0; i < get_irp_n_irgs(); i++) { ir_graph *irg = get_irp_irg(i); @@ -464,12 +464,12 @@ void firm_walk(firm_walk_interface *wif) irn_list = FW_GET_DATA_LIST(data); irn_list_len = ARR_LEN(irn_list); - // call block as prefix ir node + /* call block as prefix ir node */ if ((wif->do_node) && (wif->flags & FW_DUMP_BLOCK_AS_IRN & !FW_DUMP_IRN_IN_PREFIX)) wif->do_node(block, wif->env); - // do ir nodes in prefix or postfix order? + /* do ir nodes in prefix or postfix order? */ if (wif->flags & FW_DUMP_IRN_IN_PREFIX) irn_i = irn_list_len-1; else @@ -479,13 +479,13 @@ void firm_walk(firm_walk_interface *wif) { if (wif->do_node) wif->do_node((ir_node *)irn_list[irn_i], wif->env); - // do ir nodes in prefix or postfix order? + /* do ir nodes in prefix or postfix order? */ if (wif->flags & FW_DUMP_IRN_IN_PREFIX) irn_i--; else irn_i++; } - // call block as postfix ir node + /* call block as postfix ir node */ if ((wif->do_node) && (wif->flags & (FW_DUMP_BLOCK_AS_IRN | FW_DUMP_IRN_IN_PREFIX))) wif->do_node(block, wif->env); @@ -493,11 +493,11 @@ void firm_walk(firm_walk_interface *wif) /* wall over all block's ir nodes nested end =============== */ if (wif->do_block_finalize) wif->do_block_finalize(current_ir_graph, wif->env); - } // for each block + } /* for each block */ /* walk over all irg's block nested end ====================== */ - } // for each ir graph irg + } /* for each ir graph irg */ if (wif->do_graph_finalize) wif->do_graph_finalize(wif->env); /** ### ToDo: Dump const_code_irg ?? No! Dump const code with entities, types etc. */ diff --git a/ir/common/firmwalk.h b/ir/common/firmwalk.h index 91b80adaa..56ce8228a 100644 --- a/ir/common/firmwalk.h +++ b/ir/common/firmwalk.h @@ -79,12 +79,12 @@ typedef void firm_walk_type_func(type *tp, void *env); typedef void firm_walk_entity_func(entity *ent, void *env); /** Graph callback function definition */ typedef void firm_walk_graph_func(ir_graph *irg, void *env); -//@{ +/* @{ */ /** Block callback function definition */ typedef void firm_walk_block_init_func(ir_graph *irg, void *env); typedef void firm_walk_block_func(ir_node *block, void *env); typedef void firm_walk_block_finalize_func(ir_graph *irg, void *env); -//@} +/* @} */ /** Node callback function definition */ typedef void firm_walk_node_func (ir_node *irn, void *env); @@ -112,15 +112,15 @@ typedef enum /** Interface of the firm walker */ typedef struct { - //@{ + /* @{ */ /** Interface function to dump all used and internal modes. Internal modes are: BB, X, M and T */ firm_walk_init_func *do_mode_init; firm_walk_mode_func *do_mode; firm_walk_finalize_func *do_mode_finalize; - //@} + /* @} */ - //@{ + /* @{ */ /** Interface to dump all collected types. * * @node To dump all (not only used types by default) a special walk @@ -128,14 +128,14 @@ typedef struct firm_walk_init_func *do_type_init; firm_walk_type_func *do_type; firm_walk_finalize_func *do_type_finalize; - //@} + /* @} */ - //@{ + /* @{ */ /** Dumping interface for entities */ firm_walk_init_func *do_entity_init; firm_walk_entity_func *do_entity; firm_walk_finalize_func *do_entity_finalize; - //@} + /* @} */ /** Dumps all graphs and subnodes. * @@ -156,14 +156,14 @@ typedef struct firm_walk_graph_func *do_graph; firm_walk_finalize_func *do_graph_finalize; - //@{ + /* @{ */ /** Dumping interface for blocks. If blocks should be handled like * like a normal ir node, a special walker flag could be set. * @see do_graph */ firm_walk_block_init_func *do_block_init; firm_walk_block_func *do_block; firm_walk_block_finalize_func *do_block_finalize; - //@} + /* @} */ /** Dumping interface for ir nodes * @see do_graph */ diff --git a/ir/ident/ident.h b/ir/ident/ident.h index 767331ad4..cfba365cc 100644 --- a/ir/ident/ident.h +++ b/ir/ident/ident.h @@ -120,7 +120,7 @@ int id_is_suffix (ident *suffix, ident *id); * * @see new_get_id_str(), id_from_str(), get_id_str(), id_is_prefix() */ -//int id_contains(ident *infix, ident *id); +/* int id_contains(ident *infix, ident *id); */ /** * Return true if an ident contains a given character. diff --git a/ir/ir/ircgcons.c b/ir/ir/ircgcons.c index 8df89ed7c..6efb84f1e 100644 --- a/ir/ir/ircgcons.c +++ b/ir/ir/ircgcons.c @@ -27,12 +27,12 @@ #include "irflag_t.h" -// # define CATE_jni +/* # define CATE_jni */ /* Datenstruktur für jede Methode */ typedef struct { int count; /* GL: anzahl aufrufer */ - bool open; /* offene Methode (mit unbekanntem Aufrufer) */ + bool open; /* offene Methode (mit unbekanntem Aufrufer) */ ir_node * reg, * mem, ** res; /* EndReg, Mem und Rückgabewerte */ ir_node * except, * except_mem; /* EndExcept und Mem für Ausnahmeabbruch */ } irg_data_t; @@ -61,14 +61,14 @@ static void caller_init(int arr_length, entity ** free_methods) { for (call = get_irn_link(get_irg_end(irg)); call; call = get_irn_link(call)) { if (intern_get_irn_op(call) != op_Call) continue; for (j = get_Call_n_callees(call) - 1; j >= 0; --j) { - entity * ent = get_Call_callee(call, j); - if (ent) { - irg_data_t * data = get_entity_link(ent); + entity * ent = get_Call_callee(call, j); + if (ent) { + irg_data_t * data = get_entity_link(ent); # ifndef CATE_jni - assert(get_entity_irg(ent) && data); - ++data->count; + assert(get_entity_irg(ent) && data); + ++data->count; # endif /* ndef CATE_jni */ - } + } } } } @@ -182,8 +182,8 @@ static void prepare_irg_end_except(ir_graph * irg, irg_data_t * data); * block has no predecessors. */ static INLINE ir_node *get_cg_Unknown(ir_mode *m) { assert((get_Block_n_cfgpreds(get_irg_start_block(get_irp_main_irg())) == 1) && - (get_nodes_block(get_Block_cfgpred(get_irg_start_block(get_irp_main_irg()), 0)) == - get_irg_start_block(get_irp_main_irg()))); + (get_nodes_block(get_Block_cfgpred(get_irg_start_block(get_irp_main_irg()), 0)) == + get_irg_start_block(get_irp_main_irg()))); return new_r_Unknown(get_irp_main_irg(), m); } @@ -208,7 +208,7 @@ static void prepare_irg(ir_graph * irg, irg_data_t * data) { * den Start-Block verschieben. */ for (proj = get_irn_link(get_irg_start(irg)); proj; proj = get_irn_link(proj)) { if (get_Proj_pred(proj) != get_irg_start(irg) - || (get_Proj_proj(proj) != pns_initial_exec && get_Proj_proj(proj) != pns_args)) { + || (get_Proj_proj(proj) != pns_initial_exec && get_Proj_proj(proj) != pns_args)) { ir_node * filter = exchange_proj(proj); set_Filter_cg_pred_arr(filter, n_callers, in); } else { @@ -226,8 +226,8 @@ static void prepare_irg(ir_graph * irg, irg_data_t * data) { ir_node * filter = get_Id_pred(proj); assert(get_irn_op(filter) == op_Filter); if (filter != link && get_irn_link(filter) == NULL) { - set_irn_link(link, filter); - link = filter; + set_irn_link(link, filter); + link = filter; } } } @@ -240,7 +240,7 @@ static void prepare_irg(ir_graph * irg, irg_data_t * data) { set_Block_cg_cfgpred(start_block, 0, get_cg_Unknown(mode_X)); for (proj = get_irn_link(get_irg_start(irg)); proj; proj = get_irn_link(proj)) { if (intern_get_irn_op(proj) == op_Filter) { - set_Filter_cg_pred(proj, 0, get_cg_Unknown(intern_get_irn_mode(proj))); + set_Filter_cg_pred(proj, 0, get_cg_Unknown(intern_get_irn_mode(proj))); } } data->count = 1; @@ -265,10 +265,10 @@ static void prepare_irg_end(ir_graph * irg, irg_data_t * data) { for (i = get_Block_n_cfgpreds(end_block) - 1; i >= 0; --i) { if (intern_get_irn_op(cfgpred_arr[i]) == op_Return) { if (ret_arr) { - ARR_APP1(ir_node *, ret_arr, cfgpred_arr[i]); + ARR_APP1(ir_node *, ret_arr, cfgpred_arr[i]); } else { - ret_arr = NEW_ARR_F(ir_node *, 1); - ret_arr[0] = cfgpred_arr[i]; + ret_arr = NEW_ARR_F(ir_node *, 1); + ret_arr[0] = cfgpred_arr[i]; } ++n_ret; } @@ -304,14 +304,14 @@ static void prepare_irg_end(ir_graph * irg, irg_data_t * data) { ir_mode *mode = NULL; /* In[0] could be a Bad node with wrong mode. */ for (i = n_ret - 1; i >= 0; --i) { - in[i] = get_Return_res(ret_arr[i], j); - if (!mode && intern_get_irn_mode(in[i]) != mode_T) - mode = intern_get_irn_mode(in[i]); + in[i] = get_Return_res(ret_arr[i], j); + if (!mode && intern_get_irn_mode(in[i]) != mode_T) + mode = intern_get_irn_mode(in[i]); } if (mode) - data->res[j] = new_Phi(n_ret, in, mode); + data->res[j] = new_Phi(n_ret, in, mode); else /* All preds are Bad */ - data->res[j] = new_Bad(); + data->res[j] = new_Bad(); } DEL_ARR_F(in); @@ -332,10 +332,10 @@ static void prepare_irg_end_except(ir_graph * irg, irg_data_t * data) { for (i = get_Block_n_cfgpreds(end_block) - 1; i >= 0; --i) { if (intern_get_irn_op(cfgpred_arr[i]) != op_Return) { if (except_arr) { - ARR_APP1(ir_node *, except_arr, cfgpred_arr[i]); + ARR_APP1(ir_node *, except_arr, cfgpred_arr[i]); } else { - except_arr = NEW_ARR_F(ir_node *, 1); - except_arr[0] = cfgpred_arr[i]; + except_arr = NEW_ARR_F(ir_node *, 1); + except_arr[0] = cfgpred_arr[i]; } ++n_except; } @@ -350,20 +350,20 @@ static void prepare_irg_end_except(ir_graph * irg, irg_data_t * data) { for (i = n_except - 1; i >= 0; --i) { ir_node * node = skip_Proj(except_arr[i]); if (intern_get_irn_op(node) == op_Call) { - in[i] = new_r_Proj(irg, get_nodes_Block(node), node, mode_M, 3); + in[i] = new_r_Proj(irg, get_nodes_Block(node), node, mode_M, 3); } else if (intern_get_irn_op(node) == op_Raise) { - in[i] = new_r_Proj(irg, get_nodes_Block(node), node, mode_M, 1); + in[i] = new_r_Proj(irg, get_nodes_Block(node), node, mode_M, 1); } else { - assert(is_fragile_op(node)); - /* We rely that all cfops have the memory output at the same position. */ - in[i] = new_r_Proj(irg, get_nodes_Block(node), node, mode_M, 0); + assert(is_fragile_op(node)); + /* We rely that all cfops have the memory output at the same position. */ + in[i] = new_r_Proj(irg, get_nodes_Block(node), node, mode_M, 0); } } data->except_mem = new_Phi(n_except, in, mode_M); /* This Phi is a merge, therefor needs not be kept alive. It might be optimized away, though. */ if (get_End_keepalive(end, get_End_n_keepalives(end)-1 ) - == data->except_mem) + == data->except_mem) set_End_keepalive(end, get_End_n_keepalives(end)-1, new_Bad()); DEL_ARR_F(in); } @@ -424,7 +424,7 @@ static void move_nodes(ir_node * from_block, ir_node * to_block, ir_node * node) /* Abhängigkeiten vom Start-Block und den Filter-Operationen im * Start-Block auf den Aufrufer hinzufügen. */ static void construct_start(entity * caller, entity * callee, - ir_node * call, ir_node * exec) { + ir_node * call, ir_node * exec) { irg_data_t *data = get_entity_link(callee); ir_graph *irg = get_entity_irg(callee); ir_node *start = get_irg_start(irg); @@ -433,7 +433,7 @@ static void construct_start(entity * caller, entity * callee, assert(irg); assert(get_entity_peculiarity(callee) == peculiarity_existent); /* Else data is not initalized. */ assert((0 <= data->count) && - (data->count < get_Block_cg_n_cfgpreds(get_nodes_Block(start)))); + (data->count < get_Block_cg_n_cfgpreds(get_nodes_Block(start)))); set_Block_cg_cfgpred(get_nodes_Block(start), data->count, exec); for (filter = get_irn_link(start); filter; filter = get_irn_link(filter)) { @@ -441,24 +441,24 @@ static void construct_start(entity * caller, entity * callee, if (get_Proj_pred(filter) == start) { switch ((int) get_Proj_proj(filter)) { case pns_global_store: - set_Filter_cg_pred(filter, data->count, get_Call_mem(call)); - break; + set_Filter_cg_pred(filter, data->count, get_Call_mem(call)); + break; case pns_frame_base: - /* "frame_base" wird nur durch Unknown dargestellt. Man kann ihn aber - * auch explizit darstellen, wenn sich daraus Vorteile für die - * Datenflussanalyse ergeben. */ - set_Filter_cg_pred(filter, data->count, get_cg_Unknown(intern_get_irn_mode(filter))); - break; + /* "frame_base" wird nur durch Unknown dargestellt. Man kann ihn aber + * auch explizit darstellen, wenn sich daraus Vorteile für die + * Datenflussanalyse ergeben. */ + set_Filter_cg_pred(filter, data->count, get_cg_Unknown(intern_get_irn_mode(filter))); + break; case pns_globals: - /* "globals" wird nur durch Unknown dargestellt. Man kann ihn aber auch - * explizit darstellen, wenn sich daraus Vorteile für die - * Datenflussanalyse ergeben. */ - set_Filter_cg_pred(filter, data->count, get_cg_Unknown(intern_get_irn_mode(filter))); - break; + /* "globals" wird nur durch Unknown dargestellt. Man kann ihn aber auch + * explizit darstellen, wenn sich daraus Vorteile für die + * Datenflussanalyse ergeben. */ + set_Filter_cg_pred(filter, data->count, get_cg_Unknown(intern_get_irn_mode(filter))); + break; default: - /* not reached */ - assert(0 && "not reached"); - break; + /* not reached */ + assert(0 && "not reached"); + break; } } else { set_Filter_cg_pred(filter, data->count, get_Call_param(call, get_Proj_proj(filter))); @@ -475,9 +475,9 @@ static void fill_mem(int length, irg_data_t * data[], ir_node * in[]) { for (i = 0; i < length; ++i) { if (data[i]) { /* explicit */ if (data[i]->reg) { - in[i] = data[i]->mem; + in[i] = data[i]->mem; } else { - in[i] = new_Bad(); + in[i] = new_Bad(); } } else { /* unknown */ in[i] = get_cg_Unknown(mode_M); @@ -493,9 +493,9 @@ static void fill_except_mem(int length, irg_data_t * data[], ir_node * in[]) { for (i = 0; i < length; ++i) { if (data[i]) { /* explicit */ if (data[i]->except) { - in[i] = data[i]->except_mem; + in[i] = data[i]->except_mem; } else { - in[i] = new_Bad(); + in[i] = new_Bad(); } } else { /* unknown */ in[i] = get_cg_Unknown(mode_M); @@ -511,9 +511,9 @@ static void fill_result(int pos, int length, irg_data_t * data[], ir_node * in[] for (i = 0; i < length; ++i) { if (data[i]) { /* explicit */ if (data[i]->reg) { - in[i] = data[i]->res[pos]; + in[i] = data[i]->res[pos]; } else { - in[i] = new_Bad(); + in[i] = new_Bad(); } } else { /* unknown */ in[i] = get_cg_Unknown(m); @@ -570,10 +570,10 @@ static void construct_call(ir_node * call) { int n_callees = get_Call_n_callees(call); ir_node * post_block = get_nodes_Block(call); /* block nach dem Aufruf */ ir_node * pre_block = create_Block(get_Block_n_cfgpreds(post_block), - get_Block_cfgpred_arr(post_block)); /* block vor dem Aufruf (mit CallBegin) */ + get_Block_cfgpred_arr(post_block)); /* block vor dem Aufruf (mit CallBegin) */ ir_node * except_block = NULL, * proj; ir_node * jmp = new_Break(); /* Sprung für intraprozedurale Darstellung (in - * pre_block) */ + * pre_block) */ ir_node * call_begin = new_CallBegin(call); /* (in pre_block) */ ir_node ** in = NEW_ARR_F(ir_node *, n_callees); entity * caller = get_irg_ent(current_ir_graph); /* entity des aktuellen ir_graph */ @@ -586,7 +586,7 @@ static void construct_call(ir_node * call) { * besitzen. Diese müssen dann auch noch für den pre_block gesetzt werden. */ if (get_Block_cg_cfgpred_arr(post_block)) { set_Block_cg_cfgpred_arr(pre_block, get_Block_cg_n_cfgpreds(post_block), - get_Block_cg_cfgpred_arr(post_block)); + get_Block_cg_cfgpred_arr(post_block)); remove_Block_cg_cfgpred_arr(post_block); } @@ -613,10 +613,10 @@ static void construct_call(ir_node * call) { for (i = 0; i < n_callees; ++i) { if (data[i]) { /* explicit */ if (data[i]->reg) { - in[i] = new_r_Proj(irgs[i], get_nodes_Block(data[i]->reg), - data[i]->reg, mode_X, data[i]->count); + in[i] = new_r_Proj(irgs[i], get_nodes_Block(data[i]->reg), + data[i]->reg, mode_X, data[i]->count); } else { - in[i] = new_Bad(); + in[i] = new_Bad(); } } else { /* unknown */ in[i] = get_cg_Unknown(mode_X); @@ -633,15 +633,15 @@ static void construct_call(ir_node * call) { bool exc_to_end = false; if (exc_branches_to_end(current_ir_graph, proj)) { /* The Call aborts the procedure if it returns with an exception. - If this is an outermost procedure, the normal handling of exceptions - will generate a Break that goes to the end block. This is illegal - Frim. So directly branch to the end block with all exceptions. */ + If this is an outermost procedure, the normal handling of exceptions + will generate a Break that goes to the end block. This is illegal + Frim. So directly branch to the end block with all exceptions. */ exc_to_end = true; if (is_outermost_graph(current_ir_graph)) { - except_block = get_irg_end_block(current_ir_graph); + except_block = get_irg_end_block(current_ir_graph); } else { - irg_data_t * tmp_data = get_entity_link(get_irg_ent(current_ir_graph)); - except_block = get_nodes_block(tmp_data->except); + irg_data_t * tmp_data = get_entity_link(get_irg_ent(current_ir_graph)); + except_block = get_nodes_block(tmp_data->except); } } else { @@ -662,14 +662,14 @@ static void construct_call(ir_node * call) { for (i = 0; i < n_callees; ++i) { entity * callee = get_Call_callee(call, i); if (data[i]) { /* explicit */ - if (data[i]->except) { - in[i] = new_r_Proj(get_entity_irg(callee), get_nodes_Block(data[i]->except), - data[i]->except, mode_X, data[i]->count); - } else { - in[i] = new_Bad(); - } + if (data[i]->except) { + in[i] = new_r_Proj(get_entity_irg(callee), get_nodes_Block(data[i]->except), + data[i]->except, mode_X, data[i]->count); + } else { + in[i] = new_Bad(); + } } else { /* unknown */ - in[i] = get_cg_Unknown(mode_X); + in[i] = get_cg_Unknown(mode_X); } } @@ -681,11 +681,11 @@ static void construct_call(ir_node * call) { * (interporcedural view is set!) * Do not add the exc pred of end we are replacing! */ for (i = get_Block_n_cfgpreds(except_block)-1; i >= 0; --i) { - ir_node *pred = get_Block_cfgpred(except_block, i); - if (pred != proj) { - ARR_APP1(ir_node *, in, pred); - preds++; - } + ir_node *pred = get_Block_cfgpred(except_block, i); + if (pred != proj) { + ARR_APP1(ir_node *, in, pred); + preds++; + } } } set_Block_cg_cfgpred_arr(except_block, preds, in); @@ -707,38 +707,38 @@ static void construct_call(ir_node * call) { if (skip_Proj(get_Proj_pred(proj)) != call) continue; if (get_Proj_pred(proj) == call) { if (get_Proj_proj(proj) == 0) { /* memory */ - ir_node * filter; - - set_nodes_Block(proj, post_block); - filter = exchange_proj(proj); - /* filter in die Liste der Phis aufnehmen */ - if (get_irn_link(filter) == NULL) { /* note CSE */ - set_irn_link(filter, get_irn_link(post_block)); - set_irn_link(post_block, filter); - } - fill_mem(n_callees, data, in); - set_Filter_cg_pred_arr(filter, n_callees, in); + ir_node * filter; + + set_nodes_Block(proj, post_block); + filter = exchange_proj(proj); + /* filter in die Liste der Phis aufnehmen */ + if (get_irn_link(filter) == NULL) { /* note CSE */ + set_irn_link(filter, get_irn_link(post_block)); + set_irn_link(post_block, filter); + } + fill_mem(n_callees, data, in); + set_Filter_cg_pred_arr(filter, n_callees, in); } else if (get_Proj_proj(proj) == 1) { /* except */ - /* nothing: siehe oben */ + /* nothing: siehe oben */ } else if (get_Proj_proj(proj) == 2) { /* results */ - /* nothing */ + /* nothing */ } else if (get_Proj_proj(proj) == 3) { /* except_mem */ ir_node * filter; - set_nodes_Block(proj, post_block); - assert(except_block); - set_irg_current_block(current_ir_graph, except_block); - filter = exchange_proj(proj); - /* filter in die Liste der Phis aufnehmen */ - if (get_irn_link(filter) == NULL) { /* note CSE */ - set_irn_link(filter, get_irn_link(except_block)); - set_irn_link(except_block, filter); - } - set_irg_current_block(current_ir_graph, post_block); - fill_except_mem(n_callees, data, in); - set_Filter_cg_pred_arr(filter, n_callees, in); + set_nodes_Block(proj, post_block); + assert(except_block); + set_irg_current_block(current_ir_graph, except_block); + filter = exchange_proj(proj); + /* filter in die Liste der Phis aufnehmen */ + if (get_irn_link(filter) == NULL) { /* note CSE */ + set_irn_link(filter, get_irn_link(except_block)); + set_irn_link(except_block, filter); + } + set_irg_current_block(current_ir_graph, post_block); + fill_except_mem(n_callees, data, in); + set_Filter_cg_pred_arr(filter, n_callees, in); } else { - assert(0 && "not reached"); + assert(0 && "not reached"); } } else { /* result */ ir_node * filter; @@ -748,8 +748,8 @@ static void construct_call(ir_node * call) { filter = exchange_proj(proj); /* filter in die Liste der Phis aufnehmen */ if (get_irn_link(filter) == NULL) { /* not CSE */ - set_irn_link(filter, get_irn_link(post_block)); - set_irn_link(post_block, filter); + set_irn_link(filter, get_irn_link(post_block)); + set_irn_link(post_block, filter); } fill_result(get_Proj_proj(filter), n_callees, data, in, intern_get_irn_mode(filter)); set_Filter_cg_pred_arr(filter, n_callees, in); @@ -794,10 +794,10 @@ void cg_construct(int arr_len, entity ** free_methods_arr) { current_ir_graph = get_irp_irg(i); for (node = get_irn_link(get_irg_end(current_ir_graph)); node; node = get_irn_link(node)) { if (intern_get_irn_op(node) == op_Call) { - int n_callees = get_Call_n_callees(node); - if (n_callees > 1 || (n_callees == 1 && get_Call_callee(node, 0) != NULL)) { - construct_call(node); - } + int n_callees = get_Call_n_callees(node); + if (n_callees > 1 || (n_callees == 1 && get_Call_callee(node, 0) != NULL)) { + construct_call(node); + } } } } @@ -824,7 +824,7 @@ static void destruct_walker(ir_node * node, void * env) { } else if (intern_get_irn_op(node) == op_Call) { remove_Call_callee_arr(node); } else if (intern_get_irn_op(node) == op_Proj) { - // some ProjX end up in strage blocks. + /* some ProjX end up in strage blocks. */ set_nodes_block(node, get_nodes_block(get_Proj_pred(node))); } } diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index c983cbb46..7e6ce473b 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -60,8 +60,8 @@ new_rd_Block (dbg_info* db, ir_graph *irg, int arity, ir_node **in) set_Block_matured(res, 1); set_Block_block_visited(res, 0); - //res->attr.block.exc = exc_normal; - //res->attr.block.handler_entry = 0; + /* res->attr.block.exc = exc_normal; */ + /* res->attr.block.handler_entry = 0; */ res->attr.block.irg = irg; res->attr.block.backedge = new_backedge_arr(irg->obst, arity); res->attr.block.in_cg = NULL; @@ -77,7 +77,7 @@ new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block) ir_node *res; res = new_ir_node (db, irg, block, op_Start, mode_T, 0, NULL); - //res->attr.start.irg = irg; + /* res->attr.start.irg = irg; */ irn_vrfy_irg (res, irg); return res; @@ -164,7 +164,7 @@ new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *m INLINE ir_node * new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, - long proj) + long proj) { ir_node *in[1]; ir_node *res; @@ -185,7 +185,7 @@ new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode INLINE ir_node * new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, - long max_proj) + long max_proj) { ir_node *res; assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_Iu)); @@ -231,7 +231,7 @@ new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node ** INLINE 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 *op1, ir_node *op2, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -245,7 +245,7 @@ new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) + ir_node *op1, ir_node *op2, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -259,7 +259,7 @@ new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op, ir_mode *mode) + ir_node *op, ir_mode *mode) { ir_node *in[1]; ir_node *res; @@ -272,7 +272,7 @@ new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) + ir_node *op1, ir_node *op2, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -286,7 +286,7 @@ new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *memop, ir_node *op1, ir_node *op2) + ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *in[3] ; ir_node *res; @@ -301,7 +301,7 @@ new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *memop, ir_node *op1, ir_node *op2) + ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *in[3]; ir_node *res; @@ -316,7 +316,7 @@ new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *memop, ir_node *op1, ir_node *op2) + ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *in[3]; ir_node *res; @@ -331,7 +331,7 @@ new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *memop, ir_node *op1, ir_node *op2) + ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *in[3]; ir_node *res; @@ -346,7 +346,7 @@ new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) + ir_node *op1, ir_node *op2, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -360,7 +360,7 @@ new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) + ir_node *op1, ir_node *op2, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -374,7 +374,7 @@ new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) + ir_node *op1, ir_node *op2, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -388,7 +388,7 @@ new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Not (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op, ir_mode *mode) + ir_node *op, ir_mode *mode) { ir_node *in[1]; ir_node *res; @@ -401,7 +401,7 @@ new_rd_Not (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op, ir_node *k, ir_mode *mode) + ir_node *op, ir_node *k, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -415,7 +415,7 @@ new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op, ir_node *k, ir_mode *mode) + ir_node *op, ir_node *k, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -429,7 +429,7 @@ new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op, ir_node *k, ir_mode *mode) + ir_node *op, ir_node *k, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -443,7 +443,7 @@ new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op, ir_node *k, ir_mode *mode) + ir_node *op, ir_node *k, ir_mode *mode) { ir_node *in[2]; ir_node *res; @@ -457,7 +457,7 @@ new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op, ir_mode *mode) + ir_node *op, ir_mode *mode) { ir_node *in[1]; ir_node *res; @@ -470,7 +470,7 @@ new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2) + ir_node *op1, ir_node *op2) { ir_node *in[2]; ir_node *res; @@ -508,7 +508,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, type *tp) { ir_node **r_in; ir_node *res; @@ -563,7 +563,7 @@ new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_no INLINE ir_node * new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *store, ir_node *adr) + ir_node *store, ir_node *adr) { ir_node *in[2]; ir_node *res; @@ -578,7 +578,7 @@ new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block, INLINE ir_node * new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *store, ir_node *adr, ir_node *val) + ir_node *store, ir_node *adr, ir_node *val) { ir_node *in[3]; ir_node *res; @@ -595,7 +595,7 @@ new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block, INLINE 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, type *alloc_type, where_alloc where) { ir_node *in[2]; ir_node *res; @@ -613,7 +613,7 @@ new_rd_Alloc (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, INLINE 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) + ir_node *ptr, ir_node *size, type *free_type) { ir_node *in[3]; ir_node *res; @@ -655,7 +655,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, type *ent) { ir_node **r_in; ir_node *res; @@ -692,7 +692,7 @@ new_rd_SymConst (dbg_info* db, ir_graph *irg, ir_node *block, type_or_id_p value res->attr.i.tori.ptrinfo = (ident *)value; } else { assert ( ( (symkind == type_tag) - || (symkind == size)) + || (symkind == size)) && (is_type(value))); res->attr.i.tori.typ = (type *)value; } @@ -748,7 +748,7 @@ new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call) ir_node *res; in[0] = get_Call_ptr(call); res = new_ir_node (db, irg, block, op_CallBegin, mode_T, 1, in); - //res->attr.callbegin.irg = irg; + /* res->attr.callbegin.irg = irg; */ res->attr.callbegin.call = call; res = optimize_node (res); irn_vrfy_irg (res, irg); @@ -761,7 +761,7 @@ new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block) ir_node *res; res = new_ir_node (db, irg, block, op_EndReg, mode_T, -1, NULL); - //res->attr.end.irg = irg; + /* res->attr.end.irg = irg; */ irn_vrfy_irg (res, irg); return res; @@ -773,7 +773,7 @@ new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block) ir_node *res; res = new_ir_node (db, irg, block, op_EndExcept, mode_T, -1, NULL); - //res->attr.end.irg = irg; + /* res->attr.end.irg = irg; */ irn_vrfy_irg (res, irg); return res; @@ -791,7 +791,7 @@ new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block) INLINE ir_node * new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode, - long proj) + long proj) { ir_node *in[1]; ir_node *res; @@ -814,7 +814,7 @@ new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mod ir_node * new_rd_FuncCall (dbg_info* db, ir_graph *irg, ir_node *block, - ir_node *callee, int arity, ir_node **in, type *tp) + ir_node *callee, int arity, ir_node **in, type *tp) { ir_node **r_in; ir_node *res; @@ -852,15 +852,15 @@ INLINE ir_node *new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c) { return new_rd_Cond(NULL, irg, block, c); } INLINE ir_node *new_r_Return (ir_graph *irg, ir_node *block, - ir_node *store, int arity, ir_node **in) { + ir_node *store, int arity, ir_node **in) { return new_rd_Return(NULL, irg, block, store, arity, in); } INLINE ir_node *new_r_Raise (ir_graph *irg, ir_node *block, - ir_node *store, ir_node *obj) { + ir_node *store, ir_node *obj) { return new_rd_Raise(NULL, irg, block, store, obj); } INLINE ir_node *new_r_Const (ir_graph *irg, ir_node *block, - ir_mode *mode, tarval *con) { + ir_mode *mode, tarval *con) { return new_rd_Const(NULL, irg, block, mode, con); } INLINE ir_node *new_r_SymConst (ir_graph *irg, ir_node *block, @@ -868,135 +868,135 @@ INLINE ir_node *new_r_SymConst (ir_graph *irg, ir_node *block, return new_rd_SymConst(NULL, irg, block, value, symkind); } INLINE ir_node *new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store, - ir_node *objptr, int n_index, ir_node **index, - entity *ent) { + ir_node *objptr, int n_index, ir_node **index, + entity *ent) { return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent); } INLINE ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr, - type *ent) { + type *ent) { return (new_rd_InstOf (NULL, irg, block, store, objptr, ent)); } INLINE 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_node *callee, int arity, ir_node **in, + 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) { + ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Add(NULL, irg, block, op1, op2, mode); } INLINE ir_node *new_r_Sub (ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) { + ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Sub(NULL, irg, block, op1, op2, mode); } INLINE ir_node *new_r_Minus (ir_graph *irg, ir_node *block, - ir_node *op, ir_mode *mode) { + ir_node *op, ir_mode *mode) { return new_rd_Minus(NULL, irg, block, op, mode); } INLINE ir_node *new_r_Mul (ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) { + ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Mul(NULL, irg, block, op1, op2, mode); } INLINE ir_node *new_r_Quot (ir_graph *irg, ir_node *block, - ir_node *memop, ir_node *op1, ir_node *op2) { + ir_node *memop, ir_node *op1, ir_node *op2) { return new_rd_Quot(NULL, irg, block, memop, op1, op2); } INLINE ir_node *new_r_DivMod (ir_graph *irg, ir_node *block, - ir_node *memop, ir_node *op1, ir_node *op2) { + ir_node *memop, ir_node *op1, ir_node *op2) { return new_rd_DivMod(NULL, irg, block, memop, op1, op2); } INLINE ir_node *new_r_Div (ir_graph *irg, ir_node *block, - ir_node *memop, ir_node *op1, ir_node *op2) { + ir_node *memop, ir_node *op1, ir_node *op2) { return new_rd_Div(NULL, irg, block, memop, op1, op2); } INLINE ir_node *new_r_Mod (ir_graph *irg, ir_node *block, - ir_node *memop, ir_node *op1, ir_node *op2) { + ir_node *memop, ir_node *op1, ir_node *op2) { return new_rd_Mod(NULL, irg, block, memop, op1, op2); } INLINE ir_node *new_r_Abs (ir_graph *irg, ir_node *block, - ir_node *op, ir_mode *mode) { + ir_node *op, ir_mode *mode) { return new_rd_Abs(NULL, irg, block, op, mode); } INLINE ir_node *new_r_And (ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) { + ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_And(NULL, irg, block, op1, op2, mode); } INLINE ir_node *new_r_Or (ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) { + ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Or(NULL, irg, block, op1, op2, mode); } INLINE ir_node *new_r_Eor (ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2, ir_mode *mode) { + ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Eor(NULL, irg, block, op1, op2, mode); } INLINE ir_node *new_r_Not (ir_graph *irg, ir_node *block, - ir_node *op, ir_mode *mode) { + ir_node *op, ir_mode *mode) { return new_rd_Not(NULL, irg, block, op, mode); } INLINE ir_node *new_r_Cmp (ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2) { + ir_node *op1, ir_node *op2) { return new_rd_Cmp(NULL, irg, block, op1, op2); } INLINE ir_node *new_r_Shl (ir_graph *irg, ir_node *block, - ir_node *op, ir_node *k, ir_mode *mode) { + ir_node *op, ir_node *k, ir_mode *mode) { return new_rd_Shl(NULL, irg, block, op, k, mode); } INLINE ir_node *new_r_Shr (ir_graph *irg, ir_node *block, - ir_node *op, ir_node *k, ir_mode *mode) { + ir_node *op, ir_node *k, ir_mode *mode) { return new_rd_Shr(NULL, irg, block, op, k, mode); } INLINE ir_node *new_r_Shrs (ir_graph *irg, ir_node *block, - ir_node *op, ir_node *k, ir_mode *mode) { + ir_node *op, ir_node *k, ir_mode *mode) { return new_rd_Shrs(NULL, irg, block, op, k, mode); } INLINE ir_node *new_r_Rot (ir_graph *irg, ir_node *block, - ir_node *op, ir_node *k, ir_mode *mode) { + ir_node *op, ir_node *k, ir_mode *mode) { return new_rd_Rot(NULL, irg, block, op, k, mode); } INLINE ir_node *new_r_Conv (ir_graph *irg, ir_node *block, - ir_node *op, ir_mode *mode) { + ir_node *op, ir_mode *mode) { return new_rd_Conv(NULL, irg, block, op, mode); } INLINE ir_node *new_r_Cast (ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) { return new_rd_Cast(NULL, irg, block, op, to_tp); } INLINE ir_node *new_r_Phi (ir_graph *irg, ir_node *block, int arity, - ir_node **in, ir_mode *mode) { + ir_node **in, ir_mode *mode) { return new_rd_Phi(NULL, irg, block, arity, in, mode); } INLINE ir_node *new_r_Load (ir_graph *irg, ir_node *block, - ir_node *store, ir_node *adr) { + ir_node *store, ir_node *adr) { return new_rd_Load(NULL, irg, block, store, adr); } INLINE ir_node *new_r_Store (ir_graph *irg, ir_node *block, - ir_node *store, ir_node *adr, ir_node *val) { + ir_node *store, ir_node *adr, ir_node *val) { return new_rd_Store(NULL, irg, block, store, adr, val); } INLINE 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, type *alloc_type, where_alloc where) { return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where); } INLINE ir_node *new_r_Free (ir_graph *irg, ir_node *block, ir_node *store, - ir_node *ptr, ir_node *size, type *free_type) { + ir_node *ptr, ir_node *size, type *free_type) { return new_rd_Free(NULL, irg, block, store, ptr, size, free_type); } INLINE ir_node *new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in) { return new_rd_Sync(NULL, irg, block, arity, in); } INLINE ir_node *new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg, - ir_mode *mode, long proj) { + ir_mode *mode, long proj) { return new_rd_Proj(NULL, irg, block, arg, mode, proj); } INLINE ir_node *new_r_defaultProj (ir_graph *irg, ir_node *block, ir_node *arg, - long max_proj) { + long max_proj) { return new_rd_defaultProj(NULL, irg, block, arg, max_proj); } INLINE ir_node *new_r_Tuple (ir_graph *irg, ir_node *block, - int arity, ir_node **in) { + int arity, ir_node **in) { return new_rd_Tuple(NULL, irg, block, arity, in ); } INLINE ir_node *new_r_Id (ir_graph *irg, ir_node *block, - ir_node *val, ir_mode *mode) { + ir_node *val, ir_mode *mode) { return new_rd_Id(NULL, irg, block, val, mode); } INLINE ir_node *new_r_Bad (ir_graph *irg) { @@ -1021,12 +1021,12 @@ INLINE ir_node *new_r_Break (ir_graph *irg, ir_node *block) { return new_rd_Break(NULL, irg, block); } INLINE ir_node *new_r_Filter (ir_graph *irg, ir_node *block, ir_node *arg, - ir_mode *mode, long proj) { + ir_mode *mode, long proj) { return new_rd_Filter(NULL, irg, block, arg, mode, proj); } INLINE ir_node *new_r_FuncCall (ir_graph *irg, ir_node *block, - ir_node *callee, int arity, ir_node **in, - type *tp) { + ir_node *callee, int arity, ir_node **in, + type *tp) { return new_rd_FuncCall(NULL, irg, block, callee, arity, in, tp); } @@ -1049,8 +1049,8 @@ new_d_Start (dbg_info* db) ir_node *res; res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block, - op_Start, mode_T, 0, NULL); - //res->attr.start.irg = current_ir_graph; + op_Start, mode_T, 0, NULL); + /* res->attr.start.irg = current_ir_graph; */ res = optimize_node (res); irn_vrfy_irg (res, current_ir_graph); @@ -1062,7 +1062,7 @@ new_d_End (dbg_info* db) { ir_node *res; res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block, - op_End, mode_X, -1, NULL); + op_End, mode_X, -1, NULL); res = optimize_node (res); irn_vrfy_irg (res, current_ir_graph); @@ -1116,9 +1116,9 @@ new_d_Block (dbg_info* db, int arity, ir_node **in) \|/ / |/_ \ get_r_value_internal | | | - | | - \|/ \|/ - new_rd_Phi0 new_rd_Phi_in + | | + \|/ \|/ + new_rd_Phi0 new_rd_Phi_in * *************************************************************************** */ @@ -1175,7 +1175,7 @@ free_to_Phi_in_stack(ir_node *phi) { static INLINE ir_node * alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode, - int arity, ir_node **in) { + int arity, ir_node **in) { ir_node *res; ir_node **stack = current_ir_graph->Phi_in_stack->stack; int pos = current_ir_graph->Phi_in_stack->pos; @@ -1226,7 +1226,7 @@ alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode, */ static INLINE ir_node * new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, - ir_node **in, int ins) + ir_node **in, int ins) { int i; ir_node *res, *known; @@ -1373,11 +1373,11 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) * The recursion that visited this node and set the flag did not return yet. We are computing a value in a loop and need to break the recursion without knowing the result yet. - @@@ strange case. Straight forward we would create a Phi before - starting the computation of it's predecessors. In this case we will - find a Phi here in any case. The problem is that this implementation - only creates a Phi after computing the predecessors, so that it is - hard to compute self references of this Phi. @@@ + @@@ strange case. Straight forward we would create a Phi before + starting the computation of it's predecessors. In this case we will + find a Phi here in any case. The problem is that this implementation + only creates a Phi after computing the predecessors, so that it is + hard to compute self references of this Phi. @@@ There is no simple check for the second subcase. Therefore we check for a second visit and treat all such cases as the second subcase. Anyways, the basic situation is the same: we reached a block @@ -1387,8 +1387,8 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) implementation that relies on the fact that an obstack is a stack and will return a node with the same address on different allocations. Look also at phi_merge and new_rd_phi_in to understand this. - @@@ Unfortunately this does not work, see testprogram - three_cfpred_example. + @@@ Unfortunately this does not work, see testprogram + three_cfpred_example. */ @@ -1436,7 +1436,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) printf("Error: no value set. Use of undefined variable. Initializing to zero.\n"); assert (mode->code >= irm_F && mode->code <= irm_P); res = new_rd_Const (NULL, current_ir_graph, block, mode, - tarval_mode_null[mode->code]); + tarval_mode_null[mode->code]); } /* The local valid value is available now. */ @@ -1459,7 +1459,7 @@ INLINE void free_Phi_in_stack(Phi_in_stack *s) { } static INLINE ir_node * new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, - ir_node **in, int ins) + ir_node **in, int ins) { int i; ir_node *res, *known; @@ -1476,7 +1476,7 @@ new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode, known = res; for (i=0; i < ins; ++i) { - assert(in[i]); + assert(in[i]); if (in[i]==res || in[i]==known || is_Bad(in[i])) continue; @@ -1520,7 +1520,7 @@ static INLINE ir_node ** new_frag_arr (ir_node *n) int opt; arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc); memcpy(arr, current_ir_graph->current_block->attr.block.graph_arr, - sizeof(ir_node *)*current_ir_graph->n_loc); + sizeof(ir_node *)*current_ir_graph->n_loc); /* turn off optimization before allocating Proj nodes, as res isn't finished yet. */ opt = get_opt_optimize(); set_optimize(0); @@ -1564,21 +1564,21 @@ get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode if (!res) { if (block->attr.block.graph_arr[pos]) { /* There was a set_value after the cfOp and no get_value before that - set_value. We must build a Phi node now. */ + set_value. We must build a Phi node now. */ if (block->attr.block.matured) { - int ins = intern_get_irn_arity(block); - ir_node **nin; - NEW_ARR_A (ir_node *, nin, ins); - res = phi_merge(block, pos, mode, nin, ins); + int ins = intern_get_irn_arity(block); + ir_node **nin; + NEW_ARR_A (ir_node *, nin, ins); + res = phi_merge(block, pos, mode, nin, ins); } else { - res = new_rd_Phi0 (current_ir_graph, block, mode); - res->attr.phi0_pos = pos; - res->link = block->link; - block->link = res; + res = new_rd_Phi0 (current_ir_graph, block, mode); + res->attr.phi0_pos = pos; + res->link = block->link; + block->link = res; } assert(res); /* @@@ tested by Flo: set_frag_value(frag_arr, pos, res); - but this should be better: (remove comment if this works) */ + but this should be better: (remove comment if this works) */ /* It's a Phi, we can write this into all graph_arrs with NULL */ set_frag_value(block->attr.block.graph_arr, pos, res); } else { @@ -1624,15 +1624,15 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) else block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad); /* We don't need to care about exception ops in the start block. - There are none by definition. */ + There are none by definition. */ return block->attr.block.graph_arr[pos]; } else { phi0 = new_rd_Phi0(current_ir_graph, block, mode); block->attr.block.graph_arr[pos] = phi0; #if PRECISE_EXC_CONTEXT /* Set graph_arr for fragile ops. Also here we should break recursion. - We could choose a cyclic path through an cfop. But the recursion would - break at some point. */ + We could choose a cyclic path through an cfop. But the recursion would + break at some point. */ set_frag_value(block->attr.block.graph_arr, pos, phi0); #endif } @@ -1646,7 +1646,7 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) assert (prevCfOp); if (is_Bad(prevCfOp)) { /* In case a Cond has been optimized we would get right to the start block - with an invalid definition. */ + with an invalid definition. */ nin[i-1] = new_Bad(); continue; } @@ -1655,11 +1655,11 @@ phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins) if (!is_Bad(prevBlock)) { #if PRECISE_EXC_CONTEXT if (is_fragile_op(prevCfOp) && (intern_get_irn_op (prevCfOp) != op_Bad)) { - assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode)); - nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode); + assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode)); + nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode); } else #endif - nin[i-1] = get_r_value_internal (prevBlock, pos, mode); + nin[i-1] = get_r_value_internal (prevBlock, pos, mode); } else { nin[i-1] = new_Bad(); } @@ -1716,8 +1716,8 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) * The recursion that visited this node and set the flag did not return yet. We are computing a value in a loop and need to break the recursion. This case only happens if we visited - the same block with phi_merge before, which inserted a Phi0. - So we return the Phi0. + the same block with phi_merge before, which inserted a Phi0. + So we return the Phi0. */ /* case 4 -- already visited. */ @@ -1767,7 +1767,7 @@ get_r_value_internal (ir_node *block, int pos, ir_mode *mode) printf("Error: no value set. Use of undefined variable. Initializing to zero.\n"); assert (mode->code >= irm_F && mode->code <= irm_P); res = new_rd_Const (NULL, current_ir_graph, block, mode, - get_mode_null(mode)); + get_mode_null(mode)); } /* The local valid value is available now. */ @@ -1828,21 +1828,21 @@ ir_node * new_d_Phi (dbg_info* db, int arity, ir_node **in, ir_mode *mode) { return new_rd_Phi (db, current_ir_graph, current_ir_graph->current_block, - arity, in, mode); + arity, in, mode); } ir_node * new_d_Const (dbg_info* db, ir_mode *mode, tarval *con) { return new_rd_Const (db, current_ir_graph, current_ir_graph->start_block, - mode, con); + mode, con); } ir_node * new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp) { return new_rd_Const_type (db, current_ir_graph, current_ir_graph->start_block, - mode, con, tp); + mode, con, tp); } @@ -1850,14 +1850,14 @@ ir_node * new_d_Id (dbg_info* db, ir_node *val, ir_mode *mode) { return new_rd_Id (db, current_ir_graph, current_ir_graph->current_block, - val, mode); + val, mode); } ir_node * new_d_Proj (dbg_info* db, ir_node *arg, ir_mode *mode, long proj) { return new_rd_Proj (db, current_ir_graph, current_ir_graph->current_block, - arg, mode, proj); + arg, mode, proj); } ir_node * @@ -1875,7 +1875,7 @@ ir_node * new_d_Conv (dbg_info* db, ir_node *op, ir_mode *mode) { return new_rd_Conv (db, current_ir_graph, current_ir_graph->current_block, - op, mode); + op, mode); } ir_node * @@ -1888,21 +1888,21 @@ ir_node * new_d_Tuple (dbg_info* db, int arity, ir_node **in) { return new_rd_Tuple (db, current_ir_graph, current_ir_graph->current_block, - arity, in); + arity, in); } ir_node * new_d_Add (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Add (db, current_ir_graph, current_ir_graph->current_block, - op1, op2, mode); + op1, op2, mode); } ir_node * new_d_Sub (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Sub (db, current_ir_graph, current_ir_graph->current_block, - op1, op2, mode); + op1, op2, mode); } @@ -1910,14 +1910,14 @@ ir_node * new_d_Minus (dbg_info* db, ir_node *op, ir_mode *mode) { return new_rd_Minus (db, current_ir_graph, current_ir_graph->current_block, - op, mode); + op, mode); } ir_node * new_d_Mul (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Mul (db, current_ir_graph, current_ir_graph->current_block, - op1, op2, mode); + op1, op2, mode); } ir_node * @@ -1925,7 +1925,7 @@ new_d_Quot (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *res; res = new_rd_Quot (db, current_ir_graph, current_ir_graph->current_block, - memop, op1, op2); + memop, op1, op2); #if PRECISE_EXC_CONTEXT if ((current_ir_graph->phase_state == phase_building) && (intern_get_irn_op(res) == op_Quot)) /* Could be optimized away. */ @@ -1940,7 +1940,7 @@ new_d_DivMod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *res; res = new_rd_DivMod (db, current_ir_graph, current_ir_graph->current_block, - memop, op1, op2); + memop, op1, op2); #if PRECISE_EXC_CONTEXT if ((current_ir_graph->phase_state == phase_building) && (intern_get_irn_op(res) == op_DivMod)) /* Could be optimized away. */ @@ -1955,7 +1955,7 @@ new_d_Div (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *res; res = new_rd_Div (db, current_ir_graph, current_ir_graph->current_block, - memop, op1, op2); + memop, op1, op2); #if PRECISE_EXC_CONTEXT if ((current_ir_graph->phase_state == phase_building) && (intern_get_irn_op(res) == op_Div)) /* Could be optimized away. */ @@ -1970,7 +1970,7 @@ new_d_Mod (dbg_info* db, ir_node *memop, ir_node *op1, ir_node *op2) { ir_node *res; res = new_rd_Mod (db, current_ir_graph, current_ir_graph->current_block, - memop, op1, op2); + memop, op1, op2); #if PRECISE_EXC_CONTEXT if ((current_ir_graph->phase_state == phase_building) && (intern_get_irn_op(res) == op_Mod)) /* Could be optimized away. */ @@ -1984,70 +1984,70 @@ ir_node * new_d_And (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_And (db, current_ir_graph, current_ir_graph->current_block, - op1, op2, mode); + op1, op2, mode); } ir_node * new_d_Or (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Or (db, current_ir_graph, current_ir_graph->current_block, - op1, op2, mode); + op1, op2, mode); } ir_node * new_d_Eor (dbg_info* db, ir_node *op1, ir_node *op2, ir_mode *mode) { return new_rd_Eor (db, current_ir_graph, current_ir_graph->current_block, - op1, op2, mode); + op1, op2, mode); } ir_node * new_d_Not (dbg_info* db, ir_node *op, ir_mode *mode) { return new_rd_Not (db, current_ir_graph, current_ir_graph->current_block, - op, mode); + op, mode); } ir_node * new_d_Shl (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode) { return new_rd_Shl (db, current_ir_graph, current_ir_graph->current_block, - op, k, mode); + op, k, mode); } ir_node * new_d_Shr (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode) { return new_rd_Shr (db, current_ir_graph, current_ir_graph->current_block, - op, k, mode); + op, k, mode); } ir_node * new_d_Shrs (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode) { return new_rd_Shrs (db, current_ir_graph, current_ir_graph->current_block, - op, k, mode); + op, k, mode); } ir_node * new_d_Rot (dbg_info* db, ir_node *op, ir_node *k, ir_mode *mode) { return new_rd_Rot (db, current_ir_graph, current_ir_graph->current_block, - op, k, mode); + op, k, mode); } ir_node * new_d_Abs (dbg_info* db, ir_node *op, ir_mode *mode) { return new_rd_Abs (db, current_ir_graph, current_ir_graph->current_block, - op, mode); + op, mode); } ir_node * new_d_Cmp (dbg_info* db, ir_node *op1, ir_node *op2) { return new_rd_Cmp (db, current_ir_graph, current_ir_graph->current_block, - op1, op2); + op1, op2); } ir_node * @@ -2064,11 +2064,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 *tp) + type *tp) { ir_node *res; res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block, - store, callee, arity, in, tp); + store, callee, arity, in, tp); #if PRECISE_EXC_CONTEXT if ((current_ir_graph->phase_state == phase_building) && (intern_get_irn_op(res) == op_Call)) /* Could be optimized away. */ @@ -2082,14 +2082,14 @@ ir_node * new_d_Return (dbg_info* db, ir_node* store, int arity, ir_node **in) { return new_rd_Return (db, current_ir_graph, current_ir_graph->current_block, - store, arity, in); + store, arity, in); } ir_node * new_d_Raise (dbg_info* db, ir_node *store, ir_node *obj) { return new_rd_Raise (db, current_ir_graph, current_ir_graph->current_block, - store, obj); + store, obj); } ir_node * @@ -2097,7 +2097,7 @@ new_d_Load (dbg_info* db, ir_node *store, ir_node *addr) { ir_node *res; res = new_rd_Load (db, current_ir_graph, current_ir_graph->current_block, - store, addr); + store, addr); #if PRECISE_EXC_CONTEXT if ((current_ir_graph->phase_state == phase_building) && (intern_get_irn_op(res) == op_Load)) /* Could be optimized away. */ @@ -2112,7 +2112,7 @@ new_d_Store (dbg_info* db, ir_node *store, ir_node *addr, ir_node *val) { ir_node *res; res = new_rd_Store (db, current_ir_graph, current_ir_graph->current_block, - store, addr, val); + store, addr, val); #if PRECISE_EXC_CONTEXT if ((current_ir_graph->phase_state == phase_building) && (intern_get_irn_op(res) == op_Store)) /* Could be optimized away. */ @@ -2128,7 +2128,7 @@ new_d_Alloc (dbg_info* db, ir_node *store, ir_node *size, type *alloc_type, { ir_node *res; res = new_rd_Alloc (db, current_ir_graph, current_ir_graph->current_block, - store, size, alloc_type, where); + store, size, alloc_type, where); #if PRECISE_EXC_CONTEXT if ((current_ir_graph->phase_state == phase_building) && (intern_get_irn_op(res) == op_Alloc)) /* Could be optimized away. */ @@ -2142,7 +2142,7 @@ ir_node * new_d_Free (dbg_info* db, ir_node *store, ir_node *ptr, ir_node *size, type *free_type) { return new_rd_Free (db, current_ir_graph, current_ir_graph->current_block, - store, ptr, size, free_type); + store, ptr, size, free_type); } ir_node * @@ -2151,21 +2151,21 @@ new_d_simpleSel (dbg_info* db, ir_node *store, ir_node *objptr, entity *ent) as the operand could as well be a pointer to a dynamic object. */ { return new_rd_Sel (db, current_ir_graph, current_ir_graph->current_block, - store, objptr, 0, NULL, ent); + store, objptr, 0, NULL, ent); } ir_node * new_d_Sel (dbg_info* db, ir_node *store, ir_node *objptr, int n_index, ir_node **index, entity *sel) { return new_rd_Sel (db, current_ir_graph, current_ir_graph->current_block, - store, objptr, n_index, index, sel); + store, objptr, n_index, index, sel); } ir_node * new_d_InstOf (dbg_info *db, ir_node *store, ir_node *objptr, type *ent) { return (new_rd_InstOf (db, current_ir_graph, current_ir_graph->current_block, - store, objptr, ent)); + store, objptr, ent)); } ir_node * @@ -2179,7 +2179,7 @@ ir_node * new_d_Sync (dbg_info* db, int arity, ir_node** in) { return new_rd_Sync (db, current_ir_graph, current_ir_graph->current_block, - arity, in); + arity, in); } @@ -2193,7 +2193,7 @@ ir_node * new_d_Confirm (dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp) { return new_rd_Confirm (db, current_ir_graph, current_ir_graph->current_block, - val, bound, cmp); + val, bound, cmp); } ir_node * @@ -2236,16 +2236,16 @@ ir_node * new_d_Filter (dbg_info *db, ir_node *arg, ir_mode *mode, long proj) { return new_rd_Filter (db, current_ir_graph, current_ir_graph->current_block, - arg, mode, proj); + arg, mode, proj); } ir_node * new_d_FuncCall (dbg_info* db, ir_node *callee, int arity, ir_node **in, - type *tp) + type *tp) { ir_node *res; res = new_rd_FuncCall (db, current_ir_graph, current_ir_graph->current_block, - callee, arity, in, tp); + callee, arity, in, tp); return res; } @@ -2265,8 +2265,8 @@ ir_node *new_d_immBlock (dbg_info* db) { res = new_ir_node (db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL); current_ir_graph->current_block = res; res->attr.block.matured = 0; - //res->attr.block.exc = exc_normal; - //res->attr.block.handler_entry = 0; + /* res->attr.block.exc = exc_normal; */ + /* res->attr.block.handler_entry = 0; */ res->attr.block.irg = current_ir_graph; res->attr.block.backedge = NULL; res->attr.block.in_cg = NULL; @@ -2430,7 +2430,7 @@ 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 *tp) { + 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) { @@ -2508,7 +2508,7 @@ ir_node *new_Alloc (ir_node *store, ir_node *size, type *alloc_type, 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) { + type *free_type) { return new_d_Free(NULL, store, ptr, size, free_type); } ir_node *new_Sync (int arity, ir_node **in) { diff --git a/ir/ir/ircons.h b/ir/ir/ircons.h index 94ecb7aa4..c0c208556 100644 --- a/ir/ir/ircons.h +++ b/ir/ir/ircons.h @@ -468,9 +468,9 @@ * mature_block(loop_header); * mature_block(loop_body); * - * get_value(loop_body, x); // gets the Phi in loop_header - * set_value(loop_header, x); // sets the value the above get_value should - * // have returned!!! + * get_value(loop_body, x); // gets the Phi in loop_header + * set_value(loop_header, x); // sets the value the above get_value should + * // have returned!!! * * Mature_block also fixes the number of inputs to the Phi nodes. Mature_block * should be called as early as possible, as afterwards the generation of Phi diff --git a/ir/ir/irdump.c b/ir/ir/irdump.c index 77cc0fc83..f705e2265 100644 --- a/ir/ir/irdump.c +++ b/ir/ir/irdump.c @@ -616,7 +616,7 @@ static INLINE int dump_node_info(ir_node *n) ir_loop *loop = get_irn_loop(n); assert(loop); fprintf(F, " in loop %d with depth %d\n", - get_loop_loop_nr(loop), get_loop_depth(loop)); + get_loop_loop_nr(loop), get_loop_depth(loop)); } */ @@ -1600,7 +1600,7 @@ static void vcg_open (ir_graph *irg, char * suffix1, char *suffix2) { /** open file for vcg graph */ fname = malloc (len * 2 + strlen(suffix1) + strlen(suffix2) + 5); - //strncpy (fname, nm, len); /* copy the filename */ + /* strncpy (fname, nm, len); */ /* copy the filename */ j = 0; for (i = 0; i < len; ++i) { /* replase '/' in the name: escape by @. */ if (nm[i] == '/') { @@ -1630,7 +1630,7 @@ static void vcg_open_name (const char *name, char *suffix) { /** open file for vcg graph */ fname = malloc (len * 2 + 5 + strlen(suffix)); - //strcpy (fname, name); /* copy the filename */ + /* strcpy (fname, name);*/ /* copy the filename */ j = 0; for (i = 0; i < len; ++i) { /* replase '/' in the name: escape by @. */ if (name[i] == '/') { @@ -1680,7 +1680,7 @@ dump_ir_graph (ir_graph *irg) char *suffix; rem = current_ir_graph; - //printf("comparing %s %s\n", get_irg_dump_name(irg), dump_file_filter); + /* printf("comparing %s %s\n", get_irg_dump_name(irg), dump_file_filter); */ if(strncmp(get_irg_dump_name(irg),dump_file_filter,strlen(dump_file_filter))!=0) return; @@ -1711,7 +1711,7 @@ dump_ir_block_graph (ir_graph *irg) int i; char *suffix; - //printf("comparing %s %s\n", get_irg_dump_name(irg), dump_file_filter); + /* printf("comparing %s %s\n", get_irg_dump_name(irg), dump_file_filter); */ if(strncmp(get_irg_dump_name(irg),dump_file_filter,strlen(dump_file_filter))!=0) return; if (interprocedural_view) suffix = "-ip"; diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c index cee394679..a2537d945 100644 --- a/ir/ir/irgopt.c +++ b/ir/ir/irgopt.c @@ -49,9 +49,9 @@ static void init_link (ir_node *n, void *env) { } #if 0 /* Old version. Avoids Ids. - This is not necessary: we do a postwalk, and get_irn_n - removes ids anyways. So it's much cheaper to call the - optimization less often and use the exchange() algorithm. */ + This is not necessary: we do a postwalk, and get_irn_n + removes ids anyways. So it's much cheaper to call the + optimization less often and use the exchange() algorithm. */ static void optimize_in_place_wrapper (ir_node *n, void *env) { int i, irn_arity; @@ -191,7 +191,7 @@ copy_node (ir_node *n, void *env) { /* The end node looses it's flexible in array. This doesn't matter, as dead node elimination builds End by hand, inlineing doesn't use the End node. */ - //assert(n->op == op_End || ((_ARR_DESCR(n->in))->cookie != ARR_F_MAGIC)); + /* assert(n->op == op_End || ((_ARR_DESCR(n->in))->cookie != ARR_F_MAGIC)); */ if (intern_get_irn_opcode(n) == iro_Block) { block = NULL; @@ -206,12 +206,12 @@ copy_node (ir_node *n, void *env) { } } nn = new_ir_node(get_irn_dbg_info(n), - current_ir_graph, - block, - intern_get_irn_op(n), - intern_get_irn_mode(n), - new_arity, - get_irn_in(n)); + current_ir_graph, + block, + intern_get_irn_op(n), + intern_get_irn_mode(n), + new_arity, + get_irn_in(n)); /* Copy the attributes. These might point to additional data. If this was allocated on the old obstack the pointers now are dangling. This frees e.g. the memory of the graph_arr allocated in new_immBlock. */ @@ -245,9 +245,9 @@ copy_preds (ir_node *n, void *env) { irn_arity = intern_get_irn_arity(n); for (i = 0; i < irn_arity; i++) if (intern_get_irn_opcode(intern_get_irn_n(n, i)) != iro_Bad) { - set_irn_n (nn, j, get_new_node(intern_get_irn_n(n, i))); - /*if (is_backedge(n, i)) set_backedge(nn, j);*/ - j++; + set_irn_n (nn, j, get_new_node(intern_get_irn_n(n, i))); + /*if (is_backedge(n, i)) set_backedge(nn, j);*/ + j++; } /* repair the block visited flag from above misuse. Repair it in both graphs so that the old one can still be used. */ @@ -258,8 +258,8 @@ copy_preds (ir_node *n, void *env) { We don't call optimize_in_place as it requires that the fields in ir_graph are set properly. */ if ((get_opt_control_flow_straightening()) && - (get_Block_n_cfgpreds(nn) == 1) && - (intern_get_irn_op(get_Block_cfgpred(nn, 0)) == op_Jmp)) + (get_Block_n_cfgpreds(nn) == 1) && + (intern_get_irn_op(get_Block_cfgpred(nn, 0)) == op_Jmp)) exchange(nn, get_nodes_Block(get_Block_cfgpred(nn, 0))); } else if (intern_get_irn_opcode(n) == iro_Phi) { /* Don't copy node if corresponding predecessor in block is Bad. @@ -270,9 +270,9 @@ copy_preds (ir_node *n, void *env) { irn_arity = intern_get_irn_arity(n); for (i = 0; i < irn_arity; i++) if (intern_get_irn_opcode(intern_get_irn_n(block, i)) != iro_Bad) { - set_irn_n (nn, j, get_new_node(intern_get_irn_n(n, i))); - /*if (is_backedge(n, i)) set_backedge(nn, j);*/ - j++; + set_irn_n (nn, j, get_new_node(intern_get_irn_n(n, i))); + /*if (is_backedge(n, i)) set_backedge(nn, j);*/ + j++; } /* If the pre walker reached this Phi after the post walker visited the block block_visited is > 0. */ @@ -304,12 +304,12 @@ copy_graph (void) { oe = get_irg_end(current_ir_graph); /* copy the end node by hand, allocate dynamic in array! */ ne = new_ir_node(get_irn_dbg_info(oe), - current_ir_graph, - NULL, - op_End, - mode_X, - -1, - NULL); + current_ir_graph, + NULL, + op_End, + mode_X, + -1, + NULL); /* Copy the attributes. Well, there might be some in the future... */ copy_attrs(oe, ne); set_new_node(oe, ne); @@ -326,7 +326,7 @@ copy_graph (void) { for (i = 0; i < irn_arity; i++) { ka = intern_get_irn_intra_n(oe, i); if ((intern_get_irn_op(ka) == op_Block) && - (get_irn_visited(ka) < get_irg_visited(current_ir_graph))) { + (get_irn_visited(ka) < get_irg_visited(current_ir_graph))) { /* We must keep the block alive and copy everything reachable */ set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1); irg_walk(ka, copy_node, copy_preds, NULL); @@ -340,9 +340,9 @@ copy_graph (void) { ka = intern_get_irn_intra_n(oe, i); if ((intern_get_irn_op(ka) == op_Phi)) { if (get_irn_visited(ka) < get_irg_visited(current_ir_graph)) { - /* We didn't copy the Phi yet. */ - set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1); - irg_walk(ka, copy_node, copy_preds, NULL); + /* We didn't copy the Phi yet. */ + set_irg_visited(current_ir_graph, get_irg_visited(current_ir_graph)-1); + irg_walk(ka, copy_node, copy_preds, NULL); } add_End_keepalive(ne, get_new_node(ka)); } @@ -391,7 +391,7 @@ copy_graph_env (void) { set_irg_start (current_ir_graph, get_new_node(get_irg_start(current_ir_graph))); set_irg_start_block(current_ir_graph, - get_new_node(get_irg_start_block(current_ir_graph))); + get_new_node(get_irg_start_block(current_ir_graph))); set_irg_frame (current_ir_graph, get_new_node(get_irg_frame(current_ir_graph))); set_irg_globals(current_ir_graph, get_new_node(get_irg_globals(current_ir_graph))); set_irg_args (current_ir_graph, get_new_node(get_irg_args(current_ir_graph))); @@ -498,8 +498,8 @@ static void relink_bad_block_predecessors(ir_node *n, void *env) { new_in[0] = NULL; new_irn_n = 1; for (i = 1; i < old_irn_arity; i++) { - irn = intern_get_irn_n(n, i); - if (!is_Bad(irn)) new_in[new_irn_n++] = irn; + irn = intern_get_irn_n(n, i); + if (!is_Bad(irn)) new_in[new_irn_n++] = irn; } n->in = new_in; } /* ir node has bad predecessors */ @@ -536,10 +536,10 @@ static void relink_bad_predecessors(ir_node *n, void *env) { /* Relink Phi predeseccors if count of predeseccors changed */ if (old_irn_arity != ARR_LEN(get_irn_in(block))) { /* set new predeseccors in array - n->in[0] remains the same block */ + n->in[0] remains the same block */ new_irn_arity = 1; for(i = 1; i < old_irn_arity; i++) - if (!is_Bad((ir_node *)old_in[i])) n->in[new_irn_arity++] = n->in[i]; + if (!is_Bad((ir_node *)old_in[i])) n->in[new_irn_arity++] = n->in[i]; ARR_SETLEN(ir_node *, n->in, new_irn_arity); } @@ -636,7 +636,7 @@ void inline_method(ir_node *call, ir_graph *called_graph) { for the Call node, or do we branch directly to End on an exception? exc_handling: 0 There is a handler. 1 Branches to End. - 2 Exception handling not represented in Firm. -- */ + 2 Exception handling not represented in Firm. -- */ { ir_node *proj, *Mproj = NULL, *Xproj = NULL; for (proj = (ir_node *)get_irn_link(call); proj; proj = (ir_node *)get_irn_link(proj)) { @@ -644,9 +644,9 @@ void inline_method(ir_node *call, ir_graph *called_graph) { if (get_Proj_proj(proj) == pn_Call_X_except) Xproj = proj; if (get_Proj_proj(proj) == pn_Call_M_except) Mproj = proj; } - if (Mproj) { assert(Xproj); exc_handling = 0; } // Mproj - else if (Xproj) { exc_handling = 1; } //!Mproj && Xproj - else { exc_handling = 2; } //!Mproj && !Xproj + if (Mproj) { assert(Xproj); exc_handling = 0; } /* Mproj */ + else if (Xproj) { exc_handling = 1; } /* !Mproj && Xproj */ + else { exc_handling = 2; } /* !Mproj && !Xproj */ } @@ -684,11 +684,11 @@ void inline_method(ir_node *call, ir_graph *called_graph) { copying. */ set_irn_link(get_irg_start(called_graph), pre_call); set_irn_visited(get_irg_start(called_graph), - get_irg_visited(current_ir_graph)); + get_irg_visited(current_ir_graph)); set_irn_link(get_irg_start_block(called_graph), - get_nodes_Block(pre_call)); + get_nodes_Block(pre_call)); set_irn_visited(get_irg_start_block(called_graph), - get_irg_visited(current_ir_graph)); + get_irg_visited(current_ir_graph)); /* Initialize for compaction of in arrays */ inc_irg_block_visited(current_ir_graph); @@ -713,7 +713,7 @@ void inline_method(ir_node *call, ir_graph *called_graph) { entities. */ /* @@@ endless loops are not copied!! -- they should be, I think... */ irg_walk(get_irg_end(called_graph), copy_node_inline, copy_preds, - get_irg_frame_type(called_graph)); + get_irg_frame_type(called_graph)); /* Repair called_graph */ set_irg_visited(called_graph, get_irg_visited(current_ir_graph)); @@ -726,7 +726,7 @@ void inline_method(ir_node *call, ir_graph *called_graph) { -1: Block of Tuple. 0: Phi of all Memories of Return statements. 1: Jmp from new Block that merges the control flow from all exception - predecessors of the old end block. + predecessors of the old end block. 2: Tuple of all arguments. 3: Phi of Exception memories. In case the old Call directly branches to End on an exception we don't @@ -789,18 +789,18 @@ void inline_method(ir_node *call, ir_graph *called_graph) { for (j = 0; j < n_res; j++) { n_ret = 0; for (i = 0; i < arity; i++) { - ret = intern_get_irn_n(end_bl, i); - if (intern_get_irn_op(ret) == op_Return) { - cf_pred[n_ret] = get_Return_res(ret, j); - n_ret++; - } + ret = intern_get_irn_n(end_bl, i); + if (intern_get_irn_op(ret) == op_Return) { + cf_pred[n_ret] = get_Return_res(ret, j); + n_ret++; + } } phi = new_Phi(n_ret, cf_pred, intern_get_irn_mode(cf_pred[0])); res_pred[j] = phi; /* Conserve Phi-list for further inlinings -- but might be optimized */ if (get_nodes_Block(phi) == post_bl) { - set_irn_link(phi, get_irn_link(post_bl)); - set_irn_link(post_bl, phi); + set_irn_link(phi, get_irn_link(post_bl)); + set_irn_link(post_bl, phi); } } set_Tuple_pred(call, 2, new_Tuple(n_res, res_pred)); @@ -823,8 +823,8 @@ void inline_method(ir_node *call, ir_graph *called_graph) { ir_node *ret; ret = intern_get_irn_n(end_bl, i); if (is_fragile_op(skip_Proj(ret)) || (intern_get_irn_op(skip_Proj(ret)) == op_Raise)) { - cf_pred[n_exc] = ret; - n_exc++; + cf_pred[n_exc] = ret; + n_exc++; } } if (n_exc > 0) { @@ -833,19 +833,19 @@ void inline_method(ir_node *call, ir_graph *called_graph) { /* The Phi for the memories with the exception objects */ n_exc = 0; for (i = 0; i < arity; i++) { - ir_node *ret; - ret = skip_Proj(intern_get_irn_n(end_bl, i)); - if (intern_get_irn_op(ret) == op_Call) { - cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_Block(ret), ret, mode_M, 3); - n_exc++; - } else if (is_fragile_op(ret)) { - /* We rely that all cfops have the memory output at the same position. */ - cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_Block(ret), ret, mode_M, 0); - n_exc++; - } else if (intern_get_irn_op(ret) == op_Raise) { - cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_Block(ret), ret, mode_M, 1); - n_exc++; - } + ir_node *ret; + ret = skip_Proj(intern_get_irn_n(end_bl, i)); + if (intern_get_irn_op(ret) == op_Call) { + cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_Block(ret), ret, mode_M, 3); + n_exc++; + } else if (is_fragile_op(ret)) { + /* We rely that all cfops have the memory output at the same position. */ + cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_Block(ret), ret, mode_M, 0); + n_exc++; + } else if (intern_get_irn_op(ret) == op_Raise) { + cf_pred[n_exc] = new_r_Proj(current_ir_graph, get_nodes_Block(ret), ret, mode_M, 1); + n_exc++; + } } set_Tuple_pred(call, 3, new_Phi(n_exc, cf_pred, mode_M)); } else { @@ -899,14 +899,14 @@ void inline_method(ir_node *call, ir_graph *called_graph) { for (i = 0; i < get_Block_n_cfgpreds(end_bl); i++) { cf_op = get_Block_cfgpred(end_bl, i); if (intern_get_irn_op(cf_op) == op_Proj) { - cf_op = get_Proj_pred(cf_op); - if ((intern_get_irn_op(cf_op) == op_Tuple) && (cf_op == call)) { - // There are unoptimized tuples from inlineing before when no exc - assert(get_Proj_proj(get_Block_cfgpred(end_bl, i)) == pn_Call_X_except); - cf_op = get_Tuple_pred(cf_op, pn_Call_X_except); - assert(intern_get_irn_op(cf_op) == op_Jmp); - break; - } + cf_op = get_Proj_pred(cf_op); + if ((intern_get_irn_op(cf_op) == op_Tuple) && (cf_op == call)) { + /* There are unoptimized tuples from inlineing before when no exc */ + assert(get_Proj_proj(get_Block_cfgpred(end_bl, i)) == pn_Call_X_except); + cf_op = get_Tuple_pred(cf_op, pn_Call_X_except); + assert(intern_get_irn_op(cf_op) == op_Jmp); + break; + } } } /* repair */ @@ -915,14 +915,14 @@ void inline_method(ir_node *call, ir_graph *called_graph) { arity = get_Block_n_cfgpreds(end_bl) + get_Block_n_cfgpreds(bl) - 1; cf_pred = (ir_node **) malloc (arity * sizeof (ir_node *)); for (j = 0; j < i; j++) - cf_pred[j] = get_Block_cfgpred(end_bl, j); + cf_pred[j] = get_Block_cfgpred(end_bl, j); for (j = j; j < i + get_Block_n_cfgpreds(bl); j++) - cf_pred[j] = get_Block_cfgpred(bl, j-i); + cf_pred[j] = get_Block_cfgpred(bl, j-i); for (j = j; j < arity; j++) - cf_pred[j] = get_Block_cfgpred(end_bl, j-get_Block_n_cfgpreds(bl) +1); + cf_pred[j] = get_Block_cfgpred(end_bl, j-get_Block_n_cfgpreds(bl) +1); set_irn_in(end_bl, arity, cf_pred); free(cf_pred); - // Remove the exception pred from post-call Tuple. + /* Remove the exception pred from post-call Tuple. */ set_Tuple_pred(call, pn_Call_X_except, new_Bad()); } } @@ -1024,7 +1024,7 @@ void inline_small_irgs(ir_graph *irg, int size) { tv = get_Const_tarval(get_Call_ptr(calls[i])); callee = get_entity_irg(tarval_to_entity(tv)); if (((_obstack_memory_used(callee->obst) - obstack_room(callee->obst)) < size) || - (get_irg_inline_property(callee) == irg_inline_forced)) { + (get_irg_inline_property(callee) == irg_inline_forced)) { inline_method(calls[i], callee); } } @@ -1125,15 +1125,15 @@ void inline_leave_functions(int maxsize, int leavesize, int size) { assert(get_irg_callee_info_state(current_ir_graph) == irg_callee_info_none); irg_walk(get_irg_end(current_ir_graph), NULL, collect_calls2, - get_irg_link(current_ir_graph)); + get_irg_link(current_ir_graph)); env = (inline_irg_env *)get_irg_link(current_ir_graph); } /* and now inline. Inline leaves recursively -- we might construct new leaves. */ - //int itercnt = 1; + /* int itercnt = 1; */ while (did_inline) { - //printf("iteration %d\n", itercnt++); + /* printf("iteration %d\n", itercnt++); */ did_inline = 0; for (i = 0; i < n_irgs; ++i) { ir_node *call; @@ -1153,15 +1153,15 @@ void inline_leave_functions(int maxsize, int leavesize, int size) { if (env->n_nodes > maxsize) break; if (callee && - ((is_leave(callee) && is_smaller(callee, leavesize)) || - (get_irg_inline_property(callee) == irg_inline_forced))) { + ((is_leave(callee) && is_smaller(callee, leavesize)) || + (get_irg_inline_property(callee) == irg_inline_forced))) { if (!phiproj_computed) { phiproj_computed = 1; collect_phiprojs(current_ir_graph); } callee_env = (inline_irg_env *)get_irg_link(callee); -// printf(" %s: Inlineing %s.\n", get_entity_name(get_irg_entity(current_ir_graph)), -// get_entity_name(get_irg_entity(callee))); +/* printf(" %s: Inlineing %s.\n", get_entity_name(get_irg_entity(current_ir_graph)), */ +/* get_entity_name(get_irg_entity(callee))); */ inline_method(call, callee); did_inline = 1; env->n_call_nodes--; @@ -1177,7 +1177,7 @@ void inline_leave_functions(int maxsize, int leavesize, int size) { } } - //printf("Non leaves\n"); + /* printf("Non leaves\n"); */ /* inline other small functions. */ for (i = 0; i < n_irgs; ++i) { ir_node *call; @@ -1198,12 +1198,12 @@ void inline_leave_functions(int maxsize, int leavesize, int size) { if (env->n_nodes > maxsize) break; if (callee && is_smaller(callee, size)) { if (!phiproj_computed) { - phiproj_computed = 1; - collect_phiprojs(current_ir_graph); + phiproj_computed = 1; + collect_phiprojs(current_ir_graph); } callee_env = (inline_irg_env *)get_irg_link(callee); -// printf(" %s: Inlineing %s.\n", get_entity_name(get_irg_entity(current_ir_graph)), -// get_entity_name(get_irg_entity(callee))); +/* printf(" %s: Inlineing %s.\n", get_entity_name(get_irg_entity(current_ir_graph)), */ +/* get_entity_name(get_irg_entity(callee))); */ inline_method(call, callee); did_inline = 1; env->n_call_nodes--; @@ -1223,11 +1223,11 @@ void inline_leave_functions(int maxsize, int leavesize, int size) { #if 0 env = (inline_irg_env *)get_irg_link(current_ir_graph); if ((env->n_call_nodes_orig != env->n_call_nodes) || - (env->n_callers_orig != env->n_callers)) + (env->n_callers_orig != env->n_callers)) printf("Nodes:%3d ->%3d, calls:%3d ->%3d, callers:%3d ->%3d, -- %s\n", - env->n_nodes_orig, env->n_nodes, env->n_call_nodes_orig, env->n_call_nodes, - env->n_callers_orig, env->n_callers, - get_entity_name(get_irg_entity(current_ir_graph))); + env->n_nodes_orig, env->n_nodes, env->n_call_nodes_orig, env->n_call_nodes, + env->n_callers_orig, env->n_callers, + get_entity_name(get_irg_entity(current_ir_graph))); #endif free_inline_irg_env((inline_irg_env *)get_irg_link(current_ir_graph)); } @@ -1261,9 +1261,9 @@ place_floats_early(ir_node *n, pdeq *worklist) assert(intern_get_irn_op(n) != op_Block); if ((intern_get_irn_op(n) == op_Const) || - (intern_get_irn_op(n) == op_SymConst) || - (is_Bad(n)) || - (intern_get_irn_op(n) == op_Unknown)) { + (intern_get_irn_op(n) == op_SymConst) || + (is_Bad(n)) || + (intern_get_irn_op(n) == op_Unknown)) { /* These nodes will not be placed by the loop below. */ b = get_irg_start_block(current_ir_graph); depth = 1; @@ -1275,23 +1275,23 @@ place_floats_early(ir_node *n, pdeq *worklist) ir_node *dep = intern_get_irn_n(n, i); ir_node *dep_block; if ((irn_not_visited(dep)) && - (get_op_pinned(intern_get_irn_op(dep)) == floats)) { - place_floats_early(dep, worklist); + (get_op_pinned(intern_get_irn_op(dep)) == floats)) { + place_floats_early(dep, worklist); } /* Because all loops contain at least one pinned node, now all our inputs are either pinned or place_early has already been finished on them. We do not have any unfinished inputs! */ dep_block = get_nodes_Block(dep); if ((!is_Bad(dep_block)) && - (get_Block_dom_depth(dep_block) > depth)) { - b = dep_block; - depth = get_Block_dom_depth(dep_block); + (get_Block_dom_depth(dep_block) > depth)) { + b = dep_block; + depth = get_Block_dom_depth(dep_block); } /* Avoid that the node is placed in the Start block */ if ((depth == 1) && (get_Block_dom_depth(get_nodes_Block(n)) > 1)) { - b = get_Block_cfg_out(get_irg_start_block(current_ir_graph), 0); - assert(b != get_irg_start_block(current_ir_graph)); - depth = 2; + b = get_Block_cfg_out(get_irg_start_block(current_ir_graph), 0); + assert(b != get_irg_start_block(current_ir_graph)); + depth = 2; } } set_nodes_Block(n, b); @@ -1348,7 +1348,7 @@ consumer_dom_dca (ir_node *dca, ir_node *consumer, ir_node *producer) irn_arity = intern_get_irn_arity(consumer); for (i = 0; i < irn_arity; i++) { if (intern_get_irn_n(consumer, i) == producer) { - block = get_nodes_Block(get_Block_cfgpred(phi_block, i)); + block = get_nodes_Block(get_Block_cfgpred(phi_block, i)); } } } else { @@ -1441,20 +1441,20 @@ place_floats_late(ir_node *n, pdeq *worklist) for (i = 0; i < get_irn_n_outs(n); i++) { ir_node *succ = get_irn_out(n, i); if (irn_not_visited(succ) && (intern_get_irn_op(succ) != op_Phi)) - place_floats_late(succ, worklist); + place_floats_late(succ, worklist); } /* We have to determine the final block of this node... except for constants. */ if ((get_op_pinned(intern_get_irn_op(n)) == floats) && - (intern_get_irn_op(n) != op_Const) && - (intern_get_irn_op(n) != op_SymConst)) { - ir_node *dca = NULL; /* deepest common ancestor in the - dominator tree of all nodes' - blocks depending on us; our final - placement has to dominate DCA. */ + (intern_get_irn_op(n) != op_Const) && + (intern_get_irn_op(n) != op_SymConst)) { + ir_node *dca = NULL; /* deepest common ancestor in the + dominator tree of all nodes' + blocks depending on us; our final + placement has to dominate DCA. */ for (i = 0; i < get_irn_n_outs(n); i++) { - dca = consumer_dom_dca (dca, get_irn_out(n, i), n); + dca = consumer_dom_dca (dca, get_irn_out(n, i), n); } set_nodes_Block(n, dca); @@ -1544,20 +1544,20 @@ static void merge_blocks(ir_node *n, void *env) { /* Remove Tuples */ for (i = 0; i < get_Block_n_cfgpreds(n); i++) /* GL @@@ : is this possible? if (get_opt_normalize()) -- added, all tests go through. - A different order of optimizations might cause problems. */ + A different order of optimizations might cause problems. */ if (get_opt_normalize()) - set_Block_cfgpred(n, i, skip_Tuple(get_Block_cfgpred(n, i))); + set_Block_cfgpred(n, i, skip_Tuple(get_Block_cfgpred(n, i))); } else if (get_opt_optimize() && (intern_get_irn_mode(n) == mode_X)) { /* We will soon visit a block. Optimize it before visiting! */ ir_node *b = get_nodes_Block(n); ir_node *new_node = equivalent_node(b); while (irn_not_visited(b) && (!is_Bad(new_node)) && (new_node != b)) { /* We would have to run gigo if new is bad, so we - promote it directly below. */ + promote it directly below. */ assert(((b == new_node) || - get_opt_control_flow_straightening() || - get_opt_control_flow_weak_simplification()) && - ("strange flag setting")); + get_opt_control_flow_straightening() || + get_opt_control_flow_weak_simplification()) && + ("strange flag setting")); exchange (b, new_node); b = new_node; new_node = equivalent_node(b); @@ -1615,28 +1615,28 @@ static int test_whether_dispensable(ir_node *b, int pos) { n_preds = get_Block_n_cfgpreds(pred); } else { /* b's pred blocks and pred's pred blocks must be pairwise disjunct. - Work preds < pos as if they were already removed. */ + Work preds < pos as if they were already removed. */ for (i = 0; i < pos; i++) { - ir_node *b_pred = get_nodes_Block(get_Block_cfgpred(b, i)); - if (get_Block_block_visited(b_pred) + 1 - < get_irg_block_visited(current_ir_graph)) { - for (j = 0; j < get_Block_n_cfgpreds(b_pred); j++) { - ir_node *b_pred_pred = get_nodes_Block(get_Block_cfgpred(b_pred, j)); - if (is_pred_of(b_pred_pred, pred)) dispensable = 0; - } - } else { - if (is_pred_of(b_pred, pred)) dispensable = 0; - } + ir_node *b_pred = get_nodes_Block(get_Block_cfgpred(b, i)); + if (get_Block_block_visited(b_pred) + 1 + < get_irg_block_visited(current_ir_graph)) { + for (j = 0; j < get_Block_n_cfgpreds(b_pred); j++) { + ir_node *b_pred_pred = get_nodes_Block(get_Block_cfgpred(b_pred, j)); + if (is_pred_of(b_pred_pred, pred)) dispensable = 0; + } + } else { + if (is_pred_of(b_pred, pred)) dispensable = 0; + } } for (i = pos +1; i < get_Block_n_cfgpreds(b); i++) { - ir_node *b_pred = get_nodes_Block(get_Block_cfgpred(b, i)); - if (is_pred_of(b_pred, pred)) dispensable = 0; + ir_node *b_pred = get_nodes_Block(get_Block_cfgpred(b, i)); + if (is_pred_of(b_pred, pred)) dispensable = 0; } if (!dispensable) { - set_Block_block_visited(pred, get_irg_block_visited(current_ir_graph)-1); - n_preds = 1; + set_Block_block_visited(pred, get_irg_block_visited(current_ir_graph)-1); + n_preds = 1; } else { - n_preds = get_Block_n_cfgpreds(pred); + n_preds = get_Block_n_cfgpreds(pred); } } } @@ -1664,7 +1664,7 @@ static void optimize_blocks(ir_node *b, void *env) { if (is_Bad(get_Block_cfgpred(b, i))) { printf(" removing Bad %i\n ", i); } else if (get_Block_block_visited(pred) +1 - < get_irg_block_visited(current_ir_graph)) { + < get_irg_block_visited(current_ir_graph)) { printf(" removing pred %i ", i); DDMN(pred); } else { printf(" Nothing to do for "); DDMN(pred); } } @@ -1679,35 +1679,35 @@ static void optimize_blocks(ir_node *b, void *env) { for (i = 0; i < get_Block_n_cfgpreds(b); i++) { pred = get_nodes_Block(get_Block_cfgpred(b, i)); if (is_Bad(get_Block_cfgpred(b, i))) { - /* Do nothing */ + /* Do nothing */ } else if (get_Block_block_visited(pred) +1 - < get_irg_block_visited(current_ir_graph)) { - /* It's an empty block and not yet visited. */ - ir_node *phi_pred = get_Phi_pred(phi, i); - for (j = 0; j < get_Block_n_cfgpreds(pred); j++) { - if (get_nodes_Block(phi_pred) == pred) { - assert(intern_get_irn_op(phi_pred) == op_Phi); /* Block is empty!! */ - in[n_preds] = get_Phi_pred(phi_pred, j); - } else { - in[n_preds] = phi_pred; - } - n_preds++; - } - /* The Phi_pred node is replaced now if it is a Phi. - In Schleifen kann offenbar der entfernte Phi Knoten legal verwendet werden. - Daher muss der Phiknoten durch den neuen ersetzt werden. - Weiter muss der alte Phiknoten entfernt werden (durch ersetzen oder - durch einen Bad) damit er aus den keep_alive verschwinden kann. - Man sollte also, falls keine Schleife vorliegt, exchange mit new_Bad - aufrufen. */ - if (get_nodes_Block(phi_pred) == pred) { - /* remove the Phi as it might be kept alive. Further there - might be other users. */ - exchange(phi_pred, phi); /* geht, ist aber doch semantisch falsch! Warum?? */ - } + < get_irg_block_visited(current_ir_graph)) { + /* It's an empty block and not yet visited. */ + ir_node *phi_pred = get_Phi_pred(phi, i); + for (j = 0; j < get_Block_n_cfgpreds(pred); j++) { + if (get_nodes_Block(phi_pred) == pred) { + assert(intern_get_irn_op(phi_pred) == op_Phi); /* Block is empty!! */ + in[n_preds] = get_Phi_pred(phi_pred, j); } else { - in[n_preds] = get_Phi_pred(phi, i); - n_preds ++; + in[n_preds] = phi_pred; + } + n_preds++; + } + /* The Phi_pred node is replaced now if it is a Phi. + In Schleifen kann offenbar der entfernte Phi Knoten legal verwendet werden. + Daher muss der Phiknoten durch den neuen ersetzt werden. + Weiter muss der alte Phiknoten entfernt werden (durch ersetzen oder + durch einen Bad) damit er aus den keep_alive verschwinden kann. + Man sollte also, falls keine Schleife vorliegt, exchange mit new_Bad + aufrufen. */ + if (get_nodes_Block(phi_pred) == pred) { + /* remove the Phi as it might be kept alive. Further there + might be other users. */ + exchange(phi_pred, phi); /* geht, ist aber doch semantisch falsch! Warum?? */ + } + } else { + in[n_preds] = get_Phi_pred(phi, i); + n_preds ++; } } /* Fix the node */ @@ -1721,55 +1721,55 @@ static void optimize_blocks(ir_node *b, void *env) { for (k = 0; k < get_Block_n_cfgpreds(b); k++) { pred = get_nodes_Block(get_Block_cfgpred(b, k)); if (get_Block_block_visited(pred) +1 - < get_irg_block_visited(current_ir_graph)) { + < get_irg_block_visited(current_ir_graph)) { phi = get_irn_link(pred); while (phi) { - if (intern_get_irn_op(phi) == op_Phi) { - set_nodes_Block(phi, b); - - n_preds = 0; - for (i = 0; i < k; i++) { - pred = get_nodes_Block(get_Block_cfgpred(b, i)); - if (is_Bad(get_Block_cfgpred(b, i))) { - /* Do nothing */ - } else if (get_Block_block_visited(pred) +1 - < get_irg_block_visited(current_ir_graph)) { - /* It's an empty block and not yet visited. */ - for (j = 0; j < get_Block_n_cfgpreds(pred); j++) { - /* @@@ Hier brauche ich Schleifeninformation!!! Kontrollflusskante - muss Rueckwaertskante sein! (An allen vier in[n_preds] = phi - Anweisungen.) Trotzdem tuts bisher!! */ - in[n_preds] = phi; - n_preds++; - } - } else { - in[n_preds] = phi; - n_preds++; - } - } - for (i = 0; i < get_Phi_n_preds(phi); i++) { - in[n_preds] = get_Phi_pred(phi, i); - n_preds++; - } - for (i = k+1; i < get_Block_n_cfgpreds(b); i++) { - pred = get_nodes_Block(get_Block_cfgpred(b, i)); - if (is_Bad(get_Block_cfgpred(b, i))) { - /* Do nothing */ - } else if (get_Block_block_visited(pred) +1 - < get_irg_block_visited(current_ir_graph)) { - /* It's an empty block and not yet visited. */ - for (j = 0; j < get_Block_n_cfgpreds(pred); j++) { - in[n_preds] = phi; - n_preds++; - } - } else { - in[n_preds] = phi; - n_preds++; - } - } - set_irn_in(phi, n_preds, in); - } - phi = get_irn_link(phi); + if (intern_get_irn_op(phi) == op_Phi) { + set_nodes_Block(phi, b); + + n_preds = 0; + for (i = 0; i < k; i++) { + pred = get_nodes_Block(get_Block_cfgpred(b, i)); + if (is_Bad(get_Block_cfgpred(b, i))) { + /* Do nothing */ + } else if (get_Block_block_visited(pred) +1 + < get_irg_block_visited(current_ir_graph)) { + /* It's an empty block and not yet visited. */ + for (j = 0; j < get_Block_n_cfgpreds(pred); j++) { + /* @@@ Hier brauche ich Schleifeninformation!!! Kontrollflusskante + muss Rueckwaertskante sein! (An allen vier in[n_preds] = phi + Anweisungen.) Trotzdem tuts bisher!! */ + in[n_preds] = phi; + n_preds++; + } + } else { + in[n_preds] = phi; + n_preds++; + } + } + for (i = 0; i < get_Phi_n_preds(phi); i++) { + in[n_preds] = get_Phi_pred(phi, i); + n_preds++; + } + for (i = k+1; i < get_Block_n_cfgpreds(b); i++) { + pred = get_nodes_Block(get_Block_cfgpred(b, i)); + if (is_Bad(get_Block_cfgpred(b, i))) { + /* Do nothing */ + } else if (get_Block_block_visited(pred) +1 + < get_irg_block_visited(current_ir_graph)) { + /* It's an empty block and not yet visited. */ + for (j = 0; j < get_Block_n_cfgpreds(pred); j++) { + in[n_preds] = phi; + n_preds++; + } + } else { + in[n_preds] = phi; + n_preds++; + } + } + set_irn_in(phi, n_preds, in); + } + phi = get_irn_link(phi); } } } @@ -1781,13 +1781,13 @@ static void optimize_blocks(ir_node *b, void *env) { if (is_Bad(get_Block_cfgpred(b, i))) { /* Do nothing */ } else if (get_Block_block_visited(pred) +1 - < get_irg_block_visited(current_ir_graph)) { + < get_irg_block_visited(current_ir_graph)) { /* It's an empty block and not yet visited. */ assert(get_Block_n_cfgpreds(b) > 1); /* Else it should be optimized by equivalent_node. */ for (j = 0; j < get_Block_n_cfgpreds(pred); j++) { - in[n_preds] = get_Block_cfgpred(pred, j); - n_preds++; + in[n_preds] = get_Block_cfgpred(pred, j); + n_preds++; } /* Remove block as it might be kept alive. */ exchange(pred, b/*new_Bad()*/); @@ -1830,14 +1830,14 @@ void optimize_cf(ir_graph *irg) { ir_node *ka = get_End_keepalive(end, i); if (irn_not_visited(ka)) { if ((intern_get_irn_op(ka) == op_Block) && Block_not_block_visited(ka)) { - set_irg_block_visited(current_ir_graph, /* Don't walk all the way to Start. */ - get_irg_block_visited(current_ir_graph)-1); - irg_block_walk(ka, optimize_blocks, NULL, NULL); - mark_irn_visited(ka); - ARR_APP1 (ir_node *, in, ka); + set_irg_block_visited(current_ir_graph, /* Don't walk all the way to Start. */ + get_irg_block_visited(current_ir_graph)-1); + irg_block_walk(ka, optimize_blocks, NULL, NULL); + mark_irn_visited(ka); + ARR_APP1 (ir_node *, in, ka); } else if (intern_get_irn_op(ka) == op_Phi) { - mark_irn_visited(ka); - ARR_APP1 (ir_node *, in, ka); + mark_irn_visited(ka); + ARR_APP1 (ir_node *, in, ka); } } } @@ -1868,26 +1868,26 @@ static void walk_critical_cf_edges(ir_node *n, void *env) { arity = intern_get_irn_arity(n); if (n == get_irg_end_block(current_ir_graph)) - return; // No use to add a block here. + return; /* No use to add a block here. */ for (i=0; iobst, 1); - /* set predecessor of new block */ - in[0] = pre; - block = new_Block(1, in); - /* insert new jmp node to new block */ - switch_block(block); - jmp = new_Jmp(); - switch_block(n); - /* set successor of new block */ - set_irn_n(n, i, jmp); + (op_Proj == intern_get_irn_op(pre)) && + op_Raise != intern_get_irn_op(skip_Proj(pre))) { + + /* set predecessor array for new block */ + in = NEW_ARR_D (ir_node *, current_ir_graph->obst, 1); + /* set predecessor of new block */ + in[0] = pre; + block = new_Block(1, in); + /* insert new jmp node to new block */ + switch_block(block); + jmp = new_Jmp(); + switch_block(n); + /* set successor of new block */ + set_irn_n(n, i, jmp); } /* predecessor has multiple successors */ } /* for all predecessors */ diff --git a/ir/ir/irgraph.c b/ir/ir/irgraph.c index 1d593a801..d27e0827a 100644 --- a/ir/ir/irgraph.c +++ b/ir/ir/irgraph.c @@ -82,13 +82,13 @@ new_ir_graph (entity *ent, int n_loc) #if PRECISE_EXC_CONTEXT res->n_loc = n_loc + 1 + 1; /* number of local variables that are never dereferenced in this graph plus one for - the store plus one for links to fragile - operations. n_loc is not the number of - parameters to the procedure! */ + the store plus one for links to fragile + operations. n_loc is not the number of + parameters to the procedure! */ #else res->n_loc = n_loc + 1; /* number of local variables that are never dereferenced in this graph plus one for - the store. This is not the number of parameters + the store. This is not the number of parameters to the procedure! */ #endif @@ -103,8 +103,8 @@ new_ir_graph (entity *ent, int n_loc) res->obst = (struct obstack *) xmalloc (sizeof (struct obstack)); obstack_init (res->obst); res->value_table = new_identities (); /* value table for global value - numbering for optimizing use in - iropt.c */ + numbering for optimizing use in + iropt.c */ res->outs = NULL; res->phase_state = phase_building; @@ -131,7 +131,7 @@ new_ir_graph (entity *ent, int n_loc) res->start_block = new_immBlock (); res->start = new_Start (); res->bad = new_ir_node (NULL, res, res->start_block, op_Bad, mode_T, 0, NULL); - //res->unknown = new_ir_node (NULL, res, res->start_block, op_Unknown, mode_T, 0, NULL); + /* res->unknown = new_ir_node (NULL, res, res->start_block, op_Unknown, mode_T, 0, NULL); */ /* Proj results of start node */ projX = new_Proj (res->start, mode_X, pns_initial_exec); @@ -182,8 +182,8 @@ ir_graph *new_const_code_irg(void) { res->phase_state = phase_building; res->pinned = pinned; res->value_table = new_identities (); /* value table for global value - numbering for optimizing use in - iropt.c */ + numbering for optimizing use in + iropt.c */ res->ent = NULL; res->frame_type = NULL; res->start_block = new_immBlock (); @@ -191,7 +191,7 @@ ir_graph *new_const_code_irg(void) { res->end = new_End (); mature_block(get_cur_block()); res->bad = new_ir_node (NULL, res, res->start_block, op_Bad, mode_T, 0, NULL); - //res->unknown = new_ir_node (NULL, res, res->start_block, op_Unknown, mode_T, 0, NULL); + /* res->unknown = new_ir_node (NULL, res, res->start_block, op_Unknown, mode_T, 0, NULL); */ res->start = new_Start (); /* Proj results of start node */ @@ -470,7 +470,7 @@ struct obstack *get_irg_obstack(ir_graph *irg) { */ int node_is_in_irgs_storage(ir_graph *irg, ir_node *n) { - struct _obstack_chunk *p; + struct _obstack_chunk *p; /* * checks wheater the ir_node pointer i on the obstack. diff --git a/ir/ir/irgraph_t.h b/ir/ir/irgraph_t.h index f346891aa..b35c62324 100644 --- a/ir/ir/irgraph_t.h +++ b/ir/ir/irgraph_t.h @@ -34,26 +34,26 @@ struct ir_graph { firm_kind kind; /**< always set to k_ir_graph*/ /* -- Basics of the representation -- */ struct entity *ent; /**< The entity of this procedure, i.e., - the type of the procedure and the - class it belongs to. */ + the type of the procedure and the + class it belongs to. */ struct type *frame_type; /**< A class type representing the stack frame. - Can include "inner" methods. */ + Can include "inner" methods. */ struct ir_node *start_block; /**< block the start node will belong to */ - struct ir_node *start; /**< start node of this ir_graph */ + struct ir_node *start; /**< start node of this ir_graph */ struct ir_node *end_block; /**< block the end node will belong to */ - struct ir_node *end; /**< end node of this ir_graph */ - struct ir_node *cstore; /**< constant store -- no more needed!! */ + struct ir_node *end; /**< end node of this ir_graph */ + struct ir_node *cstore; /**< constant store -- no more needed!! */ struct ir_node *frame; /**< method's frame */ struct ir_node *globals; /**< pointer to the data segment containing all - globals as well as global procedures. */ + globals as well as global procedures. */ struct ir_node *args; /**< methods arguments */ - struct ir_node *bad; /**< bad node of this ir_graph, the one and + struct ir_node *bad; /**< bad node of this ir_graph, the one and only in this graph */ /* GL removed: we need unknown with mode for analyses. */ - // struct ir_node *unknown; /**< unknown node of this ir_graph */ - struct obstack *obst; /**< obstack where all of the ir_nodes live */ + /* struct ir_node *unknown;*/ /**< unknown node of this ir_graph */ + struct obstack *obst; /**< obstack where all of the ir_nodes live */ struct ir_node *current_block; /**< block for newly gen_*()-erated - ir_nodes */ + ir_nodes */ /* -- Fields indicating different states of irgraph -- */ irg_phase_state phase_state; /**< compiler phase */ @@ -70,25 +70,25 @@ struct ir_graph { struct Phi_in_stack *Phi_in_stack; /**< needed for automatic Phi construction */ #endif int n_loc; /**< number of local variable in this - procedure including procedure parameters. */ + procedure including procedure parameters. */ /* -- Fields for optimizations / analysis information -- */ pset *value_table; /**< hash table for global value numbering (cse) - for optimizing use in iropt.c */ + for optimizing use in iropt.c */ struct ir_node **outs; /**< Space for the out arrays. */ struct ir_loop *loop; /**< The outermost loop */ void *link; /**< A void* field to link any information to - the node. */ + the node. */ /* -- Fields for Walking the graph -- */ unsigned long visited; /**< this flag is an identifier for - ir walk. it will be incremented - every time someone walks through - the graph */ + ir walk. it will be incremented + every time someone walks through + the graph */ unsigned long block_visited; /**< same as visited, for a complete block */ #ifdef DEBUG_libfirm int graph_nr; /**< a unique graph number for each graph to make output - readable. */ + readable. */ #endif }; @@ -101,8 +101,8 @@ ir_graph *new_const_code_irg(void); /** * Set the pinned state of a graph. * - * @irg the IR graph - * @p new pin state + * @irg the IR graph + * @p new pin state */ INLINE void set_irg_pinned (ir_graph *irg, op_pinned p); @@ -113,8 +113,8 @@ struct obstack *get_irg_obstack(ir_graph *irg); /** * Returns true if the node n is allocated on the storage of graph irg. * - * @param irg the IR graph - * @param n the IR node + * @param irg the IR graph + * @param n the IR node */ int node_is_in_irgs_storage(ir_graph *irg, ir_node *n); diff --git a/ir/ir/irnode.h b/ir/ir/irnode.h index 4165560f6..26ac6d5b6 100644 --- a/ir/ir/irnode.h +++ b/ir/ir/irnode.h @@ -46,7 +46,7 @@ typedef enum { # include "irmode.h" # include "type.h" # include "dbginfo.h" -//# include "exc.h" +/* # include "exc.h" */ /** * @file irnode.h @@ -637,7 +637,7 @@ typedef enum { pn_Cmp_True = 15 /**< true */ /* not_mask = Leg*/ /* bits to flip to negate comparison * @@ hack for jni interface */ } pn_Cmp; /* Projection numbers for Cmp */ -//#define not_mask pn_Cmp_Leg +/* #define not_mask pn_Cmp_Leg */ const char *get_pnc_string(int pnc); int get_negated_pnc(int pnc); diff --git a/ir/ir/irnode_t.h b/ir/ir/irnode_t.h index 142c5c2a8..5d4e6ee63 100644 --- a/ir/ir/irnode_t.h +++ b/ir/ir/irnode_t.h @@ -50,32 +50,32 @@ typedef struct { struct ir_node **graph_arr; /**< array to store all parameters */ /* Attributes holding analyses information */ struct dom_info dom; /**< Datastructure that holds information about dominators. - @@@ @todo - Eventually overlay with graph_arr as only valid - in different phases. Eventually inline the whole - datastructure. */ - // exc_t exc; /**< role of this block for exception handling */ - // ir_node *handler_entry; /**< handler entry block iff this block is part of a region */ + @@@ @todo + Eventually overlay with graph_arr as only valid + in different phases. Eventually inline the whole + datastructure. */ + /* exc_t exc; */ /**< role of this block for exception handling */ + /* ir_node *handler_entry; */ /**< handler entry block iff this block is part of a region */ ir_node ** in_cg; /**< array with predecessors in - * interprocedural_view, if they differ - * from intraprocedural predecessors */ + * interprocedural_view, if they differ + * from intraprocedural predecessors */ int *backedge; /**< Field n set to true if pred n is backedge. - @@@ @todo Ev. replace by bitfield! */ + @@@ @todo Ev. replace by bitfield! */ int *cg_backedge; /**< Field n set to true if pred n is interprocedural backedge. - @@@ @todo Ev. replace by bitfield! */ + @@@ @todo Ev. replace by bitfield! */ } block_attr; /** Start attributes */ typedef struct { char dummy; - // ir_graph *irg; @@@ now in block + /* ir_graph *irg; @@@ now in block */ } start_attr; /** Cond attributes */ typedef struct { cond_kind kind; /**< flavor of Cond */ long default_proj; /**< for optimization: biggest Proj number, i.e. the one - used for default. */ + used for default. */ } cond_attr; /** Const attributes */ @@ -130,22 +130,22 @@ typedef struct { long proj; /**< contains the result position to project (Proj) */ ir_node ** in_cg; /**< array with interprocedural predecessors (Phi) */ int *backedge; /**< Field n set to true if pred n is backedge. - @todo Ev. replace by bitfield! */ + @todo Ev. replace by bitfield! */ } filter_attr; /** EndReg/EndExcept attributes */ typedef struct { char dummy; - // ir_graph * irg; /**< ir_graph this node belongs to (for - // * navigating in interprocedural graphs) - // @@@ now in block */ + /* ir_graph * irg; */ /**< ir_graph this node belongs to (for */ + /* * navigating in interprocedural graphs) */ + /* @@@ now in block */ } end_attr; /** CallBegin attributes */ typedef struct { - // ir_graph * irg; / **< ir_graph this node belongs to (for - // * navigating in interprocedural graphs) */ - // @@@ now in block + /* ir_graph * irg; */ /**< ir_graph this node belongs to (for */ + /* * navigating in interprocedural graphs) */ + /* @@@ now in block */ ir_node * call; /**< associated Call-operation */ } callbegin_attr; @@ -168,25 +168,25 @@ typedef union { call_attr call; /**< For Call: pointer to the type of the method to call */ callbegin_attr callbegin; /**< For CallBegin */ alloc_attr a; /**< For Alloc. */ - io_attr io; /**< For InstOf */ + io_attr io; /**< For InstOf */ type *f; /**< For Free. */ cast_attr cast; /**< For Cast. */ int phi0_pos; /**< For Phi. Used to remember the value defined by - this Phi node. Needed when the Phi is completed - to call get_r_internal_value to find the - predecessors. If this attribute is set, the Phi - node takes the role of the obsolete Phi0 node, - therefore the name. */ + this Phi node. Needed when the Phi is completed + to call get_r_internal_value to find the + predecessors. If this attribute is set, the Phi + node takes the role of the obsolete Phi0 node, + therefore the name. */ int *phi_backedge; /**< For Phi after construction. - Field n set to true if pred n is backedge. - @todo Ev. replace by bitfield! */ + Field n set to true if pred n is backedge. + @todo Ev. replace by bitfield! */ long proj; /**< For Proj: contains the result position to project */ confirm_attr confirm_cmp; /**< For Confirm: compare operation */ filter_attr filter; /**< For Filter */ end_attr end; /**< For EndReg, EndExcept */ #if PRECISE_EXC_CONTEXT struct ir_node **frag_arr; /**< For Phi node construction in case of exceptions - for nodes Store, Load, Div, Mod, Quot, DivMod. */ + for nodes Store, Load, Div, Mod, Quot, DivMod. */ #endif } attr; @@ -202,15 +202,15 @@ struct ir_node { struct ir_node **in; /**< array with predecessors / operands */ void *link; /**< to attach additional information to the node, e.g. used while construction to link Phi0 nodes and - during optimization to link to nodes that - shall replace a node. */ + during optimization to link to nodes that + shall replace a node. */ /* ------- Fields for optimizations / analysis information ------- */ struct ir_node **out; /**< array of out edges */ struct dbg_info* dbi; /**< A pointer to information for debug support. */ /* ------- For debugging ------- */ #ifdef DEBUG_libfirm int node_nr; /**< a unique node number for each node to make output - readable. */ + readable. */ #endif /* ------- For analyses -------- */ ir_loop *loop; /**< the loop the node is in. Access routines in irloop.h */ diff --git a/ir/ir/irvrfy.c b/ir/ir/irvrfy.c index d0b532975..faf381e79 100644 --- a/ir/ir/irvrfy.c +++ b/ir/ir/irvrfy.c @@ -542,19 +542,19 @@ int irn_vrfy_irg(ir_node *n, ir_graph *irg) (get_irn_mode(pred) == mode_X) ), "Block node", 0); } - // End block may only have Return, Raise or fragile ops as preds. + /* End block may only have Return, Raise or fragile ops as preds. */ if (n == get_irg_end_block(irg)) for (i = 0; i < get_Block_n_cfgpreds(n); ++i) { ir_node *pred = skip_Proj(get_Block_cfgpred(n, i)); if (is_Proj(pred) || get_irn_op(pred) == op_Tuple) - break; // We can not test properly. How many tuples are there? + break; /* We can not test properly. How many tuples are there? */ ASSERT_AND_RET(((get_irn_op(pred) == op_Return) || is_Bad(pred) || (get_irn_op(pred) == op_Raise) || is_fragile_op(pred) ), "End Block node", 0); } - // irg attr must == graph we are in. + /* irg attr must == graph we are in. */ if (! interprocedural_view) { ASSERT_AND_RET(((get_irn_irg(n) && get_irn_irg(n) == irg)), "Block node has wrong irg attribute", 0); } diff --git a/ir/ir/old_fctnames.h b/ir/ir/old_fctnames.h index 649e49fa8..36235ba7b 100644 --- a/ir/ir/old_fctnames.h +++ b/ir/ir/old_fctnames.h @@ -27,8 +27,8 @@ #define get_ident_of_mode get_mode_ident #define get_size_of_mode get_mode_size #define get_ld_align_of_mode get_mode_ld_align -#define get_min_of_mode get_mode_min -#define get_max_of_mode get_mode_max +#define get_min_of_mode get_mode_min +#define get_max_of_mode get_mode_max #define get_null_of_mode get_mode_null #define get_fsigned_of_mode get_mode_fsigned #define get_ffloat_of_mode get_mode_ffloat @@ -49,8 +49,8 @@ #define tarval_P_from_entity(X) new_tarval_from_entity(X, mode_P_mach) #define get_tarval_entity(X) tarval_to_entity(X) -/* ident.h */ // @@@ Attention: still in ident.h -//#define id_to_str get_id_str -//#define id_to_strlen get_id_strlen +/* ident.h */ /* @@@ Attention: still in ident.h */ +/* #define id_to_str get_id_str */ +/* #define id_to_strlen get_id_strlen */ #endif diff --git a/ir/tr/entity.c b/ir/tr/entity.c index 71d85b65a..2a2810bc9 100644 --- a/ir/tr/entity.c +++ b/ir/tr/entity.c @@ -131,14 +131,14 @@ void free_entity_attrs(entity *ent) { DEL_ARR_F(ent->overwrites); ent->overwrites = NULL; DEL_ARR_F(ent->overwrittenby); ent->overwrittenby = NULL; } - //if (ent->values) DEL_ARR_F(ent->values); /* @@@ warum nich? */ + /* if (ent->values) DEL_ARR_F(ent->values); *//* @@@ warum nich? */ if (ent->val_paths) { if (is_compound_entity(ent)) for (i = 0; i < get_compound_ent_n_values(ent); i++) - if (ent->val_paths[i]) ; - /* free_compound_graph_path(ent->val_paths[i]) ; * @@@ warum nich? */ - /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */ - //DEL_ARR_F(ent->val_paths); + if (ent->val_paths[i]) ; + /* free_compound_graph_path(ent->val_paths[i]) ; * @@@ warum nich? */ + /* Geht nich: wird mehrfach verwendet!!! ==> mehrfach frei gegeben. */ + /* DEL_ARR_F(ent->val_paths); */ } ent->val_paths = NULL; ent->values = NULL; @@ -159,7 +159,7 @@ copy_entity_own (entity *old, type *new_owner) { new->overwrites = DUP_ARR_F(entity *, old->overwrites); new->overwrittenby = DUP_ARR_F(entity *, old->overwrittenby); } else if ((get_type_tpop(get_entity_owner(old)) != type_class) && - (get_type_tpop(new_owner) == type_class)) { + (get_type_tpop(new_owner) == type_class)) { new->overwrites = NEW_ARR_F(entity *, 0); new->overwrittenby = NEW_ARR_F(entity *, 0); } @@ -252,8 +252,8 @@ assert_legal_owner_of_ent(type *owner) { assert (get_type_tpop_code(owner) == tpo_class || get_type_tpop_code(owner) == tpo_union || get_type_tpop_code(owner) == tpo_struct || - get_type_tpop_code(owner) == tpo_array); /* Yes, array has an entity - -- to select fields! */ + get_type_tpop_code(owner) == tpo_array); /* Yes, array has an entity + -- to select fields! */ } ident * @@ -303,7 +303,7 @@ set_entity_allocation (entity *ent, ent_allocation al) { /* return the name of the visibility */ const char *get_allocation_name(ent_allocation all) { -#define X(a) case a: return #a +#define X(a) case a: return #a switch (all) { X(allocation_automatic); X(allocation_parameter); @@ -324,7 +324,7 @@ void set_entity_visibility (entity *ent, ent_visibility vis) { if (vis != visibility_local) assert((ent->allocation == allocation_static) || - (ent->allocation == allocation_automatic)); + (ent->allocation == allocation_automatic)); /* @@@ Test that the owner type is not local, but how?? && get_class_visibility(get_entity_owner(ent)) != local));*/ ent->visibility = vis; @@ -333,7 +333,7 @@ set_entity_visibility (entity *ent, ent_visibility vis) { /* return the name of the visibility */ const char *get_visibility_name(ent_visibility vis) { -#define X(a) case a: return #a +#define X(a) case a: return #a switch (vis) { X(visibility_local); X(visibility_external_visible); @@ -373,7 +373,7 @@ set_entity_variability (entity *ent, ent_variability var) /* return the name of the variablity */ const char *get_variability_name(ent_variability var) { -#define X(a) case a: return #a +#define X(a) case a: return #a switch (var) { X(variability_uninitialized); X(variability_initialized); @@ -399,7 +399,7 @@ set_entity_volatility (entity *ent, ent_volatility vol) { /* return the name of the volatility */ const char *get_volatility_name(ent_volatility var) { -#define X(a) case a: return #a +#define X(a) case a: return #a switch (var) { X(volatility_non_volatile); X(volatility_is_volatile); @@ -425,7 +425,7 @@ set_entity_peculiarity (entity *ent, peculiarity pec) { /* return the name of the peculiarity */ const char *get_peculiarity_name(peculiarity var) { -#define X(a) case a: return #a +#define X(a) case a: return #a switch (var) { X(peculiarity_description); X(peculiarity_inherited); @@ -490,7 +490,7 @@ ir_node *copy_const_value(ir_node *n) { nn = new_SymConst(get_SymConst_type_or_id(n), get_SymConst_kind(n)); break; case iro_Add: nn = new_Add(copy_const_value(get_Add_left(n)), - copy_const_value(get_Add_right(n)), m); break; + copy_const_value(get_Add_right(n)), m); break; case iro_Cast: nn = new_Cast(copy_const_value(get_Cast_op(n)), get_Cast_type(n)); break; case iro_Conv: @@ -612,8 +612,8 @@ remove_compound_ent_value(entity *ent, entity *value_ent) { compound_graph_path *path = ent->val_paths[i]; if (path->nodes[path->len-1] == value_ent) { for(; i < (ARR_LEN (ent->val_paths))-1; i++) { - ent->val_paths[i] = ent->val_paths[i+1]; - ent->values[i] = ent->values[i+1]; + ent->val_paths[i] = ent->val_paths[i+1]; + ent->values[i] = ent->values[i+1]; } ARR_SETLEN(entity*, ent->val_paths, ARR_LEN(ent->val_paths) - 1); ARR_SETLEN(ir_node*, ent->values, ARR_LEN(ent->values) - 1); @@ -751,7 +751,7 @@ remove_entity_overwrites(entity *ent, entity *overwritten) { for (i = 0; i < (ARR_LEN (ent->overwrites)); i++) if (ent->overwrites[i] == overwritten) { for(; i < (ARR_LEN (ent->overwrites))-1; i++) - ent->overwrites[i] = ent->overwrites[i+1]; + ent->overwrites[i] = ent->overwrites[i+1]; ARR_SETLEN(entity*, ent->overwrites, ARR_LEN(ent->overwrites) - 1); break; } @@ -803,7 +803,7 @@ void remove_entity_overwrittenby(entity *ent, entity *overwrites) { for (i = 0; i < (ARR_LEN (ent->overwrittenby)); i++) if (ent->overwrittenby[i] == overwrites) { for(; i < (ARR_LEN (ent->overwrittenby))-1; i++) - ent->overwrittenby[i] = ent->overwrittenby[i+1]; + ent->overwrittenby[i] = ent->overwrittenby[i+1]; ARR_SETLEN(entity*, ent->overwrittenby, ARR_LEN(ent->overwrittenby) - 1); break; } @@ -852,13 +852,13 @@ int is_entity (void *thing) { int is_atomic_entity(entity *ent) { type* t = get_entity_type(ent); return (is_primitive_type(t) || is_pointer_type(t) || - is_enumeration_type(t) || is_method_type(t)); + is_enumeration_type(t) || is_method_type(t)); } int is_compound_entity(entity *ent) { type* t = get_entity_type(ent); return (is_class_type(t) || is_struct_type(t) || - is_array_type(t) || is_union_type(t)); + is_array_type(t) || is_union_type(t)); } /* @@@ not implemnted!!! */ @@ -935,7 +935,7 @@ entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent) { #if 1 || DEBUG_libfirm int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */ -#define X(a) case a: printf(#a); break +#define X(a) case a: printf(#a); break void dump_entity (entity *ent) { int i, j; type *owner = get_entity_owner(ent); @@ -974,13 +974,13 @@ void dump_entity (entity *ent) { } else { printf("\n compound values:"); for (i = 0; i < get_compound_ent_n_values(ent); ++i) { - compound_graph_path *path = get_compound_ent_value_path(ent, i); - entity *ent0 = get_compound_graph_path_node(path, 0); - printf("\n %2d %s", get_entity_offset(ent0), get_entity_name(ent0)); - for (j = 1; j < get_compound_graph_path_length(path); ++j) - printf(".%s", get_entity_name(get_compound_graph_path_node(path, j))); - printf("\t = "); - dump_node_opcode(stdout, get_compound_ent_value(ent, i)); + compound_graph_path *path = get_compound_ent_value_path(ent, i); + entity *ent0 = get_compound_graph_path_node(path, 0); + printf("\n %2d %s", get_entity_offset(ent0), get_entity_name(ent0)); + for (j = 1; j < get_compound_graph_path_length(path); ++j) + printf(".%s", get_entity_name(get_compound_graph_path_node(path, j))); + printf("\t = "); + dump_node_opcode(stdout, get_compound_ent_value(ent, i)); } } } diff --git a/ir/tv/IeeeCC754/include/Bitstring.h b/ir/tv/IeeeCC754/include/Bitstring.h index 37518c58c..e67229603 100644 --- a/ir/tv/IeeeCC754/include/Bitstring.h +++ b/ir/tv/IeeeCC754/include/Bitstring.h @@ -10,7 +10,7 @@ # with the principles of the IEEE 754-854 floating-point standards. # # You can find out more about the testing tool IeeeCC754 at # # # -# http://win-www.uia.ac.be/u/cant/ieeecc754.html # +# http:/* win-www.uia.ac.be/u/cant/ieeecc754.html # */ # # # This tool is in parts based on and greatly benefited from the # # the program FPTEST developed by Jerome Coonen. For a full # @@ -93,17 +93,17 @@ because this concept simplifies the resizing of the bitstring. class Bitstring { protected: - ///the bitstring + /* * the bitstring */ */ unsigned long * bitstr; - ///length of bitstring, + /* * length of bitstring, */ */ long length; - /// number of array elments + /* * number of array elments */ */ long lengthBlock; - ///number of bits in class T + /* * number of bits in class T */ */ long lengthT; - /// returns a unsigned long with the first res bits set. + /* * returns a unsigned long with the first res bits set. */ */ unsigned long GetPattern(unsigned long rest); /** returns the first block of bitstr. It's only defined @@ -112,7 +112,7 @@ protected: unsigned long Convert(); public: - /// Constructor, creates an empty bitstring + /* * Constructor, creates an empty bitstring */ */ Bitstring(); /**Constructor, creates a bitstring of size size. @param size the default size*/ @@ -120,9 +120,9 @@ public: /**Constructor,initiate the bitstring with the str as input @param str the default value for the bitstring */ Bitstring(char * str); - /// Copy constructor. + /* * Copy constructor. */ */ Bitstring(const Bitstring& copy); - ///Destructor + /* * Destructor */ */ ~Bitstring(); /**Get the length of the bitstring. @@ -170,7 +170,7 @@ public: /** Replace the byte value at position "byte" with the new "bytevalue" @param byte position of the byte @param bytevalue new value - @return: void // Previous byte value */ + @return: void /* Previous byte value */ */ void PutByte(unsigned long byte,Bitstring bytevalue); @@ -203,7 +203,7 @@ public: @param begin the begining of the substring @param count the length of the substring @return substring from bitstring */ - // Bitstring SubBitstring (unsigned long begin, unsigned long count) const; + /* Bitstring SubBitstring (unsigned long begin, unsigned long count) const; */ void SubBitstring(unsigned long begin, Bitstring &sub) const; /** Overloads the array operator. Returns/change block "n" @@ -292,6 +292,6 @@ public: friend istream& operator >> (istream& ins, Bitstring &instr); }; -//@Include: Hex.h +/* @Include: Hex.h */ #endif diff --git a/ir/tv/IeeeCC754/include/DriverFloatRepr.h b/ir/tv/IeeeCC754/include/DriverFloatRepr.h index 9aedef5cf..9c4762268 100644 --- a/ir/tv/IeeeCC754/include/DriverFloatRepr.h +++ b/ir/tv/IeeeCC754/include/DriverFloatRepr.h @@ -10,7 +10,7 @@ # with the principles of the IEEE 754-854 floating-point standards. # # You can find out more about the testing tool IeeeCC754 at # # # -# http://win-www.uia.ac.be/u/cant/ieeecc754.html # +# http:/* win-www.uia.ac.be/u/cant/ieeecc754.html # */ # # # This tool is in parts based on and greatly benefited from the # # the program FPTEST developed by Jerome Coonen. For a full # @@ -57,35 +57,35 @@ Last updated: */ -// MORE INFORMATION ON THE FUNCTIONS IN THIS HEADER FILE CAN BE FOUND -// ON THE WEBPAGE -// http://win-www.uia.ac.be/u/cant/ieeecc754.html -// ``Adapt IeeeCC754 to test your floating-point implementation'' +/* MORE INFORMATION ON THE FUNCTIONS IN THIS HEADER FILE CAN BE FOUND */ +/* ON THE WEBPAGE */ +/* http://win-www.uia.ac.be/u/cant/ieeecc754.html */ +/* ``Adapt IeeeCC754 to test your floating-point implementation'' */ -// ---- -// Includes -// ---- +/* ---- */ +/* Includes */ +/* ---- */ #include #include -// ---- -// Includes and Defines specificly for testing MpIeee -// ---- +/* ---- */ +/* Includes and Defines specificly for testing MpIeee */ +/* ---- */ #ifdef MPIEEE_TEST #include #endif -// ---- -// Includes and Defines specificly for testing FMLib -// ---- +/* ---- */ +/* Includes and Defines specificly for testing FMLib */ +/* ---- */ #ifdef FMLIB_TEST #include #endif -// ---- -// CLASS DEFINITION : DriverFloatRepr -// ---- +/* ---- */ +/* CLASS DEFINITION : DriverFloatRepr */ +/* ---- */ class DriverFloatRepr: public FP @@ -93,22 +93,22 @@ class DriverFloatRepr: public FP protected: void SetLibRound( ); -// call the appropriate functions to set the rounding mode -// on the target platform - see item (a) on webpage +/* call the appropriate functions to set the rounding mode */ +/* on the target platform - see item (a) on webpage */ void SetLibEnvironment( ); -// call the appropriate functions to clear all floating-point -// exceptions on the target platform - see item (b) on webpage +/* call the appropriate functions to clear all floating-point */ +/* exceptions on the target platform - see item (b) on webpage */ void GetLibExceptions( ); -// call the appropriate functions to read out exceptions generated -// by the target platform - see item (b) on webpage +/* call the appropriate functions to read out exceptions generated */ +/* by the target platform - see item (b) on webpage */ public: #ifndef FMLIB_TEST -// For testing FMLib we use other definitions -// -- +/* For testing FMLib we use other definitions */ +/* -- */ DriverFloatRepr::DriverFloatRepr( ) :FP( ) {} @@ -120,11 +120,11 @@ DriverFloatRepr::DriverFloatRepr( Bitstring &fp,int m,int e,int h ) :FP( fp,m,e ; #endif -// If your target implementation is implemented in hardware, -// provide an implementation of the functions listed below for -// conversion between your hardware data types and DriverFloatRepr -// see item (c) on webpage and -// ftp://win-ftp.uia.ac.be/pub/cant/IeeeCC754/converting.pdf +/* If your target implementation is implemented in hardware, */ +/* provide an implementation of the functions listed below for */ +/* conversion between your hardware data types and DriverFloatRepr */ +/* see item (c) on webpage and */ +/* ftp://win-ftp.uia.ac.be/pub/cant/IeeeCC754/converting.pdf */ DriverFloatRepr( float f ); DriverFloatRepr( double d ); @@ -134,26 +134,26 @@ double todouble( ); long double tolongdouble( ); -// If your target implementation is implemented in software, -// provide an implementation of the functions listed below for -// conversion between your floating-point datatype and +/* If your target implementation is implemented in software, */ +/* provide an implementation of the functions listed below for */ +/* conversion between your floating-point datatype and */ // DriverFloatRepr (don't forget to replace MyDatatype by the -// appropriate identifier in this declaration) - see item (c) on -// webpage and -// ftp://win-ftp.uia.ac.be/pub/cant/IeeeCC754/converting.pdf +/* appropriate identifier in this declaration) - see item (c) on */ +/* webpage and */ +/* ftp://win-ftp.uia.ac.be/pub/cant/IeeeCC754/converting.pdf */ DriverFloatRepr (void *val); void* to(void *val); -// -// Here is an example to test the multiprecision floating-point -// implementation MpIeee: +/* */ +/* Here is an example to test the multiprecision floating-point */ +/* implementation MpIeee: */ #ifdef MPIEEE_TEST -// Functions that Convert MpIeee to DriverFloatRepr and vice-versa -//-- +/* Functions that Convert MpIeee to DriverFloatRepr and vice-versa */ +/* -- */ DriverFloatRepr ( const MpIeee &M ); MpIeee to( ); @@ -161,8 +161,8 @@ MpIeee to( ); #endif #ifdef FMLIB_TEST -// Functions specifically for Testing FMLib -// -- +/* Functions specifically for Testing FMLib */ +/* -- */ DriverFloatRepr::DriverFloatRepr( ); DriverFloatRepr::DriverFloatRepr( int m,int e,int h ); @@ -178,10 +178,10 @@ void SetOperations( ); #endif -// provide implementaton of the functions listed below in the file -// BasicOperations/$PLATFORM/BasicOperationstest.cc -// see item (d) on webpage -// -- +/* provide implementaton of the functions listed below in the file */ +/* BasicOperations/$PLATFORM/BasicOperationstest.cc */ +/* see item (d) on webpage */ +/* -- */ DriverFloatRepr operator + ( DriverFloatRepr &T ); DriverFloatRepr operator - ( DriverFloatRepr &T ); @@ -190,10 +190,10 @@ DriverFloatRepr operator / ( DriverFloatRepr &T ); DriverFloatRepr operator % ( DriverFloatRepr &T ); DriverFloatRepr sqrt( ); -// provide implementation of the functions listed below in the file -// Conversions/$PLATFORM/Conversionstest.cc -// see item (d) on webpage -// -- +/* provide implementation of the functions listed below in the file */ +/* Conversions/$PLATFORM/Conversionstest.cc */ +/* see item (d) on webpage */ +/* -- */ DriverFloatRepr roundto ( int, int, int ); DriverFloatRepr copyto ( int, int, int ); @@ -209,13 +209,13 @@ DriverFloatRepr cU ( int, int, int ); DriverFloatRepr b2d ( int ); DriverFloatRepr d2b ( ); -// conversions between DriverFloatRepr and hardware integer -// data types; implementation is provided in the files -// BasicOperations/$PLATFORM/fpenv_$PLATFORM.cc -// and -// Conversions/$PLATFORM/fpenv_$PLATFORM.cc -// and should not be modified -// -- +/* conversions between DriverFloatRepr and hardware integer */ +/* data types; implementation is provided in the files */ +/* BasicOperations/$PLATFORM/fpenv_$PLATFORM.cc */ +/* and */ +/* Conversions/$PLATFORM/fpenv_$PLATFORM.cc */ +/* and should not be modified */ +/* -- */ DriverFloatRepr( long i ); DriverFloatRepr( unsigned long i ); diff --git a/ir/tv/IeeeCC754/include/Fp.h b/ir/tv/IeeeCC754/include/Fp.h index dfd4b2f01..4b0c64f0c 100644 --- a/ir/tv/IeeeCC754/include/Fp.h +++ b/ir/tv/IeeeCC754/include/Fp.h @@ -10,7 +10,7 @@ # with the principles of the IEEE 754-854 floating-point standards. # # You can find out more about the testing tool IeeeCC754 at # # # -# http://win-www.uia.ac.be/u/cant/ieeecc754.html # +# http:/* win-www.uia.ac.be/u/cant/ieeecc754.html # */ # # # This tool is in parts based on and greatly benefited from the # # the program FPTEST developed by Jerome Coonen. For a full # @@ -85,7 +85,7 @@ Last updated: #endif #define maxstr 5000 -// maximum chars for binary to decimal conversion +/* maximum chars for binary to decimal conversion */ /**This is an abstract class defining floating-points as described in the IEEE 754 standard. It uses the Bitstring class to represent the mantissa and exponent separately. The hidden bit is always present in the mantissa and needs to be defined for input and output in a hexadecimal form.\\ @@ -104,7 +104,7 @@ class FP { protected: - ///Little or Big Endian + /* * Little or Big Endian */ */ static int Endian; /**The representation of a floating-point environment. \\ @@ -124,15 +124,15 @@ protected: \end{itemize} */ static Bitstring fpEnv; - ///The sign of the floating-point number + /* /The sign of the floating-point number */ int sign; - ///Hidden bit (yes/no) + /* /Hidden bit (yes/no) */ int hidden; - ///The size of the mantissa + /* * The size of the mantissa */ */ int sizeMant; - ///The mantissa + /* * The mantissa */ */ Bitstring mant; - ///The exponent + /* * The exponent */ */ Bitstring exp; @@ -159,27 +159,27 @@ protected: */ int GetFPRound(); - ///Sets the divide by zero exception in fpEnv + /* * Sets the divide by zero exception in fpEnv */ */ void SetFPDivByZero(){fpEnv.Set(0);} - ///Sets the invalid exception in fpEnv + /* * Sets the invalid exception in fpEnv */ */ void SetFPInvalid() {fpEnv.Set(1);} - ///Sets the underflow exception in fpEnv + /* * Sets the underflow exception in fpEnv */ */ void SetFPUnderflow(){fpEnv.Set(2);} - ///Sets the overflow exception in fpEnv + /* * Sets the overflow exception in fpEnv */ */ void SetFPOverflow() {fpEnv.Set(3);} - ///Sets the inexact exception in fpEnv + /* * Sets the inexact exception in fpEnv */ */ void SetFPInexact() {fpEnv.Set(4);} public: - ///The size of the exponent + /* * The size of the exponent */ */ int sizeExp; - ///decimal - char *decimal; // binary to decimal conversion + /* * decimal */ */ + char *decimal; /* binary to decimal conversion */ - ///Constructor + /* * Constructor */ */ FP(); /**Constructor setting the size of the exponent, the mantissa and the hidden bit @@ -200,10 +200,10 @@ public: @param copy an other FP object*/ FP(FP & copy); - //Destructor + /* Destructor */ virtual~FP(){}; - ///returns true (1) if there is a hidden bit + /* * returns true (1) if there is a hidden bit */ */ int Hidden(){return hidden;}; /**returns or sets the sign @param sgn the new sign \\ \begin{tabular}{rcl} 1 &:& negative \\ @@ -273,7 +273,7 @@ public: \end{tabular} */ void SetFPRound (int rm); - ///Clears the environment (fpEnv) + /* * Clears the environment (fpEnv) */ */ void ClearFPEnvironment(); /**Returns the exceptions stored in fpEnv as a Bitstring @return a Bitstring with next bit positions set, depending the exception \\\begin{tabular}{rcl} @@ -295,7 +295,7 @@ public: @return\begin{tabular}{rcl} 1 &:& invalid exception \\ 0 &:& no invalid exception \end{tabular}*/ - int GetFPInvalid() {//cout << "fpEnv.GetBit(1)" << fpEnv.GetBit(1); + int GetFPInvalid() {/* cout << "fpEnv.GetBit(1)" << fpEnv.GetBit(1); */ return fpEnv.GetBit(1);} /**chekcs if there has occured a underflow exception @return\begin{tabular}{rcl} 1 &:& underflow exception \\ @@ -316,13 +316,13 @@ public: int isInf(); int isNan(); - ///Overloaded output operator + /* * Overloaded output operator */ */ friend ostream& operator << (ostream& outs, FP &outstr); friend istream& operator >> (istream& ins, FP &instr); }; -//@Include: MyFloat.h MyDouble.h MyQuad.h FpSim.h Bitstring.h UCB.h dlist.h stack.h ../Calculator/FPcalculator.h +/* @Include: MyFloat.h MyDouble.h MyQuad.h FpSim.h Bitstring.h UCB.h dlist.h stack.h ../Calculator/FPcalculator.h */ #endif diff --git a/ir/tv/IeeeCC754/include/Hex.h b/ir/tv/IeeeCC754/include/Hex.h index 92c3325d0..9b763f425 100644 --- a/ir/tv/IeeeCC754/include/Hex.h +++ b/ir/tv/IeeeCC754/include/Hex.h @@ -10,7 +10,7 @@ # with the principles of the IEEE 754-854 floating-point standards. # # You can find out more about the testing tool IeeeCC754 at # # # -# http://win-www.uia.ac.be/u/cant/ieeecc754.html # +# http:/* win-www.uia.ac.be/u/cant/ieeecc754.html # */ # # # This tool is in parts based on and greatly benefited from the # # the program FPTEST developed by Jerome Coonen. For a full # @@ -99,7 +99,7 @@ protected: public: - /// Constructor, creates empty Bitstring + /* * Constructor, creates empty Bitstring */ */ Hex(); /** Constructor @@ -115,7 +115,7 @@ public: @param copy a Bitstring object */ Hex(const Bitstring ©); - ///Deconstructor + /* * Deconstructor */ */ ~Hex(){}; diff --git a/ir/tv/IeeeCC754/include/UCB.h b/ir/tv/IeeeCC754/include/UCB.h index b06d1ef97..19403f53b 100644 --- a/ir/tv/IeeeCC754/include/UCB.h +++ b/ir/tv/IeeeCC754/include/UCB.h @@ -10,7 +10,7 @@ # with the principles of the IEEE 754-854 floating-point standards. # # You can find out more about the testing tool IeeeCC754 at # # # -# http://win-www.uia.ac.be/u/cant/ieeecc754.html # +# http:/* win-www.uia.ac.be/u/cant/ieeecc754.html # */ # # # This tool is in parts based on and greatly benefited from the # # the program FPTEST developed by Jerome Coonen. For a full # @@ -60,18 +60,18 @@ Last updated: #ifndef _UCB_H #define _UCB_H -// ---- -// Includes -// ---- +/* ---- */ +/* Includes */ +/* ---- */ #include #include #include #include #include -// ---- -// Defines -// ---- +/* ---- */ +/* Defines */ +/* ---- */ #define BUF_LEN 1024 #define FP_STR 256 @@ -133,7 +133,7 @@ template UCB::UCB( ) { line = 0; - // result.SetEnvironment(); change BV + /* result.SetEnvironment(); change BV */ signalu = 0; signalv = 0; signalw = 0; @@ -171,7 +171,7 @@ void UCB::Close( int tiny ) logfile << "Summary: " << endl; logfile << "-------- " << endl; - if ( tiny ) { // conclusion underflow + if ( tiny ) { /* conclusion underflow */ if ( ucb.nou ) { if ( ucb.nov ) { if ( !( ucb.now ) ) @@ -181,7 +181,7 @@ void UCB::Close( int tiny ) logfile << "Warning: only 'v' underflow cases in the testset" << endl; else logfile << "Warning: only 'v' and 'w' underflow cases in the testset" << endl; - } // if + } /* if */ else { if ( ucb.nov ) { if ( ucb.now ) { @@ -202,10 +202,10 @@ void UCB::Close( int tiny ) logfile << "Implementation signals underflow in case the result" << endl << "(1) is tiny after rounding and" << endl << "(2) raises the inexact exception"<< endl << "('v' - underflow)" << endl; else logfile << "Implementation signals underflow in case the result" << endl << "(1) is tiny after rounding and" << endl << "(2) suffers denormalization loss" << endl << "('u' - underflow)" << endl; - } // else - } // else - } // else - } // if tiny + } /* else */ + } /* else */ + } /* else */ + } /* if tiny */ logfile << "Errors: " << errors << "/" << allops << endl; logfile << "Warnings: " << warnings << "/" << allops << endl; @@ -341,14 +341,14 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) } } else { - ieeeVector=0; // Cannot be ieeeVector! + ieeeVector=0; /* Cannot be ieeeVector! */ i--; - while ( isdigit( buf[ i ] ) ) i--; // rewind + while ( isdigit( buf[ i ] ) ) i--; /* rewind */ i++; - operation[ i ] = '\0'; // ignore digit after operation + operation[ i ] = '\0'; /* ignore digit after operation */ j = 0; while ( buf[ i ] != ' ' ) @@ -376,12 +376,12 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) tmp[ j ] ='\0'; sizeM = atoi( tmp ); - sizeM++ ; // +1 for the sign + sizeM++ ; /* +1 for the sign */ } while ( buf[ i ] == ' ' ) i++; - // read destination format + /* read destination format */ if ( ( strncmp( operation,"rt",2 ) == 0 ) || ( strncmp( operation,"ct",2 ) == 0 ) ) { if ( !isdigit( buf[ i ] ) ) { prec = buf[ i ]; @@ -412,11 +412,11 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) dsizeM=240 + 1; dhidden = 0; break; - } // switch + } /* switch */ i++; while ( buf[ i ] == ' ' ) i++; - } // if + } /* if */ else { j = 0; @@ -442,15 +442,15 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) dsizeM = atoi( tmp ); dsizeM++; - } // else + } /* else */ while ( buf[ i ] == ' ' ) i++; - } // if + } /* if */ else { dsizeE = sizeE; dhidden = hidden; dsizeM = sizeM; - } // else + } /* else */ rounding=buf[ i ]; @@ -476,8 +476,8 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) if ( ( strncmp( operation,"ci",2 ) ==0 ) || ( strncmp( operation,"cu",2 ) ==0 ) ) { - count = 32; // 32 bit integer - i += 2; // avoid 0x + count = 32; /* 32 bit integer */ + i += 2; /* avoid 0x */ for ( j=0; j= 'a' ) && ( buf[ i ] <= 'f' ) ) ) @@ -486,15 +486,15 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) tmp[ j ] = 0; break; } - } // for + } /* for */ for ( ; j= 'a' ) && ( buf[ i ] <= 'f' ) ) ) tmp[ j ] = buf[ i++ ]; @@ -523,7 +523,7 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) tmp[ j ] ='\0'; if ( strncmp( operation,"d2b",3 ) == 0 ) { - operand1 = T( sizeM-1, sizeE, hidden ); // sets Mantissa and exp right + operand1 = T( sizeM-1, sizeE, hidden ); /* sets Mantissa and exp right */ operand1.decimal = new char[ maxstr ]; for ( k = 0; k <= j; k++ ) operand1.decimal[ k ] = tmp[ k ]; @@ -546,7 +546,7 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) } i++; - count =( int ) ceil( ( double ) ( sizeM+sizeE ) /32.0 ) *8; // reset count! + count =( int ) ceil( ( double ) ( sizeM+sizeE ) /32.0 ) *8; /* reset count! */ for ( j=0; j::ReadLine( char* str,int sZero,int nflags,int *lines ) } else { if ( ( strncmp( operation,"ri",2 ) ==0 ) || ( strncmp( operation,"ru",2 ) ==0 ) ) { - count = 32; // 32 bit integer - i += 3; // avoid 0x + count = 32; /* 32 bit integer */ + i += 3; /* avoid 0x */ for ( j=0; j= 'a' ) && ( buf[ i ] <= 'f' ) ) ) tmp[ j ] = buf[ i++ ]; @@ -572,14 +572,14 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) tmp[ j ] = 0; break; } - } // for + } /* for */ for ( ; j= 'a' ) && ( buf[ i ] <= 'f' ) ) ) tmp[ j ] = buf[ i++ ]; @@ -587,7 +587,7 @@ int UCB::ReadLine( char* str,int sZero,int nflags,int *lines ) tmp[ j ] = 0; break; } - } // for + } /* for */ for ( ; j::DoLine( int tiny,int inf, int nan) int i = 0; if ( !( tiny ) && ( operand1.istiny( ) || operand2.istiny( ) || result.istiny( ) ) ) - return NULL; // do not test tiny denormalized numbers + return NULL; /* do not test tiny denormalized numbers */ else if ( !( inf ) && ( operand1.isInf( ) || operand2.isInf( ) || result.isInf( ) ) ) - return NULL; // do not test infinities + return NULL; /* do not test infinities */ else if ( !( nan ) && ( operand1.isNan( ) || operand2.isNan( ) || result.isNan( ) ) ) - return NULL; // do not test NaNs - // logstream.seekp(0,ios::beg); + return NULL; /* do not test NaNs */ + /* logstream.seekp(0,ios::beg); */ allops++; SetFPRound( ); @@ -712,7 +712,7 @@ char* UCB::DoLine( int tiny,int inf, int nan) else if( strncmp( operation,"mul",3 ) ==0 ) res = operand1 * operand2; else if( strncmp( operation,"div",3 ) ==0 ) - res = operand1 / operand2; // debug + res = operand1 / operand2; /* debug */ else if( strncmp( operation,"rem",3 ) ==0 ) res = operand1 % operand2; else if( strncmp( operation,"sqrt",4 ) ==0 ) @@ -773,7 +773,7 @@ void UCB::PrintError( T &res ) { unsigned int i; if ( (!ieeeVector) || (ieee) ) - errors++; // total number of errors encountered + errors++; /* total number of errors encountered */ else warnings++; logfile<<"Operation: " << operation << endl; @@ -790,7 +790,7 @@ void UCB::PrintError( T &res ) case 'm': logfile<<"Round down" << endl; break; - } // switch + } /* switch */ logfile<<"Operand 1: " << operand1 << endl; logfile<<"Operand 2: " << operand2 << endl; logfile<< "Flags expected: "; @@ -817,7 +817,7 @@ void UCB::PrintError( T &res ) case 'd': logfile<<"z "; break; - } // switch + } /* switch */ logfile << endl; logfile <<"Flags returned: "; if ( res.GetFPDivByZero( ) ) @@ -881,7 +881,7 @@ void UCB::Compare ( T &reslt ) if ( notsignalv ) { logfile<<((ieeeVector) && !(ieee) ? "Warning " : "Error ") <<"Line "<::Compare ( T &reslt ) if ( notsignalw ) { logfile <<((ieeeVector) && !(ieee) ? "Warning " : "Error ")<<"Line "<::Compare ( T &reslt ) if ( ( noFlags & NO_FLAGS_UNDERFLOW ) == 0 ) { if( !reslt.GetFPUnderflow( ) ) { notsignalv = 1; - //PrintError(reslt); + /* PrintError(reslt); */ if ( signalv ) { check = 0; - } // end if - } // end if - } // end if + } /* end if */ + } /* end if */ + } /* end if */ break; case 'b': @@ -951,9 +951,9 @@ void UCB::Compare ( T &reslt ) if ( signalw ) { logfile<<((ieeeVector) && !(ieee) ? "Warning " : "Error ") <<"Line "<::Compare ( T &reslt ) if (strcmp(resultdummy, reslt.decimal) != 0) { - logfile <<((ieeeVector) && !(ieee) ? "Warning " : "Error ") << "Line "<::Compare ( T &reslt ) check =0; } else if ( signedZero ) { - // In this case result is a zero and there is signedzero + /* In this case result is a zero and there is signedzero */ logfile<<((ieeeVector) && !(ieee) ? "Warning " : "Error ") <<"Line "<value == NULL means dereferencing a null pointer */ return ((get_mode_sort(tv->mode) == irms_reference) && (tv->value != NULL) && (tv->length == 0) - && (tv != tarval_P_void)); + && (tv != tarval_P_void)); } entity *tarval_to_entity(tarval *tv) @@ -734,7 +734,7 @@ int tarval_is_negative(tarval *a) case irms_int_number: if (!mode_is_signed(a->mode)) return 0; else - return sc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0; + return sc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0; case irms_float_number: return fc_comp(a->value, get_mode_null(a->mode)->value) == -1 ? 1 : 0; @@ -839,7 +839,7 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) /* cast float to something */ case irms_float_number: switch (get_mode_sort(m)) { - case irms_float_number: + case irms_float_number: switch (get_mode_size_bits(m)) { case 32: @@ -855,7 +855,7 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) break; } return get_tarval(fc_get_buffer(), fc_get_buffer_length(), m); - break; + break; case irms_int_number: switch (GET_FLOAT_TO_INT_MODE()) @@ -874,7 +874,7 @@ tarval *tarval_convert_to(tarval *src, ir_mode *m) * an intermediate representation is needed here first. */ /* return get_tarval(); */ return tarval_bad; - break; + break; default: /* the rest can't be converted */ @@ -1440,17 +1440,17 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) case TVO_DECIMAL: str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_DEC); - break; + break; case TVO_OCTAL: str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_OCT); - break; + break; case TVO_HEX: case TVO_NATIVE: default: str = sc_print(tv->value, get_mode_size_bits(tv->mode), SC_HEX); - break; + break; } return snprintf(buf, len, "%s%s%s", prefix, str, suffix); @@ -1476,24 +1476,24 @@ int tarval_snprintf(char *buf, size_t len, tarval *tv) if (get_entity_peculiarity((entity *)tv->value) != peculiarity_description) return snprintf(buf, len, "%s%s%s", prefix, get_entity_ld_name((entity *)tv->value), suffix); else { - if (mode_info->mode_output == TVO_NATIVE) + if (mode_info->mode_output == TVO_NATIVE) return snprintf(buf, len, "NULL"); - else + else return snprintf(buf, len, "0"); - } - } + } + } else { - if (size > tv->length) { - memcpy(buf, tv->value, tv->length); - buf[tv->length] = '\0'; - } - else { - /* truncated */ - memcpy(buf, tv->value, size-1); - buf[size-1] = '\0'; - } + if (size > tv->length) { + memcpy(buf, tv->value, tv->length); + buf[tv->length] = '\0'; + } + else { + /* truncated */ + memcpy(buf, tv->value, size-1); + buf[size-1] = '\0'; + } return tv->length; - } + } else return snprintf(buf, len, "void"); diff --git a/testprograms/dead_block_example.c b/testprograms/dead_block_example.c index e958837e2..bac5bb008 100644 --- a/testprograms/dead_block_example.c +++ b/testprograms/dead_block_example.c @@ -31,17 +31,17 @@ * |/_ _\| * Block1 Block2 deadBlock * \ | / -* \ | / -* _\| \ / |/_ +* \ | / +* _\| \ / |/_ * nextBlock * * * This is a program as, e.g., * * if () then -* { Jmp label1; } // happens anyways +* { Jmp label1; } /* happens anyways */ * else -* { Jmp label1; } // happens anyways +* { Jmp label1; } /* happens anyways */ * label1: * return(); * Jmp label1; diff --git a/testprograms/endless_loop.c b/testprograms/endless_loop.c index 0c9c7f8f4..4410e195d 100644 --- a/testprograms/endless_loop.c +++ b/testprograms/endless_loop.c @@ -24,9 +24,9 @@ * * VAR_A is some extern variable. * -* main(int a) { // pos 0 -* int b = 1; // pos 1 -* int h; // pos 2 +* main(int a) { /* pos 0 */ +* int b = 1; /* pos 1 */ +* int h; /* pos 2 */ * * while (0 == 0) loop { * h = a; @@ -88,8 +88,8 @@ main(void) r = new_immBlock (); add_in_edge (r, x); x = new_Cond (new_Proj(new_Cmp(new_Const (mode_Is, new_tarval_from_long (0, mode_Is)), - new_Const (mode_Is, new_tarval_from_long (0, mode_Is))), - mode_b, Eq)); + new_Const (mode_Is, new_tarval_from_long (0, mode_Is))), + mode_b, Eq)); f = new_Proj (x, mode_X, 0); t = new_Proj (x, mode_X, 1); @@ -146,7 +146,7 @@ main(void) /* output the vcg file */ printf("Done building the graph. Dumping it.\n"); - //turn_of_edge_labels(); + /* turn_of_edge_labels(); */ dump_keepalive_edges(true); dump_all_types(); dump_ir_block_graph (irg); diff --git a/testprograms/if_while_example.c b/testprograms/if_while_example.c index f2558f698..63a6f3005 100644 --- a/testprograms/if_while_example.c +++ b/testprograms/if_while_example.c @@ -23,9 +23,9 @@ * This file constructs the ir for the following pseudo-program: * * main() { -* int a = 0; // pos 0 -* int b = 1; // pos 1 -* int h; // pos 2 +* int a = 0; /* pos 0 */ +* int b = 1; /* pos 1 */ +* int h; /* pos 2 */ * * if (0 == 0) * { a = 2; } diff --git a/testprograms/three_cfpred_example.c b/testprograms/three_cfpred_example.c index eb8a1b572..9c6ae8280 100644 --- a/testprograms/three_cfpred_example.c +++ b/testprograms/three_cfpred_example.c @@ -29,7 +29,7 @@ * Block1 scnCondBlock * | | | * | | | - * | \ / \ / + * | \ / \ / * | Block2 Block3 * \ | / * \ | / @@ -40,9 +40,9 @@ * This is a program as, e.g., * * if () then - * { Jmp label1; } // happens anyways + * { Jmp label1; } /* happens anyways */ * else - * { Jmp label1; } // happens anyways + * { Jmp label1; } /* happens anyways */ * label1: * return(); * Jmp label1; @@ -79,7 +79,7 @@ int main(int argc, char **argv) owner = get_glob_type(); proc_main = new_type_method(id_from_str(METHODNAME, strlen(METHODNAME)), - NRARGS, NRES); + NRARGS, NRES); set_method_param_type(proc_main, 0, prim_t_int); set_method_res_type(proc_main, 0, prim_t_int); diff --git a/testprograms/while_example.c b/testprograms/while_example.c index 8986af6b8..fa8c01206 100644 --- a/testprograms/while_example.c +++ b/testprograms/while_example.c @@ -21,9 +21,9 @@ /** * This file constructs the ir for the following pseudo-program: * -* main(int a) { // pos 0 -* int b = 1; // pos 1 -* int h; // pos 2 +* main(int a) { /* pos 0 */ +* int b = 1; /* pos 1 */ +* int h; /* pos 2 */ * * while (0 == 2) loop { * h = a; @@ -83,7 +83,7 @@ main(void) r = new_immBlock (); add_in_edge (r, x); x = new_Cond (new_Proj(new_Cmp(new_Const (mode_Is, new_tarval_from_long (0, mode_Is)), - get_value(1, mode_Is)), + get_value(1, mode_Is)), mode_b, Eq)); f = new_Proj (x, mode_X, 0); t = new_Proj (x, mode_X, 1);