/*
-* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe
-* All rights reserved.
-*
-*/
+ * Project: libFIRM
+ * File name: ir/tr/entity.h
+ * Purpose: Representation of all program known entities.
+ * Author: Martin Trapp, Christian Schaefer
+ * Modified by: Goetz Lindenmaier
+ * Created:
+ * CVS-ID: $Id$
+ * Copyright: (c) 1998-2003 Universität Karlsruhe
+ * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE.
+ */
/**
* @file entity.h
/** The allocation type. */
typedef enum {
- automatic_allocated, /**< The entity is allocated during runtime, implicitly
- as component of a compound type. This is the default. */
- parameter_allocated, /**< The entity is a parameter. It is also automatic allocated.
- We distinguish the allocation of paramters from the allocation
- of local variables as their placement depends on the calling
- conventions. */
- dynamic_allocated, /**< The entity is allocated during runtime, explicitly
- by an Alloc node. */
- static_allocated /**< The entity is allocated statically. We can use a
- SymConst(?) as address of the entity. */
+ allocation_automatic, /**< The entity is allocated during runtime, implicitly
+ as component of a compound type. This is the default. */
+ allocation_parameter, /**< The entity is a parameter. It is also automatic allocated.
+ We distinguish the allocation of paramters from the allocation
+ of local variables as their placement depends on the calling
+ conventions. */
+ allocation_dynamic, /**< The entity is allocated during runtime, explicitly
+ by an Alloc node. */
+ allocation_static /**< The entity is allocated statically. We can use a
+ Const as address of the entity. */
} ent_allocation;
/** Returns the allocation type of an entity. */
/** Sets the allocation type of an entity. */
void set_entity_allocation (entity *ent, ent_allocation al);
-/** Return the name of the visibility */
+/** Return the name of the allocation type. */
const char *get_allocation_name(ent_allocation vis);
/**
* for partial compilation.
*/
typedef enum {
- local, /**< The entity is only visible locally. This is the default. */
- external_visible, /**< The entity is visible to other external program parts, but
- it is defined here. It may not be optimized away. The entity must
- be static_allocated. */
- external_allocated /**< The entity is defined and allocated externally. This compilation
- must not allocate memory for this entity. The entity must
- be static_allocated. This can also be an external defined
- method. */
+ visibility_local, /**< The entity is only visible locally. This is the default. */
+ visibility_external_visible, /**< The entity is visible to other external program parts, but
+ it is defined here. It may not be optimized away. The entity must
+ be static_allocated. */
+ visibility_external_allocated /**< The entity is defined and allocated externally. This compilation
+ must not allocate memory for this entity. The entity must
+ be static_allocated. This can also be an external defined
+ method. */
} ent_visibility;
/** Returns the visibility of an entity. */
/** This enumeration flags the variability of entities. */
typedef enum {
- uninitialized, /**< The content of the entity is completely unknown. */
- initialized, /**< After allocation the entity is initalized with the
- value given somewhere in the entity. */
- part_constant, /**< For entities of compound types. Some members of the entity
- are constant. The others are uninitialized. Those members
- given a value for are constant. */
- constant /**< The entity is constant. */
+ variability_uninitialized, /**< The content of the entity is completely unknown. */
+ variability_initialized, /**< After allocation the entity is initalized with the
+ value given somewhere in the entity. */
+ variability_part_constant, /**< For entities of compound types. Some members of the entity
+ are constant. The others are uninitialized. Those members
+ given a value for are constant. */
+ variability_constant /**< The entity is constant. */
} ent_variability;
/** Returns the variability of an entity. */
/** This enumeration flags the volatility of entities. */
typedef enum {
- non_volatile, /**< The entity is not volatile */
- is_volatile /**< The entity is volatile */
+ volatility_non_volatile, /**< The entity is not volatile */
+ volatility_is_volatile /**< The entity is volatile */
} ent_volatility;
/** Returns the volatility of an entity. */
const char *get_peculiarity_name(peculiarity var);
/* -- Representation of constant values of entites -- */
+/** Returns true if the the node is representable as code on
+ * const_code_irg. */
+int is_irn_const_expression(ir_node *n);
/* Set current_ir_graph to get_const_code_irg() to generate a constant
expression. */
/* Copies a firm subgraph that complies to the restrictions for
direct, atomic member of the constant entities type. In this case the
corresponding entity can be accessed directly. The following functions
allow direct access. */
+/* generates a Path with length 1 */
void add_compound_ent_value(entity *ent, ir_node *val, entity *member);
+/* Returns the last member in the path */
entity *get_compound_ent_value_member(entity *ent, int pos);
+/* Sets the path at pos 0 */
void set_compound_ent_value(entity *ent, ir_node *val, entity *member, int pos);
/** Returns true if this entity was not visited. */
bool entity_not_visited(entity *ent);
+/** Returns the dynamically referenced entity if the static entity and the
+ * dynamic type are given. */
+entity *resolve_ent_polymorphy(type *dynamic_class, entity* static_ent);
+
+
+/*******************************************************************/
+/** Debug aides **/
+/*******************************************************************/
+
+
+/** Write the entity and all its attributes to stdout.
+ *
+ * Writes the entity and all its attributes to stdout if DEBUG_libfirm
+ * is set. Else does nothing. */
+void dump_entity (entity *ent);
+
+
# endif /* _ENTITY_H_ */