X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fbe%2Fbeabi.c;h=e10097a1e6ff709a9f9f42e8ded586e5026bb251;hb=a8e4a954b36da58bce5413b569532ef54b87abcd;hp=4ff9cbd00da29aabb72da31985a94f0b2ce3bd04;hpb=87965f5c94d561cb15233b80711123f6edc80b30;p=libfirm diff --git a/ir/be/beabi.c b/ir/be/beabi.c index 4ff9cbd00..e10097a1e 100644 --- a/ir/be/beabi.c +++ b/ir/be/beabi.c @@ -1,18 +1,35 @@ -/** - * ABI lowering. +/* + * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. * - * @author Sebastian Hack - * @date 7.3.2005 - * @cvsid $Id$ + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. + * + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. + */ + +/** + * @file + * @brief Backend ABI implementation. + * @author Sebastian Hack, Michael Beck + * @version $Id$ */ #ifdef HAVE_CONFIG_H -# include +# include "config.h" #endif #include "obst.h" #include "offset.h" -#include "type.h" #include "irgopt.h" #include "irgraph_t.h" @@ -28,15 +45,16 @@ #include "pdeq.h" #include "irtools.h" #include "raw_bitset.h" +#include "error.h" #include "be.h" #include "beabi.h" -#include "bearch.h" +#include "bearch_t.h" #include "benode_t.h" #include "belive_t.h" #include "besched_t.h" -#include "beirg.h" -#include "beirgmod.h" +#include "beirg_t.h" +#include "bessaconstr.h" typedef struct _be_abi_call_arg_t { unsigned is_res : 1; /**< 1: the call argument is a return value. 0: it's a call parameter. */ @@ -46,9 +64,9 @@ typedef struct _be_abi_call_arg_t { int pos; const arch_register_t *reg; ir_entity *stack_ent; - unsigned alignment; - unsigned space_before; - unsigned space_after; + unsigned alignment; /**< stack alignment */ + unsigned space_before; /**< allocate space before */ + unsigned space_after; /**< allocate space after */ } be_abi_call_arg_t; struct _be_abi_call_t { @@ -70,15 +88,15 @@ struct _be_abi_irg_t { ir_type *method_type; /**< The type of the method of the IRG. */ ir_node *init_sp; /**< The node representing the stack pointer - at the start of the function. */ + at the start of the function. */ ir_node *start_barrier; /**< The barrier of the start block */ ir_node *reg_params; /**< The reg params node. */ pmap *regs; /**< A map of all callee-save and ignore regs to - their Projs to the RegParams node. */ + their Projs to the RegParams node. */ - int start_block_bias; /**< The stack bias at the end of the start block. */ + int start_block_bias; /**< The stack bias at the end of the start block. */ void *cb; /**< ABI Callback self pointer. */ @@ -93,14 +111,6 @@ struct _be_abi_irg_t { DEBUG_ONLY(firm_dbg_module_t *dbg;) /**< The debugging module. */ }; -#if 0 -#define get_abi_from_handler(ptr) firm_container_of(ptr, be_abi_irg_t, irn_handler) -#define get_abi_from_ops(ptr) firm_container_of(ptr, be_abi_irg_t, irn_ops) - -/* Forward, since be need it in be_abi_introduce(). */ -static const arch_irn_ops_if_t abi_irn_ops; -static const arch_irn_handler_t abi_irn_handler; -#endif static heights_t *ir_heights; /* Flag: if set, try to omit the frame pointer if called by the backend */ @@ -389,7 +399,8 @@ static INLINE int is_on_stack(be_abi_call_t *call, int pos) static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, ir_node *alloca_copy) { ir_graph *irg = env->birg->irg; - const arch_isa_t *isa = env->birg->main_env->arch_env->isa; + const arch_env_t *arch_env = env->birg->main_env->arch_env; + const arch_isa_t *isa = arch_env->isa; ir_type *mt = get_Call_type(irn); ir_node *call_ptr = get_Call_ptr(irn); int n_params = get_method_n_params(mt); @@ -698,6 +709,7 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i assert(arg->in_reg); be_set_constr_single_reg(low_call, BE_OUT_POS(pn), arg->reg); + arch_set_irn_register(arch_env, res_projs[i], arg->reg); } obstack_free(obst, in); exchange(irn, low_call); @@ -782,6 +794,31 @@ static ir_node *adjust_call(be_abi_irg_t *env, ir_node *irn, ir_node *curr_sp, i return curr_sp; } +/** + * Adjust the size of a node representing a stack alloc or free for the minimum stack alignment. + * + * @param alignment the minimum stack alignment + * @param size the node containing the non-aligned size + * @param irg the irg where new nodes are allocated on + * @param irg the block where new nodes are allocated on + * @param dbg debug info for new nodes + * + * @return a node representing the aligned size + */ +static ir_node *adjust_alloc_size(unsigned stack_alignment, ir_node *size, ir_graph *irg, ir_node *block, dbg_info *dbg) { + if (stack_alignment > 1) { + ir_mode *mode = get_irn_mode(size); + tarval *tv = new_tarval_from_long(stack_alignment-1, mode); + ir_node *mask = new_r_Const(irg, block, mode, tv); + + size = new_rd_Add(dbg, irg, block, size, mask, mode); + + tv = new_tarval_from_long(-(long)stack_alignment, mode); + mask = new_r_Const(irg, block, mode, tv); + size = new_rd_And(dbg, irg, block, size, mask, mode); + } + return size; +} /** * Adjust an alloca. * The alloca is transformed into a back end alloca node and connected to the stack nodes. @@ -793,13 +830,11 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp ir_node *alloc_mem; ir_node *alloc_res; ir_type *type; + dbg_info *dbg; const ir_edge_t *edge; - ir_node *new_alloc; - ir_node *size; - ir_node *addr; - ir_node *copy; - ir_node *ins[2]; + ir_node *new_alloc, *size, *addr, *copy, *ins[2]; + unsigned stack_alignment; if (get_Alloc_where(alloc) != stack_alloc) { assert(0); @@ -836,11 +871,13 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp return curr_sp; } + dbg = get_irn_dbg_info(alloc); + /* we might need to multiply the size with the element size */ if(type != get_unknown_type() && get_type_size_bytes(type) != 1) { tarval *tv = new_tarval_from_long(get_type_size_bytes(type), mode_Iu); - ir_node *cnst = new_rd_Const(NULL, irg, block, mode_Iu, tv); - ir_node *mul = new_rd_Mul(NULL, irg, block, get_Alloc_size(alloc), + ir_node *cnst = new_rd_Const(dbg, irg, block, mode_Iu, tv); + ir_node *mul = new_rd_Mul(dbg, irg, block, get_Alloc_size(alloc), cnst, mode_Iu); size = mul; } else { @@ -850,7 +887,13 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp /* The stack pointer will be modified in an unknown manner. We cannot omit it. */ env->call->flags.bits.try_omit_fp = 0; + + /* FIXME: size must be here round up for the stack alignment, but + this must be transmitted from the backend. */ + stack_alignment = 4; + size = adjust_alloc_size(stack_alignment, size, irg, block, dbg); new_alloc = be_new_AddSP(env->isa->sp, irg, block, curr_sp, size); + set_irn_dbg_info(new_alloc, dbg); if(alloc_mem != NULL) { ir_node *addsp_mem; @@ -858,8 +901,8 @@ static ir_node *adjust_alloc(be_abi_irg_t *env, ir_node *alloc, ir_node *curr_sp addsp_mem = new_r_Proj(irg, block, new_alloc, mode_M, pn_be_AddSP_M); - // We need to sync the output mem of the AddSP with the input mem - // edge into the alloc node + /* We need to sync the output mem of the AddSP with the input mem + edge into the alloc node. */ ins[0] = get_Alloc_mem(alloc); ins[1] = addsp_mem; sync = new_r_Sync(irg, block, 2, ins); @@ -900,6 +943,9 @@ static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp) ir_node *subsp, *mem, *res, *size, *sync; ir_type *type; ir_node *in[2]; + ir_mode *sp_mode; + unsigned stack_alignment; + dbg_info *dbg; if (get_Free_where(free) != stack_alloc) { assert(0); @@ -909,25 +955,33 @@ static ir_node *adjust_free(be_abi_irg_t *env, ir_node *free, ir_node *curr_sp) block = get_nodes_block(free); irg = get_irn_irg(block); type = get_Free_type(free); + sp_mode = env->isa->sp->reg_class->mode; + dbg = get_irn_dbg_info(free); /* we might need to multiply the size with the element size */ if(type != get_unknown_type() && get_type_size_bytes(type) != 1) { tarval *tv = new_tarval_from_long(get_type_size_bytes(type), mode_Iu); - ir_node *cnst = new_rd_Const(NULL, irg, block, mode_Iu, tv); - ir_node *mul = new_rd_Mul(NULL, irg, block, get_Free_size(free), + ir_node *cnst = new_rd_Const(dbg, irg, block, mode_Iu, tv); + ir_node *mul = new_rd_Mul(dbg, irg, block, get_Free_size(free), cnst, mode_Iu); size = mul; } else { size = get_Free_size(free); } + /* FIXME: size must be here round up for the stack alignment, but + this must be transmitted from the backend. */ + stack_alignment = 4; + size = adjust_alloc_size(stack_alignment, size, irg, block, dbg); + /* The stack pointer will be modified in an unknown manner. We cannot omit it. */ env->call->flags.bits.try_omit_fp = 0; subsp = be_new_SubSP(env->isa->sp, irg, block, curr_sp, size); + set_irn_dbg_info(subsp, dbg); mem = new_r_Proj(irg, block, subsp, mode_M, pn_be_SubSP_M); - res = new_r_Proj(irg, block, subsp, mode_P_data, pn_be_SubSP_res); + res = new_r_Proj(irg, block, subsp, sp_mode, pn_be_SubSP_res); /* we need to sync the memory */ in[0] = get_Free_mem(free); @@ -988,7 +1042,7 @@ static int dependent_on(ir_node *n1, ir_node *n2) return heights_reachable_in_block(ir_heights, n1, n2); } -static int cmp_call_dependecy(const void *c1, const void *c2) +static int cmp_call_dependency(const void *c1, const void *c2) { ir_node *n1 = *(ir_node **) c1; ir_node *n2 = *(ir_node **) c2; @@ -1057,7 +1111,7 @@ static void process_calls_in_block(ir_node *bl, void *data) nodes = obstack_finish(&env->obst); /* order the call nodes according to data dependency */ - qsort(nodes, n, sizeof(nodes[0]), cmp_call_dependecy); + qsort(nodes, n, sizeof(nodes[0]), cmp_call_dependency); for(i = n - 1; i >= 0; --i) { ir_node *irn = nodes[i]; @@ -1074,6 +1128,7 @@ static void process_calls_in_block(ir_node *bl, void *data) curr_sp = adjust_free(env, irn, curr_sp); break; default: + panic("invalid call"); break; } } @@ -1081,9 +1136,12 @@ static void process_calls_in_block(ir_node *bl, void *data) obstack_free(&env->obst, nodes); /* Keep the last stack state in the block by tying it to Keep node */ - nodes[0] = curr_sp; - keep = be_new_Keep(env->isa->sp->reg_class, get_irn_irg(bl), bl, 1, nodes); - pmap_insert(env->keep_map, bl, keep); + if(curr_sp != env->init_sp) { + nodes[0] = curr_sp; + keep = be_new_Keep(env->isa->sp->reg_class, get_irn_irg(bl), + bl, 1, nodes); + pmap_insert(env->keep_map, bl, keep); + } } set_irn_link(bl, curr_sp); @@ -1414,11 +1472,9 @@ static ir_node *create_be_return(be_abi_irg_t *env, ir_node *irn, ir_node *bl, i */ stack = be_abi_reg_map_get(env->regs, isa->sp); if (keep) { - ir_node *bad = new_r_Bad(env->birg->irg); stack = get_irn_n(keep, 0); - set_nodes_block(keep, bad); - set_irn_n(keep, 0, bad); - // exchange(keep, new_r_Bad(env->birg->irg)); + be_kill_node(keep); + remove_End_keepalive(get_irg_end(env->birg->irg), keep); } /* Insert results for Return into the register map. */ @@ -1678,7 +1734,9 @@ static void modify_irg(be_abi_irg_t *env) ir_graph *irg = env->birg->irg; ir_node *bl = get_irg_start_block(irg); ir_node *end = get_irg_end_block(irg); - ir_node *mem = get_irg_initial_mem(irg); + ir_node *old_mem = get_irg_initial_mem(irg); + ir_node *new_mem_proj; + ir_node *mem; ir_type *method_type = get_entity_type(get_irg_entity(irg)); pset *dont_save = pset_new_ptr(8); @@ -1819,6 +1877,13 @@ static void modify_irg(be_abi_irg_t *env) } obstack_free(&env->obst, rm); + /* create a new initial memory proj */ + assert(is_Proj(old_mem)); + new_mem_proj = new_r_Proj(irg, get_nodes_block(old_mem), + new_r_Unknown(irg, mode_T), mode_M, + get_Proj_proj(old_mem)); + mem = new_mem_proj; + /* Generate the Prologue */ fp_reg = call->cb->prologue(env->cb, &mem, env->regs); @@ -1837,6 +1902,10 @@ static void modify_irg(be_abi_irg_t *env) set_irg_frame(irg, frame_pointer); pset_insert_ptr(env->ignore_regs, fp_reg); + /* rewire old mem users to new mem */ + set_Proj_pred(new_mem_proj, get_Proj_pred(old_mem)); + exchange(old_mem, mem); + set_irg_initial_mem(irg, mem); /* Now, introduce stack param nodes for all parameters passed on the stack */ @@ -1847,13 +1916,14 @@ static void modify_irg(be_abi_irg_t *env) if(arg_proj != NULL) { be_abi_call_arg_t *arg; ir_type *param_type; - int nr = get_Proj_proj(arg_proj); + int nr = get_Proj_proj(arg_proj); + ir_mode *mode; nr = MIN(nr, n_params); arg = get_call_arg(call, 0, nr); param_type = get_method_param_type(method_type, nr); - if(arg->in_reg) { + if (arg->in_reg) { repl = pmap_get(env->regs, (void *) arg->reg); } @@ -1866,14 +1936,21 @@ static void modify_irg(be_abi_irg_t *env) } /* The stack parameter is not primitive (it is a struct or array), - we thus will create a node representing the parameter's address - on the stack. */ + we thus will create a node representing the parameter's address + on the stack. */ else { repl = be_new_FrameAddr(sp->reg_class, irg, reg_params_bl, frame_pointer, arg->stack_ent); } } assert(repl != NULL); + + /* Beware: the mode of the register parameters is always the mode of the register class + which may be wrong. Add Conv's then. */ + mode = get_irn_mode(args[i]); + if (mode != get_irn_mode(repl)) { + repl = new_r_Conv(irg, get_irn_n(repl, -1), repl, mode); + } exchange(args[i], repl); } } @@ -1909,7 +1986,7 @@ void fix_call_state_inputs(be_abi_irg_t *env) { const arch_isa_t *isa = env->isa; int i, n, n_states; - const arch_register_t **stateregs = NEW_ARR_F(const arch_register_t*, 0); + arch_register_t **stateregs = NEW_ARR_F(arch_register_t*, 0); /* Collect caller save registers */ n = arch_isa_get_n_reg_class(isa); @@ -1919,7 +1996,7 @@ void fix_call_state_inputs(be_abi_irg_t *env) for(j = 0; j < cls->n_regs; ++j) { const arch_register_t *reg = arch_register_for_index(cls, j); if(arch_register_type_is(reg, state)) { - ARR_APP1(arch_register_t*, stateregs, reg); + ARR_APP1(arch_register_t*, stateregs, (arch_register_t *)reg); } } } @@ -1985,11 +2062,6 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg) restore_optimization_state(&state); FIRM_DBG_REGISTER(env->dbg, "firm.be.abi"); -#if 0 - memcpy(&env->irn_handler, &abi_irn_handler, sizeof(abi_irn_handler)); - env->irn_ops.impl = &abi_irn_ops; -#endif - env->calls = NEW_ARR_F(ir_node*, 0); /* Lower all call nodes in the IRG. */ @@ -2023,10 +2095,6 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg) survive_dce_register_irn(env->dce_survivor, (ir_node **) &ent->value); } -#if 0 - arch_env_push_irn_handler(env->birg->main_env->arch_env, &env->irn_handler); -#endif - env->call->cb->done(env->cb); env->cb = NULL; return env; @@ -2034,13 +2102,11 @@ be_abi_irg_t *be_abi_introduce(be_irg_t *birg) void be_abi_free(be_abi_irg_t *env) { + be_abi_call_free(env->call); free_survive_dce(env->dce_survivor); del_pset(env->ignore_regs); pmap_destroy(env->regs); obstack_free(&env->obst, NULL); -#if 0 - arch_env_pop_irn_handler(env->birg->main_env->arch_env); -#endif free(env); } @@ -2068,8 +2134,10 @@ const be_stack_layout_t *be_abi_get_stack_layout(const be_abi_irg_t *abi) { */ +typedef ir_node **node_array; + typedef struct fix_stack_walker_env_t { - ir_node **nodes; + node_array sp_nodes; const arch_env_t *arch_env; } fix_stack_walker_env_t; @@ -2080,46 +2148,65 @@ static void collect_stack_nodes_walker(ir_node *node, void *data) { fix_stack_walker_env_t *env = data; - if (is_Block(node)) - return; - if (arch_irn_is(env->arch_env, node, modify_sp)) { assert(get_irn_mode(node) != mode_M && get_irn_mode(node) != mode_T); - ARR_APP1(ir_node*, env->nodes, node); + ARR_APP1(ir_node*, env->sp_nodes, node); } } -void be_abi_fix_stack_nodes(be_abi_irg_t *env, be_lv_t *lv) +void be_abi_fix_stack_nodes(be_abi_irg_t *env) { - int i; + be_ssa_construction_env_t senv; + int i, len; ir_node **phis; be_irg_t *birg = env->birg; + be_lv_t *lv = be_get_birg_liveness(birg); fix_stack_walker_env_t walker_env; + arch_isa_t *isa; - walker_env.nodes = NEW_ARR_F(ir_node*, 0); + walker_env.sp_nodes = NEW_ARR_F(ir_node*, 0); walker_env.arch_env = birg->main_env->arch_env; - - be_assure_dom_front(birg); + isa = walker_env.arch_env->isa; irg_walk_graph(birg->irg, collect_stack_nodes_walker, NULL, &walker_env); - phis = be_ssa_construction( - be_get_birg_dom_front(birg), - be_get_birg_liveness(birg), - env->init_sp, - ARR_LEN(walker_env.nodes), walker_env.nodes, - NULL, 1); + /* nothing to be done if we didn't find any node, in fact we mustn't + * continue, as for endless loops incsp might have had no users and is bad + * now. + */ + len = ARR_LEN(walker_env.sp_nodes); + if(len == 0) { + DEL_ARR_F(walker_env.sp_nodes); + return; + } + + be_ssa_construction_init(&senv, birg); + be_ssa_construction_add_copies(&senv, walker_env.sp_nodes, + ARR_LEN(walker_env.sp_nodes)); + be_ssa_construction_fix_users_array(&senv, walker_env.sp_nodes, + ARR_LEN(walker_env.sp_nodes)); + + if(lv != NULL) { + len = ARR_LEN(walker_env.sp_nodes); + for(i = 0; i < len; ++i) { + be_liveness_update(lv, walker_env.sp_nodes[i]); + } + be_ssa_construction_update_liveness_phis(&senv, lv); + } + + phis = be_ssa_construction_get_new_phis(&senv); /* set register requirements for stack phis */ - for(i = 0; i < ARR_LEN(phis); ++i) { + len = ARR_LEN(phis); + for(i = 0; i < len; ++i) { ir_node *phi = phis[i]; be_set_phi_reg_req(walker_env.arch_env, phi, &env->sp_req); be_set_phi_flags(walker_env.arch_env, phi, arch_irn_flags_ignore | arch_irn_flags_modify_sp); arch_set_irn_register(walker_env.arch_env, phi, env->isa->sp); } + be_ssa_construction_destroy(&senv); - DEL_ARR_F(phis); - DEL_ARR_F(walker_env.nodes); + DEL_ARR_F(walker_env.sp_nodes); } static int process_stack_bias(be_abi_irg_t *env, ir_node *bl, int bias) @@ -2223,107 +2310,6 @@ ir_node *be_abi_get_start_barrier(be_abi_irg_t *abi) return abi->start_barrier; } -#if 0 -/* - _____ _____ _ _ _ _ _ _ - |_ _| __ \| \ | | | | | | | | | - | | | |__) | \| | | |__| | __ _ _ __ __| | | ___ _ __ - | | | _ /| . ` | | __ |/ _` | '_ \ / _` | |/ _ \ '__| - _| |_| | \ \| |\ | | | | | (_| | | | | (_| | | __/ | - |_____|_| \_\_| \_| |_| |_|\__,_|_| |_|\__,_|_|\___|_| - - for Phi nodes which are created due to stack modifying nodes - such as IncSP, AddSP and SetSP. - - These Phis are always to be ignored by the reg alloc and are - fixed on the SP register of the ISA. -*/ - -static const void *abi_get_irn_ops(const arch_irn_handler_t *handler, const ir_node *irn) -{ - const be_abi_irg_t *abi = get_abi_from_handler(handler); - const void *res = NULL; - - if(is_Phi(irn) && pset_find_ptr(abi->stack_phis, (void *) irn)) - res = &abi->irn_ops; - - return res; -} - -static -const arch_register_req_t *abi_get_irn_reg_req(const void *self, - const ir_node *irn, int pos) -{ - be_abi_irg_t *abi = get_abi_from_ops(self); - - if(pos == BE_OUT_POS(0)) { - return &abi->sp_req; - } else if(pos >= 0 && pos < get_irn_arity(irn)) { - return &abi->sp_cls_req; - } - - return arch_no_register_req; -} - -static void abi_set_irn_reg(const void *self, ir_node *irn, const arch_register_t *reg) -{ -} - -static const arch_register_t *abi_get_irn_reg(const void *self, const ir_node *irn) -{ - const be_abi_irg_t *abi = get_abi_from_ops(self); - return abi->isa->sp; -} - -static arch_irn_class_t abi_classify(const void *_self, const ir_node *irn) -{ - return arch_irn_class_normal; -} - -static arch_irn_flags_t abi_get_flags(const void *_self, const ir_node *irn) -{ - return arch_irn_flags_ignore | arch_irn_flags_modify_sp; -} - -static ir_entity *abi_get_frame_entity(const void *_self, const ir_node *irn) -{ - return NULL; -} - -static void abi_set_frame_entity(const void *_self, ir_node *irn, ir_entity *ent) -{ -} - -static void abi_set_frame_offset(const void *_self, ir_node *irn, int bias) -{ -} - -static int abi_get_sp_bias(const void *self, const ir_node *irn) -{ - return 0; -} - -static const arch_irn_ops_if_t abi_irn_ops = { - abi_get_irn_reg_req, - abi_set_irn_reg, - abi_get_irn_reg, - abi_classify, - abi_get_flags, - abi_get_frame_entity, - abi_set_frame_entity, - abi_set_frame_offset, - abi_get_sp_bias, - NULL, /* get_inverse */ - NULL, /* get_op_estimated_cost */ - NULL, /* possible_memory_operand */ - NULL, /* perform_memory_operand */ -}; - -static const arch_irn_handler_t abi_irn_handler = { - abi_get_irn_ops -}; -#endif - /** * Returns non-zero if the ABI has omitted the frame pointer in * the current graph.