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