/**
* Constructs a Block with a fixed number of predecessors.
- * Does not set current_block. Can not be used with automatic
+ * Does not set current_block. Cannot be used with automatic
* Phi node construction.
*/
static ir_node *
-new_bd_Block(dbg_info *db, int arity, ir_node **in) {
+new_bd_Block(dbg_info *db, int arity, ir_node **in) {
ir_node *res;
ir_graph *irg = current_ir_graph;
- res = new_ir_node (db, irg, NULL, op_Block, mode_BB, arity, in);
- set_Block_matured(res, 1);
- set_Block_block_visited(res, 0);
+ res = new_ir_node(db, irg, NULL, op_Block, mode_BB, arity, in);
+
+ /* macroblock header */
+ res->in[0] = res;
- res->attr.block.dead = 0;
+ res->attr.block.is_dead = 0;
+ res->attr.block.is_mb_head = 1;
res->attr.block.irg = irg;
res->attr.block.backedge = new_backedge_arr(irg->obst, arity);
res->attr.block.in_cg = NULL;
res->attr.block.cg_backedge = NULL;
res->attr.block.extblk = NULL;
+ res->attr.block.mb_depth = 0;
+
+ set_Block_matured(res, 1);
+ set_Block_block_visited(res, 0);
IRN_VRFY_IRG(res, irg);
return res;
- } /* new_bd_Block */
+} /* new_bd_Block */
static ir_node *
new_bd_Start(dbg_info *db, ir_node *block) {
in[0] = val;
in[1] = bound;
- res = new_ir_node (db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
- res->attr.confirm_cmp = cmp;
- res = optimize_node (res);
+ res = new_ir_node(db, irg, block, op_Confirm, get_irn_mode(val), 2, in);
+ res->attr.confirm.cmp = cmp;
+ res = optimize_node(res);
IRN_VRFY_IRG(res, irg);
return res;
} /* new_bd_Confirm */
return res;
} /* new_bd_Pin */
+static ir_node *
+new_bd_ASM(dbg_info *db, ir_node *block, int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs, int n_clobber, ident *clobber[], ident *asm_text) {
+ ir_node *res;
+ ir_graph *irg = current_ir_graph;
+
+ res = new_ir_node(db, irg, block, op_ASM, mode_T, arity, in);
+ res->attr.assem.pin_state = op_pin_state_pinned;
+ res->attr.assem.inputs = NEW_ARR_D(ir_asm_constraint, irg->obst, arity);
+ res->attr.assem.outputs = NEW_ARR_D(ir_asm_constraint, irg->obst, n_outs);
+ res->attr.assem.clobber = NEW_ARR_D(ident *, irg->obst, n_clobber);
+ res->attr.assem.asm_text = asm_text;
+
+ memcpy(res->attr.assem.inputs, inputs, sizeof(inputs[0]) * arity);
+ memcpy(res->attr.assem.outputs, outputs, sizeof(outputs[0]) * n_outs);
+
+ res = optimize_node(res);
+ IRN_VRFY_IRG(res, irg);
+ return res;
+} /* new_bd_ASM */
+
/* --------------------------------------------- */
/* private interfaces, for professional use only */
/* --------------------------------------------- */
Does not set current_block. Can not be used with automatic
Phi node construction. */
ir_node *
-new_rd_Block(dbg_info *db, ir_graph *irg, int arity, ir_node **in) {
+new_rd_Block(dbg_info *db, ir_graph *irg, int arity, ir_node **in) {
ir_graph *rem = current_ir_graph;
ir_node *res;
return res;
} /* new_rd_Pin */
+ir_node *new_rd_ASM(dbg_info *db, ir_graph *irg, ir_node *block,
+ int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs,
+ int n_clobber, ident *clobber[], ident *asm_text) {
+ ir_node *res;
+ ir_graph *rem = current_ir_graph;
+
+ current_ir_graph = irg;
+ res = new_bd_ASM(db, block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
+ current_ir_graph = rem;
+
+ return res;
+} /* new_rd_ASM */
+
+
ir_node *new_r_Block(ir_graph *irg, int arity, ir_node **in) {
return new_rd_Block(NULL, irg, arity, in);
}
return new_rd_Bad(irg);
}
ir_node *new_r_Confirm(ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp) {
- return new_rd_Confirm (NULL, irg, block, val, bound, cmp);
+ return new_rd_Confirm(NULL, irg, block, val, bound, cmp);
}
ir_node *new_r_Unknown(ir_graph *irg, ir_mode *m) {
return new_rd_Unknown(irg, m);
ir_node *new_r_Pin(ir_graph *irg, ir_node *block, ir_node *node) {
return new_rd_Pin(NULL, irg, block, node);
}
+ir_node *new_r_ASM(ir_graph *irg, ir_node *block,
+ int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs,
+ int n_clobber, ident *clobber[], ident *asm_text) {
+ return new_rd_ASM(NULL, irg, block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
+}
/** ********************/
/** public interfaces */
/* case 2 -- If the value is actually computed, return it. */
if (res) return res;
- if (block->attr.block.matured) { /* case 3 */
+ if (block->attr.block.is_matured) { /* case 3 */
/* The Phi has the same amount of ins as the corresponding block. */
int ins = get_irn_arity(block);
if (block->attr.block.graph_arr[pos]) {
/* There was a set_value() after the cfOp and no get_value before that
set_value(). We must build a Phi node now. */
- if (block->attr.block.matured) {
+ if (block->attr.block.is_matured) {
int ins = get_irn_arity(block);
ir_node **nin;
NEW_ARR_A(ir_node *, nin, ins);
/* case 2 -- If the value is actually computed, return it. */
if (res) { return res; };
- if (block->attr.block.matured) { /* case 3 */
+ if (block->attr.block.is_matured) { /* case 3 */
/* The Phi has the same amount of ins as the corresponding block. */
int ins = get_irn_arity(block);
exchange(n, phi_merge(block, n->attr.phi0.pos, n->mode, nin, ins));
}
- block->attr.block.matured = 1;
+ block->attr.block.is_matured = 1;
/* Now, as the block is a finished firm node, we can optimize it.
Since other nodes have been allocated since the block was created
return new_bd_Pin(db, current_ir_graph->current_block, node);
} /* new_d_Pin */
+ir_node *
+new_d_ASM(dbg_info *db, int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs,
+ int n_clobber, ident *clobber[], ident *asm_text) {
+ return new_bd_ASM(db, current_ir_graph->current_block, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
+} /* new_d_ASM */
+
/* ********************************************************************* */
/* Comfortable interface with automatic Phi node construction. */
/* (Uses also constructors of ?? interface, except new_Block. */
/* Block construction */
/* immature Block without predecessors */
-ir_node *new_d_immBlock(dbg_info *db) {
+ir_node *
+new_d_immBlock(dbg_info *db) {
ir_node *res;
assert(get_irg_phase_state(current_ir_graph) == phase_building);
/* creates a new dynamic in-array as length of in is -1 */
- res = new_ir_node (db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
+ res = new_ir_node(db, current_ir_graph, NULL, op_Block, mode_BB, -1, NULL);
current_ir_graph->current_block = res;
- res->attr.block.matured = 0;
- res->attr.block.dead = 0;
+
+ /* macroblock head */
+ res->in[0] = res;
+
+ res->attr.block.is_matured = 0;
+ res->attr.block.is_dead = 0;
+ res->attr.block.is_mb_head = 1;
res->attr.block.irg = current_ir_graph;
res->attr.block.backedge = NULL;
res->attr.block.in_cg = NULL;
res->attr.block.cg_backedge = NULL;
res->attr.block.extblk = NULL;
res->attr.block.region = NULL;
+ res->attr.block.mb_depth = 0;
+
set_Block_block_visited(res, 0);
/* Create and initialize array for Phi-node construction. */
return new_d_immBlock(NULL);
} /* new_immBlock */
+/* immature PartBlock with its predecessors */
+ir_node *
+new_d_immPartBlock(dbg_info *db, ir_node *pred_jmp) {
+ ir_node *res = new_d_immBlock(db);
+ ir_node *blk = get_nodes_block(pred_jmp);
+
+ res->in[0] = blk->in[0];
+ add_immBlock_pred(res, pred_jmp);
+
+ res->attr.block.is_mb_head = 0;
+ res->attr.block.mb_depth = blk->attr.block.mb_depth + 1;
+
+ return res;
+} /* new_d_immPartBlock */
+
+ir_node *
+new_immPartBlock(ir_node *pred_jmp) {
+ return new_d_immPartBlock(NULL, pred_jmp);
+} /* new_immPartBlock */
+
/* add an edge to a jmp/control flow node */
void
add_immBlock_pred(ir_node *block, ir_node *jmp) {
- if (block->attr.block.matured) {
- assert(0 && "Error: Block already matured!\n");
- } else {
- int n = ARR_LEN(block->in) - 1;
- assert(jmp != NULL);
- ARR_APP1(ir_node *, block->in, jmp);
- /* Call the hook */
- hook_set_irn_n(block, n, jmp, NULL);
- }
+ int n = ARR_LEN(block->in) - 1;
+
+ assert(!block->attr.block.is_matured && "Error: Block already matured!\n");
+ assert(block->attr.block.is_mb_head && "Error: Cannot add a predecessor to a PartBlock");
+ assert(jmp != NULL);
+
+ ARR_APP1(ir_node *, block->in, jmp);
+ /* Call the hook */
+ hook_set_irn_n(block, n, jmp, NULL);
} /* add_immBlock_pred */
/* changing the current block */
return new_d_Bad();
}
ir_node *new_Confirm(ir_node *val, ir_node *bound, pn_Cmp cmp) {
- return new_d_Confirm (NULL, val, bound, cmp);
+ return new_d_Confirm(NULL, val, bound, cmp);
}
ir_node *new_Unknown(ir_mode *m) {
return new_d_Unknown(m);
ir_node *new_Pin(ir_node *node) {
return new_d_Pin(NULL, node);
}
+ir_node *new_ASM(int arity, ir_node *in[], ir_asm_constraint *inputs,
+ int n_outs, ir_asm_constraint *outputs,
+ int n_clobber, ident *clobber[], ident *asm_text) {
+ return new_d_ASM(NULL, arity, in, inputs, n_outs, outputs, n_clobber, clobber, asm_text);
+}
projects / libfirm / blobdiff