/** Size of pdeq block cache */
#define TUNE_NSAVED_PDEQS 16
-#ifndef INLINE
-#ifdef USE_GCC_INLINE
-#define INLINE inline
-#else
-#define INLINE
-#endif
-#endif
-
/* # of data items in block */
#define NDATA ((int)((PREF_MALLOC_SIZE - offsetof (pdeq, data)) / sizeof (void *)))
# include <config.h>
#endif
-#ifndef INLINE
-#ifdef USE_GCC_INLINE
-#define INLINE inline
-#else
-#define INLINE
-#endif
-#endif
-
/* bcopy is not ISO C *
#define bcopy(X, Y, Z) memcpy((Y), (X), (Z))
*/
int get_irn_n_outs (ir_node *node);
/** Get predecessor n */
-INLINE ir_node *get_irn_out (ir_node *node, int pos);
+ir_node *get_irn_out (ir_node *node, int pos);
/** Set predecessor n */
-INLINE void set_irn_out (ir_node *node, int pos, ir_node *out);
+void set_irn_out (ir_node *node, int pos, ir_node *out);
/* Methods to iterate through the control flow graph. Iterate from 0 to
i < get_Block_cfg_outs(block). No order of successors guaranteed. */
int get_Block_n_cfg_outs (ir_node *node);
/** Access predecessor n. */
-INLINE ir_node *get_Block_cfg_out (ir_node *node, int pos);
+ir_node *get_Block_cfg_out (ir_node *node, int pos);
#ifndef _IRG_WALK_FUNC_TYPEDEF_
#define _IRG_WALK_FUNC_TYPEDEF_
# ifndef _FIRM_COMMON_H_
# define _FIRM_COMMON_H_
-#ifndef INLINE
-#ifdef USE_GCC_INLINE
-#define INLINE inline
-#else
-#define INLINE
-#endif
-#endif
-
/** a list of firm kinds
@@@ not all datatypes are tagged yet. */
typedef enum {
#include "entity_t.h"
-INLINE void
+void
dbg_info_merge_pair(ir_node *nw, ir_node *old, dbg_action info) {
set_irn_dbg_info(nw, get_irn_dbg_info(old));
}
-INLINE void
+void
dbg_info_merge_sets(ir_node **new_nodes, int n_new_nodes,
ir_node **old_nodes, int n_old_nodes,
dbg_action info) {
}
-INLINE void
+void
set_irn_dbg_info(ir_node *n, struct dbg_info* db) {
n->dbi = db;
}
-INLINE struct dbg_info *
+struct dbg_info *
get_irn_dbg_info(ir_node *n) {
return n->dbi;
}
/* Routines to access the field of an entity containing the
debugging information. */
-INLINE void set_entity_dbg_info(entity *ent, dbg_info* db) {
+void set_entity_dbg_info(entity *ent, dbg_info* db) {
ent->dbi = db;
}
-INLINE dbg_info *get_entity_dbg_info(entity *ent) {
+dbg_info *get_entity_dbg_info(entity *ent) {
return ent->dbi;
}
/* Routines to access the field of a type containing the
debugging information. */
-INLINE void set_type_dbg_info(type *tp, dbg_info* db) {
+void set_type_dbg_info(type *tp, dbg_info* db) {
tp->dbi = db;
}
-INLINE dbg_info *get_type_dbg_info(type *tp) {
+dbg_info *get_type_dbg_info(type *tp) {
return tp->dbi;
}
/**
* Sets the debug information of a node.
*/
-INLINE void set_irn_dbg_info(ir_node *n, dbg_info* db);
+void set_irn_dbg_info(ir_node *n, dbg_info* db);
/**
* Returns the debug information of an node.
*/
-INLINE dbg_info *get_irn_dbg_info(ir_node *n);
+dbg_info *get_irn_dbg_info(ir_node *n);
/**
* Sets the debug information of an entity.
*/
-INLINE void set_entity_dbg_info(entity *ent, dbg_info* db);
+void set_entity_dbg_info(entity *ent, dbg_info* db);
/**
* Returns the debug information of an entity.
*/
-INLINE dbg_info *get_entity_dbg_info(entity *ent);
+dbg_info *get_entity_dbg_info(entity *ent);
/**
* Sets the debug information of a type.
*/
-INLINE void set_type_dbg_info(type *tp, dbg_info* db);
+void set_type_dbg_info(type *tp, dbg_info* db);
/**
* Returns the debug information of a type.
*/
-INLINE dbg_info *get_type_dbg_info(type *tp);
+dbg_info *get_type_dbg_info(type *tp);
/**
* An enumeration indicating the action performed by a transformation.
* Converts enum values to strings.
*/
#ifdef __GNUC__
-INLINE static const char* dbg_action_2_str(dbg_action) __attribute__ ((unused));
+static const char* dbg_action_2_str(dbg_action) __attribute__ ((unused));
#endif
-INLINE static const char* dbg_action_2_str(dbg_action a) {
+static const char* dbg_action_2_str(dbg_action a) {
switch(a) {
case dbg_error: return "dbg_error"; break;
case dbg_opt_ssa: return "dbg_opt_ssa"; break;
*
* @see new_get_id_str(), get_id_strlen()
*/
-INLINE ident *id_from_str (const char *str, int len);
+ident *id_from_str (const char *str, int len);
/**
* Returns a string represented by an ident.
*
* @see new_get_id_str(), id_from_str(), get_id_strlen()
*/
-INLINE const char *get_id_str (ident *id);
+const char *get_id_str (ident *id);
#define id_to_str get_id_str
/**
*
* @see new_get_id_str(), id_from_str(), get_id_str()
*/
-INLINE int get_id_strlen(ident *id);
+int get_id_strlen(ident *id);
#define id_to_strlen get_id_strlen
/**
* Returns true if prefix is a prefix of an ident.
{
libFIRM_opt = *state;
}
-
-/* repeat 'inline' methods here */
-
-# ifndef USE_GCC_INLINE
-
-/** Returns constant folding optimization setting. */
-int get_opt_cse(void) /* iropt.c */
-{
- return libFIRM_opt & OPT_CSE;
-}
-
-/** Returns constant subexpression elimination setting. */
-int get_opt_global_cse(void) /* irgopt.c iropt.c */
-{
- return libFIRM_opt & OPT_GLOBAL_CSE;
-}
-
-/** Returns global constant subexpression elimination setting. */
-int get_opt_constant_folding(void) /* iropt.c */
-{
- return libFIRM_opt & OPT_CONSTANT_FOLDING;
-}
-
-/** Returns unreachable code elimination setting. */
-int get_opt_unreachable_code(void) /* iropt.c */
-{
- return libFIRM_opt & OPT_UNREACHABLE_CODE;
-}
-
-/** Returns Straightening setting. */
-int get_opt_control_flow_straightening(void) /* iropt.c, irgopt.c */
-{
- return libFIRM_opt & OPT_CONTROL_FLOW_STRAIGHTENING;
-}
-
-/** Returns if simplifications in local optimizations setting. */
-int get_opt_control_flow_weak_simplification(void) /* iropt.c, irgopt.c */
-{
- return libFIRM_opt & OPT_CONTROL_FLOW_WEAK_SIMPLIFICATION;
-}
-
-/** Returns strong if and loop simplification setting */
-int get_opt_control_flow_strong_simplification(void) /* irgopt.c */
-{
- return libFIRM_opt & OPT_CONTROL_FLOW_STRONG_SIMPLIFICATION;
-}
-
-/** Returns whether critical edges are removed */
-int get_opt_critical_edges(void) /* irgopt.c */
-{
- return libFIRM_opt & OPT_CRITICAL_EDGES;
-}
-
-/** Returns reassociation setting. */
-int get_opt_reassociation(void) /* iropt.c */
-{
- return libFIRM_opt & OPT_REASSOCIATION;
-}
-
-/** Returns dead node elimination setting. */
-int get_opt_dead_node_elimination(void) /* irgopt.c */
-{
- return libFIRM_opt & OPT_DEAD_NODE_ELIMINATION;
-}
-
-/** Returns global optimization setting */
-int get_opt_optimize(void) /* iropt.c, irgopt.c */
-{
- return libFIRM_opt & OPT_OPTIMIZED;
-}
-
-/** Returns inlining setting. */ /* how appropriate */
-int get_opt_inline(void) /* irgopt.c */
-{
- return libFIRM_opt & OPT_INLINE;
-}
-
-int get_opt_dyn_meth_dispatch(void) /* cgana.c */
-{
- return libFIRM_opt & OPT_DYN_METH_DISPATCH;
-}
-
-int get_opt_normalize(void) /* irgopt.c, irnode.c, iropt.c */
-{
- return libFIRM_opt & OPT_NORMALIZE;
-}
-
-# endif /* not defined USE_GCC_INLINE */
int get_irg_n_locs (ir_graph *irg);
-INLINE long get_irg_graph_nr(ir_graph *irg);
+long get_irg_graph_nr(ir_graph *irg);
/********************************************************************************/
/* States of an ir_graph. */
#define RETURN_RESULT_OFFSET 1 /* mem is not a result */
#define END_KEEPALIVE_OFFSET 0
-/* Declarations for inlineing */
-INLINE ir_node ** get_irn_in (const ir_node *node);
-INLINE ir_mode *get_irn_mode (const ir_node *node);
-INLINE ir_op *get_irn_op (const ir_node *node);
-INLINE opcode get_irn_opcode (const ir_node *node);
-INLINE ident *get_irn_opident (const ir_node *node);
-INLINE type *get_SymConst_type (ir_node *node);
-INLINE ir_node *skip_nop (ir_node *node);
-INLINE int is_Proj (const ir_node *node);
-
-
static const char *pnc_name_arr [] = {
"False", "Eq", "Lt", "Le",
"Gt", "Ge", "Lg", "Leg", "Uo",
/**
* returns the pnc name from an pnc constant
*/
-INLINE const char *get_pnc_string(int pnc) {
+const char *get_pnc_string(int pnc) {
return pnc_name_arr[pnc];
}
* some incoming irnodes.
* If arity is negative, a node with a dynamic array is created.
*/
-INLINE ir_node *
+ir_node *
new_ir_node (dbg_info *db, ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode,
int arity, ir_node **in)
{
return 0;
}
-INLINE int
+int
get_irn_intra_arity (const ir_node *node) {
return intern_get_irn_intra_arity(node);
}
-INLINE int
+int
get_irn_inter_arity (const ir_node *node) {
return intern_get_irn_inter_arity(node);
}
-INLINE int
+int
get_irn_arity (const ir_node *node) {
return intern_get_irn_arity(node);
}
The order of the predecessors in this array is not guaranteed, except that
lists of operands as predecessors of Block or arguments of a Call are
consecutive. */
-INLINE ir_node **
+ir_node **
get_irn_in (const ir_node *node) {
assert(node);
if (interprocedural_view) { /* handle Filter and Block specially */
return node->in;
}
-INLINE void
+void
set_irn_in (ir_node *node, int arity, ir_node **in) {
ir_node *** arr;
assert(node);
memcpy((*arr) + 1, in, sizeof(ir_node *) * arity);
}
-INLINE ir_node *
+ir_node *
get_irn_intra_n (ir_node *node, int n) {
return intern_get_irn_intra_n (node, n);
}
-INLINE ir_node *
+ir_node *
get_irn_inter_n (ir_node *node, int n) {
return intern_get_irn_inter_n (node, n);
}
-INLINE ir_node *
+ir_node *
get_irn_n (ir_node *node, int n) {
return intern_get_irn_n (node, n);
}
-INLINE void
+void
set_irn_n (ir_node *node, int n, ir_node *in) {
assert(node && -1 <= n && n < get_irn_arity(node));
if ((n == -1) && (get_irn_opcode(node) == iro_Filter)) {
node->in[n + 1] = in;
}
-INLINE ir_mode *
+ir_mode *
get_irn_mode (const ir_node *node) {
return intern_get_irn_mode(node);
}
-INLINE void
+void
set_irn_mode (ir_node *node, ir_mode *mode)
{
assert (node);
return;
}
-INLINE modecode
+modecode
get_irn_modecode (const ir_node *node)
{
assert (node);
}
/** Gets the string representation of the mode .*/
-INLINE const char *
+const char *
get_irn_modename (const ir_node *node)
{
assert(node);
return get_mode_name(node->mode);
}
-INLINE ident *
+ident *
get_irn_modeident (const ir_node *node)
{
assert(node);
return get_mode_ident(node->mode);
}
-INLINE ir_op *
+ir_op *
get_irn_op (const ir_node *node)
{
return intern_get_irn_op(node);
}
/* should be private to the library: */
-INLINE void
+void
set_irn_op (ir_node *node, ir_op *op)
{
assert (node);
node->op = op;
}
-INLINE opcode
+opcode
get_irn_opcode (const ir_node *node)
{
return intern_get_irn_opcode(node);
}
-INLINE const char *
+const char *
get_irn_opname (const ir_node *node)
{
assert(node);
return get_id_str(node->op->name);
}
-INLINE ident *
+ident *
get_irn_opident (const ir_node *node)
{
assert(node);
return node->op->name;
}
-INLINE unsigned long
+unsigned long
get_irn_visited (const ir_node *node)
{
assert (node);
return node->visited;
}
-INLINE void
+void
set_irn_visited (ir_node *node, unsigned long visited)
{
assert (node);
node->visited = visited;
}
-INLINE void
+void
mark_irn_visited (ir_node *node) {
assert (node);
node->visited = current_ir_graph->visited;
}
-INLINE int
+int
irn_not_visited (const ir_node *node) {
assert (node);
return (node->visited < current_ir_graph->visited);
}
-INLINE int
+int
irn_visited (const ir_node *node) {
assert (node);
return (node->visited >= current_ir_graph->visited);
}
-INLINE void
+void
set_irn_link (ir_node *node, void *link) {
assert (node);
/* Link field is used for Phi construction and various optimizations
node->link = link;
}
-INLINE void *
+void *
get_irn_link (const ir_node *node) {
assert (node);
return node->link;
}
/* Outputs a unique number for this node */
-INLINE long
+long
get_irn_node_nr(const ir_node *node) {
assert(node);
#ifdef DEBUG_libfirm
#endif
}
-INLINE const_attr
+const_attr
get_irn_const_attr (ir_node *node)
{
assert (node->op == op_Const);
return node->attr.con;
}
-INLINE long
+long
get_irn_proj_attr (ir_node *node)
{
assert (node->op == op_Proj);
return node->attr.proj;
}
-INLINE alloc_attr
+alloc_attr
get_irn_alloc_attr (ir_node *node)
{
assert (node->op == op_Alloc);
return node->attr.a;
}
-INLINE type *
+type *
get_irn_free_attr (ir_node *node)
{
assert (node->op == op_Free);
return node->attr.f = skip_tid(node->attr.f);
}
-INLINE symconst_attr
+symconst_attr
get_irn_symconst_attr (ir_node *node)
{
assert (node->op == op_SymConst);
return node->attr.i;
}
-INLINE type *
+type *
get_irn_call_attr (ir_node *node)
{
assert (node->op == op_Call);
return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
}
-INLINE type *
+type *
get_irn_funccall_attr (ir_node *node)
{
assert (node->op == op_FuncCall);
return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
}
-INLINE sel_attr
+sel_attr
get_irn_sel_attr (ir_node *node)
{
assert (node->op == op_Sel);
return node->attr.s;
}
-INLINE int
+int
get_irn_phi_attr (ir_node *node)
{
assert (node->op == op_Phi);
return node->attr.phi0_pos;
}
-INLINE block_attr
+block_attr
get_irn_block_attr (ir_node *node)
{
assert (node->op == op_Block);
return get_irn_n(node, -1);
}
-INLINE void
+void
set_nodes_Block (ir_node *node, ir_node *block) {
assert (!(node->op == op_Block));
set_irn_n(node, -1, block);
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. */
-INLINE ir_node **
+ir_node **
get_Block_cfgpred_arr (ir_node *node)
{
assert ((node->op == op_Block));
}
-INLINE int
+int
get_Block_n_cfgpreds (ir_node *node) {
assert ((node->op == op_Block));
return (get_irn_arity(node));
}
-INLINE ir_node *
+ir_node *
get_Block_cfgpred (ir_node *node, int pos) {
assert (node->op == op_Block);
/* debug @@@
return get_irn_n(node, pos);
}
-INLINE void
+void
set_Block_cfgpred (ir_node *node, int pos, ir_node *pred) {
assert (node->op == op_Block);
set_irn_n(node, pos, pred);
}
-INLINE bool
+bool
get_Block_matured (ir_node *node) {
assert (node->op == op_Block);
return node->attr.block.matured;
}
-INLINE void
+void
set_Block_matured (ir_node *node, bool matured) {
assert (node->op == op_Block);
node->attr.block.matured = matured;
}
-INLINE unsigned long
+unsigned long
get_Block_block_visited (ir_node *node) {
assert (node->op == op_Block);
return node->attr.block.block_visited;
}
-INLINE void
+void
set_Block_block_visited (ir_node *node, unsigned long visit) {
assert (node->op == op_Block);
node->attr.block.block_visited = visit;
}
/* For this current_ir_graph must be set. */
-INLINE void
+void
mark_Block_block_visited (ir_node *node) {
assert (node->op == op_Block);
node->attr.block.block_visited = get_irg_block_visited(current_ir_graph);
}
-INLINE int
+int
Block_not_block_visited(ir_node *node) {
assert (node->op == op_Block);
return (node->attr.block.block_visited < get_irg_block_visited(current_ir_graph));
}
-INLINE ir_node *
+ir_node *
get_Block_graph_arr (ir_node *node, int pos) {
assert (node->op == op_Block);
return node->attr.block.graph_arr[pos+1];
}
-INLINE void
+void
set_Block_graph_arr (ir_node *node, int pos, ir_node *value) {
assert (node->op == op_Block);
node->attr.block.graph_arr[pos+1] = value;
}
/* Start references the irg it is in. */
-INLINE ir_graph *
+ir_graph *
get_Start_irg(ir_node *node) {
return get_irn_irg(node);
}
-INLINE void
+void
set_Start_irg(ir_node *node, ir_graph *irg) {
assert(node->op == op_Start);
assert(is_ir_graph(irg));
assert(0 && " Why set irg? -- use set_irn_irg");
}
-INLINE int
+int
get_End_n_keepalives(ir_node *end) {
assert (end->op == op_End);
return (get_irn_arity(end) - END_KEEPALIVE_OFFSET);
}
-INLINE ir_node *
+ir_node *
get_End_keepalive(ir_node *end, int pos) {
assert (end->op == op_End);
return get_irn_n(end, pos + END_KEEPALIVE_OFFSET);
}
-INLINE void
+void
add_End_keepalive (ir_node *end, ir_node *ka) {
assert (end->op == op_End);
ARR_APP1 (ir_node *, end->in, ka);
}
-INLINE void
+void
set_End_keepalive(ir_node *end, int pos, ir_node *ka) {
assert (end->op == op_End);
set_irn_n(end, pos + END_KEEPALIVE_OFFSET, ka);
}
-INLINE void
+void
free_End (ir_node *end) {
assert (end->op == op_End);
end->kind = k_BAD;
dataflow analysis and 3) does not allow to convert the representation to
2a).
*/
-INLINE ir_node *
+ir_node *
get_Cond_selector (ir_node *node) {
assert (node->op == op_Cond);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Cond_selector (ir_node *node, ir_node *selector) {
assert (node->op == op_Cond);
set_irn_n(node, 0, selector);
}
-INLINE cond_kind
+cond_kind
get_Cond_kind (ir_node *node) {
assert (node->op == op_Cond);
return node->attr.c.kind;
}
-INLINE void
+void
set_Cond_kind (ir_node *node, cond_kind kind) {
assert (node->op == op_Cond);
node->attr.c.kind = kind;
}
-INLINE ir_node *
+ir_node *
get_Return_mem (ir_node *node) {
assert (node->op == op_Return);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Return_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Return);
set_irn_n(node, 0, mem);
}
-INLINE int
+int
get_Return_n_ress (ir_node *node) {
assert (node->op == op_Return);
return (get_irn_arity(node) - RETURN_RESULT_OFFSET);
}
-INLINE ir_node **
+ir_node **
get_Return_res_arr (ir_node *node)
{
assert ((node->op == op_Return));
}
/*
-INLINE void
+void
set_Return_n_res (ir_node *node, int results) {
assert (node->op == op_Return);
}
*/
-INLINE ir_node *
+ir_node *
get_Return_res (ir_node *node, int pos) {
assert (node->op == op_Return);
assert (get_Return_n_ress(node) > pos);
return get_irn_n(node, pos + RETURN_RESULT_OFFSET);
}
-INLINE void
+void
set_Return_res (ir_node *node, int pos, ir_node *res){
assert (node->op == op_Return);
set_irn_n(node, pos + RETURN_RESULT_OFFSET, res);
}
-INLINE ir_node *
+ir_node *
get_Raise_mem (ir_node *node) {
assert (node->op == op_Raise);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Raise_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Raise);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Raise_exo_ptr (ir_node *node) {
assert (node->op == op_Raise);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Raise_exo_ptr (ir_node *node, ir_node *exo_ptr) {
assert (node->op == op_Raise);
set_irn_n(node, 1, exo_ptr);
}
-INLINE tarval *get_Const_tarval (ir_node *node) {
+tarval *get_Const_tarval (ir_node *node) {
assert (node->op == op_Const);
return node->attr.con.tv;
}
-INLINE void
+void
set_Const_tarval (ir_node *node, tarval *con) {
assert (node->op == op_Const);
node->attr.con.tv = con;
/* The source language type. Must be an atomic type. Mode of type must
be mode of node. For tarvals from entities type must be pointer to
entity type. */
-INLINE type *
+type *
get_Const_type (ir_node *node) {
assert (node->op == op_Const);
return node->attr.con.tp;
}
-INLINE void
+void
set_Const_type (ir_node *node, type *tp) {
assert (node->op == op_Const);
if (tp != unknown_type) {
}
-INLINE symconst_kind
+symconst_kind
get_SymConst_kind (const ir_node *node) {
assert (node->op == op_SymConst);
return node->attr.i.num;
}
-INLINE void
+void
set_SymConst_kind (ir_node *node, symconst_kind num) {
assert (node->op == op_SymConst);
node->attr.i.num = num;
}
-INLINE type *
+type *
get_SymConst_type (ir_node *node) {
assert ( (node->op == op_SymConst)
&& ( get_SymConst_kind(node) == type_tag
return node->attr.i.tori.typ = skip_tid(node->attr.i.tori.typ);
}
-INLINE void
+void
set_SymConst_type (ir_node *node, type *tp) {
assert ( (node->op == op_SymConst)
&& ( get_SymConst_kind(node) == type_tag
node->attr.i.tori.typ = tp;
}
-INLINE ident *
+ident *
get_SymConst_ptrinfo (ir_node *node) {
assert ( (node->op == op_SymConst)
&& (get_SymConst_kind(node) == linkage_ptr_info));
return node->attr.i.tori.ptrinfo;
}
-INLINE void
+void
set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo) {
assert ( (node->op == op_SymConst)
&& (get_SymConst_kind(node) == linkage_ptr_info));
node->attr.i.tori.ptrinfo = ptrinfo;
}
-INLINE type_or_id_p
+type_or_id_p
get_SymConst_type_or_id (ir_node *node) {
assert (node->op == op_SymConst);
return &(node->attr.i.tori);
}
-INLINE void
+void
set_SymConst_type_or_id (ir_node *node, type_or_id_p tori) {
assert (node->op == op_SymConst);
memcpy (&(node->attr.i.tori), tori, sizeof(type_or_id));
}
-INLINE ir_node *
+ir_node *
get_Sel_mem (ir_node *node) {
assert (node->op == op_Sel);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Sel_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Sel);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Sel_ptr (ir_node *node) {
assert (node->op == op_Sel);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Sel_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Sel);
set_irn_n(node, 1, ptr);
}
-INLINE int
+int
get_Sel_n_indexs (ir_node *node) {
assert (node->op == op_Sel);
return (get_irn_arity(node) - SEL_INDEX_OFFSET);
}
-INLINE ir_node **
+ir_node **
get_Sel_index_arr (ir_node *node)
{
assert ((node->op == op_Sel));
return NULL;
}
-INLINE ir_node *
+ir_node *
get_Sel_index (ir_node *node, int pos) {
assert (node->op == op_Sel);
return get_irn_n(node, pos + SEL_INDEX_OFFSET);
}
-INLINE void
+void
set_Sel_index (ir_node *node, int pos, ir_node *index) {
assert (node->op == op_Sel);
set_irn_n(node, pos + SEL_INDEX_OFFSET, index);
}
-INLINE entity *
+entity *
get_Sel_entity (ir_node *node) {
assert (node->op == op_Sel);
return node->attr.s.ent;
}
-INLINE void
+void
set_Sel_entity (ir_node *node, entity *ent) {
assert (node->op == op_Sel);
node->attr.s.ent = ent;
Shr, Shrs, Rotate, Cmp */
-INLINE ir_node *
+ir_node *
get_Call_mem (ir_node *node) {
assert (node->op == op_Call);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Call_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Call);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Call_ptr (ir_node *node) {
assert (node->op == op_Call);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Call_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Call);
set_irn_n(node, 1, ptr);
}
-INLINE ir_node **
+ir_node **
get_Call_param_arr (ir_node *node) {
assert (node->op == op_Call);
return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET + 1];
}
-INLINE int
+int
get_Call_n_params (ir_node *node) {
assert (node->op == op_Call);
return (get_irn_arity(node) - CALL_PARAM_OFFSET);
}
-INLINE int
+int
get_Call_arity (ir_node *node) {
assert (node->op == op_Call);
return get_Call_n_params(node);
}
-/* INLINE void
+/* void
set_Call_arity (ir_node *node, ir_node *arity) {
assert (node->op == op_Call);
}
*/
-INLINE ir_node *
+ir_node *
get_Call_param (ir_node *node, int pos) {
assert (node->op == op_Call);
return get_irn_n(node, pos + CALL_PARAM_OFFSET);
}
-INLINE void
+void
set_Call_param (ir_node *node, int pos, ir_node *param) {
assert (node->op == op_Call);
set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
}
-INLINE type *
+type *
get_Call_type (ir_node *node) {
assert (node->op == op_Call);
return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
}
-INLINE void
+void
set_Call_type (ir_node *node, type *tp) {
assert (node->op == op_Call);
assert (is_method_type(tp));
node->attr.callbegin.call = call;
}
-INLINE ir_node *
+ir_node *
get_FuncCall_ptr (ir_node *node) {
assert (node->op == op_FuncCall);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_FuncCall_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_FuncCall);
set_irn_n(node, 0, ptr);
}
-INLINE ir_node **
+ir_node **
get_FuncCall_param_arr (ir_node *node) {
assert (node->op == op_FuncCall);
return (ir_node **)&get_irn_in(node)[CALL_PARAM_OFFSET];
}
-INLINE int
+int
get_FuncCall_n_params (ir_node *node) {
assert (node->op == op_FuncCall);
return (get_irn_arity(node) - CALL_PARAM_OFFSET);
}
-INLINE int
+int
get_FuncCall_arity (ir_node *node) {
assert (node->op == op_FuncCall);
return get_FuncCall_n_params(node);
}
-/* INLINE void
+/* void
set_FuncCall_arity (ir_node *node, ir_node *arity) {
assert (node->op == op_FuncCall);
}
*/
-INLINE ir_node *
+ir_node *
get_FuncCall_param (ir_node *node, int pos) {
assert (node->op == op_FuncCall);
return get_irn_n(node, pos + CALL_PARAM_OFFSET);
}
-INLINE void
+void
set_FuncCall_param (ir_node *node, int pos, ir_node *param) {
assert (node->op == op_FuncCall);
set_irn_n(node, pos + CALL_PARAM_OFFSET, param);
}
-INLINE type *
+type *
get_FuncCall_type (ir_node *node) {
assert (node->op == op_FuncCall);
return node->attr.call.cld_tp = skip_tid(node->attr.call.cld_tp);
}
-INLINE void
+void
set_FuncCall_type (ir_node *node, type *tp) {
assert (node->op == op_FuncCall);
assert (is_method_type(tp));
BINOP(Mul)
BINOP(Quot)
-INLINE ir_node *
+ir_node *
get_Quot_mem (ir_node *node) {
assert (node->op == op_Quot);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Quot_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Quot);
set_irn_n(node, 0, mem);
BINOP(DivMod)
-INLINE ir_node *
+ir_node *
get_DivMod_mem (ir_node *node) {
assert (node->op == op_DivMod);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_DivMod_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_DivMod);
set_irn_n(node, 0, mem);
BINOP(Div)
-INLINE ir_node *
+ir_node *
get_Div_mem (ir_node *node) {
assert (node->op == op_Div);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Div_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Div);
set_irn_n(node, 0, mem);
BINOP(Mod)
-INLINE ir_node *
+ir_node *
get_Mod_mem (ir_node *node) {
assert (node->op == op_Mod);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Mod_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Mod);
set_irn_n(node, 0, mem);
UNOP(Conv)
UNOP(Cast)
-INLINE type *
+type *
get_Cast_type (ir_node *node) {
assert (node->op == op_Cast);
return node->attr.cast.totype;
}
-INLINE void
+void
set_Cast_type (ir_node *node, type *to_tp) {
assert (node->op == op_Cast);
node->attr.cast.totype = to_tp;
}
-INLINE int
+int
is_unop (ir_node *node) {
return (node->op->opar == oparity_unary);
}
-INLINE ir_node *
+ir_node *
get_unop_op (ir_node *node) {
if (node->op->opar == oparity_unary)
return get_irn_n(node, node->op->op_index);
return NULL;
}
-INLINE void
+void
set_unop_op (ir_node *node, ir_node *op) {
if (node->op->opar == oparity_unary)
set_irn_n(node, node->op->op_index, op);
return (node->op->opar == oparity_binary);
}
-INLINE ir_node *
+ir_node *
get_binop_left (ir_node *node) {
if (node->op->opar == oparity_binary)
return get_irn_n(node, node->op->op_index);
return NULL;
}
-INLINE void
+void
set_binop_left (ir_node *node, ir_node *left) {
if (node->op->opar == oparity_binary)
set_irn_n(node, node->op->op_index, left);
assert (node->op->opar == oparity_binary);
}
-INLINE ir_node *
+ir_node *
get_binop_right (ir_node *node) {
if (node->op->opar == oparity_binary)
return get_irn_n(node, node->op->op_index + 1);
return NULL;
}
-INLINE void
+void
set_binop_right (ir_node *node, ir_node *right) {
if (node->op->opar == oparity_binary)
set_irn_n(node, node->op->op_index + 1, right);
assert (node->op->opar == oparity_binary);
}
-INLINE int is_Phi (ir_node *n) {
+int is_Phi (ir_node *n) {
ir_op *op;
assert(n);
return (op == op_Phi) || (op == op_Filter && interprocedural_view);
}
-INLINE ir_node **
+ir_node **
get_Phi_preds_arr (ir_node *node) {
assert (node->op == op_Phi);
return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE int
+int
get_Phi_n_preds (ir_node *node) {
assert (is_Phi(node));
return (get_irn_arity(node));
}
/*
-INLINE void set_Phi_n_preds (ir_node *node, int n_preds) {
+void set_Phi_n_preds (ir_node *node, int n_preds) {
assert (node->op == op_Phi);
}
*/
-INLINE ir_node *
+ir_node *
get_Phi_pred (ir_node *node, int pos) {
assert (is_Phi(node));
return get_irn_n(node, pos);
}
-INLINE void
+void
set_Phi_pred (ir_node *node, int pos, ir_node *pred) {
assert (is_Phi(node));
set_irn_n(node, pos, pred);
}
-INLINE ir_node *
+ir_node *
get_Load_mem (ir_node *node) {
assert (node->op == op_Load);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Load_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Load);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Load_ptr (ir_node *node) {
assert (node->op == op_Load);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Load_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Load);
set_irn_n(node, 1, ptr);
}
-INLINE
+
ir_node *
get_Store_mem (ir_node *node) {
assert (node->op == op_Store);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Store_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Store);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Store_ptr (ir_node *node) {
assert (node->op == op_Store);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Store_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Store);
set_irn_n(node, 1, ptr);
}
-INLINE ir_node *
+ir_node *
get_Store_value (ir_node *node) {
assert (node->op == op_Store);
return get_irn_n(node, 2);
}
-INLINE void
+void
set_Store_value (ir_node *node, ir_node *value) {
assert (node->op == op_Store);
set_irn_n(node, 2, value);
}
-INLINE ir_node *
+ir_node *
get_Alloc_mem (ir_node *node) {
assert (node->op == op_Alloc);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Alloc_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Alloc);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Alloc_size (ir_node *node) {
assert (node->op == op_Alloc);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Alloc_size (ir_node *node, ir_node *size) {
assert (node->op == op_Alloc);
set_irn_n(node, 1, size);
}
-INLINE type *
+type *
get_Alloc_type (ir_node *node) {
assert (node->op == op_Alloc);
return node->attr.a.type = skip_tid(node->attr.a.type);
}
-INLINE void
+void
set_Alloc_type (ir_node *node, type *tp) {
assert (node->op == op_Alloc);
node->attr.a.type = tp;
}
-INLINE where_alloc
+where_alloc
get_Alloc_where (ir_node *node) {
assert (node->op == op_Alloc);
return node->attr.a.where;
}
-INLINE void
+void
set_Alloc_where (ir_node *node, where_alloc where) {
assert (node->op == op_Alloc);
node->attr.a.where = where;
}
-INLINE ir_node *
+ir_node *
get_Free_mem (ir_node *node) {
assert (node->op == op_Free);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Free_mem (ir_node *node, ir_node *mem) {
assert (node->op == op_Free);
set_irn_n(node, 0, mem);
}
-INLINE ir_node *
+ir_node *
get_Free_ptr (ir_node *node) {
assert (node->op == op_Free);
return get_irn_n(node, 1);
}
-INLINE void
+void
set_Free_ptr (ir_node *node, ir_node *ptr) {
assert (node->op == op_Free);
set_irn_n(node, 1, ptr);
}
-INLINE ir_node *
+ir_node *
get_Free_size (ir_node *node) {
assert (node->op == op_Free);
return get_irn_n(node, 2);
}
-INLINE void
+void
set_Free_size (ir_node *node, ir_node *size) {
assert (node->op == op_Free);
set_irn_n(node, 2, size);
}
-INLINE type *
+type *
get_Free_type (ir_node *node) {
assert (node->op == op_Free);
return node->attr.f = skip_tid(node->attr.f);
}
-INLINE void
+void
set_Free_type (ir_node *node, type *tp) {
assert (node->op == op_Free);
node->attr.f = tp;
}
-INLINE ir_node **
+ir_node **
get_Sync_preds_arr (ir_node *node) {
assert (node->op == op_Sync);
return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE int
+int
get_Sync_n_preds (ir_node *node) {
assert (node->op == op_Sync);
return (get_irn_arity(node));
}
/*
-INLINE void
+void
set_Sync_n_preds (ir_node *node, int n_preds) {
assert (node->op == op_Sync);
}
*/
-INLINE ir_node *
+ir_node *
get_Sync_pred (ir_node *node, int pos) {
assert (node->op == op_Sync);
return get_irn_n(node, pos);
}
-INLINE void
+void
set_Sync_pred (ir_node *node, int pos, ir_node *pred) {
assert (node->op == op_Sync);
set_irn_n(node, pos, pred);
}
-INLINE ir_node *
+ir_node *
get_Proj_pred (ir_node *node) {
assert (is_Proj(node));
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Proj_pred (ir_node *node, ir_node *pred) {
assert (is_Proj(node));
set_irn_n(node, 0, pred);
}
-INLINE long
+long
get_Proj_proj (ir_node *node) {
assert (is_Proj(node));
if (get_irn_opcode(node) == iro_Proj) {
}
}
-INLINE void
+void
set_Proj_proj (ir_node *node, long proj) {
assert (node->op == op_Proj);
node->attr.proj = proj;
}
-INLINE ir_node **
+ir_node **
get_Tuple_preds_arr (ir_node *node) {
assert (node->op == op_Tuple);
return (ir_node **)&(get_irn_in(node)[1]);
}
-INLINE int
+int
get_Tuple_n_preds (ir_node *node) {
assert (node->op == op_Tuple);
return (get_irn_arity(node));
}
/*
-INLINE void
+void
set_Tuple_n_preds (ir_node *node, int n_preds) {
assert (node->op == op_Tuple);
}
*/
-INLINE ir_node *
+ir_node *
get_Tuple_pred (ir_node *node, int pos) {
assert (node->op == op_Tuple);
return get_irn_n(node, pos);
}
-INLINE void
+void
set_Tuple_pred (ir_node *node, int pos, ir_node *pred) {
assert (node->op == op_Tuple);
set_irn_n(node, pos, pred);
}
-INLINE ir_node *
+ir_node *
get_Id_pred (ir_node *node) {
assert (node->op == op_Id);
return get_irn_n(node, 0);
}
-INLINE void
+void
set_Id_pred (ir_node *node, ir_node *pred) {
assert (node->op == op_Id);
set_irn_n(node, 0, pred);
}
-INLINE ir_node *get_Confirm_value (ir_node *node) {
+ir_node *get_Confirm_value (ir_node *node) {
assert (node->op == op_Confirm);
return get_irn_n(node, 0);
}
-INLINE void set_Confirm_value (ir_node *node, ir_node *value) {
+void set_Confirm_value (ir_node *node, ir_node *value) {
assert (node->op == op_Confirm);
set_irn_n(node, 0, value);
}
-INLINE ir_node *get_Confirm_bound (ir_node *node) {
+ir_node *get_Confirm_bound (ir_node *node) {
assert (node->op == op_Confirm);
return get_irn_n(node, 1);
}
-INLINE void set_Confirm_bound (ir_node *node, ir_node *bound) {
+void set_Confirm_bound (ir_node *node, ir_node *bound) {
assert (node->op == op_Confirm);
set_irn_n(node, 0, bound);
}
-INLINE pn_Cmp get_Confirm_cmp (ir_node *node) {
+pn_Cmp get_Confirm_cmp (ir_node *node) {
assert (node->op == op_Confirm);
return node->attr.confirm_cmp;
}
-INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
+void set_Confirm_cmp (ir_node *node, pn_Cmp cmp) {
assert (node->op == op_Confirm);
node->attr.confirm_cmp = cmp;
}
-INLINE ir_node *
+ir_node *
get_Filter_pred (ir_node *node) {
assert(node->op == op_Filter);
return node->in[1];
}
-INLINE void
+void
set_Filter_pred (ir_node *node, ir_node *pred) {
assert(node->op == op_Filter);
node->in[1] = pred;
}
-INLINE long
+long
get_Filter_proj(ir_node *node) {
assert(node->op == op_Filter);
return node->attr.filter.proj;
}
-INLINE void
+void
set_Filter_proj (ir_node *node, long proj) {
assert(node->op == op_Filter);
node->attr.filter.proj = proj;
}
-INLINE ir_graph *
+ir_graph *
get_irn_irg(ir_node *node) {
if (get_irn_op(node) != op_Block)
node = get_nodes_block(node);
/* Auxiliary routines */
/*----------------------------------------------------------------*/
-INLINE ir_node *
+ir_node *
skip_Proj (ir_node *node) {
/* don't assert node !!! */
if (node && is_Proj(node)) {
}
}
-INLINE ir_node *
+ir_node *
skip_Tuple (ir_node *node) {
ir_node *pred;
/* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
than any other approach, as Id chains are resolved and all point to the real node, or
all id's are self loops. */
-INLINE ir_node *
+ir_node *
skip_nop (ir_node *node) {
/* don't assert node !!! */
/* This should compact Id-cycles to self-cycles. It has the same (or less?) complexity
than any other approach, as Id chains are resolved and all point to the real node, or
all id's are self loops. */
-INLINE ir_node *
+ir_node *
skip_nop (ir_node *node) {
ir_node *pred;
/* don't assert node !!! */
}
#endif
-INLINE ir_node *
+ir_node *
skip_Id (ir_node *node) {
return skip_nop(node);
}
-INLINE int
+int
is_Bad (ir_node *node) {
assert(node);
if ((node) && get_irn_opcode(node) == iro_Bad)
return 0;
}
-INLINE int
+int
is_no_Block (ir_node *node) {
assert(node);
return (get_irn_opcode(node) != iro_Block);
}
-INLINE int
+int
is_Block (ir_node *node) {
assert(node);
return (get_irn_opcode(node) == iro_Block);
}
/* returns true if node is a Unknown node. */
-INLINE int
+int
is_Unknown (ir_node *node) {
assert(node);
return (get_irn_opcode(node) == iro_Unknown);
}
-INLINE int
+int
is_Proj (const ir_node *node) {
assert(node);
return node->op == op_Proj
/* Returns true if the operation manipulates interprocedural control flow:
CallBegin, EndReg, EndExcept */
-INLINE int is_ip_cfop(ir_node *node) {
+int is_ip_cfop(ir_node *node) {
return is_ip_cfopcode(get_irn_op(node));
}
/** returns the number of predecessors without the block predecessor: */
int get_irn_arity (const ir_node *node);
-INLINE int get_irn_intra_arity (const ir_node *node);
-INLINE int get_irn_inter_arity (const ir_node *node);
+int get_irn_intra_arity (const ir_node *node);
+int get_irn_inter_arity (const ir_node *node);
/** Replaces the old in array by a new one that will contain the ins given in
the parameters. Conserves the block predecessor. It copies the array passed.
Assumes that current_ir_graph is set to the graph containing "node".
"in" must contain all predecessors except the block that are required for
the nodes opcode. */
-INLINE void set_irn_in (ir_node *node, int arity,
+void set_irn_in (ir_node *node, int arity,
ir_node *in[]);
/* to iterate through the predecessors without touching the array. No
order of predecessors guaranteed.
i < get_irn_arity. */
/* Access predecessor n */
/* get_irn_n removes Id predecessors. */
-INLINE ir_node *get_irn_n (ir_node *node, int n);
-INLINE ir_node *get_irn_intra_n (ir_node *node, int n);
-INLINE ir_node *get_irn_inter_n (ir_node *node, int n);
-INLINE void set_irn_n (ir_node *node, int n, ir_node *in);
+ir_node *get_irn_n (ir_node *node, int n);
+ir_node *get_irn_intra_n (ir_node *node, int n);
+ir_node *get_irn_inter_n (ir_node *node, int n);
+void set_irn_n (ir_node *node, int n, ir_node *in);
/** Sets the mode struct of node */
-INLINE void set_irn_mode (ir_node *node, ir_mode *mode);
+void set_irn_mode (ir_node *node, ir_mode *mode);
/** Gets the mode struct. */
-INLINE ir_mode *get_irn_mode (const ir_node *node);
+ir_mode *get_irn_mode (const ir_node *node);
/** Gets the mode-enum modecode. */
-INLINE modecode get_irn_modecode (const ir_node *node);
+modecode get_irn_modecode (const ir_node *node);
/** Gets the ident for a string representation of the mode .*/
-INLINE ident *get_irn_modeident (const ir_node *node);
+ident *get_irn_modeident (const ir_node *node);
/** Gets the string representation of the mode .*/
-INLINE const char *get_irn_modename (const ir_node *node);
+const char *get_irn_modename (const ir_node *node);
/** Gets the opcode struct of the node */
-INLINE ir_op *get_irn_op (const ir_node *node);
+ir_op *get_irn_op (const ir_node *node);
/** Sets the opcode struct of the node. */
-INLINE void set_irn_op (ir_node *node, ir_op *op);
+void set_irn_op (ir_node *node, ir_op *op);
/** Gets the opcode-enum of the node. */
-INLINE opcode get_irn_opcode (const ir_node *node);
+opcode get_irn_opcode (const ir_node *node);
/** Get the string representation of the opcode. */
-INLINE const char *get_irn_opname (const ir_node *node);
+const char *get_irn_opname (const ir_node *node);
/** Get the ident for a string representation of the opcode. */
-INLINE ident *get_irn_opident (const ir_node *node);
-INLINE unsigned long get_irn_visited (const ir_node *node);
-INLINE void set_irn_visited (ir_node *node, unsigned long visited);
+ident *get_irn_opident (const ir_node *node);
+unsigned long get_irn_visited (const ir_node *node);
+void set_irn_visited (ir_node *node, unsigned long visited);
/** Sets visited to get_irg_visited(current_ir_graph). */
-INLINE void mark_irn_visited (ir_node *node);
+void mark_irn_visited (ir_node *node);
/** Returns 1 if visited < get_irg_visited(current_ir_graph). */
-INLINE int irn_not_visited (const ir_node *node);
+int irn_not_visited (const ir_node *node);
/** Returns 1 if visited >= get_irg_visited(current_ir_graph). */
-INLINE int irn_visited (const ir_node *node);
-INLINE void set_irn_link (ir_node *node, void *link);
-INLINE void *get_irn_link (const ir_node *node);
+int irn_visited (const ir_node *node);
+void set_irn_link (ir_node *node, void *link);
+void *get_irn_link (const ir_node *node);
/** Returns the ir_graph this node belongs to. Only valid if irg
* is in state pinned (irg is only stored in the block. */
-INLINE ir_graph *get_irn_irg (ir_node *node);
+ir_graph *get_irn_irg (ir_node *node);
/** Outputs a unique number for this node if libFIRM is compiled for
debugging, (configure with --enable-debug) else returns address
of node cast to long. */
-INLINE long get_irn_node_nr (const ir_node *node);
+long get_irn_node_nr (const ir_node *node);
/**
* @param arity The arity of the new node, may be <0 if yet.
* @param in An array of arity predecessor nodes.
*/
-INLINE ir_node *
+ir_node *
new_ir_node (dbg_info *db,
ir_graph *irg,
ir_node *block,
/* This works for all except Block. To express the difference to
* access routines that work for all nodes we use infix "nodes". */
#define get_nodes_block get_nodes_Block
-INLINE ir_node *get_nodes_Block (ir_node *node);
+ir_node *get_nodes_Block (ir_node *node);
#define set_nodes_block set_nodes_Block
-INLINE void set_nodes_Block (ir_node *node, ir_node *block);
+void set_nodes_Block (ir_node *node, ir_node *block);
/**
* Projection numbers for result of Start node: use for Proj nodes!
/* @@@ no more supported */
-INLINE ir_node **get_Block_cfgpred_arr (ir_node *node);
+ir_node **get_Block_cfgpred_arr (ir_node *node);
int get_Block_n_cfgpreds (ir_node *node);
-INLINE ir_node *get_Block_cfgpred (ir_node *node, int pos);
-INLINE void set_Block_cfgpred (ir_node *node, int pos, ir_node *pred);
-INLINE bool get_Block_matured (ir_node *node);
-INLINE void set_Block_matured (ir_node *node, bool matured);
-INLINE unsigned long get_Block_block_visited (ir_node *node);
-INLINE void set_Block_block_visited (ir_node *node, unsigned long visit);
+ir_node *get_Block_cfgpred (ir_node *node, int pos);
+void set_Block_cfgpred (ir_node *node, int pos, ir_node *pred);
+bool get_Block_matured (ir_node *node);
+void set_Block_matured (ir_node *node, bool matured);
+unsigned long get_Block_block_visited (ir_node *node);
+void set_Block_block_visited (ir_node *node, unsigned long visit);
/* For this current_ir_graph must be set. */
-INLINE void mark_Block_block_visited(ir_node *node);
-INLINE int Block_not_block_visited(ir_node *node);
+void mark_Block_block_visited(ir_node *node);
+int Block_not_block_visited(ir_node *node);
/* Set and remove interprocedural predecessors. If the interprocedural
* predecessors are removed, the node has the same predecessors in
@@@ old -- use get_irn_irg instead! */
ir_graph *get_Start_irg(ir_node *node);
-INLINE int get_End_n_keepalives(ir_node *end);
-INLINE ir_node *get_End_keepalive(ir_node *end, int pos);
-INLINE void add_End_keepalive (ir_node *end, ir_node *ka);
-INLINE void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
+int get_End_n_keepalives(ir_node *end);
+ir_node *get_End_keepalive(ir_node *end, int pos);
+void add_End_keepalive (ir_node *end, ir_node *ka);
+void set_End_keepalive(ir_node *end, int pos, ir_node *ka);
/* Some parts of the End node are allocated separately -- their memory
is not recovered by dead_node_elimination if a End node is dead.
free_End frees these data structures. */
-INLINE void free_End (ir_node *end);
+void free_End (ir_node *end);
/* @@@ old -- use get_irn_irg instead! */
ir_graph *get_EndReg_irg (ir_node *end);
Proj nodes mean default control flow, i.e., Proj(n). */
} cond_kind;
-INLINE ir_node *get_Cond_selector (ir_node *node);
-INLINE void set_Cond_selector (ir_node *node, ir_node *selector);
-INLINE cond_kind get_Cond_kind (ir_node *node);
-INLINE void set_Cond_kind (ir_node *node, cond_kind kind);
+ir_node *get_Cond_selector (ir_node *node);
+void set_Cond_selector (ir_node *node, ir_node *selector);
+cond_kind get_Cond_kind (ir_node *node);
+void set_Cond_kind (ir_node *node, cond_kind kind);
/**
* Projection numbers for conditions.
pn_Cond_true /**< Control flow if operand is "true". */
} pn_Cond; /* Projection numbers for Cond. */
-INLINE ir_node *get_Return_mem (ir_node *node);
-INLINE void set_Return_mem (ir_node *node, ir_node *mem);
-INLINE ir_node **get_Return_res_arr (ir_node *node);
-INLINE int get_Return_n_ress (ir_node *node);
-INLINE ir_node *get_Return_res (ir_node *node, int pos);
-INLINE void set_Return_res (ir_node *node, int pos, ir_node *res);
+ir_node *get_Return_mem (ir_node *node);
+void set_Return_mem (ir_node *node, ir_node *mem);
+ir_node **get_Return_res_arr (ir_node *node);
+int get_Return_n_ress (ir_node *node);
+ir_node *get_Return_res (ir_node *node, int pos);
+void set_Return_res (ir_node *node, int pos, ir_node *res);
-INLINE ir_node *get_Raise_mem (ir_node *node);
-INLINE void set_Raise_mem (ir_node *node, ir_node *mem);
-INLINE ir_node *get_Raise_exo_ptr (ir_node *node); /* PoinTeR to EXception Object */
-INLINE void set_Raise_exo_ptr (ir_node *node, ir_node *exoptr);
+ir_node *get_Raise_mem (ir_node *node);
+void set_Raise_mem (ir_node *node, ir_node *mem);
+ir_node *get_Raise_exo_ptr (ir_node *node); /* PoinTeR to EXception Object */
+void set_Raise_exo_ptr (ir_node *node, ir_node *exoptr);
/**
* Projection numbers for Raise.
pn_Raise_M /**< Memory result. */
} pn_Raise; /* Projection numbers for Raise. */
-INLINE tarval *get_Const_tarval (ir_node *node);
-INLINE void set_Const_tarval (ir_node *node, tarval *con);
+tarval *get_Const_tarval (ir_node *node);
+void set_Const_tarval (ir_node *node, tarval *con);
/* The source language type. Must be an atomic type. Mode of type must
be mode of node. For tarvals from entities type must be pointer to
entity type. */
-INLINE type *get_Const_type (ir_node *node);
-INLINE void set_Const_type (ir_node *node, type *tp);
+type *get_Const_type (ir_node *node);
+void set_Const_type (ir_node *node, type *tp);
/** This enum names the three different kinds of symbolic Constants
represented by SymConst. The content of the attribute type_or_id
} symconst_kind;
typedef union type_or_id * type_or_id_p;
-INLINE symconst_kind get_SymConst_kind (const ir_node *node);
-INLINE void set_SymConst_kind (ir_node *node, symconst_kind num);
+symconst_kind get_SymConst_kind (const ir_node *node);
+void set_SymConst_kind (ir_node *node, symconst_kind num);
/* Only to access SymConst of kind type_tag or size. Else assertion: */
-INLINE type *get_SymConst_type (ir_node *node);
-INLINE void set_SymConst_type (ir_node *node, type *tp);
+type *get_SymConst_type (ir_node *node);
+void set_SymConst_type (ir_node *node, type *tp);
/* Only to access SymConst of kind linkage_ptr_info. Else assertion: */
-INLINE ident *get_SymConst_ptrinfo (ir_node *node);
-INLINE void set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo);
+ident *get_SymConst_ptrinfo (ir_node *node);
+void set_SymConst_ptrinfo (ir_node *node, ident *ptrinfo);
/* Sets both: type and ptrinfo. Needed to treat the node independent of
its semantics. Does a memcpy for the memory tori points to. */
-INLINE type_or_id_p get_SymConst_type_or_id (ir_node *node);
-INLINE void set_SymConst_type_or_id (ir_node *node, type_or_id_p tori);
-
-INLINE ir_node *get_Sel_mem (ir_node *node);
-INLINE void set_Sel_mem (ir_node *node, ir_node *mem);
-INLINE ir_node *get_Sel_ptr (ir_node *node); /* ptr to the object to select from */
-INLINE void set_Sel_ptr (ir_node *node, ir_node *ptr);
-INLINE ir_node **get_Sel_index_arr (ir_node *node);
-INLINE int get_Sel_n_indexs (ir_node *node);
-INLINE ir_node *get_Sel_index (ir_node *node, int pos);
-INLINE void set_Sel_index (ir_node *node, int pos, ir_node *index);
-INLINE entity *get_Sel_entity (ir_node *node); /* entity to select */
-INLINE void set_Sel_entity (ir_node *node, entity *ent);
+type_or_id_p get_SymConst_type_or_id (ir_node *node);
+void set_SymConst_type_or_id (ir_node *node, type_or_id_p tori);
+
+ir_node *get_Sel_mem (ir_node *node);
+void set_Sel_mem (ir_node *node, ir_node *mem);
+ir_node *get_Sel_ptr (ir_node *node); /* ptr to the object to select from */
+void set_Sel_ptr (ir_node *node, ir_node *ptr);
+ir_node **get_Sel_index_arr (ir_node *node);
+int get_Sel_n_indexs (ir_node *node);
+ir_node *get_Sel_index (ir_node *node, int pos);
+void set_Sel_index (ir_node *node, int pos, ir_node *index);
+entity *get_Sel_entity (ir_node *node); /* entity to select */
+void set_Sel_entity (ir_node *node, entity *ent);
/**
* Projection numbers for result of Call node: use for Proj nodes!
an exception */
} pn_Call; /* Projection numbers for Call. */
-INLINE ir_node *get_Call_mem (ir_node *node);
-INLINE void set_Call_mem (ir_node *node, ir_node *mem);
-INLINE ir_node *get_Call_ptr (ir_node *node);
-INLINE void set_Call_ptr (ir_node *node, ir_node *ptr);
-INLINE ir_node **get_Call_param_arr (ir_node *node);
+ir_node *get_Call_mem (ir_node *node);
+void set_Call_mem (ir_node *node, ir_node *mem);
+ir_node *get_Call_ptr (ir_node *node);
+void set_Call_ptr (ir_node *node, ir_node *ptr);
+ir_node **get_Call_param_arr (ir_node *node);
/** Gets the number of parameters of a call. */
-INLINE int get_Call_n_params (ir_node *node);
+int get_Call_n_params (ir_node *node);
/** Gets the call parameter at position pos. */
-INLINE ir_node *get_Call_param (ir_node *node, int pos);
+ir_node *get_Call_param (ir_node *node, int pos);
/** Sets the call parameter at position pos. */
-INLINE void set_Call_param (ir_node *node, int pos, ir_node *param);
+void set_Call_param (ir_node *node, int pos, ir_node *param);
/** Gets the type of a call. */
-INLINE type *get_Call_type (ir_node *node);
+type *get_Call_type (ir_node *node);
/** Sets the type of a call. */
-INLINE void set_Call_type (ir_node *node, type *tp);
+void set_Call_type (ir_node *node, type *tp);
/** Gets the arity of a call. Identical to get_Call_n_params(). */
-INLINE int get_Call_arity (ir_node *node);
+int get_Call_arity (ir_node *node);
/* Set, get and remove the callee-analysis.
The array is only accessible if information is valid.
ir_node *get_CallBegin_call (ir_node *node);
void set_CallBegin_call (ir_node *node, ir_node *call);
-INLINE ir_node *get_FuncCall_ptr (ir_node *node);
-INLINE void set_FuncCall_ptr (ir_node *node, ir_node *ptr);
-INLINE ir_node **get_FuncCall_param_arr (ir_node *node);
+ir_node *get_FuncCall_ptr (ir_node *node);
+void set_FuncCall_ptr (ir_node *node, ir_node *ptr);
+ir_node **get_FuncCall_param_arr (ir_node *node);
/** Gets the number of parameters of a func call. */
-INLINE int get_FuncCall_n_params (ir_node *node);
+int get_FuncCall_n_params (ir_node *node);
/** Gets the func call parameter at position pos. */
-INLINE ir_node *get_FuncCall_param (ir_node *node, int pos);
+ir_node *get_FuncCall_param (ir_node *node, int pos);
/** Sets the func call parameter at position pos. */
-INLINE void set_FuncCall_param (ir_node *node, int pos, ir_node *param);
+void set_FuncCall_param (ir_node *node, int pos, ir_node *param);
/** Gets the type of a func call. */
-INLINE type *get_FuncCall_type (ir_node *node);
+type *get_FuncCall_type (ir_node *node);
/** Sets the type of a func call. */
-INLINE void set_FuncCall_type (ir_node *node, type *tp);
+void set_FuncCall_type (ir_node *node, type *tp);
/** Gets the arity of a func call. Identical to get_FuncCall_n_params(). */
-INLINE int get_FuncCall_arity (ir_node *node);
+int get_FuncCall_arity (ir_node *node);
/* Set, get and remove the callee-analysis.
The array is only accessible if information is valid.
unops are: Minus, Abs, Not, Conv, Cast
binops are: Add, Sub, Mul, Quot, DivMod, Div, Mod, And, Or, Eor, Shl,
Shr, Shrs, Rot, Cmp */
-INLINE int is_unop (ir_node *node);
-INLINE ir_node *get_unop_op (ir_node *node);
-INLINE void set_unop_op (ir_node *node, ir_node *op);
-INLINE int is_binop (ir_node *node);
-INLINE ir_node *get_binop_left (ir_node *node);
-INLINE void set_binop_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_binop_right (ir_node *node);
-INLINE void set_binop_right (ir_node *node, ir_node *right);
-
-INLINE ir_node *get_Add_left (ir_node *node);
-INLINE void set_Add_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Add_right (ir_node *node);
-INLINE void set_Add_right (ir_node *node, ir_node *right);
-
-INLINE ir_node *get_Sub_left (ir_node *node);
-INLINE void set_Sub_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Sub_right (ir_node *node);
-INLINE void set_Sub_right (ir_node *node, ir_node *right);
-
-INLINE ir_node *get_Minus_op (ir_node *node);
-INLINE void set_Minus_op (ir_node *node, ir_node *op);
-
-INLINE ir_node *get_Mul_left (ir_node *node);
-INLINE void set_Mul_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Mul_right (ir_node *node);
-INLINE void set_Mul_right (ir_node *node, ir_node *right);
-
-INLINE ir_node *get_Quot_left (ir_node *node);
-INLINE void set_Quot_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Quot_right (ir_node *node);
-INLINE void set_Quot_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Quot_mem (ir_node *node);
-INLINE void set_Quot_mem (ir_node *node, ir_node *mem);
+int is_unop (ir_node *node);
+ir_node *get_unop_op (ir_node *node);
+void set_unop_op (ir_node *node, ir_node *op);
+int is_binop (ir_node *node);
+ir_node *get_binop_left (ir_node *node);
+void set_binop_left (ir_node *node, ir_node *left);
+ir_node *get_binop_right (ir_node *node);
+void set_binop_right (ir_node *node, ir_node *right);
+
+ir_node *get_Add_left (ir_node *node);
+void set_Add_left (ir_node *node, ir_node *left);
+ir_node *get_Add_right (ir_node *node);
+void set_Add_right (ir_node *node, ir_node *right);
+
+ir_node *get_Sub_left (ir_node *node);
+void set_Sub_left (ir_node *node, ir_node *left);
+ir_node *get_Sub_right (ir_node *node);
+void set_Sub_right (ir_node *node, ir_node *right);
+
+ir_node *get_Minus_op (ir_node *node);
+void set_Minus_op (ir_node *node, ir_node *op);
+
+ir_node *get_Mul_left (ir_node *node);
+void set_Mul_left (ir_node *node, ir_node *left);
+ir_node *get_Mul_right (ir_node *node);
+void set_Mul_right (ir_node *node, ir_node *right);
+
+ir_node *get_Quot_left (ir_node *node);
+void set_Quot_left (ir_node *node, ir_node *left);
+ir_node *get_Quot_right (ir_node *node);
+void set_Quot_right (ir_node *node, ir_node *right);
+ir_node *get_Quot_mem (ir_node *node);
+void set_Quot_mem (ir_node *node, ir_node *mem);
/**
* Projection numbers for Quot: use for Proj nodes!
pn_Quot_res /**< Result of computation. */
} pn_Quot; /* Projection numbers for Quot. */
-INLINE ir_node *get_DivMod_left (ir_node *node);
-INLINE void set_DivMod_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_DivMod_right (ir_node *node);
-INLINE void set_DivMod_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_DivMod_mem (ir_node *node);
-INLINE void set_DivMod_mem (ir_node *node, ir_node *mem);
+ir_node *get_DivMod_left (ir_node *node);
+void set_DivMod_left (ir_node *node, ir_node *left);
+ir_node *get_DivMod_right (ir_node *node);
+void set_DivMod_right (ir_node *node, ir_node *right);
+ir_node *get_DivMod_mem (ir_node *node);
+void set_DivMod_mem (ir_node *node, ir_node *mem);
/**
* Projection numbers for DivMod: use for Proj nodes!
pn_DivMod_res_mod /**< Result of computation a % b. */
} pn_DivMod; /* Projection numbers for DivMod. */
-INLINE ir_node *get_Div_left (ir_node *node);
-INLINE void set_Div_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Div_right (ir_node *node);
-INLINE void set_Div_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Div_mem (ir_node *node);
-INLINE void set_Div_mem (ir_node *node, ir_node *mem);
+ir_node *get_Div_left (ir_node *node);
+void set_Div_left (ir_node *node, ir_node *left);
+ir_node *get_Div_right (ir_node *node);
+void set_Div_right (ir_node *node, ir_node *right);
+ir_node *get_Div_mem (ir_node *node);
+void set_Div_mem (ir_node *node, ir_node *mem);
/**
* Projection numbers for Div: use for Proj nodes!
pn_Div_res /**< Result of computation. */
} pn_Div; /* Projection numbers for Div. */
-INLINE ir_node *get_Mod_left (ir_node *node);
-INLINE void set_Mod_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Mod_right (ir_node *node);
-INLINE void set_Mod_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Mod_mem (ir_node *node);
-INLINE void set_Mod_mem (ir_node *node, ir_node *mem);
+ir_node *get_Mod_left (ir_node *node);
+void set_Mod_left (ir_node *node, ir_node *left);
+ir_node *get_Mod_right (ir_node *node);
+void set_Mod_right (ir_node *node, ir_node *right);
+ir_node *get_Mod_mem (ir_node *node);
+void set_Mod_mem (ir_node *node, ir_node *mem);
/**
* Projection numbers for Mod: use for Proj nodes!
pn_Mod_res /**< Result of computation. */
} pn_Mod; /* Projection numbers for Mod. */
-INLINE ir_node *get_Abs_op (ir_node *node);
-INLINE void set_Abs_op (ir_node *node, ir_node *op);
+ir_node *get_Abs_op (ir_node *node);
+void set_Abs_op (ir_node *node, ir_node *op);
-INLINE ir_node *get_And_left (ir_node *node);
-INLINE void set_And_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_And_right (ir_node *node);
-INLINE void set_And_right (ir_node *node, ir_node *right);
+ir_node *get_And_left (ir_node *node);
+void set_And_left (ir_node *node, ir_node *left);
+ir_node *get_And_right (ir_node *node);
+void set_And_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Or_left (ir_node *node);
-INLINE void set_Or_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Or_right (ir_node *node);
-INLINE void set_Or_right (ir_node *node, ir_node *right);
+ir_node *get_Or_left (ir_node *node);
+void set_Or_left (ir_node *node, ir_node *left);
+ir_node *get_Or_right (ir_node *node);
+void set_Or_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Eor_left (ir_node *node);
-INLINE void set_Eor_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Eor_right (ir_node *node);
-INLINE void set_Eor_right (ir_node *node, ir_node *right);
+ir_node *get_Eor_left (ir_node *node);
+void set_Eor_left (ir_node *node, ir_node *left);
+ir_node *get_Eor_right (ir_node *node);
+void set_Eor_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Not_op (ir_node *node);
-INLINE void set_Not_op (ir_node *node, ir_node *op);
+ir_node *get_Not_op (ir_node *node);
+void set_Not_op (ir_node *node, ir_node *op);
/**
* Projection numbers for Cmp are defined several times.
} pn_Cmp; /* Projection numbers for Cmp */
//#define not_mask pn_Cmp_Leg
-INLINE const char *get_pnc_string(int pnc);
-INLINE int get_negated_pnc(int pnc);
-INLINE ir_node *get_Cmp_left (ir_node *node);
-INLINE void set_Cmp_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Cmp_right (ir_node *node);
-INLINE void set_Cmp_right (ir_node *node, ir_node *right);
+const char *get_pnc_string(int pnc);
+int get_negated_pnc(int pnc);
+ir_node *get_Cmp_left (ir_node *node);
+void set_Cmp_left (ir_node *node, ir_node *left);
+ir_node *get_Cmp_right (ir_node *node);
+void set_Cmp_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Shl_left (ir_node *node);
-INLINE void set_Shl_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Shl_right (ir_node *node);
-INLINE void set_Shl_right (ir_node *node, ir_node *right);
+ir_node *get_Shl_left (ir_node *node);
+void set_Shl_left (ir_node *node, ir_node *left);
+ir_node *get_Shl_right (ir_node *node);
+void set_Shl_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Shr_left (ir_node *node);
-INLINE void set_Shr_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Shr_right (ir_node *node);
-INLINE void set_Shr_right (ir_node *node, ir_node *right);
+ir_node *get_Shr_left (ir_node *node);
+void set_Shr_left (ir_node *node, ir_node *left);
+ir_node *get_Shr_right (ir_node *node);
+void set_Shr_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Shrs_left (ir_node *node);
-INLINE void set_Shrs_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Shrs_right (ir_node *node);
-INLINE void set_Shrs_right (ir_node *node, ir_node *right);
+ir_node *get_Shrs_left (ir_node *node);
+void set_Shrs_left (ir_node *node, ir_node *left);
+ir_node *get_Shrs_right (ir_node *node);
+void set_Shrs_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Rot_left (ir_node *node);
-INLINE void set_Rot_left (ir_node *node, ir_node *left);
-INLINE ir_node *get_Rot_right (ir_node *node);
-INLINE void set_Rot_right (ir_node *node, ir_node *right);
+ir_node *get_Rot_left (ir_node *node);
+void set_Rot_left (ir_node *node, ir_node *left);
+ir_node *get_Rot_right (ir_node *node);
+void set_Rot_right (ir_node *node, ir_node *right);
-INLINE ir_node *get_Conv_op (ir_node *node);
-INLINE void set_Conv_op (ir_node *node, ir_node *op);
+ir_node *get_Conv_op (ir_node *node);
+void set_Conv_op (ir_node *node, ir_node *op);
/* Does Cast need a mem operator?
* Cast should only depend on the type, not on the state of an
* are accessed in the cast. This required some precaution, to
* get the right memory into the Loads generated from the cast.
*/
-INLINE ir_node *get_Cast_op (ir_node *node);
-INLINE void set_Cast_op (ir_node *node, ir_node *op);
-INLINE type *get_Cast_type (ir_node *node);
-INLINE void set_Cast_type (ir_node *node, type *to_tp);
+ir_node *get_Cast_op (ir_node *node);
+void set_Cast_op (ir_node *node, ir_node *op);
+type *get_Cast_type (ir_node *node);
+void set_Cast_type (ir_node *node, type *to_tp);
/* Returns true if n is Phi or Filter in interprocedural_view. */
-INLINE int is_Phi (ir_node *n);
+int is_Phi (ir_node *n);
/* These routines also work for Filter nodes in interprocedural view. */
-INLINE ir_node **get_Phi_preds_arr (ir_node *node);
-INLINE int get_Phi_n_preds (ir_node *node);
-INLINE ir_node *get_Phi_pred (ir_node *node, int pos);
-INLINE void set_Phi_pred (ir_node *node, int pos, ir_node *pred);
-
-INLINE ir_node *get_Filter_pred(ir_node *node);
-INLINE void set_Filter_pred(ir_node *node, ir_node *pred);
-INLINE long get_Filter_proj(ir_node *node);
-INLINE void set_Filter_proj(ir_node *node, long proj);
+ir_node **get_Phi_preds_arr (ir_node *node);
+int get_Phi_n_preds (ir_node *node);
+ir_node *get_Phi_pred (ir_node *node, int pos);
+void set_Phi_pred (ir_node *node, int pos, ir_node *pred);
+
+ir_node *get_Filter_pred(ir_node *node);
+void set_Filter_pred(ir_node *node, ir_node *pred);
+long get_Filter_proj(ir_node *node);
+void set_Filter_proj(ir_node *node, long proj);
/* set the interprocedural predecessors, ...d_arr uses current_ir_graph.
* @@@ Maybe better: arity is zero if no cg preds. */
void set_Filter_cg_pred_arr(ir_node * node, int arity, ir_node ** in);
pn_Load_res /**< Result of load operation. */
} pn_Load; /* Projection numbers for Load. */
-INLINE ir_node *get_Load_mem (ir_node *node);
-INLINE void set_Load_mem (ir_node *node, ir_node *mem);
-INLINE ir_node *get_Load_ptr (ir_node *node);
-INLINE void set_Load_ptr (ir_node *node, ir_node *ptr);
+ir_node *get_Load_mem (ir_node *node);
+void set_Load_mem (ir_node *node, ir_node *mem);
+ir_node *get_Load_ptr (ir_node *node);
+void set_Load_ptr (ir_node *node, ir_node *ptr);
/**
* Projection numbers for Store: use for Proj nodes!
pn_Store_X_except /**< Execution result if exception occured. */
} pn_Store; /* Projection numbers for Store. */
-INLINE ir_node *get_Store_mem (ir_node *node);
-INLINE void set_Store_mem (ir_node *node, ir_node *mem);
-INLINE ir_node *get_Store_ptr (ir_node *node);
-INLINE void set_Store_ptr (ir_node *node, ir_node *ptr);
-INLINE ir_node *get_Store_value (ir_node *node);
-INLINE void set_Store_value (ir_node *node, ir_node *value);
+ir_node *get_Store_mem (ir_node *node);
+void set_Store_mem (ir_node *node, ir_node *mem);
+ir_node *get_Store_ptr (ir_node *node);
+void set_Store_ptr (ir_node *node, ir_node *ptr);
+ir_node *get_Store_value (ir_node *node);
+void set_Store_value (ir_node *node, ir_node *value);
/**
* Projection numbers for Alloc: use for Proj nodes!
pn_Alloc_res /**< Result of allocation. */
} pn_Alloc; /* Projection numbers for Alloc. */
-INLINE ir_node *get_Alloc_mem (ir_node *node);
-INLINE void set_Alloc_mem (ir_node *node, ir_node *mem);
-INLINE ir_node *get_Alloc_size (ir_node *node);
-INLINE void set_Alloc_size (ir_node *node, ir_node *size);
-INLINE type *get_Alloc_type (ir_node *node);
-INLINE void set_Alloc_type (ir_node *node, type *tp);
+ir_node *get_Alloc_mem (ir_node *node);
+void set_Alloc_mem (ir_node *node, ir_node *mem);
+ir_node *get_Alloc_size (ir_node *node);
+void set_Alloc_size (ir_node *node, ir_node *size);
+type *get_Alloc_type (ir_node *node);
+void set_Alloc_type (ir_node *node, type *tp);
/** The allocation place. */
typedef enum {
heap_alloc /**< Alloc allocates the object on the heap. */
} where_alloc;
-INLINE where_alloc get_Alloc_where (ir_node *node);
-INLINE void set_Alloc_where (ir_node *node, where_alloc where);
-
-INLINE ir_node *get_Free_mem (ir_node *node);
-INLINE void set_Free_mem (ir_node *node, ir_node *mem);
-INLINE ir_node *get_Free_ptr (ir_node *node);
-INLINE void set_Free_ptr (ir_node *node, ir_node *ptr);
-INLINE ir_node *get_Free_size (ir_node *node);
-INLINE void set_Free_size (ir_node *node, ir_node *size);
-INLINE type *get_Free_type (ir_node *node);
-INLINE void set_Free_type (ir_node *node, type *tp);
-
-INLINE ir_node **get_Sync_preds_arr (ir_node *node);
-INLINE int get_Sync_n_preds (ir_node *node);
-INLINE ir_node *get_Sync_pred (ir_node *node, int pos);
-INLINE void set_Sync_pred (ir_node *node, int pos, ir_node *pred);
-
-INLINE ir_node *get_Proj_pred (ir_node *node);
-INLINE void set_Proj_pred (ir_node *node, ir_node *pred);
+where_alloc get_Alloc_where (ir_node *node);
+void set_Alloc_where (ir_node *node, where_alloc where);
+
+ir_node *get_Free_mem (ir_node *node);
+void set_Free_mem (ir_node *node, ir_node *mem);
+ir_node *get_Free_ptr (ir_node *node);
+void set_Free_ptr (ir_node *node, ir_node *ptr);
+ir_node *get_Free_size (ir_node *node);
+void set_Free_size (ir_node *node, ir_node *size);
+type *get_Free_type (ir_node *node);
+void set_Free_type (ir_node *node, type *tp);
+
+ir_node **get_Sync_preds_arr (ir_node *node);
+int get_Sync_n_preds (ir_node *node);
+ir_node *get_Sync_pred (ir_node *node, int pos);
+void set_Sync_pred (ir_node *node, int pos, ir_node *pred);
+
+ir_node *get_Proj_pred (ir_node *node);
+void set_Proj_pred (ir_node *node, ir_node *pred);
/* Why long? shouldn't int be enough, and smaller? Or even byte? */
-INLINE long get_Proj_proj (ir_node *node);
-INLINE void set_Proj_proj (ir_node *node, long proj);
+long get_Proj_proj (ir_node *node);
+void set_Proj_proj (ir_node *node, long proj);
-INLINE ir_node **get_Tuple_preds_arr (ir_node *node);
-INLINE int get_Tuple_n_preds (ir_node *node);
-INLINE ir_node *get_Tuple_pred (ir_node *node, int pos);
-INLINE void set_Tuple_pred (ir_node *node, int pos, ir_node *pred);
+ir_node **get_Tuple_preds_arr (ir_node *node);
+int get_Tuple_n_preds (ir_node *node);
+ir_node *get_Tuple_pred (ir_node *node, int pos);
+void set_Tuple_pred (ir_node *node, int pos, ir_node *pred);
-INLINE ir_node *get_Id_pred (ir_node *node);
-INLINE void set_Id_pred (ir_node *node, ir_node *pred);
+ir_node *get_Id_pred (ir_node *node);
+void set_Id_pred (ir_node *node, ir_node *pred);
/** Confirm has a single result and returns 'value' unchanged.
* The node expresses a restriction on 'value':
* 'value' 'cmp' 'bound' == true. */
-INLINE ir_node *get_Confirm_value (ir_node *node);
-INLINE void set_Confirm_value (ir_node *node, ir_node *value);
-INLINE ir_node *get_Confirm_bound (ir_node *node);
-INLINE void set_Confirm_bound (ir_node *node, ir_node *bound);
-INLINE pn_Cmp get_Confirm_cmp (ir_node *node);
-INLINE void set_Confirm_cmp (ir_node *node, pn_Cmp cmp);
+ir_node *get_Confirm_value (ir_node *node);
+void set_Confirm_value (ir_node *node, ir_node *value);
+ir_node *get_Confirm_bound (ir_node *node);
+void set_Confirm_bound (ir_node *node, ir_node *bound);
+pn_Cmp get_Confirm_cmp (ir_node *node);
+void set_Confirm_cmp (ir_node *node, pn_Cmp cmp);
/*
*
*/
/** returns operand of node if node is a Proj. */
-INLINE ir_node *skip_Proj (ir_node *node);
+ir_node *skip_Proj (ir_node *node);
/** returns operand of node if node is a Id */
-INLINE ir_node *skip_nop (ir_node *node);
-INLINE ir_node *skip_Id (ir_node *node); /* Same as skip_nop. */
+ir_node *skip_nop (ir_node *node);
+ir_node *skip_Id (ir_node *node); /* Same as skip_nop. */
/* returns corresponding operand of Tuple if node is a Proj from
a Tuple. */
-INLINE ir_node *skip_Tuple (ir_node *node);
+ir_node *skip_Tuple (ir_node *node);
/** returns true if node is a Bad node. */
-INLINE int is_Bad (ir_node *node);
+int is_Bad (ir_node *node);
/** returns true if the node is not a Block */
-INLINE int is_no_Block (ir_node *node);
+int is_no_Block (ir_node *node);
/** returns true if the node is a Block */
-INLINE int is_Block (ir_node *node);
+int is_Block (ir_node *node);
/** returns true if node is a Unknown node. */
-INLINE int is_Unknown (ir_node *node);
+int is_Unknown (ir_node *node);
/** returns true if node is a Proj node or a Filter node in
* intraprocedural view */
-INLINE int is_Proj (const ir_node *node);
+int is_Proj (const ir_node *node);
/** Returns true if the operation manipulates control flow:
Start, End, Jmp, Cond, Return, Raise, Bad, CallBegin, EndReg, EndExcept */
int is_cfop(ir_node *node);
if (op == op_Block || op == op_Phi || is_cfopcode(op)) return;
op->pinned = pinned;
}
-
-/* repeat 'inline' methods here */
-
-# ifndef USE_GCC_INLINE
-/** Returns the attribute size of nodes of this opcode.
- @note Use not encouraged, internal feature. */
-int get_op_attr_size (const ir_op *op) { /* used in irnode.c */
- return op->attr_size;
-}
-
-/** Returns non-zero if op is one of Start, End, Jmp, Cond, Return, Raise or Bad. */
-int is_cfopcode(const ir_op *op) { /* used in irnode.c */
- return op->flags & irop_flag_cfopcode;
-}
-
-/** Returns true if the operation manipulates interprocedural control flow:
- CallBegin, EndReg, EndExcept */
-int is_ip_cfopcode(const ir_op *op) { /* used in irnode.c */
- return op->flags & irop_flag_ip_cfopcode;
-}
-
-/* Returns non-zero if operation is commutative */
-int is_op_commutative(const ir_op *op) { /* used in iropt.c */
- return op->flags & irop_flag_commutative;
-}
-
-/* Returns non-zero if operation is fragile */
-int is_op_fragile(const ir_op *op) { /* used in irnode.c */
- return op->flags & irop_flag_fragile;
-}
-# endif /* not defined USE_GCC_INLINE */
{
}
-/*******************************************************************/
-/** ENTITY **/
-/*******************************************************************/
-
-/* redeclared to declare INLINE. */
-INLINE entity *get_entity_overwrites (entity *ent, int pos);
-INLINE entity *get_entity_overwrittenby (entity *ent, int pos);
-INLINE type *get_entity_owner (entity *ent);
+/*-----------------------------------------------------------------*/
+/* ENTITY */
+/*-----------------------------------------------------------------*/
-INLINE void insert_entity_in_owner (entity *ent) {
+void insert_entity_in_owner (entity *ent) {
type *owner = ent->owner;
switch (get_type_tpop_code(owner)) {
case tpo_class: {
return res;
}
-INLINE void free_compound_graph_path (compound_graph_path *gr);
-INLINE int is_compound_graph_path(void *thing);
-INLINE int get_compound_graph_path_length(compound_graph_path *gr);
-INLINE entity *get_compound_graph_path_node(compound_graph_path *gr, int pos);
-INLINE int get_compound_ent_n_values(entity *ent);
+void free_compound_graph_path (compound_graph_path *gr);
+int is_compound_graph_path(void *thing);
+int get_compound_graph_path_length(compound_graph_path *gr);
+entity *get_compound_graph_path_node(compound_graph_path *gr, int pos);
+int get_compound_ent_n_values(entity *ent);
-INLINE void free_entity_attrs(entity *ent) {
+void free_entity_attrs(entity *ent) {
int i;
assert(ent);
if (get_type_tpop(get_entity_owner(ent)) == type_class) {
}
/* Outputs a unique number for this node */
-INLINE long
+long
get_entity_nr(entity *ent) {
assert(ent);
#ifdef DEBUG_libfirm
#endif
}
-INLINE const char *
+const char *
get_entity_name (entity *ent) {
assert (ent);
return get_id_str(get_entity_ident(ent));
void set_entity_ld_ident (entity *, ident *ld_ident);
*/
-INLINE type *
+type *
get_entity_owner (entity *ent) {
return ent->owner = skip_tid(ent->owner);
}
-INLINE void
+void
set_entity_owner (entity *ent, type *owner) {
assert_legal_owner_of_ent(owner);
ent->owner = owner;
}
-INLINE void /* should this go into type.c? */
+void /* should this go into type.c? */
assert_legal_owner_of_ent(type *owner) {
assert (get_type_tpop_code(owner) == tpo_class ||
get_type_tpop_code(owner) == tpo_union ||
-- to select fields! */
}
-INLINE ident *
+ident *
get_entity_ld_ident (entity *ent)
{
if (ent->ld_name == NULL)
return ent->ld_name;
}
-INLINE void
+void
set_entity_ld_ident (entity *ent, ident *ld_ident) {
ent->ld_name = ld_ident;
}
-INLINE const char *
+const char *
get_entity_ld_name (entity *ent) {
return get_id_str(get_entity_ld_ident(ent));
}
void set_entity_ld_name (entity *, char *ld_name);
*/
-INLINE type *
+type *
get_entity_type (entity *ent) {
return ent->type = skip_tid(ent->type);
}
-INLINE void
+void
set_entity_type (entity *ent, type *type) {
ent->type = type;
}
-INLINE ent_allocation
+ent_allocation
get_entity_allocation (entity *ent) {
return ent->allocation;
}
-INLINE void
+void
set_entity_allocation (entity *ent, ent_allocation al) {
ent->allocation = al;
}
}
-INLINE ent_visibility
+ent_visibility
get_entity_visibility (entity *ent) {
return ent->visibility;
}
-INLINE void
+void
set_entity_visibility (entity *ent, ent_visibility vis) {
if (vis != visibility_local)
assert((ent->allocation == allocation_static) ||
#undef X
}
-INLINE ent_variability
+ent_variability
get_entity_variability (entity *ent) {
return ent->variability;
}
-INLINE void
+void
set_entity_variability (entity *ent, ent_variability var)
{
if (var == variability_part_constant)
#undef X
}
-INLINE ent_volatility
+ent_volatility
get_entity_volatility (entity *ent) {
assert (ent);
return ent->volatility;
}
-INLINE void
+void
set_entity_volatility (entity *ent, ent_volatility vol) {
assert (ent);
ent->volatility = vol;
#undef X
}
-INLINE peculiarity
+peculiarity
get_entity_peculiarity (entity *ent) {
assert (ent);
return ent->peculiarity;
}
-INLINE void
+void
set_entity_peculiarity (entity *ent, peculiarity pec) {
assert (ent);
/* @@@ why peculiarity only for methods? */
}
/* Set has no effect for existent entities of type method. */
-INLINE ir_node *
+ir_node *
get_atomic_ent_value(entity *ent)
{
assert(ent);
return ent->value;
}
-INLINE void
+void
set_atomic_ent_value(entity *ent, ir_node *val) {
assert(ent && is_atomic_entity(ent) && (ent->variability != variability_uninitialized));
if (is_method_type(ent->type) && (ent->peculiarity == peculiarity_existent))
return res;
}
-INLINE void
+void
free_compound_graph_path (compound_graph_path *gr) {
assert(gr && is_compound_graph_path(gr));
gr->kind = k_BAD;
free(gr);
}
-INLINE int
+int
is_compound_graph_path(void *thing) {
return (get_kind(thing) == k_ir_compound_graph_path);
}
/* checks whether nodes 0..pos are correct (all lie on a path.) */
/* @@@ not implemented */
-INLINE int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
+int is_proper_compound_graph_path(compound_graph_path *gr, int pos) {
int i;
entity *node;
type *owner = gr->tp;
return true;
}
-INLINE int
+int
get_compound_graph_path_length(compound_graph_path *gr) {
assert(gr && is_compound_graph_path(gr));
return gr->len;
}
-INLINE entity *
+entity *
get_compound_graph_path_node(compound_graph_path *gr, int pos) {
assert(gr && is_compound_graph_path(gr));
assert(pos >= 0 && pos < gr->len);
return gr->nodes[pos];
}
-INLINE void
+void
set_compound_graph_path_node(compound_graph_path *gr, int pos, entity *node) {
assert(gr && is_compound_graph_path(gr));
assert(pos >= 0 && pos < gr->len);
/* A value of a compound entity is a pair of value and the corresponding path to a member of
the compound. */
-INLINE void
+void
add_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path) {
assert(ent && is_compound_entity(ent) && (ent->variability != variability_uninitialized));
ARR_APP1 (ir_node *, ent->values, val);
ARR_APP1 (compound_graph_path *, ent->val_paths, path);
}
-INLINE void
+void
set_compound_ent_value_w_path(entity *ent, ir_node *val, compound_graph_path *path, int pos) {
assert(ent && is_compound_entity(ent) && (ent->variability != variability_uninitialized));
ent->values[pos] = val;
ent->val_paths[pos] = path;
}
-INLINE int
+int
get_compound_ent_n_values(entity *ent) {
assert(ent && is_compound_entity(ent) && (ent->variability != variability_uninitialized));
return (ARR_LEN (ent->values));
}
-INLINE ir_node *
+ir_node *
get_compound_ent_value(entity *ent, int pos) {
assert(ent && is_compound_entity(ent) && (ent->variability != variability_uninitialized));
return ent->values[pos];
}
-INLINE compound_graph_path *
+compound_graph_path *
get_compound_ent_value_path(entity *ent, int pos) {
assert(ent && is_compound_entity(ent) && (ent->variability != variability_uninitialized));
return ent->val_paths[pos];
}
}
-INLINE void
+void
add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
compound_graph_path *path;
assert(ent && is_compound_entity(ent) && (ent->variability != variability_uninitialized));
/* Copies the firm subgraph referenced by val to const_code_irg and adds
the node as constant initialization to ent.
The subgraph may not contain control flow operations.
-INLINE void
+void
copy_and_add_compound_ent_value(entity *ent, ir_node *val, entity *member) {
ir_graph *rem = current_ir_graph;
return copy_const_value(ent->values[pos+1]);
}*/
-INLINE entity *
+entity *
get_compound_ent_value_member(entity *ent, int pos) {
compound_graph_path *path;
assert(ent && is_compound_entity(ent) && (ent->variability != variability_uninitialized));
return get_compound_graph_path_node(path, get_compound_graph_path_length(path)-1);
}
-INLINE void
+void
set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos) {
compound_graph_path *path;
assert(ent && is_compound_entity(ent) && (ent->variability != variability_uninitialized));
current_ir_graph = rem;
}
-INLINE int
+int
get_entity_offset (entity *ent) {
return ent->offset;
}
-INLINE void
+void
set_entity_offset (entity *ent, int offset) {
ent->offset = offset;
}
-INLINE void
+void
add_entity_overwrites (entity *ent, entity *overwritten) {
assert(ent);
assert(is_class_type(get_entity_owner(ent)));
ARR_APP1 (entity *, overwritten->overwrittenby, ent);
}
-INLINE int
+int
get_entity_n_overwrites (entity *ent) {
assert(ent);
assert(is_class_type(get_entity_owner(ent)));
return -1;
}
-INLINE entity *
+entity *
get_entity_overwrites (entity *ent, int pos) {
assert(ent);
assert(is_class_type(get_entity_owner(ent)));
return ent->overwrites[pos];
}
-INLINE void
+void
set_entity_overwrites (entity *ent, int pos, entity *overwritten) {
assert(ent);
assert(is_class_type(get_entity_owner(ent)));
}
}
-INLINE void
+void
add_entity_overwrittenby (entity *ent, entity *overwrites) {
assert(ent);
assert(is_class_type(get_entity_owner(ent)));
add_entity_overwrites(overwrites, ent);
}
-INLINE int
+int
get_entity_n_overwrittenby (entity *ent) {
assert(ent);
assert(is_class_type(get_entity_owner(ent)));
return -1;
}
-INLINE entity *
+entity *
get_entity_overwrittenby (entity *ent, int pos) {
assert(ent);
assert(is_class_type(get_entity_owner(ent)));
return ent->overwrittenby[pos];
}
-INLINE void
+void
set_entity_overwrittenby (entity *ent, int pos, entity *overwrites) {
assert(ent);
assert(is_class_type(get_entity_owner(ent)));
ent->link = l;
}
-INLINE ir_graph *
+ir_graph *
get_entity_irg(entity *ent) {
assert (ent);
assert (is_method_type(ent->type));
return ent->irg;
}
-INLINE void
+void
set_entity_irg(entity *ent, ir_graph *irg) {
assert (ent && ent->type);
/* Wie kann man die Referenz auf einen IRG löschen, z.B. wenn die
}
-INLINE bool entity_visited(entity *ent) {
+bool entity_visited(entity *ent) {
return get_entity_visited(ent) >= type_visited;
}
-INLINE bool entity_not_visited(entity *ent) {
+bool entity_not_visited(entity *ent) {
return get_entity_visited(ent) < type_visited;
}
/* Need two routines because I want to assert the result. */
-static INLINE entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent) {
+static entity *resolve_ent_polymorphy2 (type *dynamic_class, entity* static_ent) {
int i, n_overwrittenby;
entity *res = NULL;
#if 1 || DEBUG_libfirm
-INLINE int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */
+int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */
#define X(a) case a: printf(#a); break
void dump_entity (entity *ent) {
void set_entity_owner (entity *ent, type *owner);
/** Asserts if the type owner is neither a compound type or an array */
-INLINE void assert_legal_owner_of_ent(type *owner);
+void assert_legal_owner_of_ent(type *owner);
/** Returns the type of an entity. */
type *get_entity_type (entity *ent);
/** Outputs a unique number for this entity if libfirm is compiled for
debugging, (configure with --enable-debug) else returns 0. */
-INLINE long get_entity_nr(entity *ent);
+long get_entity_nr(entity *ent);
/** Returns the entitys visited count. */
unsigned long get_entity_visited(entity *ent);
entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent);
-/*******************************************************************/
-/** Debug aides **/
-/*******************************************************************/
+/*-----------------------------------------------------------------*/
+/* Debug aides */
+/*-----------------------------------------------------------------*/
/** Write the entity and all its attributes to stdout.
}
unsigned long type_visited;
-INLINE void set_master_type_visited(unsigned long val) { type_visited = val; }
-INLINE unsigned long get_master_type_visited() { return type_visited; }
-INLINE void inc_master_type_visited() { type_visited++; }
+void set_master_type_visited(unsigned long val) { type_visited = val; }
+unsigned long get_master_type_visited() { return type_visited; }
+void inc_master_type_visited() { type_visited++; }
-INLINE type *
+type *
new_type(tp_op *type_op, ir_mode *mode, ident* name) {
type *res;
int node_size ;
}
/* Outputs a unique number for this node */
-INLINE long
+long
get_type_nr(type *tp) {
assert(tp);
#ifdef DEBUG_libfirm
/*******************************************************************/
/* create a new class type */
-INLINE type *new_type_class (ident *name) {
+type *new_type_class (ident *name) {
type *res;
res = new_type(type_class, NULL, name);
return res;
}
-INLINE void free_class_entities(type *clss) {
+void free_class_entities(type *clss) {
int i;
assert(clss && (clss->type_op == type_class));
for (i = get_class_n_members(clss)-1; i >= 0; --i)
free_entity(get_class_member(clss, i));
}
-INLINE void free_class_attrs(type *clss) {
+void free_class_attrs(type *clss) {
assert(clss && (clss->type_op == type_class));
DEL_ARR_F(clss->attr.ca.members);
DEL_ARR_F(clss->attr.ca.subtypes);
return "peculiarity_existent";
}
-INLINE peculiarity get_class_peculiarity (type *clss) {
+peculiarity get_class_peculiarity (type *clss) {
assert(clss && (clss->type_op == type_class));
return clss->attr.ca.peculiarity;
}
-INLINE void set_class_peculiarity (type *clss, peculiarity pec) {
+void set_class_peculiarity (type *clss, peculiarity pec) {
assert(clss && (clss->type_op == type_class));
assert(pec != peculiarity_inherited); /* There is no inheritance of types in libFirm. */
clss->attr.ca.peculiarity = pec;
/*******************************************************************/
/* create a new type struct */
-INLINE type *new_type_struct (ident *name) {
+type *new_type_struct (ident *name) {
type *res;
res = new_type(type_struct, NULL, name);
res->attr.sa.members = NEW_ARR_F (entity *, 1);
set_type_dbg_info(res, db);
return res;
}
-INLINE void free_struct_entities (type *strct) {
+void free_struct_entities (type *strct) {
int i;
assert(strct && (strct->type_op == type_struct));
for (i = get_struct_n_members(strct)-1; i >= 0; --i)
free_entity(get_struct_member(strct, i));
}
-INLINE void free_struct_attrs (type *strct) {
+void free_struct_attrs (type *strct) {
assert(strct && (strct->type_op == type_struct));
DEL_ARR_F(strct->attr.sa.members);
}
/* Create a new method type.
N_param is the number of parameters, n_res the number of results. */
-INLINE type *new_type_method (ident *name, int n_param, int n_res) {
+type *new_type_method (ident *name, int n_param, int n_res) {
type *res;
res = new_type(type_method, mode_P_mach, name);
res->state = layout_fixed;
return res;
}
-INLINE void free_method_entities(type *method) {
+void free_method_entities(type *method) {
assert(method && (method->type_op == type_method));
}
/* Attention: also frees entities in value parameter subtypes! */
-INLINE void free_method_attrs(type *method) {
+void free_method_attrs(type *method) {
assert(method && (method->type_op == type_method));
free(method->attr.ma.param_type);
free(method->attr.ma.res_type);
/*******************************************************************/
/* create a new type uni */
-INLINE type *new_type_union (ident *name) {
+type *new_type_union (ident *name) {
type *res;
res = new_type(type_union, NULL, name);
/*res->attr.ua.unioned_type = (type **) xmalloc (sizeof (type *) * n_types);
set_type_dbg_info(res, db);
return res;
}
-INLINE void free_union_entities (type *uni) {
+void free_union_entities (type *uni) {
int i;
assert(uni && (uni->type_op == type_union));
for (i = get_union_n_members(uni)-1; i >= 0; --i)
free_entity(get_union_member(uni, i));
}
-INLINE void free_union_attrs (type *uni) {
+void free_union_attrs (type *uni) {
assert(uni && (uni->type_op == type_union));
DEL_ARR_F(uni->attr.ua.members);
}
/* create a new type array -- set dimension sizes independently */
-INLINE type *new_type_array (ident *name, int n_dimensions,
+type *new_type_array (ident *name, int n_dimensions,
type *element_type) {
type *res;
int i;
return res;
}
-INLINE void free_array_entities (type *array) {
+void free_array_entities (type *array) {
assert(array && (array->type_op == type_array));
}
-INLINE void free_array_attrs (type *array) {
+void free_array_attrs (type *array) {
assert(array && (array->type_op == type_array));
free(array->attr.aa.lower_bound);
free(array->attr.aa.upper_bound);
return array->attr.aa.n_dimensions;
}
-INLINE void
+void
set_array_bounds (type *array, int dimension, ir_node * lower_bound,
ir_node * upper_bound) {
assert(array && (array->type_op == type_array));
new_Const(mode_Iu, new_tarval_from_long (upper_bound, mode_Iu )));
current_ir_graph = rem;
}
-INLINE void
+void
set_array_lower_bound (type *array, int dimension, ir_node * lower_bound) {
assert(array && (array->type_op == type_array));
assert(lower_bound && "lower_bound node may not be NULL.");
new_Const(mode_Iu, new_tarval_from_long (lower_bound, mode_Iu)));
current_ir_graph = rem;
}
-INLINE void
+void
set_array_upper_bound (type *array, int dimension, ir_node * upper_bound) {
assert(array && (array->type_op == type_array));
assert(upper_bound && "upper_bound node may not be NULL.");
/*******************************************************************/
/* create a new type enumeration -- set the enumerators independently */
-INLINE type *new_type_enumeration (ident *name, int n_enums) {
+type *new_type_enumeration (ident *name, int n_enums) {
type *res;
res = new_type(type_enumeration, NULL, name);
res->attr.ea.n_enums = n_enums;
return res;
}
-INLINE void free_enumeration_entities(type *enumeration) {
+void free_enumeration_entities(type *enumeration) {
assert(enumeration && (enumeration->type_op == type_enumeration));
}
-INLINE void free_enumeration_attrs(type *enumeration) {
+void free_enumeration_attrs(type *enumeration) {
assert(enumeration && (enumeration->type_op == type_enumeration));
free(enumeration->attr.ea.enumer);
free(enumeration->attr.ea.enum_nameid);
/*******************************************************************/
/* Create a new type pointer */
-INLINE type *new_type_pointer_mode (ident *name, type *points_to, ir_mode *ptr_mode) {
+type *new_type_pointer_mode (ident *name, type *points_to, ir_mode *ptr_mode) {
type *res;
assert(mode_is_reference(ptr_mode));
res = new_type(type_pointer, ptr_mode, name);
set_type_dbg_info(res, db);
return res;
}
-INLINE void free_pointer_entities (type *pointer) {
+void free_pointer_entities (type *pointer) {
assert(pointer && (pointer->type_op == type_pointer));
}
-INLINE void free_pointer_attrs (type *pointer) {
+void free_pointer_attrs (type *pointer) {
assert(pointer && (pointer->type_op == type_pointer));
}
/* manipulate fields of type_pointer */
/*******************************************************************/
/* create a new type primitive */
-INLINE type *new_type_primitive (ident *name, ir_mode *mode) {
+type *new_type_primitive (ident *name, ir_mode *mode) {
type *res;
/* @@@ assert( mode_is_data(mode) && (!mode_is_reference(mode))); */
res = new_type(type_primitive, mode, name);
set_type_dbg_info(res, db);
return res;
}
-INLINE void free_primitive_entities (type *primitive) {
+void free_primitive_entities (type *primitive) {
assert(primitive && (primitive->type_op == type_primitive));
}
-INLINE void free_primitive_attrs (type *primitive) {
+void free_primitive_attrs (type *primitive) {
assert(primitive && (primitive->type_op == type_primitive));
}
/*******************************************************************/
-INLINE int is_atomic_type(type *tp) {
+int is_atomic_type(type *tp) {
assert(tp && tp->kind == k_type);
return (is_primitive_type(tp) || is_pointer_type(tp) ||
is_enumeration_type(tp));
}
-INLINE int is_compound_type(type *tp) {
+int is_compound_type(type *tp) {
assert(tp && tp->kind == k_type);
return (is_class_type(tp) || is_struct_type(tp) ||
is_array_type(tp) || is_union_type(tp));
#if 1 || DEBUG_libfirm
-INLINE int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */
+int dump_node_opcode(FILE *F, ir_node *n); /* from irdump.c */
void dump_type (type *tp) {
int i;
/* The peculiarity of the class. The enumeration peculiarity is defined
in entity.h */
-INLINE peculiarity get_class_peculiarity (type *clss);
-INLINE void set_class_peculiarity (type *clss, peculiarity pec);
+peculiarity get_class_peculiarity (type *clss);
+void set_class_peculiarity (type *clss, peculiarity pec);
/* Set and get a class' dfn --
@todo This is an undocumented field, subject to change! */
* debugging, (configure with --enable-debug) else returns the address
* of the type cast to long.
*/
-INLINE long get_type_nr(type *tp);
+long get_type_nr(type *tp);
/*******************************************************************/
/** Debug aides **/
/* Define to disable assertion checking. */
/* #undef NDEBUG */
-/* Define to value "inline" for gcc inlineing. */
-/* #undef USE_GCC_INLINE */
+/* Remove to disable inlining */
+#define USE_INLINING 1
/* Define to 1 if you have the <alloca.h> header file. */
/* #undef HAVE_ALLOCA_H */
first (like Motorola and SPARC, unlike Intel and VAX). */
/* #undef WORDS_BIGENDIAN */
-#define INLINE __inline
+/* Define to 1 if Firm statistics are activated */
+/* #undef FIRM_STATISTICS */
+
+/* Define the right volatile token */
+/* #undef volatile */
+
+/* Define the right inline token */
+#define inline __inline
+
+/* Define the right const token */
+/* #undef const */
+
+#ifdef USE_INLINING
+#define INLINE inline
+#else
+#define INLINE
+#endif
#define snprintf _snprintf
#define strcasecmp stricmp
projects / libfirm / commitdiff