#include "bearch_sparc_t.h"
#include "gen_sparc_regalloc_if.h"
#include "sparc_new_nodes.h"
+#include "sparc_transform.h"
#include "irprog.h"
#include "irgmod.h"
+#include "ircons.h"
+#include "irgwalk.h"
#include "../bepeephole.h"
#include "../benode.h"
#include "../besched.h"
+#include "../bespillslots.h"
+#include "../bestack.h"
+#include "../beirgmod.h"
+
+static void kill_unused_stacknodes(ir_node *node)
+{
+ if (get_irn_n_edges(node) > 0)
+ return;
+
+ if (be_is_IncSP(node)) {
+ sched_remove(node);
+ kill_node(node);
+ } else if (is_Phi(node)) {
+ int arity = get_irn_arity(node);
+ ir_node **ins = ALLOCAN(ir_node*, arity);
+ int i;
+ sched_remove(node);
+ memcpy(ins, get_irn_in(node), arity*sizeof(ins[0]));
+ kill_node(node);
+
+ for (i = 0; i < arity; ++i)
+ kill_unused_stacknodes(ins[i]);
+ }
+}
+
+static void introduce_epilog(ir_node *ret)
+{
+ const arch_register_t *sp_reg = &sparc_registers[REG_SP];
+ ir_graph *irg = get_irn_irg(ret);
+ be_stack_layout_t *layout = be_get_irg_stack_layout(irg);
+ ir_node *block = get_nodes_block(ret);
+ ir_type *frame_type = get_irg_frame_type(irg);
+ unsigned frame_size = get_type_size_bytes(frame_type);
+ int sp_idx = be_find_return_reg_input(ret, sp_reg);
+ ir_node *sp = get_irn_n(ret, sp_idx);
+
+ if (!layout->sp_relative) {
+ const arch_register_t *fp_reg = &sparc_registers[REG_FRAME_POINTER];
+ ir_node *fp = be_get_initial_reg_value(irg, fp_reg);
+ ir_node *restore = new_bd_sparc_RestoreZero(NULL, block, fp);
+ sched_add_before(ret, restore);
+ arch_set_irn_register(restore, sp_reg);
+ set_irn_n(ret, sp_idx, restore);
+
+ kill_unused_stacknodes(sp);
+ } else {
+ ir_node *incsp = be_new_IncSP(sp_reg, block, sp, -frame_size, 0);
+ set_irn_n(ret, sp_idx, incsp);
+ sched_add_before(ret, incsp);
+ }
+}
+
+void sparc_introduce_prolog_epilog(ir_graph *irg)
+{
+ const arch_register_t *sp_reg = &sparc_registers[REG_SP];
+ ir_node *start = get_irg_start(irg);
+ be_stack_layout_t *layout = be_get_irg_stack_layout(irg);
+ ir_node *block = get_nodes_block(start);
+ ir_node *initial_sp = be_get_initial_reg_value(irg, sp_reg);
+ ir_node *sp = initial_sp;
+ ir_node *schedpoint = start;
+ ir_type *frame_type = get_irg_frame_type(irg);
+ unsigned frame_size = get_type_size_bytes(frame_type);
+
+ /* introduce epilog for every return node */
+ {
+ ir_node *end_block = get_irg_end_block(irg);
+ int arity = get_irn_arity(end_block);
+ int i;
+
+ for (i = 0; i < arity; ++i) {
+ ir_node *ret = get_irn_n(end_block, i);
+ assert(is_sparc_Return(ret));
+ introduce_epilog(ret);
+ }
+ }
+
+ while (be_is_Keep(sched_next(schedpoint)))
+ schedpoint = sched_next(schedpoint);
+
+ if (!layout->sp_relative) {
+ ir_node *save = new_bd_sparc_Save_imm(NULL, block, sp, NULL,
+ -SPARC_MIN_STACKSIZE-frame_size);
+ arch_set_irn_register(save, sp_reg);
+ sched_add_after(schedpoint, save);
+ schedpoint = save;
+
+ edges_reroute(initial_sp, save);
+ set_irn_n(save, n_sparc_Save_stack, initial_sp);
+
+ /* we still need the Save even if noone is explicitely using the
+ * value. (TODO: this isn't 100% correct yet, something at the end of
+ * the function should hold the Save, even if we use a restore
+ * which just overrides it instead of using the value)
+ */
+ if (get_irn_n_edges(save) == 0) {
+ ir_node *in[] = { save };
+ ir_node *keep = be_new_Keep(block, 1, in);
+ sched_add_after(schedpoint, keep);
+ }
+ } else {
+ ir_node *incsp = be_new_IncSP(sp_reg, block, sp, frame_size, 0);
+ edges_reroute(initial_sp, incsp);
+ be_set_IncSP_pred(incsp, sp);
+ sched_add_after(schedpoint, incsp);
+ }
+}
static void finish_sparc_Save(ir_node *node)
{
dbg_info *dbgi = get_irn_dbg_info(node);
ir_node *block = get_nodes_block(node);
int sign = 1;
- bool sp_relative
- = arch_get_irn_register(base) == &sparc_registers[REG_SP];
- if (sp_relative) {
- offset += SPARC_MIN_STACKSIZE;
- }
if (offset < 0) {
sign = -1;
attr->immediate_value = sign*offset;
}
-static void finish_sparc_LdSt(ir_node *node)
-{
- sparc_load_store_attr_t *attr = get_sparc_load_store_attr(node);
- if (attr->is_frame_entity) {
- ir_node *base;
- bool sp_relative;
- if (is_sparc_Ld(node)) {
- base = get_irn_n(node, n_sparc_Ld_ptr);
- } else {
- assert(is_sparc_St(node));
- base = get_irn_n(node, n_sparc_St_ptr);
- }
- sp_relative = arch_get_irn_register(base) == &sparc_registers[REG_SP];
- if (sp_relative)
- attr->base.immediate_value += SPARC_MIN_STACKSIZE;
- }
-}
-
static void peephole_be_IncSP(ir_node *node)
{
ir_node *pred;
(void) node;
}
+static void finish_sparc_Return(ir_node *node)
+{
+ ir_node *schedpoint = node;
+ ir_node *restore;
+ /* see that there is no code between Return and restore, if there is move
+ * it in front of the restore */
+ while (true) {
+ if (!sched_has_prev(schedpoint))
+ return;
+ schedpoint = sched_prev(schedpoint);
+ if (is_sparc_Restore(schedpoint) || is_sparc_RestoreZero(schedpoint))
+ break;
+ }
+ restore = schedpoint;
+ schedpoint = sched_prev(node);
+ /* move all code between return and restore up */
+ while (schedpoint != restore) {
+ ir_node *next_schedpoint = sched_prev(schedpoint);
+ sched_remove(schedpoint);
+ sched_add_before(restore, schedpoint);
+ schedpoint = next_schedpoint;
+ }
+}
+
static void register_peephole_optimisation(ir_op *op, peephole_opt_func func)
{
assert(op->ops.generic == NULL);
op->ops.generic = (op_func) func;
}
+static void sparc_collect_frame_entity_nodes(ir_node *node, void *data)
+{
+ be_fec_env_t *env = (be_fec_env_t*)data;
+ const ir_mode *mode;
+ int align;
+ ir_entity *entity;
+ const sparc_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;
+ }
+
+ if (!is_sparc_Ld(node) && !is_sparc_Ldf(node))
+ return;
+
+ attr = get_sparc_load_store_attr_const(node);
+ entity = attr->base.immediate_value_entity;
+ mode = attr->load_store_mode;
+ if (entity != NULL)
+ return;
+ if (!attr->is_frame_entity)
+ return;
+ if (arch_get_irn_flags(node) & sparc_arch_irn_flag_needs_64bit_spillslot)
+ mode = mode_Lu;
+ align = get_mode_size_bytes(mode);
+ be_node_needs_frame_entity(env, node, mode, align);
+}
+
+static void sparc_set_frame_entity(ir_node *node, ir_entity *entity)
+{
+ if (is_be_node(node)) {
+ be_node_set_frame_entity(node, entity);
+ } else {
+ /* we only say be_node_needs_frame_entity on nodes with load_store
+ * attributes, so this should be fine */
+ sparc_load_store_attr_t *attr = get_sparc_load_store_attr(node);
+ assert(attr->is_frame_entity);
+ assert(attr->base.immediate_value_entity == NULL);
+ attr->base.immediate_value_entity = entity;
+ }
+}
+
void sparc_finish(ir_graph *irg)
{
+ 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);
+
+ irg_walk_graph(irg, NULL, sparc_collect_frame_entity_nodes, fec_env);
+ be_assign_entities(fec_env, sparc_set_frame_entity, at_begin);
+ be_free_frame_entity_coalescer(fec_env);
+
+ sparc_introduce_prolog_epilog(irg);
+
+ /* fix stack entity offsets */
+ be_abi_fix_stack_nodes(irg);
+ sparc_fix_stack_bias(irg);
+
+ /* perform peephole optimizations */
clear_irp_opcodes_generic_func();
register_peephole_optimisation(op_be_IncSP, peephole_be_IncSP);
register_peephole_optimisation(op_sparc_FrameAddr, peephole_sparc_FrameAddr);
be_peephole_opt(irg);
+ /* perform legalizations (mostly fix nodes with too big immediates) */
clear_irp_opcodes_generic_func();
register_peephole_optimisation(op_be_IncSP, finish_be_IncSP);
- register_peephole_optimisation(op_sparc_Save, finish_sparc_Save);
register_peephole_optimisation(op_sparc_FrameAddr, finish_sparc_FrameAddr);
- register_peephole_optimisation(op_sparc_Ld, finish_sparc_LdSt);
- register_peephole_optimisation(op_sparc_St, finish_sparc_LdSt);
+ register_peephole_optimisation(op_sparc_Return, finish_sparc_Return);
+ register_peephole_optimisation(op_sparc_Save, finish_sparc_Save);
be_peephole_opt(irg);
+
+ be_remove_dead_nodes_from_schedule(irg);
}