+/** property:
+ * Tells how to handle an ir graph in inlineing.
+ */
+typedef enum {
+ irg_inline_any, /**< No restriction on inlineing. Default. */
+ irg_inline_forbidden, /**< The graph may not be inlined. */
+ irg_inline_recomended, /**< The graph should be inlined. */
+ irg_inline_forced /**< The graph must be inlined. */
+} irg_inline_property;
+
+/** 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);
+
+/** additional graph flags:
+ * Tell about special properties of a graph. Some
+ * of these may be discovered by analyses.
+ */
+typedef enum {
+ irg_const_function = 0x00000001, /**< This graph did not access memory and calculates
+ its return values solely from its parameters.
+ GCC: __attribute__((const)). */
+ irg_pure_function = 0x00000002, /**< This graph did NOT write to memory and calculates
+ its return values solely form its parameters and
+ the memory they points to (or global vars).
+ GCC: __attribute__((pure)). */
+ irg_noreturn_function = 0x00000004, /**< This graph did not return due to an aborting system
+ call.
+ GCC: __attribute__((noreturn)). */
+ irg_nothrow_function = 0x00000008, /**< This graph cannot throw an exception.
+ GCC: __attribute__((nothrow)). */
+ irg_naked_function = 0x00000010, /**< This graph is naked.
+ GCC: __attribute__((naked)). */
+ irg_malloc_function = 0x00000020 /**< This graph returns newly allocate memory.
+ GCC: __attribute__((malloc)). */
+} irg_additional_property;
+
+/** Returns the mask of the additional graph properties. */
+unsigned get_irg_additional_properties(const ir_graph *irg);
+
+/** Sets the mask of the additional graph properties. */
+void set_irg_additional_properties(ir_graph *irg, unsigned property_mask);
+
+/** Sets one additional graph property. */
+void set_irg_additional_property(ir_graph *irg, irg_additional_property flag);
+
+/**
+ * calling conventions
+ */
+typedef enum {
+ irg_cc_reg_param = 0x00000001, /**< Transmit parameters in registers, else the stack is used.
+ This flag may be set as default on some architectures. */
+ irg_cc_last_on_top = 0x00000002, /**< The last non-register parameter is transmitted on top of
+ the stack. This is equivalent to the stddecl or pascal
+ calling convention. If this flag is not set, the first
+ non-register parameter is used (cdecl calling convention) */
+ irg_cc_this_call = 0x00000004 /**< The first parameter is a this pointer and is transmitted
+ in a special way. */
+} irg_calling_convention;
+
+/** Returns the calling convention of a graph. */
+unsigned get_irg_calling_convention(const ir_graph *irg);
+
+/** Sets the calling convention of a graph. */
+void set_irg_calling_convention(ir_graph *irg, unsigned cc_mask);
+
+/** Gets the default calling convention for new constructed graphs. */
+unsigned get_firm_default_calling_convention(void);
+
+/** Sets the default calling convention for new constructed graphs. */
+void set_firm_default_calling_convention(unsigned cc_mask);
+
+/** A void * field to link arbitrary information to the node. */
+void set_irg_link (ir_graph *irg, void *thing);
+void *get_irg_link (const ir_graph *irg);
+
+/** Increments visited flag by one.
+ * @see also: get_irn_visited() get_irg_block_visited(). */
+void inc_irg_visited (ir_graph *irg);
+unsigned long get_irg_visited (const ir_graph *irg);
+void set_irg_visited (ir_graph *irg, unsigned long i);
+/** An interprocedural flag valid for all irgs.
+ * @see also: get_irn_visited() get_irg_block_visited(). */
+unsigned long get_max_irg_visited (void);
+void set_max_irg_visited (int val);
+unsigned long inc_max_irg_visited (void);
+
+/** Increments block_visited by one.
+ * @see also: get_irn_visited() get_irg_block_visited(). */
+void inc_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);
+
+/** move Proj nodes into the same block as its predecessors */
+void normalize_proj_nodes(ir_graph *irg);
+
+/** set a description for local value n */
+void set_irg_loc_description(ir_graph *irg, int n, void *description);
+
+/** get the description for local value n */
+void *get_irg_loc_description(ir_graph *irg, int n);
+
+/**
+ * Access custom graph data.
+ * The data must have been registered with
+ * register_additional_graph_data() before.
+ * @param graph The graph to get the data from.
+ * @param type The type of the data you registered.
+ * @param off The value returned by register_additional_graph_data().
+ * @return A pointer of type @p type.
+ */
+#define get_irg_data(graph,type,off) \
+ (assert(off > 0 && "Invalid graph data offset"), (type *) ((char *) (graph) - (off)))
+
+/**
+ * Get the pointer to the node some custom data belongs to.
+ * @param data The pointer to the custom data.
+ * @param off The number as returned by register_additional_graph_data().
+ * @return A pointer to the ir node the custom data belongs to.
+ */
+#define get_irg_data_base(data,off) \
+ (assert(off > 0 && "Invalid graph data offset"), (ir_graph *) ((char *) (data) + (off)))
+
+/**
+ * Request additional data to be allocated with an ir graph.
+ * @param size The size of the additional data required.
+ * @return A positive number, if the operation was successful, which
+ * must be passed to the access macro get_irg_data(), 0 if the
+ * registration failed.
+ */
+size_t register_additional_graph_data(size_t size);