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 /** Extended Basic Block */
  98 typedef struct ir_extblk            ir_extblk;
  99 /** @ingroup execfreq
 100  * Execution Frequency Analysis Results */
 101 typedef struct ir_exec_freq         ir_exec_freq;
 102 /** @ingroup ir_cdep
 103  * Control Dependence Analysis Results */
 104 typedef struct ir_cdep              ir_cdep;
 105 /** @ingroup be
 106  * Target Architecture specific node operations */
 107 typedef struct arch_irn_ops_t       arch_irn_ops_t;
 108 /** A graph transformation pass */
 109 typedef struct ir_graph_pass_t      ir_graph_pass_t;
 110 /** A whole program transformation pass */
 111 typedef struct ir_prog_pass_t       ir_prog_pass_t;
 112
 113 /** A graph pass manager */
 114 typedef struct ir_graph_pass_manager_t      ir_graph_pass_manager_t;
 115 /** A program pass manager */
 116 typedef struct ir_prog_pass_manager_t       ir_prog_pass_manager_t;
 117
 118 /** @ingroup ir_initializer
 119  * Initializer (for entities) */
 120 typedef union  ir_initializer_t     ir_initializer_t;
 121
 122 /**
 123  * @ingroup irgwalk
 124  * type for graph-walk callbacks */
 125 typedef void irg_walk_func(ir_node *, void *);
 126
 127 /**
 128  * @ingroup Switch
 129  * A switch table mapping integer numbers to proj-numbers of a Switch-node.
 130  * Entries map a continuous range of integer numbers to a proj-number.
 131  * There must never be two different entries matching the same integer number.
 132  */
 133 typedef struct ir_switch_table  ir_switch_table;
 134
 135 /**
 136  * @ingroup ir_cons
 137  * This function is called, whenever a local variable is used before definition
 138  *
 139  * @param irg       the IR graph on which this happens
 140  * @param mode      the mode of the local var
 141  * @param pos       position chosen be the frontend for this variable (n_loc)
 142  *
 143  * @return a firm node of mode @p mode that initializes the var at position pos
 144  *
 145  * @note
 146  *      Do not return NULL!
 147  *      If this function is not set, FIRM will create a const node with tarval BAD.
 148  *      Use set_irg_loc_description()/get_irg_loc_description() to assign additional
 149  *      informations to local variables.
 150  */
 151 typedef ir_node *uninitialized_local_variable_func_t(ir_graph *irg, ir_mode *mode, int pos);
 152
 153 #ifdef __cplusplus
 154 # define ENUM_BITSET(type) \
 155         extern "C++" { \
 156                 static inline type operator ~  (type  a)         { return     (type)~(int)a;           } \
 157                 static inline type operator &  (type  a, type b) { return     (type)((int)a & (int)b); } \
 158                 static inline type operator &= (type& a, type b) { return a = (type)((int)a & (int)b); } \
 159                 static inline type operator ^  (type  a, type b) { return     (type)((int)a ^ (int)b); } \
 160                 static inline type operator ^= (type& a, type b) { return a = (type)((int)a ^ (int)b); } \
 161                 static inline type operator |  (type  a, type b) { return     (type)((int)a | (int)b); } \
 162                 static inline type operator |= (type& a, type b) { return a = (type)((int)a | (int)b); } \
 163         }
 164 #else
 165 /** Marks an enum type as bitset enum. That is the enumeration values will
 166  * probably be combined to form a (bit)set of flags.
 167  * When compiling for C++ this macro will define the ~, &, &=, ^, ^=, | and |=
 168  * operators for the enum values. */
 169 # define ENUM_BITSET(type)
 170 #endif
 171
 172 #ifdef __cplusplus
 173 # define ENUM_COUNTABLE(type) \
 174         extern "C++" { \
 175                 static inline type operator ++(type& a) { return a = (type)((int)a + 1); } \
 176                 static inline type operator --(type& a) { return a = (type)((int)a - 1); } \
 177         }
 178 #else
 179 /** Marks an enum type as countable enum. The enumeration values will be a
 180  * linear sequence of numbers which can be iterated through by incrementing
 181  * by 1.
 182  * When compiling for C++ this macro will define the ++ and -- operators. */
 183 # define ENUM_COUNTABLE(type)
 184 #endif
 185
 186 /**
 187  * @ingroup ir_node
 188  * Relations for comparing numbers
 189  */
 190 typedef enum ir_relation {
 191         ir_relation_false              = 0,       /**< always false */
 192         ir_relation_equal              = 1u << 0, /**< equal */
 193         ir_relation_less               = 1u << 1, /**< less */
 194         ir_relation_greater            = 1u << 2, /**< greater */
 195         ir_relation_unordered          = 1u << 3, /**< unordered */
 196         ir_relation_less_equal         = ir_relation_equal|ir_relation_less,    /**< less or equal */
 197         ir_relation_greater_equal      = ir_relation_equal|ir_relation_greater, /**< greater or equal */
 198         ir_relation_less_greater       = ir_relation_less|ir_relation_greater,  /** less or greater ('not equal' for integer numbers) */
 199         ir_relation_less_equal_greater = ir_relation_equal|ir_relation_less|ir_relation_greater, /**< less equal or greater ('not unordered') */
 200         ir_relation_unordered_equal    = ir_relation_unordered|ir_relation_equal, /**< unordered or equal */
 201         ir_relation_unordered_less     = ir_relation_unordered|ir_relation_less,  /**< unordered or less */
 202         ir_relation_unordered_less_equal = ir_relation_unordered|ir_relation_less|ir_relation_equal, /**< unordered, less or equal */
 203         ir_relation_unordered_greater    = ir_relation_unordered|ir_relation_greater, /**< unordered or greater */
 204         ir_relation_unordered_greater_equal = ir_relation_unordered|ir_relation_greater|ir_relation_equal, /**< unordered, greater or equal */
 205         ir_relation_unordered_less_greater  = ir_relation_unordered|ir_relation_less|ir_relation_greater, /**< unordered, less or greater ('not equal' for floatingpoint numbers) */
 206         ir_relation_true                    = ir_relation_equal|ir_relation_less|ir_relation_greater|ir_relation_unordered, /**< always true */
 207 } ir_relation;
 208 ENUM_BITSET(ir_relation)
 209
 210 /**
 211  * @ingroup ir_node
 212  * constrained flags for memory operations.
 213  */
 214 typedef enum ir_cons_flags {
 215         cons_none             = 0,        /**< No constrains. */
 216         cons_volatile         = 1U << 0,  /**< Memory operation is volatile. */
 217         cons_unaligned        = 1U << 1,  /**< Memory operation is unaligned. */
 218         cons_floats           = 1U << 2,  /**< Memory operation can float. */
 219         cons_throws_exception = 1U << 3,  /**< fragile op throws exception (and
 220                                                produces X_regular and X_except
 221                                                values) */
 222 } ir_cons_flags;
 223 ENUM_BITSET(ir_cons_flags)
 224
 225 /**
 226  * @ingroup ir_node
 227  * pinned states.
 228  */
 229 typedef enum op_pin_state {
 230         op_pin_state_floats = 0,    /**< Nodes of this opcode can be placed in any basic block. */
 231         op_pin_state_pinned = 1,    /**< Nodes must remain in this basic block. */
 232         op_pin_state_exc_pinned,    /**< Node must be remain in this basic block if it can throw an
 233                                          exception, else can float. Used internally. */
 234         op_pin_state_mem_pinned     /**< Node must be remain in this basic block if it can throw an
 235                                          exception or uses memory, else can float. Used internally. */
 236 } op_pin_state;
 237
 238 /**
 239  * @ingroup Cond
 240  * A type to express conditional jump predictions.
 241  */
 242 typedef enum cond_jmp_predicate {
 243         COND_JMP_PRED_NONE,        /**< No jump prediction. Default. */
 244         COND_JMP_PRED_TRUE,        /**< The True case is predicted. */
 245         COND_JMP_PRED_FALSE        /**< The False case is predicted. */
 246 } cond_jmp_predicate;
 247
 248 /**
 249  * @ingroup method_type
 250  * Additional method type properties:
 251  * Tell about special properties of a method type. Some
 252  * of these may be discovered by analyses.
 253  */
 254 typedef enum mtp_additional_properties {
 255         mtp_no_property            = 0x00000000, /**< no additional properties, default */
 256         mtp_property_const         = 0x00000001, /**< This method did not access memory and calculates
 257                                                       its return values solely from its parameters.
 258                                                       The only observable effect of a const function must be its
 259                                                       return value. So they must not exhibit infinite loops or wait
 260                                                       for user input. The return value must not depend on any
 261                                                       global variables/state.
 262                                                       GCC: __attribute__((const)). */
 263         mtp_property_pure          = 0x00000002, /**< This method did NOT write to memory and calculates
 264                                                       its return values solely from its parameters and
 265                                                       the memory they points to (or global vars).
 266                                                       The only observable effect of a const function must be its
 267                                                       return value. So they must not exhibit infinite loops or wait
 268                                                       for user input.
 269                                                       GCC: __attribute__((pure)). */
 270         mtp_property_noreturn      = 0x00000004, /**< This method did not return due to an aborting system
 271                                                       call.
 272                                                       GCC: __attribute__((noreturn)). */
 273         mtp_property_nothrow       = 0x00000008, /**< This method cannot throw an exception.
 274                                                       GCC: __attribute__((nothrow)). */
 275         mtp_property_naked         = 0x00000010, /**< This method is naked.
 276                                                       GCC: __attribute__((naked)). */
 277         mtp_property_malloc        = 0x00000020, /**< This method returns newly allocate memory.
 278                                                       GCC: __attribute__((malloc)). */
 279         mtp_property_returns_twice = 0x00000040, /**< This method can return more than one (typically setjmp).
 280                                                   GCC: __attribute__((returns_twice)). */
 281         mtp_property_intrinsic     = 0x00000080, /**< This method is intrinsic. It is expected that
 282                                                       a lowering phase will remove all calls to it. */
 283         mtp_property_runtime       = 0x00000100, /**< This method represents a runtime routine. */
 284         mtp_property_private       = 0x00000200, /**< All method invocations are known, the backend is free to
 285                                                       optimize the call in any possible way. */
 286         mtp_property_has_loop      = 0x00000400, /**< Set, if this method contains one possible endless loop. */
 287         mtp_property_inherited     = (1<<31)     /**< Internal. Used only in irg's, means property is
 288                                                       inherited from type. */
 289 } mtp_additional_properties;
 290 ENUM_BITSET(mtp_additional_properties)
 291
 292 /**
 293  * @ingroup SymConst
 294  * This enum names the different kinds of symbolic Constants represented by
 295  * SymConst.  The content of the attribute symconst_symbol depends on this tag.
 296  * Use the proper access routine after testing this flag.
 297  */
 298 typedef enum symconst_kind {
 299         symconst_type_size,   /**< The SymConst is the size of the given type.
 300                                    symconst_symbol is type *. */
 301         symconst_type_align,  /**< The SymConst is the alignment of the given type.
 302                                    symconst_symbol is type *. */
 303         symconst_addr_ent,    /**< The SymConst is a symbolic pointer to be filled in
 304                                    by the linker.  The pointer is represented by an entity.
 305                                    symconst_symbol is entity *. */
 306         symconst_ofs_ent,     /**< The SymConst is the offset of its entity in the entities
 307                                    owner type. */
 308         symconst_enum_const   /**< The SymConst is a enumeration constant of an
 309                                    enumeration type. */
 310 } symconst_kind;
 311
 312 /**
 313  * @ingroup SymConst
 314  * SymConst attribute.
 315  *
 316  *  This union contains the symbolic information represented by the node.
 317  *  @ingroup SymConst
 318  */
 319 typedef union symconst_symbol {
 320         ir_type       *type_p;    /**< The type of a SymConst. */
 321         ir_entity     *entity_p;  /**< The entity of a SymConst. */
 322         ir_enum_const *enum_p;    /**< The enumeration constant of a SymConst. */
 323 } symconst_symbol;
 324
 325 /**
 326  * @ingroup Alloc
 327  * The allocation place.
 328  */
 329 typedef enum ir_where_alloc {
 330         stack_alloc,          /**< Alloc allocates the object on the stack. */
 331         heap_alloc            /**< Alloc allocates the object on the heap. */
 332 } ir_where_alloc;
 333
 334 /** A input/output constraint attribute.
 335  * @ingroup ASM
 336  */
 337 typedef struct ir_asm_constraint {
 338         unsigned       pos;           /**< The inputs/output position for this constraint. */
 339         ident          *constraint;   /**< The constraint for this input/output. */
 340         ir_mode        *mode;         /**< The mode of the constraint. */
 341 } ir_asm_constraint;
 342
 343 /** Supported libFirm builtins.
 344  * @ingroup Builtin
 345  */
 346 typedef enum ir_builtin_kind {
 347         ir_bk_trap,                   /**< GCC __builtin_trap(): insert trap */
 348         ir_bk_debugbreak,             /**< MS __debugbreak(): insert debug break */
 349         ir_bk_return_address,         /**< GCC __builtin_return_address() */
 350         ir_bk_frame_address,          /**< GCC __builtin_frame_address() */
 351         ir_bk_prefetch,               /**< GCC __builtin_prefetch() */
 352         ir_bk_ffs,                    /**< GCC __builtin_ffs(): find first (least) significant 1 bit */
 353         ir_bk_clz,                    /**< GCC __builtin_clz(): count leading zero */
 354         ir_bk_ctz,                    /**< GCC __builtin_ctz(): count trailing zero */
 355         ir_bk_popcount,               /**< GCC __builtin_popcount(): population count */
 356         ir_bk_parity,                 /**< GCC __builtin_parity(): parity */
 357         ir_bk_bswap,                  /**< byte swap */
 358         ir_bk_inport,                 /**< in port */
 359         ir_bk_outport,                /**< out port */
 360         ir_bk_inner_trampoline,       /**< address of a trampoline for GCC inner functions */
 361         ir_bk_last = ir_bk_inner_trampoline,
 362 } ir_builtin_kind;
 363
 364 /**
 365  * Possible return values of value_classify().
 366  */
 367 typedef enum ir_value_classify_sign {
 368         value_classified_unknown  = 0,   /**< could not classify */
 369         value_classified_positive = 1,   /**< value is positive, i.e. >= 0 */
 370         value_classified_negative = -1   /**< value is negative, i.e. <= 0 if
 371                                               no signed zero exists or < 0 else */
 372 } ir_value_classify_sign;
 373
 374 /**
 375  * This enumeration flags the volatility of entities and Loads/Stores.
 376  */
 377 typedef enum {
 378         volatility_non_volatile,    /**< The entity is not volatile. Default. */
 379         volatility_is_volatile      /**< The entity is volatile. */
 380 } ir_volatility;
 381
 382 /**
 383  * This enumeration flags the align of Loads/Stores.
 384  */
 385 typedef enum {
 386         align_is_aligned = 0, /**< The entity is aligned. Default */
 387         align_non_aligned,    /**< The entity is not aligned. */
 388 } ir_align;
 389
 390 #include "end.h"
 391
 392 #endif