-/* 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
-*/
-
-/* $Id$ */
+/*
+ * Project: libFIRM
+ * File name: ir/ir/ircons.c
+ * Purpose: Various irnode constructors. Automatic construction
+ * of SSA representation.
+ * Author: Martin Trapp, Christian Schaefer
+ * Modified by: Goetz Lindenmaier, Boris Boesler
+ * Created:
+ * CVS-ID: $Id$
+ * Copyright: (c) 1998-2003 Universität Karlsruhe
+ * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
+ */
#ifdef HAVE_CONFIG_H
# include <config.h>
# include "irnode_t.h"
# include "irmode_t.h"
# include "ircons.h"
-# include "common_t.h"
+# include "firm_common_t.h"
# include "irvrfy.h"
# include "irop.h"
# include "iropt_t.h"
# include "array.h"
/* memset belongs to string.h */
# include "string.h"
-
-/* # include "exc.h" */
+# include "irbackedge_t.h"
+# include "irflag_t.h"
#if USE_EXPLICIT_PHI_IN_STACK
/* A stack needed for the automatic Phi node construction in constructor
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 */
/* Constructs a Block with a fixed number of predecessors.
Does not set current_block. Can not be used with automatic
Phi node construction. */
-inline ir_node *
+INLINE ir_node *
new_rd_Block (dbg_info* db, ir_graph *irg, int arity, ir_node **in)
{
ir_node *res;
- res = new_ir_node (db, irg, NULL, op_Block, mode_R, arity, in);
+ 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->attr.block.exc = exc_normal;
- res->attr.block.handler_entry = 0;
+ //res->attr.block.exc = exc_normal;
+ //res->attr.block.handler_entry = 0;
+ 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;
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
-ir_node *
+INLINE ir_node *
new_rd_Start (dbg_info* db, ir_graph *irg, ir_node *block)
{
ir_node *res;
res = new_ir_node (db, irg, block, op_Start, mode_T, 0, NULL);
+ //res->attr.start.irg = irg;
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
-ir_node *
+INLINE ir_node *
new_rd_End (dbg_info* db, ir_graph *irg, ir_node *block)
{
ir_node *res;
res = new_ir_node (db, irg, block, op_End, mode_X, -1, NULL);
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
/* Creates a Phi node with all predecessors. Calling this constructor
is only allowed if the corresponding block is mature. */
-ir_node *
+INLINE ir_node *
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 );
+ /* Don't assert that block matured: the use of this constructor is strongly
+ restricted ... */
+ if ( get_Block_matured(block) )
+ assert( get_irn_arity(block) == arity );
res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
- res = optimize (res);
- irn_vrfy (res);
+ res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
+
+ 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. */
return res;
}
-ir_node *
-new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
+INLINE ir_node *
+new_rd_Const_type (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con, type *tp)
{
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->attr.con.tv = con;
+ set_Const_type(res, tp); /* Call method because of complex assertion. */
+ res = optimize_node (res);
+ assert(get_Const_type(res) == tp);
+ irn_vrfy_irg (res, irg);
#if 0
res = local_optimize_newby (res);
return res;
}
-ir_node *
+INLINE ir_node *
+new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
+{
+ type *tp = unknown_type;
+ if (tarval_is_entity(con))
+ tp = find_pointer_type_to_type(get_entity_type(get_tarval_entity(con)));
+ return new_rd_Const_type (db, irg, block, mode, con, tp);
+}
+
+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;
}
-ir_node *
+INLINE ir_node *
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;
}
-ir_node *
+INLINE ir_node *
new_rd_defaultProj (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *arg,
long max_proj)
{
ir_node *res;
- assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_I));
+ assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_Iu));
arg->attr.c.kind = fragmentary;
arg->attr.c.default_proj = max_proj;
res = new_rd_Proj (db, irg, block, arg, mode_X, max_proj);
return res;
}
-ir_node *
+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;
+}
+INLINE ir_node *
+new_rd_Cast (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *op, type *to_tp)
+{
+ ir_node *res;
+ res = new_ir_node (db, irg, block, op_Cast, get_irn_mode(op), 1, &op);
+ res->attr.cast.totype = to_tp;
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
+ return res;
}
-ir_node *
+INLINE ir_node *
new_rd_Tuple (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
{
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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 *
+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 *
+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;
}
ir_node *
new_rd_Call (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *callee, int arity, ir_node **in, type *type)
+ ir_node *callee, int arity, ir_node **in, type *tp)
{
ir_node **r_in;
ir_node *res;
res = new_ir_node (db, irg, block, op_Call, mode_T, r_arity, r_in);
- assert(is_method_type(type));
- set_Call_type(res, type);
+ 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 *
+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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+INLINE ir_node *
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;
}
-inline ir_node *
+ir_node *
new_rd_Sel (dbg_info* db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
int arity, ir_node **in, entity *ent)
{
ir_node *res;
int r_arity;
+ assert(ent != NULL && is_entity(ent) && "entity expected in Sel construction");
+
r_arity = arity + 2;
- NEW_ARR_A (ir_node *, r_in, r_arity);
+ NEW_ARR_A (ir_node *, r_in, r_arity); /* uses alloca */
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.ltyp = static_linkage;
res->attr.s.ent = ent;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
ir_node *
-new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr, type *ent)
+new_rd_InstOf (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *store,
+ ir_node *objptr, type *ent)
{
ir_node **r_in;
ir_node *res;
res->attr.io.ent = ent;
- // res = optimize (res);
- // irn_vrfy (res);
+ /* res = optimize (res);
+ * irn_vrfy_irg (res, irg); */
return (res);
}
-inline ir_node *
+INLINE ir_node *
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_I;
- res = new_ir_node (db, irg, block, op_SymConst, mode, 0, in);
+ mode = mode_Iu;
+ 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;
}
-ir_node *
+INLINE ir_node *
new_rd_Sync (dbg_info* db, ir_graph *irg, ir_node *block, int arity, ir_node **in)
{
ir_node *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;
}
-ir_node *
-new_rd_Bad ()
+INLINE ir_node *
+new_rd_Bad (ir_graph *irg)
{
- return current_ir_graph->bad;
+ return irg->bad;
}
-ir_node *
-new_rd_Unknown ()
+INLINE ir_node *
+new_rd_Confirm (dbg_info *db, ir_graph *irg, ir_node *block, ir_node *val, ir_node *bound, pn_Cmp cmp)
+{
+ ir_node *in[2], *res;
+ 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);
+ irn_vrfy_irg(res, irg);
+ return res;
+}
+
+INLINE ir_node *
+new_rd_Unknown (ir_graph *irg, ir_mode *m)
{
- return current_ir_graph->unknown;
+ return new_ir_node (NULL, irg, irg->start_block, op_Unknown, m, 0, NULL);
}
-ir_node *
+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.irg = irg;
res->attr.callbegin.call = call;
- res = optimize (res);
- irn_vrfy (res);
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
return res;
}
-ir_node *
+INLINE ir_node *
new_rd_EndReg (dbg_info *db, ir_graph *irg, ir_node *block)
{
ir_node *res;
res = new_ir_node (db, irg, block, op_EndReg, mode_T, -1, NULL);
- res->attr.end.irg = irg;
+ //res->attr.end.irg = irg;
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
-ir_node *
+INLINE ir_node *
new_rd_EndExcept (dbg_info *db, ir_graph *irg, ir_node *block)
{
ir_node *res;
res = new_ir_node (db, irg, block, op_EndExcept, mode_T, -1, NULL);
- res->attr.end.irg = irg;
+ //res->attr.end.irg = irg;
- irn_vrfy (res);
+ irn_vrfy_irg (res, irg);
return res;
}
-inline ir_node *
+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;
}
-ir_node *
+INLINE ir_node *
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;
+ res->attr.filter.backedge = NULL;
assert(res);
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 *new_r_Block (ir_graph *irg, int arity, ir_node **in) {
+ir_node *
+new_rd_FuncCall (dbg_info* db, ir_graph *irg, ir_node *block,
+ ir_node *callee, int arity, ir_node **in, type *tp)
+{
+ ir_node **r_in;
+ ir_node *res;
+ int r_arity;
+
+ r_arity = arity+1;
+ NEW_ARR_A (ir_node *, r_in, r_arity);
+ r_in[0] = callee;
+ memcpy (&r_in[1], in, sizeof (ir_node *) * arity);
+
+ res = new_ir_node (db, irg, block, op_FuncCall, mode_T, r_arity, r_in);
+
+ assert(is_method_type(tp));
+ set_FuncCall_type(res, tp);
+ res->attr.call.callee_arr = NULL;
+ res = optimize_node (res);
+ irn_vrfy_irg (res, irg);
+ return res;
+}
+
+
+INLINE ir_node *new_r_Block (ir_graph *irg, int arity, ir_node **in) {
return new_rd_Block(NULL, irg, arity, in);
}
-ir_node *new_r_Start (ir_graph *irg, ir_node *block) {
+INLINE ir_node *new_r_Start (ir_graph *irg, ir_node *block) {
return new_rd_Start(NULL, irg, block);
}
-ir_node *new_r_End (ir_graph *irg, ir_node *block) {
+INLINE ir_node *new_r_End (ir_graph *irg, ir_node *block) {
return new_rd_End(NULL, irg, block);
}
-ir_node *new_r_Jmp (ir_graph *irg, ir_node *block) {
+INLINE ir_node *new_r_Jmp (ir_graph *irg, ir_node *block) {
return new_rd_Jmp(NULL, irg, block);
}
-ir_node *new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c) {
+INLINE ir_node *new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c) {
return new_rd_Cond(NULL, irg, block, c);
}
-ir_node *new_r_Return (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Return (ir_graph *irg, ir_node *block,
ir_node *store, int arity, ir_node **in) {
return new_rd_Return(NULL, irg, block, store, arity, in);
}
-ir_node *new_r_Raise (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Raise (ir_graph *irg, ir_node *block,
ir_node *store, ir_node *obj) {
return new_rd_Raise(NULL, irg, block, store, obj);
}
-ir_node *new_r_Const (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Const (ir_graph *irg, ir_node *block,
ir_mode *mode, tarval *con) {
return new_rd_Const(NULL, irg, block, mode, con);
}
-ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_SymConst (ir_graph *irg, ir_node *block,
type_or_id_p value, symconst_kind symkind) {
return new_rd_SymConst(NULL, irg, block, value, symkind);
}
-ir_node *new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *objptr, int n_index, ir_node **index,
- entity *ent) {
+INLINE ir_node *new_r_Sel (ir_graph *irg, ir_node *block, ir_node *store,
+ ir_node *objptr, int n_index, ir_node **index,
+ entity *ent) {
return new_rd_Sel(NULL, irg, block, store, objptr, n_index, index, ent);
}
-ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
- type *ent) {
+INLINE ir_node *new_r_InstOf (ir_graph *irg, ir_node *block, ir_node *store, ir_node *objptr,
+ type *ent) {
return (new_rd_InstOf (NULL, irg, block, store, objptr, ent));
}
-ir_node *new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
- ir_node *callee, int arity, ir_node **in,
- type *type) {
- return new_rd_Call(NULL, irg, block, store, callee, arity, in, type);
+INLINE ir_node *new_r_Call (ir_graph *irg, ir_node *block, ir_node *store,
+ ir_node *callee, int arity, ir_node **in,
+ type *tp) {
+ return new_rd_Call(NULL, irg, block, store, callee, arity, in, tp);
}
-ir_node *new_r_Add (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+INLINE ir_node *new_r_Add (ir_graph *irg, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Add(NULL, irg, block, op1, op2, mode);
}
-ir_node *new_r_Sub (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+INLINE ir_node *new_r_Sub (ir_graph *irg, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Sub(NULL, irg, block, op1, op2, mode);
}
-ir_node *new_r_Minus (ir_graph *irg, ir_node *block,
- ir_node *op, ir_mode *mode) {
+INLINE ir_node *new_r_Minus (ir_graph *irg, ir_node *block,
+ ir_node *op, ir_mode *mode) {
return new_rd_Minus(NULL, irg, block, op, mode);
}
-ir_node *new_r_Mul (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+INLINE ir_node *new_r_Mul (ir_graph *irg, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Mul(NULL, irg, block, op1, op2, mode);
}
-ir_node *new_r_Quot (ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2) {
+INLINE ir_node *new_r_Quot (ir_graph *irg, ir_node *block,
+ ir_node *memop, ir_node *op1, ir_node *op2) {
return new_rd_Quot(NULL, irg, block, memop, op1, op2);
}
-ir_node *new_r_DivMod (ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2) {
+INLINE ir_node *new_r_DivMod (ir_graph *irg, ir_node *block,
+ ir_node *memop, ir_node *op1, ir_node *op2) {
return new_rd_DivMod(NULL, irg, block, memop, op1, op2);
}
-ir_node *new_r_Div (ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2) {
+INLINE ir_node *new_r_Div (ir_graph *irg, ir_node *block,
+ ir_node *memop, ir_node *op1, ir_node *op2) {
return new_rd_Div(NULL, irg, block, memop, op1, op2);
}
-ir_node *new_r_Mod (ir_graph *irg, ir_node *block,
- ir_node *memop, ir_node *op1, ir_node *op2) {
+INLINE ir_node *new_r_Mod (ir_graph *irg, ir_node *block,
+ ir_node *memop, ir_node *op1, ir_node *op2) {
return new_rd_Mod(NULL, irg, block, memop, op1, op2);
}
-ir_node *new_r_Abs (ir_graph *irg, ir_node *block,
- ir_node *op, ir_mode *mode) {
+INLINE ir_node *new_r_Abs (ir_graph *irg, ir_node *block,
+ ir_node *op, ir_mode *mode) {
return new_rd_Abs(NULL, irg, block, op, mode);
}
-ir_node *new_r_And (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+INLINE ir_node *new_r_And (ir_graph *irg, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_And(NULL, irg, block, op1, op2, mode);
}
-ir_node *new_r_Or (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+INLINE ir_node *new_r_Or (ir_graph *irg, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Or(NULL, irg, block, op1, op2, mode);
}
-ir_node *new_r_Eor (ir_graph *irg, ir_node *block,
- ir_node *op1, ir_node *op2, ir_mode *mode) {
+INLINE ir_node *new_r_Eor (ir_graph *irg, ir_node *block,
+ ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_rd_Eor(NULL, irg, block, op1, op2, mode);
}
-ir_node *new_r_Not (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Not (ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode) {
return new_rd_Not(NULL, irg, block, op, mode);
}
-ir_node *new_r_Cmp (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Cmp (ir_graph *irg, ir_node *block,
ir_node *op1, ir_node *op2) {
return new_rd_Cmp(NULL, irg, block, op1, op2);
}
-ir_node *new_r_Shl (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Shl (ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode) {
return new_rd_Shl(NULL, irg, block, op, k, mode);
}
-ir_node *new_r_Shr (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Shr (ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode) {
return new_rd_Shr(NULL, irg, block, op, k, mode);
}
-ir_node *new_r_Shrs (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Shrs (ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode) {
return new_rd_Shrs(NULL, irg, block, op, k, mode);
}
-ir_node *new_r_Rot (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Rot (ir_graph *irg, ir_node *block,
ir_node *op, ir_node *k, ir_mode *mode) {
return new_rd_Rot(NULL, irg, block, op, k, mode);
}
-ir_node *new_r_Conv (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Conv (ir_graph *irg, ir_node *block,
ir_node *op, ir_mode *mode) {
return new_rd_Conv(NULL, irg, block, op, mode);
}
-ir_node *new_r_Phi (ir_graph *irg, ir_node *block, int arity,
+INLINE ir_node *new_r_Cast (ir_graph *irg, ir_node *block, ir_node *op, type *to_tp) {
+ return new_rd_Cast(NULL, irg, block, op, to_tp);
+}
+INLINE ir_node *new_r_Phi (ir_graph *irg, ir_node *block, int arity,
ir_node **in, ir_mode *mode) {
return new_rd_Phi(NULL, irg, block, arity, in, mode);
}
-ir_node *new_r_Load (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Load (ir_graph *irg, ir_node *block,
ir_node *store, ir_node *adr) {
return new_rd_Load(NULL, irg, block, store, adr);
}
-ir_node *new_r_Store (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Store (ir_graph *irg, ir_node *block,
ir_node *store, ir_node *adr, ir_node *val) {
return new_rd_Store(NULL, irg, block, store, adr, val);
}
-ir_node *new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
+INLINE ir_node *new_r_Alloc (ir_graph *irg, ir_node *block, ir_node *store,
ir_node *size, type *alloc_type, where_alloc where) {
return new_rd_Alloc(NULL, irg, block, store, size, alloc_type, where);
}
-ir_node *new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
+INLINE ir_node *new_r_Free (ir_graph *irg, ir_node *block, ir_node *store,
ir_node *ptr, ir_node *size, type *free_type) {
return new_rd_Free(NULL, irg, block, store, ptr, size, free_type);
}
-ir_node *new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in) {
+INLINE ir_node *new_r_Sync (ir_graph *irg, ir_node *block, int arity, ir_node **in) {
return new_rd_Sync(NULL, irg, block, arity, in);
}
-ir_node *new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg,
+INLINE ir_node *new_r_Proj (ir_graph *irg, ir_node *block, ir_node *arg,
ir_mode *mode, long proj) {
return new_rd_Proj(NULL, irg, block, arg, mode, proj);
}
-ir_node *new_r_defaultProj (ir_graph *irg, ir_node *block, ir_node *arg,
+INLINE ir_node *new_r_defaultProj (ir_graph *irg, ir_node *block, ir_node *arg,
long max_proj) {
return new_rd_defaultProj(NULL, irg, block, arg, max_proj);
}
-ir_node *new_r_Tuple (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Tuple (ir_graph *irg, ir_node *block,
int arity, ir_node **in) {
return new_rd_Tuple(NULL, irg, block, arity, in );
}
-ir_node *new_r_Id (ir_graph *irg, ir_node *block,
+INLINE ir_node *new_r_Id (ir_graph *irg, ir_node *block,
ir_node *val, ir_mode *mode) {
return new_rd_Id(NULL, irg, block, val, mode);
}
-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_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);
}
-ir_node *new_r_Unknown () {
- return new_rd_Unknown();
+INLINE ir_node *new_r_Unknown (ir_graph *irg, ir_mode *m) {
+ return new_rd_Unknown(irg, m);
}
-ir_node *new_r_CallBegin (ir_graph *irg, ir_node *block, ir_node *callee) {
+INLINE ir_node *new_r_CallBegin (ir_graph *irg, ir_node *block, ir_node *callee) {
return new_rd_CallBegin(NULL, irg, block, callee);
}
-ir_node *new_r_EndReg (ir_graph *irg, ir_node *block) {
+INLINE ir_node *new_r_EndReg (ir_graph *irg, ir_node *block) {
return new_rd_EndReg(NULL, irg, block);
}
-ir_node *new_r_EndExcept (ir_graph *irg, ir_node *block) {
+INLINE ir_node *new_r_EndExcept (ir_graph *irg, ir_node *block) {
return new_rd_EndExcept(NULL, irg, block);
}
-ir_node *new_r_Break (ir_graph *irg, ir_node *block) {
+INLINE ir_node *new_r_Break (ir_graph *irg, ir_node *block) {
return new_rd_Break(NULL, irg, block);
}
-ir_node *new_r_Filter (ir_graph *irg, ir_node *block, ir_node *arg,
+INLINE ir_node *new_r_Filter (ir_graph *irg, ir_node *block, ir_node *arg,
ir_mode *mode, long proj) {
return new_rd_Filter(NULL, irg, block, arg, mode, proj);
}
+INLINE ir_node *new_r_FuncCall (ir_graph *irg, ir_node *block,
+ ir_node *callee, int arity, ir_node **in,
+ type *tp) {
+ return new_rd_FuncCall(NULL, irg, block, callee, arity, in, tp);
+}
/** ********************/
/** 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->attr.start.irg = current_ir_graph;
- 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;
}
* *************************************************************************** */
/* Creates a Phi node with 0 predecessors */
-inline ir_node *
+static INLINE ir_node *
new_rd_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode)
{
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;
}
to model this stack, now it is explicit. This reduces side effects.
*/
#if USE_EXPLICIT_PHI_IN_STACK
-Phi_in_stack *
-new_Phi_in_stack() {
+INLINE Phi_in_stack *
+new_Phi_in_stack(void) {
Phi_in_stack *res;
res = (Phi_in_stack *) malloc ( sizeof (Phi_in_stack));
return res;
}
-void
+INLINE void
free_Phi_in_stack(Phi_in_stack *s) {
DEL_ARR_F(s->stack);
free(s);
}
-
-void free_to_Phi_in_stack(ir_node *phi) {
+static INLINE void
+free_to_Phi_in_stack(ir_node *phi) {
assert(get_irn_opcode(phi) == iro_Phi);
if (ARR_LEN(current_ir_graph->Phi_in_stack->stack) ==
(current_ir_graph->Phi_in_stack->pos)++;
}
-ir_node *
+static INLINE ir_node *
alloc_or_pop_from_Phi_in_stack(ir_graph *irg, ir_node *block, ir_mode *mode,
int arity, ir_node **in) {
ir_node *res;
if (pos == 0) {
/* We need to allocate a new node */
res = new_ir_node (db, irg, block, op_Phi, mode, arity, in);
+ res->attr.phi_backedge = new_backedge_arr(irg->obst, arity);
} else {
/* reuse the old node and initialize it again. */
res = stack[pos-1];
res->visited = 0;
res->link = NULL;
assert (arity >= 0);
- /* ???!!! How to free the old in array?? */
+ /* ???!!! How to free the old in array?? Not at all: on obstack ?!! */
res->in = NEW_ARR_D (ir_node *, irg->obst, (arity+1));
res->in[0] = block;
memcpy (&res->in[1], in, sizeof (ir_node *) * arity);
finds a pointer to itself and, when this routine is called again,
eliminates itself.
*/
-inline ir_node *
+static INLINE ir_node *
new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
ir_node **in, int ins)
{
res = known = alloc_or_pop_from_Phi_in_stack(irg, block, mode, ins, in);
#else
res = known = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
+ res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
#endif
/* The in-array can contain NULLs. These were returned by
get_r_value_internal if it reached the same block/definition on a
#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! */
return res;
}
-inline ir_node *
+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!
This function is called with an in-array of proper size. **/
-static inline ir_node *
+static ir_node *
phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
{
ir_node *prevBlock, *res;
block->attr.block.graph_arr[pos] = res;
} else {
/* printf(" value already computed by %s\n",
- id_to_str(block->attr.block.graph_arr[pos]->op->name)); */
+ get_id_str(block->attr.block.graph_arr[pos]->op->name)); */
}
return res;
this variable was last defined in a previous block, Phi nodes are
inserted. If the part of the firm graph containing the definition
is not yet constructed, a dummy Phi node is returned. */
-inline ir_node *
+static ir_node *
get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
{
ir_node *res;
/* 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");
- assert (mode->code >= irm_f && mode->code <= irm_p);
+ 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! **/
#if USE_EXPLICIT_PHI_IN_STACK
/* Just dummies */
-Phi_in_stack * new_Phi_in_stack() { return NULL; }
-void free_Phi_in_stack(Phi_in_stack *s) { }
+INLINE Phi_in_stack * new_Phi_in_stack() { return NULL; }
+INLINE void free_Phi_in_stack(Phi_in_stack *s) { }
#endif
-inline ir_node *
+static INLINE ir_node *
new_rd_Phi_in (ir_graph *irg, ir_node *block, ir_mode *mode,
ir_node **in, int ins)
{
/* Allocate a new node on the obstack. The allocation copies the in
array. */
res = new_ir_node (NULL, irg, block, op_Phi, mode, ins, in);
+ res->attr.phi_backedge = new_backedge_arr(irg->obst, ins);
/* This loop checks whether the Phi has more than one predecessor.
If so, it is a real Phi node and we break the loop. Else the
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))
return res;
}
-inline ir_node *
+static ir_node *
get_r_value_internal (ir_node *block, int pos, ir_mode *mode);
#if PRECISE_EXC_CONTEXT
-static inline ir_node *
+static ir_node *
phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins);
-ir_node **
-new_frag_arr (ir_node *n) {
+static INLINE ir_node ** new_frag_arr (ir_node *n)
+{
ir_node **arr;
int opt;
arr = NEW_ARR_D (ir_node *, current_ir_graph->obst, current_ir_graph->n_loc);
sizeof(ir_node *)*current_ir_graph->n_loc);
/* turn off optimization before allocating Proj nodes, as res isn't
finished yet. */
- opt = get_optimize(); set_optimize(0);
+ opt = get_opt_optimize(); set_optimize(0);
/* Here we rely on the fact that all frag ops have Memory as first result! */
if (get_irn_op(n) == op_Call)
arr[0] = new_Proj(n, mode_M, 3);
return arr;
}
-inline ir_node **
+static INLINE ir_node **
get_frag_arr (ir_node *n) {
if (get_irn_op(n) == op_Call) {
return n->attr.call.frag_arr;
}
}
-void
+static void
set_frag_value(ir_node **frag_arr, int pos, ir_node *val) {
if (!frag_arr[pos]) frag_arr[pos] = val;
if (frag_arr[current_ir_graph->n_loc - 1])
set_frag_value (get_frag_arr(frag_arr[current_ir_graph->n_loc - 1]), pos, val);
}
-inline ir_node *
+static ir_node *
get_r_frag_value_internal (ir_node *block, ir_node *cfOp, int pos, ir_mode *mode) {
ir_node *res;
ir_node **frag_arr;
}
#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.
- This function is called with an in-array of proper size. **/
-static inline ir_node *
+ This function must be called with an in-array of proper size. **/
+static ir_node *
phi_merge (ir_node *block, int pos, ir_mode *mode, ir_node **nin, int ins)
{
ir_node *prevBlock, *prevCfOp, *res, *phi0;
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. */
+ There are none by definition. */
return block->attr.block.graph_arr[pos];
} else {
phi0 = new_rd_Phi0(current_ir_graph, block, mode);
block->attr.block.graph_arr[pos] = phi0;
#if PRECISE_EXC_CONTEXT
/* Set graph_arr for fragile ops. Also here we should break recursion.
- We could choose a cyclic path through an cfop. But the recursion would
- break at some point. */
+ We could choose a cyclic path through an cfop. But the recursion would
+ break at some point. */
set_frag_value(block->attr.block.graph_arr, pos, phi0);
#endif
}
assert (prevCfOp);
if (is_Bad(prevCfOp)) {
/* In case a Cond has been optimized we would get right to the start block
- with an invalid definition. */
+ with an invalid definition. */
nin[i-1] = new_Bad();
continue;
}
if (!is_Bad(prevBlock)) {
#if PRECISE_EXC_CONTEXT
if (is_fragile_op(prevCfOp) && (get_irn_op (prevCfOp) != op_Bad)) {
- assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
- nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
+ assert(get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode));
+ nin[i-1] = get_r_frag_value_internal (prevBlock, prevCfOp, pos, mode);
} else
#endif
- nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
+ nin[i-1] = get_r_value_internal (prevBlock, pos, mode);
} else {
nin[i-1] = new_Bad();
}
this variable was last defined in a previous block, Phi nodes are
inserted. If the part of the firm graph containing the definition
is not yet constructed, a dummy Phi node is returned. */
-inline ir_node *
+static ir_node *
get_r_value_internal (ir_node *block, int pos, ir_mode *mode)
{
ir_node *res;
/* 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");
- assert (mode->code >= irm_f && mode->code <= irm_p);
+ 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. */
ir_node *next;
assert (get_irn_opcode(block) == iro_Block);
- // assert (!get_Block_matured(block) && "Block already matured");
+ /* @@@ should be commented in
+ assert (!get_Block_matured(block) && "Block already matured"); */
if (!get_Block_matured(block)) {
+ ins = ARR_LEN (block->in)-1;
+ /* Fix block parameters */
+ block->attr.block.backedge = new_backedge_arr(current_ir_graph->obst, ins);
/* An array for building the Phi nodes. */
- ins = ARR_LEN (block->in)-1;
NEW_ARR_A (ir_node *, nin, ins);
- /* shouldn't we delete this array at the end of the procedure? @@@ memory leak? */
/* Traverse a chain of Phi nodes attached to this block and mature
these, too. **/
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);
}
}
mode, con);
}
+ir_node *
+new_d_Const_type (dbg_info* db, ir_mode *mode, tarval *con, type *tp)
+{
+ return new_rd_Const_type (db, current_ir_graph, current_ir_graph->start_block,
+ mode, con, tp);
+}
+
+
ir_node *
new_d_Id (dbg_info* db, ir_node *val, ir_mode *mode)
{
new_d_defaultProj (dbg_info* db, ir_node *arg, long max_proj)
{
ir_node *res;
- assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_I));
+ assert((arg->op==op_Cond) && (get_irn_mode(arg->in[1]) == mode_Iu));
arg->attr.c.kind = fragmentary;
arg->attr.c.default_proj = max_proj;
res = new_Proj (arg, mode_X, max_proj);
op, mode);
}
+ir_node *
+new_d_Cast (dbg_info* db, ir_node *op, type *to_tp)
+{
+ return new_rd_Cast (db, current_ir_graph, current_ir_graph->current_block, op, to_tp);
+}
+
ir_node *
new_d_Tuple (dbg_info* db, int arity, ir_node **in)
{
ir_node *
new_d_Call (dbg_info* db, ir_node *store, ir_node *callee, int arity, ir_node **in,
- type *type)
+ type *tp)
{
ir_node *res;
res = new_rd_Call (db, current_ir_graph, current_ir_graph->current_block,
- store, callee, arity, in, type);
+ store, callee, arity, in, tp);
#if PRECISE_EXC_CONTEXT
if ((current_ir_graph->phase_state == phase_building) &&
(get_irn_op(res) == op_Call)) /* Could be optimized away. */
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);
}
new_d_Sync (dbg_info* db, int arity, ir_node** in)
{
return new_rd_Sync (db, current_ir_graph, current_ir_graph->current_block,
- arity, in);
+ arity, in);
}
}
ir_node *
-new_d_Unknown (void)
+new_d_Confirm (dbg_info *db, ir_node *val, ir_node *bound, pn_Cmp cmp)
+{
+ return new_rd_Confirm (db, current_ir_graph, current_ir_graph->current_block,
+ val, bound, cmp);
+}
+
+ir_node *
+new_d_Unknown (ir_mode *m)
{
- return current_ir_graph->unknown;
+ return new_rd_Unknown(current_ir_graph, m);
}
ir_node *
arg, mode, proj);
}
+ir_node *
+new_d_FuncCall (dbg_info* db, ir_node *callee, int arity, ir_node **in,
+ type *tp)
+{
+ ir_node *res;
+ res = new_rd_FuncCall (db, current_ir_graph, current_ir_graph->current_block,
+ callee, arity, in, tp);
+
+ return res;
+}
+
/* ********************************************************************* */
/* Comfortable interface with automatic Phi node construction. */
/* (Uses also constructors of ?? interface, except new_Block. */
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_R, -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.exc = exc_normal;
- res->attr.block.handler_entry = 0;
+ //res->attr.block.exc = exc_normal;
+ //res->attr.block.handler_entry = 0;
+ res->attr.block.irg = current_ir_graph;
+ res->attr.block.backedge = NULL;
res->attr.block.in_cg = NULL;
+ res->attr.block.cg_backedge = NULL;
set_Block_block_visited(res, 0);
/* Create and initialize array for Phi-node construction. */
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;
}
-inline ir_node *
+INLINE ir_node *
new_immBlock () {
return new_d_immBlock(NULL);
}
return get_r_value_internal (current_ir_graph->current_block, pos + 1, mode);
}
/* get a value from the parameter array from the current block by its index */
-inline ir_node *
+INLINE ir_node *
get_value (int pos, ir_mode *mode)
{
return get_d_value(NULL, pos, mode);
}
/* set a value at position pos in the parameter array from the current block */
-inline void
+INLINE void
set_value (int pos, ir_node *value)
{
assert(get_irg_phase_state (current_ir_graph) == phase_building);
+ assert(pos+1 < current_ir_graph->n_loc);
current_ir_graph->current_block->attr.block.graph_arr[pos + 1] = value;
}
/* get the current store */
-inline ir_node *
+INLINE ir_node *
get_store (void)
{
assert(get_irg_phase_state (current_ir_graph) == phase_building);
}
/* set the current store */
-inline void
+INLINE void
set_store (ir_node *store)
{
- assert(get_irg_phase_state (current_ir_graph) == phase_building);
/* GL: one could call set_value instead */
+ assert(get_irg_phase_state (current_ir_graph) == phase_building);
current_ir_graph->current_block->attr.block.graph_arr[0] = store;
}
-inline void
+void
keep_alive (ir_node *ka)
{
add_End_keepalive(current_ir_graph->end, ka);
/* 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 */
ir_node *new_Cond (ir_node *c) {
return new_d_Cond(NULL, c);
}
-ir_node *new_Return (ir_node *store, int arity, ir_node **in) {
+ir_node *new_Return (ir_node *store, int arity, ir_node *in[]) {
return new_d_Return(NULL, store, arity, in);
}
ir_node *new_Raise (ir_node *store, ir_node *obj) {
return new_d_Sel(NULL, store, objptr, arity, in, ent);
}
ir_node *new_InstOf (ir_node *store, ir_node *objptr, type *ent) {
- return (new_d_InstOf (NULL, store, objptr, ent));
+ return new_d_InstOf (NULL, store, objptr, ent);
}
ir_node *new_Call (ir_node *store, ir_node *callee, int arity, ir_node **in,
- type *type) {
- return new_d_Call(NULL, store, callee, arity, in, type);
+ type *tp) {
+ return new_d_Call(NULL, store, callee, arity, in, tp);
}
ir_node *new_Add (ir_node *op1, ir_node *op2, ir_mode *mode) {
return new_d_Add(NULL, op1, op2, mode);
ir_node *new_Conv (ir_node *op, ir_mode *mode) {
return new_d_Conv(NULL, op, mode);
}
+ir_node *new_Cast (ir_node *op, type *to_tp) {
+ return new_d_Cast(NULL, op, to_tp);
+}
ir_node *new_Phi (int arity, ir_node **in, ir_mode *mode) {
return new_d_Phi(NULL, arity, in, mode);
}
ir_node *new_Bad (void) {
return new_d_Bad();
}
-ir_node *new_Unknown(void) {
- return new_d_Unknown();
+ir_node *new_Confirm (ir_node *val, ir_node *bound, pn_Cmp cmp) {
+ return new_d_Confirm (NULL, val, bound, cmp);
+}
+ir_node *new_Unknown(ir_mode *m) {
+ return new_d_Unknown(m);
}
ir_node *new_CallBegin (ir_node *callee) {
return new_d_CallBegin(NULL, callee);
ir_node *new_Filter (ir_node *arg, ir_mode *mode, long proj) {
return new_d_Filter(NULL, arg, mode, proj);
}
+ir_node *new_FuncCall (ir_node *callee, int arity, ir_node **in, type *tp) {
+ return new_d_FuncCall(NULL, callee, arity, in, tp);
+}
projects / libfirm / blobdiff