They are reserved in ANSI-C so instead of _XXX we use XXX_ now.
/* Internal use. */
-#define _bsfe_get_irn(irg, elm) (elm == (unsigned) -1 ? NULL : get_idx_irn((irg), (unsigned) elm))
+#define bsfe_get_irn_(irg, elm) (elm == (unsigned) -1 ? NULL : get_idx_irn((irg), (unsigned) elm))
/**
* Iterate over a bitset containing node indexes.
* @param irn An ir_node * which is set to the current node.
*/
#define bitset_foreach_irn(irg, bs, elm, irn) \
- for(elm = bitset_next_set(bs, 0), irn = _bsfe_get_irn(irg, elm); elm != (unsigned) -1; elm = bitset_next_set(bs, elm + 1), irn = _bsfe_get_irn(irg, elm))
+ for(elm = bitset_next_set(bs, 0), irn = bsfe_get_irn_(irg, elm); elm != (unsigned) -1; elm = bitset_next_set(bs, elm + 1), irn = bsfe_get_irn_(irg, elm))
#endif
*/
void edges_reset_private_data(ir_graph *irg, int offset, unsigned size)
{
- irg_edge_info_t *info = _get_irg_edge_info(irg, EDGE_KIND_NORMAL);
+ irg_edge_info_t *info = get_irg_edge_info(irg, EDGE_KIND_NORMAL);
ir_edge_t *edge;
ir_edgeset_iterator_t iter;
void edges_init_graph_kind(ir_graph *irg, ir_edge_kind_t kind)
{
if (edges_activated_kind(irg, kind)) {
- irg_edge_info_t *info = _get_irg_edge_info(irg, kind);
+ irg_edge_info_t *info = get_irg_edge_info(irg, kind);
size_t amount = irg->estimated_node_count * 2;
edges_used = 1;
{
ir_graph *irg = get_irn_irg(src);
if (edges_activated_kind(irg, kind)) {
- irg_edge_info_t *info = _get_irg_edge_info(irg, kind);
+ irg_edge_info_t *info = get_irg_edge_info(irg, kind);
ir_edge_t key;
key.src = (ir_node *)src;
*/
static inline void edge_change_cnt(ir_node *tgt, ir_edge_kind_t kind, int ofs)
{
- irn_edge_info_t *info = _get_irn_edge_info(tgt, kind);
+ irn_edge_info_t *info = get_irn_edge_info(tgt, kind);
info->out_count += ofs;
}
*/
static inline void verify_list_head(ir_node *irn, ir_edge_kind_t kind)
{
- int err = 0;
- int num = 0;
- pset *lh_set = pset_new_ptr(16);
- const struct list_head *head = _get_irn_outs_head(irn, kind);
+ int err = 0;
+ int num = 0;
+ pset *lh_set = pset_new_ptr(16);
+ const struct list_head *head = &get_irn_edge_info(irn, kind)->outs_head;
const struct list_head *pos;
list_for_each(pos, head) {
if (!edges_activated_kind(irg, kind))
return;
- info = _get_irg_edge_info(irg, kind);
+ info = get_irg_edge_info(irg, kind);
edges = &info->edges;
foreach_ir_edgeset(edges, e, iter) {
ir_printf("%+F %d %d\n", e->src, e->pos, e->invalid);
if (tgt == old_tgt)
return;
- info = _get_irg_edge_info(irg, kind);
+ info = get_irg_edge_info(irg, kind);
edges = &info->edges;
/* Initialize the edge template to search in the set. */
* old target was != NULL) or added (if the old target was
* NULL).
*/
- struct list_head *head = _get_irn_outs_head(tgt, kind);
+ struct list_head *head = &get_irn_edge_info(tgt, kind)->outs_head;
assert(head->next && head->prev &&
"target list head must have been initialized");
if (!edges_activated_kind(irg, kind))
return;
- info = _get_irn_edge_info(irn, kind);
+ info = get_irn_edge_info(irn, kind);
if (info->edges_built)
return;
ir_node *pred = get_n(irn, i, kind);
edges_notify_edge_kind(irn, i, pred, NULL, kind, irg);
}
- _get_irn_edge_info(irn, kind)->edges_built = 1;
+ get_irn_edge_info(irn, kind)->edges_built = 1;
}
/**
{
build_walker *w = (build_walker*)data;
ir_edge_kind_t kind = w->kind;
- list_head *head = _get_irn_outs_head(irn, kind);
+ list_head *head = &get_irn_edge_info(irn, kind)->outs_head;
INIT_LIST_HEAD(head);
- _get_irn_edge_info(irn, kind)->edges_built = 0;
- _get_irn_edge_info(irn, kind)->out_count = 0;
+ get_irn_edge_info(irn, kind)->edges_built = 0;
+ get_irn_edge_info(irn, kind)->out_count = 0;
}
/**
{
build_walker *w = (build_walker*)data;
ir_edge_kind_t kind = w->kind;
- list_head *head = _get_irn_outs_head(irn, kind);
+ list_head *head = &get_irn_edge_info(irn, kind)->outs_head;
int i;
INIT_LIST_HEAD(head);
- _get_irn_edge_info(irn, kind)->edges_built = 0;
- _get_irn_edge_info(irn, kind)->out_count = 0;
+ get_irn_edge_info(irn, kind)->edges_built = 0;
+ get_irn_edge_info(irn, kind)->out_count = 0;
for (i = get_irn_deps(irn) - 1; i >= 0; --i) {
ir_node *dep = get_irn_dep(irn, i);
- head = _get_irn_outs_head(dep, kind);
+ head = &get_irn_edge_info(dep, kind)->outs_head;
INIT_LIST_HEAD(head);
- _get_irn_edge_info(dep, kind)->edges_built = 0;
- _get_irn_edge_info(dep, kind)->out_count = 0;
+ get_irn_edge_info(dep, kind)->edges_built = 0;
+ get_irn_edge_info(dep, kind)->out_count = 0;
}
}
void edges_activate_kind(ir_graph *irg, ir_edge_kind_t kind)
{
struct build_walker w;
- irg_edge_info_t *info = _get_irg_edge_info(irg, kind);
+ irg_edge_info_t *info = get_irg_edge_info(irg, kind);
visitor_info_t visit;
w.kind = kind;
void edges_deactivate_kind(ir_graph *irg, ir_edge_kind_t kind)
{
- irg_edge_info_t *info = _get_irg_edge_info(irg, kind);
+ irg_edge_info_t *info = get_irg_edge_info(irg, kind);
info->activated = 0;
if (info->allocated) {
int (edges_activated_kind)(const ir_graph *irg, ir_edge_kind_t kind)
{
- return _edges_activated_kind(irg, kind);
+ return edges_activated_kind_(irg, kind);
}
set_edge_func_t *set_edge = edge_kind_info[kind].set_edge;
if (set_edge && edges_activated_kind(irg, kind)) {
- struct list_head *head = _get_irn_outs_head(from, kind);
+ struct list_head *head = &get_irn_edge_info(from, kind)->outs_head;
DBG((dbg, LEVEL_5, "reroute from %+F to %+F\n", from, to));
{
build_walker *w = (build_walker*)data;
ir_graph *irg = get_irn_irg(irn);
- ir_edgeset_t *edges = &_get_irg_edge_info(irg, w->kind)->edges;
+ ir_edgeset_t *edges = &get_irg_edge_info(irg, w->kind)->edges;
int i, n;
foreach_tgt(irn, i, n, w->kind) {
int edges_verify_kind(ir_graph *irg, ir_edge_kind_t kind)
{
struct build_walker w;
- ir_edgeset_t *edges = &_get_irg_edge_info(irg, kind)->edges;
+ ir_edgeset_t *edges = &get_irg_edge_info(irg, kind)->edges;
ir_edge_t *e;
ir_edgeset_iterator_t iter;
bs = (bitset_t*)get_irn_link(irn);
list_cnt = 0;
ref_cnt = 0;
- edge_cnt = _get_irn_edge_info(irn, EDGE_KIND_NORMAL)->out_count;
- head = _get_irn_outs_head(irn, EDGE_KIND_NORMAL);
+ edge_cnt = get_irn_edge_info(irn, EDGE_KIND_NORMAL)->out_count;
+ head = &get_irn_edge_info(irn, EDGE_KIND_NORMAL)->outs_head;
/* We can iterate safely here, list heads have already been verified. */
list_for_each(pos, head) {
const ir_edge_t *(get_irn_out_edge_first_kind)(const ir_node *irn, ir_edge_kind_t kind)
{
- return _get_irn_out_edge_first_kind(irn, kind);
+ return get_irn_out_edge_first_kind_(irn, kind);
}
const ir_edge_t *(get_irn_out_edge_next)(const ir_node *irn, const ir_edge_t *last)
{
- return _get_irn_out_edge_next(irn, last);
+ return get_irn_out_edge_next_(irn, last);
}
ir_node *(get_edge_src_irn)(const ir_edge_t *edge)
{
- return _get_edge_src_irn(edge);
+ return get_edge_src_irn_(edge);
}
int (get_edge_src_pos)(const ir_edge_t *edge)
{
- return _get_edge_src_pos(edge);
+ return get_edge_src_pos_(edge);
}
int (get_irn_n_edges_kind)(const ir_node *irn, ir_edge_kind_t kind)
{
- return _get_irn_n_edges_kind(irn, kind);
+ return get_irn_n_edges_kind_(irn, kind);
}
static void irg_walk_edges2(ir_node *node, irg_walk_func *pre,
struct list_head list; /**< The list head to queue all out edges at a node. */
};
-
/** Accessor for private irn info. */
-#define _get_irn_edge_info(irn, kind) (&(((irn)->edge_info)[kind]))
+static inline irn_edge_info_t *get_irn_edge_info(ir_node *node,
+ ir_edge_kind_t kind)
+{
+ return &node->edge_info[kind];
+}
+
+static inline const irn_edge_info_t *get_irn_edge_info_const(
+ const ir_node *node, ir_edge_kind_t kind)
+{
+ return &node->edge_info[kind];
+}
/** Accessor for private irg info. */
-#define _get_irg_edge_info(irg, kind) (&(((irg)->edge_info)[kind]))
+static inline irg_edge_info_t *get_irg_edge_info(ir_graph *irg,
+ ir_edge_kind_t kind)
+{
+ return &irg->edge_info[kind];
+}
-/**
-* Convenience macro to get the outs_head from a irn_edge_info_t
-* struct.
-*/
-#define _get_irn_outs_head(irn, kind) (&_get_irn_edge_info(irn, kind)->outs_head)
+/** Accessor for private irg info. */
+static inline const irg_edge_info_t *get_irg_edge_info_const(
+ const ir_graph *irg, ir_edge_kind_t kind)
+{
+ return &irg->edge_info[kind];
+}
/**
-* Get the first edge pointing to some node.
-* @note There is no order on out edges. First in this context only
-* means, that you get some starting point into the list of edges.
-* @param irn The node.
-* @return The first out edge that points to this node.
-*/
-static inline const ir_edge_t *_get_irn_out_edge_first_kind(const ir_node *irn, ir_edge_kind_t kind)
+ * Get the first edge pointing to some node.
+ * @note There is no order on out edges. First in this context only
+ * means, that you get some starting point into the list of edges.
+ * @param irn The node.
+ * @return The first out edge that points to this node.
+ */
+static inline const ir_edge_t *get_irn_out_edge_first_kind_(const ir_node *irn, ir_edge_kind_t kind)
{
const struct list_head *head;
assert(edges_activated_kind(get_irn_irg(irn), kind));
- head = _get_irn_outs_head(irn, kind);
+ head = &get_irn_edge_info_const(irn, kind)->outs_head;
return list_empty(head) ? NULL : list_entry(head->next, ir_edge_t, list);
}
/**
-* Get the next edge in the out list of some node.
-* @param irn The node.
-* @param last The last out edge you have seen.
-* @return The next out edge in @p irn 's out list after @p last.
-*/
-static inline const ir_edge_t *_get_irn_out_edge_next(const ir_node *irn, const ir_edge_t *last)
+ * Get the next edge in the out list of some node.
+ * @param irn The node.
+ * @param last The last out edge you have seen.
+ * @return The next out edge in @p irn 's out list after @p last.
+ */
+static inline const ir_edge_t *get_irn_out_edge_next_(const ir_node *irn, const ir_edge_t *last)
{
struct list_head *next = last->list.next;
- return next == _get_irn_outs_head(irn, last->kind) ? NULL : list_entry(next, ir_edge_t, list);
+ const struct list_head *head
+ = &get_irn_edge_info_const(irn, last->kind)->outs_head;
+ return next == head ? NULL : list_entry(next, ir_edge_t, list);
}
/**
-* Get the number of edges pointing to a node.
-* @param irn The node.
-* @return The number of edges pointing to this node.
-*/
-static inline int _get_irn_n_edges_kind(const ir_node *irn, int kind)
+ * Get the number of edges pointing to a node.
+ * @param irn The node.
+ * @return The number of edges pointing to this node.
+ */
+static inline int get_irn_n_edges_kind_(const ir_node *irn, int kind)
{
- return _get_irn_edge_info(irn, kind)->out_count;
+ return get_irn_edge_info_const(irn, kind)->out_count;
}
-static inline int _edges_activated_kind(const ir_graph *irg, ir_edge_kind_t kind)
+static inline int edges_activated_kind_(const ir_graph *irg, ir_edge_kind_t kind)
{
- return _get_irg_edge_info(irg, kind)->activated;
+ return get_irg_edge_info_const(irg, kind)->activated;
}
/**
-* Assure, that the edges information is present for a certain graph.
-* @param irg The graph.
-*/
-static inline void _edges_assure_kind(ir_graph *irg, ir_edge_kind_t kind)
+ * Assure, that the edges information is present for a certain graph.
+ * @param irg The graph.
+ */
+static inline void edges_assure_kind_(ir_graph *irg, ir_edge_kind_t kind)
{
- if(!_edges_activated_kind(irg, kind))
+ if(!edges_activated_kind_(irg, kind))
edges_activate_kind(irg, kind);
}
void edges_invalidate_kind(ir_node *irn, ir_edge_kind_t kind);
/**
-* Register additional memory in an edge.
-* This must be called before Firm is initialized.
-* @param n Number of bytes you need.
-* @return A number you have to keep and to pass
-* edges_get_private_data()
-* to get a pointer to your data.
-*/
+ * Register additional memory in an edge.
+ * This must be called before Firm is initialized.
+ * @param n Number of bytes you need.
+ * @return A number you have to keep and to pass
+ * edges_get_private_data()
+ * to get a pointer to your data.
+ */
size_t edges_register_private_data(size_t n);
/**
-* Get a pointer to the private data you registered.
-* @param edge The edge.
-* @param ofs The number, you obtained with
-* edges_register_private_data().
-* @return A pointer to the private data.
-*/
-static inline void *_get_edge_private_data(const ir_edge_t *edge, int ofs)
+ * Get a pointer to the private data you registered.
+ * @param edge The edge.
+ * @param ofs The number, you obtained with
+ * edges_register_private_data().
+ * @return A pointer to the private data.
+ */
+static inline void *get_edge_private_data_(const ir_edge_t *edge, int ofs)
{
return (void *) ((char *) edge + sizeof(edge[0]) + ofs);
}
-static inline ir_node *_get_edge_src_irn(const ir_edge_t *edge)
+static inline ir_node *get_edge_src_irn_(const ir_edge_t *edge)
{
return edge->src;
}
-static inline int _get_edge_src_pos(const ir_edge_t *edge)
+static inline int get_edge_src_pos_(const ir_edge_t *edge)
{
return edge->pos;
}
/**
-* Initialize the out edges.
-* This must be called before firm is initialized.
-*/
+ * Initialize the out edges.
+ * This must be called before firm is initialized.
+ */
extern void init_edges(void);
void edges_invalidate_all(ir_node *irn);
void edges_notify_edge(ir_node *src, int pos, ir_node *tgt,
ir_node *old_tgt, ir_graph *irg);
-#define get_irn_n_edges_kind(irn, kind) _get_irn_n_edges_kind(irn, kind)
-#define get_edge_src_irn(edge) _get_edge_src_irn(edge)
-#define get_edge_src_pos(edge) _get_edge_src_pos(edge)
-#define get_edge_private_data(edge, ofs) _get_edge_private_data(edge,ofs)
-#define get_irn_out_edge_next(irn, last) _get_irn_out_edge_next(irn, last)
+#define get_irn_n_edges_kind(irn, kind) get_irn_n_edges_kind_(irn, kind)
+#define get_edge_src_irn(edge) get_edge_src_irn_(edge)
+#define get_edge_src_pos(edge) get_edge_src_pos_(edge)
+#define get_edge_private_data(edge, ofs) get_edge_private_data_(edge,ofs)
+#define get_irn_out_edge_next(irn, last) get_irn_out_edge_next_(irn, last)
#ifndef get_irn_n_edges
-#define get_irn_n_edges(irn) _get_irn_n_edges_kind(irn, EDGE_KIND_NORMAL)
+#define get_irn_n_edges(irn) get_irn_n_edges_kind_(irn, EDGE_KIND_NORMAL)
#endif
#ifndef get_irn_out_edge_first
-#define get_irn_out_edge_first(irn) _get_irn_out_edge_first_kind(irn, EDGE_KIND_NORMAL)
+#define get_irn_out_edge_first(irn) get_irn_out_edge_first_kind_(irn, EDGE_KIND_NORMAL)
#endif
#ifndef get_block_succ_first
-#define get_block_succ_first(irn) _get_irn_out_edge_first_kind(irn, EDGE_KIND_BLOCK)
+#define get_block_succ_first(irn) get_irn_out_edge_first_kind_(irn, EDGE_KIND_BLOCK)
#endif
#ifndef get_block_succ_next
-#define get_block_succ_next(irn, last) _get_irn_out_edge_next(irn, last)
+#define get_block_succ_next(irn, last) get_irn_out_edge_next_(irn, last)
#endif
#endif
else libFIRM_opt &= ~irf_##name; \
} \
int (get_opt_##name)(void) { \
- return _get_opt_##name(); \
+ return get_opt_##name##_(); \
}
/* an internal flag can only be set from outside */
/* generate the getter functions for external access */
#define E_FLAG(name, value, def) \
-static inline int _get_opt_##name(void) { \
+static inline int get_opt_##name##_(void) { \
return libFIRM_opt & irf_##name; \
}
#undef E_FLAG
#undef R_FLAG
-static inline int _get_optimize(void)
+static inline int get_optimize_(void)
{
return get_opt_optimize();
}
return opt_do_node_verification;
}
-#define get_optimize() _get_optimize()
-#define get_opt_cse() _get_opt_cse()
-#define get_opt_dyn_meth_dispatch() _get_opt_dyn_meth_dispatch()
-#define get_opt_suppress_downcast_optimization() _get_opt_suppress_downcast_optimization()
+#define get_optimize() get_optimize_()
+#define get_opt_cse() get_opt_cse_()
+#define get_opt_dyn_meth_dispatch() get_opt_dyn_meth_dispatch_()
+#define get_opt_suppress_downcast_optimization() get_opt_suppress_downcast_optimization_()
#endif
int (is_ir_graph)(const void *thing)
{
- return _is_ir_graph(thing);
+ return is_ir_graph_(thing);
}
#ifdef DEBUG_libfirm
ir_node *(get_idx_irn)(const ir_graph *irg, unsigned idx)
{
- return _get_idx_irn(irg, idx);
+ return get_idx_irn_(irg, idx);
}
ir_node *(get_irg_start_block)(const ir_graph *irg)
{
- return _get_irg_start_block(irg);
+ return get_irg_start_block_(irg);
}
void (set_irg_start_block)(ir_graph *irg, ir_node *node)
{
- _set_irg_start_block(irg, node);
+ set_irg_start_block_(irg, node);
}
ir_node *(get_irg_start)(const ir_graph *irg)
{
- return _get_irg_start(irg);
+ return get_irg_start_(irg);
}
void (set_irg_start)(ir_graph *irg, ir_node *node)
{
- _set_irg_start(irg, node);
+ set_irg_start_(irg, node);
}
ir_node *(get_irg_end_block)(const ir_graph *irg)
{
- return _get_irg_end_block(irg);
+ return get_irg_end_block_(irg);
}
void (set_irg_end_block)(ir_graph *irg, ir_node *node)
{
- _set_irg_end_block(irg, node);
+ set_irg_end_block_(irg, node);
}
ir_node *(get_irg_end)(const ir_graph *irg)
{
- return _get_irg_end(irg);
+ return get_irg_end_(irg);
}
void (set_irg_end)(ir_graph *irg, ir_node *node)
{
- _set_irg_end(irg, node);
+ set_irg_end_(irg, node);
}
ir_node *(get_irg_initial_exec)(const ir_graph *irg)
{
- return _get_irg_initial_exec(irg);
+ return get_irg_initial_exec_(irg);
}
void (set_irg_initial_exec)(ir_graph *irg, ir_node *node)
{
- _set_irg_initial_exec(irg, node);
+ set_irg_initial_exec_(irg, node);
}
ir_node *(get_irg_frame)(const ir_graph *irg)
{
- return _get_irg_frame(irg);
+ return get_irg_frame_(irg);
}
void (set_irg_frame)(ir_graph *irg, ir_node *node)
{
- _set_irg_frame(irg, node);
+ set_irg_frame_(irg, node);
}
ir_node *(get_irg_initial_mem)(const ir_graph *irg)
{
- return _get_irg_initial_mem(irg);
+ return get_irg_initial_mem_(irg);
}
void (set_irg_initial_mem)(ir_graph *irg, ir_node *node)
{
- _set_irg_initial_mem(irg, node);
+ set_irg_initial_mem_(irg, node);
}
ir_node *(get_irg_args)(const ir_graph *irg)
{
- return _get_irg_args(irg);
+ return get_irg_args_(irg);
}
void (set_irg_args)(ir_graph *irg, ir_node *node)
{
- _set_irg_args(irg, node);
+ set_irg_args_(irg, node);
}
ir_node *(get_irg_no_mem)(const ir_graph *irg)
{
- return _get_irg_no_mem(irg);
+ return get_irg_no_mem_(irg);
}
void (set_irg_no_mem)(ir_graph *irg, ir_node *node)
{
- _set_irg_no_mem(irg, node);
+ set_irg_no_mem_(irg, node);
}
ir_entity *(get_irg_entity)(const ir_graph *irg)
{
- return _get_irg_entity(irg);
+ return get_irg_entity_(irg);
}
void (set_irg_entity)(ir_graph *irg, ir_entity *ent)
{
- _set_irg_entity(irg, ent);
+ set_irg_entity_(irg, ent);
}
ir_type *(get_irg_frame_type)(ir_graph *irg)
{
- return _get_irg_frame_type(irg);
+ return get_irg_frame_type_(irg);
}
void (set_irg_frame_type)(ir_graph *irg, ir_type *ftp)
{
- _set_irg_frame_type(irg, ftp);
+ set_irg_frame_type_(irg, ftp);
}
int get_irg_n_locs(ir_graph *irg)
}
/* Returns the obstack associated with the graph. */
-struct obstack *
-(get_irg_obstack)(const ir_graph *irg) {
- return _get_irg_obstack(irg);
+struct obstack *(get_irg_obstack)(const ir_graph *irg)
+{
+ return get_irg_obstack_(irg);
}
/*
irg_phase_state (get_irg_phase_state)(const ir_graph *irg)
{
- return _get_irg_phase_state(irg);
+ return get_irg_phase_state_(irg);
}
void (set_irg_phase_state)(ir_graph *irg, irg_phase_state state)
{
- _set_irg_phase_state(irg, state);
+ set_irg_phase_state_(irg, state);
}
op_pin_state (get_irg_pinned)(const ir_graph *irg)
{
- return _get_irg_pinned(irg);
+ return get_irg_pinned_(irg);
}
void (set_irg_pinned)(ir_graph *irg, op_pin_state p)
{
- _set_irg_pinned(irg, p);
+ set_irg_pinned_(irg, p);
}
irg_callee_info_state (get_irg_callee_info_state)(const ir_graph *irg)
{
- return _get_irg_callee_info_state(irg);
+ return get_irg_callee_info_state_(irg);
}
void (set_irg_callee_info_state)(ir_graph *irg, irg_callee_info_state s)
{
- _set_irg_callee_info_state(irg, s);
+ set_irg_callee_info_state_(irg, s);
}
irg_inline_property (get_irg_inline_property)(const ir_graph *irg)
{
- return _get_irg_inline_property(irg);
+ return get_irg_inline_property_(irg);
}
void (set_irg_inline_property)(ir_graph *irg, irg_inline_property s)
{
- _set_irg_inline_property(irg, s);
+ set_irg_inline_property_(irg, s);
}
mtp_additional_properties (get_irg_additional_properties)(const ir_graph *irg)
{
- return _get_irg_additional_properties(irg);
+ return get_irg_additional_properties_(irg);
}
void (set_irg_additional_properties)(ir_graph *irg, mtp_additional_properties property_mask)
{
- _set_irg_additional_properties(irg, property_mask);
+ set_irg_additional_properties_(irg, property_mask);
}
void (add_irg_additional_properties)(ir_graph *irg, mtp_additional_properties flag)
{
- _add_irg_additional_properties(irg, flag);
+ add_irg_additional_properties_(irg, flag);
}
void (set_irg_link)(ir_graph *irg, void *thing)
{
- _set_irg_link(irg, thing);
+ set_irg_link_(irg, thing);
}
void *(get_irg_link)(const ir_graph *irg)
{
- return _get_irg_link(irg);
+ return get_irg_link_(irg);
}
ir_visited_t (get_irg_visited)(const ir_graph *irg)
{
- return _get_irg_visited(irg);
+ return get_irg_visited_(irg);
}
/** maximum visited flag content of all ir_graph visited fields. */
ir_visited_t (get_irg_block_visited)(const ir_graph *irg)
{
- return _get_irg_block_visited(irg);
+ return get_irg_block_visited_(irg);
}
void (set_irg_block_visited)(ir_graph *irg, ir_visited_t visited)
{
- _set_irg_block_visited(irg, visited);
+ set_irg_block_visited_(irg, visited);
}
void (inc_irg_block_visited)(ir_graph *irg)
{
- _inc_irg_block_visited(irg);
+ inc_irg_block_visited_(irg);
}
/* Return the floating point model of this graph. */
unsigned (get_irg_fp_model)(const ir_graph *irg)
{
- return _get_irg_fp_model(irg);
+ return get_irg_fp_model_(irg);
}
/* Sets the floating point model for this graph. */
/* Returns a estimated node count of the irg. */
unsigned (get_irg_estimated_node_cnt)(const ir_graph *irg)
{
- return _get_irg_estimated_node_cnt(irg);
+ return get_irg_estimated_node_cnt_(irg);
}
/* Returns the last irn index for this graph. */
void (set_irg_state)(ir_graph *irg, ir_graph_state_t state)
{
- _set_irg_state(irg, state);
+ set_irg_state_(irg, state);
}
void (clear_irg_state)(ir_graph *irg, ir_graph_state_t state)
{
- _clear_irg_state(irg, state);
+ clear_irg_state_(irg, state);
}
int (is_irg_state)(const ir_graph *irg, ir_graph_state_t state)
{
- return _is_irg_state(irg, state);
+ return is_irg_state_(irg, state);
}
/* inline functions for graphs */
/*-------------------------------------------------------------------*/
-static inline int _is_ir_graph(const void *thing)
+static inline int is_ir_graph_(const void *thing)
{
return (get_kind(thing) == k_ir_graph);
}
/** Returns the start block of a graph. */
-static inline ir_node *_get_irg_start_block(const ir_graph *irg)
+static inline ir_node *get_irg_start_block_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_start_block);
}
-static inline void _set_irg_start_block(ir_graph *irg, ir_node *node)
+static inline void set_irg_start_block_(ir_graph *irg, ir_node *node)
{
set_irn_n(irg->anchor, anchor_start_block, node);
}
-static inline ir_node *_get_irg_start(const ir_graph *irg)
+static inline ir_node *get_irg_start_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_start);
}
-static inline void _set_irg_start(ir_graph *irg, ir_node *node)
+static inline void set_irg_start_(ir_graph *irg, ir_node *node)
{
set_irn_n(irg->anchor, anchor_start, node);
}
-static inline ir_node *_get_irg_end_block(const ir_graph *irg)
+static inline ir_node *get_irg_end_block_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_end_block);
}
-static inline void _set_irg_end_block(ir_graph *irg, ir_node *node)
+static inline void set_irg_end_block_(ir_graph *irg, ir_node *node)
{
- set_irn_n(irg->anchor, -1, node);
set_irn_n(irg->anchor, anchor_end_block, node);
}
-static inline ir_node *_get_irg_end(const ir_graph *irg)
+static inline ir_node *get_irg_end_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_end);
}
-static inline void _set_irg_end(ir_graph *irg, ir_node *node)
+static inline void set_irg_end_(ir_graph *irg, ir_node *node)
{
set_irn_n(irg->anchor, anchor_end, node);
}
-static inline ir_node *_get_irg_initial_exec(const ir_graph *irg)
+static inline ir_node *get_irg_initial_exec_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_initial_exec);
}
-static inline void _set_irg_initial_exec(ir_graph *irg, ir_node *node)
+static inline void set_irg_initial_exec_(ir_graph *irg, ir_node *node)
{
set_irn_n(irg->anchor, anchor_initial_exec, node);
}
-static inline ir_node *_get_irg_frame(const ir_graph *irg)
+static inline ir_node *get_irg_frame_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_frame);
}
-static inline void _set_irg_frame(ir_graph *irg, ir_node *node)
+static inline void set_irg_frame_(ir_graph *irg, ir_node *node)
{
set_irn_n(irg->anchor, anchor_frame, node);
}
-static inline ir_node *_get_irg_initial_mem(const ir_graph *irg)
+static inline ir_node *get_irg_initial_mem_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_initial_mem);
}
-static inline void _set_irg_initial_mem(ir_graph *irg, ir_node *node)
+static inline void set_irg_initial_mem_(ir_graph *irg, ir_node *node)
{
set_irn_n(irg->anchor, anchor_initial_mem, node);
}
-static inline ir_node *_get_irg_args(const ir_graph *irg)
+static inline ir_node *get_irg_args_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_args);
}
-static inline void _set_irg_args(ir_graph *irg, ir_node *node)
+static inline void set_irg_args_(ir_graph *irg, ir_node *node)
{
set_irn_n(irg->anchor, anchor_args, node);
}
-static inline ir_node * _get_irg_no_mem(const ir_graph *irg)
+static inline ir_node *get_irg_no_mem_(const ir_graph *irg)
{
return get_irn_n(irg->anchor, anchor_no_mem);
}
-static inline void _set_irg_no_mem(ir_graph *irg, ir_node *node)
+static inline void set_irg_no_mem_(ir_graph *irg, ir_node *node)
{
set_irn_n(irg->anchor, anchor_no_mem, node);
}
-static inline ir_entity *_get_irg_entity(const ir_graph *irg)
+static inline ir_entity *get_irg_entity_(const ir_graph *irg)
{
- assert(irg);
return irg->ent;
}
-static inline void _set_irg_entity(ir_graph *irg, ir_entity *ent)
+static inline void set_irg_entity_(ir_graph *irg, ir_entity *ent)
{
irg->ent = ent;
}
-static inline ir_type *_get_irg_frame_type(ir_graph *irg)
+static inline ir_type *get_irg_frame_type_(ir_graph *irg)
{
assert(irg->frame_type);
return irg->frame_type;
}
-static inline void _set_irg_frame_type(ir_graph *irg, ir_type *ftp)
+static inline void set_irg_frame_type_(ir_graph *irg, ir_type *ftp)
{
assert(is_frame_type(ftp));
irg->frame_type = ftp;
}
-static inline struct obstack *_get_irg_obstack(const ir_graph *irg)
+static inline struct obstack *get_irg_obstack_(const ir_graph *irg)
{
return irg->obst;
}
-static inline irg_phase_state _get_irg_phase_state(const ir_graph *irg)
+static inline irg_phase_state get_irg_phase_state_(const ir_graph *irg)
{
return irg->phase_state;
}
-static inline void _set_irg_phase_state(ir_graph *irg, irg_phase_state state)
+static inline void set_irg_phase_state_(ir_graph *irg, irg_phase_state state)
{
irg->phase_state = state;
}
-static inline op_pin_state _get_irg_pinned(const ir_graph *irg)
+static inline op_pin_state get_irg_pinned_(const ir_graph *irg)
{
return irg->irg_pinned_state;
}
-static inline void _set_irg_pinned(ir_graph *irg, op_pin_state p)
+static inline void set_irg_pinned_(ir_graph *irg, op_pin_state p)
{
irg->irg_pinned_state = p;
}
-static inline irg_callee_info_state _get_irg_callee_info_state(const ir_graph *irg)
+static inline irg_callee_info_state get_irg_callee_info_state_(const ir_graph *irg)
{
return irg->callee_info_state;
}
-static inline void _set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s)
+static inline void set_irg_callee_info_state_(ir_graph *irg, irg_callee_info_state s)
{
irg_callee_info_state irp_state = get_irp_callee_info_state();
set_irp_callee_info_state(s);
}
-static inline irg_inline_property _get_irg_inline_property(const ir_graph *irg)
+static inline irg_inline_property get_irg_inline_property_(const ir_graph *irg)
{
return irg->inline_property;
}
-static inline void _set_irg_inline_property(ir_graph *irg, irg_inline_property s)
+static inline void set_irg_inline_property_(ir_graph *irg, irg_inline_property s)
{
irg->inline_property = s;
}
-static inline mtp_additional_properties _get_irg_additional_properties(const ir_graph *irg)
+static inline mtp_additional_properties get_irg_additional_properties_(const ir_graph *irg)
{
if (irg->additional_properties & mtp_property_inherited)
return get_method_additional_properties(get_entity_type(irg->ent));
return irg->additional_properties;
}
-static inline void _set_irg_additional_properties(ir_graph *irg, mtp_additional_properties mask)
+static inline void set_irg_additional_properties_(ir_graph *irg, mtp_additional_properties mask)
{
irg->additional_properties = mask & ~mtp_property_inherited;
}
-static inline void _add_irg_additional_properties(ir_graph *irg, mtp_additional_properties flag)
+static inline void add_irg_additional_properties_(ir_graph *irg, mtp_additional_properties flag)
{
mtp_additional_properties prop = irg->additional_properties;
irg->additional_properties = prop | flag;
}
-static inline void _set_irg_link(ir_graph *irg, void *thing)
+static inline void set_irg_link_(ir_graph *irg, void *thing)
{
irg->link = thing;
}
-static inline void *_get_irg_link(const ir_graph *irg)
+static inline void *get_irg_link_(const ir_graph *irg)
{
return irg->link;
}
-static inline ir_visited_t _get_irg_visited(const ir_graph *irg)
+static inline ir_visited_t get_irg_visited_(const ir_graph *irg)
{
return irg->visited;
}
-static inline ir_visited_t _get_irg_block_visited(const ir_graph *irg)
+static inline ir_visited_t get_irg_block_visited_(const ir_graph *irg)
{
return irg->block_visited;
}
-static inline void _set_irg_block_visited(ir_graph *irg, ir_visited_t visited)
+static inline void set_irg_block_visited_(ir_graph *irg, ir_visited_t visited)
{
irg->block_visited = visited;
}
-static inline void _inc_irg_block_visited(ir_graph *irg)
+static inline void inc_irg_block_visited_(ir_graph *irg)
{
++irg->block_visited;
}
-static inline void _dec_irg_block_visited(ir_graph *irg)
+static inline void dec_irg_block_visited_(ir_graph *irg)
{
--irg->block_visited;
}
-static inline unsigned _get_irg_estimated_node_cnt(const ir_graph *irg)
+static inline unsigned get_irg_estimated_node_cnt_(const ir_graph *irg)
{
return irg->estimated_node_count;
}
/* Return the floating point model of this graph. */
-static inline unsigned _get_irg_fp_model(const ir_graph *irg)
+static inline unsigned get_irg_fp_model_(const ir_graph *irg)
{
return irg->fp_model;
}
-static inline void _set_irg_state(ir_graph *irg, ir_graph_state_t state)
+static inline void set_irg_state_(ir_graph *irg, ir_graph_state_t state)
{
irg->state = (ir_graph_state_t) (irg->state | state);
}
-static inline void _clear_irg_state(ir_graph *irg, ir_graph_state_t state)
+static inline void clear_irg_state_(ir_graph *irg, ir_graph_state_t state)
{
irg->state = (ir_graph_state_t) (irg->state & ~state);
}
-static inline int _is_irg_state(const ir_graph *irg, ir_graph_state_t state)
+static inline int is_irg_state_(const ir_graph *irg, ir_graph_state_t state)
{
return (irg->state & state) == state;
}
* @return The node with that index or NULL, if there is no node with that index.
* @note The node you got might be dead.
*/
-static inline ir_node *_get_idx_irn(const ir_graph *irg, unsigned idx)
+static inline ir_node *get_idx_irn_(const ir_graph *irg, unsigned idx)
{
assert(idx < (unsigned) ARR_LEN(irg->idx_irn_map));
return irg->idx_irn_map[idx];
}
-#define is_ir_graph(thing) _is_ir_graph(thing)
-#define get_irg_start_block(irg) _get_irg_start_block(irg)
-#define set_irg_start_block(irg, node) _set_irg_start_block(irg, node)
-#define get_irg_start(irg) _get_irg_start(irg)
-#define set_irg_start(irg, node) _set_irg_start(irg, node)
-#define get_irg_end_block(irg) _get_irg_end_block(irg)
-#define set_irg_end_block(irg, node) _set_irg_end_block(irg, node)
-#define get_irg_end(irg) _get_irg_end(irg)
-#define set_irg_end(irg, node) _set_irg_end(irg, node)
-#define get_irg_initial_exec(irg) _get_irg_initial_exec(irg)
-#define set_irg_initial_exec(irg, node) _set_irg_initial_exec(irg, node)
-#define get_irg_frame(irg) _get_irg_frame(irg)
-#define set_irg_frame(irg, node) _set_irg_frame(irg, node)
-#define get_irg_initial_mem(irg) _get_irg_initial_mem(irg)
-#define set_irg_initial_mem(irg, node) _set_irg_initial_mem(irg, node)
-#define get_irg_args(irg) _get_irg_args(irg)
-#define set_irg_args(irg, node) _set_irg_args(irg, node)
-#define get_irg_no_mem(irg) _get_irg_no_mem(irg)
-#define set_irn_no_mem(irg, node) _set_irn_no_mem(irg, node)
-#define get_irg_entity(irg) _get_irg_entity(irg)
-#define set_irg_entity(irg, ent) _set_irg_entity(irg, ent)
-#define get_irg_frame_type(irg) _get_irg_frame_type(irg)
-#define set_irg_frame_type(irg, ftp) _set_irg_frame_type(irg, ftp)
-#define get_irg_obstack(irg) _get_irg_obstack(irg)
-#define get_irg_phase_state(irg) _get_irg_phase_state(irg)
-#define set_irg_phase_state(irg, state) _set_irg_phase_state(irg, state)
-#define get_irg_pinned(irg) _get_irg_pinned(irg)
-#define set_irg_pinned(irg, p) _set_irg_pinned(irg, p)
-#define get_irg_callee_info_state(irg) _get_irg_callee_info_state(irg)
-#define set_irg_callee_info_state(irg, s) _set_irg_callee_info_state(irg, s)
-#define get_irg_inline_property(irg) _get_irg_inline_property(irg)
-#define set_irg_inline_property(irg, s) _set_irg_inline_property(irg, s)
-#define get_irg_additional_properties(irg) _get_irg_additional_properties(irg)
-#define set_irg_additional_properties(irg, m) _set_irg_additional_properties(irg, m)
-#define set_irg_additional_property(irg, f) _set_irg_additional_property(irg, f)
-#define set_irg_link(irg, thing) _set_irg_link(irg, thing)
-#define get_irg_link(irg) _get_irg_link(irg)
-#define get_irg_visited(irg) _get_irg_visited(irg)
-#define get_irg_block_visited(irg) _get_irg_block_visited(irg)
-#define set_irg_block_visited(irg, v) _set_irg_block_visited(irg, v)
-#define inc_irg_block_visited(irg) _inc_irg_block_visited(irg)
-#define dec_irg_block_visited(irg) _dec_irg_block_visited(irg)
-#define get_irg_estimated_node_cnt(irg) _get_irg_estimated_node_cnt(irg)
-#define get_irg_fp_model(irg) _get_irg_fp_model(irg)
-#define get_idx_irn(irg, idx) _get_idx_irn(irg, idx)
-#define set_irg_state(irg, state) _set_irg_state(irg, state)
-#define clear_irg_state(irg, state) _clear_irg_state(irg, state)
-#define is_irg_state(irg, state) _is_irg_state(irg, state)
+#define is_ir_graph(thing) is_ir_graph_(thing)
+#define get_irg_start_block(irg) get_irg_start_block_(irg)
+#define set_irg_start_block(irg, node) set_irg_start_block_(irg, node)
+#define get_irg_start(irg) get_irg_start_(irg)
+#define set_irg_start(irg, node) set_irg_start_(irg, node)
+#define get_irg_end_block(irg) get_irg_end_block_(irg)
+#define set_irg_end_block(irg, node) set_irg_end_block_(irg, node)
+#define get_irg_end(irg) get_irg_end_(irg)
+#define set_irg_end(irg, node) set_irg_end_(irg, node)
+#define get_irg_initial_exec(irg) get_irg_initial_exec_(irg)
+#define set_irg_initial_exec(irg, node) set_irg_initial_exec_(irg, node)
+#define get_irg_frame(irg) get_irg_frame_(irg)
+#define set_irg_frame(irg, node) set_irg_frame_(irg, node)
+#define get_irg_initial_mem(irg) get_irg_initial_mem_(irg)
+#define set_irg_initial_mem(irg, node) set_irg_initial_mem_(irg, node)
+#define get_irg_args(irg) get_irg_args_(irg)
+#define set_irg_args(irg, node) set_irg_args_(irg, node)
+#define get_irg_no_mem(irg) get_irg_no_mem_(irg)
+#define set_irn_no_mem(irg, node) set_irn_no_mem_(irg, node)
+#define get_irg_entity(irg) get_irg_entity_(irg)
+#define set_irg_entity(irg, ent) set_irg_entity_(irg, ent)
+#define get_irg_frame_type(irg) get_irg_frame_type_(irg)
+#define set_irg_frame_type(irg, ftp) set_irg_frame_type_(irg, ftp)
+#define get_irg_obstack(irg) get_irg_obstack_(irg)
+#define get_irg_phase_state(irg) get_irg_phase_state_(irg)
+#define set_irg_phase_state(irg, state) set_irg_phase_state_(irg, state)
+#define get_irg_pinned(irg) get_irg_pinned_(irg)
+#define set_irg_pinned(irg, p) set_irg_pinned_(irg, p)
+#define get_irg_callee_info_state(irg) get_irg_callee_info_state_(irg)
+#define set_irg_callee_info_state(irg, s) set_irg_callee_info_state_(irg, s)
+#define get_irg_inline_property(irg) get_irg_inline_property_(irg)
+#define set_irg_inline_property(irg, s) set_irg_inline_property_(irg, s)
+#define get_irg_additional_properties(irg) get_irg_additional_properties_(irg)
+#define set_irg_additional_properties(irg, m) set_irg_additional_properties_(irg, m)
+#define set_irg_additional_property(irg, f) set_irg_additional_property_(irg, f)
+#define set_irg_link(irg, thing) set_irg_link_(irg, thing)
+#define get_irg_link(irg) get_irg_link_(irg)
+#define get_irg_visited(irg) get_irg_visited_(irg)
+#define get_irg_block_visited(irg) get_irg_block_visited_(irg)
+#define set_irg_block_visited(irg, v) set_irg_block_visited_(irg, v)
+#define inc_irg_block_visited(irg) inc_irg_block_visited_(irg)
+#define dec_irg_block_visited(irg) dec_irg_block_visited_(irg)
+#define get_irg_estimated_node_cnt(irg) get_irg_estimated_node_cnt_(irg)
+#define get_irg_fp_model(irg) get_irg_fp_model_(irg)
+#define get_idx_irn(irg, idx) get_idx_irn_(irg, idx)
+#define set_irg_state(irg, state) set_irg_state_(irg, state)
+#define clear_irg_state(irg, state) clear_irg_state_(irg, state)
+#define is_irg_state(irg, state) is_irg_state_(irg, state)
#endif
int (is_ir_node)(const void *thing)
{
- return _is_ir_node(thing);
+ return is_ir_node_(thing);
}
int (get_irn_arity)(const ir_node *node)
{
- return _get_irn_arity(node);
+ return get_irn_arity_(node);
}
/* Returns the array with ins. This array is shifted with respect to the
ir_node *(get_irn_n)(const ir_node *node, int n)
{
- return _get_irn_n(node, n);
+ return get_irn_n_(node, n);
}
void set_irn_n(ir_node *node, int n, ir_node *in)
int (get_irn_deps)(const ir_node *node)
{
- return _get_irn_deps(node);
+ return get_irn_deps_(node);
}
ir_node *(get_irn_dep)(const ir_node *node, int pos)
{
- return _get_irn_dep(node, pos);
+ return get_irn_dep_(node, pos);
}
void (set_irn_dep)(ir_node *node, int pos, ir_node *dep)
{
- _set_irn_dep(node, pos, dep);
+ set_irn_dep_(node, pos, dep);
}
int add_irn_dep(ir_node *node, ir_node *dep)
ir_mode *(get_irn_mode)(const ir_node *node)
{
- return _get_irn_mode(node);
+ return get_irn_mode_(node);
}
void (set_irn_mode)(ir_node *node, ir_mode *mode)
{
- _set_irn_mode(node, mode);
+ set_irn_mode_(node, mode);
}
ir_op *(get_irn_op)(const ir_node *node)
{
- return _get_irn_op(node);
+ return get_irn_op_(node);
}
/* should be private to the library: */
void (set_irn_op)(ir_node *node, ir_op *op)
{
- _set_irn_op(node, op);
+ set_irn_op_(node, op);
}
unsigned (get_irn_opcode)(const ir_node *node)
{
- return _get_irn_opcode(node);
+ return get_irn_opcode_(node);
}
const char *get_irn_opname(const ir_node *node)
ir_visited_t (get_irn_visited)(const ir_node *node)
{
- return _get_irn_visited(node);
+ return get_irn_visited_(node);
}
void (set_irn_visited)(ir_node *node, ir_visited_t visited)
{
- _set_irn_visited(node, visited);
+ set_irn_visited_(node, visited);
}
void (mark_irn_visited)(ir_node *node)
{
- _mark_irn_visited(node);
+ mark_irn_visited_(node);
}
int (irn_visited)(const ir_node *node)
{
- return _irn_visited(node);
+ return irn_visited_(node);
}
int (irn_visited_else_mark)(ir_node *node)
{
- return _irn_visited_else_mark(node);
+ return irn_visited_else_mark_(node);
}
void (set_irn_link)(ir_node *node, void *link)
{
- _set_irn_link(node, link);
+ set_irn_link_(node, link);
}
void *(get_irn_link)(const ir_node *node)
{
- return _get_irn_link(node);
+ return get_irn_link_(node);
}
op_pin_state (get_irn_pinned)(const ir_node *node)
{
- return _get_irn_pinned(node);
+ return get_irn_pinned_(node);
}
op_pin_state (is_irn_pinned_in_irg) (const ir_node *node)
{
- return _is_irn_pinned_in_irg(node);
+ return is_irn_pinned_in_irg_(node);
}
void set_irn_pinned(ir_node *node, op_pin_state state)
void *(get_irn_generic_attr)(ir_node *node)
{
assert(is_ir_node(node));
- return _get_irn_generic_attr(node);
+ return get_irn_generic_attr_(node);
}
const void *(get_irn_generic_attr_const)(const ir_node *node)
{
assert(is_ir_node(node));
- return _get_irn_generic_attr_const(node);
+ return get_irn_generic_attr_const_(node);
}
unsigned (get_irn_idx)(const ir_node *node)
{
assert(is_ir_node(node));
- return _get_irn_idx(node);
+ return get_irn_idx_(node);
}
int get_irn_pred_pos(ir_node *node, ir_node *arg)
ir_node *(get_nodes_block)(const ir_node *node)
{
- return _get_nodes_block(node);
+ return get_nodes_block_(node);
}
void set_nodes_block(ir_node *node, ir_node *block)
int (get_Block_n_cfgpreds)(const ir_node *node)
{
- return _get_Block_n_cfgpreds(node);
+ return get_Block_n_cfgpreds_(node);
}
ir_node *(get_Block_cfgpred)(const ir_node *node, int pos)
{
- return _get_Block_cfgpred(node, pos);
+ return get_Block_cfgpred_(node, pos);
}
void set_Block_cfgpred(ir_node *node, int pos, ir_node *pred)
ir_node *(get_Block_cfgpred_block)(const ir_node *node, int pos)
{
- return _get_Block_cfgpred_block(node, pos);
+ return get_Block_cfgpred_block_(node, pos);
}
int get_Block_matured(const ir_node *node)
ir_visited_t (get_Block_block_visited)(const ir_node *node)
{
- return _get_Block_block_visited(node);
+ return get_Block_block_visited_(node);
}
void (set_Block_block_visited)(ir_node *node, ir_visited_t visit)
{
- _set_Block_block_visited(node, visit);
+ set_Block_block_visited_(node, visit);
}
void (mark_Block_block_visited)(ir_node *node)
{
- _mark_Block_block_visited(node);
+ mark_Block_block_visited_(node);
}
int (Block_block_visited)(const ir_node *node)
{
- return _Block_block_visited(node);
+ return Block_block_visited_(node);
}
ir_extblk *get_Block_extbb(const ir_node *block)
/* returns the graph of a Block. */
ir_graph *(get_Block_irg)(const ir_node *block)
{
- return _get_Block_irg(block);
+ return get_Block_irg_(block);
}
ir_entity *create_Block_entity(ir_node *block)
ir_node *(get_Block_phis)(const ir_node *block)
{
- return _get_Block_phis(block);
+ return get_Block_phis_(block);
}
void (set_Block_phis)(ir_node *block, ir_node *phi)
{
- _set_Block_phis(block, phi);
+ set_Block_phis_(block, phi);
}
void (add_Block_phi)(ir_node *block, ir_node *phi)
{
- _add_Block_phi(block, phi);
+ add_Block_phi_(block, phi);
}
/* Get the Block mark (single bit). */
unsigned (get_Block_mark)(const ir_node *block)
{
- return _get_Block_mark(block);
+ return get_Block_mark_(block);
}
/* Set the Block mark (single bit). */
void (set_Block_mark)(ir_node *block, unsigned mark)
{
- _set_Block_mark(block, mark);
+ set_Block_mark_(block, mark);
}
int get_End_n_keepalives(const ir_node *end)
int (is_Const_null)(const ir_node *node)
{
- return _is_Const_null(node);
+ return is_Const_null_(node);
}
int (is_Const_one)(const ir_node *node)
{
- return _is_Const_one(node);
+ return is_Const_one_(node);
}
int (is_Const_all_one)(const ir_node *node)
{
- return _is_Const_all_one(node);
+ return is_Const_all_one_(node);
}
int (is_unop)(const ir_node *node)
{
- return _is_unop(node);
+ return is_unop_(node);
}
ir_node *get_unop_op(const ir_node *node)
int (is_binop)(const ir_node *node)
{
- return _is_binop(node);
+ return is_binop_(node);
}
ir_node *get_binop_left(const ir_node *node)
ir_node *(get_Phi_next)(const ir_node *phi)
{
- return _get_Phi_next(phi);
+ return get_Phi_next_(phi);
}
void (set_Phi_next)(ir_node *phi, ir_node *next)
{
- _set_Phi_next(phi, next);
+ set_Phi_next_(phi, next);
}
int is_memop(const ir_node *node)
int (is_arg_Proj)(const ir_node *node)
{
- return _is_arg_Proj(node);
+ return is_arg_Proj_(node);
}
int is_x_except_Proj(const ir_node *node)
/* returns the graph of a node */
ir_graph *(get_irn_irg)(const ir_node *node)
{
- return _get_irn_irg(node);
+ return get_irn_irg_(node);
}
int (is_strictConv)(const ir_node *node)
{
- return _is_strictConv(node);
+ return is_strictConv_(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);
+ return is_SymConst_addr_ent_(node);
}
/* Returns true if the operation manipulates control flow. */
/* Returns true if the operation is a forking control flow operation. */
int (is_irn_forking)(const ir_node *node)
{
- return _is_irn_forking(node);
+ return is_irn_forking_(node);
}
void (copy_node_attr)(ir_graph *irg, const ir_node *old_node, ir_node *new_node)
{
- _copy_node_attr(irg, old_node, new_node);
+ copy_node_attr_(irg, old_node, new_node);
}
/* Return the type attribute of a node n (SymConst, Call, Alloc, Free,
Cast) or NULL.*/
ir_type *(get_irn_type_attr)(ir_node *node)
{
- return _get_irn_type_attr(node);
+ return get_irn_type_attr_(node);
}
/* Return the entity attribute of a node n (SymConst, Sel) or NULL. */
ir_entity *(get_irn_entity_attr)(ir_node *node)
{
- return _get_irn_entity_attr(node);
+ return get_irn_entity_attr_(node);
}
/* Returns non-zero for constant-like nodes. */
int (is_irn_constlike)(const ir_node *node)
{
- return _is_irn_constlike(node);
+ return is_irn_constlike_(node);
}
/*
*/
int (is_irn_keep)(const ir_node *node)
{
- return _is_irn_keep(node);
+ return is_irn_keep_(node);
}
/*
*/
int (is_irn_start_block_placed)(const ir_node *node)
{
- return _is_irn_start_block_placed(node);
+ return is_irn_start_block_placed_(node);
}
/* Returns non-zero for nodes that are machine operations. */
int (is_irn_machine_op)(const ir_node *node)
{
- return _is_irn_machine_op(node);
+ return is_irn_machine_op_(node);
}
/* Returns non-zero for nodes that are machine operands. */
int (is_irn_machine_operand)(const ir_node *node)
{
- return _is_irn_machine_operand(node);
+ return is_irn_machine_operand_(node);
}
/* Returns non-zero for nodes that have the n'th user machine flag set. */
int (is_irn_machine_user)(const ir_node *node, unsigned n)
{
- return _is_irn_machine_user(node, n);
+ return is_irn_machine_user_(node, n);
}
/* Returns non-zero for nodes that are CSE neutral to its users. */
int (is_irn_cse_neutral)(const ir_node *node)
{
- return _is_irn_cse_neutral(node);
+ return is_irn_cse_neutral_(node);
}
/* Gets the string representation of the jump prediction .*/
/* Sets the debug information of a node. */
void (set_irn_dbg_info)(ir_node *n, dbg_info *db)
{
- _set_irn_dbg_info(n, db);
+ set_irn_dbg_info_(n, db);
}
/**
*/
dbg_info *(get_irn_dbg_info)(const ir_node *n)
{
- return _get_irn_dbg_info(n);
+ return get_irn_dbg_info_(n);
}
/*
* Note that this function returns the whole in array including the
* block predecessor. So, it is NOT symmetric with set_irn_in().
*/
-ir_node **get_irn_in (const ir_node *node);
+ir_node **get_irn_in(const ir_node *node);
/**
* The amount of additional space for custom data to be allocated upon creating a new node.
* Checks whether a pointer points to a ir node.
* Intern version for libFirm.
*/
-static inline int _is_ir_node(const void *thing)
+static inline int is_ir_node_(const void *thing)
{
return (get_kind(thing) == k_ir_node);
}
* Gets the op of a node.
* Intern version for libFirm.
*/
-static inline ir_op *_get_irn_op(const ir_node *node)
+static inline ir_op *get_irn_op_(const ir_node *node)
{
assert(node);
return node->op;
}
-static inline void _set_irn_op(ir_node *node, ir_op *op)
+static inline void set_irn_op_(ir_node *node, ir_op *op)
{
assert(node);
node->op = op;
/** Copies all attributes stored in the old node to the new node.
Assumes both have the same opcode and sufficient size. */
-static inline void _copy_node_attr(ir_graph *irg, const ir_node *old_node,
+static inline void copy_node_attr_(ir_graph *irg, const ir_node *old_node,
ir_node *new_node)
{
- ir_op *op = _get_irn_op(old_node);
+ ir_op *op = get_irn_op_(old_node);
/* must always exist */
op->ops.copy_attr(irg, old_node, new_node);
* Gets the opcode of a node.
* Intern version for libFirm.
*/
-static inline unsigned _get_irn_opcode(const ir_node *node)
+static inline unsigned get_irn_opcode_(const ir_node *node)
{
assert(k_ir_node == get_kind(node));
assert(node->op);
* Returns the number of predecessors without the block predecessor.
* Intern version for libFirm.
*/
-static inline int _get_irn_arity(const ir_node *node)
+static inline int get_irn_arity_(const ir_node *node)
{
return (int)(ARR_LEN(node->in) - 1);
}
/**
* Intern version for libFirm.
*/
-static inline ir_node *_get_irn_n(const ir_node *node, int n)
+static inline ir_node *get_irn_n_(const ir_node *node, int n)
{
ir_node *nn;
- assert(-1 <= n && n < _get_irn_arity(node));
+ assert(-1 <= n && n < get_irn_arity_(node));
nn = node->in[n + 1];
if (nn->op != op_Id) return nn;
return (unsigned) get_irn_idx(node);
}
-static inline int _get_irn_deps(const ir_node *node) {
+static inline int get_irn_deps_(const ir_node *node)
+{
return node->deps ? (int)ARR_LEN(node->deps) : 0;
}
-static inline ir_node *_get_irn_dep(const ir_node *node, int pos) {
+static inline ir_node *get_irn_dep_(const ir_node *node, int pos)
+{
assert(node->deps && "dependency array node yet allocated. use add_irn_dep()");
assert(pos >= 0 && pos < (int)ARR_LEN(node->deps) && "dependency index out of range");
return node->deps[pos];
/* forward declaration outside iredges_t.h to avoid circular include problems */
void edges_notify_edge_kind(ir_node *src, int pos, ir_node *tgt, ir_node *old_tgt, ir_edge_kind_t kind, ir_graph *irg);
-static inline void _set_irn_dep(ir_node *node, int pos, ir_node *dep)
+static inline void set_irn_dep_(ir_node *node, int pos, ir_node *dep)
{
ir_node *old;
}
-static inline int _get_irn_ins_or_deps(const ir_node *irn)
+static inline int get_irn_ins_or_deps_(const ir_node *irn)
{
- return _get_irn_deps(irn) + _get_irn_arity(irn);
+ return get_irn_deps_(irn) + get_irn_arity_(irn);
}
-static inline ir_node *_get_irn_in_or_dep(const ir_node *irn, int pos)
+static inline ir_node *get_irn_in_or_dep_(const ir_node *irn, int pos)
{
int n_in = get_irn_arity(irn);
return pos < n_in ? get_irn_n(irn, pos) : get_irn_dep(irn, pos - n_in);
* Gets the mode of a node.
* Intern version for libFirm.
*/
-static inline ir_mode *_get_irn_mode(const ir_node *node)
+static inline ir_mode *get_irn_mode_(const ir_node *node)
{
assert(node);
return node->mode;
* Sets the mode of a node.
* Intern version of libFirm.
*/
-static inline void _set_irn_mode(ir_node *node, ir_mode *mode)
+static inline void set_irn_mode_(ir_node *node, ir_mode *mode)
{
assert(node);
node->mode = mode;
return is_Block(node) || is_Bad(node) || is_Anchor(node);
}
-static inline ir_graph *_get_irn_irg(const ir_node *node)
+static inline ir_graph *get_irn_irg_(const ir_node *node)
{
/*
* Do not use get_nodes_block() here, because this
return node->attr.irg.irg;
}
-static inline ir_node *_get_nodes_block(const ir_node *node)
+static inline ir_node *get_nodes_block_(const ir_node *node)
{
assert(!is_Block(node));
return get_irn_n(node, -1);
* Gets the visited counter of a node.
* Intern version for libFirm.
*/
-static inline ir_visited_t _get_irn_visited(const ir_node *node)
+static inline ir_visited_t get_irn_visited_(const ir_node *node)
{
assert(node);
return node->visited;
* Sets the visited counter of a node.
* Intern version for libFirm.
*/
-static inline void _set_irn_visited(ir_node *node, ir_visited_t visited)
+static inline void set_irn_visited_(ir_node *node, ir_visited_t visited)
{
assert(node);
node->visited = visited;
* Mark a node as visited in a graph.
* Intern version for libFirm.
*/
-static inline void _mark_irn_visited(ir_node *node)
+static inline void mark_irn_visited_(ir_node *node)
{
node->visited = get_irn_irg(node)->visited;
}
* Returns non-zero if a node of was visited.
* Intern version for libFirm.
*/
-static inline int _irn_visited(const ir_node *node)
+static inline int irn_visited_(const ir_node *node)
{
ir_graph *irg = get_irn_irg(node);
return node->visited >= irg->visited;
}
-static inline int _irn_visited_else_mark(ir_node *node)
+static inline int irn_visited_else_mark_(ir_node *node)
{
- if (_irn_visited(node))
+ if (irn_visited_(node))
return 1;
- _mark_irn_visited(node);
+ mark_irn_visited_(node);
return 0;
}
* Sets the link of a node.
* Intern version of libFirm.
*/
-static inline void _set_irn_link(ir_node *node, void *link)
+static inline void set_irn_link_(ir_node *node, void *link)
{
assert(node);
node->link = link;
* Returns the link of a node.
* Intern version of libFirm.
*/
-static inline void *_get_irn_link(const ir_node *node)
+static inline void *get_irn_link_(const ir_node *node)
{
- assert(node && _is_ir_node(node));
+ assert(node && is_ir_node_(node));
return node->link;
}
*
* Intern version of libFirm.
*/
-static inline op_pin_state _get_irn_pinned(const ir_node *node)
+static inline op_pin_state get_irn_pinned_(const ir_node *node)
{
op_pin_state state;
- assert(node && _is_ir_node(node));
+ assert(node && is_ir_node_(node));
/* Check opcode */
- state = _get_op_pinned(_get_irn_op(node));
+ state = get_op_pinned_(get_irn_op_(node));
if (state >= op_pin_state_exc_pinned)
return (op_pin_state)node->attr.except.pin_state;
return state;
}
-static inline op_pin_state _is_irn_pinned_in_irg(const ir_node *node)
+static inline op_pin_state is_irn_pinned_in_irg_(const ir_node *node)
{
if (get_irg_pinned(get_irn_irg(node)) == op_pin_state_floats)
return get_irn_pinned(node);
/* include generated code */
#include "gen_irnode.h"
-static inline int _is_unop(const ir_node *node)
+static inline int is_unop_(const ir_node *node)
{
- assert(node && _is_ir_node(node));
+ assert(node && is_ir_node_(node));
return (node->op->opar == oparity_unary);
}
-static inline int _is_binop(const ir_node *node)
+static inline int is_binop_(const ir_node *node)
{
- assert(node && _is_ir_node(node));
+ assert(node && is_ir_node_(node));
return (node->op->opar == oparity_binary);
}
-static inline int _is_strictConv(const ir_node *node)
+static inline int is_strictConv_(const ir_node *node)
{
- return _is_Conv(node) && get_Conv_strict(node);
+ return is_Conv_(node) && get_Conv_strict(node);
}
-static inline int _is_SymConst_addr_ent(const ir_node *node)
+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 _get_Block_n_cfgpreds(const ir_node *node)
+static inline int get_Block_n_cfgpreds_(const ir_node *node)
{
- assert(_is_Block(node));
- return _get_irn_arity(node);
+ assert(is_Block_(node));
+ return get_irn_arity_(node);
}
-static inline ir_node *_get_Block_cfgpred(const ir_node *node, int pos)
+static inline ir_node *get_Block_cfgpred_(const ir_node *node, int pos)
{
- assert(0 <= pos && pos < get_irn_arity(node));
- assert(_is_Block(node));
- return _get_irn_n(node, pos);
+ assert(is_Block_(node));
+ return get_irn_n_(node, pos);
}
/* Get the predecessor block.
* - If we encounter the Bad node, this function does not return
* the Start block, but the Bad node.
*/
-static inline ir_node *_get_Block_cfgpred_block(const ir_node *node, int pos)
+static inline ir_node *get_Block_cfgpred_block_(const ir_node *node, int pos)
{
ir_node *res = get_Block_cfgpred(node, pos);
if (is_Bad(res)) {
}
}
-static inline ir_visited_t _get_Block_block_visited(const ir_node *node)
+static inline ir_visited_t get_Block_block_visited_(const ir_node *node)
{
assert(is_Block(node));
return node->attr.block.block_visited;
}
-static inline void _set_Block_block_visited(ir_node *node, ir_visited_t visit)
+static inline void set_Block_block_visited_(ir_node *node, ir_visited_t visit)
{
assert(is_Block(node));
node->attr.block.block_visited = visit;
}
-static inline void _mark_Block_block_visited(ir_node *node)
+static inline void mark_Block_block_visited_(ir_node *node)
{
ir_graph *irg = get_Block_irg(node);
node->attr.block.block_visited = get_irg_block_visited(irg);
}
-static inline int _Block_block_visited(const ir_node *node)
+static inline int Block_block_visited_(const ir_node *node)
{
ir_graph *irg = get_Block_irg(node);
return node->attr.block.block_visited >= get_irg_block_visited(irg);
}
-static inline ir_graph *_get_Block_irg(const ir_node *block)
+static inline ir_graph *get_Block_irg_(const ir_node *block)
{
assert(is_Block(block));
return block->attr.irg.irg;
}
-static inline ir_tarval *_get_Const_tarval(const ir_node *node) {
- assert(_get_irn_op(node) == op_Const);
+static inline ir_tarval *get_Const_tarval_(const ir_node *node)
+{
+ assert(get_irn_op_(node) == op_Const);
return node->attr.con.tarval;
}
-static inline int _is_Const_null(const ir_node *node) {
- return tarval_is_null(_get_Const_tarval(node));
+static inline int is_Const_null_(const ir_node *node)
+{
+ return tarval_is_null(get_Const_tarval_(node));
}
-static inline int _is_Const_one(const ir_node *node) {
- return tarval_is_one(_get_Const_tarval(node));
+static inline int is_Const_one_(const ir_node *node)
+{
+ return tarval_is_one(get_Const_tarval_(node));
}
-static inline int _is_Const_all_one(const ir_node *node) {
- return tarval_is_all_one(_get_Const_tarval(node));
+static inline int is_Const_all_one_(const ir_node *node)
+{
+ return tarval_is_all_one(get_Const_tarval_(node));
}
-static inline int _is_irn_forking(const ir_node *node) {
- return is_op_forking(_get_irn_op(node));
+static inline int is_irn_forking_(const ir_node *node)
+{
+ return is_op_forking(get_irn_op_(node));
}
-static inline ir_type *_get_irn_type_attr(ir_node *node) {
- return _get_irn_op(node)->ops.get_type_attr(node);
+static inline ir_type *get_irn_type_attr_(ir_node *node)
+{
+ return get_irn_op_(node)->ops.get_type_attr(node);
}
-static inline ir_entity *_get_irn_entity_attr(ir_node *node) {
- return _get_irn_op(node)->ops.get_entity_attr(node);
+static inline ir_entity *get_irn_entity_attr_(ir_node *node)
+{
+ return get_irn_op_(node)->ops.get_entity_attr(node);
}
-static inline int _is_irn_constlike(const ir_node *node) {
- return is_op_constlike(_get_irn_op(node));
+static inline int is_irn_constlike_(const ir_node *node)
+{
+ return is_op_constlike(get_irn_op_(node));
}
-static inline int _is_irn_always_opt(const ir_node *node) {
- return is_op_always_opt(_get_irn_op(node));
+static inline int is_irn_always_opt_(const ir_node *node)
+{
+ return is_op_always_opt(get_irn_op_(node));
}
-static inline int _is_irn_keep(const ir_node *node) {
- return is_op_keep(_get_irn_op(node));
+static inline int is_irn_keep_(const ir_node *node)
+{
+ return is_op_keep(get_irn_op_(node));
}
-static inline int _is_irn_start_block_placed(const ir_node *node) {
- return is_op_start_block_placed(_get_irn_op(node));
+static inline int is_irn_start_block_placed_(const ir_node *node)
+{
+ return is_op_start_block_placed(get_irn_op_(node));
}
-static inline int _is_irn_machine_op(const ir_node *node) {
- return is_op_machine(_get_irn_op(node));
+static inline int is_irn_machine_op_(const ir_node *node)
+{
+ return is_op_machine(get_irn_op_(node));
}
-static inline int _is_irn_machine_operand(const ir_node *node) {
- return is_op_machine_operand(_get_irn_op(node));
+static inline int is_irn_machine_operand_(const ir_node *node)
+{
+ return is_op_machine_operand(get_irn_op_(node));
}
-static inline int _is_irn_machine_user(const ir_node *node, unsigned n) {
- return is_op_machine_user(_get_irn_op(node), n);
+static inline int is_irn_machine_user_(const ir_node *node, unsigned n)
+{
+ return is_op_machine_user(get_irn_op_(node), n);
}
-static inline int _is_irn_cse_neutral(const ir_node *node) {
- return is_op_cse_neutral(_get_irn_op(node));
+static inline int is_irn_cse_neutral_(const ir_node *node)
+{
+ return is_op_cse_neutral(get_irn_op_(node));
}
-static inline cond_jmp_predicate _get_Cond_jmp_pred(const ir_node *node) {
- assert(_get_irn_op(node) == op_Cond);
+static inline cond_jmp_predicate get_Cond_jmp_pred_(const ir_node *node)
+{
+ assert(get_irn_op_(node) == op_Cond);
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);
+static inline void set_Cond_jmp_pred_(ir_node *node, cond_jmp_predicate pred)
+{
+ assert(get_irn_op_(node) == op_Cond);
node->attr.cond.jmp_pred = pred;
}
-static inline void *_get_irn_generic_attr(ir_node *node) {
+static inline void *get_irn_generic_attr_(ir_node *node)
+{
return &node->attr;
}
-static inline const void *_get_irn_generic_attr_const(const ir_node *node) {
+static inline const void *get_irn_generic_attr_const_(const ir_node *node)
+{
return &node->attr;
}
-static inline unsigned _get_irn_idx(const ir_node *node) {
+static inline unsigned get_irn_idx_(const ir_node *node)
+{
return node->node_idx;
}
-static inline dbg_info *_get_irn_dbg_info(const ir_node *n) {
+static inline dbg_info *get_irn_dbg_info_(const ir_node *n)
+{
return n->dbi;
}
-static inline void _set_irn_dbg_info(ir_node *n, dbg_info *db) {
+static inline void set_irn_dbg_info_(ir_node *n, dbg_info *db)
+{
n->dbi = db;
}
/**
* Sets the Phi list of a block.
*/
-static inline void _set_Block_phis(ir_node *block, ir_node *phi)
+static inline void set_Block_phis_(ir_node *block, ir_node *phi)
{
- assert(_is_Block(block));
- assert(phi == NULL || _is_Phi(phi));
+ assert(is_Block_(block));
+ assert(phi == NULL || is_Phi_(phi));
block->attr.block.phis = phi;
}
* Returns the link of a node.
* Intern version of libFirm.
*/
-static inline ir_node *_get_Block_phis(const ir_node *block)
+static inline ir_node *get_Block_phis_(const ir_node *block)
{
- assert(_is_Block(block));
+ assert(is_Block_(block));
return block->attr.block.phis;
}
-static inline void _set_Phi_next(ir_node *phi, ir_node *next)
+static inline void set_Phi_next_(ir_node *phi, ir_node *next)
{
- assert(_is_Phi(phi));
+ assert(is_Phi_(phi));
phi->attr.phi.next = next;
}
-static inline ir_node *_get_Phi_next(const ir_node *phi)
+static inline ir_node *get_Phi_next_(const ir_node *phi)
{
- assert(_is_Phi(phi));
+ assert(is_Phi_(phi));
return phi->attr.phi.next;
}
/** Add a Phi node to the list of Block Phi's. */
-static inline void _add_Block_phi(ir_node *block, ir_node *phi)
+static inline void add_Block_phi_(ir_node *block, ir_node *phi)
{
- assert(_is_Block(block));
- _set_Phi_next(phi, _get_Block_phis(block));
- _set_Block_phis(block, phi);
+ assert(is_Block_(block));
+ set_Phi_next_(phi, get_Block_phis_(block));
+ set_Block_phis_(block, phi);
}
/** Get the Block mark (single bit). */
-static inline unsigned _get_Block_mark(const ir_node *block)
+static inline unsigned get_Block_mark_(const ir_node *block)
{
- assert(_is_Block(block));
+ assert(is_Block_(block));
return block->attr.block.marked;
}
/** Set the Block mark (single bit). */
-static inline void _set_Block_mark(ir_node *block, unsigned mark)
+static inline void set_Block_mark_(ir_node *block, unsigned mark)
{
- assert(_is_Block(block));
+ assert(is_Block_(block));
block->attr.block.marked = mark;
}
/** Returns non-zero if a node is a routine parameter. */
-static inline int _is_arg_Proj(const ir_node *node)
+static inline int is_arg_Proj_(const ir_node *node)
{
if (! is_Proj(node))
return 0;
void init_irnode(void);
/* this section MUST contain all inline functions */
-#define is_ir_node(thing) _is_ir_node(thing)
-#define get_irn_arity(node) _get_irn_arity(node)
-#define get_irn_n(node, n) _get_irn_n(node, n)
-#define get_irn_mode(node) _get_irn_mode(node)
-#define set_irn_mode(node, mode) _set_irn_mode(node, mode)
-#define get_irn_irg(node) _get_irn_irg(node)
-#define get_nodes_block(node) _get_nodes_block(node)
-#define get_irn_op(node) _get_irn_op(node)
-#define set_irn_op(node, op) _set_irn_op(node, op)
-#define get_irn_opcode(node) _get_irn_opcode(node)
-#define get_irn_visited(node) _get_irn_visited(node)
-#define set_irn_visited(node, v) _set_irn_visited(node, v)
-#define mark_irn_visited(node) _mark_irn_visited(node)
-#define irn_visited(node) _irn_visited(node)
-#define irn_visited_else_mark(node) _irn_visited_else_mark(node)
-#define set_irn_link(node, link) _set_irn_link(node, link)
-#define get_irn_link(node) _get_irn_link(node)
-#define get_irn_pinned(node) _get_irn_pinned(node)
-#define is_irn_pinned_in_irg(node) _is_irn_pinned_in_irg(node)
-#define is_unop(node) _is_unop(node)
-#define is_binop(node) _is_binop(node)
-#define is_Proj(node) _is_Proj(node)
-#define is_Phi(node) _is_Phi(node)
-#define is_strictConv(node) _is_strictConv(node)
-#define is_SymConst_addr_ent(node) _is_SymConst_addr_ent(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)
-#define get_Block_block_visited(node) _get_Block_block_visited(node)
-#define set_Block_block_visited(node, visit) _set_Block_block_visited(node, visit)
-#define mark_Block_block_visited(node) _mark_Block_block_visited(node)
-#define Block_block_visited(node) _Block_block_visited(node)
-#define get_Block_irg(block) _get_Block_irg(block)
-#define get_Const_tarval(node) _get_Const_tarval(node)
-#define is_Const_null(node) _is_Const_null(node)
-#define is_Const_one(node) _is_Const_one(node)
-#define is_Const_all_one(node) _is_Const_all_one(node)
-#define is_irn_forking(node) _is_irn_forking(node)
-#define copy_node_attr(irg,oldn,newn) _copy_node_attr(irg,oldn,newn)
-#define get_irn_type(node) _get_irn_type(node)
-#define get_irn_type_attr(node) _get_irn_type_attr(node)
-#define get_irn_entity_attr(node) _get_irn_entity_attr(node)
-#define is_irn_constlike(node) _is_irn_constlike(node)
-#define is_irn_always_opt(node) _is_irn_always_opt(node)
-#define is_irn_keep(node) _is_irn_keep(node)
-#define is_irn_start_block_placed(node) _is_irn_start_block_placed(node)
-#define is_irn_machine_op(node) _is_irn_machine_op(node)
-#define is_irn_machine_operand(node) _is_irn_machine_operand(node)
-#define is_irn_machine_user(node, n) _is_irn_machine_user(node, n)
-#define is_irn_cse_neutral(node) _is_irn_cse_neutral(node)
-#define get_Cond_jmp_pred(node) _get_Cond_jmp_pred(node)
-#define set_Cond_jmp_pred(node, pred) _set_Cond_jmp_pred(node, pred)
-#define get_irn_generic_attr(node) _get_irn_generic_attr(node)
-#define get_irn_generic_attr_const(node) _get_irn_generic_attr_const(node)
-#define get_irn_idx(node) _get_irn_idx(node)
-
-#define get_irn_deps(node) _get_irn_deps(node)
-#define set_irn_dep(node, pos, dep) _set_irn_dep(node, pos, dep)
-#define get_irn_dep(node, pos) _get_irn_dep(node, pos)
-
-#define get_irn_ins_or_deps(node) _get_irn_ins_or_deps(node)
-#define get_irn_in_or_dep(node, pos) _get_irn_in_or_dep(node, pos)
-
-#define get_irn_dbg_info(node) _get_irn_dbg_info(node)
-#define set_irn_dbg_info(node, db) _set_irn_dbg_info(node, db)
-
-#define set_Block_phis(block, phi) _set_Block_phis(block, phi)
-#define get_Block_phis(block) _get_Block_phis(block)
-#define add_Block_phi(block, phi) _add_Block_phi(block, phi)
-#define get_Block_mark(block) _get_Block_mark(block)
-#define set_Block_mark(block, mark) _set_Block_mark(block, mark)
-
-#define set_Phi_next(node, phi) _set_Phi_next(node, phi)
-#define get_Phi_next(node) _get_Phi_next(node)
-
-#define is_arg_Proj(node) _is_arg_Proj(node)
+#define is_ir_node(thing) is_ir_node_(thing)
+#define get_irn_arity(node) get_irn_arity_(node)
+#define get_irn_n(node, n) get_irn_n_(node, n)
+#define get_irn_mode(node) get_irn_mode_(node)
+#define set_irn_mode(node, mode) set_irn_mode_(node, mode)
+#define get_irn_irg(node) get_irn_irg_(node)
+#define get_nodes_block(node) get_nodes_block_(node)
+#define get_irn_op(node) get_irn_op_(node)
+#define set_irn_op(node, op) set_irn_op_(node, op)
+#define get_irn_opcode(node) get_irn_opcode_(node)
+#define get_irn_visited(node) get_irn_visited_(node)
+#define set_irn_visited(node, v) set_irn_visited_(node, v)
+#define mark_irn_visited(node) mark_irn_visited_(node)
+#define irn_visited(node) irn_visited_(node)
+#define irn_visited_else_mark(node) irn_visited_else_mark_(node)
+#define set_irn_link(node, link) set_irn_link_(node, link)
+#define get_irn_link(node) get_irn_link_(node)
+#define get_irn_pinned(node) get_irn_pinned_(node)
+#define is_irn_pinned_in_irg(node) is_irn_pinned_in_irg_(node)
+#define is_unop(node) is_unop_(node)
+#define is_binop(node) is_binop_(node)
+#define is_Proj(node) is_Proj_(node)
+#define is_Phi(node) is_Phi_(node)
+#define is_strictConv(node) is_strictConv_(node)
+#define is_SymConst_addr_ent(node) is_SymConst_addr_ent_(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)
+#define get_Block_block_visited(node) get_Block_block_visited_(node)
+#define set_Block_block_visited(node, visit) set_Block_block_visited_(node, visit)
+#define mark_Block_block_visited(node) mark_Block_block_visited_(node)
+#define Block_block_visited(node) Block_block_visited_(node)
+#define get_Block_irg(block) get_Block_irg_(block)
+#define get_Const_tarval(node) get_Const_tarval_(node)
+#define is_Const_null(node) is_Const_null_(node)
+#define is_Const_one(node) is_Const_one_(node)
+#define is_Const_all_one(node) is_Const_all_one_(node)
+#define is_irn_forking(node) is_irn_forking_(node)
+#define copy_node_attr(irg,oldn,newn) copy_node_attr_(irg,oldn,newn)
+#define get_irn_type(node) get_irn_type_(node)
+#define get_irn_type_attr(node) get_irn_type_attr_(node)
+#define get_irn_entity_attr(node) get_irn_entity_attr_(node)
+#define is_irn_constlike(node) is_irn_constlike_(node)
+#define is_irn_always_opt(node) is_irn_always_opt_(node)
+#define is_irn_keep(node) is_irn_keep_(node)
+#define is_irn_start_block_placed(node) is_irn_start_block_placed_(node)
+#define is_irn_machine_op(node) is_irn_machine_op_(node)
+#define is_irn_machine_operand(node) is_irn_machine_operand_(node)
+#define is_irn_machine_user(node, n) is_irn_machine_user_(node, n)
+#define is_irn_cse_neutral(node) is_irn_cse_neutral_(node)
+#define get_Cond_jmp_pred(node) get_Cond_jmp_pred_(node)
+#define set_Cond_jmp_pred(node, pred) set_Cond_jmp_pred_(node, pred)
+#define get_irn_generic_attr(node) get_irn_generic_attr_(node)
+#define get_irn_generic_attr_const(node) get_irn_generic_attr_const_(node)
+#define get_irn_idx(node) get_irn_idx_(node)
+
+#define get_irn_deps(node) get_irn_deps_(node)
+#define set_irn_dep(node, pos, dep) set_irn_dep_(node, pos, dep)
+#define get_irn_dep(node, pos) get_irn_dep_(node, pos)
+
+#define get_irn_ins_or_deps(node) get_irn_ins_or_deps_(node)
+#define get_irn_in_or_dep(node, pos) get_irn_in_or_dep_(node, pos)
+
+#define get_irn_dbg_info(node) get_irn_dbg_info_(node)
+#define set_irn_dbg_info(node, db) set_irn_dbg_info_(node, db)
+
+#define set_Block_phis(block, phi) set_Block_phis_(block, phi)
+#define get_Block_phis(block) get_Block_phis_(block)
+#define add_Block_phi(block, phi) add_Block_phi_(block, phi)
+#define get_Block_mark(block) get_Block_mark_(block)
+#define set_Block_mark(block, mark) set_Block_mark_(block, mark)
+
+#define set_Phi_next(node, phi) set_Phi_next_(node, phi)
+#define get_Phi_next(node) get_Phi_next_(node)
+
+#define is_arg_Proj(node) is_arg_Proj_(node)
#endif
unsigned (get_op_code)(const ir_op *op)
{
- return _get_op_code(op);
+ return get_op_code_(op);
}
ident *(get_op_ident)(const ir_op *op)
{
- return _get_op_ident(op);
+ return get_op_ident_(op);
}
const char *get_op_pin_state_name(op_pin_state s)
op_pin_state (get_op_pinned)(const ir_op *op)
{
- return _get_op_pinned(op);
+ return get_op_pinned_(op);
}
/* Sets op_pin_state_pinned in the opcode. Setting it to floating has no effect
/* Returns the generic function pointer from an ir operation. */
op_func (get_generic_function_ptr)(const ir_op *op)
{
- return _get_generic_function_ptr(op);
+ return get_generic_function_ptr_(op);
}
/* Store a generic function pointer into an ir operation. */
void (set_generic_function_ptr)(ir_op *op, op_func func)
{
- _set_generic_function_ptr(op, func);
+ set_generic_function_ptr_(op, func);
}
/* Returns the ir_op_ops of an ir_op. */
const ir_op_ops *(get_op_ops)(const ir_op *op)
{
- return _get_op_ops(op);
+ return get_op_ops_(op);
}
irop_flags get_op_flags(const ir_op *op)
return op->flags & (irop_flag_user << n);
}
-static inline unsigned _get_op_code(const ir_op *op)
+static inline unsigned get_op_code_(const ir_op *op)
{
return op->code;
}
-static inline ident *_get_op_ident(const ir_op *op)
+static inline ident *get_op_ident_(const ir_op *op)
{
return op->name;
}
-static inline op_pin_state _get_op_pinned(const ir_op *op)
+static inline op_pin_state get_op_pinned_(const ir_op *op)
{
return op->pin_state;
}
-static inline void _set_generic_function_ptr(ir_op *op, op_func func)
+static inline void set_generic_function_ptr_(ir_op *op, op_func func)
{
op->ops.generic = func;
}
-static inline op_func _get_generic_function_ptr(const ir_op *op)
+static inline op_func get_generic_function_ptr_(const ir_op *op)
{
return op->ops.generic;
}
-static inline const ir_op_ops *_get_op_ops(const ir_op *op)
+static inline const ir_op_ops *get_op_ops_(const ir_op *op)
{
return &op->ops;
}
-static inline void _set_op_tag(ir_op *op, unsigned tag)
+static inline void set_op_tag_(ir_op *op, unsigned tag)
{
op->tag = tag;
}
-static inline unsigned _get_op_tag(const ir_op *op)
+static inline unsigned get_op_tag_(const ir_op *op)
{
return op->tag;
}
-static inline void _set_op_attr(ir_op *op, void *attr)
+static inline void set_op_attr_(ir_op *op, void *attr)
{
op->attr = attr;
}
-static inline void *_get_op_attr(const ir_op *op)
+static inline void *get_op_attr_(const ir_op *op)
{
return op->attr;
}
-#define get_op_code(op) _get_op_code(op)
-#define get_op_ident(op) _get_op_ident(op)
-#define get_op_pinned(op) _get_op_pinned(op)
-#define get_op_ops(op) _get_op_ops(op)
-#define set_op_tag(op, tag) _set_op_tag((op), (tag))
-#define get_op_tag(op) _get_op_tag(op)
-#define set_op_attr(op, attr) _set_op_attr((op), (attr))
-#define get_op_attr(op) _get_op_attr(op)
+#define get_op_code(op) get_op_code_(op)
+#define get_op_ident(op) get_op_ident_(op)
+#define get_op_pinned(op) get_op_pinned_(op)
+#define get_op_ops(op) get_op_ops_(op)
+#define set_op_tag(op, tag) set_op_tag_((op), (tag))
+#define get_op_tag(op) get_op_tag_(op)
+#define set_op_attr(op, attr) set_op_attr_((op), (attr))
+#define get_op_attr(op) get_op_attr_(op)
#endif
ir_type *ptr_type = new_type_pointer(method_type);
ir_type *constructors = get_segment_type(IR_SEGMENT_CONSTRUCTORS);
- /* Mach-O does not like labels in the constructor segment, but with ELF
- * the linker dies horribly if there is no label. */
ident *ide = id_unique("constructor_ptr.%u");
ir_entity *ptr = new_entity(constructors, ide, ptr_type);
ir_graph *irg = get_const_code_irg();
ir_type *(get_segment_type)(ir_segment_t segment)
{
- return _get_segment_type(segment);
+ return get_segment_type_(segment);
}
void set_segment_type(ir_segment_t segment, ir_type *new_type)
ir_type *(get_glob_type)(void)
{
- return _get_glob_type();
+ return get_glob_type_();
}
ir_type *(get_tls_type)(void)
{
- return _get_tls_type();
+ return get_tls_type_();
}
/* Adds irg to the list of ir graphs in irp. */
size_t (get_irp_n_irgs)(void)
{
- return _get_irp_n_irgs();
+ return get_irp_n_irgs_();
}
ir_graph *(get_irp_irg)(size_t pos)
{
- return _get_irp_irg(pos);
+ return get_irp_irg_(pos);
}
size_t get_irp_last_idx(void)
size_t (get_irp_n_types) (void)
{
- return _get_irp_n_types();
+ return get_irp_n_types_();
}
ir_type *(get_irp_type) (size_t pos)
{
- return _get_irp_type(pos);
+ return get_irp_type_(pos);
}
void set_irp_type(size_t pos, ir_type *typ)
/* Returns the number of all modes in the irp. */
size_t (get_irp_n_modes)(void)
{
- return _get_irp_n_modes();
+ return get_irp_n_modes_();
}
/* Returns the mode at position pos in the irp. */
ir_mode *(get_irp_mode)(size_t pos)
{
- return _get_irp_mode(pos);
+ return get_irp_mode_(pos);
}
/* Adds mode to the list of modes in irp. */
/* Returns the number of all opcodes in the irp. */
size_t (get_irp_n_opcodes)(void)
{
- return _get_irp_n_opcodes();
+ return get_irp_n_opcodes_();
}
/* Returns the opcode at position pos in the irp. */
ir_op *(get_irp_opcode)(size_t pos)
{
- return _get_irp_opcode(pos);
+ return get_irp_opcode_(pos);
}
/* Sets the generic function pointer of all opcodes to NULL */
ir_graph *(get_const_code_irg)(void)
{
- return _get_const_code_irg();
+ return get_const_code_irg_();
}
irg_phase_state get_irp_phase_state(void)
/* Returns a new, unique exception region number. */
ir_exc_region_t (get_irp_next_region_nr)(void)
{
- return _get_irp_next_region_nr();
+ return get_irp_next_region_nr_();
}
/* Returns a new, unique label number. */
ir_label_t (get_irp_next_label_nr)(void)
{
- return _get_irp_next_label_nr();
+ return get_irp_next_label_nr_();
}
/* Add a new global asm include */
void add_irp_mode(ir_mode *mode);
/* inline functions */
-static inline ir_type *_get_segment_type(ir_segment_t segment)
+static inline ir_type *get_segment_type_(ir_segment_t segment)
{
assert(segment <= IR_SEGMENT_LAST);
return irp->segment_types[segment];
}
-static inline ir_type *_get_glob_type(void)
+static inline ir_type *get_glob_type_(void)
{
- return _get_segment_type(IR_SEGMENT_GLOBAL);
+ return get_segment_type_(IR_SEGMENT_GLOBAL);
}
-static inline ir_type *_get_tls_type(void)
+static inline ir_type *get_tls_type_(void)
{
- return _get_segment_type(IR_SEGMENT_THREAD_LOCAL);
+ return get_segment_type_(IR_SEGMENT_THREAD_LOCAL);
}
-static inline size_t _get_irp_n_irgs(void)
+static inline size_t get_irp_n_irgs_(void)
{
assert(irp && irp->graphs);
return ARR_LEN(irp->graphs);
}
-static inline ir_graph *_get_irp_irg(size_t pos)
+static inline ir_graph *get_irp_irg_(size_t pos)
{
assert(pos < ARR_LEN(irp->graphs));
return irp->graphs[pos];
}
-static inline size_t _get_irp_n_types(void)
+static inline size_t get_irp_n_types_(void)
{
assert(irp && irp->types);
return ARR_LEN(irp->types);
}
-static inline ir_type *_get_irp_type(size_t pos)
+static inline ir_type *get_irp_type_(size_t pos)
{
assert(irp->types);
assert(pos < ARR_LEN(irp->types));
return irp->types[pos];
}
-static inline size_t _get_irp_n_modes(void)
+static inline size_t get_irp_n_modes_(void)
{
assert(irp->modes);
return ARR_LEN(irp->modes);
}
-static inline ir_mode *_get_irp_mode(size_t pos)
+static inline ir_mode *get_irp_mode_(size_t pos)
{
assert(irp && irp->modes);
return irp->modes[pos];
}
-static inline size_t _get_irp_n_opcodes(void)
+static inline size_t get_irp_n_opcodes_(void)
{
assert(irp && irp->opcodes);
return ARR_LEN(irp->opcodes);
}
-static inline ir_op *_get_irp_opcode(size_t pos)
+static inline ir_op *get_irp_opcode_(size_t pos)
{
assert(irp && irp->opcodes);
return irp->opcodes[pos];
return irp->max_irg_idx++;
}
-static inline ir_graph *_get_const_code_irg(void)
+static inline ir_graph *get_const_code_irg_(void)
{
return irp->const_code_irg;
}
/** Returns a new, unique exception region number. */
-static inline ir_exc_region_t _get_irp_next_region_nr(void)
+static inline ir_exc_region_t get_irp_next_region_nr_(void)
{
assert(irp);
return ++irp->last_region_nr;
}
/** Returns a new, unique label number. */
-static inline ir_label_t _get_irp_next_label_nr(void)
+static inline ir_label_t get_irp_next_label_nr_(void)
{
assert(irp);
return ++irp->last_label_nr;
}
/** Whether optimizations should dump irgs */
-static inline int _get_irp_optimization_dumps(void)
+static inline int get_irp_optimization_dumps_(void)
{
assert(irp);
return irp->optimization_dumps;
}
/** Set optimizations to dump irgs */
-static inline void _enable_irp_optimization_dumps(void)
+static inline void enable_irp_optimization_dumps_(void)
{
assert(irp);
irp->optimization_dumps = 1;
}
-void set_irp_ip_outedges(ir_node ** ip_outedges);
-ir_node** get_irp_ip_outedges(void);
+void set_irp_ip_outedges(ir_node ** ip_outedges);
+ir_node** get_irp_ip_outedges(void);
/** initializes ir_prog. Constructs only the basic lists */
void init_irprog_1(void);
void init_irprog_2(void);
/* Inline functions. */
-#define get_irp_n_irgs() _get_irp_n_irgs()
-#define get_irp_irg(pos) _get_irp_irg(pos)
-#define get_irp_n_types() _get_irp_n_types()
-#define get_irp_type(pos) _get_irp_type(pos)
-#define get_irp_n_modes() _get_irp_n_modes()
-#define get_irp_mode(pos) _get_irp_mode(pos)
-#define get_irp_n_opcodes() _get_irp_n_opcodes()
-#define get_irp_opcode(pos) _get_irp_opcode(pos)
-#define get_const_code_irg() _get_const_code_irg()
-#define get_segment_type(s) _get_segment_type(s)
-#define get_glob_type() _get_glob_type()
-#define get_tls_type() _get_tls_type()
-#define get_irp_next_region_nr() _get_irp_next_region_nr()
-#define get_irp_next_label_nr() _get_irp_next_label_nr()
-#define get_irp_optimization_dumps() _get_irp_optimization_dumps()
-#define enable_irp_optimization_dumps() _enable_irp_optimization_dumps()
+#define get_irp_n_irgs() get_irp_n_irgs_()
+#define get_irp_irg(pos) get_irp_irg_(pos)
+#define get_irp_n_types() get_irp_n_types_()
+#define get_irp_type(pos) get_irp_type_(pos)
+#define get_irp_n_modes() get_irp_n_modes_()
+#define get_irp_mode(pos) get_irp_mode_(pos)
+#define get_irp_n_opcodes() get_irp_n_opcodes_()
+#define get_irp_opcode(pos) get_irp_opcode_(pos)
+#define get_const_code_irg() get_const_code_irg_()
+#define get_segment_type(s) get_segment_type_(s)
+#define get_glob_type() get_glob_type_()
+#define get_tls_type() get_tls_type_()
+#define get_irp_next_region_nr() get_irp_next_region_nr_()
+#define get_irp_next_label_nr() get_irp_next_label_nr_()
+#define get_irp_optimization_dumps() get_irp_optimization_dumps_()
+#define enable_irp_optimization_dumps() enable_irp_optimization_dumps_()
#endif
op = get_irn_op(n);
- if (_get_op_pinned(op) >= op_pin_state_exc_pinned) {
+ if (get_op_pinned(op) >= op_pin_state_exc_pinned) {
op_pin_state state = get_irn_pinned(n);
ASSERT_AND_RET_DBG(
state == op_pin_state_floats ||
'''/* Warning: automatically generated code */
{%- for node in nodes|isnot('custom_is') %}
-static inline int _is_{{node.name}}(const ir_node *node)
+static inline int is_{{node.name}}_(const ir_node *node)
{
assert(node != NULL);
- return _get_irn_op(node) == op_{{node.name}};
+ return get_irn_op_(node) == op_{{node.name}};
}
{%- endfor -%}
{% for node in nodes %}
-#define is_{{node.name}}(node) _is_{{node.name}}(node)
+#define is_{{node.name}}(node) is_{{node.name}}_(node)
{%- endfor %}
''')
{% for node in nodes %}
int (is_{{node.name}})(const ir_node *node)
{
- return _is_{{node.name}}(node);
+ return is_{{node.name}}_(node);
}
{% endfor %}
projects / libfirm / commitdiff