#include "irprintf.h"
#include "ircons.h"
#include "irgmod.h"
+#include "lower_calls.h"
#include "bitset.h"
#include "debug.h"
#include "../bemodule.h"
#include "../begnuas.h"
#include "../belistsched.h"
+#include "../bestack.h"
#include "bearch_TEMPLATE_t.h"
static arch_irn_class_t TEMPLATE_classify(const ir_node *irn)
{
(void) irn;
- return 0;
+ return arch_irn_class_none;
}
static ir_entity *TEMPLATE_get_frame_entity(const ir_node *node)
*/
static void TEMPLATE_finish_irg(ir_graph *irg)
{
- (void) irg;
+ /* fix stack entity offsets */
+ be_abi_fix_stack_nodes(irg);
+ be_abi_fix_stack_bias(irg);
}
/* Some stuff you need to do after scheduling but before register allocation */
}
-static void TEMPLATE_after_ra(ir_graph *irg)
-{
- (void) irg;
- /* Some stuff you need to do immediatly after register allocation */
-}
-
static void TEMPLATE_init_graph(ir_graph *irg)
{
(void) irg;
-const arch_isa_if_t TEMPLATE_isa_if;
+extern const arch_isa_if_t TEMPLATE_isa_if;
static TEMPLATE_isa_t TEMPLATE_isa_template = {
{
&TEMPLATE_isa_if, /* isa interface implementation */
- &TEMPLATE_gp_regs[REG_SP], /* stack pointer register */
- &TEMPLATE_gp_regs[REG_BP], /* base pointer register */
+ N_TEMPLATE_REGISTERS,
+ TEMPLATE_registers,
+ N_TEMPLATE_CLASSES,
+ TEMPLATE_reg_classes,
+ &TEMPLATE_registers[REG_SP], /* stack pointer register */
+ &TEMPLATE_registers[REG_BP], /* base pointer register */
&TEMPLATE_reg_classes[CLASS_TEMPLATE_gp], /* link pointer register class */
- -1, /* stack direction */
2, /* power of two stack alignment for calls, 2^2 == 4 */
NULL, /* main environment */
7, /* costs for a spill instruction */
*/
static arch_env_t *TEMPLATE_init(FILE *outfile)
{
- static int run_once = 0;
- TEMPLATE_isa_t *isa;
-
- if (run_once)
- return NULL;
- run_once = 1;
-
- isa = XMALLOC(TEMPLATE_isa_t);
- memcpy(isa, &TEMPLATE_isa_template, sizeof(*isa));
+ TEMPLATE_isa_t *isa = XMALLOC(TEMPLATE_isa_t);
+ *isa = TEMPLATE_isa_template;
be_emit_init(outfile);
return &isa->base;
}
-
-
/**
* Closes the output file and frees the ISA structure.
*/
static void TEMPLATE_done(void *self)
{
- TEMPLATE_isa_t *isa = self;
+ TEMPLATE_isa_t *isa = (TEMPLATE_isa_t*)self;
/* emit now all global declarations */
be_gas_emit_decls(isa->base.main_env);
free(self);
}
-
-static unsigned TEMPLATE_get_n_reg_class(void)
-{
- return N_CLASSES;
-}
-
-static const arch_register_class_t *TEMPLATE_get_reg_class(unsigned i)
-{
- assert(i < N_CLASSES);
- return &TEMPLATE_reg_classes[i];
-}
-
-
-
/**
* Get the register class which shall be used to store a value of a given mode.
* @param self The this pointer.
return &TEMPLATE_reg_classes[CLASS_TEMPLATE_gp];
}
-
-
-typedef struct {
- be_abi_call_flags_bits_t flags;
- ir_graph *irg;
-} TEMPLATE_abi_env_t;
-
-static void *TEMPLATE_abi_init(const be_abi_call_t *call, ir_graph *irg)
-{
- TEMPLATE_abi_env_t *env = XMALLOC(TEMPLATE_abi_env_t);
- be_abi_call_flags_t fl = be_abi_call_get_flags(call);
- env->flags = fl.bits;
- env->irg = irg;
- return env;
-}
-
/**
* Get the between type for that call.
* @param self The callback object.
* @return The between type of for that call.
*/
-static ir_type *TEMPLATE_get_between_type(void *self)
+static ir_type *TEMPLATE_get_between_type(ir_graph *irg)
{
static ir_type *between_type = NULL;
static ir_entity *old_bp_ent = NULL;
- (void) self;
+ (void) irg;
if (!between_type) {
ir_entity *ret_addr_ent;
return between_type;
}
-/**
- * Build the prolog, return the BASE POINTER register
- */
-static const arch_register_t *TEMPLATE_abi_prologue(void *self, ir_node **mem,
- pmap *reg_map, int *stack_bias)
-{
- TEMPLATE_abi_env_t *env = self;
- const arch_env_t *arch_env = be_get_irg_arch_env(env->irg);
- (void) reg_map;
- (void) mem;
- (void) stack_bias;
-
- if (env->flags.try_omit_fp)
- return arch_env->sp;
- return arch_env->bp;
-}
-
-/* Build the epilog */
-static void TEMPLATE_abi_epilogue(void *self, ir_node *bl, ir_node **mem,
- pmap *reg_map)
-{
- (void) self;
- (void) bl;
- (void) mem;
- (void) reg_map;
-}
-
static const be_abi_callbacks_t TEMPLATE_abi_callbacks = {
- TEMPLATE_abi_init,
- free,
TEMPLATE_get_between_type,
- TEMPLATE_abi_prologue,
- TEMPLATE_abi_epilogue,
};
/**
(void) self;
/* set abi flags for calls */
- call_flags.bits.left_to_right = 0;
call_flags.bits.store_args_sequential = 1;
call_flags.bits.try_omit_fp = 1;
call_flags.bits.fp_free = 0;
mode = get_type_mode(tp);
be_abi_call_res_reg(abi, 0,
- mode_is_float(mode) ? &TEMPLATE_fp_regs[REG_F0] : &TEMPLATE_gp_regs[REG_R0], ABI_CONTEXT_BOTH);
+ mode_is_float(mode) ? &TEMPLATE_registers[REG_F0] : &TEMPLATE_registers[REG_R0], ABI_CONTEXT_BOTH);
}
}
static void TEMPLATE_lower_for_target(void)
{
+ /* lower compound param handling */
+ lower_calls_with_compounds(LF_RETURN_HIDDEN);
+}
+
+static int TEMPLATE_is_mux_allowed(ir_node *sel, ir_node *mux_false,
+ ir_node *mux_true)
+{
+ (void) sel;
+ (void) mux_false;
+ (void) mux_true;
+ return false;
}
/**
0, /* no inline assembly */
0, /* no support for Rotl nodes */
0, /* 0: little-endian, 1: big-endian */
- TEMPLATE_lower_for_target, /* lowering for target */
+ 1, /* modulo shift efficient */
+ 0, /* non-modulo shift efficient */
NULL, /* architecture dependent settings, will be set later */
- NULL, /* parameter for if conversion */
+ TEMPLATE_is_mux_allowed, /* parameter for if conversion */
+ 32, /* machine size - a 32bit CPU */
NULL, /* float arithmetic mode */
+ NULL, /* long long type */
+ NULL, /* unsigned long long type */
+ NULL, /* long double type */
0, /* no trampoline support: size 0 */
0, /* no trampoline support: align 0 */
NULL, /* no trampoline support: no trampoline builder */
return 0;
}
+/**
+ * Check if the given register is callee or caller save.
+ */
+static int TEMPLATE_register_saved_by(const arch_register_t *reg, int callee)
+{
+ if (callee) {
+ /* check for callee saved */
+ if (reg->reg_class == &TEMPLATE_reg_classes[CLASS_TEMPLATE_gp]) {
+ switch (reg->index) {
+ case REG_GP_R7:
+ case REG_GP_R8:
+ case REG_GP_R9:
+ case REG_GP_R10:
+ case REG_GP_R11:
+ case REG_GP_R12:
+ case REG_GP_R13:
+ return 1;
+ default:
+ return 0;
+ }
+ }
+ } else {
+ /* check for caller saved */
+ if (reg->reg_class == &TEMPLATE_reg_classes[CLASS_TEMPLATE_gp]) {
+ switch (reg->index) {
+ case REG_GP_R0:
+ case REG_GP_R1:
+ case REG_GP_R2:
+ case REG_GP_R3:
+ case REG_GP_R4:
+ case REG_GP_R5:
+ case REG_GP_R6:
+ return 1;
+ default:
+ return 0;
+ }
+ } else if (reg->reg_class == &TEMPLATE_reg_classes[CLASS_TEMPLATE_fp]) {
+ /* all FP registers are caller save */
+ return 1;
+ }
+ }
+ return 0;
+}
+
const arch_isa_if_t TEMPLATE_isa_if = {
TEMPLATE_init,
+ TEMPLATE_lower_for_target,
TEMPLATE_done,
NULL, /* handle intrinsics */
- TEMPLATE_get_n_reg_class,
- TEMPLATE_get_reg_class,
TEMPLATE_get_reg_class_for_mode,
TEMPLATE_get_call_abi,
TEMPLATE_get_reg_class_alignment,
NULL, /* before_abi */
TEMPLATE_prepare_graph,
TEMPLATE_before_ra,
- TEMPLATE_after_ra,
TEMPLATE_finish_irg,
TEMPLATE_emit_routine,
+ TEMPLATE_register_saved_by,
};
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_arch_TEMPLATE);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_arch_TEMPLATE)
void be_init_arch_TEMPLATE(void)
{
be_register_isa_if("TEMPLATE", &TEMPLATE_isa_if);