/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-** All rights reserved.
-**
-** Authors: Martin Trapp, Christian Schaefer
-**
-** ircons.c: basic and more detailed irnode constructors
-** store, block and parameter administration.
-** Adapted to extended FIRM nodes (exceptions...) and commented
-** by Goetz Lindenmaier
+* All rights reserved.
+*
+* Authors: Martin Trapp, Christian Schaefer
+*
+* ircons.c: basic and more detailed irnode constructors
+* store, block and parameter administration.
+* Adapted to extended FIRM nodes (exceptions...) and commented
+* by Goetz Lindenmaier
*/
/* $Id$ */
typedef struct Phi_in_stack Phi_in_stack;
#endif
+/*
+ * language dependant initialization variable
+ */
+static default_initialize_local_variable_func_t *default_initialize_local_variable = NULL;
+
/*** ******************************************** */
/** privat interfaces, for professional use only */
res->attr.block.in_cg = NULL;
res->attr.block.cg_backedge = NULL;
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
res = new_ir_node (db, irg, block, op_Start, mode_T, 0, NULL);
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
res = new_ir_node (db, irg, block, op_End, mode_X, -1, NULL);
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Phi (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in, ir_mode *mode)
{
ir_node *res;
+ int i;
+ bool has_unknown = false;
assert( get_Block_matured(block) );
assert( get_irn_arity(block) == arity );
res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
- res = optimize (res);
- irn_vrfy (res);
+ for (i = arity-1; i >= 0; i--) if (get_irn_op(in[i]) == op_Unknown) has_unknown = true;
+ if (!has_unknown) res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
/* Memory Phis in endless loops must be kept alive.
As we can't distinguish these easily we keep all of them alive. */
ir_node *res;
res = new_ir_node (db, irg, block, op_Const, mode, 0, NULL);
res->attr.con = con;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
#if 0
res = local_optimize_newby (res);
INLINE ir_node *
new_rd_Id (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *val, ir_mode *mode)
{
- ir_node *in[1] = {val};
+ ir_node *in[1];
ir_node *res;
+ in[0]=val;
res = new_ir_node (db, irg, block, op_Id, mode, 1, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Proj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
long proj)
{
- ir_node *in[1] = {arg};
+ ir_node *in[1];
ir_node *res;
+ in[0]=arg;
res = new_ir_node (db, irg, block, op_Proj, mode, 1, in);
res->attr.proj = proj;
assert(get_Proj_pred(res));
assert(get_nodes_Block(get_Proj_pred(res)));
- res = optimize (res);
+ res = optimize_node (res);
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
INLINE ir_node *
new_rd_Conv (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode)
{
- ir_node *in[1] = {op};
+ ir_node *in[1];
ir_node *res;
+ in[0]=op;
res = new_ir_node (db, irg, block, op_Conv, mode, 1, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
ir_node *res;
res = new_ir_node (db, irg, block, op_Tuple, mode_T, arity, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Add (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
- ir_node *in[2] = {op1, op2};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op1;
+ in[1] = op2;
res = new_ir_node (db, irg, block, op_Add, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Sub (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
- ir_node *in[2] = {op1, op2};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op1;
+ in[1] = op2;
res = new_ir_node (db, irg, block, op_Sub, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Minus (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
- ir_node *in[1] = {op};
+ ir_node *in[1];
ir_node *res;
+ in[0]=op;
res = new_ir_node (db, irg, block, op_Minus, mode, 1, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Mul (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
- ir_node *in[2] = {op1, op2};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op1;
+ in[1] = op2;
res = new_ir_node (db, irg, block, op_Mul, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Quot (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
- ir_node *in[3] = {memop, op1, op2};
+ ir_node *in[3] ;
ir_node *res;
+ in[0] = memop;
+ in[1] = op1;
+ in[2] = op2;
res = new_ir_node (db, irg, block, op_Quot, mode_T, 3, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_DivMod (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
- ir_node *in[3] = {memop, op1, op2};
+ ir_node *in[3];
ir_node *res;
+ in[0] = memop;
+ in[1] = op1;
+ in[2] = op2;
res = new_ir_node (db, irg, block, op_DivMod, mode_T, 3, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Div (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
- ir_node *in[3] = {memop, op1, op2};
+ ir_node *in[3];
ir_node *res;
+ in[0] = memop;
+ in[1] = op1;
+ in[2] = op2;
res = new_ir_node (db, irg, block, op_Div, mode_T, 3, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Mod (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *memop, ir_node *op1, ir_node *op2)
{
- ir_node *in[3] = {memop, op1, op2};
+ ir_node *in[3];
ir_node *res;
+ in[0] = memop;
+ in[1] = op1;
+ in[2] = op2;
res = new_ir_node (db, irg, block, op_Mod, mode_T, 3, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_And (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
- ir_node *in[2] = {op1, op2};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op1;
+ in[1] = op2;
res = new_ir_node (db, irg, block, op_And, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Or (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
- ir_node *in[2] = {op1, op2};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op1;
+ in[1] = op2;
res = new_ir_node (db, irg, block, op_Or, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Eor (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2, ir_mode *mode)
{
- ir_node *in[2] = {op1, op2};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op1;
+ in[1] = op2;
res = new_ir_node (db, irg, block, op_Eor, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Not (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
- ir_node *in[1] = {op};
+ ir_node *in[1];
ir_node *res;
+ in[0] = op;
res = new_ir_node (db, irg, block, op_Not, mode, 1, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Shl (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
- ir_node *in[2] = {op, k};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op;
+ in[1] = k;
res = new_ir_node (db, irg, block, op_Shl, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Shr (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
- ir_node *in[2] = {op, k};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op;
+ in[1] = k;
res = new_ir_node (db, irg, block, op_Shr, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Shrs (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
- ir_node *in[2] = {op, k};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op;
+ in[1] = k;
res = new_ir_node (db, irg, block, op_Shrs, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Rot (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode)
{
- ir_node *in[2] = {op, k};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op;
+ in[1] = k;
res = new_ir_node (db, irg, block, op_Rot, mode, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Abs (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode)
{
- ir_node *in[1] = {op};
+ ir_node *in[1];
ir_node *res;
+ in[0] = op;
res = new_ir_node (db, irg, block, op_Abs, mode, 1, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Cmp (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2)
{
- ir_node *in[2] = {op1, op2};
+ ir_node *in[2];
ir_node *res;
+ in[0] = op1;
+ in[1] = op2;
res = new_ir_node (db, irg, block, op_Cmp, mode_T, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
INLINE ir_node *
new_rd_Jmp (dbg_info* db, ir_graph *irg, ir_node *block)
{
- ir_node *in[0] = {};
ir_node *res;
- res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = new_ir_node (db, irg, block, op_Jmp, mode_X, 0, NULL);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
INLINE ir_node *
new_rd_Cond (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *c)
{
- ir_node *in[1] = {c};
+ ir_node *in[1];
ir_node *res;
+ in[0] = c;
res = new_ir_node (db, irg, block, op_Cond, mode_T, 1, in);
res->attr.c.kind = dense;
res->attr.c.default_proj = 0;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
assert(is_method_type(tp));
set_Call_type(res, tp);
res->attr.call.callee_arr = NULL;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
r_in[0] = store;
memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
res = new_ir_node (db, irg, block, op_Return, mode_X, r_arity, r_in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
INLINE ir_node *
new_rd_Raise (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *obj)
{
- ir_node *in[2] = {store, obj};
+ ir_node *in[2];
ir_node *res;
+ in[0] = store;
+ in[1] = obj;
res = new_ir_node (db, irg, block, op_Raise, mode_T, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Load (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *store, ir_node *adr)
{
- ir_node *in[2] = {store, adr};
+ ir_node *in[2];
ir_node *res;
+ in[0] = store;
+ in[1] = adr;
res = new_ir_node (db, irg, block, op_Load, mode_T, 2, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Store (dbg_info* db, ir_graph *irg, ir_node *block,
ir_node *store, ir_node *adr, ir_node *val)
{
- ir_node *in[3] = {store, adr, val};
+ ir_node *in[3];
ir_node *res;
+ in[0] = store;
+ in[1] = adr;
+ in[2] = val;
res = new_ir_node (db, irg, block, op_Store, mode_T, 3, in);
- res = optimize (res);
+ res = optimize_node (res);
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Alloc (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
ir_node *size, type *alloc_type, where_alloc where)
{
- ir_node *in[2] = {store, size};
+ ir_node *in[2];
ir_node *res;
+ in[0] = store;
+ in[1] = size;
res = new_ir_node (db, irg, block, op_Alloc, mode_T, 2, in);
res->attr.a.where = where;
res->attr.a.type = alloc_type;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Free (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
ir_node *ptr, ir_node *size, type *free_type)
{
- ir_node *in[3] = {store, ptr, size};
+ ir_node *in[3];
ir_node *res;
+ in[0] = store;
+ in[1] = ptr;
+ in[2] = size;
res = new_ir_node (db, irg, block, op_Free, mode_T, 3, in);
res->attr.f = free_type;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
r_in[0] = store;
r_in[1] = objptr;
memcpy (&r_in[2], in, sizeof (ir_node *) * arity);
- res = new_ir_node (db, irg, block, op_Sel, mode_P, r_arity, r_in);
+ res = new_ir_node (db, irg, block, op_Sel, mode_P_mach, r_arity, r_in);
res->attr.s.ent = ent;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
res->attr.io.ent = ent;
/* res = optimize (res);
- ** irn_vrfy (res); */
+ * irn_vrfy_irg (res, irg); */
return (res);
}
new_rd_SymConst (dbg_info* db, ir_graph *irg, ir_node *block, type_or_id_p value,
symconst_kind symkind)
{
- ir_node *in[0] = {};
ir_node *res;
ir_mode *mode;
if (symkind == linkage_ptr_info)
- mode = mode_P;
+ mode = mode_P_mach;
else
mode = mode_Iu;
- res = new_ir_node (db, irg, block, op_SymConst, mode, 0, in);
+ res = new_ir_node (db, irg, block, op_SymConst, mode, 0, NULL);
res->attr.i.num = symkind;
if (symkind == linkage_ptr_info) {
&& (is_type(value)));
res->attr.i.tori.typ = (type *)value;
}
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
res = new_ir_node (db, irg, block, op_Sync, mode_M, arity, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
INLINE ir_node *
-new_rd_Bad ()
+new_rd_Bad (ir_graph *irg)
{
- return current_ir_graph->bad;
+ return irg->bad;
}
INLINE ir_node *
-new_rd_Unknown ()
+new_rd_Unknown (ir_graph *irg)
{
- return current_ir_graph->unknown;
+ return irg->unknown;
}
INLINE ir_node *
new_rd_CallBegin (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *call)
{
- ir_node *in[1] = { get_Call_ptr(call) };
+ ir_node *in[1];
ir_node *res;
+ in[0] = get_Call_ptr(call);
res = new_ir_node (db, irg, block, op_CallBegin, mode_T, 1, in);
res->attr.callbegin.irg = irg;
res->attr.callbegin.call = call;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
res = new_ir_node (db, irg, block, op_EndReg, mode_T, -1, NULL);
res->attr.end.irg = irg;
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
res = new_ir_node (db, irg, block, op_EndExcept, mode_T, -1, NULL);
res->attr.end.irg = irg;
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
INLINE ir_node *
new_rd_Break (dbg_info *db, ir_graph *irg, ir_node *block)
{
- ir_node *in[0] = {};
ir_node *res;
- res = new_ir_node (db, irg, block, op_Break, mode_X, 0, in);
- res = optimize (res);
- irn_vrfy (res);
+ res = new_ir_node (db, irg, block, op_Break, mode_X, 0, NULL);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
new_rd_Filter (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *arg, ir_mode *mode,
long proj)
{
- ir_node *in[1] = {arg};
+ ir_node *in[1];
ir_node *res;
+ in[0] = arg;
res = new_ir_node (db, irg, block, op_Filter, mode, 1, in);
res->attr.filter.proj = proj;
res->attr.filter.in_cg = NULL;
assert(get_Proj_pred(res));
assert(get_nodes_Block(get_Proj_pred(res)));
- res = optimize (res);
+ res = optimize_node (res);
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
ir_node *val, ir_mode *mode) {
return new_rd_Id(NULL, irg, block, val, mode);
}
-INLINE ir_node *new_r_Bad () {
- return new_rd_Bad();
+INLINE ir_node *new_r_Bad (ir_graph *irg) {
+ return new_rd_Bad(irg);
}
-INLINE ir_node *new_r_Unknown () {
- return new_rd_Unknown();
+INLINE ir_node *new_r_Unknown (ir_graph *irg) {
+ return new_rd_Unknown(irg);
}
INLINE ir_node *new_r_CallBegin (ir_graph *irg, ir_node *block, ir_node *callee) {
return new_rd_CallBegin(NULL, irg, block, callee);
/** public interfaces */
/** construction tools */
-/****f* ircons/new_Start
+/**
*
- * NAME
- * new_Start -- create a new Start node in the current block
+ * - create a new Start node in the current block
*
- * SYNOPSIS
- * s = new_Start(void);
- * ir_node* new_Start(void);
+ * @return s - pointer to the created Start node
*
- * RESULT
- * s - pointer to the created Start node
*
- ****
*/
ir_node *
new_d_Start (dbg_info* db)
res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
op_Start, mode_T, 0, NULL);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, current_ir_graph);
return res;
}
ir_node *res;
res = new_ir_node (db, current_ir_graph, current_ir_graph->current_block,
op_End, mode_X, -1, NULL);
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, current_ir_graph);
return res;
}
new_d_Block (dbg_info* db, int arity, ir_node **in)
{
ir_node *res;
+ int i;
+ bool has_unknown = false;
res = new_rd_Block (db, current_ir_graph, arity, in);
current_ir_graph->n_loc);
memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
- res = optimize (res);
+ for (i = arity-1; i >= 0; i--) if (get_irn_op(in[i]) == op_Unknown) has_unknown = true;
+
+ if (!has_unknown) res = optimize_node (res);
current_ir_graph->current_block = res;
- irn_vrfy (res);
+ irn_vrfy_irg (res, current_ir_graph);
return res;
}
{
ir_node *res;
res = new_ir_node (NULL, irg, block, op_Phi, mode, 0, NULL);
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
#endif
res = known;
} else {
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
}
/* return the pointer to the Phi node. This node might be deallocated! */
static ir_node *
get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
-/** This function computes the predecessors for a real Phi node, and then
+/**
allocates and returns this node. The routine called to allocate the
node might optimize it away and return a real value, or even a pointer
to a deallocated Phi node on top of the obstack!
/* If we get here, the frontend missed a use-before-definition error */
if (!res) {
/* Error Message */
- printf("Error: no value set. Use of undefined variable. Initializing
- to zero.\n");
+ printf("Error: no value set. Use of undefined variable. Initializing to zero.\n");
assert (mode->code >= irm_F && mode->code <= irm_P);
res = new_rd_Const (NULL, current_ir_graph, block, mode,
tarval_mode_null[mode->code]);
#else /* if 0 */
-/** This is the simple algorithm. If first generates a Phi0, then
+/**
it starts the recursion. This causes an Id at the entry of
every block that has no definition of the value! **/
res = new_Bad();
}
} else {
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
/* Memory Phis in endless loops must be kept alive.
As we can't distinguish these easily we keep all of the alive. */
if ((res->op == op_Phi) && (mode == mode_M))
}
#endif
-/** This function allocates a dummy Phi node to break recursions,
+/**
computes the predecessors for the real phi node, and then
allocates and returns this node. The routine called to allocate the
node might optimize it away and return a real value.
Else we may not set graph_arr as there a later value is remembered. */
phi0 = NULL;
if (!block->attr.block.graph_arr[pos]) {
- /* This is commented out as collapsing to Bads is no good idea.
- Either we need an assert here, or we need to call a routine
- that deals with this case as appropriate for the given language.
- Right now a self referencing Id is created which will crash irg_vrfy().
-
- Even if all variables are defined before use, it can happen that
- we get to the start block, if a cond has been replaced by a tuple
- (bad, jmp). As the start has a self referencing control flow edge,
- we get a self referencing Id, which is hard to optimize away. We avoid
- this by defining the value as a Bad node.
- Returning a const with tarval_bad is a preliminary solution. In some
- situations we might want a Warning or an Error. */
-
if (block == get_irg_start_block(current_ir_graph)) {
- block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
+ /* Collapsing to Bad tarvals is no good idea.
+ So we call a user-supplied routine here that deals with this case as
+ appropriate for the given language. Sorryly the only help we can give
+ here is the position.
+
+ Even if all variables are defined before use, it can happen that
+ we get to the start block, if a cond has been replaced by a tuple
+ (bad, jmp). In this case we call the function needlessly, eventually
+ generating an non existant error.
+ However, this SHOULD NOT HAPPEN, as bad control flow nodes are intercepted
+ before recuring.
+ */
+ if (default_initialize_local_variable)
+ block->attr.block.graph_arr[pos] = default_initialize_local_variable(mode, pos);
+ else
+ block->attr.block.graph_arr[pos] = new_Const(mode, tarval_bad);
/* We don't need to care about exception ops in the start block.
There are none by definition. */
return block->attr.block.graph_arr[pos];
/* If we get here, the frontend missed a use-before-definition error */
if (!res) {
/* Error Message */
- printf("Error: no value set. Use of undefined variable. Initializing
- to zero.\n");
+ printf("Error: no value set. Use of undefined variable. Initializing to zero.\n");
assert (mode->code >= irm_F && mode->code <= irm_P);
res = new_rd_Const (NULL, current_ir_graph, block, mode,
- tarval_mode_null[mode->code]);
+ get_mode_null(mode));
}
/* The local valid value is available now. */
nodes refer to the unoptimized node.
We can call _2, as global cse has no effect on blocks. */
block = optimize_in_place_2(block);
- irn_vrfy(block);
+ irn_vrfy_irg(block, current_ir_graph);
}
}
ir_node *
new_d_SymConst (dbg_info* db, type_or_id_p value, symconst_kind kind)
{
- return new_rd_SymConst (db, current_ir_graph, current_ir_graph->current_block,
+ return new_rd_SymConst (db, current_ir_graph, current_ir_graph->start_block,
value, kind);
}
memset(res->attr.block.graph_arr, 0, sizeof(ir_node *)*current_ir_graph->n_loc);
/* Immature block may not be optimized! */
- irn_vrfy (res);
+ irn_vrfy_irg (res, current_ir_graph);
return res;
}
/* call once for each run of the library */
void
-init_cons (void)
+init_cons (default_initialize_local_variable_func_t *func)
{
+ default_initialize_local_variable = func;
}
/* call for each graph */
projects / libfirm / blobdiff