/*
- * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved.
+ * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
*
* This file is part of libFirm.
*
#include "irnode_t.h"
#include "irgraph_t.h"
#include "irmode_t.h"
-#include "typegmod.h"
#include "irbackedge_t.h"
#include "irdump.h"
#include "irop_t.h"
* returns the pnc name from an pnc constant
*/
const char *get_pnc_string(int pnc) {
+ assert(pnc >= 0 && pnc <
+ (int) (sizeof(pnc_name_arr)/sizeof(pnc_name_arr[0])));
return pnc_name_arr[pnc];
}
/*
* Calculates the negated (Complement(R)) pnc condition.
*/
-int get_negated_pnc(int pnc, ir_mode *mode) {
+pn_Cmp get_negated_pnc(long pnc, ir_mode *mode) {
pnc ^= pn_Cmp_True;
/* do NOT add the Uo bit for non-floating point values */
if (! mode_is_float(mode))
pnc &= ~pn_Cmp_Uo;
- return pnc;
+ return (pn_Cmp) pnc;
}
/* Calculates the inversed (R^-1) pnc condition, i.e., "<" --> ">" */
-int
-get_inversed_pnc(int pnc) {
- int code = pnc & ~(pn_Cmp_Lt|pn_Cmp_Gt);
- int lesser = pnc & pn_Cmp_Lt;
- int greater = pnc & pn_Cmp_Gt;
+pn_Cmp get_inversed_pnc(long pnc) {
+ long code = pnc & ~(pn_Cmp_Lt|pn_Cmp_Gt);
+ long lesser = pnc & pn_Cmp_Lt;
+ long greater = pnc & pn_Cmp_Gt;
code |= (lesser ? pn_Cmp_Gt : 0) | (greater ? pn_Cmp_Lt : 0);
- return code;
+ return (pn_Cmp) code;
}
/**
/* register new space for every node */
-unsigned register_additional_node_data(unsigned size) {
+unsigned firm_register_additional_node_data(unsigned size) {
assert(!forbid_new_data && "Too late to register additional node data");
if (forbid_new_data)
* If arity is negative, a node with a dynamic array is created.
*/
ir_node *
-new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
- int arity, ir_node **in)
+new_ir_node(dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
+ int arity, ir_node **in)
{
ir_node *res;
size_t node_size = offsetof(ir_node, attr) + op->attr_size + firm_add_node_size;
_set_irn_op(node, op);
}
-ir_opcode
+unsigned
(get_irn_opcode)(const ir_node *node) {
return _get_irn_opcode(node);
}
}
#else
/* Dummies needed for firmjni. */
-struct abstval *get_irn_abst_value(ir_node *n) { return NULL; }
-void set_irn_abst_value(ir_node *n, struct abstval *os) {}
-struct section *firm_get_irn_section(ir_node *n) { return NULL; }
-void firm_set_irn_section(ir_node *n, struct section *s) {}
+struct abstval *get_irn_abst_value(ir_node *n) {
+ (void) n;
+ return NULL;
+}
+void set_irn_abst_value(ir_node *n, struct abstval *os) {
+ (void) n;
+ (void) os;
+}
+struct section *firm_get_irn_section(ir_node *n) {
+ (void) n;
+ return NULL;
+}
+void firm_set_irn_section(ir_node *n, struct section *s) {
+ (void) n;
+ (void) s;
+}
#endif /* DO_HEAPANALYSIS */
#endif
}
-const_attr
+const_attr *
get_irn_const_attr(ir_node *node) {
assert(node->op == op_Const);
- return node->attr.con;
+ return &node->attr.con;
}
long
return node->attr.proj;
}
-alloc_attr
+alloc_attr *
get_irn_alloc_attr(ir_node *node) {
assert(node->op == op_Alloc);
- return node->attr.alloc;
+ return &node->attr.alloc;
}
-free_attr
+free_attr *
get_irn_free_attr(ir_node *node) {
assert(node->op == op_Free);
- return node->attr.free;
+ return &node->attr.free;
}
-symconst_attr
+symconst_attr *
get_irn_symconst_attr(ir_node *node) {
assert(node->op == op_SymConst);
- return node->attr.symc;
+ return &node->attr.symc;
}
ir_type *
return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
}
-sel_attr
+sel_attr *
get_irn_sel_attr(ir_node *node) {
assert(node->op == op_Sel);
- return node->attr.sel;
+ return &node->attr.sel;
}
int
return node->attr.phi0.pos;
}
-block_attr
+block_attr *
get_irn_block_attr(ir_node *node) {
assert(node->op == op_Block);
- return node->attr.block;
+ return &node->attr.block;
}
-load_attr
+load_attr *
get_irn_load_attr(ir_node *node) {
assert(node->op == op_Load);
- return node->attr.load;
+ return &node->attr.load;
}
-store_attr
+store_attr *
get_irn_store_attr(ir_node *node) {
assert(node->op == op_Store);
- return node->attr.store;
+ return &node->attr.store;
}
-except_attr
+except_attr *
get_irn_except_attr(ir_node *node) {
assert(node->op == op_Div || node->op == op_Quot ||
node->op == op_DivMod || node->op == op_Mod || node->op == op_Call || node->op == op_Alloc);
- return node->attr.except;
+ return &node->attr.except;
}
void *(get_irn_generic_attr)(ir_node *node) {
ir_node *
get_nodes_block(const ir_node *node) {
assert(node->op != op_Block);
- assert(is_irn_pinned_in_irg(node) && "block info may be incorrect");
return get_irn_n(node, -1);
}
set_irn_n(node, -1, block);
}
+/* this works for all except Block */
+ir_node *
+get_nodes_MacroBlock(const ir_node *node) {
+ assert(node->op != op_Block);
+ return get_Block_MacroBlock(get_irn_n(node, -1));
+}
+
/* Test whether arbitrary node is frame pointer, i.e. Proj(pn_Start_P_frame_base)
* from Start. If so returns frame type, else Null. */
-ir_type *is_frame_pointer(ir_node *n) {
+ir_type *is_frame_pointer(const ir_node *n) {
if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_frame_base)) {
ir_node *start = get_Proj_pred(n);
- if (get_irn_op(start) == op_Start) {
+ if (is_Start(start)) {
return get_irg_frame_type(get_irn_irg(start));
}
}
/* Test whether arbitrary node is globals pointer, i.e. Proj(pn_Start_P_globals)
* from Start. If so returns global type, else Null. */
-ir_type *is_globals_pointer(ir_node *n) {
+ir_type *is_globals_pointer(const ir_node *n) {
if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
ir_node *start = get_Proj_pred(n);
- if (get_irn_op(start) == op_Start) {
+ if (is_Start(start)) {
return get_glob_type();
}
}
/* Test whether arbitrary node is tls pointer, i.e. Proj(pn_Start_P_tls)
* from Start. If so returns tls type, else Null. */
-ir_type *is_tls_pointer(ir_node *n) {
+ir_type *is_tls_pointer(const ir_node *n) {
if (is_Proj(n) && (get_Proj_proj(n) == pn_Start_P_globals)) {
ir_node *start = get_Proj_pred(n);
- if (get_irn_op(start) == op_Start) {
+ if (is_Start(start)) {
return get_tls_type();
}
}
/* Test whether arbitrary node is value arg base, i.e. Proj(pn_Start_P_value_arg_base)
* from Start. If so returns 1, else 0. */
-int is_value_arg_pointer(ir_node *n) {
- if ((get_irn_op(n) == op_Proj) &&
+int is_value_arg_pointer(const ir_node *n) {
+ if (is_Proj(n) &&
(get_Proj_proj(n) == pn_Start_P_value_arg_base) &&
- (get_irn_op(get_Proj_pred(n)) == op_Start))
+ is_Start(get_Proj_pred(n)))
return 1;
return 0;
}
}
ir_node *
-(get_Block_cfgpred)(ir_node *node, int pos) {
+(get_Block_cfgpred)(const ir_node *node, int pos) {
return _get_Block_cfgpred(node, pos);
}
}
ir_node *
-(get_Block_cfgpred_block)(ir_node *node, int pos) {
+(get_Block_cfgpred_block)(const ir_node *node, int pos) {
return _get_Block_cfgpred_block(node, pos);
}
int
-get_Block_matured(ir_node *node) {
+get_Block_matured(const ir_node *node) {
assert(node->op == op_Block);
return (int)node->attr.block.is_matured;
}
}
ir_node *
-get_Block_graph_arr (ir_node *node, int pos) {
+get_Block_graph_arr(ir_node *node, int pos) {
assert(node->op == op_Block);
return node->attr.block.graph_arr[pos+1];
}
void
-set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
+set_Block_graph_arr(ir_node *node, int pos, ir_node *value) {
assert(node->op == op_Block);
node->attr.block.graph_arr[pos+1] = value;
}
+#ifdef INTERPROCEDURAL_VIEW
void set_Block_cg_cfgpred_arr(ir_node *node, int arity, ir_node *in[]) {
assert(node->op == op_Block);
if (node->attr.block.in_cg == NULL || arity != ARR_LEN(node->attr.block.in_cg) - 1) {
return node->attr.block.in_cg == NULL ? NULL : node->attr.block.in_cg + 1;
}
-int get_Block_cg_n_cfgpreds(ir_node *node) {
+int get_Block_cg_n_cfgpreds(const ir_node *node) {
assert(node->op == op_Block);
return node->attr.block.in_cg == NULL ? 0 : ARR_LEN(node->attr.block.in_cg) - 1;
}
-ir_node *get_Block_cg_cfgpred(ir_node *node, int pos) {
+ir_node *get_Block_cg_cfgpred(const ir_node *node, int pos) {
assert(node->op == op_Block && node->attr.block.in_cg);
return node->attr.block.in_cg[pos + 1];
}
assert(node->op == op_Block);
node->attr.block.in_cg = NULL;
}
+#endif
ir_node *(set_Block_dead)(ir_node *block) {
return _set_Block_dead(block);
block->attr.block.extblk = extblk;
}
+/* returns the macro block header of a block. */
ir_node *get_Block_MacroBlock(const ir_node *block) {
+ ir_node *mbh;
+ assert(is_Block(block));
+ mbh = get_irn_n(block, -1);
+ /* once macro block header is respected by all optimizations,
+ this assert can be removed */
+ assert(mbh != NULL);
+ return mbh;
+}
+
+/* returns the graph of a Block. */
+ir_graph *get_Block_irg(const ir_node *block) {
+ assert(is_Block(block));
+ return block->attr.block.irg;
+}
+
+int has_Block_label(const ir_node *block) {
+ assert(is_Block(block));
+ return block->attr.block.has_label;
+}
+
+ir_label_t get_Block_label(const ir_node *block) {
+ assert(is_Block(block));
+ return block->attr.block.label;
+}
+
+void set_Block_label(ir_node *block, ir_label_t label) {
assert(is_Block(block));
- return get_irn_n(block, -1);
+ block->attr.block.has_label = 1;
+ block->attr.block.label = label;
}
int
-get_End_n_keepalives(ir_node *end) {
+get_End_n_keepalives(const ir_node *end) {
assert(end->op == op_End);
return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
}
ir_node *
-get_End_keepalive(ir_node *end, int pos) {
+get_End_keepalive(const ir_node *end, int pos) {
assert(end->op == op_End);
return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}
}
void
-free_End (ir_node *end) {
+free_End(ir_node *end) {
assert(end->op == op_End);
end->kind = k_BAD;
DEL_ARR_F(end->in);
}
/* Return the target address of an IJmp */
-ir_node *get_IJmp_target(ir_node *ijmp) {
+ir_node *get_IJmp_target(const ir_node *ijmp) {
assert(ijmp->op == op_IJmp);
return get_irn_n(ijmp, 0);
}
> Firm to the target machine. That could be done if there was some way of
> projecting "default" out of the Cond node.
I know it's complicated.
-Basically there are two proglems:
- - determining the gaps between the projs
+Basically there are two problems:
+ - determining the gaps between the Projs
- determining the biggest case constant to know the proj number for
the default node.
I see several solutions:
1. Introduce a ProjDefault node. Solves both problems.
This means to extend all optimizations executed during construction.
2. Give the Cond node for switch two flavors:
- a) there are no gaps in the projs (existing flavor)
+ a) there are no gaps in the Projs (existing flavor)
b) gaps may exist, default proj is still the Proj with the largest
projection number. This covers also the gaps.
3. Fix the semantic of the Cond to that of 2b)
2a).
*/
ir_node *
-get_Cond_selector(ir_node *node) {
+get_Cond_selector(const ir_node *node) {
assert(node->op == op_Cond);
return get_irn_n(node, 0);
}
}
cond_kind
-get_Cond_kind(ir_node *node) {
+get_Cond_kind(const ir_node *node) {
assert(node->op == op_Cond);
return node->attr.cond.kind;
}
}
long
-get_Cond_defaultProj(ir_node *node) {
+get_Cond_defaultProj(const ir_node *node) {
assert(node->op == op_Cond);
return node->attr.cond.default_proj;
}
ir_node *
-get_Return_mem(ir_node *node) {
+get_Return_mem(const ir_node *node) {
assert(node->op == op_Return);
return get_irn_n(node, 0);
}
}
int
-get_Return_n_ress(ir_node *node) {
+get_Return_n_ress(const ir_node *node) {
assert(node->op == op_Return);
return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
}
ir_node **
-get_Return_res_arr (ir_node *node) {
+get_Return_res_arr(ir_node *node) {
assert((node->op == op_Return));
if (get_Return_n_ress(node) > 0)
return (ir_node **)&(get_irn_in(node)[1 + RETURN_RESULT_OFFSET]);
*/
ir_node *
-get_Return_res(ir_node *node, int pos) {
+get_Return_res(const ir_node *node, int pos) {
assert(node->op == op_Return);
assert(get_Return_n_ress(node) > pos);
return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
node->attr.con.tv = con;
}
-cnst_classify_t (classify_Const)(ir_node *node) {
- return _classify_Const(node);
+int (is_Const_null)(const ir_node *node) {
+ return _is_Const_null(node);
+}
+
+int (is_Const_one)(const ir_node *node) {
+ return _is_Const_one(node);
+}
+
+int (is_Const_all_one)(const ir_node *node) {
+ return _is_Const_all_one(node);
}
ir_type *
get_Const_type(ir_node *node) {
assert(node->op == op_Const);
+ node->attr.con.tp = skip_tid(node->attr.con.tp);
return node->attr.con.tp;
}
node->attr.symc.sym = sym;
}
+ir_label_t get_SymConst_label(const ir_node *node) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
+ return node->attr.symc.sym.label;
+}
+
+void set_SymConst_label(ir_node *node, ir_label_t label) {
+ assert(node->op == op_SymConst && SYMCONST_HAS_LABEL(get_SymConst_kind(node)));
+ node->attr.symc.sym.label = label;
+}
+
ir_type *
get_SymConst_value_type(ir_node *node) {
assert(node->op == op_SymConst);
}
ir_node *
-get_Sel_mem(ir_node *node) {
+get_Sel_mem(const ir_node *node) {
assert(node->op == op_Sel);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Sel_ptr(ir_node *node) {
+get_Sel_ptr(const ir_node *node) {
assert(node->op == op_Sel);
return get_irn_n(node, 1);
}
}
int
-get_Sel_n_indexs(ir_node *node) {
+get_Sel_n_indexs(const ir_node *node) {
assert(node->op == op_Sel);
return (get_irn_arity(node) - SEL_INDEX_OFFSET);
}
}
ir_node *
-get_Sel_index(ir_node *node, int pos) {
+get_Sel_index(const ir_node *node, int pos) {
assert(node->op == op_Sel);
return get_irn_n(node, pos + SEL_INDEX_OFFSET);
}
}
ir_entity *
-get_Sel_entity(ir_node *node) {
+get_Sel_entity(const ir_node *node) {
assert(node->op == op_Sel);
return node->attr.sel.ent;
}
+ir_entity *_get_Sel_entity(ir_node *node) {
+ return get_Sel_entity(node);
+}
+
void
set_Sel_entity(ir_node *node, ir_entity *ent) {
assert(node->op == op_Sel);
ir_node *
-get_Call_mem(ir_node *node) {
+get_Call_mem(const ir_node *node) {
assert(node->op == op_Call);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Call_ptr(ir_node *node) {
+get_Call_ptr(const ir_node *node) {
assert(node->op == op_Call);
return get_irn_n(node, 1);
}
}
int
-get_Call_n_params(ir_node *node) {
+get_Call_n_params(const ir_node *node) {
assert(node->op == op_Call);
return (get_irn_arity(node) - CALL_PARAM_OFFSET);
}
int
-get_Call_arity(ir_node *node) {
+get_Call_arity(const ir_node *node) {
assert(node->op == op_Call);
return get_Call_n_params(node);
}
*/
ir_node *
-get_Call_param(ir_node *node, int pos) {
+get_Call_param(const ir_node *node, int pos) {
assert(node->op == op_Call);
return get_irn_n(node, pos + CALL_PARAM_OFFSET);
}
node->attr.call.cld_tp = tp;
}
-int Call_has_callees(ir_node *node) {
+int Call_has_callees(const ir_node *node) {
assert(node && node->op == op_Call);
return ((get_irg_callee_info_state(get_irn_irg(node)) != irg_callee_info_none) &&
(node->attr.call.callee_arr != NULL));
}
-int get_Call_n_callees(ir_node * node) {
+int get_Call_n_callees(const ir_node *node) {
assert(node && node->op == op_Call && node->attr.call.callee_arr);
return ARR_LEN(node->attr.call.callee_arr);
}
-ir_entity * get_Call_callee(ir_node * node, int pos) {
+ir_entity *get_Call_callee(const ir_node *node, int pos) {
assert(pos >= 0 && pos < get_Call_n_callees(node));
return node->attr.call.callee_arr[pos];
}
-void set_Call_callee_arr(ir_node * node, const int n, ir_entity ** arr) {
+void set_Call_callee_arr(ir_node *node, const int n, ir_entity ** arr) {
assert(node->op == op_Call);
if (node->attr.call.callee_arr == NULL || get_Call_n_callees(node) != n) {
node->attr.call.callee_arr = NEW_ARR_D(ir_entity *, current_ir_graph->obst, n);
memcpy(node->attr.call.callee_arr, arr, n * sizeof(ir_entity *));
}
-void remove_Call_callee_arr(ir_node * node) {
+void remove_Call_callee_arr(ir_node *node) {
assert(node->op == op_Call);
node->attr.call.callee_arr = NULL;
}
-ir_node * get_CallBegin_ptr(ir_node *node) {
+ir_node *get_CallBegin_ptr(const ir_node *node) {
assert(node->op == op_CallBegin);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, ptr);
}
-ir_node * get_CallBegin_call(ir_node *node) {
+ir_node *get_CallBegin_call(const ir_node *node) {
assert(node->op == op_CallBegin);
return node->attr.callbegin.call;
}
-void set_CallBegin_call(ir_node *node, ir_node *call) {
+void set_CallBegin_call(ir_node *node, ir_node *call) {
assert(node->op == op_CallBegin);
node->attr.callbegin.call = call;
}
assert(node->op == op_##OP); \
return get_irn_n(node, node->op->op_index); \
} \
-void set_##OP##_op (ir_node *node, ir_node *op) { \
+void set_##OP##_op(ir_node *node, ir_node *op) { \
assert(node->op == op_##OP); \
set_irn_n(node, node->op->op_index, op); \
}
BINOP(OP) \
\
ir_node * \
-get_##OP##_mem(ir_node *node) { \
+get_##OP##_mem(const ir_node *node) { \
assert(node->op == op_##OP); \
return get_irn_n(node, 0); \
} \
BINOP(Sub)
UNOP(Minus)
BINOP(Mul)
+BINOP(Mulh)
DIVOP(Quot)
DIVOP(DivMod)
DIVOP(Div)
UNOP(Conv)
UNOP(Cast)
-int get_Conv_strict(ir_node *node) {
+int get_Conv_strict(const ir_node *node) {
assert(node->op == op_Conv);
return node->attr.conv.strict;
}
ir_type *
get_Cast_type(ir_node *node) {
assert(node->op == op_Cast);
+ node->attr.cast.totype = skip_tid(node->attr.cast.totype);
return node->attr.cast.totype;
}
int is_Cast_upcast(ir_node *node) {
ir_type *totype = get_Cast_type(node);
ir_type *fromtype = get_irn_typeinfo_type(get_Cast_op(node));
- ir_graph *myirg = get_irn_irg(node);
- assert(get_irg_typeinfo_state(myirg) == ir_typeinfo_consistent);
+ assert(get_irg_typeinfo_state(get_irn_irg(node)) == ir_typeinfo_consistent);
assert(fromtype);
while (is_Pointer_type(totype) && is_Pointer_type(fromtype)) {
set_irn_n(node, node->op->op_index + 1, right);
}
-int is_Phi(const ir_node *n) {
- ir_op *op;
-
- assert(n);
- op = get_irn_op(n);
-
- if (op == op_Filter) return get_interprocedural_view();
-
- if (op == op_Phi)
- return ((get_irg_phase_state(get_irn_irg(n)) != phase_building) ||
- (get_irn_arity(n) > 0));
-
- return 0;
+int
+(is_Phi)(const ir_node *n) {
+ return _is_Phi(n);
}
int is_Phi0(const ir_node *n) {
}
-int is_memop(ir_node *node) {
- return ((get_irn_op(node) == op_Load) || (get_irn_op(node) == op_Store));
+int is_memop(const ir_node *node) {
+ ir_opcode code = get_irn_opcode(node);
+ return (code == iro_Load || code == iro_Store);
}
-ir_node *get_memop_mem(ir_node *node) {
+ir_node *get_memop_mem(const ir_node *node) {
assert(is_memop(node));
return get_irn_n(node, 0);
}
set_irn_n(node, 0, mem);
}
-ir_node *get_memop_ptr(ir_node *node) {
+ir_node *get_memop_ptr(const ir_node *node) {
assert(is_memop(node));
return get_irn_n(node, 1);
}
}
ir_node *
-get_Load_mem(ir_node *node) {
+get_Load_mem(const ir_node *node) {
assert(node->op == op_Load);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Load_ptr(ir_node *node) {
+get_Load_ptr(const ir_node *node) {
assert(node->op == op_Load);
return get_irn_n(node, 1);
}
}
ir_mode *
-get_Load_mode(ir_node *node) {
+get_Load_mode(const ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.load_mode;
}
}
ir_volatility
-get_Load_volatility(ir_node *node) {
+get_Load_volatility(const ir_node *node) {
assert(node->op == op_Load);
return node->attr.load.volatility;
}
node->attr.load.volatility = volatility;
}
+ir_align
+get_Load_align(const ir_node *node) {
+ assert(node->op == op_Load);
+ return node->attr.load.aligned;
+}
+
+void
+set_Load_align(ir_node *node, ir_align align) {
+ assert(node->op == op_Load);
+ node->attr.load.aligned = align;
+}
+
ir_node *
-get_Store_mem(ir_node *node) {
+get_Store_mem(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Store_ptr(ir_node *node) {
+get_Store_ptr(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 1);
}
}
ir_node *
-get_Store_value(ir_node *node) {
+get_Store_value(const ir_node *node) {
assert(node->op == op_Store);
return get_irn_n(node, 2);
}
}
ir_volatility
-get_Store_volatility(ir_node *node) {
+get_Store_volatility(const ir_node *node) {
assert(node->op == op_Store);
return node->attr.store.volatility;
}
node->attr.store.volatility = volatility;
}
+ir_align
+get_Store_align(const ir_node *node) {
+ assert(node->op == op_Store);
+ return node->attr.store.aligned;
+}
+
+void
+set_Store_align(ir_node *node, ir_align align) {
+ assert(node->op == op_Store);
+ node->attr.store.aligned = align;
+}
+
ir_node *
-get_Alloc_mem(ir_node *node) {
+get_Alloc_mem(const ir_node *node) {
assert(node->op == op_Alloc);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Alloc_size(ir_node *node) {
+get_Alloc_size(const ir_node *node) {
assert(node->op == op_Alloc);
return get_irn_n(node, 1);
}
node->attr.alloc.type = tp;
}
-where_alloc
-get_Alloc_where(ir_node *node) {
+ir_where_alloc
+get_Alloc_where(const ir_node *node) {
assert(node->op == op_Alloc);
return node->attr.alloc.where;
}
void
-set_Alloc_where(ir_node *node, where_alloc where) {
+set_Alloc_where(ir_node *node, ir_where_alloc where) {
assert(node->op == op_Alloc);
node->attr.alloc.where = where;
}
ir_node *
-get_Free_mem(ir_node *node) {
+get_Free_mem(const ir_node *node) {
assert(node->op == op_Free);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Free_ptr(ir_node *node) {
+get_Free_ptr(const ir_node *node) {
assert(node->op == op_Free);
return get_irn_n(node, 1);
}
}
ir_node *
-get_Free_size(ir_node *node) {
+get_Free_size(const ir_node *node) {
assert(node->op == op_Free);
return get_irn_n(node, 2);
}
node->attr.free.type = tp;
}
-where_alloc
-get_Free_where(ir_node *node) {
+ir_where_alloc
+get_Free_where(const ir_node *node) {
assert(node->op == op_Free);
return node->attr.free.where;
}
void
-set_Free_where(ir_node *node, where_alloc where) {
+set_Free_where(ir_node *node, ir_where_alloc where) {
assert(node->op == op_Free);
node->attr.free.where = where;
}
return (ir_node **)&(get_irn_in(node)[1]);
}
-int get_Sync_n_preds(ir_node *node) {
+int get_Sync_n_preds(const ir_node *node) {
assert(node->op == op_Sync);
return (get_irn_arity(node));
}
}
*/
-ir_node *get_Sync_pred(ir_node *node, int pos) {
+ir_node *get_Sync_pred(const ir_node *node, int pos) {
assert(node->op == op_Sync);
return get_irn_n(node, pos);
}
set_irn_n(node, 0, pred);
}
-long get_VProj_proj(const ir_node *node)
-{
- return node->attr.proj;
-}
-
-void set_VProj_proj(ir_node *node, long value)
-{
- node->attr.proj = value;
-}
-
long
get_Proj_proj(const ir_node *node) {
assert(is_Proj(node));
}
int
-get_Tuple_n_preds(ir_node *node) {
+get_Tuple_n_preds(const ir_node *node) {
assert(node->op == op_Tuple);
return (get_irn_arity(node));
}
*/
ir_node *
-get_Tuple_pred (ir_node *node, int pos) {
+get_Tuple_pred(const ir_node *node, int pos) {
assert(node->op == op_Tuple);
return get_irn_n(node, pos);
}
}
ir_node *
-get_Id_pred(ir_node *node) {
+get_Id_pred(const ir_node *node) {
assert(node->op == op_Id);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, pred);
}
-ir_node *get_Confirm_value(ir_node *node) {
+ir_node *get_Confirm_value(const ir_node *node) {
assert(node->op == op_Confirm);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, value);
}
-ir_node *get_Confirm_bound(ir_node *node) {
+ir_node *get_Confirm_bound(const ir_node *node) {
assert(node->op == op_Confirm);
return get_irn_n(node, 1);
}
set_irn_n(node, 0, bound);
}
-pn_Cmp get_Confirm_cmp(ir_node *node) {
+pn_Cmp get_Confirm_cmp(const ir_node *node) {
assert(node->op == op_Confirm);
- return node->attr.confirm_cmp;
+ return node->attr.confirm.cmp;
}
void set_Confirm_cmp(ir_node *node, pn_Cmp cmp) {
assert(node->op == op_Confirm);
- node->attr.confirm_cmp = cmp;
+ node->attr.confirm.cmp = cmp;
}
-
ir_node *
get_Filter_pred(ir_node *node) {
assert(node->op == op_Filter);
/* Don't use get_irn_arity, get_irn_n in implementation as access
shall work independent of view!!! */
-void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in) {
+void set_Filter_cg_pred_arr(ir_node *node, int arity, ir_node ** in) {
assert(node->op == op_Filter);
if (node->attr.filter.in_cg == NULL || arity != ARR_LEN(node->attr.filter.in_cg) - 1) {
+ ir_graph *irg = get_irn_irg(node);
node->attr.filter.in_cg = NEW_ARR_D(ir_node *, current_ir_graph->obst, arity + 1);
- node->attr.filter.backedge = NEW_ARR_D (int, current_ir_graph->obst, arity);
- memset(node->attr.filter.backedge, 0, sizeof(int) * arity);
+ node->attr.filter.backedge = new_backedge_arr(irg->obst, arity);
node->attr.filter.in_cg[0] = node->in[0];
}
memcpy(node->attr.filter.in_cg + 1, in, sizeof(ir_node *) * arity);
}
/* Mux support */
-ir_node *get_Mux_sel(ir_node *node) {
+ir_node *get_Mux_sel(const ir_node *node) {
if (node->op == op_Psi) {
assert(get_irn_arity(node) == 3);
return get_Psi_cond(node, 0);
}
}
-ir_node *get_Mux_false(ir_node *node) {
+ir_node *get_Mux_false(const ir_node *node) {
if (node->op == op_Psi) {
assert(get_irn_arity(node) == 3);
return get_Psi_default(node);
}
}
-ir_node *get_Mux_true(ir_node *node) {
+ir_node *get_Mux_true(const ir_node *node) {
if (node->op == op_Psi) {
assert(get_irn_arity(node) == 3);
return get_Psi_val(node, 0);
}
/* Psi support */
-ir_node *get_Psi_cond(ir_node *node, int pos) {
- int num_conds = get_Psi_n_conds(node);
+ir_node *get_Psi_cond(const ir_node *node, int pos) {
assert(node->op == op_Psi);
- assert(pos < num_conds);
+ assert(pos < get_Psi_n_conds(node));
return get_irn_n(node, 2 * pos);
}
void set_Psi_cond(ir_node *node, int pos, ir_node *cond) {
- int num_conds = get_Psi_n_conds(node);
assert(node->op == op_Psi);
- assert(pos < num_conds);
+ assert(pos < get_Psi_n_conds(node));
set_irn_n(node, 2 * pos, cond);
}
-ir_node *get_Psi_val(ir_node *node, int pos) {
- int num_vals = get_Psi_n_conds(node);
+ir_node *get_Psi_val(const ir_node *node, int pos) {
assert(node->op == op_Psi);
- assert(pos < num_vals);
+ assert(pos < get_Psi_n_conds(node));
return get_irn_n(node, 2 * pos + 1);
}
void set_Psi_val(ir_node *node, int pos, ir_node *val) {
- int num_vals = get_Psi_n_conds(node);
assert(node->op == op_Psi);
- assert(pos < num_vals);
+ assert(pos < get_Psi_n_conds(node));
set_irn_n(node, 2 * pos + 1, val);
}
-ir_node *get_Psi_default(ir_node *node) {
+ir_node *get_Psi_default(const ir_node *node) {
int def_pos = get_irn_arity(node) - 1;
assert(node->op == op_Psi);
return get_irn_n(node, def_pos);
set_irn_n(node, def_pos, val);
}
-int (get_Psi_n_conds)(ir_node *node) {
+int (get_Psi_n_conds)(const ir_node *node) {
return _get_Psi_n_conds(node);
}
/* CopyB support */
-ir_node *get_CopyB_mem(ir_node *node) {
+ir_node *get_CopyB_mem(const ir_node *node) {
assert(node->op == op_CopyB);
return get_irn_n(node, 0);
}
set_irn_n(node, 0, mem);
}
-ir_node *get_CopyB_dst(ir_node *node) {
+ir_node *get_CopyB_dst(const ir_node *node) {
assert(node->op == op_CopyB);
return get_irn_n(node, 1);
}
set_irn_n(node, 1, dst);
}
-ir_node *get_CopyB_src (ir_node *node) {
+ir_node *get_CopyB_src(const ir_node *node) {
assert(node->op == op_CopyB);
return get_irn_n(node, 2);
}
ir_type *get_CopyB_type(ir_node *node) {
assert(node->op == op_CopyB);
- return node->attr.copyb.data_type;
+ return node->attr.copyb.data_type = skip_tid(node->attr.copyb.data_type);
}
void set_CopyB_type(ir_node *node, ir_type *data_type) {
ir_type *
get_InstOf_type(ir_node *node) {
- assert(node->op = op_InstOf);
- return node->attr.instof.type;
+ assert(node->op == op_InstOf);
+ return node->attr.instof.type = skip_tid(node->attr.instof.type);
}
void
set_InstOf_type(ir_node *node, ir_type *type) {
- assert(node->op = op_InstOf);
+ assert(node->op == op_InstOf);
node->attr.instof.type = type;
}
ir_node *
-get_InstOf_store(ir_node *node) {
- assert(node->op = op_InstOf);
+get_InstOf_store(const ir_node *node) {
+ assert(node->op == op_InstOf);
return get_irn_n(node, 0);
}
void
set_InstOf_store(ir_node *node, ir_node *obj) {
- assert(node->op = op_InstOf);
+ assert(node->op == op_InstOf);
set_irn_n(node, 0, obj);
}
ir_node *
-get_InstOf_obj(ir_node *node) {
- assert(node->op = op_InstOf);
+get_InstOf_obj(const ir_node *node) {
+ assert(node->op == op_InstOf);
return get_irn_n(node, 1);
}
void
set_InstOf_obj(ir_node *node, ir_node *obj) {
- assert(node->op = op_InstOf);
+ assert(node->op == op_InstOf);
set_irn_n(node, 1, obj);
}
/* Returns the memory input of a Raise operation. */
ir_node *
-get_Raise_mem(ir_node *node) {
+get_Raise_mem(const ir_node *node) {
assert(node->op == op_Raise);
return get_irn_n(node, 0);
}
}
ir_node *
-get_Raise_exo_ptr(ir_node *node) {
+get_Raise_exo_ptr(const ir_node *node) {
assert(node->op == op_Raise);
return get_irn_n(node, 1);
}
/* Bound support */
/* Returns the memory input of a Bound operation. */
-ir_node *get_Bound_mem(ir_node *bound) {
+ir_node *get_Bound_mem(const ir_node *bound) {
assert(bound->op == op_Bound);
return get_irn_n(bound, 0);
}
}
/* Returns the index input of a Bound operation. */
-ir_node *get_Bound_index(ir_node *bound) {
+ir_node *get_Bound_index(const ir_node *bound) {
assert(bound->op == op_Bound);
return get_irn_n(bound, 1);
}
}
/* Returns the lower bound input of a Bound operation. */
-ir_node *get_Bound_lower(ir_node *bound) {
+ir_node *get_Bound_lower(const ir_node *bound) {
assert(bound->op == op_Bound);
return get_irn_n(bound, 2);
}
}
/* Returns the upper bound input of a Bound operation. */
-ir_node *get_Bound_upper(ir_node *bound) {
+ir_node *get_Bound_upper(const ir_node *bound) {
assert(bound->op == op_Bound);
return get_irn_n(bound, 3);
}
}
/* Return the assembler text of an ASM pseudo node. */
-const char *get_ASM_text(const ir_node *node) {
+ident *get_ASM_text(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return node->attr.assem.asm_text;
+}
+
+/* Return the number of input constraints for an ASM node. */
+int get_ASM_n_input_constraints(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return ARR_LEN(node->attr.assem.inputs);
+}
+
+/* Return the input constraints for an ASM node. This is a flexible array. */
+const ir_asm_constraint *get_ASM_input_constraints(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return node->attr.assem.inputs;
+}
+
+/* Return the number of output constraints for an ASM node. */
+int get_ASM_n_output_constraints(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return ARR_LEN(node->attr.assem.outputs);
+}
+
+/* Return the output constraints for an ASM node. */
+const ir_asm_constraint *get_ASM_output_constraints(const ir_node *node) {
assert(node->op == op_ASM);
- return get_id_str(node->attr.asm.asm_text);
+ return node->attr.assem.outputs;
}
+/* Return the number of clobbered registers for an ASM node. */
+int get_ASM_n_clobbers(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return ARR_LEN(node->attr.assem.clobber);
+}
+
+/* Return the list of clobbered registers for an ASM node. */
+ident **get_ASM_clobbers(const ir_node *node) {
+ assert(node->op == op_ASM);
+ return node->attr.assem.clobber;
+}
/* returns the graph of a node */
ir_graph *
return _is_NoMem(node);
}
+int
+(is_Minus)(const ir_node *node) {
+ return _is_Minus(node);
+}
+
int
(is_Mod)(const ir_node *node) {
return _is_Mod(node);
return _is_Add(node);
}
+int
+(is_And)(const ir_node *node) {
+ return _is_And(node);
+}
+
+int
+(is_Or)(const ir_node *node) {
+ return _is_Or(node);
+}
+
+int
+(is_Eor)(const ir_node *node) {
+ return _is_Eor(node);
+}
+
int
(is_Sub)(const ir_node *node) {
return _is_Sub(node);
}
+int
+(is_Shl)(const ir_node *node) {
+ return _is_Shl(node);
+}
+
+int
+(is_Shr)(const ir_node *node) {
+ return _is_Shr(node);
+}
+
+int
+(is_Shrs)(const ir_node *node) {
+ return _is_Shrs(node);
+}
+
+int
+(is_Rot)(const ir_node *node) {
+ return _is_Rot(node);
+}
+
+int
+(is_Not)(const ir_node *node) {
+ return _is_Not(node);
+}
+
+int
+(is_Psi)(const ir_node *node) {
+ return _is_Psi(node);
+}
+
+int
+(is_Tuple)(const ir_node *node) {
+ return _is_Tuple(node);
+}
+
int
(is_Start)(const ir_node *node) {
return _is_Start(node);
return _is_Conv(node);
}
+int
+(is_strictConv)(const ir_node *node) {
+ return _is_strictConv(node);
+}
+
+int
+(is_Cast)(const ir_node *node) {
+ return _is_Cast(node);
+}
+
int
(is_no_Block)(const ir_node *node) {
return _is_no_Block(node);
return _is_Sync(node);
}
-/* returns true if node is a Confirm node. */
+/* Returns true if node is a Confirm node. */
int
(is_Confirm)(const ir_node *node) {
return _is_Confirm(node);
}
-/* returns true if node is a Pin node. */
+/* Returns true if node is a Pin node. */
int
(is_Pin)(const ir_node *node) {
return _is_Pin(node);
}
-/* returns true if node is a SymConst node. */
+/* Returns true if node is a SymConst node. */
int
(is_SymConst)(const ir_node *node) {
return _is_SymConst(node);
}
-/* returns true if node is a Cond node. */
+/* Returns true if node is a SymConst node with kind symconst_addr_ent. */
+int
+(is_SymConst_addr_ent)(const ir_node *node) {
+ return _is_SymConst_addr_ent(node);
+}
+
+/* Returns true if node is a Cond node. */
int
(is_Cond)(const ir_node *node) {
return _is_Cond(node);
return _is_Raise(node);
}
+/* returns true if a node is an ASM node. */
int
-is_Proj(const ir_node *node) {
+(is_ASM)(const ir_node *node) {
+ return _is_ASM(node);
+}
+
+int
+(is_Proj)(const ir_node *node) {
assert(node);
return node->op == op_Proj ||
(!get_interprocedural_view() && node->op == op_Filter);
}
/* Returns true if the operation manipulates control flow. */
-int
-is_cfop(const ir_node *node) {
- return is_cfopcode(get_irn_op(node));
+int is_cfop(const ir_node *node) {
+ return is_op_cfopcode(get_irn_op(node));
}
/* Returns true if the operation manipulates interprocedural control flow:
case iro_Store :
case iro_Alloc :
case iro_Bound :
- return get_irn_n(node, 0);
+ case iro_CopyB :
+ return get_irn_n(node, pn_Generic_M_regular);
case iro_Bad :
case iro_Unknown:
return node;
/** the get_type operation must be always implemented and return a firm type */
static ir_type *get_Default_type(ir_node *n) {
+ (void) n;
return get_unknown_type();
}
/** the get_type_attr operation must be always implemented */
static ir_type *get_Null_type(ir_node *n) {
+ (void) n;
return firm_unknown_type;
}
/** the get_entity_attr operation must be always implemented */
static ir_entity *get_Null_ent(ir_node *n) {
+ (void) n;
return NULL;
}
ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops) {
switch (code) {
case iro_SymConst: ops->get_entity_attr = get_SymConst_attr_entity; break;
- case iro_Sel: ops->get_entity_attr = get_Sel_entity; break;
+ case iro_Sel: ops->get_entity_attr = _get_Sel_entity; break;
default:
/* not allowed to be NULL */
if (! ops->get_entity_attr)
return ops;
}
+/* Sets the debug information of a node. */
+void (set_irn_dbg_info)(ir_node *n, dbg_info *db) {
+ _set_irn_dbg_info(n, db);
+}
+
+/**
+ * Returns the debug information of an node.
+ *
+ * @param n The node.
+ */
+dbg_info *(get_irn_dbg_info)(const ir_node *n) {
+ return _get_irn_dbg_info(n);
+}
+
+
+
#ifdef DEBUG_libfirm
-void dump_irn(ir_node *n) {
+void dump_irn(const ir_node *n) {
int i, arity = get_irn_arity(n);
printf("%s%s: %ld (%p)\n", get_irn_opname(n), get_mode_name(get_irn_mode(n)), get_irn_node_nr(n), (void *)n);
if (!is_Block(n)) {
}
#else /* DEBUG_libfirm */
-void dump_irn(ir_node *n) {}
+void dump_irn(const ir_node *n) { (void) n; }
#endif /* DEBUG_libfirm */
projects / libfirm / blobdiff