* @file
* @brief The main arm backend driver file.
* @author Matthias Braun, Oliver Richter, Tobias Gneist
- * @version $Id$
*/
#include "config.h"
#include "irgopt.h"
#include "iroptimize.h"
#include "irdump.h"
-#include "lowering.h"
+#include "lower_calls.h"
#include "error.h"
#include "bitset.h"
#include "array_t.h"
#include "irtools.h"
-#include "../bearch.h"
-#include "../benode.h"
-#include "../belower.h"
-#include "../besched.h"
+#include "bearch.h"
+#include "benode.h"
+#include "belower.h"
+#include "besched.h"
#include "be.h"
-#include "../bemachine.h"
-#include "../bemodule.h"
-#include "../beirg.h"
-#include "../bespillslots.h"
-#include "../begnuas.h"
-#include "../belistsched.h"
-#include "../beflags.h"
+#include "bemodule.h"
+#include "beirg.h"
+#include "bespillslots.h"
+#include "bespillutil.h"
+#include "begnuas.h"
+#include "belistsched.h"
+#include "beflags.h"
+#include "bestack.h"
#include "bearch_arm_t.h"
{
(void) irn;
/* TODO: we should mark reload/spill instructions and classify them here */
- return 0;
+ return arch_irn_class_none;
}
static ir_entity *arm_get_frame_entity(const ir_node *irn)
const arm_attr_t *attr = get_arm_attr_const(irn);
if (is_arm_FrameAddr(irn)) {
- const arm_SymConst_attr_t *attr = get_irn_generic_attr_const(irn);
- return attr->entity;
+ const arm_SymConst_attr_t *frame_attr = get_arm_SymConst_attr_const(irn);
+ return frame_attr->entity;
}
if (attr->is_load_store) {
const arm_load_store_attr_t *load_store_attr
static void arm_set_stack_bias(ir_node *irn, int bias)
{
if (is_arm_FrameAddr(irn)) {
- arm_SymConst_attr_t *attr = get_irn_generic_attr(irn);
+ arm_SymConst_attr_t *attr = get_arm_SymConst_attr(irn);
attr->fp_offset += bias;
} else {
arm_load_store_attr_t *attr = get_arm_load_store_attr(irn);
place_code(irg);
}
-/**
- * Called immediately before emit phase.
- */
-static void arm_finish_irg(ir_graph *irg)
+static void arm_collect_frame_entity_nodes(ir_node *node, void *data)
{
- /* do peephole optimizations and fix stack offsets */
- arm_peephole_optimization(irg);
+ be_fec_env_t *env = (be_fec_env_t*)data;
+ const ir_mode *mode;
+ int align;
+ ir_entity *entity;
+ const arm_load_store_attr_t *attr;
+
+ if (be_is_Reload(node) && be_get_frame_entity(node) == NULL) {
+ mode = get_irn_mode(node);
+ align = get_mode_size_bytes(mode);
+ be_node_needs_frame_entity(env, node, mode, align);
+ return;
+ }
+
+ switch (get_arm_irn_opcode(node)) {
+ case iro_arm_Ldf:
+ case iro_arm_Ldr:
+ break;
+ default:
+ return;
+ }
+
+ attr = get_arm_load_store_attr_const(node);
+ entity = attr->entity;
+ mode = attr->load_store_mode;
+ align = get_mode_size_bytes(mode);
+ if (entity != NULL)
+ return;
+ if (!attr->is_frame_entity)
+ return;
+ be_node_needs_frame_entity(env, node, mode, align);
}
-static void arm_before_ra(ir_graph *irg)
+static void arm_set_frame_entity(ir_node *node, ir_entity *entity)
{
- be_sched_fix_flags(irg, &arm_reg_classes[CLASS_arm_flags], NULL, NULL);
+ if (is_be_node(node)) {
+ be_node_set_frame_entity(node, entity);
+ } else {
+ arm_load_store_attr_t *attr = get_arm_load_store_attr(node);
+ attr->entity = entity;
+ }
}
static void transform_Reload(ir_node *node)
{
ir_node *block = get_nodes_block(node);
dbg_info *dbgi = get_irn_dbg_info(node);
- ir_node *ptr = get_irn_n(node, be_pos_Reload_frame);
- ir_node *mem = get_irn_n(node, be_pos_Reload_mem);
+ ir_node *ptr = get_irn_n(node, n_be_Reload_frame);
+ ir_node *mem = get_irn_n(node, n_be_Reload_mem);
ir_mode *mode = get_irn_mode(node);
ir_entity *entity = be_get_frame_entity(node);
const arch_register_t *reg;
{
ir_node *block = get_nodes_block(node);
dbg_info *dbgi = get_irn_dbg_info(node);
- ir_node *ptr = get_irn_n(node, be_pos_Spill_frame);
- ir_node *mem = new_NoMem();
- ir_node *val = get_irn_n(node, be_pos_Spill_val);
+ ir_node *ptr = get_irn_n(node, n_be_Spill_frame);
+ ir_graph *irg = get_irn_irg(node);
+ ir_node *mem = get_irg_no_mem(irg);
+ ir_node *val = get_irn_n(node, n_be_Spill_val);
ir_mode *mode = get_irn_mode(val);
ir_entity *entity = be_get_frame_entity(node);
ir_node *sched_point;
}
}
-static void arm_collect_frame_entity_nodes(ir_node *node, void *data)
+/**
+ * Called immediately before emit phase.
+ */
+static void arm_finish_irg(ir_graph *irg)
{
- be_fec_env_t *env = data;
- const ir_mode *mode;
- int align;
- ir_entity *entity;
- const arm_load_store_attr_t *attr;
+ be_stack_layout_t *stack_layout = be_get_irg_stack_layout(irg);
+ bool at_begin = stack_layout->sp_relative ? true : false;
+ be_fec_env_t *fec_env = be_new_frame_entity_coalescer(irg);
- if (be_is_Reload(node) && be_get_frame_entity(node) == NULL) {
- mode = get_irn_mode(node);
- align = get_mode_size_bytes(mode);
- be_node_needs_frame_entity(env, node, mode, align);
- return;
- }
+ irg_walk_graph(irg, NULL, arm_collect_frame_entity_nodes, fec_env);
+ be_assign_entities(fec_env, arm_set_frame_entity, at_begin);
+ be_free_frame_entity_coalescer(fec_env);
- switch (get_arm_irn_opcode(node)) {
- case iro_arm_Ldf:
- case iro_arm_Ldr:
- break;
- default:
- return;
- }
+ irg_block_walk_graph(irg, NULL, arm_after_ra_walker, NULL);
- attr = get_arm_load_store_attr_const(node);
- entity = attr->entity;
- mode = attr->load_store_mode;
- align = get_mode_size_bytes(mode);
- if (entity != NULL)
- return;
- if (!attr->is_frame_entity)
- return;
- be_node_needs_frame_entity(env, node, mode, align);
-}
+ /* fix stack entity offsets */
+ be_abi_fix_stack_nodes(irg);
+ be_abi_fix_stack_bias(irg);
-static void arm_set_frame_entity(ir_node *node, ir_entity *entity)
-{
- if (is_be_node(node)) {
- be_node_set_frame_entity(node, entity);
- } else {
- arm_load_store_attr_t *attr = get_arm_load_store_attr(node);
- attr->entity = entity;
- }
+ /* do peephole optimizations and fix stack offsets */
+ arm_peephole_optimization(irg);
}
-static void arm_after_ra(ir_graph *irg)
+static void arm_before_ra(ir_graph *irg)
{
- be_fec_env_t *fec_env = be_new_frame_entity_coalescer(irg);
-
- irg_walk_graph(irg, NULL, arm_collect_frame_entity_nodes, fec_env);
- be_assign_entities(fec_env, arm_set_frame_entity);
- be_free_frame_entity_coalescer(fec_env);
-
- irg_block_walk_graph(irg, NULL, arm_after_ra_walker, NULL);
+ be_sched_fix_flags(irg, &arm_reg_classes[CLASS_arm_flags], NULL, NULL);
}
/**
rt_iDiv.mem_proj_nr = pn_Div_M;
rt_iDiv.regular_proj_nr = pn_Div_X_regular;
rt_iDiv.exc_proj_nr = pn_Div_X_except;
- rt_iDiv.exc_mem_proj_nr = pn_Div_M;
rt_iDiv.res_proj_nr = pn_Div_res;
add_entity_linkage(rt_iDiv.ent, IR_LINKAGE_CONSTANT);
rt_uDiv.mem_proj_nr = pn_Div_M;
rt_uDiv.regular_proj_nr = pn_Div_X_regular;
rt_uDiv.exc_proj_nr = pn_Div_X_except;
- rt_uDiv.exc_mem_proj_nr = pn_Div_M;
rt_uDiv.res_proj_nr = pn_Div_res;
set_entity_visibility(rt_uDiv.ent, ir_visibility_external);
rt_iMod.mem_proj_nr = pn_Mod_M;
rt_iMod.regular_proj_nr = pn_Mod_X_regular;
rt_iMod.exc_proj_nr = pn_Mod_X_except;
- rt_iMod.exc_mem_proj_nr = pn_Mod_M;
rt_iMod.res_proj_nr = pn_Mod_res;
set_entity_visibility(rt_iMod.ent, ir_visibility_external);
rt_uMod.mem_proj_nr = pn_Mod_M;
rt_uMod.regular_proj_nr = pn_Mod_X_regular;
rt_uMod.exc_proj_nr = pn_Mod_X_except;
- rt_uMod.exc_mem_proj_nr = pn_Mod_M;
rt_uMod.res_proj_nr = pn_Mod_res;
set_entity_visibility(rt_uMod.ent, ir_visibility_external);
lower_intrinsics(records, n_records, /*part_block_used=*/0);
}
-const arch_isa_if_t arm_isa_if;
+extern const arch_isa_if_t arm_isa_if;
static arm_isa_t arm_isa_template = {
{
&arm_isa_if, /* isa interface */
- &arm_gp_regs[REG_SP], /* stack pointer */
- &arm_gp_regs[REG_R11], /* base pointer */
+ N_ARM_REGISTERS,
+ arm_registers,
+ N_ARM_CLASSES,
+ arm_reg_classes,
+ &arm_registers[REG_SP], /* stack pointer */
+ &arm_registers[REG_R11], /* base pointer */
&arm_reg_classes[CLASS_arm_gp], /* static link pointer class */
- -1, /* stack direction */
2, /* power of two stack alignment for calls, 2^2 == 4 */
NULL, /* main environment */
7, /* spill costs */
/**
* Initializes the backend ISA and opens the output file.
*/
-static arch_env_t *arm_init(FILE *file_handle)
+static arch_env_t *arm_init(const be_main_env_t *env)
{
- static int inited = 0;
- arm_isa_t *isa;
-
- if (inited)
- return NULL;
-
- isa = XMALLOC(arm_isa_t);
- memcpy(isa, &arm_isa_template, sizeof(*isa));
+ arm_isa_t *isa = XMALLOC(arm_isa_t);
+ *isa = arm_isa_template;
arm_register_init();
- be_emit_init(file_handle);
-
arm_create_opcodes(&arm_irn_ops);
arm_handle_intrinsics();
be_gas_emit_types = false;
- /* needed for the debug support */
- be_gas_emit_switch_section(GAS_SECTION_TEXT);
- be_emit_irprintf("%stext0:\n", be_gas_get_private_prefix());
- be_emit_write_line();
+ be_emit_init(env->file_handle);
+ be_gas_begin_compilation_unit(env);
- inited = 1;
return &isa->base;
}
*/
static void arm_done(void *self)
{
- arm_isa_t *isa = self;
+ arm_isa_t *isa = (arm_isa_t*)self;
- be_gas_emit_decls(isa->base.main_env);
+ be_gas_end_compilation_unit(isa->base.main_env);
be_emit_exit();
free(self);
}
-
-/**
- * Report the number of register classes.
- * If we don't have fp instructions, report only GP
- * here to speed up register allocation (and makes dumps
- * smaller and more readable).
- */
-static unsigned arm_get_n_reg_class(void)
-{
- return N_CLASSES;
-}
-
-/**
- * Return the register class with requested index.
- */
-static const arch_register_class_t *arm_get_reg_class(unsigned i)
-{
- assert(i < N_CLASSES);
- return &arm_reg_classes[i];
-}
-
-/**
- * Get the register class which shall be used to store a value of a given mode.
- * @param self The this pointer.
- * @param mode The mode in question.
- * @return A register class which can hold values of the given mode.
- */
-static const arch_register_class_t *arm_get_reg_class_for_mode(const ir_mode *mode)
-{
- if (mode_is_float(mode))
- return &arm_reg_classes[CLASS_arm_fpa];
- else
- return &arm_reg_classes[CLASS_arm_gp];
-}
-
-/**
- * Returns the necessary byte alignment for storing a register of given class.
- */
-static int arm_get_reg_class_alignment(const arch_register_class_t *cls)
-{
- (void) cls;
- /* ARM is a 32 bit CPU, no need for other alignment */
- return 4;
-}
-
-/**
- * Return irp irgs in the desired order.
- */
-static ir_graph **arm_get_irg_list(const void *self, ir_graph ***irg_list)
-{
- (void) self;
- (void) irg_list;
- return NULL;
-}
-
/**
* Allows or disallows the creation of Psi nodes for the given Phi nodes.
* @return 1 if allowed, 0 otherwise
(void) sel;
(void) mux_false;
(void) mux_true;
-
- return 0;
+ return false;
}
static asm_constraint_flags_t arm_parse_asm_constraint(const char **c)
static void arm_lower_for_target(void)
{
- int i;
- int n_irgs = get_irp_n_irgs();
+ size_t i, n_irgs = get_irp_n_irgs();
+
+ /* lower compound param handling */
+ lower_calls_with_compounds(LF_RETURN_HIDDEN);
+
+ for (i = 0; i < n_irgs; ++i) {
+ ir_graph *irg = get_irp_irg(i);
+ lower_switch(irg, 4, 256, false);
+ }
for (i = 0; i < n_irgs; ++i) {
ir_graph *irg = get_irp_irg(i);
- lower_switch(irg, 256, true);
+ /* Turn all small CopyBs into loads/stores and all bigger CopyBs into
+ * memcpy calls.
+ * TODO: These constants need arm-specific tuning. */
+ lower_CopyB(irg, 31, 32, false);
}
}
{
static ir_settings_arch_dep_t ad = {
1, /* allow subs */
- 1, /* Muls are fast enough on ARM but ... */
+ 1, /* Muls are fast enough on ARM but ... */
31, /* ... one shift would be possible better */
NULL, /* no evaluator function */
0, /* SMUL is needed, only in Arch M */
0, /* don't support inline assembler yet */
1, /* support Rotl nodes */
1, /* big endian */
- arm_lower_for_target, /* lowering function */
+ 1, /* modulo shift efficient */
+ 0, /* non-modulo shift not efficient */
&ad, /* will be set later */
arm_is_mux_allowed, /* allow_ifconv function */
+ 32, /* machine size */
NULL, /* float arithmetic mode (TODO) */
+ 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 */
const arch_isa_if_t arm_isa_if = {
arm_init,
+ arm_lower_for_target,
arm_done,
NULL, /* handle_intrinsics */
- arm_get_n_reg_class,
- arm_get_reg_class,
- arm_get_reg_class_for_mode,
NULL,
- arm_get_reg_class_alignment,
arm_get_libfirm_params,
- arm_get_irg_list,
NULL, /* mark remat */
arm_parse_asm_constraint,
arm_is_valid_clobber,
NULL, /* before_abi */
arm_prepare_graph,
arm_before_ra,
- arm_after_ra,
arm_finish_irg,
arm_gen_routine,
+ NULL, /* register_saved_by */
+ be_new_spill,
+ be_new_reload,
};
-BE_REGISTER_MODULE_CONSTRUCTOR(be_init_arch_arm);
+BE_REGISTER_MODULE_CONSTRUCTOR(be_init_arch_arm)
void be_init_arch_arm(void)
{
lc_opt_entry_t *be_grp = lc_opt_get_grp(firm_opt_get_root(), "be");
projects / libfirm / blobdiff