From bea700ecc61bc5228929abaf9e94de34092a04de Mon Sep 17 00:00:00 2001 From: =?utf8?q?Christian=20W=C3=BCrdig?= Date: Tue, 28 Feb 2006 15:58:16 +0000 Subject: [PATCH 1/1] removed unnecessary phases and functions which are now handled directly by the generic part of the backend --- ir/be/belower.c | 123 ----------------- ir/be/belower.h | 1 - ir/be/firm/bearch_firm.c | 7 +- ir/be/ia32/bearch_ia32.c | 187 +------------------------- ir/be/ia32/bearch_ia32_t.h | 1 - ir/be/ia32/ia32_map_regs.c | 37 ------ ir/be/ia32/ia32_map_regs.h | 4 - ir/be/ia32/ia32_transform.c | 255 +----------------------------------- 8 files changed, 7 insertions(+), 608 deletions(-) diff --git a/ir/be/belower.c b/ir/be/belower.c index 9e395671c..02e9d02cb 100644 --- a/ir/be/belower.c +++ b/ir/be/belower.c @@ -463,98 +463,6 @@ static void lower_perm_node(ir_node *irn, void *walk_env) { -/** - * Adds Projs to keep nodes for each register class, which eats the - * caller saved registers. - * Note: The caller has to make sure, that call is a Call - * - * @param call The Call node - * @param walk_env The walker environment - */ -static void lower_call_node(ir_node *call, const void *walk_env) { - const arch_env_t *arch_env = walk_env; - int bitset_idx = 0; - int set_size = 0; - arch_isa_t *isa = arch_env_get_isa(arch_env); - const ir_node *proj_T = NULL; - ir_node *block = get_nodes_block(call); - const arch_register_class_t *reg_class; - int i, j, pn, keep_arity; - ir_node **in_keep; - bitset_t *proj_set; - const ir_edge_t *edge; - const arch_register_t *reg; - - /* Prepare the bitset where we store the projnums which are already in use*/ - for (i = 0; i < arch_isa_get_n_reg_class(isa); i++) { - reg_class = arch_isa_get_reg_class(isa, i); - set_size += arch_register_class_n_regs(reg_class); - } - - in_keep = xmalloc(set_size * sizeof(ir_node *)); - - proj_set = bitset_malloc(set_size); - bitset_clear_all(proj_set); - - /* check if there is a ProjT node and which arguments are used */ - foreach_out_edge(call, edge) { - if (get_irn_mode(get_edge_src_irn(edge)) == mode_T) - proj_T = get_edge_src_irn(edge); - } - - /* set all used arguments */ - if (proj_T) { - foreach_out_edge(proj_T, edge) { - ir_node *proj = get_edge_src_irn(edge); - - assert(is_Proj(proj)); - pn = isa->impl->handle_call_proj(isa, proj, 0); - bitset_set(proj_set, pn); - } - } - else { - proj_T = new_r_Proj(current_ir_graph, block, call, mode_T, pn_Call_T_result); - } - - /* Create for each caller save register a proj (keep node argument) */ - /* if this proj is not already present */ - for (i = 0; i < arch_isa_get_n_reg_class(isa); i++) { - - /* reset the keep input, as we need one keep for each register class */ - memset(in_keep, 0, set_size * sizeof(ir_node *)); - keep_arity = 0; - reg_class = arch_isa_get_reg_class(isa, i); - - for (j = 0; j < arch_register_class_n_regs(reg_class); j++) { - reg = arch_register_for_index(reg_class, j); - - /* only check caller save registers */ - if (arch_register_type_is(reg, caller_save)) { - - /* Only create new proj, iff not already present */ - if (!bitset_is_set(proj_set, bitset_idx)) { - ir_node *proj = new_r_Proj(current_ir_graph, block, (ir_node *)proj_T, mode_Is, bitset_idx); - - pn = isa->impl->handle_call_proj(isa, proj, 1); - in_keep[keep_arity++] = proj; - } - - bitset_idx++; - } - } - - /* ok, we found some caller save register which are not in use but must be saved */ - if (keep_arity) { - be_new_Keep(reg_class, current_ir_graph, block, keep_arity, in_keep); - } - } - - bitset_free(proj_set); - return; -} - - - /** * Calls the backend code generator functions to lower Spill and * Reload nodes into Store and Load. The backend is fully responsible @@ -597,24 +505,6 @@ static void lower_spill_reload(ir_node *irn, void *walk_env) { } -/** - * Calls the corresponding lowering function for the node. - * - * @param irn The node to be checked for lowering - * @param walk_env The walker environment - */ -static void lower_nodes_before_sched_walker(ir_node *irn, void *walk_env) { - const arch_env_t *arch_env = walk_env; - - if (!is_Block(irn) && !is_Proj(irn)) { - if (is_Call(arch_env, irn)) { - lower_call_node(irn, walk_env); - } - } - - return; -} - /** * Calls the corresponding lowering function for the node. @@ -640,19 +530,6 @@ static void lower_nodes_after_ra_walker(ir_node *irn, void *walk_env) { -/** - * Walks over all blocks in an irg and performs lowering need - * to be done before scheduling (e.g. call lowering). - * - * @param chord_env The chordal environment containing the irg - * @param do_copy 1 == resolve cycles with a free reg if available - */ -void lower_nodes_before_sched(ir_graph *irg, const void *env) { - irg_walk_blkwise_graph(irg, NULL, lower_nodes_before_sched_walker, (void *)env); -} - - - /** * Walks over all blocks in an irg and performs lowering need to be * done after register allocation (e.g. perm and spill/reload lowering). diff --git a/ir/be/belower.h b/ir/be/belower.h index 2b380f6fb..06745fdc8 100644 --- a/ir/be/belower.h +++ b/ir/be/belower.h @@ -10,7 +10,6 @@ #include "bechordal.h" -void lower_nodes_before_sched(ir_graph *irg, const void *env); void lower_nodes_after_ra(be_chordal_env_t *chord_env, int do_copy); #endif /* _BELOWER_H_ */ diff --git a/ir/be/firm/bearch_firm.c b/ir/be/firm/bearch_firm.c index e0bc60e25..e1e934e26 100644 --- a/ir/be/firm/bearch_firm.c +++ b/ir/be/firm/bearch_firm.c @@ -562,10 +562,6 @@ static const list_sched_selector_t *firm_get_list_sched_selector(const void *sel return trivial_selector; } -static long firm_handle_call_proj(const void *self, ir_node *proj, int is_keep) { - return get_Proj_proj(proj); -} - #ifdef WITH_LIBCORE static void firm_register_options(lc_opt_entry_t *ent) { @@ -584,6 +580,5 @@ const arch_isa_if_t firm_isa = { firm_get_call_abi, firm_get_irn_handler, firm_get_code_generator_if, - firm_get_list_sched_selector, - firm_handle_call_proj + firm_get_list_sched_selector }; diff --git a/ir/be/ia32/bearch_ia32.c b/ir/be/ia32/bearch_ia32.c index f13ac4480..ab2ce8e02 100644 --- a/ir/be/ia32/bearch_ia32.c +++ b/ir/be/ia32/bearch_ia32.c @@ -133,26 +133,7 @@ static const arch_register_req_t *ia32_get_irn_reg_req(const void *self, arch_re DBG((mod, LEVEL_1, "get requirements at pos %d for %+F ... ", pos, irn)); - if (is_Call_Proj(irn) && is_used_by_Keep(irn)) { - if (pos >= 0) { - req = NULL; - } - else { - irn_req = ia32_projnum_reg_req_map[get_Proj_proj(irn)]; - memcpy(req, &(irn_req->req), sizeof(*req)); - } - - return req; - } - else if (is_Start_Proj(irn)) { -/* irn_req = ops->cg->reg_param_req[get_Proj_proj(irn)]; - assert(irn_req && "missing requirement for regparam"); - memcpy(req, &(irn_req->req), sizeof(*req)); */ - memcpy(req, &(ia32_default_req_ia32_gp.req), sizeof(*req)); - return req; - //return NULL; - } - else if (is_Proj(irn)) { + if (is_Proj(irn)) { if (pos == -1) { node_pos = ia32_translate_proj_pos(irn); } @@ -202,23 +183,6 @@ static const arch_register_req_t *ia32_get_irn_reg_req(const void *self, arch_re else assert(0 && "unsupported Phi-Mode"); } - else if (is_Start(irn)) { - DB((mod, LEVEL_1, "returning reqs none for ProjX -> Start (%+F )\n", irn)); - switch (node_pos) { - case pn_Start_X_initial_exec: - case pn_Start_P_value_arg_base: - case pn_Start_P_globals: - case pn_Start_P_frame_base: - memcpy(req, &(ia32_default_req_none.req), sizeof(*req)); - break; - case pn_Start_T_args: - assert(0 && "ProjT(pn_Start_T_args) should not be asked"); - } - } - else if (get_irn_op(irn) == op_Return && pos > 0) { - DB((mod, LEVEL_1, "returning reqs EAX for %+F\n", irn)); - memcpy(req, &(ia32_default_req_ia32_gp_eax.req), sizeof(*req)); - } else { DB((mod, LEVEL_1, "returning NULL for %+F (not ia32)\n", irn)); req = NULL; @@ -345,101 +309,7 @@ static void ia32_prepare_graph(void *self) { * Stack reservation and StackParam lowering. */ static void ia32_finish_irg(ir_graph *irg, ia32_code_gen_t *cg) { -#if 0 - firm_dbg_module_t *mod = cg->mod; - ir_node *frame = get_irg_frame(irg); - ir_node *end_block = get_irg_end_block(irg); - ir_node **returns, **in, **new_in; - ir_node *stack_reserve, *sched_point; - ir_node *stack_free, *new_ret, *return_block; - int stack_size = 0, i, n_arg; - arch_register_t *stack_reg; - tarval *stack_size_tv; - dbg_info *frame_dbg; - - /* Determine stack register */ - if (cg->has_alloca) { - stack_reg = &ia32_gp_regs[REG_EBP]; - } - else { - stack_reg = &ia32_gp_regs[REG_ESP]; - } - - /* If frame is used, then we need to reserve some stackspace. */ - if (get_irn_n_edges(frame) > 0) { - /* The initial stack reservation. */ - stack_size = get_type_size_bytes(get_irg_frame_type(irg)); - frame_dbg = get_irn_dbg_info(frame); - stack_reserve = new_rd_ia32_Sub_i(frame_dbg, irg, get_nodes_block(frame), new_NoMem(), mode_Is); - stack_size_tv = new_tarval_from_long(stack_size, mode_Is); - set_ia32_Immop_tarval(stack_reserve, stack_size_tv); - - assert(stack_size && "bOrken stack layout"); - - /* reroute all edges from frame pointer to corrected frame pointer */ - edges_reroute(frame, stack_reserve, irg); - set_irn_n(stack_reserve, 0, frame); - - /* schedule frame pointer */ - if (! sched_is_scheduled(frame)) { - sched_add_after(get_irg_start(irg), frame); - } - - /* set register */ - arch_set_irn_register(cg->arch_env, frame, stack_reg); - arch_set_irn_register(cg->arch_env, stack_reserve, stack_reg); - - /* insert into schedule */ - sched_add_after(frame, stack_reserve); - - /* Free stack for each Return node */ - returns = get_Block_cfgpred_arr(end_block); - for (i = 0; i < get_Block_n_cfgpreds(end_block); i++) { - assert(get_irn_opcode(returns[i]) == iro_Return && "cfgpred of endblock is not a return"); - - return_block = get_nodes_block(returns[i]); - - /* free the stack */ - stack_free = new_rd_ia32_Add_i(frame_dbg, irg, return_block, stack_reserve, mode_Is); - set_ia32_Immop_tarval(stack_free, stack_size_tv); - arch_set_irn_register(cg->arch_env, stack_free, stack_reg); - - DBG((mod, LEVEL_1, "examining %+F, %+F created, block %+F", returns[i], stack_free, return_block)); - - /* get the old Return arguments */ - n_arg = get_Return_n_ress(returns[i]); - in = get_Return_res_arr(returns[i]); - new_in = alloca((n_arg + 2) * sizeof(new_in[0])); - - /* copy the old to the new in's */ - memcpy(new_in, in, n_arg * sizeof(in[0])); - new_in[n_arg++] = stack_free; - new_in[n_arg++] = get_Return_mem(returns[i]); - /* create the new return node */ - new_ret = new_rd_ia32_Return(get_irn_dbg_info(returns[i]), irg, return_block, n_arg, new_in); - - /* In case the return node is the only node in the block, */ - /* it is not scheduled, so we need this work-around. */ - if (! sched_is_scheduled(returns[i])) { - sched_point = return_block; - } - else { - sched_point = sched_prev(returns[i]); - sched_remove(returns[i]); - } - - /* exchange the old return with the new one */ - exchange(returns[i], new_ret); - - DB((mod, LEVEL_1, " ... replaced with %+F\n", new_ret)); - - /* remove the old one from schedule and add the new nodes properly */ - sched_add_after(sched_point, new_ret); - sched_add_after(sched_point, stack_free); - } - } -#endif } @@ -448,9 +318,6 @@ static void ia32_finish_irg(ir_graph *irg, ia32_code_gen_t *cg) { * Dummy functions for hooks we don't need but which must be filled. */ static void ia32_before_sched(void *self) { - ia32_code_gen_t *cg = self; - - lower_nodes_before_sched(cg->irg, cg->arch_env); } static void ia32_before_ra(void *self) { @@ -629,8 +496,7 @@ static ia32_isa_t ia32_isa_template = { &ia32_gp_regs[REG_ESP], &ia32_gp_regs[REG_EBP], -1, - 0, - NULL + 0 }; /** @@ -646,8 +512,6 @@ static void *ia32_init(void) { isa = xcalloc(1, sizeof(*isa)); memcpy(isa, &ia32_isa_template, sizeof(*isa)); - isa->reg_projnum_map = new_set(ia32_cmp_reg_projnum_assoc, 1024); - ia32_register_init(isa); ia32_create_opcodes(); @@ -785,50 +649,6 @@ const arch_irn_handler_t *ia32_get_irn_handler(const void *self) { return &ia32_irn_handler; } -long ia32_handle_call_proj(const void *self, ir_node *proj, int is_keep) { - ia32_isa_t *isa = (ia32_isa_t *)self; - long pn = get_Proj_proj(proj); - - if (!is_keep) { - /* It's not a Keep proj, which means, that it is a result proj. */ - /* Possible result proj numbers are 0 and 1 */ - /* Set the correct register (depends on the mode) and the */ - /* corresponding proj number */ - if (mode_is_float(get_irn_mode(proj))) { - assert(pn == 0 && "only one floating point result supported"); - - /* Get the proj number for the floating point result */ - pn = ia32_get_reg_projnum(&ia32_fp_regs[REG_XMM0], isa->reg_projnum_map); - } - else { - /* In case of 64bit return value, the result is */ - /* in EDX:EAX and we have two result projs. */ - switch (pn) { - case 0: - pn = ia32_get_reg_projnum(&ia32_gp_regs[REG_EAX], isa->reg_projnum_map); - break; - case 1: - pn = ia32_get_reg_projnum(&ia32_gp_regs[REG_EDX], isa->reg_projnum_map); - break; - default: - assert(0 && "only two int results supported"); - } - } - - /* Set the correct proj number */ - set_Proj_proj(proj, pn); - } - else { - /* Set mode to floating point if required */ - if (!strcmp(ia32_reg_classes[CLASS_ia32_fp].name, - ia32_projnum_reg_req_map[pn]->req.cls->name)) { - set_irn_mode(proj, mode_F); - } - } - - return pn; -} - int ia32_to_appear_in_schedule(void *block_env, const ir_node *irn) { return is_ia32_irn(irn); } @@ -869,6 +689,5 @@ const arch_isa_if_t ia32_isa_if = { ia32_get_call_abi, ia32_get_irn_handler, ia32_get_code_generator_if, - ia32_get_list_sched_selector, - ia32_handle_call_proj + ia32_get_list_sched_selector }; diff --git a/ir/be/ia32/bearch_ia32_t.h b/ir/be/ia32/bearch_ia32_t.h index cdd72518a..fec051210 100644 --- a/ir/be/ia32/bearch_ia32_t.h +++ b/ir/be/ia32/bearch_ia32_t.h @@ -29,7 +29,6 @@ typedef struct _ia32_isa_t { const arch_register_t *bp; /** The base pointer register. */ const int stack_dir; /** -1 for decreasing, 1 for increasing. */ int num_codegens; - set *reg_projnum_map; } ia32_isa_t; typedef struct _ia32_irn_ops_t { diff --git a/ir/be/ia32/ia32_map_regs.c b/ir/be/ia32/ia32_map_regs.c index ab776aea6..1ccbcad6d 100644 --- a/ir/be/ia32/ia32_map_regs.c +++ b/ir/be/ia32/ia32_map_regs.c @@ -97,43 +97,6 @@ const arch_register_t *ia32_get_firm_reg(const ir_node *irn, set *reg_set) { -/* Mapping to store proj numbers for registers */ - -struct ia32_reg_projnum_assoc { - const arch_register_t *reg; - long proj_num; -}; - -int ia32_cmp_reg_projnum_assoc(const void *a, const void *b, size_t len) { - const struct ia32_reg_projnum_assoc *x = a; - const struct ia32_reg_projnum_assoc *y = b; - - return !(x->reg == y->reg); -} - -static struct ia32_reg_projnum_assoc *get_reg_projnum_assoc(const arch_register_t *reg, set *reg_set) { - struct ia32_reg_projnum_assoc templ; - unsigned int hash; - - templ.reg = reg; - templ.proj_num = -1; - hash = HASH_PTR(reg); - - return set_insert(reg_set, &templ, sizeof(templ), hash); -} - -void ia32_set_reg_projnum(const arch_register_t *reg, long proj_num, set *reg_set) { - struct ia32_reg_projnum_assoc *assoc = get_reg_projnum_assoc(reg, reg_set); - assoc->proj_num = proj_num; -} - -long ia32_get_reg_projnum(const arch_register_t *reg, set *reg_set) { - struct ia32_reg_projnum_assoc *assoc = get_reg_projnum_assoc(reg, reg_set); - return assoc->proj_num; -} - - - /** * Check all parameters and determine the maximum number of parameters * to pass in gp regs resp. in fp regs. diff --git a/ir/be/ia32/ia32_map_regs.h b/ir/be/ia32/ia32_map_regs.h index c0140aa69..1756b887c 100644 --- a/ir/be/ia32/ia32_map_regs.h +++ b/ir/be/ia32/ia32_map_regs.h @@ -11,10 +11,6 @@ int ia32_cmp_irn_reg_assoc(const void *a, const void *b, size_t len); void ia32_set_firm_reg(ir_node *irn, const arch_register_t *reg, set *reg_set); const arch_register_t *ia32_get_firm_reg(const ir_node *irn, set *reg_set); -int ia32_cmp_reg_projnum_assoc(const void *a, const void *b, size_t len); -void ia32_set_reg_projnum(const arch_register_t *reg, long proj_num, set *reg_set); -long ia32_get_reg_projnum(const arch_register_t *reg, set *reg_set); - int ia32_get_n_regparam_class(int n, ir_mode **modes, int *n_int, int *n_float); const arch_register_t *ia32_get_RegParam_reg(int n, ir_mode **modes, long nr, unsigned cc); diff --git a/ir/be/ia32/ia32_transform.c b/ir/be/ia32/ia32_transform.c index 569b6de6d..f7ed24cf9 100644 --- a/ir/be/ia32/ia32_transform.c +++ b/ir/be/ia32/ia32_transform.c @@ -20,7 +20,6 @@ #include "../arch/archop.h" /* we need this for Min and Max nodes */ #include "ia32_transform.h" #include "ia32_new_nodes.h" -#include "ia32_map_regs.h" #include "gen_ia32_regalloc_if.h" @@ -1145,128 +1144,10 @@ ir_node *gen_Store(ia32_transform_env_t *env) { /** * Transforms a Call and its arguments corresponding to the calling convention. * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Call node - * @param dummy mode doesn't matter - * @return the created ia32 Call node + * @param env The transformation environment + * @return The created ia32 Call node */ static ir_node *gen_Call(ia32_transform_env_t *env) { -#if 0 - const ia32_register_req_t **in_req; - ir_node **in; - ir_node *new_call, *sync; - int i, j, n_new_call_in, ignore = 0; - ia32_attr_t *attr; - dbg_info *dbg = env->dbg; - ir_graph *irg = env->irg; - ir_node *block = env->block; - ir_node *call = env->irn; - ir_node **stack_param = NULL; - ir_node **param = get_Call_param_arr(call); - ir_node *call_Mem = get_Call_mem(call); - unsigned cc = get_method_calling_convention(get_Call_type(call)); - int n = get_Call_n_params(call); - int stack_idx = 0; - int biggest_n = -1; - int n_res = get_method_n_ress(get_Call_type(call)); - - assert(n_res <= 2 && "method with more than two results not supported"); - - if (cc & cc_reg_param) - biggest_n = ia32_get_n_regparam_class(n, param, &ignore, &ignore); - - /* remember: biggest_n = x means we can pass (x + 1) parameters in register */ - - /* do we need to pass arguments on stack? */ - if (biggest_n + 1 < n) - stack_param = xcalloc(n - biggest_n - 1, sizeof(ir_node *)); - - /* we need at least one in, either for the stack params or the call_Mem */ - n_new_call_in = biggest_n + 2; - - /* the call has one IN for all stack parameter and one IN for each reg param */ - in = xcalloc(n_new_call_in, sizeof(ir_node *)); - in_req = xcalloc(n_new_call_in, sizeof(arch_register_req_t *)); - - /* loop over all parameters and set the register requirements */ - for (i = 0; i <= biggest_n && (cc & cc_reg_param); i++) { - in_req[i] = ia32_get_RegParam_req(n, param, i, cc); - } - stack_idx = i; - - /* create remaining stack parameters */ - if (cc & cc_last_on_top) { - for (i = stack_idx; i < n; i++) { - /* pass it on stack */ - if (mode_is_float(get_irn_mode(param[i]))) { - stack_param[i - stack_idx] = new_rd_ia32_fStackArg(get_irn_dbg_info(param[i]), irg, - block, call_Mem, param[i], mode_M); - } - else { - stack_param[i - stack_idx] = new_rd_ia32_StackArg(get_irn_dbg_info(param[i]), irg, - block, call_Mem, param[i], mode_M); - } - /* set the argument number for later lowering */ - set_ia32_pncode(stack_param[i - stack_idx], i - stack_idx); - } - } - else { - for (i = n - 1, j = 0; i >= stack_idx; i--, j++) { - /* pass it on stack */ - if (mode_is_float(get_irn_mode(param[i]))) { - stack_param[j] = new_rd_ia32_fStackArg(get_irn_dbg_info(param[i]), irg, - block, call_Mem, param[i], mode_M); - } - else { - stack_param[j] = new_rd_ia32_StackArg(get_irn_dbg_info(param[i]), irg, - block, call_Mem, param[i], mode_M); - } - /* set the argument number for later lowering */ - set_ia32_pncode(stack_param[j], j); - } - } - - if (stack_param) { - sync = new_r_Sync(irg, block, n - biggest_n - 1, stack_param); - in[n_new_call_in - 1] = sync; - } - else { - in[n_new_call_in - 1] = call_Mem; - } - - /* create the new node */ - new_call = new_rd_ia32_Call(dbg, irg, block, n_new_call_in, in); - set_ia32_Immop_attr(new_call, get_Call_ptr(call)); - - /* set register requirements for in and out */ - attr = get_ia32_attr(new_call); - attr->in_req = in_req; - - set_ia32_n_res(new_call, n_res); - - if (n_res > 0) { - attr->out_req = xcalloc(n_res, sizeof(ia32_register_req_t *)); - attr->slots = xcalloc(n_res, sizeof(arch_register_t *)); - } - - /* two results only appear when a 64bit int result is broken up into two 32bit results */ - if (n_res == 1) { - if (mode_is_float(get_type_mode(get_method_res_type(get_Call_type(call), 0)))) - attr->out_req[0] = &ia32_default_req_ia32_fp_xmm0; - else - attr->out_req[0] = &ia32_default_req_ia32_gp_eax; - } - else if (n_res == 2) { - attr->out_req[0] = &ia32_default_req_ia32_gp_eax; - attr->out_req[1] = &ia32_default_req_ia32_gp_edx; - } - - /* stack parameter has no OUT register */ - attr->in_req[n_new_call_in - 1] = &ia32_default_req_none; - - return new_call; -#endif } @@ -1321,136 +1202,6 @@ static ir_node *gen_Cond(ia32_transform_env_t *env) { -/** - * Transform the argument projs from a start node corresponding to the - * calling convention. - * It transforms "Proj Arg x -> ProjT -> Start <- ProjM" into - * "RegParam x -> ProjT -> Start" OR - * "StackParam x -> ProjM -> Start" - * whether parameter is passed in register or on stack. - * - * @param mod the debug module - * @param block the block the nodes should belong to - * @param proj the ProjT node which points to Start - * @param start the Start node - * @return Should be always NULL - */ -static ir_node *gen_Proj_Start(ia32_transform_env_t *env, ir_node *proj, ir_node *start) { -#if 0 - const ia32_register_req_t *temp_req; - const ir_edge_t *edge; - ir_node *succ, *irn; - ir_node **projargs; - ir_mode *mode; - int n, i; - unsigned cc; - ir_node *proj_M = get_irg_initial_mem(current_ir_graph); - entity *irg_ent = get_irg_entity(current_ir_graph); - ir_type *tp = get_entity_type(irg_ent); - int cur_pn = 0; - ir_graph *irg = env->irg; - ir_node *block = env->block; - - assert(is_Method_type(tp) && "irg type is not a method"); - - switch(get_Proj_proj(proj)) { - case pn_Start_T_args: - /* We cannot use get_method_n_params here as the function might - be variadic or one argument is not used. */ - n = get_irn_n_edges(proj); - - /* Allocate memory for all non variadic parameters in advance to be on the save side */ - env->cg->reg_param_req = xcalloc(get_method_n_params(tp), sizeof(ia32_register_req_t *)); - - /* we are done here when there are no parameters */ - if (n < 1) - break; - - /* temporary remember all proj arg x */ - projargs = xcalloc(n, sizeof(ir_node *)); - - i = 0; - foreach_out_edge((const ir_node *)proj, edge) { - succ = get_edge_src_irn(edge); - assert(is_Proj(succ) && "non-Proj from a Proj_T (pn_Start_T_args)."); - projargs[i++] = succ; - } - - cc = get_method_calling_convention(tp); - - /* loop over all parameters and check whether its a int or float */ - for (i = 0; i < n; i++) { - mode = get_irn_mode(projargs[i]); - cur_pn = get_Proj_proj(projargs[i]); - - if (cc & cc_reg_param) { - temp_req = ia32_get_RegParam_req(n, projargs, cur_pn, cc); - } - else { - temp_req = NULL; - } - - if (temp_req) { - /* passed in register */ - env->cg->reg_param_req[cur_pn] = temp_req; - } - else { - /* passed on stack */ - if (mode_is_float(mode)) - irn = new_rd_ia32_fStackParam(get_irn_dbg_info(projargs[i]), irg, block, proj_M, mode); - else - irn = new_rd_ia32_StackParam(get_irn_dbg_info(projargs[i]), irg, block, proj_M, mode); - - set_ia32_pncode(irn, cur_pn); - - /* kill the old "Proj Arg" and replace with the new stack param */ - exchange(projargs[i], irn); - } - } - - free(projargs); - - break; - case pn_Start_P_frame_base: - case pn_Start_X_initial_exec: - case pn_Start_M: - case pn_Start_P_globals: - case pn_Start_P_value_arg_base: - break; - default: - assert(0 && "unsupported Proj(Start)"); - } - - return NULL; -#endif -} - -/** - * Transform some Proj's (Proj_Proj, Proj_Start, Proj_Cmp, Proj_Cond, Proj_Call). - * All others are ignored. - * - * @param mod the debug module - * @param block the block the new node should belong to - * @param node the ir Proj node - * @param mode mode of the Proj - * @return The transformed node. - */ -static ir_node *gen_Proj(ia32_transform_env_t *env) { - ir_node *new_node = NULL; - ir_node *pred = get_Proj_pred(env->irn); - - if (env->mode == mode_M) - return NULL; - - if (get_irn_op(pred) == op_Start) { - new_node = gen_Proj_Start(env, env->irn, pred); - } - - return new_node; -} - - - /********************************************************* * _ _ _ * (_) | | (_) @@ -1523,10 +1274,10 @@ void ia32_transform_node(ir_node *node, void *env) { GEN(Store); GEN(Cond); - IGN(Proj); IGN(Call); IGN(Alloc); + IGN(Proj); IGN(Block); IGN(Start); IGN(End); -- 2.20.1