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

20
/*
Michael Beck's avatar
Michael Beck committed
21
22
23
24
 * @file     entity_t.h
 * @brief   Representation of all program known entities -- private header.
 * @author  Martin Trapp, Christian Schaefer, Goetz Lindenmaier, Michael Beck
 * @version $Id$
25
 */
Michael Beck's avatar
Michael Beck committed
26
27
#ifndef FIRM_TR_ENTITY_T_H
#define FIRM_TR_ENTITY_T_H
Götz Lindenmaier's avatar
Götz Lindenmaier committed
28

29
30
#include <assert.h>

31
#include "firm_common_t.h"
32
#include "firm_config.h"
33

34
#include "typerep.h"
Michael Beck's avatar
Michael Beck committed
35
#include "type_t.h"
36
#include "ident.h"
Michael Beck's avatar
Michael Beck committed
37
#include "pseudo_irg.h"
38

39
40
41
42
typedef struct ir_initializer_base_t {
	ir_initializer_kind_t kind;
} ir_initializer_base_t;

Michael Beck's avatar
Michael Beck committed
43
44
45
/**
 * An compound initializer.
 */
46
47
48
49
50
51
typedef struct ir_initializer_compound_t {
	ir_initializer_base_t  base;
	unsigned               n_initializers;
	ir_initializer_t      *initializers[1];
} ir_initializer_compound_t;

Michael Beck's avatar
Michael Beck committed
52
53
54
/**
 * An initializer containing an ir_node,
 */
55
56
57
58
59
typedef struct ir_initializer_const_t {
	ir_initializer_base_t  base;
	ir_node               *value;
} ir_initializer_const_t ;

Michael Beck's avatar
Michael Beck committed
60
61
62
/**
 * An initializer containing a tarval.
 */
63
64
65
66
67
68
69
70
71
72
73
74
75
typedef struct ir_initializer_tarval_t {
	ir_initializer_base_t  base;
	tarval                *value;
} ir_initializer_tarval_t ;

union ir_initializer_t {
	ir_initializer_kind_t      kind;
	ir_initializer_base_t      base;
	ir_initializer_compound_t  compound;
	ir_initializer_const_t     consti;
	ir_initializer_tarval_t    tarval;
};

76
/** A path in a compound graph. */
77
struct compound_graph_path {
78
79
80
81
82
83
84
	firm_kind kind;       /**< The dynamic type tag for compound graph path. */
	ir_type *tp;          /**< The type this path belongs to. */
	int len;              /**< The length of the path. */
	struct tuple {
		int       index;    /**< Array index.  To compute position of array elements */
		ir_entity *node;    /**< The accessed entity. */
	} list[1];            /**< List of entity/index tuple of length len to express the
85
	                           access path. */
86
87
};

88
/** The attributes for atomic entities. */
89
typedef struct atomic_ent_attr {
90
91
	ir_node *value;            /**< value if entity is not of variability uninitialized.
	                             Only for atomic entities. */
92
} atomic_ent_attr;
93

94
/** The attributes for compound entities. */
95
typedef struct compound_ent_attr {
96
97
98
99
100
	ir_node **values;     /**< constant values of compound entities. Only available if
	                           variability not uninitialized.  Must be set for variability constant. */
	compound_graph_path **val_paths;
	                     /**< paths corresponding to constant values. Only available if
	                          variability not uninitialized.  Must be set for variability constant. */
101
102
} compound_ent_attr;

103
/** A reserved value for "not yet set". */
104
105
#define VTABLE_NUM_NOT_SET ((unsigned)(-1))

106
/** The attributes for methods. */
107
typedef struct method_ent_attr {
108
109
110
111
112
113
114
115
116
	ir_graph *irg;                 /**< The corresponding irg if known.
	                                    The ir_graph constructor automatically sets this field. */
	unsigned irg_add_properties;   /**< Additional graph properties can be
	                                    stored in a entity if no irg is available. */

	unsigned vtable_number;        /**< For a dynamically called method, the number assigned
	                                    in the virtual function table. */

	ptr_access_kind *param_access; /**< the parameter access */
117
118
	unsigned *param_weight;        /**< The weight of method's parameters. Parameters
	                                    with a high weight are good candidates for procedure cloning. */
119
120
121
} method_ent_attr;


Michael Beck's avatar
Michael Beck committed
122
123
124
125
126
/**
 * An abstract data type to represent program entities.
 *
 * @see  ir_type
 */
Michael Beck's avatar
Michael Beck committed
127
struct ir_entity {
128
129
130
131
132
133
134
135
136
137
138
	firm_kind kind;       /**< The dynamic type tag for entity. */
	ident *name;          /**< The name of this entity. */
	ident *ld_name;       /**< Unique name of this entity, i.e., the mangled
	                           name.  If the field is read before written a default
	                           mangling is applies.  The name of the owner is prepended
	                           to the name of the entity, separated by a underscore.
	                           E.g.,  for a class `A' with field `a' this
	                           is the ident for `A_a'. */
	ir_type *type;        /**< The type of this entity, e.g., a method type, a
	                           basic type of the language or a class itself. */
	ir_type *owner;       /**< The compound type (e.g. class type) this entity belongs to. */
139
140
141
142
143
144
145
146
147
	unsigned allocation:3;         /**< Distinguishes static and dynamically allocated
	                                    entities and some further cases. */
	unsigned visibility:3;         /**< Specifies visibility to external program fragments. */
	unsigned variability:3;        /**< Specifies variability of entities content. */
	unsigned volatility:1;         /**< Specifies volatility of entities content. */
	unsigned align:1;              /**< Specifies alignment of entities content. */
	unsigned stickyness:2;         /**< Specifies whether this entity is sticky.  */
	unsigned peculiarity:3;        /**< The peculiarity of this entity. */
	unsigned address_taken:3;      /**< A flag that can be set to mark address taken entities. */
148
149
	unsigned final:1;              /**< If set, this entity cannot be overridden. */
	unsigned compiler_gen:1;       /**< If set, this entity was compiler generated. */
Michael Beck's avatar
Michael Beck committed
150
	unsigned backend_marked:1;     /**< If set, this entity was marked by the backend for emission. */
Michael Beck's avatar
Michael Beck committed
151
	unsigned has_initializer:1;    /**< if set, this entity is initialized by new style initializers. */
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
	int offset;                    /**< Offset in bytes for this entity.  Fixed when layout
	                                    of owner is determined. */
	unsigned char offset_bit_remainder;
	                               /**< If the entity is a bit field, this is the offset of
	                                    the start of the bit field within the byte specified
	                                    by offset. */
	unsigned long visit;           /**< visited counter for walks of the type information. */
	struct dbg_info *dbi;          /**< A pointer to information for debug support. */
	void *link;                    /**< To store some intermediate information. */
	ir_type *repr_class;           /**< If this entity represents a class info, the associated class. */

	/* ------------- fields for entities owned by a class type ---------------*/

	ir_entity **overwrites;     /**< A list of entities this entity overwrites. */
	ir_entity **overwrittenby;  /**< A list of entities that overwrite this entity.  */

	/* ------------- fields for atomic entities  --------------- */
	ir_node *value;          /**< value if entity is not of variability uninitialized.
	                              Only for atomic entities. */
	union {
		/* ------------- fields for compound entities -------------- */
		compound_ent_attr cmpd_attr;
		/* ------------- fields for method entities ---------------- */
		method_ent_attr   mtd_attr;
176
177
		/* entity initializer */
		ir_initializer_t *initializer;
178
179
180
	} attr; /**< type specific attributes */

	/* ------------- fields for analyses ---------------*/
181

182
#ifdef DEBUG_libfirm
183
	long nr;             /**< A unique node number for each node to make output readable. */
Florian Liekweg's avatar
Florian Liekweg committed
184
# endif /* DEBUG_libfirm */
Götz Lindenmaier's avatar
Götz Lindenmaier committed
185
186
};

187
/** Initialize the entity module. */
188
void firm_init_entity(void);
189
190


Michael Beck's avatar
Michael Beck committed
191
192
/* ----------------------- inline functions ------------------------ */
static INLINE int
193
_is_entity(const void *thing) {
194
	return get_kind(thing) == k_entity;
Michael Beck's avatar
Michael Beck committed
195
196
197
}

static INLINE const char *
Michael Beck's avatar
Michael Beck committed
198
_get_entity_name(const ir_entity *ent) {
199
200
	assert(ent && ent->kind == k_entity);
	return get_id_str(get_entity_ident(ent));
Michael Beck's avatar
Michael Beck committed
201
202
203
}

static INLINE ident *
Michael Beck's avatar
Michael Beck committed
204
_get_entity_ident(const ir_entity *ent) {
205
206
	assert(ent && ent->kind == k_entity);
	return ent->name;
Michael Beck's avatar
Michael Beck committed
207
208
}

209
static INLINE void
Michael Beck's avatar
Michael Beck committed
210
_set_entity_ident(ir_entity *ent, ident *id) {
211
212
	assert(ent && ent->kind == k_entity);
	ent->name = id;
Michael Beck's avatar
Michael Beck committed
213
214
}

215
static INLINE ir_type *
Michael Beck's avatar
Michael Beck committed
216
_get_entity_owner(ir_entity *ent) {
217
218
	assert(ent && ent->kind == k_entity);
	return ent->owner = skip_tid(ent->owner);
Michael Beck's avatar
Michael Beck committed
219
220
221
}

static INLINE ident *
Michael Beck's avatar
Michael Beck committed
222
_get_entity_ld_ident(ir_entity *ent)
Michael Beck's avatar
Michael Beck committed
223
{
224
225
226
227
	assert(ent && ent->kind == k_entity);
	if (ent->ld_name == NULL)
		ent->ld_name = mangle_entity(ent);
	return ent->ld_name;
Michael Beck's avatar
Michael Beck committed
228
229
230
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
231
_set_entity_ld_ident(ir_entity *ent, ident *ld_ident) {
232
233
	assert(ent && ent->kind == k_entity);
	ent->ld_name = ld_ident;
Michael Beck's avatar
Michael Beck committed
234
235
236
}

static INLINE const char *
Michael Beck's avatar
Michael Beck committed
237
_get_entity_ld_name(ir_entity *ent) {
238
239
	assert(ent && ent->kind == k_entity);
	return get_id_str(get_entity_ld_ident(ent));
Michael Beck's avatar
Michael Beck committed
240
241
}

242
static INLINE ir_type *
Michael Beck's avatar
Michael Beck committed
243
_get_entity_type(ir_entity *ent) {
244
245
	assert(ent && ent->kind == k_entity);
	return ent->type = skip_tid(ent->type);
Michael Beck's avatar
Michael Beck committed
246
247
248
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
249
_set_entity_type(ir_entity *ent, ir_type *type) {
250
251
	assert(ent && ent->kind == k_entity);
	ent->type = type;
Michael Beck's avatar
Michael Beck committed
252
253
}

254
static INLINE ir_allocation
Michael Beck's avatar
Michael Beck committed
255
_get_entity_allocation(const ir_entity *ent) {
256
257
	assert(ent && ent->kind == k_entity);
	return ent->allocation;
Michael Beck's avatar
Michael Beck committed
258
259
260
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
261
_set_entity_allocation(ir_entity *ent, ir_allocation al) {
262
263
	assert(ent && ent->kind == k_entity);
	ent->allocation = al;
Michael Beck's avatar
Michael Beck committed
264
265
}

266
static INLINE ir_visibility
Michael Beck's avatar
Michael Beck committed
267
_get_entity_visibility(const ir_entity *ent) {
268
269
	assert(ent && ent->kind == k_entity);
	return ent->visibility;
Michael Beck's avatar
Michael Beck committed
270
271
}

272
static INLINE ir_variability
Michael Beck's avatar
Michael Beck committed
273
_get_entity_variability(const ir_entity *ent) {
274
275
	assert(ent && ent->kind == k_entity);
	return ent->variability;
Michael Beck's avatar
Michael Beck committed
276
277
}

278
static INLINE ir_volatility
Michael Beck's avatar
Michael Beck committed
279
_get_entity_volatility(const ir_entity *ent) {
280
281
	assert(ent && ent->kind == k_entity);
	return ent->volatility;
Michael Beck's avatar
Michael Beck committed
282
283
284
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
285
_set_entity_volatility(ir_entity *ent, ir_volatility vol) {
286
287
	assert(ent && ent->kind == k_entity);
	ent->volatility = vol;
Michael Beck's avatar
Michael Beck committed
288
289
}

290
291
292
293
294
295
296
297
298
299
300
301
static INLINE ir_align
_get_entity_align(const ir_entity *ent) {
	assert(ent && ent->kind == k_entity);
	return ent->align;
}

static INLINE void
_set_entity_align(ir_entity *ent, ir_align a) {
	assert(ent && ent->kind == k_entity);
	ent->align = a;
}

302
static INLINE ir_peculiarity
Michael Beck's avatar
Michael Beck committed
303
_get_entity_peculiarity(const ir_entity *ent) {
304
305
	assert(ent && ent->kind == k_entity);
	return ent->peculiarity;
Michael Beck's avatar
Michael Beck committed
306
307
308
}

/**
Götz Lindenmaier's avatar
Götz Lindenmaier committed
309
310
311
312
313
 * @todo Why peculiarity only for methods?
 *       Good question.  Originally, there were only description and
 *       existent.  The thought was, what sense does it make to
 *       describe a field?  With inherited the situation changed.  So
 *       I removed the assertion.  GL, 28.2.05
Michael Beck's avatar
Michael Beck committed
314
315
 */
static INLINE void
Michael Beck's avatar
Michael Beck committed
316
_set_entity_peculiarity(ir_entity *ent, ir_peculiarity pec) {
317
318
319
	assert(ent && ent->kind == k_entity);
	/* @@@ why peculiarity only for methods? */
	//assert(is_Method_type(ent->type));
320

321
	ent->peculiarity = pec;
Michael Beck's avatar
Michael Beck committed
322
323
}

324
static INLINE ir_stickyness
Michael Beck's avatar
Michael Beck committed
325
_get_entity_stickyness(const ir_entity *ent) {
326
327
	assert(ent && ent->kind == k_entity);
	return ent->stickyness;
Michael Beck's avatar
Michael Beck committed
328
329
330
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
331
_set_entity_stickyness(ir_entity *ent, ir_stickyness stickyness) {
332
333
	assert(ent && ent->kind == k_entity);
	ent->stickyness = stickyness;
Michael Beck's avatar
Michael Beck committed
334
335
}

336
static INLINE int
Michael Beck's avatar
Michael Beck committed
337
_is_entity_final(const ir_entity *ent) {
338
339
	assert(ent && ent->kind == k_entity);
	return (int)ent->final;
340
341
342
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
343
_set_entity_final(ir_entity *ent, int final) {
344
345
	assert(ent && ent->kind == k_entity);
	ent->final = final ? 1 : 0;
346
347
}

Michael Beck's avatar
Michael Beck committed
348
349
350
351
352
353
354
355
356
357
358
359
static INLINE int
_is_entity_compiler_generated(const ir_entity *ent) {
	assert(ent && ent->kind == k_entity);
	return ent->compiler_gen;
}

static INLINE void
_set_entity_compiler_generated(ir_entity *ent, int flag) {
	assert(ent && ent->kind == k_entity);
	ent->compiler_gen = flag ? 1 : 0;
}

Michael Beck's avatar
Michael Beck committed
360
361
362
363
364
365
366
367
368
369
370
371
static INLINE int
_is_entity_backend_marked(const ir_entity *ent) {
	assert(ent && ent->kind == k_entity);
	return ent->backend_marked;
}

static INLINE void
_set_entity_backend_marked(ir_entity *ent, int flag) {
	assert(ent && ent->kind == k_entity);
	ent->backend_marked = flag ? 1 : 0;
}

Michael Beck's avatar
Michael Beck committed
372
373
374
375
376
377
378
static INLINE ir_address_taken_state
_get_entity_address_taken(const ir_entity *ent) {
	assert(ent && ent->kind == k_entity);
	return ent->address_taken;
}

static INLINE void
379
_set_entity_address_taken(ir_entity *ent, ir_address_taken_state state) {
Michael Beck's avatar
Michael Beck committed
380
	assert(ent && ent->kind == k_entity);
Matthias Braun's avatar
Matthias Braun committed
381
382
383
	assert(state == ir_address_not_taken ||
			state == ir_address_taken_unknown ||
			state == ir_address_taken);
384
	ent->address_taken = state;
Michael Beck's avatar
Michael Beck committed
385
386
}

Michael Beck's avatar
Michael Beck committed
387
static INLINE int
388
389
390
_get_entity_offset(const ir_entity *ent) {
	assert(ent && ent->kind == k_entity);
	return ent->offset;
Michael Beck's avatar
Michael Beck committed
391
392
}

393
394
395
396
static INLINE void
_set_entity_offset(ir_entity *ent, int offset) {
	assert(ent && ent->kind == k_entity);
	ent->offset = offset;
Michael Beck's avatar
Michael Beck committed
397
398
}

399
400
401
402
static INLINE unsigned char
_get_entity_offset_bits_remainder(const ir_entity *ent) {
	assert(ent && ent->kind == k_entity);
	return ent->offset_bit_remainder;
Michael Beck's avatar
Michael Beck committed
403
404
405
}

static INLINE void
406
407
408
_set_entity_offset_bits_remainder(ir_entity *ent, unsigned char offset) {
	assert(ent && ent->kind == k_entity);
	ent->offset_bit_remainder = offset;
Michael Beck's avatar
Michael Beck committed
409
410
411
}

static INLINE void *
Michael Beck's avatar
Michael Beck committed
412
_get_entity_link(const ir_entity *ent) {
413
414
	assert(ent && ent->kind == k_entity);
	return ent->link;
Michael Beck's avatar
Michael Beck committed
415
416
417
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
418
_set_entity_link(ir_entity *ent, void *l) {
419
420
	assert(ent && ent->kind == k_entity);
	ent->link = l;
Michael Beck's avatar
Michael Beck committed
421
422
423
}

static INLINE ir_graph *
Michael Beck's avatar
Michael Beck committed
424
_get_entity_irg(const ir_entity *ent) {
425
	ir_graph *irg;
426
427
	assert(ent && ent->kind == k_entity);
	assert(ent == unknown_entity || is_Method_type(ent->type));
428
429
	irg = ent->attr.mtd_attr.irg;
	if (irg != NULL && !get_visit_pseudo_irgs()	&& is_pseudo_ir_graph(irg))
430
		return NULL;
431
	return irg;
Michael Beck's avatar
Michael Beck committed
432
433
}

Michael Beck's avatar
Michael Beck committed
434
static INLINE unsigned long
Michael Beck's avatar
Michael Beck committed
435
_get_entity_visited(ir_entity *ent) {
436
437
	assert(ent && ent->kind == k_entity);
	return ent->visit;
Michael Beck's avatar
Michael Beck committed
438
439
440
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
441
_set_entity_visited(ir_entity *ent, unsigned long num) {
442
443
	assert(ent && ent->kind == k_entity);
	ent->visit = num;
Michael Beck's avatar
Michael Beck committed
444
445
446
}

static INLINE void
Michael Beck's avatar
Michael Beck committed
447
_mark_entity_visited(ir_entity *ent) {
448
449
	assert(ent && ent->kind == k_entity);
	ent->visit = firm_type_visited;
Michael Beck's avatar
Michael Beck committed
450
451
452
}

static INLINE int
Michael Beck's avatar
Michael Beck committed
453
_entity_visited(ir_entity *ent) {
454
	return _get_entity_visited(ent) >= firm_type_visited;
Michael Beck's avatar
Michael Beck committed
455
456
457
}

static INLINE int
Michael Beck's avatar
Michael Beck committed
458
_entity_not_visited(ir_entity *ent) {
459
	return _get_entity_visited(ent) < firm_type_visited;
Michael Beck's avatar
Michael Beck committed
460
461
}

462
static INLINE ir_type *
Michael Beck's avatar
Michael Beck committed
463
_get_entity_repr_class(const ir_entity *ent) {
464
465
	assert(ent && ent->kind == k_entity);
	return ent->repr_class;
466
467
}

468
469
470
471
472
473
474
475
476
477
478
static INLINE dbg_info *
_get_entity_dbg_info(const ir_entity *ent) {
	return ent->dbi;
}

static INLINE void
_set_entity_dbg_info(ir_entity *ent, dbg_info *db) {
	ent->dbi = db;
}


479
480
481
#define is_entity(thing)                         _is_entity(thing)
#define get_entity_name(ent)                     _get_entity_name(ent)
#define get_entity_ident(ent)                    _get_entity_ident(ent)
Michael Beck's avatar
Michael Beck committed
482
#define set_entity_ident(ent, id)                _set_entity_ident(ent, id)
483
484
485
486
487
488
489
490
491
492
493
494
#define get_entity_owner(ent)                    _get_entity_owner(ent)
#define get_entity_ld_ident(ent)                 _get_entity_ld_ident(ent)
#define set_entity_ld_ident(ent, ld_ident)       _set_entity_ld_ident(ent, ld_ident)
#define get_entity_ld_name(ent)                  _get_entity_ld_name(ent)
#define get_entity_type(ent)                     _get_entity_type(ent)
#define set_entity_type(ent, type)               _set_entity_type(ent, type)
#define get_entity_allocation(ent)               _get_entity_allocation(ent)
#define set_entity_allocation(ent, al)           _set_entity_allocation(ent, al)
#define get_entity_visibility(ent)               _get_entity_visibility(ent)
#define get_entity_variability(ent)              _get_entity_variability(ent)
#define get_entity_volatility(ent)               _get_entity_volatility(ent)
#define set_entity_volatility(ent, vol)          _set_entity_volatility(ent, vol)
495
496
#define get_entity_align(ent)                    _get_entity_align(ent)
#define set_entity_align(ent, a)                 _set_entity_align(ent, a)
497
498
499
500
#define get_entity_peculiarity(ent)              _get_entity_peculiarity(ent)
#define set_entity_peculiarity(ent, pec)         _set_entity_peculiarity(ent, pec)
#define get_entity_stickyness(ent)               _get_entity_stickyness(ent)
#define set_entity_stickyness(ent, stickyness)   _set_entity_stickyness(ent, stickyness)
Michael Beck's avatar
Michael Beck committed
501
#define is_entity_final(ent)                     _is_entity_final(ent)
502
#define set_entity_final(ent, final)             _set_entity_final(ent, final)
Michael Beck's avatar
Michael Beck committed
503
504
#define is_entity_compiler_generated(ent)        _is_entity_compiler_generated(ent)
#define set_entity_compiler_generated(ent, flag) _set_entity_compiler_generated(ent, flag)
Michael Beck's avatar
Michael Beck committed
505
506
#define is_entity_backend_marked(ent)            _is_entity_backend_marked(ent)
#define set_entity_backend_marked(ent, flag)     _set_entity_backend_marked(ent, flag)
Michael Beck's avatar
Michael Beck committed
507
508
#define get_entity_address_taken(ent)            _get_entity_address_taken(ent)
#define set_entity_address_taken(ent, flag)      _set_entity_address_taken(ent, flag)
509
510
511
512
#define get_entity_offset(ent)                   _get_entity_offset(ent)
#define set_entity_offset(ent, offset)           _set_entity_offset(ent, offset)
#define get_entity_offset_bits_remainder(ent)    _get_entity_offset_bits_remainder(ent)
#define set_entity_offset_bits_remainder(ent, o) _set_entity_offset_bits_remainder(ent, o)
513
514
515
516
517
518
519
520
#define get_entity_link(ent)                     _get_entity_link(ent)
#define set_entity_link(ent, l)                  _set_entity_link(ent, l)
#define get_entity_irg(ent)                      _get_entity_irg(ent)
#define get_entity_visited(ent)                  _get_entity_visited(ent)
#define set_entity_visited(ent, num)             _set_entity_visited(ent, num)
#define mark_entity_visited(ent)                 _mark_entity_visited(ent)
#define entity_visited(ent)                      _entity_visited(ent)
#define entity_not_visited(ent)                  _entity_not_visited(ent)
521
#define get_entity_repr_class(ent)               _get_entity_repr_class(ent)
522
523
#define get_entity_dbg_info(ent)                 _get_entity_dbg_info(ent)
#define set_entity_dbg_info(ent, db)             _set_entity_dbg_info(ent, db)
524

Götz Lindenmaier's avatar
Götz Lindenmaier committed
525

Michael Beck's avatar
Michael Beck committed
526
#endif /* FIRM_TR_ENTITY_T_H */