nsz Git - libfirm/blob - include/libfirm/firm_types.h

   1 /*
   2  * Copyright (C) 1995-2010 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   6  * This file may be distributed and/or modified under the terms of the
   7  * GNU General Public License version 2 as published by the Free Software
   8  * Foundation and appearing in the file LICENSE.GPL included in the
   9  * packaging of this file.
  10  *
  11  * Licensees holding valid libFirm Professional Edition licenses may use
  12  * this file in accordance with the libFirm Commercial License.
  13  * Agreement provided with the Software.
  14  *
  15  * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
  16  * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief      Definition of opaque firm types
  23  * @author     Michael Beck
  24  */
  25 #ifndef FIRM_COMMON_FIRM_TYPES_H
  26 #define FIRM_COMMON_FIRM_TYPES_H
  27
  28 #include "begin.h"
  29
  30 typedef unsigned long ir_visited_t;
  31 typedef unsigned long ir_exc_region_t;
  32 typedef unsigned long ir_label_t;
  33
  34 /** @ingroup dbg_info */
  35 typedef struct dbg_info             dbg_info;
  36 /** @ingroup dbg_info */
  37 typedef struct type_dbg_info        type_dbg_info;
  38 /** @ingroup ir_ident */
  39 typedef struct ident                ident;
  40 /** @ingroup ir_node */
  41 typedef struct ir_node              ir_node;
  42 /** @ingroup ir_op */
  43 typedef struct ir_op                ir_op;
  44 /** @ingroup ir_mode */
  45 typedef struct ir_mode              ir_mode;
  46 /** @ingroup iredges */
  47 typedef struct ir_edge_t            ir_edge_t;
  48 /** @ingroup ir_heights */
  49 typedef struct ir_heights_t         ir_heights_t;
  50 /** @ingroup ir_tarval */
  51 typedef struct ir_tarval            ir_tarval;
  52 typedef struct ir_enum_const        ir_enum_const;
  53 /** @ingroup ir_type */
  54 typedef struct ir_type              ir_type;
  55 /** @ingroup ir_graph */
  56 typedef struct ir_graph             ir_graph;
  57 /** @ingroup ir_prog */
  58 typedef struct ir_prog              ir_prog;
  59 /** @ingroup ir_loop */
  60 typedef struct ir_loop              ir_loop;
  61 /** @ingroup ir_entity */
  62 typedef struct ir_entity            ir_entity;
  63 typedef struct ir_extblk            ir_extblk;
  64 /** @ingroup execfreq */
  65 typedef struct ir_exec_freq         ir_exec_freq;
  66 /** @ingroup ir_cdep */
  67 typedef struct ir_cdep              ir_cdep;
  68 /** @ingroup ir_op */
  69 typedef struct arch_irn_ops_t       arch_irn_ops_t;
  70 typedef struct ir_graph_pass_t      ir_graph_pass_t;
  71 typedef struct ir_prog_pass_t       ir_prog_pass_t;
  72
  73 typedef struct ir_graph_pass_manager_t      ir_graph_pass_manager_t;
  74 typedef struct ir_prog_pass_manager_t       ir_prog_pass_manager_t;
  75
  76 /** @ingroup ir_initializer */
  77 typedef union  ir_initializer_t     ir_initializer_t;
  78
  79 typedef void irg_walk_func(ir_node *, void *);
  80
  81 /**
  82  * A switch table mapping integer numbers to proj-numbers of a Switch-node.
  83  * Entries map a continuous range of integer numbers to a proj-number.
  84  * There must never be two different entries matching the same integer number.
  85  */
  86 typedef struct ir_switch_table  ir_switch_table;
  87
  88 /**
  89  * This function is called, whenever a local variable is used before definition
  90  *
  91  * @param irg       the IR graph on which this happens
  92  * @param mode      the mode of the local var
  93  * @param pos       position chosen be the frontend for this variable (n_loc)
  94  *
  95  * @return a firm node of mode @p mode that initializes the var at position pos
  96  *
  97  * @note
  98  *      Do not return NULL!
  99  *      If this function is not set, FIRM will create a const node with tarval BAD.
 100  *      Use set_irg_loc_description()/get_irg_loc_description() to assign additional
 101  *      informations to local variables.
 102  */
 103 typedef ir_node *uninitialized_local_variable_func_t(ir_graph *irg, ir_mode *mode, int pos);
 104
 105 #ifdef __cplusplus
 106 # define ENUM_BITSET(type) \
 107         extern "C++" { \
 108                 static inline type operator ~  (type  a)         { return     (type)~(int)a;           } \
 109                 static inline type operator &  (type  a, type b) { return     (type)((int)a & (int)b); } \
 110                 static inline type operator &= (type& a, type b) { return a = (type)((int)a & (int)b); } \
 111                 static inline type operator ^  (type  a, type b) { return     (type)((int)a ^ (int)b); } \
 112                 static inline type operator ^= (type& a, type b) { return a = (type)((int)a ^ (int)b); } \
 113                 static inline type operator |  (type  a, type b) { return     (type)((int)a | (int)b); } \
 114                 static inline type operator |= (type& a, type b) { return a = (type)((int)a | (int)b); } \
 115         }
 116 #else
 117 # define ENUM_BITSET(type)
 118 #endif
 119
 120 #ifdef __cplusplus
 121 # define ENUM_COUNTABLE(type) \
 122         extern "C++" { \
 123                 static inline type operator ++(type& a) { return a = (type)((int)a + 1); } \
 124                 static inline type operator --(type& a) { return a = (type)((int)a - 1); } \
 125         }
 126 #else
 127 # define ENUM_COUNTABLE(type)
 128 #endif
 129
 130 /**
 131  * Relations for comparing numbers
 132  */
 133 typedef enum ir_relation {
 134         ir_relation_false              = 0,       /**< always false */
 135         ir_relation_equal              = 1u << 0, /**< equal */
 136         ir_relation_less               = 1u << 1, /**< less */
 137         ir_relation_greater            = 1u << 2, /**< greater */
 138         ir_relation_unordered          = 1u << 3, /**< unordered */
 139         ir_relation_less_equal         = ir_relation_equal|ir_relation_less,    /**< less or equal */
 140         ir_relation_greater_equal      = ir_relation_equal|ir_relation_greater, /**< greater or equal */
 141         ir_relation_less_greater       = ir_relation_less|ir_relation_greater,  /** less or greater ('not equal' for integer numbers) */
 142         ir_relation_less_equal_greater = ir_relation_equal|ir_relation_less|ir_relation_greater, /**< less equal or greater ('not unordered') */
 143         ir_relation_unordered_equal    = ir_relation_unordered|ir_relation_equal, /**< unordered or equal */
 144         ir_relation_unordered_less     = ir_relation_unordered|ir_relation_less,  /**< unordered or less */
 145         ir_relation_unordered_less_equal = ir_relation_unordered|ir_relation_less|ir_relation_equal, /**< unordered, less or equal */
 146         ir_relation_unordered_greater    = ir_relation_unordered|ir_relation_greater, /**< unordered or greater */
 147         ir_relation_unordered_greater_equal = ir_relation_unordered|ir_relation_greater|ir_relation_equal, /**< unordered, greater or equal */
 148         ir_relation_unordered_less_greater  = ir_relation_unordered|ir_relation_less|ir_relation_greater, /**< unordered, less or greater ('not equal' for floatingpoint numbers) */
 149         ir_relation_true                    = ir_relation_equal|ir_relation_less|ir_relation_greater|ir_relation_unordered, /**< always true */
 150 } ir_relation;
 151 ENUM_BITSET(ir_relation)
 152
 153 /**
 154  * constrained flags for memory operations.
 155  */
 156 typedef enum ir_cons_flags {
 157         cons_none             = 0,        /**< No constrains. */
 158         cons_volatile         = 1U << 0,  /**< Memory operation is volatile. */
 159         cons_unaligned        = 1U << 1,  /**< Memory operation is unaligned. */
 160         cons_floats           = 1U << 2,  /**< Memory operation can float. */
 161         cons_throws_exception = 1U << 3,  /**< fragile op throws exception (and
 162                                                produces X_regular and X_except
 163                                                values) */
 164 } ir_cons_flags;
 165 ENUM_BITSET(ir_cons_flags)
 166
 167 /** op_pin_state_pinned states. */
 168 typedef enum op_pin_state {
 169         op_pin_state_floats = 0,    /**< Nodes of this opcode can be placed in any basic block. */
 170         op_pin_state_pinned = 1,    /**< Nodes must remain in this basic block. */
 171         op_pin_state_exc_pinned,    /**< Node must be remain in this basic block if it can throw an
 172                                          exception, else can float. Used internally. */
 173         op_pin_state_mem_pinned     /**< Node must be remain in this basic block if it can throw an
 174                                          exception or uses memory, else can float. Used internally. */
 175 } op_pin_state;
 176
 177 /**
 178  * A type to express conditional jump predictions.
 179  */
 180 typedef enum cond_jmp_predicate {
 181         COND_JMP_PRED_NONE,        /**< No jump prediction. Default. */
 182         COND_JMP_PRED_TRUE,        /**< The True case is predicted. */
 183         COND_JMP_PRED_FALSE        /**< The False case is predicted. */
 184 } cond_jmp_predicate;
 185
 186 /**
 187  * Additional method type properties:
 188  * Tell about special properties of a method type. Some
 189  * of these may be discovered by analyses.
 190  */
 191 typedef enum mtp_additional_properties {
 192         mtp_no_property            = 0x00000000, /**< no additional properties, default */
 193         mtp_property_const         = 0x00000001, /**< This method did not access memory and calculates
 194                                                       its return values solely from its parameters.
 195                                                       The only observable effect of a const function must be its
 196                                                       return value. So they must not exhibit infinite loops or wait
 197                                                       for user input. The return value must not depend on any
 198                                                       global variables/state.
 199                                                       GCC: __attribute__((const)). */
 200         mtp_property_pure          = 0x00000002, /**< This method did NOT write to memory and calculates
 201                                                       its return values solely from its parameters and
 202                                                       the memory they points to (or global vars).
 203                                                       The only observable effect of a const function must be its
 204                                                       return value. So they must not exhibit infinite loops or wait
 205                                                       for user input.
 206                                                       GCC: __attribute__((pure)). */
 207         mtp_property_noreturn      = 0x00000004, /**< This method did not return due to an aborting system
 208                                                       call.
 209                                                       GCC: __attribute__((noreturn)). */
 210         mtp_property_nothrow       = 0x00000008, /**< This method cannot throw an exception.
 211                                                       GCC: __attribute__((nothrow)). */
 212         mtp_property_naked         = 0x00000010, /**< This method is naked.
 213                                                       GCC: __attribute__((naked)). */
 214         mtp_property_malloc        = 0x00000020, /**< This method returns newly allocate memory.
 215                                                       GCC: __attribute__((malloc)). */
 216         mtp_property_returns_twice = 0x00000040, /**< This method can return more than one (typically setjmp).
 217                                                   GCC: __attribute__((returns_twice)). */
 218         mtp_property_intrinsic     = 0x00000080, /**< This method is intrinsic. It is expected that
 219                                                       a lowering phase will remove all calls to it. */
 220         mtp_property_runtime       = 0x00000100, /**< This method represents a runtime routine. */
 221         mtp_property_private       = 0x00000200, /**< All method invocations are known, the backend is free to
 222                                                       optimize the call in any possible way. */
 223         mtp_property_has_loop      = 0x00000400, /**< Set, if this method contains one possible endless loop. */
 224         mtp_property_inherited     = (1<<31)     /**< Internal. Used only in irg's, means property is
 225                                                       inherited from type. */
 226 } mtp_additional_properties;
 227 ENUM_BITSET(mtp_additional_properties)
 228
 229 /**  This enum names the different kinds of symbolic Constants represented by
 230  * SymConst.  The content of the attribute symconst_symbol depends on this tag.
 231  * Use the proper access routine after testing this flag. */
 232 typedef enum symconst_kind {
 233         symconst_type_size,   /**< The SymConst is the size of the given type.
 234                                    symconst_symbol is type *. */
 235         symconst_type_align,  /**< The SymConst is the alignment of the given type.
 236                                    symconst_symbol is type *. */
 237         symconst_addr_ent,    /**< The SymConst is a symbolic pointer to be filled in
 238                                    by the linker.  The pointer is represented by an entity.
 239                                    symconst_symbol is entity *. */
 240         symconst_ofs_ent,     /**< The SymConst is the offset of its entity in the entities
 241                                    owner type. */
 242         symconst_enum_const   /**< The SymConst is a enumeration constant of an
 243                                    enumeration type. */
 244 } symconst_kind;
 245
 246 /** SymConst attribute.
 247  *
 248  *  This union contains the symbolic information represented by the node.
 249  *  @ingroup SymConst
 250  */
 251 typedef union symconst_symbol {
 252         ir_type       *type_p;    /**< The type of a SymConst. */
 253         ir_entity     *entity_p;  /**< The entity of a SymConst. */
 254         ir_enum_const *enum_p;    /**< The enumeration constant of a SymConst. */
 255 } symconst_symbol;
 256
 257 /** The allocation place.
 258  * @ingroup Alloc
 259  */
 260 typedef enum ir_where_alloc {
 261         stack_alloc,          /**< Alloc allocates the object on the stack. */
 262         heap_alloc            /**< Alloc allocates the object on the heap. */
 263 } ir_where_alloc;
 264
 265 /** A input/output constraint attribute.
 266  * @ingroup ASM
 267  */
 268 typedef struct ir_asm_constraint {
 269         unsigned       pos;           /**< The inputs/output position for this constraint. */
 270         ident          *constraint;   /**< The constraint for this input/output. */
 271         ir_mode        *mode;         /**< The mode of the constraint. */
 272 } ir_asm_constraint;
 273
 274 /** Supported libFirm builtins.
 275  * @ingroup Builtin
 276  */
 277 typedef enum ir_builtin_kind {
 278         ir_bk_trap,                   /**< GCC __builtin_trap(): insert trap */
 279         ir_bk_debugbreak,             /**< MS __debugbreak(): insert debug break */
 280         ir_bk_return_address,         /**< GCC __builtin_return_address() */
 281         ir_bk_frame_address,          /**< GCC __builtin_frame_address() */
 282         ir_bk_prefetch,               /**< GCC __builtin_prefetch() */
 283         ir_bk_ffs,                    /**< GCC __builtin_ffs(): find first (least) significant 1 bit */
 284         ir_bk_clz,                    /**< GCC __builtin_clz(): count leading zero */
 285         ir_bk_ctz,                    /**< GCC __builtin_ctz(): count trailing zero */
 286         ir_bk_popcount,               /**< GCC __builtin_popcount(): population count */
 287         ir_bk_parity,                 /**< GCC __builtin_parity(): parity */
 288         ir_bk_bswap,                  /**< byte swap */
 289         ir_bk_inport,                 /**< in port */
 290         ir_bk_outport,                /**< out port */
 291         ir_bk_inner_trampoline,       /**< address of a trampoline for GCC inner functions */
 292         ir_bk_last = ir_bk_inner_trampoline,
 293 } ir_builtin_kind;
 294
 295 /**
 296  * Possible return values of value_classify().
 297  */
 298 typedef enum ir_value_classify_sign {
 299         value_classified_unknown  = 0,   /**< could not classify */
 300         value_classified_positive = 1,   /**< value is positive, i.e. >= 0 */
 301         value_classified_negative = -1   /**< value is negative, i.e. <= 0 if
 302                                               no signed zero exists or < 0 else */
 303 } ir_value_classify_sign;
 304
 305 /**
 306  * This enumeration flags the volatility of entities and Loads/Stores.
 307  */
 308 typedef enum {
 309         volatility_non_volatile,    /**< The entity is not volatile. Default. */
 310         volatility_is_volatile      /**< The entity is volatile. */
 311 } ir_volatility;
 312
 313 /**
 314  * This enumeration flags the align of Loads/Stores.
 315  */
 316 typedef enum {
 317         align_is_aligned = 0, /**< The entity is aligned. Default */
 318         align_non_aligned,    /**< The entity is not aligned. */
 319 } ir_align;
 320
 321 #include "end.h"
 322
 323 #endif