firm_types.h 15.2 KB
Newer Older
1
/*
2
 * Copyright (C) 1995-2010 University of Karlsruhe.  All right reserved.
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
 *
 * This file is part of libFirm.
 *
 * This file may be distributed and/or modified under the terms of the
 * GNU General Public License version 2 as published by the Free Software
 * Foundation and appearing in the file LICENSE.GPL included in the
 * packaging of this file.
 *
 * Licensees holding valid libFirm Professional Edition licenses may use
 * this file in accordance with the libFirm Commercial License.
 * Agreement provided with the Software.
 *
 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
 * PURPOSE.
 */

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

29
30
#include "begin.h"

Michael Beck's avatar
Michael Beck committed
31
typedef unsigned long ir_visited_t;
32
typedef unsigned long ir_exc_region_t;
Michael Beck's avatar
Michael Beck committed
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
39
40
typedef struct ir_node              ir_node,             *ir_node_ptr;
typedef struct ir_op                ir_op,               *ir_op_ptr;
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;
Matthias Braun's avatar
Matthias Braun committed
43
typedef struct ir_tarval            ir_tarval,           *ir_tarval_ptr;
44
45
46
typedef struct ir_enum_const        ir_enum_const,       *ir_enum_const_ptr;
typedef struct ir_type              ir_type,             *ir_type_ptr;
typedef struct ir_graph             ir_graph,            *ir_graph_ptr;
47
typedef struct ir_prog              ir_prog,             *ir_prog_ptr;
48
49
50
51
typedef struct ir_loop              ir_loop,             *ir_loop_ptr;
typedef struct ir_region            ir_region,           *ir_region_ptr;
typedef struct ir_reg_tree          ir_reg_tree,         *ir_reg_tree_ptr;
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;
Matthias Braun's avatar
Matthias Braun committed
56
typedef struct arch_irn_ops_t       arch_irn_ops_t;
57
typedef struct type_identify_if_t   type_identify_if_t;
58
59
60
61
62
typedef struct ir_graph_pass_t      ir_graph_pass_t;
typedef struct ir_prog_pass_t       ir_prog_pass_t;

typedef struct ir_graph_pass_manager_t      ir_graph_pass_manager_t;
typedef struct ir_prog_pass_manager_t       ir_prog_pass_manager_t;
63

64
65
typedef union  ir_initializer_t     ir_initializer_t,    *ir_initializer_ptr;

66
67
68
typedef void irg_walk_func(ir_node *, void *);
typedef void irg_reg_walk_func(ir_region *, void *);

69
70
71
/* settings */
typedef struct ir_settings_arch_dep_t ir_settings_arch_dep_t;

72
73
74
/* Needed for MSVC to suppress warnings because it doest NOT handle const right. */
typedef const ir_node *ir_node_cnst_ptr;

75
76
/* states */

77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
/**
 * 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!
 *      If this function is not set, FIRM will create a const node with tarval BAD.
 *      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);
93

94
#ifdef __cplusplus
95
# define ENUM_BITSET(type) \
96
97
98
99
100
101
102
103
104
105
	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
106
# define ENUM_BITSET(type)
107
108
109
#endif

#ifdef __cplusplus
110
# define ENUM_COUNTABLE(type) \
111
112
113
114
115
	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
116
# define ENUM_COUNTABLE(type)
117
118
#endif

119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
/**
 * 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 */
	ir_relation_unordered_less     = ir_relation_unordered|ir_relation_less,  /**< unorderedor less */
	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)

142
143
144
145
/**
 * constrained flags for memory operations.
 */
typedef enum ir_cons_flags {
146
147
148
149
150
151
152
	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) */
153
154
} ir_cons_flags;
ENUM_BITSET(ir_cons_flags)
155

156
/** op_pin_state_pinned states. */
157
typedef enum op_pin_state {
158
159
160
161
162
163
164
165
	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;

166
167
168
/**
 * A type to express conditional jump predictions.
 */
169
typedef enum cond_jmp_predicate {
170
171
172
173
174
	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;

175
176
177
178
179
/**
 * Additional method type properties:
 * Tell about special properties of a method type. Some
 * of these may be discovered by analyses.
 */
180
typedef enum mtp_additional_properties {
181
182
183
	mtp_no_property            = 0x00000000, /**< no additional properties, default */
	mtp_property_const         = 0x00000001, /**< This method did not access memory and calculates
	                                              its return values solely from its parameters.
184
185
186
187
	                                              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.
188
189
190
191
	                                              GCC: __attribute__((const)). */
	mtp_property_pure          = 0x00000002, /**< 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).
192
193
194
	                                              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.
195
196
197
198
199
200
201
202
203
204
	                                              GCC: __attribute__((pure)). */
	mtp_property_noreturn      = 0x00000004, /**< This method did not return due to an aborting system
	                                              call.
	                                              GCC: __attribute__((noreturn)). */
	mtp_property_nothrow       = 0x00000008, /**< This method cannot throw an exception.
	                                              GCC: __attribute__((nothrow)). */
	mtp_property_naked         = 0x00000010, /**< This method is naked.
	                                              GCC: __attribute__((naked)). */
	mtp_property_malloc        = 0x00000020, /**< This method returns newly allocate memory.
	                                              GCC: __attribute__((malloc)). */
205
	mtp_property_returns_twice = 0x00000040, /**< This method can return more than one (typically setjmp).
206
                                                  GCC: __attribute__((returns_twice)). */
207
	mtp_property_intrinsic     = 0x00000080, /**< This method is intrinsic. It is expected that
208
	                                              a lowering phase will remove all calls to it. */
209
210
	mtp_property_runtime       = 0x00000100, /**< This method represents a runtime routine. */
	mtp_property_private       = 0x00000200, /**< All method invocations are known, the backend is free to
211
	                                              optimize the call in any possible way. */
212
	mtp_property_has_loop      = 0x00000400, /**< Set, if this method contains one possible endless loop. */
213
214
	mtp_property_inherited     = (1<<31)     /**< Internal. Used only in irg's, means property is
	                                              inherited from type. */
215
216
} mtp_additional_properties;
ENUM_BITSET(mtp_additional_properties)
217

218
/**  This enum names the different kinds of symbolic Constants represented by
219
220
 * SymConst.  The content of the attribute symconst_symbol depends on this tag.
 * Use the proper access routine after testing this flag. */
221
typedef enum symconst_kind {
Matthias Braun's avatar
Matthias Braun committed
222
223
224
225
226
227
228
229
230
231
232
	symconst_type_tag,    /**< The SymConst is a type tag for the given type.
	                           symconst_symbol is type *. */
	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. */
233
	symconst_enum_const   /**< The SymConst is a enumeration constant of an
Matthias Braun's avatar
Matthias Braun committed
234
235
236
237
238
239
240
241
242
243
244
245
246
247
	                           enumeration type. */
} symconst_kind;

/** SymConst attribute.
 *
 *  This union contains the symbolic information represented by the node.
 */
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;

/** The allocation place. */
248
typedef enum ir_where_alloc {
Matthias Braun's avatar
Matthias Braun committed
249
250
251
252
	stack_alloc,          /**< Alloc allocates the object on the stack. */
	heap_alloc            /**< Alloc allocates the object on the heap. */
} ir_where_alloc;

253
/** A input/output constraint attribute. */
254
typedef struct ir_asm_constraint {
Matthias Braun's avatar
Matthias Braun committed
255
256
257
258
259
	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;

260
/** Supported libFirm builtins. */
261
typedef enum ir_builtin_kind {
262
263
	ir_bk_trap,                   /**< GCC __builtin_trap(): insert trap */
	ir_bk_debugbreak,             /**< MS __debugbreak(): insert debug break */
264
	ir_bk_return_address,         /**< GCC __builtin_return_address() */
265
	ir_bk_frame_address,          /**< GCC __builtin_frame_address() */
266
	ir_bk_prefetch,               /**< GCC __builtin_prefetch() */
267
268
269
270
271
	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
272
	ir_bk_bswap,                  /**< byte swap */
273
274
	ir_bk_inport,                 /**< in port */
	ir_bk_outport,                /**< out port */
275
	ir_bk_inner_trampoline,       /**< address of a trampoline for GCC inner functions */
276
	ir_bk_last = ir_bk_inner_trampoline,
277
278
} ir_builtin_kind;

279
280
281
/**
 * Possible return values of value_classify().
 */
282
typedef enum ir_value_classify_sign {
283
284
285
286
287
288
	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;

289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
/**
 * 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;

305
306
#include "end.h"

307
#endif