Dump calling conventions for entities

[libfirm] / ir / ir / irgraph.h

diff --git a/ir/ir/irgraph.h b/ir/ir/irgraph.h
index 4ea428a..60671c9 100644 (file)
--- a/ir/ir/irgraph.h
+++ b/ir/ir/irgraph.h
@@ -200,8 +200,6 @@ void     set_irg_entity (ir_graph *irg, entity *ent);
 
 type    *get_irg_frame_type (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 (const type *ftp);
 
 ir_node *get_irg_start_block (const ir_graph *irg);
 void     set_irg_start_block (ir_graph *irg, ir_node *node);
@@ -429,6 +427,64 @@ 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);