firm_types.h 15.5 KB
Newer Older
1
2
/*
 * This file is part of libFirm.
3
 * Copyright (C) 2012 University of Karlsruhe.
4
5
6
7
8
9
10
11
12
13
 */

/**
 * @file
 * @brief      Definition of opaque firm types
 * @author     Michael Beck
 */
#ifndef FIRM_COMMON_FIRM_TYPES_H
#define FIRM_COMMON_FIRM_TYPES_H

14
15
#include "begin.h"

16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
/**
 * @page visited_counters Visited Counters
 * A visited counter is an alternative to a visited flag for elements of a
 * graph datastructure.
 * A visited counter is an integer number added to the elements of a graph.
 * There is also a global reference number for the whole datastructure. It is
 * now possible to mark nodes by setting their visited counter to the global
 * reference counter. Testing is done by comparing with the global reference
 * counter.
 * The advantage to simple boolean flag variables is that you can clear all
 * element marks by increasing the global reference counter and don't need to
 * visit the whole structure.
 * This makes it more efficient when you only visit/mark a small amount of
 * nodes in the graph.
 */

/** Type for visited counters
 * @see visited_counters */
Michael Beck's avatar
Michael Beck committed
34
typedef unsigned long ir_visited_t;
35
/** A label in the code (usually attached to a @ref Block) */
Michael Beck's avatar
Michael Beck committed
36
typedef unsigned long ir_label_t;
37

38
39
/** @ingroup dbg_info
 * Source Reference */
40
typedef struct dbg_info             dbg_info;
41
42
/** @ingroup dbg_info
 * Source Type Reference */
43
typedef struct type_dbg_info        type_dbg_info;
44
/** @ingroup ir_ident
Matthias Braun's avatar
Matthias Braun committed
45
46
47
48
49
50
 * Identifier
 *
 * @note This is currently defined as a normal C string, but you should not
 *  rely on that and always use get_id_str() before using it as a C string.
 */
typedef const char                  ident;
51
52
/** @ingroup ir_node
 * Procedure Graph Node */
53
typedef struct ir_node              ir_node;
54
55
/** @ingroup ir_op
 * Node Opcode */
56
typedef struct ir_op                ir_op;
57
58
/** @ingroup ir_mode
 * SSA Value mode */
59
typedef struct ir_mode              ir_mode;
60
61
/** @ingroup iredges
 * Dynamic Reverse Edge */
62
typedef struct ir_edge_t            ir_edge_t;
63
64
/** @ingroup ir_heights
 * Computed graph Heights */
65
typedef struct ir_heights_t         ir_heights_t;
66
67
/** @ingroup ir_tarval
 * Target Machine Value */
68
typedef struct ir_tarval            ir_tarval;
69
70
/** @ingroup enumeration_type
 * Enumeration constant */
71
typedef struct ir_enum_const        ir_enum_const;
72
73
/** @ingroup ir_type
 * Type */
74
typedef struct ir_type              ir_type;
75
76
/** @ingroup ir_graph
 * Procedure Grpah */
77
typedef struct ir_graph             ir_graph;
78
79
/** @ingroup ir_prog
 * Program */
80
typedef struct ir_prog              ir_prog;
81
82
/** @ingroup ir_loop
 * Loop */
83
typedef struct ir_loop              ir_loop;
84
85
/** @ingroup ir_entity
 * Entity */
86
typedef struct ir_entity            ir_entity;
87
88
/** @ingroup ir_cdep
 * Control Dependence Analysis Results */
89
typedef struct ir_cdep              ir_cdep;
90
/** A graph transformation pass */
91
typedef struct ir_graph_pass_t      ir_graph_pass_t;
92
/** A whole program transformation pass */
93
94
typedef struct ir_prog_pass_t       ir_prog_pass_t;

95
/** A graph pass manager */
96
typedef struct ir_graph_pass_manager_t      ir_graph_pass_manager_t;
97
/** A program pass manager */
98
typedef struct ir_prog_pass_manager_t       ir_prog_pass_manager_t;
99

100
101
/** @ingroup ir_initializer
 * Initializer (for entities) */
102
typedef union  ir_initializer_t     ir_initializer_t;
103

104
105
106
/**
 * @ingroup irgwalk
 * type for graph-walk callbacks */
107
108
typedef void irg_walk_func(ir_node *, void *);

Matthias Braun's avatar
Matthias Braun committed
109
/**
110
 * @ingroup Switch
Matthias Braun's avatar
Matthias Braun committed
111
112
113
114
115
116
 * A switch table mapping integer numbers to proj-numbers of a Switch-node.
 * Entries map a continuous range of integer numbers to a proj-number.
 * There must never be two different entries matching the same integer number.
 */
typedef struct ir_switch_table  ir_switch_table;

117
/**
118
 * @ingroup ir_cons
119
120
121
122
123
124
125
126
127
128
 * This function is called, whenever a local variable is used before definition
 *
 * @param irg       the IR graph on which this happens
 * @param mode      the mode of the local var
 * @param pos       position chosen be the frontend for this variable (n_loc)
 *
 * @return a firm node of mode @p mode that initializes the var at position pos
 *
 * @note
 *      Do not return NULL!
Christoph Mallon's avatar
Christoph Mallon committed
129
 *      If this function is not set, FIRM will create an Unknown node.
130
131
132
133
 *      Use set_irg_loc_description()/get_irg_loc_description() to assign additional
 *      informations to local variables.
 */
typedef ir_node *uninitialized_local_variable_func_t(ir_graph *irg, ir_mode *mode, int pos);
134

135
#ifdef __cplusplus
136
# define ENUM_BITSET(type) \
137
138
139
140
141
142
143
144
145
146
	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); } \
		static inline type operator &= (type& a, type b) { return a = (type)((int)a & (int)b); } \
		static inline type operator ^  (type  a, type b) { return     (type)((int)a ^ (int)b); } \
		static inline type operator ^= (type& a, type b) { return a = (type)((int)a ^ (int)b); } \
		static inline type operator |  (type  a, type b) { return     (type)((int)a | (int)b); } \
		static inline type operator |= (type& a, type b) { return a = (type)((int)a | (int)b); } \
	}
#else
147
148
149
150
/** Marks an enum type as bitset enum. That is the enumeration values will
 * probably be combined to form a (bit)set of flags.
 * When compiling for C++ this macro will define the ~, &, &=, ^, ^=, | and |=
 * operators for the enum values. */
151
# define ENUM_BITSET(type)
152
153
154
#endif

#ifdef __cplusplus
155
# define ENUM_COUNTABLE(type) \
156
157
158
159
160
	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
161
162
163
164
/** Marks an enum type as countable enum. The enumeration values will be a
 * linear sequence of numbers which can be iterated through by incrementing
 * by 1.
 * When compiling for C++ this macro will define the ++ and -- operators. */
165
# define ENUM_COUNTABLE(type)
166
167
#endif

168
/**
169
 * @ingroup ir_node
170
171
172
173
174
175
176
177
178
179
180
181
182
 * 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 */
yb9976's avatar
yb9976 committed
183
	ir_relation_unordered_less     = ir_relation_unordered|ir_relation_less,  /**< unordered or less */
184
185
186
187
188
189
190
191
	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)

192
/**
193
 * @ingroup ir_node
194
195
196
 * constrained flags for memory operations.
 */
typedef enum ir_cons_flags {
197
198
199
200
201
202
203
	cons_none             = 0,        /**< No constrains. */
	cons_volatile         = 1U << 0,  /**< Memory operation is volatile. */
	cons_unaligned        = 1U << 1,  /**< Memory operation is unaligned. */
	cons_floats           = 1U << 2,  /**< Memory operation can float. */
	cons_throws_exception = 1U << 3,  /**< fragile op throws exception (and
	                                       produces X_regular and X_except
	                                       values) */
204
205
} ir_cons_flags;
ENUM_BITSET(ir_cons_flags)
206

207
208
209
210
/**
 * @ingroup ir_node
 * pinned states.
 */
211
typedef enum op_pin_state {
212
213
214
215
216
217
218
219
	op_pin_state_floats = 0,    /**< Nodes of this opcode can be placed in any basic block. */
	op_pin_state_pinned = 1,    /**< Nodes must remain in this basic block. */
	op_pin_state_exc_pinned,    /**< Node must be remain in this basic block if it can throw an
	                                 exception, else can float. Used internally. */
	op_pin_state_mem_pinned     /**< Node must be remain in this basic block if it can throw an
	                                 exception or uses memory, else can float. Used internally. */
} op_pin_state;

220
/**
221
 * @ingroup Cond
222
223
 * A type to express conditional jump predictions.
 */
224
typedef enum cond_jmp_predicate {
225
226
227
228
229
	COND_JMP_PRED_NONE,        /**< No jump prediction. Default. */
	COND_JMP_PRED_TRUE,        /**< The True case is predicted. */
	COND_JMP_PRED_FALSE        /**< The False case is predicted. */
} cond_jmp_predicate;

230
/**
231
 * @ingroup method_type
232
233
234
235
 * Additional method type properties:
 * Tell about special properties of a method type. Some
 * of these may be discovered by analyses.
 */
236
typedef enum mtp_additional_properties {
Matthias Braun's avatar
Matthias Braun committed
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
	/** no additional properties */
	mtp_no_property                 = 0,
	/** 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_const              = 1u << 0,
	/** 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_pure               = 1u << 1,
	/** This method did not return due to an aborting system call.
	 * GCC: __attribute__((noreturn)). */
	mtp_property_noreturn           = 1u << 2,
	/** This method cannot throw an exception. GCC: __attribute__((nothrow)). */
	mtp_property_nothrow            = 1u << 3,
	/** This method is naked. GCC: __attribute__((naked)). */
	mtp_property_naked              = 1u << 4,
	/** This method returns newly allocate memory.
	 * GCC: __attribute__((malloc)). */
	mtp_property_malloc             = 1u << 5,
	/** This method can return more than one (typically setjmp).
	 * GCC: __attribute__((returns_twice)). */
	mtp_property_returns_twice      = 1u << 6,
	/** All method invocations are known, the backend is free to optimize the
	 * call in any possible way. */
267
	mtp_property_private            = 1u << 7,
Matthias Braun's avatar
Matthias Braun committed
268
	/** Set, if this method contains one possibly endless loop. */
269
	mtp_property_has_loop           = 1u << 8,
Matthias Braun's avatar
Matthias Braun committed
270
	/** try to always inline this function, even if it seems nonprofitable */
271
	mtp_property_always_inline      = 1u << 9,
Matthias Braun's avatar
Matthias Braun committed
272
	/** the function should not be inlined */
273
	mtp_property_noinline           = 1u << 10,
Matthias Braun's avatar
Matthias Braun committed
274
	/** the programmer recommends to inline the function */
275
	mtp_property_inline_recommended = 1u << 11,
Matthias Braun's avatar
Matthias Braun committed
276
	/** stupid hack used by opt_funccall... */
277
	mtp_temporary                   = 1u << 12,
278
279
} mtp_additional_properties;
ENUM_BITSET(mtp_additional_properties)
280

281
282
283
/**
 * @ingroup SymConst
 * This enum names the different kinds of symbolic Constants represented by
284
 * SymConst.  The content of the attribute symconst_symbol depends on this tag.
285
286
 * Use the proper access routine after testing this flag.
 */
287
typedef enum symconst_kind {
Matthias Braun's avatar
Matthias Braun committed
288
289
290
291
292
293
294
295
296
	symconst_type_size,   /**< The SymConst is the size of the given type.
	                           symconst_symbol is type *. */
	symconst_type_align,  /**< The SymConst is the alignment of the given type.
	                           symconst_symbol is type *. */
	symconst_addr_ent,    /**< The SymConst is a symbolic pointer to be filled in
	                           by the linker.  The pointer is represented by an entity.
	                           symconst_symbol is entity *. */
	symconst_ofs_ent,     /**< The SymConst is the offset of its entity in the entities
	                           owner type. */
297
	symconst_enum_const   /**< The SymConst is a enumeration constant of an
Matthias Braun's avatar
Matthias Braun committed
298
299
300
	                           enumeration type. */
} symconst_kind;

301
302
303
/**
 * @ingroup SymConst
 * SymConst attribute.
Matthias Braun's avatar
Matthias Braun committed
304
305
 *
 *  This union contains the symbolic information represented by the node.
Matthias Braun's avatar
Matthias Braun committed
306
 *  @ingroup SymConst
Matthias Braun's avatar
Matthias Braun committed
307
308
309
310
311
312
313
 */
typedef union symconst_symbol {
	ir_type       *type_p;    /**< The type of a SymConst. */
	ir_entity     *entity_p;  /**< The entity of a SymConst. */
	ir_enum_const *enum_p;    /**< The enumeration constant of a SymConst. */
} symconst_symbol;

314
/**
Matthias Braun's avatar
Matthias Braun committed
315
 * @ingroup Alloc
316
 * The allocation place.
Matthias Braun's avatar
Matthias Braun committed
317
 */
318
typedef enum ir_where_alloc {
Matthias Braun's avatar
Matthias Braun committed
319
320
321
322
	stack_alloc,          /**< Alloc allocates the object on the stack. */
	heap_alloc            /**< Alloc allocates the object on the heap. */
} ir_where_alloc;

Matthias Braun's avatar
Matthias Braun committed
323
324
325
/** A input/output constraint attribute.
 * @ingroup ASM
 */
326
typedef struct ir_asm_constraint {
Matthias Braun's avatar
Matthias Braun committed
327
328
329
330
331
	unsigned       pos;           /**< The inputs/output position for this constraint. */
	ident          *constraint;   /**< The constraint for this input/output. */
	ir_mode        *mode;         /**< The mode of the constraint. */
} ir_asm_constraint;

Matthias Braun's avatar
Matthias Braun committed
332
333
334
/** Supported libFirm builtins.
 * @ingroup Builtin
 */
335
typedef enum ir_builtin_kind {
336
337
	ir_bk_trap,                   /**< GCC __builtin_trap(): insert trap */
	ir_bk_debugbreak,             /**< MS __debugbreak(): insert debug break */
338
	ir_bk_return_address,         /**< GCC __builtin_return_address() */
339
	ir_bk_frame_address,          /**< GCC __builtin_frame_address() */
340
	ir_bk_prefetch,               /**< GCC __builtin_prefetch() */
341
342
343
344
345
	ir_bk_ffs,                    /**< GCC __builtin_ffs(): find first (least) significant 1 bit */
	ir_bk_clz,                    /**< GCC __builtin_clz(): count leading zero */
	ir_bk_ctz,                    /**< GCC __builtin_ctz(): count trailing zero */
	ir_bk_popcount,               /**< GCC __builtin_popcount(): population count */
	ir_bk_parity,                 /**< GCC __builtin_parity(): parity */
Michael Beck's avatar
Michael Beck committed
346
	ir_bk_bswap,                  /**< byte swap */
347
348
	ir_bk_inport,                 /**< in port */
	ir_bk_outport,                /**< out port */
349
	ir_bk_inner_trampoline,       /**< address of a trampoline for GCC inner functions */
350
	ir_bk_saturating_increment,   /**< saturating increment */
351
352
	ir_bk_compare_swap,           /**< compare exchange (aka. compare and swap) */
	ir_bk_last = ir_bk_compare_swap,
353
354
} ir_builtin_kind;

355
356
357
/**
 * Possible return values of value_classify().
 */
358
typedef enum ir_value_classify_sign {
359
360
361
362
363
364
	value_classified_unknown  = 0,   /**< could not classify */
	value_classified_positive = 1,   /**< value is positive, i.e. >= 0 */
	value_classified_negative = -1   /**< value is negative, i.e. <= 0 if
	                                      no signed zero exists or < 0 else */
} ir_value_classify_sign;

365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
/**
 * 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;

381
382
#include "end.h"

383
#endif