irtypes.h 27.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
	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 */
};

Matthias Braun's avatar
Matthias Braun committed
181
182
183
184
185
186
187
188
189
190
191
192
/* 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[];
};

193
194
/* ir node attributes */

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

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

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

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

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

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

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

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

/** Exception attributes. */
249
typedef struct except_attr {
250
251
252
253
254
255
	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 */
256
257
258
} except_attr;

/** Call attributes. */
259
typedef struct call_attr {
260
261
262
	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 */
263
264
} call_attr;

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

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

/** Load attributes. */
278
typedef struct load_attr {
279
	except_attr   exc;            /**< The exception attribute. MUST be the first one. */
280
281
	ENUMBF(ir_volatility) volatility:1;   /**< The volatility of this Load operation. */
	ENUMBF(ir_align)      unaligned:1;    /**< The align attribute of this Load operation. */
282
	ir_mode       *mode;          /**< The mode of this Load operation. */
283
284
285
} load_attr;

/** Store attributes. */
286
typedef struct store_attr {
287
	except_attr   exc;            /**< the exception attribute. MUST be the first one. */
288
289
	ENUMBF(ir_volatility) volatility:1;   /**< The volatility of this Store operation. */
	ENUMBF(ir_align)      unaligned:1;    /**< The align attribute of this Store operation. */
290
291
} store_attr;

292
typedef struct phi_attr {
293
294
	ir_node        *next;         /**< Points to the next Phi in the Phi list of a block. */
	union {
295
		bitset_t      *backedge;     /**< Raw Bitfield: bit n is set to true if pred n is backedge. */
296
297
298
299
300
301
302
303
304
		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;

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

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

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

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

/** Inline Assembler support attribute. */
335
typedef struct asm_attr {
336
	/* BEWARE: pin state MUST be the first attribute */
337
338
339
340
341
	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. */
342
343
} asm_attr;

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

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

353
354
/** Some IR-nodes just have one attribute, these are stored here,
   some have more. Their name is 'irnodename_attr' */
355
typedef union ir_attr {
356
	irg_attr       irg;           /**< For Blocks and Bad: its belonging irg */
357
	bad_attr       bad;           /**< for Bads: irg reference */
358
	anchor_attr    anchor;        /**< for Anchor: irg reference */
359
	block_attr     block;         /**< For Block: Fields needed to construct it */
360
	cmp_attr       cmp;           /**< For Cmp. */
361
362
363
364
	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. */
365
366
	call_attr      call;          /**< For Call. */
	builtin_attr   builtin;       /**< For Builtin. */
367
368
369
	alloc_attr     alloc;         /**< For Alloc. */
	load_attr      load;          /**< For Load. */
	store_attr     store;         /**< For Store. */
370
	phi_attr       phi;           /**< For Phi. */
371
	proj_attr      proj;          /**< For Proj. */
372
373
374
	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 */
375
376
	div_attr       div;           /**< For Div operation */
	mod_attr       mod;           /**< For Mod operation */
377
	asm_attr       assem;         /**< For ASM operation. */
Matthias Braun's avatar
Matthias Braun committed
378
	switch_attr    switcha;       /**< For Switch operation. */
379
} ir_attr;
380
381
382
383

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

390
typedef irn_edge_info_t irn_edges_info_t[EDGE_KIND_LAST+1];
391

392
393
394
/**
 * A Def-Use edge.
 */
395
typedef struct ir_def_use_edge {
396
397
398
399
	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
400
401
402
403
404
typedef struct ir_def_use_edges {
	unsigned        n_edges;
	ir_def_use_edge edges[];
} ir_def_use_edges;

405
406
407
408
409
410
411
/**
 * 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
412
	unsigned node_idx;       /**< The node index of this node in its graph. */
413
414
415
	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. */
416
	ir_visited_t visited;    /**< The visited counter for walks of the graph. */
417
	void *link;              /**< To attach additional information to the node, e.g.
Michael Beck's avatar
Michael Beck committed
418
	                              used during optimization to link to nodes that
419
	                              shall replace a node. */
420
	long node_nr;            /**< A globally unique node number for each node. */
421
	/* ------- Fields for optimizations / analysis information ------- */
Matthias Braun's avatar
Matthias Braun committed
422
423
424
425
426
427
	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. */
428
429
430
	/* ------- 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. */
431
	void            *backend_info;
432
	irn_edges_info_t edge_info;  /**< Everlasting out edges. */
433

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

439
440
#include "iredgeset.h"

441
442
443
/**
 * Edge info to put into an irg.
 */
444
typedef struct irg_edge_info_t {
445
446
447
448
449
	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. */
450
451
} irg_edge_info_t;

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

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

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

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

485
486
487
488
489
490
/**
 * 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
491
	unsigned last_node_idx;        /**< The last IR node index for this graph. */
492
493
494
495
496
	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. */
497
	ir_node *anchor;               /**< Pointer to the anchor node of this graph. */
498
	struct obstack obst;           /**< The obstack where all of the ir_nodes live. */
499
	ir_node *current_block;        /**< Current block for new_*()ly created ir_nodes. */
500
501

	/* -- Fields indicating different states of irgraph -- */
502
503
504
505
506
	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. */
507
508
509
510
511
512
513
514
515
516
	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
517
518
	struct obstack   out_obst;         /**< Space for the Def-Use arrays. */
	bool             out_obst_allocated;
519
	ir_vrp_info      vrp;              /**< vrp info */
520
521

	ir_loop *loop;                     /**< The outermost loop for this graph. */
Matthias Braun's avatar
Matthias Braun committed
522
	ir_dom_front_info_t domfront;      /**< dominance frontier analysis data */
523
524
525
526
	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
527
	unsigned *caller_isbe;             /**< For callgraph analysis: raw bitset if backedge info calculated. */
528
	cg_callee_entry **callees;         /**< For callgraph analysis: list of callee calls */
Michael Beck's avatar
Michael Beck committed
529
	unsigned *callee_isbe;             /**< For callgraph analysis: raw bitset if backedge info calculated. */
530
	ir_loop   *l;                            /**< For callgraph analysis. */
531
532
	size_t     callgraph_loop_depth;         /**< For callgraph analysis */
	size_t     callgraph_recursion_depth;    /**< For callgraph analysis */
533
534
535
536
	double     method_execution_frequency;   /**< For callgraph analysis */


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

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

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

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

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

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

563
564
565
566
567
568
569
570
571
572
573
574
575
576
577
/**
 * 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.
 */
578
579
580
581
582
583
584
585
586
587
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.  */
588
	ir_entity *unknown_entity;      /**< unique 'unknown'-entity */
589
	ir_type   *segment_types[IR_SEGMENT_LAST+1];
590
	ir_type  **types;               /**< A list of all types in the ir. */
591
592
	ir_type   *code_type;           /**< unique 'code'-type */
	ir_type   *unknown_type;        /**< unique 'unknown'-type */
593
	ir_type   *byte_type;           /**< type for a 'byte' */
594
	ident    **global_asms;         /**< An array of global ASM insertions. */
595
596
597
598
599
600
601
602
603
604
605
606
607
608

	/* -- 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. */
609
610
	size_t max_callgraph_loop_depth;        /**< needed in callgraph. */
	size_t max_callgraph_recursion_depth;   /**< needed in callgraph. */
611
612
	double max_method_execution_frequency;  /**< needed in callgraph. */
	loop_nesting_depth_state lnd_state;  /**< The state of loop nesting depth information. */
613
	ir_entity_usage_computed_state globals_entity_usage_state;
614

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

#endif