give Bad nodes a mode

[libfirm] / include / libfirm / firm_types.h

diff --git a/include/libfirm/firm_types.h b/include/libfirm/firm_types.h
index 64512fd..3c3657e 100644 (file)
--- a/include/libfirm/firm_types.h
+++ b/include/libfirm/firm_types.h
@@ -93,7 +93,7 @@ typedef const ir_node *ir_node_cnst_ptr;
 typedef ir_node *uninitialized_local_variable_func_t(ir_graph *irg, ir_mode *mode, int pos);
 
 #ifdef __cplusplus
-#      define ENUM_BITSET(type) \
+# define ENUM_BITSET(type) \
        extern "C++" { \
                static inline type operator ~  (type  a)         { return     (type)~(int)a;           } \
                static inline type operator &  (type  a, type b) { return     (type)((int)a & (int)b); } \
@@ -104,19 +104,42 @@ typedef ir_node *uninitialized_local_variable_func_t(ir_graph *irg, ir_mode *mod
                static inline type operator |= (type& a, type b) { return a = (type)((int)a | (int)b); } \
        }
 #else
-#      define ENUM_BITSET(type)
+# define ENUM_BITSET(type)
 #endif
 
 #ifdef __cplusplus
-#      define ENUM_COUNTABLE(type) \
+# define ENUM_COUNTABLE(type) \
        extern "C++" { \
                static inline type operator ++(type& a) { return a = (type)((int)a + 1); } \
                static inline type operator --(type& a) { return a = (type)((int)a - 1); } \
        }
 #else
-#      define ENUM_COUNTABLE(type)
+# define ENUM_COUNTABLE(type)
 #endif
 
+/**
+ * Relations for comparing numbers
+ */
+typedef enum ir_relation {
+       ir_relation_false              = 0,       /**< always false */
+       ir_relation_equal              = 1u << 0, /**< equal */
+       ir_relation_less               = 1u << 1, /**< less */
+       ir_relation_greater            = 1u << 2, /**< greater */
+       ir_relation_unordered          = 1u << 3, /**< unordered */
+       ir_relation_less_equal         = ir_relation_equal|ir_relation_less,    /**< less or equal */
+       ir_relation_greater_equal      = ir_relation_equal|ir_relation_greater, /**< greater or equal */
+       ir_relation_less_greater       = ir_relation_less|ir_relation_greater,  /** less or greater ('not equal' for integer numbers) */
+       ir_relation_less_equal_greater = ir_relation_equal|ir_relation_less|ir_relation_greater, /**< less equal or greater ('not unordered') */
+       ir_relation_unordered_equal    = ir_relation_unordered|ir_relation_equal, /**< unordered or equal */
+       ir_relation_unordered_less     = ir_relation_unordered|ir_relation_less,  /**< unorderedor less */
+       ir_relation_unordered_less_equal = ir_relation_unordered|ir_relation_less|ir_relation_equal, /**< unordered, less or equal */
+       ir_relation_unordered_greater    = ir_relation_unordered|ir_relation_greater, /**< unordered or greater */
+       ir_relation_unordered_greater_equal = ir_relation_unordered|ir_relation_greater|ir_relation_equal, /**< unordered, greater or equal */
+       ir_relation_unordered_less_greater  = ir_relation_unordered|ir_relation_less|ir_relation_greater, /**< unordered, less or greater ('not equal' for floatingpoint numbers) */
+       ir_relation_true                    = ir_relation_equal|ir_relation_less|ir_relation_greater|ir_relation_unordered, /**< always true */
+} ir_relation;
+ENUM_BITSET(ir_relation)
+
 /**
  * constrained flags for memory operations.
  */
@@ -156,10 +179,17 @@ typedef enum mtp_additional_properties {
        mtp_no_property            = 0x00000000, /**< no additional properties, default */
        mtp_property_const         = 0x00000001, /**< This method did not access memory and calculates
                                                      its return values solely from its parameters.
+                                                     The only observable effect of a const function must be its
+                                                     return value. So they must not exhibit infinite loops or wait
+                                                     for user input. The return value must not depend on any
+                                                     global variables/state.
                                                      GCC: __attribute__((const)). */
        mtp_property_pure          = 0x00000002, /**< This method did NOT write to memory and calculates
                                                      its return values solely from its parameters and
                                                      the memory they points to (or global vars).
+                                                     The only observable effect of a const function must be its
+                                                     return value. So they must not exhibit infinite loops or wait
+                                                     for user input.
                                                      GCC: __attribute__((pure)). */
        mtp_property_noreturn      = 0x00000004, /**< This method did not return due to an aborting system
                                                      call.
@@ -263,6 +293,22 @@ typedef enum ir_value_classify_sign {
                                              no signed zero exists or < 0 else */
 } ir_value_classify_sign;
 
+/**
+ * This enumeration flags the volatility of entities and Loads/Stores.
+ */
+typedef enum {
+       volatility_non_volatile,    /**< The entity is not volatile. Default. */
+       volatility_is_volatile      /**< The entity is volatile. */
+} ir_volatility;
+
+/**
+ * This enumeration flags the align of Loads/Stores.
+ */
+typedef enum {
+       align_is_aligned = 0, /**< The entity is aligned. Default */
+       align_non_aligned,    /**< The entity is not aligned. */
+} ir_align;
+
 #include "end.h"
 
 #endif