*/
ir_op_ops *firm_set_default_get_entity_attr(ir_opcode code, ir_op_ops *ops);
+/**
+ * Returns an array with the predecessors of the Block. Depending on
+ * the implementation of the graph data structure this can be a copy of
+ * the internal representation of predecessors as well as the internal
+ * array itself. Therefore writing to this array might obstruct the IR.
+ */
+ir_node **get_Block_cfgpred_arr(ir_node *node);
+
/*-------------------------------------------------------------------*/
/* These function are most used in libfirm. Give them as static */
/* functions so they can be inlined. */
return op_pin_state_pinned;
}
+/* include generated code */
+#include "gen_irnode.h"
+
static inline int
_is_unop(const ir_node *node) {
assert(node && _is_ir_node(node));
return (op == op_Proj);
}
-static inline int
-_is_Filter(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Filter);
-}
-
-static inline int
-_is_Bad(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Bad);
-}
-
-static inline int
-_is_NoMem(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_NoMem);
-}
-
-static inline int
-_is_Minus(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Minus);
-}
-
-static inline int
-_is_Abs(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Abs);
-}
-
-static inline int
-_is_Mod(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Mod);
-}
-
-static inline int
-_is_Div(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Div);
-}
-
-static inline int
-_is_DivMod(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_DivMod);
-}
-
-static inline int
-_is_Quot(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Quot);
-}
-
-static inline int
-_is_Add(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Add);
-}
-
-static inline int
-_is_Carry(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Carry);
-}
-
-static inline int
-_is_And(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_And);
-}
-
-static inline int
-_is_Or(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Or);
-}
-
-static inline int
-_is_Eor(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Eor);
-}
-
-static inline int
-_is_Sub(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Sub);
-}
-
-static inline int
-_is_Not(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Not);
-}
-
-static inline int
-_is_Shl(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Shl);
-}
-
-static inline int
-_is_Shr(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Shr);
-}
-
-static inline int
-_is_Shrs(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Shrs);
-}
-
-static inline int
-_is_Rotl(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Rotl);
-}
-
-static inline int
-_is_Id(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Id);
-}
-
-static inline int
-_is_Tuple(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Tuple);
-}
-
-static inline int
-_is_Bound(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Bound);
-}
-
-static inline int
-_is_Start(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Start);
-}
-
-static inline int
-_is_End(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_End);
-}
-
-static inline int
-_is_Const(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Const);
-}
-
-static inline int
-_is_Conv(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Conv);
-}
-
static inline int
_is_strictConv(const ir_node *node) {
return _is_Conv(node) && get_Conv_strict(node);
}
-static inline int
-_is_Cast(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Cast);
-}
-
-static inline int
-_is_CopyB(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_CopyB);
-}
-
-static inline int
-_is_Unknown(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Unknown);
-}
-
-static inline int
-_is_Return(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Return);
-}
-
-static inline int
-_is_Call(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Call);
-}
-
-static inline int
-_is_Builtin(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Builtin);
-}
-
-static inline int
-_is_CallBegin(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_CallBegin);
-}
-
-static inline int
-_is_Sel(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Sel);
-}
-
-static inline int
-_is_Mul(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Mul);
-}
-
-static inline int
-_is_Mulh(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Mulh);
-}
-
-static inline int
-_is_Mux(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Mux);
-}
-
-static inline int
-_is_Load(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Load);
-}
-
-static inline int
-_is_Store(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Store);
-}
-
-static inline int
-_is_Sync(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Sync);
-}
-
-static inline int
-_is_Confirm(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Confirm);
-}
-
-static inline int
-_is_Pin(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Pin);
-}
-
-static inline int
-_is_SymConst(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_SymConst);
-}
-
static inline int
_is_SymConst_addr_ent(const ir_node *node) {
return is_SymConst(node) && get_SymConst_kind(node) == symconst_addr_ent;
}
-static inline int
-_is_Cond(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Cond);
-}
-
-static inline int
-_is_Cmp(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Cmp);
-}
-
-static inline int
-_is_Alloc(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Alloc);
-}
-
-static inline int
-_is_Free(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Free);
-}
-
-static inline int
-_is_Jmp(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Jmp);
-}
-
-static inline int
-_is_IJmp(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_IJmp);
-}
-
-static inline int
-_is_Raise(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Raise);
-}
-
-static inline int
-_is_ASM(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_ASM);
-}
-
-static inline int
-_is_Dummy(const ir_node *node) {
- assert(node);
- return (_get_irn_op(node) == op_Dummy);
-}
-
-static inline int
-_is_Anchor(const ir_node *node) {
- return (_get_irn_op(node) == op_Anchor);
-}
-
static inline int
_is_no_Block(const ir_node *node) {
assert(node && _is_ir_node(node));
return (_get_irn_op(node) != op_Block);
}
-static inline int
-_is_Block(const ir_node *node) {
- assert(node && _is_ir_node(node));
- return (_get_irn_op(node) == op_Block);
-}
-
static inline int
_get_Block_n_cfgpreds(const ir_node *node) {
assert(_is_Block(node));
* We walk from the predecessor to the next pinned node
* (skip_Proj) and return the block that node is in.
* - If we encounter the Bad node, this function does not return
- * Start, but the Bad node.
+ * the Start block, but the Bad node.
*/
static inline ir_node *
_get_Block_cfgpred_block(const ir_node *node, int pos) {
static inline cond_jmp_predicate _get_Cond_jmp_pred(const ir_node *node) {
assert(_get_irn_op(node) == op_Cond);
- return node->attr.cond.pred;
+ return node->attr.cond.jmp_pred;
}
static inline void _set_Cond_jmp_pred(ir_node *node, cond_jmp_predicate pred) {
assert(_get_irn_op(node) == op_Cond);
- node->attr.cond.pred = pred;
+ node->attr.cond.jmp_pred = pred;
}
static inline void *_get_irn_generic_attr(ir_node *node) {
#define is_unop(node) _is_unop(node)
#define is_binop(node) _is_binop(node)
#define is_Proj(node) _is_Proj(node)
-#define is_Filter(node) _is_Filter(node)
#define is_Phi(node) _is_Phi(node)
-#define is_Const(node) _is_Const(node)
-#define is_Conv(node) _is_Conv(node)
#define is_strictConv(node) _is_strictConv(node)
-#define is_Cast(node) _is_Cast(node)
-#define is_Unknown(node) _is_Unknown(node)
-#define is_Return(node) _is_Return(node)
-#define is_Call(node) _is_Call(node)
-#define is_Builtin(node) _is_Builtin(node)
-#define is_CallBegin(node) _is_CallBegin(node)
-#define is_Sel(node) _is_Sel(node)
-#define is_Mul(node) _is_Mul(node)
-#define is_Mulh(node) _is_Mulh(node)
-#define is_Mux(node) _is_Mux(node)
-#define is_Load(node) _is_Load(node)
-#define is_Sync(node) _is_Sync(node)
-#define is_Confirm(node) _is_Confirm(node)
-#define is_Pin(node) _is_Pin(node)
-#define is_SymConst(node) _is_SymConst(node)
#define is_SymConst_addr_ent(node) _is_SymConst_addr_ent(node)
-#define is_Cond(node) _is_Cond(node)
-#define is_CopyB(node) _is_CopyB(node)
-#define is_Cmp(node) _is_Cmp(node)
-#define is_Alloc(node) _is_Alloc(node)
-#define is_Free(node) _is_Free(node)
-#define is_Jmp(node) _is_Jmp(node)
-#define is_IJmp(node) _is_IJmp(node)
-#define is_Raise(node) _is_Raise(node)
-#define is_ASM(node) _is_ASM(node)
-#define is_Dummy(node) _is_Dummy(node)
-#define is_Anchor(node) _is_Anchor(node)
-#define is_Bad(node) _is_Bad(node)
-#define is_NoMem(node) _is_NoMem(node)
-#define is_Start(node) _is_Start(node)
-#define is_End(node) _is_End(node)
-#define is_Minus(node) _is_Minus(node)
-#define is_Abs(node) _is_Abs(node)
-#define is_Mod(node) _is_Mod(node)
-#define is_Div(node) _is_Div(node)
-#define is_DivMod(node) _is_DivMod(node)
-#define is_Quot(node) _is_Quot(node)
-#define is_Add(node) _is_Add(node)
-#define is_Carry(node) _is_Carry(node)
-#define is_And(node) _is_And(node)
-#define is_Or(node) _is_Or(node)
-#define is_Eor(node) _is_Eor(node)
-#define is_Sub(node) _is_Sub(node)
-#define is_Not(node) _is_Not(node)
-#define is_Shl(node) _is_Shl(node)
-#define is_Shr(node) _is_Shr(node)
-#define is_Shrs(node) _is_Shrs(node)
-#define is_Rotl(node) _is_Rotl(node)
-#define is_Id(node) _is_Id(node)
-#define is_Tuple(node) _is_Tuple(node)
-#define is_Bound(node) _is_Bound(node)
#define is_no_Block(node) _is_no_Block(node)
-#define is_Block(node) _is_Block(node)
#define get_Block_n_cfgpreds(node) _get_Block_n_cfgpreds(node)
#define get_Block_cfgpred(node, pos) _get_Block_cfgpred(node, pos)
#define get_Block_cfgpred_block(node, pos) _get_Block_cfgpred_block(node, pos)
projects / libfirm / blobdiff