nsz Git - libfirm/blob - include/libfirm/irmemory.h

   1 /*
   2  * Copyright (C) 1995-2008 University of Karlsruhe.  All right reserved.
   3  *
   4  * This file is part of libFirm.
   5  *
   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.
  10  *
  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.
  14  *
  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
  17  * PURPOSE.
  18  */
  19
  20 /**
  21  * @file
  22  * @brief    Memory disambiguator
  23  * @author   Michael Beck
  24  * @date     27.12.2006
  25  * @version  $Id$
  26  */
  27 #ifndef FIRM_ANA_IRMEMORY_H
  28 #define FIRM_ANA_IRMEMORY_H
  29
  30 #include "firm_types.h"
  31
  32 /** The alias relation of two memory addresses. */
  33 typedef enum {
  34         ir_no_alias,       /**< No alias. */
  35         ir_may_alias,      /**< Unknown state, may alias. */
  36         ir_sure_alias      /**< Sure alias. */
  37 } ir_alias_relation;
  38
  39 /** The state of the entity usage flags. */
  40 typedef enum {
  41         ir_entity_usage_not_computed,
  42         ir_entity_usage_computed
  43 } ir_entity_usage_computed_state;
  44
  45 /** Possible options for the memory disambiguator. */
  46 typedef enum {
  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;
  53
  54 /**
  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
  58  * NOTTAKEN modifier.
  59  */
  60 typedef enum {
  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 */
  68
  69         ir_sc_modifier_nottaken = 0x80  /**< if set, the address of the variable was not taken */
  70 } ir_storage_class_class_t;
  71
  72 /**
  73  * A source language specific memory disambiguator function.
  74  * Called by get_alias_relation().
  75  */
  76 typedef ir_alias_relation (*DISAMBIGUATOR_FUNC)(
  77         ir_graph *irg,
  78         ir_node *adr1, ir_mode *mode1,
  79         ir_node *adr2, ir_mode *mode2);
  80
  81 /**
  82  * Classify a base pointer.
  83  *
  84  * @param irg  the graph of the pointer
  85  * @param irn  the node representing the base address
  86  * @param ent  the base entity of the base address iff any
  87  */
  88 ir_storage_class_class_t classify_pointer(ir_graph *irg, ir_node *irn, ir_entity *ent);
  89
  90 /**
  91  * Returns a human readable name for an alias relation.
  92  */
  93 const char *get_ir_alias_relation_name(ir_alias_relation rel);
  94
  95 /**
  96  * Determine the alias relation between two addresses.
  97  *
  98  * @param irg     The current graph.
  99  * @param adr1    The first address.
 100  * @param mode1   The mode of the first memory access.
 101  * @param adr2    The second address.
 102  * @param mode2   The mode of the second memory access.
 103  *
 104  * The memory disambiguator tries to determine the alias state between
 105  * two memory addresses. The following rules are used:
 106  *
 107  * - different variable from the same segment never alias (R1 a)
 108  * - variables from different segments never alias when:
 109  *   - a global variable and a local one never alias (R1 b)
 110  *   - a global variable and a TLS one never alias (R1 c)
 111  *   - a local variable and a TLS one never alias (R1 d)
 112  *   - a local variable and a parameter never alias (R1 e)
 113  *   - a global variable and the result of a malloc routine never alias (R1 f)
 114  *   - a local variable and the result of a malloc routine never alias (R1 g)
 115  *   - a TLS variable and the result of a malloc routine never alias (R1 h)
 116  *   - a parameter and the result of a malloc routine (obtained in the
 117  *     same routine as the parameter) never alias (R1 i)
 118  * - two different variables never alias (R2)
 119  * - if one is a variable whose address has never been taken
 120  *   there is no alias (R3)
 121  * - if two memory addresses have the same base and their offsets
 122  *   do not describe overlapping regions there is no alias (R4)
 123  * - if opt_strong_typed is set and both addresses describe entities,
 124  *   different types never alias (R5)
 125  *
 126  * If none of these rules apply, the points-to framework must be
 127  * interrogated to detect the alias relation.
 128  */
 129 ir_alias_relation get_alias_relation(
 130         ir_graph *irg,
 131         ir_node *adr1, ir_mode *mode1,
 132         ir_node *adr2, ir_mode *mode2);
 133
 134 /**
 135  * Set a source language specific memory disambiguator function.
 136  *
 137  * @param func  The callback.
 138  */
 139 void set_language_memory_disambiguator(DISAMBIGUATOR_FUNC func);
 140
 141 /**
 142  * Initialize the relation cache.
 143  */
 144 void mem_disambig_init(void);
 145
 146 /*
 147  * Determine the alias relation between two addresses and
 148  * cache the result.
 149  *
 150  * @param irg     The current graph.
 151  * @param adr1    The first address.
 152  * @param mode1   The mode of the first memory access.
 153  * @param adr2    The second address.
 154  * @param mode2   The mode of the second memory access.
 155  *
 156  * @see get_alias_relation()
 157  */
 158 ir_alias_relation get_alias_relation_ex(
 159         ir_graph *irg,
 160         ir_node *adr1, ir_mode *mode1,
 161         ir_node *adr2, ir_mode *mode2);
 162
 163 /**
 164  * Free the relation cache.
 165  */
 166 void mem_disambig_term(void);
 167
 168 ir_entity_usage_computed_state get_irg_entity_usage_state(const ir_graph *irg);
 169
 170 void set_irg_entity_usage_state(ir_graph *irg, ir_entity_usage_computed_state state);
 171
 172 /**
 173  * Assure that the entity usage flags have been computed for the given graph.
 174  *
 175  * This is an intraprocedural analysis that computes the entity usage state
 176  * for all local variables.
 177  *
 178  * Note that this is a conservative estimation that by no Firm transformation
 179  * can be invalidated, so it's only recomputed if manually triggered by calling
 180  * set_irg_entity_usage_state(irg, ir_entity_usage_not_computed).
 181  * Even then the information is not cleaned from the variables, call
 182  * assure_irg_entity_usage_computed() again for recomputation.
 183  */
 184 void assure_irg_entity_usage_computed(ir_graph *irg);
 185
 186 /**
 187  * Returns the current address taken state of the globals.
 188  */
 189 ir_entity_usage_computed_state get_irp_globals_entity_usage_state(void);
 190
 191 /**
 192  * Sets the current address taken state of the globals.
 193  *
 194  * @param state  the new state
 195  */
 196 void set_irp_globals_entity_usage_state(ir_entity_usage_computed_state state);
 197
 198 /**
 199  * Assure that the address taken flag is computed for the global and TLS entities (variables).
 200  *
 201  * This is an interprocedural analysis that computes the address_taken state
 202  * for all global and TLS variables.
 203  *
 204  * Note that this is a conservative estimation that by no Firm transformation
 205  * can be invalidated, so it's only recomputed if manually triggered by calling
 206  * set_irp_globals_entity_usage_state(ir_entity_usage_not_computed).
 207  * Even then the information is not cleaned from the variables, call
 208  * assure_irp_globals_entity_usage_computed() again for recomputation.
 209  */
 210 void assure_irp_globals_entity_usage_computed(void);
 211
 212 /**
 213  * Get the memory disambiguator options for a graph.
 214  *
 215  * @param irg  the graph
 216  */
 217 unsigned get_irg_memory_disambiguator_options(ir_graph *irg);
 218
 219 /**
 220  * Set the memory disambiguator options for a graph.
 221  *
 222  * @param irg      the graph
 223  * @param option   a set of options
 224  */
 225 void set_irg_memory_disambiguator_options(ir_graph *irg, unsigned options);
 226
 227 /**
 228  * Set the global disambiguator options for all graphs not having local options.
 229  *
 230  * @param option   a set of options
 231  */
 232 void set_irp_memory_disambiguator_options(unsigned options);
 233
 234 /**
 235  * Mark all private methods, i.e. those of which all call sites are known.
 236  * We use a very convervative estimation yet: If the address of a method is
 237  * never taken AND its visibility is visibility_local, then it's private.
 238  */
 239 void mark_private_methods(void);
 240
 241 #endif /* FIRM_ANA_IRMEMORY_H */