irtypes.h 27.7 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 the Firm IR base types, concentrated here
 * @author  Michael Beck
 */
#ifndef FIRM_IR_IRDEFS_H
#define FIRM_IR_IRDEFS_H

14
15
#include <stdbool.h>

16
17
18
19
20
#include "firm_types.h"
#include "irdom_t.h"
#include "irmode.h"
#include "irnode.h"
#include "iredgekinds.h"
21
#include "irop.h"
22
23
24
#include "irtypeinfo.h"
#include "irmemory.h"
#include "callgraph.h"
25
#include "irprog.h"
26
#include "bitset.h"
27
28

#include "pset.h"
29
#include "pmap.h"
30
#include "list.h"
31
#include "obst.h"
32
#include "vrp.h"
33

34
35
36
struct ir_nodemap {
	void **data;  /**< maps node indices to void* */
};
37

38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
typedef struct arch_irn_ops_t arch_irn_ops_t;

/**
 * Operation specific callbacks.
 */
typedef struct {
	hash_func             hash;                 /**< Calculate a hash value for an IR node. */
	computed_value_func   computed_value;       /**< Evaluates a node into a tarval if possible. */
	computed_value_func   computed_value_Proj;  /**< Evaluates a Proj node into a tarval if possible. */
	equivalent_node_func  equivalent_node;      /**< Optimizes the node by returning an equivalent one. */
	equivalent_node_func  equivalent_node_Proj; /**< Optimizes the Proj node by returning an equivalent one. */
	transform_node_func   transform_node;       /**< Optimizes the node by transforming it. */
	transform_node_func   transform_node_Proj;  /**< Optimizes the Proj node by transforming it. */
	node_cmp_attr_func    node_cmp_attr;        /**< Compares two node attributes. */
	reassociate_func      reassociate;          /**< Reassociate a tree. */
	copy_attr_func        copy_attr;            /**< Copy node attributes. */
	get_type_attr_func    get_type_attr;        /**< Returns the type attribute of a node. */
	get_entity_attr_func  get_entity_attr;      /**< Returns the entity attribute of a node. */
	verify_node_func      verify_node;          /**< Verify the node. */
	verify_proj_node_func verify_proj_node;     /**< Verify the Proj node. */
	dump_node_func        dump_node;            /**< Dump a node. */
	op_func               generic;              /**< A generic function pointer. */
	op_func               generic1;             /**< A generic function pointer. */
	op_func               generic2;             /**< A generic function pointer. */
	const arch_irn_ops_t *be_ops;               /**< callbacks used by the backend. */
} ir_op_ops;

65
66
/** The type of an ir_op. */
struct ir_op {
Matthias Braun's avatar
Matthias Braun committed
67
68
69
70
71
72
73
74
	unsigned code;            /**< The unique opcode of the op. */
	ident *name;              /**< The name of the op. */
	size_t attr_size;         /**< Space needed in memory for private attributes
	                               */
	op_pin_state pin_state;   /**< How to deal with the node in CSE, PRE. */
	op_arity opar;            /**< The arity of operator. */
	int op_index;             /**< The index of the first data operand, 0 for
	                               most cases, 1 for Div etc. */
75
	int memory_index;         /**< index of memory input for memory nodes */
Matthias Braun's avatar
Matthias Braun committed
76
77
78
79
80
81
82
83
84
85
	int pn_x_regular;         /**< for fragile ops the position of the
	                               X_regular output */
	int pn_x_except;          /**< for fragile ops the position of the
	                               X_except output */
	unsigned flags;           /**< Flags describing the behavior of the ir_op,
	                               a bitmasks of irop_flags. */
	unsigned tag;             /**< Some custom TAG value the op's creator set */
	void *attr;               /**< custom pointer where op's creator can attach
	                               attribute stuff to. */
	ir_op_ops ops;            /**< The operations of the this op. */
86
87
};

88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
/** Helper values for ir_mode_sort. */
enum ir_mode_sort_helper {
	irmsh_is_num   = 0x10, /**< mode represents a number */
	irmsh_is_data  = 0x20, /**< mode represents data (can be carried in registers) */
	irmsh_is_datab = 0x40, /**< mode represents data or is internal boolean */
	irmsh_is_dataM = 0x80, /**< mode represents data or is memory */
};

/**
 * These values represent the different mode classes of value representations.
 * Beware: do not change the order of these values without checking
 * the mode_is
 */
typedef enum ir_mode_sort {
	irms_control_flow     = 0, /**< Marks all control flow modes. */
	irms_block            = 1,
	irms_tuple            = 2,
	irms_any              = 3,
	irms_bad              = 4,
	irms_memory           = 5 | irmsh_is_dataM, /**< Marks the memory mode.  Not extensible. (irm_M) */

	/** Internal boolean representation.
	     Storing to memory impossible, convert first. (irm_b) */
	irms_internal_boolean = 6 | irmsh_is_datab,

	/** A mode to represent entities.
	    Restricted int computations can be performed */
	irms_reference        = 7 | irmsh_is_data | irmsh_is_datab | irmsh_is_dataM,
	/** A mode to represent int numbers.
	    Integer computations can be performed. */
	irms_int_number       = 8 | irmsh_is_data | irmsh_is_datab | irmsh_is_dataM | irmsh_is_num,
	/** A mode to represent float numbers.
	    Floating point computations can be performed. */
	irms_float_number     = 9 | irmsh_is_data | irmsh_is_datab | irmsh_is_dataM | irmsh_is_num,
} ir_mode_sort;

/**
 * A descriptor for an IEEE754 float value.
 */
typedef struct float_descriptor_t {
	unsigned char exponent_size;    /**< size of exponent in bits */
	unsigned char mantissa_size;    /**< size of mantissa in bits */
	bool          explicit_one;     /**< set if the leading one is explicit */
} float_descriptor_t;

133
134
135
136
137
138
139
140
141
/**
 * Contains relevant information about a mode.
 *
 * Necessary information about a mode is stored in this struct
 * which is used by the tarval module to perform calculations
 * and comparisons of values of a such described mode.
 *
 * ATTRIBUTES:
 *  -  ident *name:             Name of this mode. Two modes are different if the name is different.
142
 *  -  ir_mode_sort sort:       sort of mode specifying possible usage categories
143
144
145
146
147
148
149
150
151
152
153
154
155
 *  -  int    size:             size of the mode in Bits.
 *  -  unsigned sign:1:         signedness of this mode
 *  -  ... more to come
 *  -  modulo_shift             specifies for modes of kind irms_int_number
 *                              whether shift applies modulo to value of bits to shift
 *
 * SEE ALSO:
 *    The tech report 1999-44 describing FIRM and predefined modes
 *    tarval.h
 */
struct ir_mode {
	firm_kind         kind;       /**< distinguishes this node from others */
	ident             *name;      /**< Name ident of this mode */
156
	ir_type           *type;      /**< corresponding primitive type */
157

158
	/* ---------------------------------------------------------------------- */
159
	/* On changing this struct you have to evaluate the mode_are_equal function!*/
160
161
162
163
164
165
166
167
	ir_mode_sort       sort;          /**< coarse classification of this mode:
                                           int, float, reference ...
                                           (see irmode.h) */
	ir_mode_arithmetic arithmetic;    /**< different arithmetic operations possible with a mode */
	unsigned           size;          /**< size of the mode in Bits. */
	unsigned           sign:1;        /**< signedness of this mode */
	unsigned int       modulo_shift;  /**< number of bits a values of this mode will be shifted */
	float_descriptor_t float_desc;
168

169
	/* ---------------------------------------------------------------------- */
Matthias Braun's avatar
Matthias Braun committed
170
171
172
173
174
175
	ir_tarval         *min;         /**< the minimum value that can be expressed */
	ir_tarval         *max;         /**< the maximum value that can be expressed */
	ir_tarval         *null;        /**< the value 0 */
	ir_tarval         *one;         /**< the value 1 */
	ir_tarval         *minus_one;   /**< the value -1 */
	ir_tarval         *all_one;     /**< the value ~0 */
176
177
178
179
180
181
	ir_mode           *eq_signed;   /**< For pointer modes, the equivalent signed integer one. */
	ir_mode           *eq_unsigned; /**< For pointer modes, the equivalent unsigned integer one. */
	void              *link;        /**< To store some intermediate information */
	const void        *tv_priv;     /**< tarval module will save private data here */
};

Matthias Braun's avatar
Matthias Braun committed
182
183
184
185
186
187
188
189
190
191
192
193
/* note: we use "long" here because that is the type used for Proj-Numbers */
typedef struct ir_switch_table_entry {
	ir_tarval *min;
	ir_tarval *max;
	long       pn;
} ir_switch_table_entry;

struct ir_switch_table {
	size_t                n_entries;
	ir_switch_table_entry entries[];
};

194
195
/* ir node attributes */

196
/** first attribute of Bad, Block, Anchor nodes */
197
typedef struct irg_attr {
198
199
	ir_graph *irg;              /**< The graph this block like node belongs to. */
} irg_attr;
200

201
typedef struct bad_attr {
202
203
204
	irg_attr    irg;
} bad_attr;

205
206
207
208
typedef struct anchor_attr {
	irg_attr  irg;
} anchor_attr;

209
/** Block attributes */
210
typedef struct block_attr {
211
	/* General attributes */
212
	irg_attr     irg;           /**< The graph this block belongs to. */
213
	ir_visited_t block_visited; /**< For the walker that walks over all blocks. */
214
215
	/* Attributes private to construction: */
	unsigned is_matured:1;      /**< If set, all in-nodes of the block are fixed. */
216
	unsigned dynamic_ins:1;     /**< if set in-array is an ARR_F on the heap. */
217
	unsigned marked:1;          /**< Can be set/unset to temporary mark a block. */
218
219
	ir_node **graph_arr;        /**< An array to store all parameters. */
	/* Attributes holding analyses information */
Matthias Braun's avatar
Matthias Braun committed
220
	ir_dom_info dom;            /**< Datastructure that holds information about dominators. */
221
	ir_dom_info pdom;           /**< Datastructure that holds information about post-dominators. */
222
	bitset_t *backedge;         /**< Bitfield n set to true if pred n is backedge.*/
223
	ir_entity *entity;          /**< entitiy representing this block */
224
	ir_node  *phis;             /**< The list of Phi nodes in this block. */
225
	double    execfreq;         /**< block execution frequency */
226
227
228
} block_attr;

/** Cond attributes. */
229
typedef struct cond_attr {
230
	cond_jmp_predicate jmp_pred; /**< only for binary Conds: The jump predication. */
231
232
233
} cond_attr;

/** Const attributes. */
Matthias Braun's avatar
Matthias Braun committed
234
235
typedef struct const_attr {
	ir_tarval *tarval;  /**< the target value */
236
237
238
} const_attr;

/** SymConst attributes. */
239
typedef struct symconst_attr {
240
	symconst_symbol sym;  // old tori
241
	symconst_kind   kind;
242
243
244
} symconst_attr;

/** Sel attributes. */
245
typedef struct sel_attr {
246
	ir_entity *entity;    /**< entity to select */
247
248
249
} sel_attr;

/** Exception attributes. */
250
typedef struct except_attr {
251
252
253
254
255
256
	unsigned  pin_state : 2;         /**< the pin state for operations with
	                                      variable pinned state. Contains a
	                                      op_pin_state */
	unsigned  throws_exception : 1; /**< if true a fragile op throws and
	                                     must produce X_except and X_regular
	                                     values */
257
258
259
} except_attr;

/** Call attributes. */
260
typedef struct call_attr {
261
262
263
	except_attr exc;               /**< the exception attribute. MUST be the first one. */
	ir_type     *type;             /**< type of called procedure */
	ir_entity   **callee_arr;      /**< result of callee analysis */
264
265
} call_attr;

266
/** Builtin attributes. */
267
typedef struct builtin_attr {
268
269
	except_attr     exc;           /**< the exception attribute. MUST be the first one. */
	ir_builtin_kind kind;          /**< kind of the called builtin procedure */
270
	ir_type         *type;         /**< type of called builtin procedure */
271
272
} builtin_attr;

273
/** Alloc attributes. */
274
typedef struct alloc_attr {
275
	unsigned alignment;
276
277
278
} alloc_attr;

/** Load attributes. */
279
typedef struct load_attr {
280
	except_attr   exc;            /**< The exception attribute. MUST be the first one. */
Matthias Braun's avatar
Matthias Braun committed
281
282
	__extension__ ir_volatility volatility:1;   /**< The volatility of this Load operation. */
	__extension__ ir_align      unaligned:1;    /**< The align attribute of this Load operation. */
283
	ir_mode       *mode;          /**< The mode of this Load operation. */
284
285
286
} load_attr;

/** Store attributes. */
287
typedef struct store_attr {
288
	except_attr   exc;            /**< the exception attribute. MUST be the first one. */
Matthias Braun's avatar
Matthias Braun committed
289
290
	__extension__ ir_volatility volatility:1;   /**< The volatility of this Store operation. */
	__extension__ ir_align      unaligned:1;    /**< The align attribute of this Store operation. */
291
292
} store_attr;

293
typedef struct phi_attr {
294
295
	ir_node        *next;         /**< Points to the next Phi in the Phi list of a block. */
	union {
296
		bitset_t      *backedge;     /**< Raw Bitfield: bit n is set to true if pred n is backedge. */
297
298
299
300
301
302
303
304
305
		int            pos;           /**< For Phi0. Used to remember the value defined by
		                               this Phi node.  Needed when the Phi is completed
		                               to call get_r_internal_value() to find the
		                               predecessors. If this attribute is set, the Phi
		                               node takes the role of the obsolete Phi0 node,
		                               therefore the name. */
	} u;
} phi_attr;

306
307
308
309
/**< Cmp attribute. */
typedef struct cmp_attr {
	ir_relation relation;         /**< comparison condition. */
} cmp_attr;
310
311

/**< Confirm attribute. */
312
typedef struct confirm_attr {
313
	ir_relation relation;         /**< relation between value and bound */
314
315
316
} confirm_attr;

/** CopyB attribute. */
317
typedef struct copyb_attr {
318
319
	ir_type      *type;           /**< Type of the copied entity. */
	__extension__ ir_volatility  volatility:1;  /**< The volatility of this CopyB operation. */
320
321
} copyb_attr;

322
323
/** Div attribute. */
typedef struct div_attr {
324
	except_attr    exc;           /**< The exception attribute. MUST be the first one. */
325
	ir_mode        *resmode;      /**< Result mode for the division. */
326
	char           no_remainder;  /**< Set, if known that a division can be done without a remainder. */
327
328
329
330
331
332
333
} div_attr;

/** Mod attribute. */
typedef struct mod_attr {
	except_attr    exc;           /**< The exception attribute. MUST be the first one. */
	ir_mode        *resmode;      /**< Result mode for the division. */
} mod_attr;
334
335

/** Inline Assembler support attribute. */
336
typedef struct asm_attr {
337
	/* BEWARE: pin state MUST be the first attribute */
338
339
340
341
342
	op_pin_state      pin_state;            /**< the pin state for operations that might generate a exception */
	ident             *text;                /**< The inline assembler text. */
	ir_asm_constraint *input_constraints;   /**< Input constraints. */
	ir_asm_constraint *output_constraints;  /**< Output constraints. */
	ident             **clobbers;           /**< List of clobbered registers. */
343
344
} asm_attr;

345
346
347
348
typedef struct proj_attr {
	long  proj;           /**< position of tuple sub-value which is projected */
} proj_attr;

Matthias Braun's avatar
Matthias Braun committed
349
350
351
352
353
typedef struct switch_attr {
	unsigned         n_outs;
	ir_switch_table *table;
} switch_attr;

354
355
/** Some IR-nodes just have one attribute, these are stored here,
   some have more. Their name is 'irnodename_attr' */
356
typedef union ir_attr {
357
	irg_attr       irg;           /**< For Blocks and Bad: its belonging irg */
358
	bad_attr       bad;           /**< for Bads: irg reference */
359
	anchor_attr    anchor;        /**< for Anchor: irg reference */
360
	block_attr     block;         /**< For Block: Fields needed to construct it */
361
	cmp_attr       cmp;           /**< For Cmp. */
362
363
364
365
	cond_attr      cond;          /**< For Cond. */
	const_attr     con;           /**< For Const: contains the value of the constant and a type */
	symconst_attr  symc;          /**< For SymConst. */
	sel_attr       sel;           /**< For Sel. */
366
367
	call_attr      call;          /**< For Call. */
	builtin_attr   builtin;       /**< For Builtin. */
368
369
370
	alloc_attr     alloc;         /**< For Alloc. */
	load_attr      load;          /**< For Load. */
	store_attr     store;         /**< For Store. */
371
	phi_attr       phi;           /**< For Phi. */
372
	proj_attr      proj;          /**< For Proj. */
373
374
375
	confirm_attr   confirm;       /**< For Confirm: compare operation and region. */
	except_attr    except;        /**< For Phi node construction in case of exceptions */
	copyb_attr     copyb;         /**< For CopyB operation */
376
377
	div_attr       div;           /**< For Div operation */
	mod_attr       mod;           /**< For Mod operation */
378
	asm_attr       assem;         /**< For ASM operation. */
Matthias Braun's avatar
Matthias Braun committed
379
	switch_attr    switcha;       /**< For Switch operation. */
380
} ir_attr;
381
382
383
384

/**
 * Edge info to put into an irn.
 */
385
typedef struct irn_edge_kind_info_t {
386
	struct list_head outs_head;  /**< The list of all outs. */
Michael Beck's avatar
Michael Beck committed
387
388
	unsigned edges_built : 1;    /**< Set edges where built for this node. */
	unsigned out_count : 31;     /**< Number of outs in the list. */
389
390
} irn_edge_info_t;

391
typedef irn_edge_info_t irn_edges_info_t[EDGE_KIND_LAST+1];
392

393
394
395
/**
 * A Def-Use edge.
 */
396
typedef struct ir_def_use_edge {
397
398
399
400
	ir_node *use;            /** The use node of that edge. */
	int     pos;             /** The position of this edge in use's input array. */
} ir_def_use_edge;

Matthias Braun's avatar
Matthias Braun committed
401
402
403
404
405
typedef struct ir_def_use_edges {
	unsigned        n_edges;
	ir_def_use_edge edges[];
} ir_def_use_edges;

406
407
408
409
410
411
412
/**
 * The common structure of an irnode.
 * If the node has some attributes, they are stored in the attr field.
 */
struct ir_node {
	/* ------- Basics of the representation  ------- */
	firm_kind kind;          /**< Distinguishes this node from others. */
Michael Beck's avatar
Michael Beck committed
413
	unsigned node_idx;       /**< The node index of this node in its graph. */
414
415
416
	ir_op *op;               /**< The Opcode of this node. */
	ir_mode *mode;           /**< The Mode of this node. */
	struct ir_node **in;     /**< The array of predecessors / operands. */
417
	ir_visited_t visited;    /**< The visited counter for walks of the graph. */
418
	void *link;              /**< To attach additional information to the node, e.g.
Michael Beck's avatar
Michael Beck committed
419
	                              used during optimization to link to nodes that
420
	                              shall replace a node. */
421
	long node_nr;            /**< A globally unique node number for each node. */
422
	/* ------- Fields for optimizations / analysis information ------- */
Matthias Braun's avatar
Matthias Braun committed
423
424
425
426
427
428
	union {
		ir_def_use_edges *out;    /**< array of def-use edges. */
		unsigned          n_outs; /**< number of def-use edges (temporarily used
		                               during construction of datastructure ) */
	} o;
	struct dbg_info  *dbi;   /**< A pointer to information for debug support. */
429
430
431
	/* ------- For analyses -------- */
	ir_loop *loop;           /**< the loop the node is in. Access routines in irloop.h */
	struct ir_node **deps;   /**< Additional dependencies induced by state. */
432
	void            *backend_info;
433
	irn_edges_info_t edge_info;  /**< Everlasting out edges. */
434

435
	/* ------- Opcode depending fields -------- */
436
	ir_attr attr;            /**< The set of attributes of this node. Depends on opcode.
437
438
439
	                              Must be last field of struct ir_node. */
};

440
441
#include "iredgeset.h"

442
443
444
/**
 * Edge info to put into an irg.
 */
445
typedef struct irg_edge_info_t {
446
447
448
449
450
	ir_edgeset_t     edges;          /**< A set containing all edges of the current graph. */
	struct list_head free_edges;     /**< list of all free edges. */
	struct obstack   edges_obst;     /**< Obstack, where edges are allocated on. */
	unsigned         allocated : 1;  /**< Set if edges are allocated on the obstack. */
	unsigned         activated : 1;  /**< Set if edges are activated for the graph. */
451
452
} irg_edge_info_t;

453
typedef irg_edge_info_t irg_edges_info_t[EDGE_KIND_LAST+1];
454
455

/**
456
 * Index constants for nodes that can be accessed through the graph anchor node.
457
 */
458
459
460
461
typedef enum irg_anchors {
	anchor_first,
	anchor_end_block = anchor_first, /**< block the end node will belong to,
	                                      same as Anchors block */
462
	anchor_start_block,      /**< block the start node will belong to */
463
	anchor_end,              /**< end node of this ir_graph */
464
	anchor_start,            /**< start node of this ir_graph */
465
466
	anchor_initial_exec,     /**< methods initial control flow */
	anchor_frame,            /**< methods frame */
467
468
469
	anchor_initial_mem,      /**< initial memory of this graph */
	anchor_args,             /**< methods arguments */
	anchor_no_mem,           /**< NoMem node of this ir_graph, the one and only in this graph */
470
471
472
	anchor_last = anchor_no_mem
} irg_anchors;
ENUM_COUNTABLE(irg_anchors)
473
474
475
476
477

/** A callgraph entry for callees. */
typedef struct cg_callee_entry {
	ir_graph  *irg;        /**< The called irg. */
	ir_node  **call_list;  /**< The list of all calls to the irg. */
478
	size_t     max_depth;  /**< Maximum depth of all Call nodes to irg. */
479
480
} cg_callee_entry;

481
482
483
484
485
typedef struct ir_vrp_info {
	struct ir_nodemap infos;
	struct obstack    obst;
} ir_vrp_info;

486
487
488
489
490
491
/**
 * An ir_graph holds all information for a procedure.
 */
struct ir_graph {
	firm_kind         kind;        /**< Always set to k_ir_graph. */
	/* --  Basics of the representation -- */
yb9976's avatar
yb9976 committed
492
	unsigned last_node_idx;        /**< The last IR node index for this graph. */
493
494
495
496
497
	ir_entity  *ent;               /**< The entity of this procedure, i.e.,
	                                    the type of the procedure and the
	                                    class it belongs to. */
	ir_type *frame_type;           /**< A class type representing the stack frame.
	                                    Can include "inner" methods. */
498
	ir_node *anchor;               /**< Pointer to the anchor node of this graph. */
499
	struct obstack obst;           /**< The obstack where all of the ir_nodes live. */
500
	ir_node *current_block;        /**< Current block for new_*()ly created ir_nodes. */
501
502

	/* -- Fields indicating different states of irgraph -- */
503
504
505
506
507
	ir_graph_properties_t  properties;
	ir_graph_constraints_t constraints;
	op_pin_state           irg_pinned_state;  /**< Flag for status of nodes. */
	ir_typeinfo_state      typeinfo_state;    /**< Validity of type information. */
	irg_callee_info_state  callee_info_state; /**< Validity of callee information. */
508
509
510
511
512
513
514
515
516
517
	unsigned mem_disambig_opt;               /**< Options for the memory disambiguator. */

	/* -- Fields for construction -- */
	int n_loc;                         /**< Number of local variables in this
	                                        procedure including procedure parameters. */
	void **loc_descriptions;           /**< Storage for local variable descriptions. */

	/* -- Fields for optimizations / analysis information -- */
	pset *value_table;                 /**< Hash table for global value numbering (cse)
	                                        for optimizing use in iropt.c */
Matthias Braun's avatar
Matthias Braun committed
518
519
	struct obstack   out_obst;         /**< Space for the Def-Use arrays. */
	bool             out_obst_allocated;
520
	ir_vrp_info      vrp;              /**< vrp info */
521
522

	ir_loop *loop;                     /**< The outermost loop for this graph. */
Matthias Braun's avatar
Matthias Braun committed
523
	ir_dom_front_info_t domfront;      /**< dominance frontier analysis data */
524
525
526
527
	void *link;                        /**< A void* field to link any information to
	                                        the node. */

	ir_graph **callers;                /**< For callgraph analysis: list of caller graphs. */
Michael Beck's avatar
Michael Beck committed
528
	unsigned *caller_isbe;             /**< For callgraph analysis: raw bitset if backedge info calculated. */
529
	cg_callee_entry **callees;         /**< For callgraph analysis: list of callee calls */
Michael Beck's avatar
Michael Beck committed
530
	unsigned *callee_isbe;             /**< For callgraph analysis: raw bitset if backedge info calculated. */
531
	ir_loop   *l;                            /**< For callgraph analysis. */
532
533
	size_t     callgraph_loop_depth;         /**< For callgraph analysis */
	size_t     callgraph_recursion_depth;    /**< For callgraph analysis */
534
535
536
537
	double     method_execution_frequency;   /**< For callgraph analysis */


	/* -- Fields for Walking the graph -- */
538
	ir_visited_t visited;             /**< this flag is an identifier for
539
540
541
	                  ir walk. it will be incremented
	                  every time someone walks through
	                  the graph */
542
	ir_visited_t block_visited;        /**< same as visited, for a complete block */
543

544
	ir_visited_t self_visited;         /**< visited flag of the irg */
545

546
547
548
	irg_edges_info_t edge_info;        /**< edge info for automatic outs */
	ir_node **idx_irn_map;             /**< Array mapping node indexes to nodes. */

549
	size_t index;                      /**< a unique number for each graph */
550
	/** extra info which should survive accross multiple passes */
551
	void     *be_data;                 /**< backend can put in private data here */
552
553

	unsigned  dump_nr;                 /**< number of graph dumps */
554
#ifdef DEBUG_libfirm
Matthias Braun's avatar
Matthias Braun committed
555
556
	long graph_nr;                     /**< a unique graph number for each
	                                        graph to make output readable. */
557
558
559
#endif

#ifndef NDEBUG
560
	ir_resources_t reserved_resources; /**< Bitset for tracking used local resources. */
561
562
563
#endif
};

564
565
566
567
568
569
570
571
572
573
574
575
576
577
578
/**
 * Data structure that holds central information about a program
 * or a module.
 * One irp is created by libFirm on construction, so irp should never be NULL.
 *
 * - main_irg:  The ir graph that is the entry point to the program.
 *              (Anything not reachable from here may be optimized away
 *              if this irp represents a whole program.
 * - irg:       List of all ir graphs in the program or module.
 * - type:      A list containing all types known to the translated program.
 *              Some types can have several entries in this list (as a result of
 *              using exchange_types()).
 * - glob_type: The unique global type that is owner of all global entities
 *              of this module.
 */
579
580
581
582
583
584
585
586
587
588
struct ir_prog {
	firm_kind kind;                 /**< must be k_ir_prog */
	ident     *name;                /**< A file name or the like. */
	ir_graph  *main_irg;            /**< The entry point to the compiled program
	                                     or NULL if no point exists. */
	ir_graph **graphs;              /**< A list of all graphs in the ir. */
	ir_graph  *const_code_irg;      /**< This ir graph gives the proper environment
	                                     to allocate nodes the represent values
	                                     of constant entities. It is not meant as
	                                     a procedure.  */
589
	ir_entity *unknown_entity;      /**< unique 'unknown'-entity */
590
	ir_type   *segment_types[IR_SEGMENT_LAST+1];
591
	ir_type  **types;               /**< A list of all types in the ir. */
592
593
	ir_type   *code_type;           /**< unique 'code'-type */
	ir_type   *unknown_type;        /**< unique 'unknown'-type */
594
	ir_type   *byte_type;           /**< type for a 'byte' */
595
	ident    **global_asms;         /**< An array of global ASM insertions. */
596
597
598
599
600
601
602
603
604
605
606
607
608
609

	/* -- states of and access to generated information -- */
	ir_node **ip_outedges;          /**< A huge Array that contains all out edges
	                                     in interprocedural view. */

	irg_callee_info_state callee_info_state; /**< Validity of callee information.
	                                              Contains the lowest value or all irgs.  */
	ir_typeinfo_state typeinfo_state;    /**< Validity of type information. */
	inh_transitive_closure_state inh_trans_closure_state;  /**< State of transitive closure
	                                                            of inheritance relations. */

	irp_callgraph_state callgraph_state; /**< The state of the callgraph. */
	ir_loop *outermost_cg_loop;          /**< For callgraph analysis: entry point
	                                              to looptree over callgraph. */
610
611
	size_t max_callgraph_loop_depth;        /**< needed in callgraph. */
	size_t max_callgraph_recursion_depth;   /**< needed in callgraph. */
612
613
	double max_method_execution_frequency;  /**< needed in callgraph. */
	loop_nesting_depth_state lnd_state;  /**< The state of loop nesting depth information. */
614
	ir_entity_usage_computed_state globals_entity_usage_state;
615

616
	ir_label_t last_label_nr;            /**< The highest label number for generating unique labels. */
617
	size_t max_irg_idx;                  /**< highest unused irg index */
618
	long max_node_nr;                    /**< to generate unique numbers for nodes. */
619
	unsigned dump_nr;                    /**< number of program info dumps */
620
	pmap *compilerlib_entities;          /**< maps ident* to ir_entity* of the compilerlib */
621
#ifndef NDEBUG
yb9976's avatar
yb9976 committed
622
	irp_resources_t reserved_resources;  /**< Bitset for tracking used global resources. */
623
#endif
624
625
626
};

#endif