+ir_graph *new_const_code_irg(void)
+{
+ ir_graph *res = alloc_graph();
+ ir_node *bad;
+ ir_node *body_block;
+ ir_node *end;
+ ir_node *end_block;
+ ir_node *no_mem;
+ ir_node *projX;
+ ir_node *start_block;
+ ir_node *start;
+
+ /* inform statistics here, as blocks will be already build on this graph */
+ hook_new_graph(res, NULL);
+
+ current_ir_graph = res;
+ res->n_loc = 1; /* Only the memory. */
+ res->visited = 0; /* visited flag, for the ir walker */
+ res->block_visited = 0; /* visited flag, for the 'block'-walker */
+ res->obst = XMALLOC(struct obstack);
+ obstack_init(res->obst);
+ res->extbb_obst = NULL;
+
+ res->last_node_idx = 0;
+
+ res->phase_state = phase_building;
+ res->irg_pinned_state = op_pin_state_pinned;
+ res->extblk_state = ir_extblk_info_none;
+ res->fp_model = fp_model_precise;
+
+ /* value table for global value numbering for optimizing use in iropt.c */
+ res->value_table = new_identities();
+ res->ent = NULL;
+ res->frame_type = NULL;
+
+ /* the Anchor node must be created first */
+ res->anchor = new_Anchor(res);
+
+ /* -- The end block -- */
+ end_block = new_immBlock();
+ set_irg_end_block(res, end_block);
+ set_cur_block(end_block);
+ end = new_End();
+ set_irg_end (res, end);
+ set_irg_end_reg (res, end);
+ set_irg_end_except(res, end);
+ mature_immBlock(end_block);
+
+ /* -- The start block -- */
+ start_block = new_immBlock();
+ set_cur_block(start_block);
+ set_irg_start_block(res, start_block);
+ bad = new_ir_node(NULL, res, start_block, op_Bad, mode_T, 0, NULL);
+ bad->attr.irg.irg = res;
+ set_irg_bad(res, bad);
+ no_mem = new_ir_node(NULL, res, start_block, op_NoMem, mode_M, 0, NULL);
+ set_irg_no_mem(res, no_mem);
+ start = new_Start();
+ set_irg_start(res, start);
+
+ /* Proj results of start node */
+ set_irg_initial_mem(res, new_Proj(start, mode_M, pn_Start_M));
+ projX = new_Proj(start, mode_X, pn_Start_X_initial_exec);
+ mature_immBlock(start_block);
+
+ body_block = new_immBlock();
+ add_immBlock_pred(body_block, projX);
+ mature_immBlock(body_block); /* mature the 'body' block for expressions */
+ set_cur_block(body_block);
+
+ /* Set the visited flag high enough that the blocks will never be visited. */
+ set_irn_visited(body_block, -1);
+ set_Block_block_visited(body_block, -1);
+ set_Block_block_visited(start_block, -1);
+ set_irn_visited(start_block, -1);
+ set_irn_visited(bad, -1);
+ set_irn_visited(no_mem, -1);
+
+ res->phase_state = phase_high;
+
+ return res;
+}
+
+/**
+ * Pre-Walker: Copies blocks and nodes from the original method graph
+ * to the copied graph.
+ *
+ * @param n A node from the original method graph.
+ * @param env The copied graph.
+ */
+static void copy_all_nodes(ir_node *n, void *env) {
+ ir_graph *irg = env;
+ ir_op *op = get_irn_op(n);
+ ir_node *nn;
+
+ nn = new_ir_node(get_irn_dbg_info(n),
+ irg,
+ NULL, /* no block yet, will be set later */
+ op,
+ get_irn_mode(n),
+ get_irn_arity(n),
+ get_irn_in(n) + 1);
+
+
+ /* Copy the attributes. These might point to additional data. If this
+ was allocated on the old obstack the pointers now are dangling. This
+ frees e.g. the memory of the graph_arr allocated in new_immBlock. */
+ copy_node_attr(n, nn);
+ new_backedge_info(nn);
+ set_irn_link(n, nn);
+
+ /* fix the irg for Blocks: as Bad nodes are NOT copied, no
+ need t fix them */
+ if (is_Block(nn))
+ nn->attr.block.irg.irg = irg;
+
+ /* fix access to entities on the stack frame */
+ if (is_Sel(nn)) {
+ ir_entity *ent = get_Sel_entity(nn);
+ ir_type *tp = get_entity_owner(ent);
+
+ if (is_frame_type(tp)) {
+ /* replace by the copied entity */
+ ent = get_entity_link(ent);
+
+ assert(is_entity(ent));
+ assert(get_entity_owner(ent) == get_irg_frame_type(irg));
+ set_Sel_entity(nn, ent);
+ }
+ }
+}
+
+/**
+ * Post-walker: Set the predecessors of the copied nodes.
+ * The copied nodes are set as link of their original nodes. The links of
+ * "irn" predecessors are the predecessors of copied node.
+ */
+static void set_all_preds(ir_node *irn, void *env) {
+ int i;
+ ir_node *nn, *pred;
+ (void) env;
+
+ nn = get_irn_link(irn);
+
+ if (is_Block(irn)) {
+ ir_node *mbh = get_Block_MacroBlock(irn);
+ set_Block_MacroBlock(nn, get_irn_link(mbh));
+ for (i = get_Block_n_cfgpreds(irn) - 1; i >= 0; i--) {
+ pred = get_Block_cfgpred(irn, i);
+ set_Block_cfgpred(nn, i, get_irn_link(pred));
+ }
+ } else {
+ /* First we set the block our copy if it is not a block.*/
+ set_nodes_block(nn, get_irn_link(get_nodes_block(irn)));
+ for (i = get_irn_arity(irn) - 1; i >= 0; i--) {
+ pred = get_irn_n(irn, i);
+ set_irn_n(nn, i, get_irn_link(pred));
+ }
+ }
+}
+
+#define NN(irn) get_irn_link(irn)