/**
* @file
* @brief code selection (transform FIRM into SPARC FIRM)
+ * @author Hannes Rapp, Matthias Braun
* @version $Id$
*/
#include "config.h"
#include <stdint.h>
+#include <stdbool.h>
#include "irnode_t.h"
#include "irgraph_t.h"
static beabi_helper_env_t *abihelper;
static const arch_register_t *sp_reg = &sparc_registers[REG_SP];
static const arch_register_t *fp_reg = &sparc_registers[REG_FRAME_POINTER];
-static calling_convention_t *cconv = NULL;
+static calling_convention_t *current_cconv = NULL;
static ir_mode *mode_gp;
+static ir_mode *mode_flags;
static ir_mode *mode_fp;
static ir_mode *mode_fp2;
//static ir_mode *mode_fp4;
static pmap *node_to_stack;
-static inline int mode_needs_gp_reg(ir_mode *mode)
+static inline bool mode_needs_gp_reg(ir_mode *mode)
{
- return mode_is_int(mode) || mode_is_reference(mode);
+ if (mode_is_int(mode) || mode_is_reference(mode)) {
+ /* we should only see 32bit code */
+ assert(get_mode_size_bits(mode) <= 32);
+ return true;
+ }
+ return false;
}
/**
typedef ir_node* (*new_binop_imm_func) (dbg_info *dbgi, ir_node *block, ir_node *op1, ir_entity *entity, int32_t immediate);
typedef ir_node* (*new_unop_fp_func) (dbg_info *dbgi, ir_node *block, ir_node *op1, ir_mode *mode);
-static bool is_value_imm_encodeable(int32_t value)
-{
- return -4096 <= value && value <= 4095;
-}
-
/**
* checks if a node's value can be encoded as a immediate
*/
return false;
value = get_tarval_long(get_Const_tarval(node));
- return is_value_imm_encodeable(value);
+ return sparc_is_value_imm_encodeable(value);
}
static bool needs_extension(ir_mode *mode)
}
mode1 = get_irn_mode(op1);
mode2 = get_irn_mode(op2);
+ /* we shouldn't see 64bit code */
+ assert(get_mode_size_bits(mode1) <= 32);
+ assert(get_mode_size_bits(mode2) <= 32);
if (is_imm_encodeable(op2)) {
- ir_node *new_op1 = be_transform_node(op1);
int32_t immediate = get_tarval_long(get_Const_tarval(op2));
+ new_op1 = be_transform_node(op1);
if (! (flags & MATCH_MODE_NEUTRAL) && needs_extension(mode1)) {
new_op1 = gen_extension(dbgi, block, new_op1, mode1);
}
panic("unsupported mode %+F for float op", mode);
}
+typedef ir_node* (*new_binopx_imm_func)(dbg_info *dbgi, ir_node *block,
+ ir_node *op1, ir_node *flags,
+ ir_entity *imm_entity, int32_t imm);
+
+typedef ir_node* (*new_binopx_reg_func)(dbg_info *dbgi, ir_node *block,
+ ir_node *op1, ir_node *op2,
+ ir_node *flags);
+
+static ir_node *gen_helper_binopx(ir_node *node, match_flags_t match_flags,
+ new_binopx_reg_func new_binopx_reg,
+ new_binopx_imm_func new_binopx_imm)
+{
+ dbg_info *dbgi = get_irn_dbg_info(node);
+ ir_node *block = be_transform_node(get_nodes_block(node));
+ ir_node *op1 = get_irn_n(node, 0);
+ ir_node *op2 = get_irn_n(node, 1);
+ ir_node *flags = get_irn_n(node, 2);
+ ir_node *new_flags = be_transform_node(flags);
+ ir_node *new_op1;
+ ir_node *new_op2;
+
+ /* only support for mode-neutral implemented so far */
+ assert(match_flags & MATCH_MODE_NEUTRAL);
+
+ if (is_imm_encodeable(op2)) {
+ int32_t immediate = get_tarval_long(get_Const_tarval(op2));
+ new_op1 = be_transform_node(op1);
+ return new_binopx_imm(dbgi, block, new_op1, new_flags, NULL, immediate);
+ }
+ new_op2 = be_transform_node(op2);
+ if ((match_flags & MATCH_COMMUTATIVE) && is_imm_encodeable(op1)) {
+ int32_t immediate = get_tarval_long(get_Const_tarval(op1));
+ return new_binopx_imm(dbgi, block, new_op2, new_flags, NULL, immediate);
+ }
+ new_op1 = be_transform_node(op1);
+ return new_binopx_reg(dbgi, block, new_op1, new_op2, new_flags);
+
+}
+
static ir_node *get_g0(void)
{
return be_prolog_get_reg_value(abihelper, &sparc_registers[REG_G0]);
ptr2 = be_transform_node(get_Add_right(base));
base = be_transform_node(get_Add_left(base));
} else {
- if (is_value_imm_encodeable(offset)) {
+ if (sparc_is_value_imm_encodeable(offset)) {
base = be_transform_node(base);
} else {
base = be_transform_node(ptr);
new_bd_sparc_Add_reg, new_bd_sparc_Add_imm);
}
+static ir_node *gen_AddCC_t(ir_node *node)
+{
+ return gen_helper_binop(node, MATCH_COMMUTATIVE | MATCH_MODE_NEUTRAL,
+ new_bd_sparc_AddCC_reg, new_bd_sparc_AddCC_imm);
+}
+
+static ir_node *gen_Proj_AddCC_t(ir_node *node)
+{
+ long pn = get_Proj_proj(node);
+ ir_node *pred = get_Proj_pred(node);
+ ir_node *new_pred = be_transform_node(pred);
+
+ switch (pn) {
+ case pn_sparc_AddCC_t_res:
+ return new_r_Proj(new_pred, mode_gp, pn_sparc_AddCC_res);
+ case pn_sparc_AddCC_t_flags:
+ return new_r_Proj(new_pred, mode_flags, pn_sparc_AddCC_flags);
+ default:
+ panic("Invalid AddCC_t proj found");
+ }
+}
+
+static ir_node *gen_AddX_t(ir_node *node)
+{
+ return gen_helper_binopx(node, MATCH_COMMUTATIVE | MATCH_MODE_NEUTRAL,
+ new_bd_sparc_AddX_reg, new_bd_sparc_AddX_imm);
+}
+
/**
* Creates an sparc Sub.
*
new_bd_sparc_fsub_d, new_bd_sparc_fsub_q);
}
- return gen_helper_binop(node, MATCH_NONE, new_bd_sparc_Sub_reg, new_bd_sparc_Sub_imm);
+ return gen_helper_binop(node, MATCH_MODE_NEUTRAL,
+ new_bd_sparc_Sub_reg, new_bd_sparc_Sub_imm);
+}
+
+static ir_node *gen_SubCC_t(ir_node *node)
+{
+ return gen_helper_binop(node, MATCH_MODE_NEUTRAL,
+ new_bd_sparc_SubCC_reg, new_bd_sparc_SubCC_imm);
+}
+
+static ir_node *gen_Proj_SubCC_t(ir_node *node)
+{
+ long pn = get_Proj_proj(node);
+ ir_node *pred = get_Proj_pred(node);
+ ir_node *new_pred = be_transform_node(pred);
+
+ switch (pn) {
+ case pn_sparc_SubCC_t_res:
+ return new_r_Proj(new_pred, mode_gp, pn_sparc_SubCC_res);
+ case pn_sparc_SubCC_t_flags:
+ return new_r_Proj(new_pred, mode_flags, pn_sparc_SubCC_flags);
+ default:
+ panic("Invalid SubCC_t proj found");
+ }
+}
+
+static ir_node *gen_SubX_t(ir_node *node)
+{
+ return gen_helper_binopx(node, MATCH_MODE_NEUTRAL,
+ new_bd_sparc_SubX_reg, new_bd_sparc_SubX_imm);
}
static ir_node *create_ldf(dbg_info *dbgi, ir_node *block, ir_node *ptr,
ir_node *new_load = NULL;
address_t address;
+ if (get_Load_unaligned(node) == align_non_aligned) {
+ panic("sparc: transformation of unaligned Loads not implemented yet");
+ }
+
if (mode_is_float(mode)) {
match_address(ptr, &address, false);
new_load = create_ldf(dbgi, block, address.ptr, new_mem, mode,
ir_node *new_store = NULL;
address_t address;
+ if (get_Store_unaligned(node) == align_non_aligned) {
+ panic("sparc: transformation of unaligned Stores not implemented yet");
+ }
+
if (mode_is_float(mode)) {
/* TODO: variants with reg+reg address mode */
match_address(ptr, &address, false);
new_store = create_stf(dbgi, block, new_val, address.ptr, new_mem,
mode, address.entity, address.offset, false);
} else {
+ assert(get_mode_size_bits(mode) <= 32);
match_address(ptr, &address, true);
if (address.ptr2 != NULL) {
assert(address.entity == NULL && address.offset == 0);
return res;
}
-#if 0
-static ir_node *gen_Abs(ir_node *node)
-{
- ir_mode *const mode = get_irn_mode(node);
-
- if (mode_is_float(mode)) {
- return gen_helper_unfpop(node, mode, new_bd_sparc_fabs_s,
- new_bd_sparc_fabs_d, new_bd_sparc_fabs_q);
- } else {
- ir_node *const block = be_transform_node(get_nodes_block(node));
- dbg_info *const dbgi = get_irn_dbg_info(node);
- ir_node *const op = get_Abs_op(node);
- ir_node *const new_op = be_transform_node(op);
- ir_node *const sra = new_bd_sparc_Sra_imm(dbgi, block, new_op, NULL, 31);
- ir_node *const xor = new_bd_sparc_Xor_reg(dbgi, block, new_op, sra);
- ir_node *const sub = new_bd_sparc_Sub_reg(dbgi, block, xor, sra);
- return sub;
- }
-}
-#endif
-
/**
* Transforms a Not node.
*
{
ir_entity *entity = create_float_const_entity(tv);
ir_node *hi = new_bd_sparc_SetHi(dbgi, block, entity, 0);
- ir_node *mem = new_r_NoMem(current_ir_graph);
+ ir_node *mem = get_irg_no_mem(current_ir_graph);
ir_mode *mode = get_tarval_mode(tv);
ir_node *new_op
= create_ldf(dbgi, block, hi, mem, mode, entity, 0, false);
- ir_node *proj = new_Proj(new_op, mode, pn_sparc_Ldf_res);
- be_dep_on_frame(hi);
+ ir_node *proj = new_r_Proj(new_op, mode, pn_sparc_Ldf_res);
set_irn_pinned(new_op, op_pin_state_floats);
return proj;
value = get_tarval_long(tv);
if (value == 0) {
return get_g0();
- } else if (-4096 <= value && value <= 4095) {
+ } else if (sparc_is_value_imm_encodeable(value)) {
return new_bd_sparc_Or_imm(dbgi, block, get_g0(), NULL, value);
} else {
ir_node *hi = new_bd_sparc_SetHi(dbgi, block, NULL, value);
- be_dep_on_frame(hi);
if ((value & 0x3ff) != 0) {
return new_bd_sparc_Or_imm(dbgi, block, hi, NULL, value & 0x3ff);
} else {
static ir_mode *get_cmp_mode(ir_node *b_value)
{
- ir_node *pred;
ir_node *op;
- if (!is_Proj(b_value))
- panic("can't determine cond signednes");
- pred = get_Proj_pred(b_value);
- if (!is_Cmp(pred))
+ if (!is_Cmp(b_value))
panic("can't determine cond signednes (no cmp)");
- op = get_Cmp_left(pred);
+ op = get_Cmp_left(b_value);
return get_irn_mode(op);
}
{
ir_node *hi = new_bd_sparc_SetHi(dbgi, block, entity, offset);
ir_node *low = new_bd_sparc_Or_imm(dbgi, block, hi, entity, offset);
- be_dep_on_frame(hi);
+
+ if (get_entity_owner(entity) == get_tls_type())
+ panic("thread local storage not supported yet in sparc backend");
return low;
}
long default_pn = get_Cond_default_proj(node);
ir_entity *entity;
ir_node *table_address;
- ir_node *index;
+ ir_node *idx;
ir_node *load;
ir_node *address;
set_entity_visibility(entity, ir_visibility_private);
add_entity_linkage(entity, IR_LINKAGE_CONSTANT);
- /* TODO: this code does not construct code to check for access
- * out-of bounds of the jumptable yet. I think we should put this stuff
- * into the switch_lowering phase to get some additional optimisations
- * done. */
-
/* construct base address */
table_address = make_address(dbgi, block, entity, 0);
/* scale index */
- index = new_bd_sparc_Sll_imm(dbgi, block, new_selector, NULL, 2);
+ idx = new_bd_sparc_Sll_imm(dbgi, block, new_selector, NULL, 2);
/* load from jumptable */
- load = new_bd_sparc_Ld_reg(dbgi, block, table_address, index,
- new_r_NoMem(current_ir_graph),
+ load = new_bd_sparc_Ld_reg(dbgi, block, table_address, idx,
+ get_irg_no_mem(current_ir_graph),
mode_gp);
address = new_r_Proj(load, mode_gp, pn_sparc_Ld_res);
static ir_node *gen_Cond(ir_node *node)
{
- ir_node *selector = get_Cond_selector(node);
- ir_mode *mode = get_irn_mode(selector);
- ir_mode *cmp_mode;
- ir_node *block;
- ir_node *flag_node;
- bool is_unsigned;
- pn_Cmp pnc;
- dbg_info *dbgi;
+ ir_node *selector = get_Cond_selector(node);
+ ir_mode *mode = get_irn_mode(selector);
+ ir_mode *cmp_mode;
+ ir_node *block;
+ ir_node *flag_node;
+ bool is_unsigned;
+ ir_relation relation;
+ dbg_info *dbgi;
// switch/case jumps
if (mode != mode_b) {
}
// regular if/else jumps
- assert(is_Proj(selector));
- assert(is_Cmp(get_Proj_pred(selector)));
+ assert(is_Cmp(selector));
cmp_mode = get_cmp_mode(selector);
block = be_transform_node(get_nodes_block(node));
dbgi = get_irn_dbg_info(node);
- flag_node = be_transform_node(get_Proj_pred(selector));
- pnc = get_Proj_pn_cmp(selector);
+ flag_node = be_transform_node(selector);
+ relation = get_Cmp_relation(selector);
is_unsigned = !mode_is_signed(cmp_mode);
if (mode_is_float(cmp_mode)) {
assert(!is_unsigned);
- return new_bd_sparc_fbfcc(dbgi, block, flag_node, pnc);
+ return new_bd_sparc_fbfcc(dbgi, block, flag_node, relation);
} else {
- return new_bd_sparc_Bicc(dbgi, block, flag_node, pnc, is_unsigned);
+ return new_bd_sparc_Bicc(dbgi, block, flag_node, relation, is_unsigned);
}
}
{
ir_graph *irg = get_irn_irg(block);
ir_node *sp = get_irg_frame(irg);
- ir_node *nomem = new_r_NoMem(irg);
+ ir_node *nomem = get_irg_no_mem(irg);
ir_node *stf = create_stf(dbgi, block, ftoi, sp, nomem, src_mode,
NULL, 0, true);
ir_node *ld = new_bd_sparc_Ld_imm(dbgi, block, sp, stf, mode_gp,
{
ir_graph *irg = get_irn_irg(block);
ir_node *sp = get_irg_frame(irg);
- ir_node *nomem = new_r_NoMem(irg);
+ ir_node *nomem = get_irg_no_mem(irg);
ir_node *st = new_bd_sparc_St_imm(dbgi, block, op, sp, nomem,
mode_gp, NULL, 0, true);
ir_node *ldf = new_bd_sparc_Ldf_s(dbgi, block, sp, st, mode_fp,
ir_node *op = get_Conv_op(node);
ir_mode *src_mode = get_irn_mode(op);
ir_mode *dst_mode = get_irn_mode(node);
- dbg_info *dbg = get_irn_dbg_info(node);
+ dbg_info *dbgi = get_irn_dbg_info(node);
ir_node *new_op;
int src_bits = get_mode_size_bits(src_mode);
if (mode_is_float(src_mode)) {
if (mode_is_float(dst_mode)) {
/* float -> float conv */
- return create_fftof(dbg, block, new_op, src_mode, dst_mode);
+ return create_fftof(dbgi, block, new_op, src_mode, dst_mode);
} else {
/* float -> int conv */
if (!mode_is_signed(dst_mode))
panic("float to unsigned not implemented yet");
- return create_ftoi(dbg, block, new_op, src_mode);
+ return create_ftoi(dbgi, block, new_op, src_mode);
}
} else {
/* int -> float conv */
if (src_bits < 32) {
- new_op = gen_extension(dbg, block, new_op, src_mode);
+ new_op = gen_extension(dbgi, block, new_op, src_mode);
} else if (src_bits == 32 && !mode_is_signed(src_mode)) {
panic("unsigned to float not lowered!");
}
- return create_itof(dbg, block, new_op, dst_mode);
+ return create_itof(dbgi, block, new_op, dst_mode);
}
} else if (src_mode == mode_b) {
panic("ConvB not lowered %+F", node);
}
if (mode_is_signed(min_mode)) {
- return gen_sign_extension(dbg, block, new_op, min_bits);
+ return gen_sign_extension(dbgi, block, new_op, min_bits);
} else {
- return gen_zero_extension(dbg, block, new_op, min_bits);
+ return gen_zero_extension(dbgi, block, new_op, min_bits);
}
}
}
static ir_type *between_type = NULL;
static ir_type *between_type0 = NULL;
- if (cconv->omit_fp) {
+ if (current_cconv->omit_fp) {
if (between_type0 == NULL) {
between_type0
= new_type_class(new_id_from_str("sparc_between_type"));
int n_params;
/* calling conventions must be decided by now */
- assert(cconv != NULL);
+ assert(current_cconv != NULL);
/* construct argument type */
arg_type = new_type_struct(id_mangle_u(get_entity_ident(entity), new_id_from_chars("arg_type", 8)));
n_params = get_method_n_params(function_type);
for (p = 0; p < n_params; ++p) {
- reg_or_stackslot_t *param = &cconv->parameters[p];
+ reg_or_stackslot_t *param = ¤t_cconv->parameters[p];
char buf[128];
ident *id;
layout->arg_type = arg_type;
layout->initial_offset = 0;
layout->initial_bias = 0;
- layout->stack_dir = -1;
- layout->sp_relative = cconv->omit_fp;
+ layout->sp_relative = current_cconv->omit_fp;
assert(N_FRAME_TYPES == 3);
layout->order[0] = layout->frame_type;
}
/**
- * transform the start node to the prolog code + initial barrier
+ * transform the start node to the prolog code
*/
static ir_node *gen_Start(ir_node *node)
{
ir_node *block = get_nodes_block(node);
ir_node *new_block = be_transform_node(block);
dbg_info *dbgi = get_irn_dbg_info(node);
- ir_node *mem;
ir_node *start;
- ir_node *sp;
- ir_node *barrier;
size_t i;
/* stackpointer is important at function prolog */
arch_register_req_type_ignore);
/* function parameters in registers */
for (i = 0; i < get_method_n_params(function_type); ++i) {
- const reg_or_stackslot_t *param = &cconv->parameters[i];
+ const reg_or_stackslot_t *param = ¤t_cconv->parameters[i];
if (param->reg0 != NULL) {
be_prolog_add_reg(abihelper, param->reg0,
arch_register_req_type_none);
}
/* we need the values of the callee saves (Note: non omit-fp mode has no
* callee saves) */
- if (cconv->omit_fp) {
+ if (current_cconv->omit_fp) {
size_t n_callee_saves = ARRAY_SIZE(omit_fp_callee_saves);
size_t c;
for (c = 0; c < n_callee_saves; ++c) {
}
start = be_prolog_create_start(abihelper, dbgi, new_block);
- mem = be_prolog_get_memory(abihelper);
- sp = be_prolog_get_reg_value(abihelper, sp_reg);
-
- if (!cconv->omit_fp) {
- ir_node *save = new_bd_sparc_Save_imm(NULL, block, sp, NULL,
- -SPARC_MIN_STACKSIZE);
- sp = new_r_Proj(save, mode_gp, pn_sparc_Save_stack);
- arch_set_irn_register(sp, sp_reg);
- }
-
- sp = be_new_IncSP(sp_reg, new_block, sp, BE_STACK_FRAME_SIZE_EXPAND, 0);
- be_prolog_set_reg_value(abihelper, sp_reg, sp);
- be_prolog_set_memory(abihelper, mem);
-
- barrier = be_prolog_create_barrier(abihelper, new_block);
-
- return barrier;
+ return start;
}
static ir_node *get_stack_pointer_for(ir_node *node)
{
/* get predecessor in stack_order list */
ir_node *stack_pred = be_get_stack_pred(abihelper, node);
- ir_node *stack_pred_transformed;
ir_node *stack;
if (stack_pred == NULL) {
return sp_proj;
}
- stack_pred_transformed = be_transform_node(stack_pred);
- stack = (ir_node*)pmap_get(node_to_stack, stack_pred);
+ be_transform_node(stack_pred);
+ stack = (ir_node*)pmap_get(node_to_stack, stack_pred);
if (stack == NULL) {
return get_stack_pointer_for(stack_pred);
}
*/
static ir_node *gen_Return(ir_node *node)
{
- ir_node *block = get_nodes_block(node);
- ir_node *new_block = be_transform_node(block);
- dbg_info *dbgi = get_irn_dbg_info(node);
- ir_node *mem = get_Return_mem(node);
- ir_node *new_mem = be_transform_node(mem);
- ir_node *sp = get_stack_pointer_for(node);
- size_t n_res = get_Return_n_ress(node);
+ ir_node *block = get_nodes_block(node);
+ ir_node *new_block = be_transform_node(block);
+ dbg_info *dbgi = get_irn_dbg_info(node);
+ ir_node *mem = get_Return_mem(node);
+ ir_node *new_mem = be_transform_node(mem);
+ ir_node *sp = get_stack_pointer_for(node);
+ size_t n_res = get_Return_n_ress(node);
ir_node *bereturn;
size_t i;
for (i = 0; i < n_res; ++i) {
ir_node *res_value = get_Return_res(node, i);
ir_node *new_res_value = be_transform_node(res_value);
- const reg_or_stackslot_t *slot = &cconv->results[i];
+ const reg_or_stackslot_t *slot = ¤t_cconv->results[i];
const arch_register_t *reg = slot->reg0;
assert(slot->reg1 == NULL);
be_epilog_add_reg(abihelper, reg, arch_register_req_type_none,
new_res_value);
}
/* callee saves */
- if (cconv->omit_fp) {
+ if (current_cconv->omit_fp) {
size_t n_callee_saves = ARRAY_SIZE(omit_fp_callee_saves);
- size_t i;
for (i = 0; i < n_callee_saves; ++i) {
const arch_register_t *reg = omit_fp_callee_saves[i];
ir_node *value
}
}
- /* create the barrier before the epilog code */
- be_epilog_create_barrier(abihelper, new_block);
-
- /* epilog code: an incsp */
- sp = be_epilog_get_reg_value(abihelper, sp_reg);
- sp = be_new_IncSP(sp_reg, new_block, sp,
- BE_STACK_FRAME_SIZE_SHRINK, 0);
- be_epilog_set_reg_value(abihelper, sp_reg, sp);
-
- /* we need a restore instruction */
- if (!cconv->omit_fp) {
- ir_node *restore = new_bd_sparc_RestoreZero(NULL, block);
- keep_alive(restore);
- }
-
bereturn = be_epilog_create_return(abihelper, dbgi, new_block);
-
return bereturn;
}
{
ir_graph *irg = current_ir_graph;
ir_node *sp = get_irg_frame(irg);
- ir_node *nomem = new_r_NoMem(irg);
+ ir_node *nomem = get_irg_no_mem(irg);
ir_node *st = new_bd_sparc_St_imm(dbgi, block, value0, sp, nomem,
mode_gp, NULL, 0, true);
ir_mode *mode;
{
ir_graph *irg = current_ir_graph;
ir_node *stack = get_irg_frame(irg);
- ir_node *nomem = new_r_NoMem(irg);
+ ir_node *nomem = get_irg_no_mem(irg);
ir_node *stf = create_stf(dbgi, block, node, stack, nomem, float_mode,
NULL, 0, true);
int bits = get_mode_size_bits(float_mode);
ir_node *new_pred = be_transform_node(pred);
long pn = get_Proj_proj(node);
- assert(is_sparc_SDiv(new_pred) || is_sparc_UDiv(new_pred));
+ assert(is_sparc_SDiv(new_pred) || is_sparc_UDiv(new_pred)
+ || is_sparc_fdiv(new_pred));
assert((int)pn_sparc_SDiv_res == (int)pn_sparc_UDiv_res);
assert((int)pn_sparc_SDiv_M == (int)pn_sparc_UDiv_M);
assert((int)pn_sparc_SDiv_res == (int)pn_sparc_fdiv_res);
static ir_node *get_frame_base(void)
{
- const arch_register_t *reg = cconv->omit_fp ? sp_reg : fp_reg;
+ const arch_register_t *reg = current_cconv->omit_fp ? sp_reg : fp_reg;
return be_prolog_get_reg_value(abihelper, reg);
}
{
ir_node *block = get_nodes_block(node);
ir_node *new_block = be_transform_node(block);
- ir_node *barrier = be_transform_node(get_Proj_pred(node));
long pn = get_Proj_proj(node);
+ /* make sure prolog is constructed */
+ be_transform_node(get_Proj_pred(node));
switch ((pn_Start) pn) {
case pn_Start_X_initial_exec:
/* exchange ProjX with a jump */
return new_bd_sparc_Ba(NULL, new_block);
case pn_Start_M:
- return new_r_Proj(barrier, mode_M, 0);
+ return be_prolog_get_memory(abihelper);
case pn_Start_T_args:
- return barrier;
+ return new_r_Bad(get_irn_irg(block), mode_T);
case pn_Start_P_frame_base:
return get_frame_base();
- case pn_Start_P_tls:
- return new_r_Bad(current_ir_graph);
- case pn_Start_max:
- break;
}
panic("Unexpected start proj: %ld\n", pn);
}
/* Proj->Proj->Start must be a method argument */
assert(get_Proj_proj(get_Proj_pred(node)) == pn_Start_T_args);
- param = &cconv->parameters[pn];
+ param = ¤t_cconv->parameters[pn];
if (param->reg0 != NULL) {
/* argument transmitted in register */
case pn_Call_X_regular:
case pn_Call_X_except:
case pn_Call_T_result:
- case pn_Call_P_value_res_base:
- case pn_Call_max:
break;
}
panic("Unexpected Call proj %ld\n", pn);
/* FALLTHROUGH */
}
default:
+ if (is_sparc_AddCC_t(pred)) {
+ return gen_Proj_AddCC_t(node);
+ } else if (is_sparc_SubCC_t(pred)) {
+ return gen_Proj_SubCC_t(node);
+ }
panic("code selection didn't expect Proj after %+F\n", pred);
}
}
be_set_transform_function(op_SymConst, gen_SymConst);
be_set_transform_function(op_Unknown, gen_Unknown);
+ be_set_transform_function(op_sparc_AddX_t, gen_AddX_t);
+ be_set_transform_function(op_sparc_AddCC_t,gen_AddCC_t);
be_set_transform_function(op_sparc_Save, be_duplicate_node);
-}
-
-/* hack to avoid unused fp proj at start barrier */
-static void assure_fp_keep(void)
-{
- unsigned n_users = 0;
- const ir_edge_t *edge;
- ir_node *fp_proj = be_prolog_get_reg_value(abihelper, fp_reg);
-
- foreach_out_edge(fp_proj, edge) {
- ir_node *succ = get_edge_src_irn(edge);
- if (is_End(succ) || is_Anchor(succ))
- continue;
- ++n_users;
- }
-
- if (n_users == 0) {
- ir_node *block = get_nodes_block(fp_proj);
- ir_node *in[1] = { fp_proj };
- be_new_Keep(block, 1, in);
- }
+ be_set_transform_function(op_sparc_SubX_t, gen_SubX_t);
+ be_set_transform_function(op_sparc_SubCC_t,gen_SubCC_t);
}
/**
node_to_stack = pmap_create();
- mode_gp = mode_Iu;
- mode_fp = mode_F;
- mode_fp2 = mode_D;
+ mode_gp = mode_Iu;
+ mode_fp = mode_F;
+ mode_fp2 = mode_D;
+ mode_flags = mode_Bu;
//mode_fp4 = ?
abihelper = be_abihelper_prepare(irg);
be_collect_stacknodes(abihelper);
- cconv = sparc_decide_calling_convention(get_entity_type(entity), irg);
+ current_cconv
+ = sparc_decide_calling_convention(get_entity_type(entity), irg);
create_stacklayout(irg);
be_transform_graph(irg, NULL);
- if (!cconv->omit_fp)
- assure_fp_keep();
be_abihelper_finish(abihelper);
- sparc_free_calling_convention(cconv);
+ sparc_free_calling_convention(current_cconv);
frame_type = get_irg_frame_type(irg);
if (get_type_state(frame_type) == layout_undefined)