irtypes.h 28.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 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
	except_attr    exc;           /**< the exception attribute. MUST be the first one. */
276
277
    ir_where_alloc where;         /**< stack, heap or other managed part of memory */
	ir_type        *type;         /**< Type of the allocated object.  */
278
279
280
} alloc_attr;

/** Free attributes. */
281
typedef struct free_attr {
282
	ir_type *type;                /**< Type of the allocated object.  */
283
	ir_where_alloc where;         /**< stack, heap or other managed part of memory */
284
285
286
} free_attr;

/** InstOf attributes. */
287
typedef struct io_attr {
288
289
290
291
292
	except_attr    exc;           /**< the exception attribute. MUST be the first one. */
	ir_type *type;                /**< the type of which the object pointer must be */
} io_attr;

/** Load attributes. */
293
typedef struct load_attr {
294
	except_attr   exc;            /**< The exception attribute. MUST be the first one. */
Matthias Braun's avatar
Matthias Braun committed
295
296
	__extension__ ir_volatility volatility:1;   /**< The volatility of this Load operation. */
	__extension__ ir_align      unaligned:1;    /**< The align attribute of this Load operation. */
297
	ir_mode       *mode;          /**< The mode of this Load operation. */
298
299
300
} load_attr;

/** Store attributes. */
301
typedef struct store_attr {
302
	except_attr   exc;            /**< the exception attribute. MUST be the first one. */
Matthias Braun's avatar
Matthias Braun committed
303
304
	__extension__ ir_volatility volatility:1;   /**< The volatility of this Store operation. */
	__extension__ ir_align      unaligned:1;    /**< The align attribute of this Store operation. */
305
306
} store_attr;

307
typedef struct phi_attr {
308
309
	ir_node        *next;         /**< Points to the next Phi in the Phi list of a block. */
	union {
310
		bitset_t      *backedge;     /**< Raw Bitfield: bit n is set to true if pred n is backedge. */
311
312
313
314
315
316
317
318
319
		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;

320
321
322
323
/**< Cmp attribute. */
typedef struct cmp_attr {
	ir_relation relation;         /**< comparison condition. */
} cmp_attr;
324
325

/**< Confirm attribute. */
326
typedef struct confirm_attr {
327
	ir_relation relation;         /**< relation between value and bound */
328
329
330
} confirm_attr;

/** CopyB attribute. */
331
typedef struct copyb_attr {
332
	except_attr    exc;           /**< The exception attribute. MUST be the first one. */
333
	ir_type        *type;         /**< Type of the copied entity. */
334
335
} copyb_attr;

336
337
/** Div attribute. */
typedef struct div_attr {
338
	except_attr    exc;           /**< The exception attribute. MUST be the first one. */
339
	ir_mode        *resmode;      /**< Result mode for the division. */
340
	char           no_remainder;  /**< Set, if known that a division can be done without a remainder. */
341
342
343
344
345
346
347
} 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;
348
349

/** Inline Assembler support attribute. */
350
typedef struct asm_attr {
351
	/* BEWARE: pin state MUST be the first attribute */
352
353
354
355
356
	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. */
357
358
} asm_attr;

359
360
361
362
typedef struct proj_attr {
	long  proj;           /**< position of tuple sub-value which is projected */
} proj_attr;

Matthias Braun's avatar
Matthias Braun committed
363
364
365
366
367
typedef struct switch_attr {
	unsigned         n_outs;
	ir_switch_table *table;
} switch_attr;

368
369
/** Some IR-nodes just have one attribute, these are stored here,
   some have more. Their name is 'irnodename_attr' */
370
typedef union ir_attr {
371
	irg_attr       irg;           /**< For Blocks and Bad: its belonging irg */
372
	bad_attr       bad;           /**< for Bads: irg reference */
373
	anchor_attr    anchor;        /**< for Anchor: irg reference */
374
	block_attr     block;         /**< For Block: Fields needed to construct it */
375
	cmp_attr       cmp;           /**< For Cmp. */
376
377
378
379
	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. */
380
381
	call_attr      call;          /**< For Call. */
	builtin_attr   builtin;       /**< For Builtin. */
382
383
384
385
386
	alloc_attr     alloc;         /**< For Alloc. */
	free_attr      free;          /**< For Free. */
	io_attr        instof;        /**< For InstOf */
	load_attr      load;          /**< For Load. */
	store_attr     store;         /**< For Store. */
387
	phi_attr       phi;           /**< For Phi. */
388
	proj_attr      proj;          /**< For Proj. */
389
390
391
	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 */
392
393
	div_attr       div;           /**< For Div operation */
	mod_attr       mod;           /**< For Mod operation */
394
	asm_attr       assem;         /**< For ASM operation. */
Matthias Braun's avatar
Matthias Braun committed
395
	switch_attr    switcha;       /**< For Switch operation. */
396
} ir_attr;
397
398
399
400

/**
 * Edge info to put into an irn.
 */
401
typedef struct irn_edge_kind_info_t {
402
	struct list_head outs_head;  /**< The list of all outs. */
Michael Beck's avatar
Michael Beck committed
403
404
	unsigned edges_built : 1;    /**< Set edges where built for this node. */
	unsigned out_count : 31;     /**< Number of outs in the list. */
405
406
407
408
} irn_edge_info_t;

typedef irn_edge_info_t irn_edges_info_t[EDGE_KIND_LAST];

409
410
411
/**
 * A Def-Use edge.
 */
412
typedef struct ir_def_use_edge {
413
414
415
416
	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
417
418
419
420
421
typedef struct ir_def_use_edges {
	unsigned        n_edges;
	ir_def_use_edge edges[];
} ir_def_use_edges;

422
423
424
425
426
427
428
/**
 * 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
429
	unsigned node_idx;       /**< The node index of this node in its graph. */
430
431
432
	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. */
433
	ir_visited_t visited;    /**< The visited counter for walks of the graph. */
434
	void *link;              /**< To attach additional information to the node, e.g.
Michael Beck's avatar
Michael Beck committed
435
	                              used during optimization to link to nodes that
436
	                              shall replace a node. */
437
	long node_nr;            /**< A globally unique node number for each node. */
438
	/* ------- Fields for optimizations / analysis information ------- */
Matthias Braun's avatar
Matthias Braun committed
439
440
441
442
443
444
	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. */
445
446
447
	/* ------- 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. */
448
	void            *backend_info;
449
	irn_edges_info_t edge_info;  /**< Everlasting out edges. */
450

451
	/* ------- Opcode depending fields -------- */
452
	ir_attr attr;            /**< The set of attributes of this node. Depends on opcode.
453
454
455
	                              Must be last field of struct ir_node. */
};

456
457
#include "iredgeset.h"

458
459
460
/**
 * Edge info to put into an irg.
 */
461
typedef struct irg_edge_info_t {
462
463
464
465
466
	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. */
467
468
469
470
471
} irg_edge_info_t;

typedef irg_edge_info_t irg_edges_info_t[EDGE_KIND_LAST];

/**
472
 * Index constants for nodes that can be accessed through the graph anchor node.
473
 */
474
475
476
477
typedef enum irg_anchors {
	anchor_first,
	anchor_end_block = anchor_first, /**< block the end node will belong to,
	                                      same as Anchors block */
478
	anchor_start_block,      /**< block the start node will belong to */
479
	anchor_end,              /**< end node of this ir_graph */
480
	anchor_start,            /**< start node of this ir_graph */
481
482
	anchor_initial_exec,     /**< methods initial control flow */
	anchor_frame,            /**< methods frame */
483
484
485
	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 */
486
487
488
	anchor_last = anchor_no_mem
} irg_anchors;
ENUM_COUNTABLE(irg_anchors)
489
490
491
492
493

/** 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. */
494
	size_t     max_depth;  /**< Maximum depth of all Call nodes to irg. */
495
496
} cg_callee_entry;

497
498
499
500
501
typedef struct ir_vrp_info {
	struct ir_nodemap infos;
	struct obstack    obst;
} ir_vrp_info;

502
503
504
505
506
507
/**
 * 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
508
	unsigned last_node_idx;        /**< The last IR node index for this graph. */
509
510
511
512
513
	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. */
514
	ir_node *anchor;               /**< Pointer to the anchor node of this graph. */
515
	struct obstack obst;           /**< The obstack where all of the ir_nodes live. */
516
	ir_node *current_block;        /**< Current block for new_*()ly created ir_nodes. */
517
518

	/* -- Fields indicating different states of irgraph -- */
519
520
521
522
523
	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. */
524
525
526
527
528
529
530
531
532
533
534
	unsigned mem_disambig_opt;               /**< Options for the memory disambiguator. */
	unsigned fp_model;                       /**< floating point model of the graph. */

	/* -- 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
535
536
	struct obstack   out_obst;         /**< Space for the Def-Use arrays. */
	bool             out_obst_allocated;
537
	ir_vrp_info      vrp;              /**< vrp info */
538
539

	ir_loop *loop;                     /**< The outermost loop for this graph. */
Matthias Braun's avatar
Matthias Braun committed
540
	ir_dom_front_info_t domfront;      /**< dominance frontier analysis data */
541
542
543
544
	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
545
	unsigned *caller_isbe;             /**< For callgraph analysis: raw bitset if backedge info calculated. */
546
	cg_callee_entry **callees;         /**< For callgraph analysis: list of callee calls */
Michael Beck's avatar
Michael Beck committed
547
	unsigned *callee_isbe;             /**< For callgraph analysis: raw bitset if backedge info calculated. */
548
	ir_loop   *l;                            /**< For callgraph analysis. */
549
550
	size_t     callgraph_loop_depth;         /**< For callgraph analysis */
	size_t     callgraph_recursion_depth;    /**< For callgraph analysis */
551
552
553
554
	double     method_execution_frequency;   /**< For callgraph analysis */


	/* -- Fields for Walking the graph -- */
555
	ir_visited_t visited;             /**< this flag is an identifier for
556
557
558
	                  ir walk. it will be incremented
	                  every time someone walks through
	                  the graph */
559
	ir_visited_t block_visited;        /**< same as visited, for a complete block */
560

561
	ir_visited_t self_visited;         /**< visited flag of the irg */
562

563
564
565
	irg_edges_info_t edge_info;        /**< edge info for automatic outs */
	ir_node **idx_irn_map;             /**< Array mapping node indexes to nodes. */

566
	size_t index;                      /**< a unique number for each graph */
567
	/** extra info which should survive accross multiple passes */
568
	void     *be_data;                 /**< backend can put in private data here */
569
570

	unsigned  dump_nr;                 /**< number of graph dumps */
571
#ifdef DEBUG_libfirm
Matthias Braun's avatar
Matthias Braun committed
572
573
	long graph_nr;                     /**< a unique graph number for each
	                                        graph to make output readable. */
574
575
576
#endif

#ifndef NDEBUG
577
	ir_resources_t reserved_resources; /**< Bitset for tracking used local resources. */
578
579
580
#endif
};

581
582
583
584
585
586
587
588
589
590
591
592
593
594
595
/**
 * 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.
 */
596
597
598
599
600
601
602
603
604
605
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.  */
606
	ir_entity *unknown_entity;      /**< unique 'unknown'-entity */
607
	ir_type   *segment_types[IR_SEGMENT_LAST+1];
608
	ir_type  **types;               /**< A list of all types in the ir. */
609
610
611
	ir_type   *none_type;           /**< unique 'none'-type */
	ir_type   *code_type;           /**< unique 'code'-type */
	ir_type   *unknown_type;        /**< unique 'unknown'-type */
612
	ir_type   *byte_type;           /**< type for a 'byte' */
613
	ident    **global_asms;         /**< An array of global ASM insertions. */
614
615
616
617
618
619
620
621
622
623
624
625
626
627

	/* -- 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. */
628
629
	size_t max_callgraph_loop_depth;        /**< needed in callgraph. */
	size_t max_callgraph_recursion_depth;   /**< needed in callgraph. */
630
631
	double max_method_execution_frequency;  /**< needed in callgraph. */
	loop_nesting_depth_state lnd_state;  /**< The state of loop nesting depth information. */
632
	ir_entity_usage_computed_state globals_entity_usage_state;
633

634
	ir_label_t last_label_nr;            /**< The highest label number for generating unique labels. */
635
	size_t max_irg_idx;                  /**< highest unused irg index */
636
	long max_node_nr;                    /**< to generate unique numbers for nodes. */
637
	unsigned dump_nr;                    /**< number of program info dumps */
638
	pmap *compilerlib_entities;          /**< maps ident* to ir_entity* of the compilerlib */
639
#ifndef NDEBUG
yb9976's avatar
yb9976 committed
640
	irp_resources_t reserved_resources;  /**< Bitset for tracking used global resources. */
641
#endif
642
643
644
};

#endif