From: Sebastian Hack Date: Thu, 23 Feb 2006 08:54:29 +0000 (+0000) Subject: Added some nodes X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=b4650ff15a6ccd34b42009e045ce7c56d7e2b3e7;p=libfirm Added some nodes --- diff --git a/ir/be/benode.c b/ir/be/benode.c index 40e5b12b8..9ac76c22f 100644 --- a/ir/be/benode.c +++ b/ir/be/benode.c @@ -96,6 +96,12 @@ typedef struct { entity *ent; /**< The entity in the stack frame the spill writes to. */ } be_spill_attr_t; +typedef struct { + be_node_attr_t node_attr; + int offset; /**< The offset by which the stack shall be increased/decreased. */ + be_stack_dir_t dir; /**< The direction in which the stack shall be modified (along or in the other direction). */ +} be_stack_attr_t; + static ir_op *op_Spill; static ir_op *op_Reload; static ir_op *op_Perm; @@ -104,6 +110,9 @@ static ir_op *op_Keep; static ir_op *op_Call; static ir_op *op_IncSP; static ir_op *op_AddSP; +static ir_op *op_RegParams; +static ir_op *op_StackParam; +static ir_op *op_NoReg; static int beo_base = -1; @@ -131,17 +140,29 @@ void be_node_init(void) { /* Acquire all needed opcodes. */ beo_base = get_next_ir_opcodes(beo_Last - 1); - op_Spill = new_ir_op(beo_base + beo_Spill, "Spill", op_pin_state_mem_pinned, N, oparity_unary, 0, sizeof(be_spill_attr_t), &be_node_op_ops); - op_Reload = new_ir_op(beo_base + beo_Reload, "Reload", op_pin_state_mem_pinned, N, oparity_zero, 0, sizeof(be_node_attr_t), &be_node_op_ops); - op_Perm = new_ir_op(beo_base + beo_Perm, "Perm", op_pin_state_pinned, N, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); - op_Copy = new_ir_op(beo_base + beo_Copy, "Copy", op_pin_state_pinned, N, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops); - op_Keep = new_ir_op(beo_base + beo_Keep, "Keep", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); - - set_op_tag(op_Spill, &be_node_tag); - set_op_tag(op_Reload, &be_node_tag); - set_op_tag(op_Perm, &be_node_tag); - set_op_tag(op_Copy, &be_node_tag); - set_op_tag(op_Keep, &be_node_tag); + op_Spill = new_ir_op(beo_base + beo_Spill, "Spill", op_pin_state_mem_pinned, N, oparity_unary, 0, sizeof(be_spill_attr_t), &be_node_op_ops); + op_Reload = new_ir_op(beo_base + beo_Reload, "Reload", op_pin_state_mem_pinned, N, oparity_zero, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_Perm = new_ir_op(beo_base + beo_Perm, "Perm", op_pin_state_pinned, N, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_Copy = new_ir_op(beo_base + beo_Copy, "Copy", op_pin_state_pinned, N, oparity_unary, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_Keep = new_ir_op(beo_base + beo_Keep, "Keep", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_NoReg = new_ir_op(beo_base + beo_Keep, "NoReg", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_Call = new_ir_op(beo_base + beo_Keep, "Call", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_AddSP = new_ir_op(beo_base + beo_Keep, "AddSP", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_stack_attr_t), &be_node_op_ops); + op_IncSP = new_ir_op(beo_base + beo_Keep, "IncSP", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_stack_attr_t), &be_node_op_ops); + op_RegParams = new_ir_op(beo_base + beo_Keep, "RegParams", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + op_StackParam = new_ir_op(beo_base + beo_Keep, "StackParam", op_pin_state_pinned, K, oparity_variable, 0, sizeof(be_node_attr_t), &be_node_op_ops); + + set_op_tag(op_Spill, &be_node_tag); + set_op_tag(op_Reload, &be_node_tag); + set_op_tag(op_Perm, &be_node_tag); + set_op_tag(op_Copy, &be_node_tag); + set_op_tag(op_Keep, &be_node_tag); + set_op_tag(op_NoReg, &be_node_tag); + set_op_tag(op_Call, &be_node_tag); + set_op_tag(op_AddSP, &be_node_tag); + set_op_tag(op_IncSP, &be_node_tag); + set_op_tag(op_RegParams, &be_node_tag); + set_op_tag(op_StackParam, &be_node_tag); } static void *init_node_attr(ir_node* irn, const arch_register_class_t *cls, ir_graph *irg, int n_outs) @@ -229,31 +250,81 @@ ir_node *be_new_Keep(const arch_register_class_t *cls, ir_graph *irg, ir_node *b return irn; } -int be_is_Spill(const ir_node *irn) +ir_node *be_new_Call(ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *sp, ir_node *ptr, int n_outs, int n, ir_node *in[]) { - return get_irn_be_opcode(irn) == beo_Spill; -} + int real_n = 3 + n; + ir_node *irn; + ir_node **real_in; -int be_is_Reload(const ir_node *irn) -{ - return get_irn_be_opcode(irn) == beo_Reload; + real_in = malloc(sizeof(real_in[0]) * (real_n)); + + real_in[0] = mem; + real_in[1] = sp; + real_in[2] = ptr; + memcpy(&real_in[3], in, n * sizeof(in[0])); + + irn = new_ir_node(NULL, irg, bl, op_Call, mode_T, real_n, real_in); + init_node_attr(irn, NULL, irg, n_outs); + return irn; } -int be_is_Copy(const ir_node *irn) +ir_node *be_new_IncSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, unsigned offset, be_stack_dir_t dir) { - return get_irn_be_opcode(irn) == beo_Copy; + be_stack_attr_t *a; + ir_node *irn; + ir_node *in[1]; + + in[0] = old_sp; + irn = new_ir_node(NULL, irg, bl, op_IncSP, sp->reg_class->mode, 1, in); + a = init_node_attr(irn, sp->reg_class, irg, 1); + a->dir = dir; + a->offset = offset; + + /* Set output constraint to stack register. */ + be_set_constr_single_reg(irn, -1, sp); + + return irn; } -int be_is_Perm(const ir_node *irn) +ir_node *be_new_AddSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *op) { - return get_irn_be_opcode(irn) == beo_Perm; + ir_node *irn; + ir_node *in[2]; + + in[0] = old_sp; + in[1] = op; + irn = new_ir_node(NULL, irg, bl, op_AddSP, sp->reg_class->mode, 2, in); + init_node_attr(irn, sp->reg_class, irg, 1); + + /* Set output constraint to stack register. */ + be_set_constr_single_reg(irn, -1, sp); + + return irn; } -int be_is_Keep(const ir_node *irn) +ir_node *be_new_NoReg(const arch_register_t *reg, ir_graph *irg, ir_node *bl) { - return get_irn_be_opcode(irn) == beo_Keep; + ir_node *irn; + ir_node *in[1]; + + irn = new_ir_node(NULL, irg, bl, op_NoReg, reg->reg_class->mode, 0, in); + init_node_attr(irn, reg->reg_class, irg, 1); + be_set_constr_single_reg(irn, -1, reg); + return irn; } +int be_is_Spill (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Spill ; } +int be_is_Reload (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Reload ; } +int be_is_Copy (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Copy ; } +int be_is_Perm (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Perm ; } +int be_is_Keep (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Keep ; } +int be_is_Call (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_Call ; } +int be_is_IncSP (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_IncSP ; } +int be_is_AddSP (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_AddSP ; } +int be_is_RegParams (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_RegParams ; } +int be_is_StackParam (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_StackParam ; } +int be_is_NoReg (const ir_node *irn) { return get_irn_be_opcode(irn) == beo_NoReg ; } + static void be_limited(void *data, bitset_t *bs) { be_req_t *req = data; @@ -313,15 +384,32 @@ void be_set_constr_limited(ir_node *irn, int pos, const arch_register_req_t *req r->x.old_limited.old_limited_env = req->limited_env; } +void be_set_IncSP_offset(ir_node *irn, unsigned offset) +{ + be_stack_attr_t *a = get_irn_attr(irn); + assert(be_is_IncSP(irn)); + a->offset = offset; +} -void be_set_IncSP_offset(ir_node *irn, int offset) +unsigned be_get_IncSP_offset(ir_node *irn) { + be_stack_attr_t *a = get_irn_attr(irn); + assert(be_is_IncSP(irn)); + return a->offset; +} +void be_set_IncSP_direction(ir_node *irn, be_stack_dir_t dir) +{ + be_stack_attr_t *a = get_irn_attr(irn); + assert(be_is_IncSP(irn)); + a->dir = dir; } -int be_get_IncSP_offset(ir_node *irn) +be_stack_dir_t be_get_IncSP_direction(ir_node *irn) { - return -1; + be_stack_attr_t *a = get_irn_attr(irn); + assert(be_is_IncSP(irn)); + return a->dir; } void be_set_Spill_entity(ir_node *irn, entity *ent) diff --git a/ir/be/benode_t.h b/ir/be/benode_t.h index 7a9cff543..237de0363 100644 --- a/ir/be/benode_t.h +++ b/ir/be/benode_t.h @@ -29,13 +29,20 @@ typedef enum { beo_Perm, beo_Copy, beo_Keep, + beo_NoReg, beo_Call, beo_AddSP, beo_IncSP, + beo_RegParams, beo_StackParam, beo_Last } be_opcode_t; +typedef enum { + be_stack_dir_along = 0, + be_stack_dir_against = 1 +} be_stack_dir_t; + void be_node_init(void); const arch_irn_handler_t be_node_irn_handler; @@ -47,10 +54,31 @@ ir_node *be_new_Perm(const arch_register_class_t *cls, ir_graph *irg, ir_node *b ir_node *be_new_Keep(const arch_register_class_t *cls, ir_graph *irg, ir_node *bl, int arity, ir_node *in[]); ir_node *be_new_AddSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, ir_node *operand); -ir_node *be_new_IncSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, int amount); -ir_node *be_new_Call(ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *sp, ir_node *ptr, int n, ir_node *in[]); + +/** + * Make a stack pointer increase/decrease node. + * @param sp The stack poitner register. + * @param irg The graph to insert the node to. + * @param bl The block to insert the node into. + * @param old_sp The node defining the former stack pointer. + * @param amount The mount of bytes the stack pointer shall be increased/decreased. + * @param dir The direction in which the stack pointer shall be modified: + * Along the stack's growing direction or against. + * @return A new stack pointer increment/decrement node. + * @note This node sets a register constraint to the @p sp register on its output. + */ +ir_node *be_new_IncSP(const arch_register_t *sp, ir_graph *irg, ir_node *bl, ir_node *old_sp, unsigned amount, be_stack_dir_t dir); + +void be_set_IncSP_offset(ir_node *irn, unsigned offset); +unsigned be_get_IncSP_offset(ir_node *irn); + +void be_set_IncSP_direction(ir_node *irn, be_stack_dir_t dir); +be_stack_dir_t be_get_IncSP_direction(ir_node *irn); + +ir_node *be_new_Call(ir_graph *irg, ir_node *bl, ir_node *mem, ir_node *sp, ir_node *ptr, int n_outs, int n, ir_node *in[]); ir_node *be_new_StackParam(ir_graph *irg); ir_node *be_new_RegParams(ir_graph *irg, int n_out); +ir_node *be_new_NoReg(const arch_register_t *reg, ir_graph *irg, ir_node *bl); ir_node *be_spill(const arch_env_t *arch_env, ir_node *irn,ir_node *spill_ctx); ir_node *be_reload(const arch_env_t *arch_env, const arch_register_class_t *cls, ir_node *irn, int pos, ir_mode *mode, ir_node *spill); @@ -64,8 +92,6 @@ int be_is_Call(const ir_node *irn); int be_is_AddSP(const ir_node *irn); int be_is_IncSP(const ir_node *irn); -void be_set_IncSP_offset(ir_node *irn, int offset); -int be_get_IncSP_offset(ir_node *irn); void be_set_Spill_entity(ir_node *irn, entity *ent); entity *be_get_spill_entity(ir_node *irn);