nsz Git - libfirm/blob - ir/be/TEMPLATE/bearch_TEMPLATE.c

   1 /*
   2  * This file is part of libFirm.
   3  * Copyright (C) 2012 University of Karlsruhe.
   4  */
   5
   6 /**
   7  * @file
   8  * @brief    The main TEMPLATE backend driver file.
   9  */
  10 #include "config.h"
  11
  12 #include "bearch_TEMPLATE_t.h"
  13
  14 #include "irgwalk.h"
  15 #include "irprog.h"
  16 #include "irprintf.h"
  17 #include "ircons.h"
  18 #include "irgmod.h"
  19 #include "lower_calls.h"
  20 #include "lower_builtins.h"
  21
  22 #include "bitset.h"
  23 #include "debug.h"
  24
  25 #include "be_t.h"
  26 #include "bearch.h"
  27 #include "benode.h"
  28 #include "belower.h"
  29 #include "besched.h"
  30 #include "beabi.h"
  31 #include "bemodule.h"
  32 #include "begnuas.h"
  33 #include "belistsched.h"
  34 #include "bestack.h"
  35 #include "bespillutil.h"
  36
  37 #include "TEMPLATE_new_nodes.h"
  38 #include "gen_TEMPLATE_regalloc_if.h"
  39 #include "TEMPLATE_transform.h"
  40 #include "TEMPLATE_emitter.h"
  41
  42 DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
  43
  44 static ir_entity *TEMPLATE_get_frame_entity(const ir_node *node)
  45 {
  46         (void) node;
  47         /* TODO: return the ir_entity assigned to the frame */
  48         return NULL;
  49 }
  50
  51 /**
  52  * This function is called by the generic backend to correct offsets for
  53  * nodes accessing the stack.
  54  */
  55 static void TEMPLATE_set_frame_offset(ir_node *irn, int offset)
  56 {
  57         (void) irn;
  58         (void) offset;
  59         /* TODO: correct offset if irn accesses the stack */
  60 }
  61
  62 static int TEMPLATE_get_sp_bias(const ir_node *irn)
  63 {
  64         (void) irn;
  65         return 0;
  66 }
  67
  68 /* fill register allocator interface */
  69
  70 static const arch_irn_ops_t TEMPLATE_irn_ops = {
  71         TEMPLATE_get_frame_entity,
  72         TEMPLATE_set_frame_offset,
  73         TEMPLATE_get_sp_bias,
  74         NULL,    /* get_op_estimated_cost   */
  75         NULL,    /* possible_memory_operand */
  76         NULL,    /* perform_memory_operand  */
  77 };
  78
  79
  80
  81 /**
  82  * Transforms the standard firm graph into
  83  * a TEMLPATE firm graph
  84  */
  85 static void TEMPLATE_prepare_graph(ir_graph *irg)
  86 {
  87         /* transform nodes into assembler instructions */
  88         TEMPLATE_transform_graph(irg);
  89 }
  90
  91
  92
  93 /**
  94  * Called immediatly before emit phase.
  95  */
  96 static void TEMPLATE_finish_irg(ir_graph *irg)
  97 {
  98         /* fix stack entity offsets */
  99         be_abi_fix_stack_nodes(irg);
 100         be_abi_fix_stack_bias(irg);
 101 }
 102
 103
 104 static void TEMPLATE_before_ra(ir_graph *irg)
 105 {
 106         (void) irg;
 107         /* Some stuff you need to do after scheduling but before register allocation */
 108 }
 109
 110 static void TEMPLATE_init_graph(ir_graph *irg)
 111 {
 112         (void) irg;
 113 }
 114
 115
 116
 117 extern const arch_isa_if_t TEMPLATE_isa_if;
 118 static TEMPLATE_isa_t TEMPLATE_isa_template = {
 119         {
 120                 &TEMPLATE_isa_if,            /* isa interface implementation */
 121                 N_TEMPLATE_REGISTERS,
 122                 TEMPLATE_registers,
 123                 N_TEMPLATE_CLASSES,
 124                 TEMPLATE_reg_classes,
 125                 &TEMPLATE_registers[REG_SP], /* stack pointer register */
 126                 &TEMPLATE_registers[REG_BP], /* base pointer register */
 127                 2,                           /* power of two stack alignment for calls, 2^2 == 4 */
 128                 7,                           /* costs for a spill instruction */
 129                 5,                           /* costs for a reload instruction */
 130                 true,                        /* custom abi handling */
 131         },
 132 };
 133
 134 static void TEMPLATE_init(void)
 135 {
 136         TEMPLATE_register_init();
 137         TEMPLATE_create_opcodes(&TEMPLATE_irn_ops);
 138 }
 139
 140 static void TEMPLATE_finish(void)
 141 {
 142         TEMPLATE_free_opcodes();
 143 }
 144
 145 static arch_env_t *TEMPLATE_begin_codegeneration(void)
 146 {
 147         TEMPLATE_isa_t *isa = XMALLOC(TEMPLATE_isa_t);
 148         *isa = TEMPLATE_isa_template;
 149
 150         return &isa->base;
 151 }
 152
 153 /**
 154  * Closes the output file and frees the ISA structure.
 155  */
 156 static void TEMPLATE_end_codegeneration(void *self)
 157 {
 158         free(self);
 159 }
 160
 161 /**
 162  * Get the between type for that call.
 163  * @param self The callback object.
 164  * @return The between type of for that call.
 165  */
 166 static ir_type *TEMPLATE_get_between_type(ir_graph *irg)
 167 {
 168         static ir_type *between_type = NULL;
 169         static ir_entity *old_bp_ent = NULL;
 170         (void) irg;
 171
 172         if (!between_type) {
 173                 ir_entity *ret_addr_ent;
 174                 ir_type *ret_addr_type = new_type_primitive(mode_P);
 175                 ir_type *old_bp_type   = new_type_primitive(mode_P);
 176
 177                 between_type           = new_type_class(new_id_from_str("TEMPLATE_between_type"));
 178                 old_bp_ent             = new_entity(between_type, new_id_from_str("old_bp"), old_bp_type);
 179                 ret_addr_ent           = new_entity(between_type, new_id_from_str("old_bp"), ret_addr_type);
 180
 181                 set_entity_offset(old_bp_ent, 0);
 182                 set_entity_offset(ret_addr_ent, get_type_size_bytes(old_bp_type));
 183                 set_type_size_bytes(between_type, get_type_size_bytes(old_bp_type) + get_type_size_bytes(ret_addr_type));
 184         }
 185
 186         return between_type;
 187 }
 188
 189 static const be_abi_callbacks_t TEMPLATE_abi_callbacks = {
 190         TEMPLATE_get_between_type,
 191 };
 192
 193 /**
 194  * Get the ABI restrictions for procedure calls.
 195  * @param self        The this pointer.
 196  * @param method_type The type of the method (procedure) in question.
 197  * @param abi         The abi object to be modified
 198  */
 199 static void TEMPLATE_get_call_abi(ir_type *method_type, be_abi_call_t *abi)
 200 {
 201         ir_type  *tp;
 202         ir_mode  *mode;
 203         int       i, n = get_method_n_params(method_type);
 204
 205         /* set abi flags for calls */
 206         be_abi_call_flags_t call_flags = be_abi_call_get_flags(abi);
 207         call_flags.call_has_imm = true;
 208         be_abi_call_set_flags(abi, call_flags, &TEMPLATE_abi_callbacks);
 209
 210         for (i = 0; i < n; i++) {
 211                 /* TODO: implement register parameter: */
 212                 /* reg = get reg for param i;          */
 213                 /* be_abi_call_param_reg(abi, i, reg, ABI_CONTEXT_BOTH); */
 214
 215                 /* default: all parameters on stack */
 216                 tp   = get_method_param_type(method_type, i);
 217                 mode = get_type_mode(tp);
 218                 be_abi_call_param_stack(abi, i, mode, 4, 0, 0, ABI_CONTEXT_BOTH);
 219         }
 220
 221         /* TODO: set correct return register */
 222         /* default: return value is in R0 resp. F0 */
 223         if (get_method_n_ress(method_type) > 0) {
 224                 tp   = get_method_res_type(method_type, 0);
 225                 mode = get_type_mode(tp);
 226
 227                 be_abi_call_res_reg(abi, 0,
 228                         mode_is_float(mode) ? &TEMPLATE_registers[REG_F0] : &TEMPLATE_registers[REG_R0], ABI_CONTEXT_BOTH);
 229         }
 230 }
 231
 232 static void TEMPLATE_lower_for_target(void)
 233 {
 234         lower_builtins(0, NULL);
 235
 236         /* lower compound param handling */
 237         lower_calls_with_compounds(LF_RETURN_HIDDEN);
 238 }
 239
 240 static int TEMPLATE_is_mux_allowed(ir_node *sel, ir_node *mux_false,
 241                                    ir_node *mux_true)
 242 {
 243         (void) sel;
 244         (void) mux_false;
 245         (void) mux_true;
 246         return false;
 247 }
 248
 249 /**
 250  * Returns the libFirm configuration parameter for this backend.
 251  */
 252 static const backend_params *TEMPLATE_get_backend_params(void)
 253 {
 254         static backend_params p = {
 255                 0,     /* no inline assembly */
 256                 0,     /* no support for Rotl nodes */
 257                 0,     /* 0: little-endian, 1: big-endian */
 258                 1,     /* modulo shift efficient */
 259                 0,     /* non-modulo shift efficient */
 260                 NULL,  /* architecture dependent settings, will be set later */
 261                 TEMPLATE_is_mux_allowed,  /* parameter for if conversion */
 262                 32,    /* machine size - a 32bit CPU */
 263                 NULL,  /* float arithmetic mode */
 264                 NULL,  /* long long type */
 265                 NULL,  /* unsigned long long type */
 266                 NULL,  /* long double type */
 267                 0,     /* no trampoline support: size 0 */
 268                 0,     /* no trampoline support: align 0 */
 269                 NULL,  /* no trampoline support: no trampoline builder */
 270                 4      /* alignment of stack parameter: typically 4 (32bit) or 8 (64bit) */
 271         };
 272         return &p;
 273 }
 274
 275 static asm_constraint_flags_t TEMPLATE_parse_asm_constraint(const char **c)
 276 {
 277         (void) c;
 278         return ASM_CONSTRAINT_FLAG_INVALID;
 279 }
 280
 281 static int TEMPLATE_is_valid_clobber(const char *clobber)
 282 {
 283         (void) clobber;
 284         return 0;
 285 }
 286
 287 /**
 288  * Check if the given register is callee or caller save.
 289  */
 290 static int TEMPLATE_register_saved_by(const arch_register_t *reg, int callee)
 291 {
 292         if (callee) {
 293                 /* check for callee saved */
 294                 if (reg->reg_class == &TEMPLATE_reg_classes[CLASS_TEMPLATE_gp]) {
 295                         switch (reg->index) {
 296                         case REG_GP_R7:
 297                         case REG_GP_R8:
 298                         case REG_GP_R9:
 299                         case REG_GP_R10:
 300                         case REG_GP_R11:
 301                         case REG_GP_R12:
 302                         case REG_GP_R13:
 303                                 return 1;
 304                         default:
 305                                 return 0;
 306                         }
 307                 }
 308         } else {
 309                 /* check for caller saved */
 310                 if (reg->reg_class == &TEMPLATE_reg_classes[CLASS_TEMPLATE_gp]) {
 311                         switch (reg->index) {
 312                         case REG_GP_R0:
 313                         case REG_GP_R1:
 314                         case REG_GP_R2:
 315                         case REG_GP_R3:
 316                         case REG_GP_R4:
 317                         case REG_GP_R5:
 318                         case REG_GP_R6:
 319                                 return 1;
 320                         default:
 321                                 return 0;
 322                         }
 323                 } else if (reg->reg_class == &TEMPLATE_reg_classes[CLASS_TEMPLATE_fp]) {
 324                         /* all FP registers are caller save */
 325                         return 1;
 326                 }
 327         }
 328         return 0;
 329 }
 330
 331 const arch_isa_if_t TEMPLATE_isa_if = {
 332         TEMPLATE_init,
 333         TEMPLATE_finish,
 334     TEMPLATE_get_backend_params,
 335         TEMPLATE_lower_for_target,
 336         TEMPLATE_parse_asm_constraint,
 337         TEMPLATE_is_valid_clobber,
 338
 339         TEMPLATE_begin_codegeneration,
 340         TEMPLATE_end_codegeneration,
 341         TEMPLATE_init_graph,
 342         TEMPLATE_get_call_abi,
 343         NULL, /* mark remat */
 344         NULL, /* get_pic_base */
 345         be_new_spill,
 346         be_new_reload,
 347         TEMPLATE_register_saved_by,
 348
 349         NULL, /* handle intrinsics */
 350         NULL, /* before_abi */
 351         TEMPLATE_prepare_graph,
 352         TEMPLATE_before_ra,
 353         TEMPLATE_finish_irg,
 354         TEMPLATE_emit_routine,
 355 };
 356
 357 BE_REGISTER_MODULE_CONSTRUCTOR(be_init_arch_TEMPLATE)
 358 void be_init_arch_TEMPLATE(void)
 359 {
 360         be_register_isa_if("TEMPLATE", &TEMPLATE_isa_if);
 361         FIRM_DBG_REGISTER(dbg, "firm.be.TEMPLATE.cg");
 362         TEMPLATE_init_transform();
 363 }