void set_irg_{attr name} (ir_graph *irg, {attr type} {attr}); */
int
-(is_ir_graph)(void *thing) {
+(is_ir_graph)(const void *thing) {
return __is_ir_graph(thing);
}
}
ir_node *
-(get_irg_start_block)(ir_graph *irg) {
+(get_irg_start_block)(const ir_graph *irg) {
return __get_irg_start_block(irg);
}
}
ir_node *
-(get_irg_start)(ir_graph *irg) {
+(get_irg_start)(const ir_graph *irg) {
return __get_irg_start(irg);
}
}
ir_node *
-(get_irg_end_block)(ir_graph *irg) {
+(get_irg_end_block)(const ir_graph *irg) {
return __get_irg_end_block(irg);
}
}
ir_node *
-(get_irg_end)(ir_graph *irg) {
+(get_irg_end)(const ir_graph *irg) {
return __get_irg_end(irg);
}
}
ir_node *
-(get_irg_end_reg)(ir_graph *irg) {
+(get_irg_end_reg)(const ir_graph *irg) {
return __get_irg_end_reg(irg);
}
}
ir_node *
-(get_irg_end_except)(ir_graph *irg) {
+(get_irg_end_except)(const ir_graph *irg) {
return __get_irg_end_except(irg);
}
}
ir_node *
-(get_irg_cstore)(ir_graph *irg) {
+(get_irg_cstore)(const ir_graph *irg) {
return __get_irg_cstore(irg);
}
}
ir_node *
-(get_irg_frame)(ir_graph *irg) {
+(get_irg_frame)(const ir_graph *irg) {
return __get_irg_frame(irg);
}
}
ir_node *
-(get_irg_globals)(ir_graph *irg) {
+(get_irg_globals)(const ir_graph *irg) {
return __get_irg_globals(irg);
}
}
ir_node *
-(get_irg_initial_mem)(ir_graph *irg)
-{
+(get_irg_initial_mem)(const ir_graph *irg) {
return __get_irg_initial_mem(irg);
}
}
ir_node *
-(get_irg_args)(ir_graph *irg) {
+(get_irg_args)(const ir_graph *irg) {
return __get_irg_args(irg);
}
}
ir_node *
-(get_irg_bad)(ir_graph *irg) {
+(get_irg_bad)(const ir_graph *irg) {
return __get_irg_bad(irg);
}
*/
ir_node *
-(get_irg_current_block)(ir_graph *irg) {
+(get_irg_current_block)(const ir_graph *irg) {
return __get_irg_current_block(irg);
}
}
entity *
-(get_irg_entity)(ir_graph *irg) {
- return __get_irg_ent(irg);
+(get_irg_entity)(const ir_graph *irg) {
+ return __get_irg_entity(irg);
}
void
(set_irg_entity)(ir_graph *irg, entity *ent) {
- __set_irg_ent(irg, ent);
+ __set_irg_entity(irg, ent);
}
type *
-(get_irg_frame_type)(ir_graph *irg) {
+(get_irg_frame_type)(const ir_graph *irg) {
return __get_irg_frame_type(irg);
}
/* To test for a frame type */
int
-is_frame_type(type *ftp) {
+is_frame_type(const type *ftp) {
int i;
if (is_class_type(ftp)) {
for (i = 0; i < get_irp_n_irgs(); i++) {
- type *frame_tp = get_irg_frame_type(get_irp_irg(i));
+ const type *frame_tp = get_irg_frame_type(get_irp_irg(i));
if (ftp == frame_tp) return true;
}
}
/* Returns the obstack associated with the graph. */
struct obstack *
-(get_irg_obstack)(ir_graph *irg) {
+(get_irg_obstack)(const ir_graph *irg) {
return __get_irg_obstack(irg);
}
}
irg_phase_state
-(get_irg_phase_state)(ir_graph *irg) {
+(get_irg_phase_state)(const ir_graph *irg) {
return __get_irg_phase_state(irg);
}
}
op_pin_state
-(get_irg_pinned)(ir_graph *irg) {
+(get_irg_pinned)(const ir_graph *irg) {
return __get_irg_pinned(irg);
}
irg_outs_state
-(get_irg_outs_state)(ir_graph *irg) {
+(get_irg_outs_state)(const ir_graph *irg) {
return __get_irg_outs_state(irg);
}
}
irg_dom_state
-(get_irg_dom_state)(ir_graph *irg) {
+(get_irg_dom_state)(const ir_graph *irg) {
return __get_irg_dom_state(irg);
}
}
irg_loopinfo_state
-(get_irg_loopinfo_state)(ir_graph *irg) {
+(get_irg_loopinfo_state)(const ir_graph *irg) {
return __get_irg_loopinfo_state(irg);
}
}
irg_callee_info_state
-(get_irg_callee_info_state)(ir_graph *irg) {
+(get_irg_callee_info_state)(const ir_graph *irg) {
return __get_irg_callee_info_state(irg);
}
}
irg_inline_property
-(get_irg_inline_property)(ir_graph *irg) {
+(get_irg_inline_property)(const ir_graph *irg) {
return __get_irg_inline_property(irg);
}
}
void *
-(get_irg_link)(ir_graph *irg) {
+(get_irg_link)(const ir_graph *irg) {
return __get_irg_link(irg);
}
static int max_irg_visited = 0;
unsigned long
-(get_irg_visited)(ir_graph *irg) {
+(get_irg_visited)(const ir_graph *irg) {
return __get_irg_visited(irg);
}
}
unsigned long
-(get_irg_block_visited)(ir_graph *irg) {
+(get_irg_block_visited)(const ir_graph *irg) {
return __get_irg_block_visited(irg);
}
* @return
* true if the thing is a ir graph, else false
*/
-int is_ir_graph(void *thing);
+int is_ir_graph(const void *thing);
/* #define get_irg_entity get_irg_ent */
/* #define set_irg_entity set_irg_ent */
-entity *get_irg_entity (ir_graph *irg);
+entity *get_irg_entity (const ir_graph *irg);
void set_irg_entity (ir_graph *irg, entity *ent);
-type *get_irg_frame_type (ir_graph *irg);
+type *get_irg_frame_type (const ir_graph *irg);
void set_irg_frame_type (ir_graph *irg, type *ftp);
/* To test for a frame type. O(#irgs) if ftp is class type. */
-int is_frame_type (type *ftp);
+int is_frame_type (const type *ftp);
-ir_node *get_irg_start_block (ir_graph *irg);
+ir_node *get_irg_start_block (const ir_graph *irg);
void set_irg_start_block (ir_graph *irg, ir_node *node);
-ir_node *get_irg_start (ir_graph *irg);
+ir_node *get_irg_start (const ir_graph *irg);
void set_irg_start (ir_graph *irg, ir_node *node);
-ir_node *get_irg_end_block (ir_graph *irg);
+ir_node *get_irg_end_block (const ir_graph *irg);
void set_irg_end_block (ir_graph *irg, ir_node *node);
-ir_node *get_irg_end (ir_graph *irg);
+ir_node *get_irg_end (const ir_graph *irg);
void set_irg_end (ir_graph *irg, ir_node *node);
/* The fields end_reg and end_except contain the end nodes of the
interprocedural view. If the view is not constructed they contain
the nomal end node. */
-ir_node *get_irg_end_reg (ir_graph *irg);
+ir_node *get_irg_end_reg (const ir_graph *irg);
void set_irg_end_reg (ir_graph *irg, ir_node *node);
-ir_node *get_irg_end_except (ir_graph *irg);
+ir_node *get_irg_end_except (const ir_graph *irg);
void set_irg_end_except (ir_graph *irg, ir_node *node);
/* @@@ oblivious, no more supported. */
-ir_node *get_irg_cstore (ir_graph *irg);
+ir_node *get_irg_cstore (const ir_graph *irg);
void set_irg_cstore (ir_graph *irg, ir_node *node);
/* end oblivious */
/** Returns the node that represents the frame pointer. */
-ir_node *get_irg_frame (ir_graph *irg);
+ir_node *get_irg_frame (const ir_graph *irg);
/** Sets the node that represents the frame pointer. */
void set_irg_frame (ir_graph *irg, ir_node *node);
/** Returns the node that represents the global pointer. */
-ir_node *get_irg_globals (ir_graph *irg);
+ir_node *get_irg_globals (const ir_graph *irg);
/** Sets the node that represents the global pointer. */
void set_irg_globals (ir_graph *irg, ir_node *node);
/** Returns the node that represents the initial memory. */
-ir_node *get_irg_initial_mem (ir_graph *irg);
+ir_node *get_irg_initial_mem (const ir_graph *irg);
/** Sets the node that represents the initial memory. */
void set_irg_initial_mem (ir_graph *irg, ir_node *node);
/** Returns the node that represents the argument pointer. */
-ir_node *get_irg_args (ir_graph *irg);
+ir_node *get_irg_args (const ir_graph *irg);
/** Sets the node that represents the argument pointer. */
void set_irg_args (ir_graph *irg, ir_node *node);
/** Returns the current block of a graph. */
-ir_node *get_irg_current_block (ir_graph *irg);
+ir_node *get_irg_current_block (const ir_graph *irg);
/** Sets the current block of a graph. */
void set_irg_current_block (ir_graph *irg, ir_node *node);
-/* Use new_Bad() instead!! */
-ir_node *get_irg_bad (ir_graph *irg);
+/** Returns the Bad node. Use new_Bad() instead!! */
+ir_node *get_irg_bad (const ir_graph *irg);
void set_irg_bad (ir_graph *irg, ir_node *node);
/** Returns the number of value numbers of a graph. */
phase_low
} irg_phase_state;
-irg_phase_state get_irg_phase_state (ir_graph *irg);
+irg_phase_state get_irg_phase_state (const ir_graph *irg);
void set_irg_phase_low(ir_graph *irg);
/** state: op_pin_state_pinned
invalid block, i.e., the block is not a dominator of all the uses of
the node.
The enum op_pin_state is defined in irop.h. */
-op_pin_state get_irg_pinned (ir_graph *irg);
+op_pin_state get_irg_pinned (const ir_graph *irg);
/** state: outs_state
Outs are the back edges or def-use edges.
outs_consistent,
outs_inconsistent
} irg_outs_state;
-irg_outs_state get_irg_outs_state(ir_graph *irg);
+irg_outs_state get_irg_outs_state(const ir_graph *irg);
void set_irg_outs_inconsistent(ir_graph *irg);
/** state: dom_state
but the graph has been changed since. Using the access routines is possible,
obtained information may be incorrect. */
typedef enum {
- dom_none,
- dom_consistent,
- dom_inconsistent
+ dom_none, /**< doms are not computed, no memory is allocated */
+ dom_consistent, /**< dominator information is computed and correct */
+ dom_inconsistent /**< dominator information is computed but the graph has been changed since */
} irg_dom_state;
-irg_dom_state get_irg_dom_state(ir_graph *irg);
+irg_dom_state get_irg_dom_state(const ir_graph *irg);
void set_irg_dom_inconsistent(ir_graph *irg);
/** state: loopinfo_state
loopinfo_cf_ip_inconsistent = loopinfo_constructed | loopinfo_cf | loopinfo_inter
} irg_loopinfo_state;
-irg_loopinfo_state get_irg_loopinfo_state(ir_graph *irg);
+irg_loopinfo_state get_irg_loopinfo_state(const ir_graph *irg);
void set_irg_loopinfo_state(ir_graph *irg, irg_loopinfo_state s);
-/* Sets the loopinformation state to the appropriate inconsistent state.
+/** Sets the loopinformation state to the appropriate inconsistent state.
If state is 'none' does not change. */
void set_irg_loopinfo_inconsistent(ir_graph *irg);
/** state: callee_information_state
* Call nodes contain a list of possible callees. This list must be
- * computed by an anlysis.
+ * computed by an analysis.
*
* It's strange that this state is administered on irg basis, as the
* information must be computed for the whole program, or not?
irg_callee_info_consistent,
irg_callee_info_inconsistent
} irg_callee_info_state;
-irg_callee_info_state get_irg_callee_info_state(ir_graph *irg);
+irg_callee_info_state get_irg_callee_info_state(const ir_graph *irg);
void set_irg_callee_info_state(ir_graph *irg, irg_callee_info_state s);
/** property:
irg_inline_recomended, /**< The graph should be inlined. */
irg_inline_forced /**< The graph must be inlined. */
} irg_inline_property;
-irg_inline_property get_irg_inline_property(ir_graph *irg);
+
+/** Returns the inline property of a graph. */
+irg_inline_property get_irg_inline_property(const ir_graph *irg);
+/** Sets the inline property of a graph. */
void set_irg_inline_property(ir_graph *irg, irg_inline_property s);
/** A void * field to link arbritary information to the node. */
void set_irg_link (ir_graph *irg, void *thing);
-void *get_irg_link (ir_graph *irg);
+void *get_irg_link (const ir_graph *irg);
/* increments visited by one */
void inc_irg_visited (ir_graph *irg);
-unsigned long get_irg_visited (ir_graph *irg);
+unsigned long get_irg_visited (const ir_graph *irg);
void set_irg_visited (ir_graph *irg, unsigned long i);
unsigned long get_max_irg_visited (void);
void set_max_irg_visited (int val);
/* increments block_visited by one */
void inc_irg_block_visited (ir_graph *irg);
-unsigned long get_irg_block_visited (ir_graph *irg);
+unsigned long get_irg_block_visited (const ir_graph *irg);
void set_irg_block_visited (ir_graph *irg, unsigned long i);
/* is irg a pseudo graph for analysis? */
#include "obst.h"
#include "pset.h"
+#include "type_t.h"
#define FRAME_TP_SUFFIX "frame_tp"
#endif
};
+/**
+ * Initializes the graph construction module
+ */
void init_irgraph(void);
/** Make a rudimentary ir graph for the constant code.
/**
* Set the op_pin_state_pinned state of a graph.
*
- * @irg the IR graph
- * @p new pin state
+ * @param irg the IR graph
+ * @param p new pin state
*/
INLINE void
set_irg_pinned (ir_graph *irg, op_pin_state p);
/** Returns the obstack associated with the graph. */
-struct obstack *get_irg_obstack(ir_graph *irg);
+struct obstack *get_irg_obstack(const ir_graph *irg);
/**
* Returns true if the node n is allocated on the storage of graph irg.
}
static INLINE int
-__is_ir_graph(void *thing) {
+__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(ir_graph *irg)
-{
+__get_irg_start_block(const ir_graph *irg) {
return irg->start_block;
}
static INLINE void
-__set_irg_start_block(ir_graph *irg, ir_node *node)
-{
+__set_irg_start_block(ir_graph *irg, ir_node *node) {
irg->start_block = node;
}
static INLINE ir_node *
-__get_irg_start(ir_graph *irg)
-{
+__get_irg_start(const ir_graph *irg) {
return irg->start;
}
static INLINE void
-__set_irg_start(ir_graph *irg, ir_node *node)
-{
+__set_irg_start(ir_graph *irg, ir_node *node) {
irg->start = node;
}
static INLINE ir_node *
-__get_irg_end_block(ir_graph *irg)
-{
+__get_irg_end_block(const ir_graph *irg) {
return irg->end_block;
}
static INLINE void
-__set_irg_end_block(ir_graph *irg, ir_node *node)
-{
+__set_irg_end_block(ir_graph *irg, ir_node *node) {
irg->end_block = node;
}
static INLINE ir_node *
-__get_irg_end(ir_graph *irg)
-{
+__get_irg_end(const ir_graph *irg) {
return irg->end;
}
static INLINE void
-__set_irg_end(ir_graph *irg, ir_node *node)
-{
+__set_irg_end(ir_graph *irg, ir_node *node) {
irg->end = node;
}
static INLINE ir_node *
-__get_irg_end_reg(ir_graph *irg) {
+__get_irg_end_reg(const ir_graph *irg) {
return irg->end_reg;
}
static INLINE ir_node *
-__get_irg_end_except (ir_graph *irg) {
+__get_irg_end_except (const ir_graph *irg) {
return irg->end_except;
}
static INLINE ir_node *
-__get_irg_cstore(ir_graph *irg)
-{
+__get_irg_cstore(const ir_graph *irg) {
return irg->cstore;
}
static INLINE void
-__set_irg_cstore(ir_graph *irg, ir_node *node)
-{
+__set_irg_cstore(ir_graph *irg, ir_node *node) {
irg->cstore = node;
}
static INLINE ir_node *
-__get_irg_frame(ir_graph *irg)
-{
+__get_irg_frame(const ir_graph *irg) {
return irg->frame;
}
static INLINE void
-__set_irg_frame(ir_graph *irg, ir_node *node)
-{
+__set_irg_frame(ir_graph *irg, ir_node *node) {
irg->frame = node;
}
static INLINE ir_node *
-__get_irg_globals(ir_graph *irg)
-{
+__get_irg_globals(const ir_graph *irg) {
return irg->globals;
}
static INLINE void
-__set_irg_globals(ir_graph *irg, ir_node *node)
-{
+__set_irg_globals(ir_graph *irg, ir_node *node) {
irg->globals = node;
}
static INLINE ir_node *
-__get_irg_initial_mem(ir_graph *irg)
-{
+__get_irg_initial_mem(const ir_graph *irg) {
return irg->initial_mem;
}
static INLINE void
-__set_irg_initial_mem(ir_graph *irg, ir_node *node)
-{
+__set_irg_initial_mem(ir_graph *irg, ir_node *node) {
irg->initial_mem = node;
}
static INLINE ir_node *
-__get_irg_args(ir_graph *irg)
-{
+__get_irg_args(const ir_graph *irg) {
return irg->args;
}
static INLINE void
-__set_irg_args(ir_graph *irg, ir_node *node)
-{
+__set_irg_args(ir_graph *irg, ir_node *node) {
irg->args = node;
}
static INLINE ir_node *
-__get_irg_bad(ir_graph *irg)
-{
+__get_irg_bad(const ir_graph *irg) {
return irg->bad;
}
static INLINE void
-__set_irg_bad(ir_graph *irg, ir_node *node)
-{
+__set_irg_bad(ir_graph *irg, ir_node *node) {
irg->bad = node;
}
static INLINE ir_node *
-__get_irg_current_block(ir_graph *irg)
-{
+__get_irg_current_block(const ir_graph *irg) {
return irg->current_block;
}
static INLINE void
-__set_irg_current_block(ir_graph *irg, ir_node *node)
-{
+__set_irg_current_block(ir_graph *irg, ir_node *node) {
irg->current_block = node;
}
static INLINE entity *
-__get_irg_ent(ir_graph *irg)
-{
+__get_irg_entity(const ir_graph *irg) {
assert(irg && irg->ent);
return irg->ent;
}
static INLINE void
-__set_irg_ent(ir_graph *irg, entity *ent)
-{
+__set_irg_entity(ir_graph *irg, entity *ent) {
irg->ent = ent;
}
static INLINE type *
-__get_irg_frame_type(ir_graph *irg)
-{
+__get_irg_frame_type(const ir_graph *irg) {
assert(irg && irg->frame_type);
return irg->frame_type;
}
static INLINE void
-__set_irg_frame_type(ir_graph *irg, type *ftp)
-{
+__set_irg_frame_type(ir_graph *irg, type *ftp) {
assert(is_class_type(ftp));
irg->frame_type = ftp;
}
static INLINE struct obstack *
-__get_irg_obstack(ir_graph *irg) {
+__get_irg_obstack(const ir_graph *irg) {
return irg->obst;
}
static INLINE irg_phase_state
-__get_irg_phase_state(ir_graph *irg) {
+__get_irg_phase_state(const ir_graph *irg) {
return irg->phase_state;
}
}
static INLINE op_pin_state
-__get_irg_pinned(ir_graph *irg) {
+__get_irg_pinned(const ir_graph *irg) {
return irg->op_pin_state_pinned;
}
static INLINE irg_outs_state
-__get_irg_outs_state(ir_graph *irg) {
+__get_irg_outs_state(const ir_graph *irg) {
return irg->outs_state;
}
}
static INLINE irg_dom_state
-__get_irg_dom_state(ir_graph *irg) {
+__get_irg_dom_state(const ir_graph *irg) {
return irg->dom_state;
}
}
static INLINE irg_loopinfo_state
-__get_irg_loopinfo_state(ir_graph *irg) {
+__get_irg_loopinfo_state(const ir_graph *irg) {
return irg->loopinfo_state;
}
}
static INLINE irg_callee_info_state
-__get_irg_callee_info_state(ir_graph *irg) {
+__get_irg_callee_info_state(const ir_graph *irg) {
return irg->callee_info_state;
}
}
static INLINE irg_inline_property
-__get_irg_inline_property(ir_graph *irg) {
+__get_irg_inline_property(const ir_graph *irg) {
return irg->inline_property;
}
}
static INLINE void *
-__get_irg_link(ir_graph *irg) {
+__get_irg_link(const ir_graph *irg) {
return irg->link;
}
static INLINE unsigned long
-__get_irg_visited(ir_graph *irg)
-{
+__get_irg_visited(const ir_graph *irg) {
return irg->visited;
}
static INLINE unsigned long
-__get_irg_block_visited(ir_graph *irg)
-{
+__get_irg_block_visited(const ir_graph *irg) {
return irg->block_visited;
}
static INLINE void
-__set_irg_block_visited(ir_graph *irg, unsigned long visited)
-{
+__set_irg_block_visited(ir_graph *irg, unsigned long visited) {
irg->block_visited = visited;
}
static INLINE void
-__inc_irg_block_visited(ir_graph *irg)
-{
+__inc_irg_block_visited(ir_graph *irg) {
++irg->block_visited;
}
#define set_irg_bad(irg, node) __set_irg_bad(irg, node)
#define get_irg_current_block(irg) __get_irg_current_block(irg)
#define set_irg_current_block(irg, node) __set_irg_current_block(irg, node)
-#define get_irg_entity(irg) __get_irg_ent(irg)
-#define set_irg_entity(irg, ent) __set_irg_ent(irg, ent)
+#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)