-/* 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
-*/
+/*
+ * 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.
+ */
-/* $Id$ */
#ifdef HAVE_CONFIG_H
# include <config.h>
ir_node *res;
res = new_ir_node (db, irg, block, op_Start, mode_T, 0, NULL);
+ res->attr.start.irg = irg;
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_node (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.
}
INLINE ir_node *
-new_rd_Const (dbg_info* db, ir_graph *irg, ir_node *block, ir_mode *mode, tarval *con)
+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->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
return res;
}
+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_node (res);
irn_vrfy_irg (res, irg);
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;
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_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;
}
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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_node (res);
irn_vrfy_irg (res, irg);
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;
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_node (res);
irn_vrfy_irg (res, irg);
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_node (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_node (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;
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;
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;
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, NULL);
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;
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;
ir_node *op, ir_mode *mode) {
return new_rd_Conv(NULL, irg, block, op, mode);
}
+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);
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_node (res);
irn_vrfy_irg (res, current_ir_graph);
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_node (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_irg (res, current_ir_graph);
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;
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)
{
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_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);
}
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);
}
projects / libfirm / blobdiff