2 * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief Memory disambiguator
23 * @author Michael Beck
27 #ifndef FIRM_ANA_IRMEMORY_H
28 #define FIRM_ANA_IRMEMORY_H
30 #include "firm_types.h"
32 /** The alias relation of two memory addresses. */
34 ir_no_alias, /**< No alias. */
35 ir_may_alias, /**< Unknown state, may alias. */
36 ir_sure_alias /**< Sure alias. */
39 /** The state of the entity usage flags. */
41 ir_entity_usage_not_computed,
42 ir_entity_usage_computed
43 } ir_entity_usage_computed_state;
45 /** Possible options for the memory disambiguator. */
47 aa_opt_no_opt = 0, /**< no options: most conservative */
48 aa_opt_type_based = 1, /**< use type based alias analysis: strict typed source language */
49 aa_opt_byte_type_may_alias = 2, /**< if type based analysis is enabled: bytes types may alias other types */
50 aa_opt_no_alias = 4, /**< two addresses NEVER alias, use with CAUTION (gcc -fno-alias) */
51 aa_opt_inherited = 128 /**< only for implementation: options from a graph are inherited from global */
52 } ir_disambuigator_options;
55 * Classify storage locations.
56 * Except ir_sc_pointer they are all disjoint.
57 * ir_sc_pointer potentially aliases all classes which don't have a
61 ir_sc_pointer = 0x0, /**< generic pointer, may be anything */
62 ir_sc_globalvar = 0x1, /**< an address of a global variable */
63 ir_sc_localvar = 0x2, /**< an address of a local variable */
64 ir_sc_argument = 0x3, /**< an method argument */
65 ir_sc_tls = 0x4, /**< an address of a thread local storage variable */
66 ir_sc_malloced = 0x5, /**< an allocated heap address */
67 ir_sc_globaladdr = 0x6, /**< a constant address of something, said to be alias free */
69 ir_sc_modifier_nottaken = 0x80 /**< if set, the address of the variable was not taken */
70 } ir_storage_class_class_t;
72 /** Get the base storage class (ignore modifier) */
73 #define GET_BASE_SC(x) ((x) & ~ir_sc_modifier_nottaken)
76 * A source language specific memory disambiguator function.
77 * Called by get_alias_relation().
79 typedef ir_alias_relation (*DISAMBIGUATOR_FUNC)(
81 ir_node *adr1, ir_mode *mode1,
82 ir_node *adr2, ir_mode *mode2);
85 * Classify a base pointer.
87 * @param irg the graph of the pointer
88 * @param irn the node representing the base address
89 * @param ent the base entity of the base address iff any
91 ir_storage_class_class_t classify_pointer(ir_graph *irg, ir_node *irn, ir_entity *ent);
94 * Returns a human readable name for an alias relation.
96 const char *get_ir_alias_relation_name(ir_alias_relation rel);
99 * Determine the alias relation between two addresses.
101 * @param irg The current graph.
102 * @param adr1 The first address.
103 * @param mode1 The mode of the first memory access.
104 * @param adr2 The second address.
105 * @param mode2 The mode of the second memory access.
107 * The memory disambiguator tries to determine the alias state between
108 * two memory addresses. The following rules are used:
110 * - different variable from the same segment never alias (R1 a)
111 * - variables from different segments never alias when:
112 * - a global variable and a local one never alias (R1 b)
113 * - a global variable and a TLS one never alias (R1 c)
114 * - a local variable and a TLS one never alias (R1 d)
115 * - a local variable and a parameter never alias (R1 e)
116 * - a global variable and the result of a malloc routine never alias (R1 f)
117 * - a local variable and the result of a malloc routine never alias (R1 g)
118 * - a TLS variable and the result of a malloc routine never alias (R1 h)
119 * - a parameter and the result of a malloc routine (obtained in the
120 * same routine as the parameter) never alias (R1 i)
121 * - two different variables never alias (R2)
122 * - if one is a variable whose address has never been taken
123 * there is no alias (R3)
124 * - if two memory addresses have the same base and their offsets
125 * do not describe overlapping regions there is no alias (R4)
126 * - if opt_strong_typed is set and both addresses describe entities,
127 * different types never alias (R5)
129 * If none of these rules apply, the points-to framework must be
130 * interrogated to detect the alias relation.
132 ir_alias_relation get_alias_relation(
134 ir_node *adr1, ir_mode *mode1,
135 ir_node *adr2, ir_mode *mode2);
138 * Set a source language specific memory disambiguator function.
140 * @param func The callback.
142 void set_language_memory_disambiguator(DISAMBIGUATOR_FUNC func);
145 * Initialize the relation cache.
147 void mem_disambig_init(void);
150 * Determine the alias relation between two addresses and
153 * @param irg The current graph.
154 * @param adr1 The first address.
155 * @param mode1 The mode of the first memory access.
156 * @param adr2 The second address.
157 * @param mode2 The mode of the second memory access.
159 * @see get_alias_relation()
161 ir_alias_relation get_alias_relation_ex(
163 ir_node *adr1, ir_mode *mode1,
164 ir_node *adr2, ir_mode *mode2);
167 * Free the relation cache.
169 void mem_disambig_term(void);
171 ir_entity_usage_computed_state get_irg_entity_usage_state(const ir_graph *irg);
173 void set_irg_entity_usage_state(ir_graph *irg, ir_entity_usage_computed_state state);
176 * Assure that the entity usage flags have been computed for the given graph.
178 * This is an intraprocedural analysis that computes the entity usage state
179 * for all local variables.
181 * Note that this is a conservative estimation that by no Firm transformation
182 * can be invalidated, so it's only recomputed if manually triggered by calling
183 * set_irg_entity_usage_state(irg, ir_entity_usage_not_computed).
184 * Even then the information is not cleaned from the variables, call
185 * assure_irg_entity_usage_computed() again for recomputation.
187 void assure_irg_entity_usage_computed(ir_graph *irg);
190 * Returns the current address taken state of the globals.
192 ir_entity_usage_computed_state get_irp_globals_entity_usage_state(void);
195 * Sets the current address taken state of the globals.
197 * @param state the new state
199 void set_irp_globals_entity_usage_state(ir_entity_usage_computed_state state);
202 * Assure that the address taken flag is computed for the global and TLS entities (variables).
204 * This is an interprocedural analysis that computes the address_taken state
205 * for all global and TLS variables.
207 * Note that this is a conservative estimation that by no Firm transformation
208 * can be invalidated, so it's only recomputed if manually triggered by calling
209 * set_irp_globals_entity_usage_state(ir_entity_usage_not_computed).
210 * Even then the information is not cleaned from the variables, call
211 * assure_irp_globals_entity_usage_computed() again for recomputation.
213 void assure_irp_globals_entity_usage_computed(void);
216 * Get the memory disambiguator options for a graph.
218 * @param irg the graph
220 unsigned get_irg_memory_disambiguator_options(ir_graph *irg);
223 * Set the memory disambiguator options for a graph.
225 * @param irg the graph
226 * @param option a set of options
228 void set_irg_memory_disambiguator_options(ir_graph *irg, unsigned options);
231 * Set the global disambiguator options for all graphs not having local options.
233 * @param option a set of options
235 void set_irp_memory_disambiguator_options(unsigned options);
238 * Mark all private methods, i.e. those of which all call sites are known.
239 * We use a very convervative estimation yet: If the address of a method is
240 * never taken AND its visibility is visibility_local, then it's private.
242 void mark_private_methods(void);
244 #endif /* FIRM_ANA_IRMEMORY_H */