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 /**
  31  * @page visited_counters Visited Counters
  32  * A visited counter is an alternative to a visited flag for elements of a
  33  * graph datastructure.
  34  * A visited counter is an integer number added to the elements of a graph.
  35  * There is also a global reference number for the whole datastructure. It is
  36  * now possible to mark nodes by setting their visited counter to the global
  37  * reference counter. Testing is done by comparing with the global reference
  38  * counter.
  39  * The advantage to simple boolean flag variables is that you can clear all
  40  * element marks by increasing the global reference counter and don't need to
  41  * visit the whole structure.
  42  * This makes it more efficient when you only visit/mark a small amount of
  43  * nodes in the graph.
  44  */
  45
  46 /** Type for visited counters
  47  * @see visited_counters */
  48 typedef unsigned long ir_visited_t;
  49 /** A label in the code (usually attached to a @ref Block) */
  50 typedef unsigned long ir_label_t;
  51
  52 /** @ingroup dbg_info
  53  * Source Reference */
  54 typedef struct dbg_info             dbg_info;
  55 /** @ingroup dbg_info
  56  * Source Type Reference */
  57 typedef struct type_dbg_info        type_dbg_info;
  58 /** @ingroup ir_ident
  59  * Identifier */
  60 typedef struct ident                ident;
  61 /** @ingroup ir_node
  62  * Procedure Graph Node */
  63 typedef struct ir_node              ir_node;
  64 /** @ingroup ir_op
  65  * Node Opcode */
  66 typedef struct ir_op                ir_op;
  67 /** @ingroup ir_mode
  68  * SSA Value mode */
  69 typedef struct ir_mode              ir_mode;
  70 /** @ingroup iredges
  71  * Dynamic Reverse Edge */
  72 typedef struct ir_edge_t            ir_edge_t;
  73 /** @ingroup ir_heights
  74  * Computed graph Heights */
  75 typedef struct ir_heights_t         ir_heights_t;
  76 /** @ingroup ir_tarval
  77  * Target Machine Value */
  78 typedef struct ir_tarval            ir_tarval;
  79 /** @ingroup enumeration_type
  80  * Enumeration constant */
  81 typedef struct ir_enum_const        ir_enum_const;
  82 /** @ingroup ir_type
  83  * Type */
  84 typedef struct ir_type              ir_type;
  85 /** @ingroup ir_graph
  86  * Procedure Grpah */
  87 typedef struct ir_graph             ir_graph;
  88 /** @ingroup ir_prog
  89  * Program */
  90 typedef struct ir_prog              ir_prog;
  91 /** @ingroup ir_loop
  92  * Loop */
  93 typedef struct ir_loop              ir_loop;
  94 /** @ingroup ir_entity
  95  * Entity */
  96 typedef struct ir_entity            ir_entity;
  97 /** @ingroup ir_cdep
  98  * Control Dependence Analysis Results */
  99 typedef struct ir_cdep              ir_cdep;
 100 /** @ingroup be
 101  * Target Architecture specific node operations */
 102 typedef struct arch_irn_ops_t       arch_irn_ops_t;
 103 /** A graph transformation pass */
 104 typedef struct ir_graph_pass_t      ir_graph_pass_t;
 105 /** A whole program transformation pass */
 106 typedef struct ir_prog_pass_t       ir_prog_pass_t;
 107
 108 /** A graph pass manager */
 109 typedef struct ir_graph_pass_manager_t      ir_graph_pass_manager_t;
 110 /** A program pass manager */
 111 typedef struct ir_prog_pass_manager_t       ir_prog_pass_manager_t;
 112
 113 /** @ingroup ir_initializer
 114  * Initializer (for entities) */
 115 typedef union  ir_initializer_t     ir_initializer_t;
 116
 117 /**
 118  * @ingroup irgwalk
 119  * type for graph-walk callbacks */
 120 typedef void irg_walk_func(ir_node *, void *);
 121
 122 /**
 123  * @ingroup Switch
 124  * A switch table mapping integer numbers to proj-numbers of a Switch-node.
 125  * Entries map a continuous range of integer numbers to a proj-number.
 126  * There must never be two different entries matching the same integer number.
 127  */
 128 typedef struct ir_switch_table  ir_switch_table;
 129
 130 /**
 131  * @ingroup ir_cons
 132  * This function is called, whenever a local variable is used before definition
 133  *
 134  * @param irg       the IR graph on which this happens
 135  * @param mode      the mode of the local var
 136  * @param pos       position chosen be the frontend for this variable (n_loc)
 137  *
 138  * @return a firm node of mode @p mode that initializes the var at position pos
 139  *
 140  * @note
 141  *      Do not return NULL!
 142  *      If this function is not set, FIRM will create an Unknown node.
 143  *      Use set_irg_loc_description()/get_irg_loc_description() to assign additional
 144  *      informations to local variables.
 145  */
 146 typedef ir_node *uninitialized_local_variable_func_t(ir_graph *irg, ir_mode *mode, int pos);
 147
 148 #ifdef __cplusplus
 149 # define ENUM_BITSET(type) \
 150         extern "C++" { \
 151                 static inline type operator ~  (type  a)         { return     (type)~(int)a;           } \
 152                 static inline type operator &  (type  a, type b) { return     (type)((int)a & (int)b); } \
 153                 static inline type operator &= (type& a, type b) { return a = (type)((int)a & (int)b); } \
 154                 static inline type operator ^  (type  a, type b) { return     (type)((int)a ^ (int)b); } \
 155                 static inline type operator ^= (type& a, type b) { return a = (type)((int)a ^ (int)b); } \
 156                 static inline type operator |  (type  a, type b) { return     (type)((int)a | (int)b); } \
 157                 static inline type operator |= (type& a, type b) { return a = (type)((int)a | (int)b); } \
 158         }
 159 #else
 160 /** Marks an enum type as bitset enum. That is the enumeration values will
 161  * probably be combined to form a (bit)set of flags.
 162  * When compiling for C++ this macro will define the ~, &, &=, ^, ^=, | and |=
 163  * operators for the enum values. */
 164 # define ENUM_BITSET(type)
 165 #endif
 166
 167 #ifdef __cplusplus
 168 # define ENUM_COUNTABLE(type) \
 169         extern "C++" { \
 170                 static inline type operator ++(type& a) { return a = (type)((int)a + 1); } \
 171                 static inline type operator --(type& a) { return a = (type)((int)a - 1); } \
 172         }
 173 #else
 174 /** Marks an enum type as countable enum. The enumeration values will be a
 175  * linear sequence of numbers which can be iterated through by incrementing
 176  * by 1.
 177  * When compiling for C++ this macro will define the ++ and -- operators. */
 178 # define ENUM_COUNTABLE(type)
 179 #endif
 180
 181 /**
 182  * @ingroup ir_node
 183  * Relations for comparing numbers
 184  */
 185 typedef enum ir_relation {
 186         ir_relation_false              = 0,       /**< always false */
 187         ir_relation_equal              = 1u << 0, /**< equal */
 188         ir_relation_less               = 1u << 1, /**< less */
 189         ir_relation_greater            = 1u << 2, /**< greater */
 190         ir_relation_unordered          = 1u << 3, /**< unordered */
 191         ir_relation_less_equal         = ir_relation_equal|ir_relation_less,    /**< less or equal */
 192         ir_relation_greater_equal      = ir_relation_equal|ir_relation_greater, /**< greater or equal */
 193         ir_relation_less_greater       = ir_relation_less|ir_relation_greater,  /** less or greater ('not equal' for integer numbers) */
 194         ir_relation_less_equal_greater = ir_relation_equal|ir_relation_less|ir_relation_greater, /**< less equal or greater ('not unordered') */
 195         ir_relation_unordered_equal    = ir_relation_unordered|ir_relation_equal, /**< unordered or equal */
 196         ir_relation_unordered_less     = ir_relation_unordered|ir_relation_less,  /**< unordered or less */
 197         ir_relation_unordered_less_equal = ir_relation_unordered|ir_relation_less|ir_relation_equal, /**< unordered, less or equal */
 198         ir_relation_unordered_greater    = ir_relation_unordered|ir_relation_greater, /**< unordered or greater */
 199         ir_relation_unordered_greater_equal = ir_relation_unordered|ir_relation_greater|ir_relation_equal, /**< unordered, greater or equal */
 200         ir_relation_unordered_less_greater  = ir_relation_unordered|ir_relation_less|ir_relation_greater, /**< unordered, less or greater ('not equal' for floatingpoint numbers) */
 201         ir_relation_true                    = ir_relation_equal|ir_relation_less|ir_relation_greater|ir_relation_unordered, /**< always true */
 202 } ir_relation;
 203 ENUM_BITSET(ir_relation)
 204
 205 /**
 206  * @ingroup ir_node
 207  * constrained flags for memory operations.
 208  */
 209 typedef enum ir_cons_flags {
 210         cons_none             = 0,        /**< No constrains. */
 211         cons_volatile         = 1U << 0,  /**< Memory operation is volatile. */
 212         cons_unaligned        = 1U << 1,  /**< Memory operation is unaligned. */
 213         cons_floats           = 1U << 2,  /**< Memory operation can float. */
 214         cons_throws_exception = 1U << 3,  /**< fragile op throws exception (and
 215                                                produces X_regular and X_except
 216                                                values) */
 217 } ir_cons_flags;
 218 ENUM_BITSET(ir_cons_flags)
 219
 220 /**
 221  * @ingroup ir_node
 222  * pinned states.
 223  */
 224 typedef enum op_pin_state {
 225         op_pin_state_floats = 0,    /**< Nodes of this opcode can be placed in any basic block. */
 226         op_pin_state_pinned = 1,    /**< Nodes must remain in this basic block. */
 227         op_pin_state_exc_pinned,    /**< Node must be remain in this basic block if it can throw an
 228                                          exception, else can float. Used internally. */
 229         op_pin_state_mem_pinned     /**< Node must be remain in this basic block if it can throw an
 230                                          exception or uses memory, else can float. Used internally. */
 231 } op_pin_state;
 232
 233 /**
 234  * @ingroup Cond
 235  * A type to express conditional jump predictions.
 236  */
 237 typedef enum cond_jmp_predicate {
 238         COND_JMP_PRED_NONE,        /**< No jump prediction. Default. */
 239         COND_JMP_PRED_TRUE,        /**< The True case is predicted. */
 240         COND_JMP_PRED_FALSE        /**< The False case is predicted. */
 241 } cond_jmp_predicate;
 242
 243 /**
 244  * @ingroup method_type
 245  * Additional method type properties:
 246  * Tell about special properties of a method type. Some
 247  * of these may be discovered by analyses.
 248  */
 249 typedef enum mtp_additional_properties {
 250         /** no additional properties */
 251         mtp_no_property                 = 0,
 252         /** This method did not access memory and calculates its return values
 253          * solely from its parameters. The only observable effect of a const
 254          * function must be its return value. So they must not exhibit infinite
 255          * loops or wait for user input. The return value must not depend on any
 256          * global variables/state.
 257          * GCC: __attribute__((const)). */
 258         mtp_property_const              = 1u << 0,
 259         /** This method did NOT write to memory and calculates its return values
 260          * solely from its parameters and the memory they points to (or global
 261          * vars). The only observable effect of a const function must be its return
 262          * value. So they must not exhibit infinite loops or wait for user input.
 263          * GCC: __attribute__((pure)). */
 264         mtp_property_pure               = 1u << 1,
 265         /** This method did not return due to an aborting system call.
 266          * GCC: __attribute__((noreturn)). */
 267         mtp_property_noreturn           = 1u << 2,
 268         /** This method cannot throw an exception. GCC: __attribute__((nothrow)). */
 269         mtp_property_nothrow            = 1u << 3,
 270         /** This method is naked. GCC: __attribute__((naked)). */
 271         mtp_property_naked              = 1u << 4,
 272         /** This method returns newly allocate memory.
 273          * GCC: __attribute__((malloc)). */
 274         mtp_property_malloc             = 1u << 5,
 275         /** This method can return more than one (typically setjmp).
 276          * GCC: __attribute__((returns_twice)). */
 277         mtp_property_returns_twice      = 1u << 6,
 278         /** This method is intrinsic. It is expected that a lowering phase will
 279          * remove all calls to it. */
 280         mtp_property_intrinsic          = 1u << 7,
 281         /** This method represents a runtime routine. */
 282         mtp_property_runtime            = 1u << 8,
 283         /** All method invocations are known, the backend is free to optimize the
 284          * call in any possible way. */
 285         mtp_property_private            = 1u << 9,
 286         /** Set, if this method contains one possibly endless loop. */
 287         mtp_property_has_loop           = 1u << 10,
 288         /** try to always inline this function, even if it seems nonprofitable */
 289         mtp_property_always_inline      = 1u << 11,
 290         /** the function should not be inlined */
 291         mtp_property_noinline           = 1u << 12,
 292         /** the programmer recommends to inline the function */
 293         mtp_property_inline_recommended = 1u << 13,
 294         /** stupid hack used by opt_funccall... */
 295         mtp_temporary                   = 1u << 31,
 296 } mtp_additional_properties;
 297 ENUM_BITSET(mtp_additional_properties)
 298
 299 /**
 300  * @ingroup SymConst
 301  * This enum names the different kinds of symbolic Constants represented by
 302  * SymConst.  The content of the attribute symconst_symbol depends on this tag.
 303  * Use the proper access routine after testing this flag.
 304  */
 305 typedef enum symconst_kind {
 306         symconst_type_size,   /**< The SymConst is the size of the given type.
 307                                    symconst_symbol is type *. */
 308         symconst_type_align,  /**< The SymConst is the alignment of the given type.
 309                                    symconst_symbol is type *. */
 310         symconst_addr_ent,    /**< The SymConst is a symbolic pointer to be filled in
 311                                    by the linker.  The pointer is represented by an entity.
 312                                    symconst_symbol is entity *. */
 313         symconst_ofs_ent,     /**< The SymConst is the offset of its entity in the entities
 314                                    owner type. */
 315         symconst_enum_const   /**< The SymConst is a enumeration constant of an
 316                                    enumeration type. */
 317 } symconst_kind;
 318
 319 /**
 320  * @ingroup SymConst
 321  * SymConst attribute.
 322  *
 323  *  This union contains the symbolic information represented by the node.
 324  *  @ingroup SymConst
 325  */
 326 typedef union symconst_symbol {
 327         ir_type       *type_p;    /**< The type of a SymConst. */
 328         ir_entity     *entity_p;  /**< The entity of a SymConst. */
 329         ir_enum_const *enum_p;    /**< The enumeration constant of a SymConst. */
 330 } symconst_symbol;
 331
 332 /**
 333  * @ingroup Alloc
 334  * The allocation place.
 335  */
 336 typedef enum ir_where_alloc {
 337         stack_alloc,          /**< Alloc allocates the object on the stack. */
 338         heap_alloc            /**< Alloc allocates the object on the heap. */
 339 } ir_where_alloc;
 340
 341 /** A input/output constraint attribute.
 342  * @ingroup ASM
 343  */
 344 typedef struct ir_asm_constraint {
 345         unsigned       pos;           /**< The inputs/output position for this constraint. */
 346         ident          *constraint;   /**< The constraint for this input/output. */
 347         ir_mode        *mode;         /**< The mode of the constraint. */
 348 } ir_asm_constraint;
 349
 350 /** Supported libFirm builtins.
 351  * @ingroup Builtin
 352  */
 353 typedef enum ir_builtin_kind {
 354         ir_bk_trap,                   /**< GCC __builtin_trap(): insert trap */
 355         ir_bk_debugbreak,             /**< MS __debugbreak(): insert debug break */
 356         ir_bk_return_address,         /**< GCC __builtin_return_address() */
 357         ir_bk_frame_address,          /**< GCC __builtin_frame_address() */
 358         ir_bk_prefetch,               /**< GCC __builtin_prefetch() */
 359         ir_bk_ffs,                    /**< GCC __builtin_ffs(): find first (least) significant 1 bit */
 360         ir_bk_clz,                    /**< GCC __builtin_clz(): count leading zero */
 361         ir_bk_ctz,                    /**< GCC __builtin_ctz(): count trailing zero */
 362         ir_bk_popcount,               /**< GCC __builtin_popcount(): population count */
 363         ir_bk_parity,                 /**< GCC __builtin_parity(): parity */
 364         ir_bk_bswap,                  /**< byte swap */
 365         ir_bk_inport,                 /**< in port */
 366         ir_bk_outport,                /**< out port */
 367         ir_bk_inner_trampoline,       /**< address of a trampoline for GCC inner functions */
 368         ir_bk_last = ir_bk_inner_trampoline,
 369 } ir_builtin_kind;
 370
 371 /**
 372  * Possible return values of value_classify().
 373  */
 374 typedef enum ir_value_classify_sign {
 375         value_classified_unknown  = 0,   /**< could not classify */
 376         value_classified_positive = 1,   /**< value is positive, i.e. >= 0 */
 377         value_classified_negative = -1   /**< value is negative, i.e. <= 0 if
 378                                               no signed zero exists or < 0 else */
 379 } ir_value_classify_sign;
 380
 381 /**
 382  * This enumeration flags the volatility of entities and Loads/Stores.
 383  */
 384 typedef enum {
 385         volatility_non_volatile,    /**< The entity is not volatile. Default. */
 386         volatility_is_volatile      /**< The entity is volatile. */
 387 } ir_volatility;
 388
 389 /**
 390  * This enumeration flags the align of Loads/Stores.
 391  */
 392 typedef enum {
 393         align_is_aligned = 0, /**< The entity is aligned. Default */
 394         align_non_aligned,    /**< The entity is not aligned. */
 395 } ir_align;
 396
 397 #include "end.h"
 398
 399 #endif