use default error handler if none is specified
[libfirm] / ir / be / arm / bearch_arm.c
index 6338f67..3040ca4 100644 (file)
@@ -23,9 +23,7 @@
  * @author  Oliver Richter, Tobias Gneist
  * @version $Id$
  */
-#ifdef HAVE_CONFIG_H
 #include "config.h"
-#endif
 
 #include "lc_opts.h"
 #include "lc_opts_enum.h"
@@ -43,6 +41,7 @@
 
 #include "bitset.h"
 #include "debug.h"
+#include "array_t.h"
 #include "irtools.h"
 
 #include "../bearch_t.h"                /* the general register allocator interface */
@@ -190,9 +189,6 @@ static arch_irn_class_t arm_classify(const ir_node *irn)
        if (is_cfop(irn)) {
                return arch_irn_class_branch;
        }
-       else if (is_arm_irn(irn)) {
-               return arch_irn_class_normal;
-       }
 
        return 0;
 }
@@ -383,10 +379,9 @@ static ir_node *convert_dbl_to_int(ir_node *bl, ir_node *arg, ir_node *mem,
                v = (v << 8) | get_tarval_sub_bits(tv, 1);
                v = (v << 8) | get_tarval_sub_bits(tv, 0);
                *resL = new_Const_long(mode_Is, v);
-       }
-       else if (get_irn_op(skip_Proj(arg)) == op_Load) {
+       } else if (is_Load(skip_Proj(arg))) {
                /* FIXME: handling of low/high depends on LE/BE here */
-               assert(0);
+               panic("Unimplemented convert_dbl_to_int() case");
        }
        else {
                ir_graph *irg = current_ir_graph;
@@ -423,14 +418,12 @@ static ir_node *convert_sng_to_int(ir_node *bl, ir_node *arg)
                v = (v << 8) | get_tarval_sub_bits(tv, 1);
                v = (v << 8) | get_tarval_sub_bits(tv, 0);
                return new_Const_long(mode_Is, v);
-       }
-       else if (get_irn_op(skip_Proj(arg)) == op_Load) {
+       } else if (is_Load(skip_Proj(arg))) {
                ir_node *load;
 
                load = skip_Proj(arg);
        }
-       assert(0);
-       return NULL;
+       panic("Unimplemented convert_sng_to_int() case");
 }
 
 /**
@@ -583,11 +576,10 @@ static void *arm_cg_init(be_irg_t *birg) {
                int_tp = new_type_primitive(new_id_from_chars("int", 3), mode_Is);
        }
 
-       cg = xmalloc(sizeof(*cg));
+       cg = XMALLOC(arm_code_gen_t);
        cg->impl         = &arm_code_gen_if;
        cg->irg          = birg->irg;
        cg->reg_set      = new_set(arm_cmp_irn_reg_assoc, 1024);
-       cg->arch_env     = birg->main_env->arch_env;
        cg->isa          = isa;
        cg->birg         = birg;
        cg->int_tp       = int_tp;
@@ -769,7 +761,7 @@ static arch_env_t *arm_init(FILE *file_handle) {
        if (inited)
                return NULL;
 
-       isa = xmalloc(sizeof(*isa));
+       isa = XMALLOC(arm_isa_t);
        memcpy(isa, &arm_isa_template, sizeof(*isa));
 
        arm_register_init();
@@ -881,8 +873,8 @@ typedef struct {
 
 static void *arm_abi_init(const be_abi_call_t *call, const arch_env_t *arch_env, ir_graph *irg)
 {
-       arm_abi_env_t *env     = xmalloc(sizeof(env[0]));
-       be_abi_call_flags_t fl = be_abi_call_get_flags(call);
+       arm_abi_env_t       *env = XMALLOC(arm_abi_env_t);
+       be_abi_call_flags_t  fl  = be_abi_call_get_flags(call);
        env->flags    = fl.bits;
        env->irg      = irg;
        env->arch_env = arch_env;
@@ -902,20 +894,19 @@ static void arm_abi_dont_save_regs(void *self, pset *s)
                pset_insert_ptr(s, env->arch_env->bp);
 }
 
-
-
 /**
-* Generate the routine prologue.
+ * Generate the routine prologue.
  *
- * @param self    The callback object.
- * @param mem     A pointer to the mem node. Update this if you define new memory.
- * @param reg_map A map mapping all callee_save/ignore/parameter registers to their defining nodes.
+ * @param self       The callback object.
+ * @param mem        A pointer to the mem node. Update this if you define new memory.
+ * @param reg_map    A map mapping all callee_save/ignore/parameter registers to their defining nodes.
+ * @param stack_bias Points to the current stack bias, can be modified if needed.
  *
  * @return        The register which shall be used as a stack frame base.
  *
  * All nodes which define registers in @p reg_map must keep @p reg_map current.
  */
-static const arch_register_t *arm_abi_prologue(void *self, ir_node **mem, pmap *reg_map) {
+static const arch_register_t *arm_abi_prologue(void *self, ir_node **mem, pmap *reg_map, int *stack_bias) {
        arm_abi_env_t         *env = self;
        ir_node               *keep, *store;
        ir_graph              *irg;
@@ -925,6 +916,8 @@ static const arch_register_t *arm_abi_prologue(void *self, ir_node **mem, pmap *
        ir_node               *fp, *ip, *lr, *pc;
        ir_node               *sp = be_abi_reg_map_get(reg_map, env->arch_env->sp);
 
+       (void) stack_bias;
+
        if (env->flags.try_omit_fp)
                return env->arch_env->sp;
 
@@ -938,24 +931,24 @@ static const arch_register_t *arm_abi_prologue(void *self, ir_node **mem, pmap *
        block = get_irg_start_block(irg);
 
        ip = be_new_Copy(gp, irg, block, sp);
-       arch_set_irn_register(env->arch_env, ip, &arm_gp_regs[REG_R12]);
+       arch_set_irn_register(ip, &arm_gp_regs[REG_R12]);
        be_set_constr_single_reg(ip, BE_OUT_POS(0), &arm_gp_regs[REG_R12] );
 
        store = new_rd_arm_StoreStackM4Inc(NULL, irg, block, sp, fp, ip, lr, pc, *mem);
 
        sp = new_r_Proj(irg, block, store, env->arch_env->sp->reg_class->mode, pn_arm_StoreStackM4Inc_ptr);
-       arch_set_irn_register(env->arch_env, sp, env->arch_env->sp);
+       arch_set_irn_register(sp, env->arch_env->sp);
        *mem = new_r_Proj(irg, block, store, mode_M, pn_arm_StoreStackM4Inc_M);
 
        keep = be_new_CopyKeep_single(gp, irg, block, ip, sp, get_irn_mode(ip));
        be_node_set_reg_class(keep, 1, gp);
-       arch_set_irn_register(env->arch_env, keep, &arm_gp_regs[REG_R12]);
+       arch_set_irn_register(keep, &arm_gp_regs[REG_R12]);
        be_set_constr_single_reg(keep, BE_OUT_POS(0), &arm_gp_regs[REG_R12] );
 
        fp = new_rd_arm_Sub_i(NULL, irg, block, keep, get_irn_mode(fp), 4);
-       arch_set_irn_register(env->arch_env, fp, env->arch_env->bp);
+       arch_set_irn_register(fp, env->arch_env->bp);
        fp = be_new_Copy(gp, irg, block, fp); // XXX Gammelfix: only be_ nodes can have the ignore flag set
-       arch_set_irn_register(env->arch_env, fp, env->arch_env->bp);
+       arch_set_irn_register(fp, env->arch_env->bp);
        be_node_set_flags(fp, BE_OUT_POS(0), arch_irn_flags_ignore);
 
        be_abi_reg_map_set(reg_map, env->arch_env->bp, fp);
@@ -980,15 +973,14 @@ static void arm_abi_epilogue(void *self, ir_node *bl, ir_node **mem, pmap *reg_m
        // TODO: Activate Omit fp in epilogue
        if (env->flags.try_omit_fp) {
                curr_sp = be_new_IncSP(env->arch_env->sp, env->irg, bl, curr_sp, BE_STACK_FRAME_SIZE_SHRINK, 0);
-               add_irn_dep(curr_sp, *mem);
 
                curr_lr = be_new_CopyKeep_single(&arm_reg_classes[CLASS_arm_gp], env->irg, bl, curr_lr, curr_sp, get_irn_mode(curr_lr));
                be_node_set_reg_class(curr_lr, 1, &arm_reg_classes[CLASS_arm_gp]);
-               arch_set_irn_register(env->arch_env, curr_lr, &arm_gp_regs[REG_LR]);
+               arch_set_irn_register(curr_lr, &arm_gp_regs[REG_LR]);
                be_set_constr_single_reg(curr_lr, BE_OUT_POS(0), &arm_gp_regs[REG_LR] );
 
                curr_pc = be_new_Copy(&arm_reg_classes[CLASS_arm_gp], env->irg, bl, curr_lr );
-               arch_set_irn_register(env->arch_env, curr_pc, &arm_gp_regs[REG_PC]);
+               arch_set_irn_register(curr_pc, &arm_gp_regs[REG_PC]);
                be_set_constr_single_reg(curr_pc, BE_OUT_POS(0), &arm_gp_regs[REG_PC] );
                be_node_set_flags(curr_pc, BE_OUT_POS(0), arch_irn_flags_ignore);
        } else {
@@ -997,7 +989,7 @@ static void arm_abi_epilogue(void *self, ir_node *bl, ir_node **mem, pmap *reg_m
                sub12_node = new_rd_arm_Sub_i(NULL, env->irg, bl, curr_bp, mode_Iu, 12);
                // FIXME
                //set_arm_req_out_all(sub12_node, sub12_req);
-               arch_set_irn_register(env->arch_env, sub12_node, env->arch_env->sp);
+               arch_set_irn_register(sub12_node, env->arch_env->sp);
                load_node = new_rd_arm_LoadStackM3( NULL, env->irg, bl, sub12_node, *mem );
                // FIXME
                //set_arm_req_out(load_node, &arm_default_req_arm_gp_r11, 0);
@@ -1007,9 +999,9 @@ static void arm_abi_epilogue(void *self, ir_node *bl, ir_node **mem, pmap *reg_m
                curr_sp = new_r_Proj(env->irg, bl, load_node, env->arch_env->sp->reg_class->mode, pn_arm_LoadStackM3_res1);
                curr_pc = new_r_Proj(env->irg, bl, load_node, mode_Iu, pn_arm_LoadStackM3_res2);
                *mem    = new_r_Proj(env->irg, bl, load_node, mode_M, pn_arm_LoadStackM3_M);
-               arch_set_irn_register(env->arch_env, curr_bp, env->arch_env->bp);
-               arch_set_irn_register(env->arch_env, curr_sp, env->arch_env->sp);
-               arch_set_irn_register(env->arch_env, curr_pc, &arm_gp_regs[REG_PC]);
+               arch_set_irn_register(curr_bp, env->arch_env->bp);
+               arch_set_irn_register(curr_sp, env->arch_env->sp);
+               arch_set_irn_register(curr_pc, &arm_gp_regs[REG_PC]);
        }
        be_abi_reg_map_set(reg_map, env->arch_env->sp, curr_sp);
        be_abi_reg_map_set(reg_map, env->arch_env->bp, curr_bp);
@@ -1143,15 +1135,13 @@ static const be_execution_unit_t ***arm_get_allowed_execution_units(const void *
        (void) self;
        (void) irn;
        /* TODO */
-       assert(0);
-       return NULL;
+       panic("Unimplemented arm_get_allowed_execution_units()");
 }
 
 static const be_machine_t *arm_get_machine(const void *self) {
        (void) self;
        /* TODO */
-       assert(0);
-       return NULL;
+       panic("Unimplemented arm_get_machine()");
 }
 
 /**
@@ -1212,11 +1202,11 @@ static asm_constraint_flags_t arm_parse_asm_constraint(const void *self, const c
        return ASM_CONSTRAINT_FLAG_INVALID;
 }
 
-static bool arm_is_valid_clobber(const void *self, const char *clobber)
+static int arm_is_valid_clobber(const void *self, const char *clobber)
 {
        (void) self;
        (void) clobber;
-       return false;
+       return 0;
 }
 
 /**
@@ -1289,6 +1279,7 @@ const arch_isa_if_t arm_isa_if = {
        arm_get_allowed_execution_units,
        arm_get_machine,
        arm_get_irg_list,
+       NULL,               /* mark remat */
        arm_parse_asm_constraint,
        arm_is_valid_clobber
 };