X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Firmemory.h;h=fbc22461c2d17dce743f8a6147d76a66454f31f0;hb=e3e0e94d6bcf4257ff00c8bc173d13fd279932b1;hp=2fbe025ea5e2dc9717f3ba0baee8f17baa5b3afc;hpb=1ec30d95387eb392ba5a1adc7958ebd91383d59c;p=libfirm diff --git a/include/libfirm/irmemory.h b/include/libfirm/irmemory.h index 2fbe025ea..fbc22461c 100644 --- a/include/libfirm/irmemory.h +++ b/include/libfirm/irmemory.h @@ -1,5 +1,5 @@ /* - * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved. * * This file is part of libFirm. * @@ -31,16 +31,16 @@ /** The alias relation of two memory addresses. */ typedef enum { - no_alias, /**< No alias. */ - may_alias, /**< Unknown state, may alias. */ - sure_alias /**< Sure alias. */ + ir_no_alias, /**< No alias. */ + ir_may_alias, /**< Unknown state, may alias. */ + ir_sure_alias /**< Sure alias. */ } ir_alias_relation; -/** The state of the address taken flags. */ +/** The state of the entity usage flags. */ typedef enum { - ir_address_taken_not_computed, /**< Address taken flag is not computed. */ - ir_address_taken_computed /**< Address taken flag is computed. */ -} ir_address_taken_computed_state; + ir_entity_usage_not_computed, + ir_entity_usage_computed +} ir_entity_usage_computed_state; /** Possible options for the memory disambiguator. */ typedef enum { @@ -49,7 +49,25 @@ typedef enum { aa_opt_byte_type_may_alias = 2, /**< if type based analysis is enabled: bytes types may alias other types */ aa_opt_no_alias = 4, /**< two addresses NEVER alias, use with CAUTION (gcc -fno-alias) */ aa_opt_inherited = 128 /**< only for implementation: options from a graph are inherited from global */ -} disambuigator_options; +} ir_disambuigator_options; + +/** + * Classify storage locations. + * Except ir_sc_pointer they are all disjoint. + * ir_sc_pointer potentially aliases all classes which don't have a + * NOTTAKEN modifier. + */ +typedef enum { + ir_sc_pointer = 0x0, /**< generic pointer, may be anything */ + ir_sc_globalvar = 0x1, /**< an address of a global variable */ + ir_sc_localvar = 0x2, /**< an address of a local variable */ + ir_sc_argument = 0x3, /**< an method argument */ + ir_sc_tls = 0x4, /**< an address of a thread local storage variable */ + ir_sc_malloced = 0x5, /**< an allocated heap address */ + ir_sc_globaladdr = 0x6, /**< a constant address of something, said to be alias free */ + + ir_sc_modifier_nottaken = 0x80 /**< if set, the address of the variable was not taken */ +} ir_storage_class_class_t; /** * A source language specific memory disambiguator function. @@ -60,6 +78,20 @@ typedef ir_alias_relation (*DISAMBIGUATOR_FUNC)( ir_node *adr1, ir_mode *mode1, ir_node *adr2, ir_mode *mode2); +/** + * Classify a base pointer. + * + * @param irg the graph of the pointer + * @param irn the node representing the base address + * @param ent the base entity of the base address iff any + */ +ir_storage_class_class_t classify_pointer(ir_graph *irg, ir_node *irn, ir_entity *ent); + +/** + * Returns a human readable name for an alias relation. + */ +const char *get_ir_alias_relation_name(ir_alias_relation rel); + /** * Determine the alias relation between two addresses. * @@ -72,11 +104,17 @@ typedef ir_alias_relation (*DISAMBIGUATOR_FUNC)( * The memory disambiguator tries to determine the alias state between * two memory addresses. The following rules are used: * - * - variables from different segments never alias (R1) + * - different variable from the same segment never alias (R1 a) + * - variables from different segments never alias when: * - a global variable and a local one never alias (R1 b) * - a global variable and a TLS one never alias (R1 c) * - a local variable and a TLS one never alias (R1 d) * - a local variable and a parameter never alias (R1 e) + * - a global variable and the result of a malloc routine never alias (R1 f) + * - a local variable and the result of a malloc routine never alias (R1 g) + * - a TLS variable and the result of a malloc routine never alias (R1 h) + * - a parameter and the result of a malloc routine (obtained in the + * same routine as the parameter) never alias (R1 i) * - two different variables never alias (R2) * - if one is a variable whose address has never been taken * there is no alias (R3) @@ -127,44 +165,35 @@ ir_alias_relation get_alias_relation_ex( */ void mem_disambig_term(void); -/** - * Returns the current address taken state of the graph. - */ -ir_address_taken_computed_state get_irg_address_taken_state(const ir_graph *irg); +ir_entity_usage_computed_state get_irg_entity_usage_state(const ir_graph *irg); -/** - * Sets the current address taken state of the graph. - * - * @param irg the graph - * @param state the new state - */ -void set_irg_address_taken_state(ir_graph *irg, ir_address_taken_computed_state state); +void set_irg_entity_usage_state(ir_graph *irg, ir_entity_usage_computed_state state); /** - * Assure that the address taken flag is computed for the given graph. + * Assure that the entity usage flags have been computed for the given graph. * - * This is an intraprocedural analysis that computes the address_taken state + * This is an intraprocedural analysis that computes the entity usage state * for all local variables. * * Note that this is a conservative estimation that by no Firm transformation * can be invalidated, so it's only recomputed if manually triggered by calling - * set_irg_address_taken_state(irg, ir_address_taken_not_computed). + * set_irg_entity_usage_state(irg, ir_entity_usage_not_computed). * Even then the information is not cleaned from the variables, call - * assure_irg_address_taken_computed() again for recomputation. + * assure_irg_entity_usage_computed() again for recomputation. */ -void assure_irg_address_taken_computed(ir_graph *irg); +void assure_irg_entity_usage_computed(ir_graph *irg); /** * Returns the current address taken state of the globals. */ -ir_address_taken_computed_state get_irp_globals_address_taken_state(void); +ir_entity_usage_computed_state get_irp_globals_entity_usage_state(void); /** * Sets the current address taken state of the globals. * * @param state the new state */ -void set_irp_globals_address_taken_state(ir_address_taken_computed_state state); +void set_irp_globals_entity_usage_state(ir_entity_usage_computed_state state); /** * Assure that the address taken flag is computed for the global and TLS entities (variables). @@ -174,11 +203,11 @@ void set_irp_globals_address_taken_state(ir_address_taken_computed_state state); * * Note that this is a conservative estimation that by no Firm transformation * can be invalidated, so it's only recomputed if manually triggered by calling - * set_irp_globals_address_taken_state(ir_address_taken_not_computed). + * set_irp_globals_entity_usage_state(ir_entity_usage_not_computed). * Even then the information is not cleaned from the variables, call - * assure_irp_globals_address_taken_computed() again for recomputation. + * assure_irp_globals_entity_usage_computed() again for recomputation. */ -void assure_irp_globals_address_taken_computed(void); +void assure_irp_globals_entity_usage_computed(void); /** * Get the memory disambiguator options for a graph. @@ -202,4 +231,11 @@ void set_irg_memory_disambiguator_options(ir_graph *irg, unsigned options); */ void set_irp_memory_disambiguator_options(unsigned options); +/** + * Mark all private methods, i.e. those of which all call sites are known. + * We use a very convervative estimation yet: If the address of a method is + * never taken AND its visibility is visibility_local, then it's private. + */ +void mark_private_methods(void); + #endif /* FIRM_ANA_IRMEMORY_H */