X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=include%2Flibfirm%2Firmemory.h;h=c99764a270bb30c3e305b03b91bfd930f367ab1c;hb=fa9c992b5f23e7a059ac91fdd04b409b951ebcc4;hp=9dd703e2354ecf63cd7d851f4cac0501f33f41bd;hpb=1ce363f80e6a204d4011f85813362d9bd1d0e7e4;p=libfirm diff --git a/include/libfirm/irmemory.h b/include/libfirm/irmemory.h index 9dd703e23..c99764a27 100644 --- a/include/libfirm/irmemory.h +++ b/include/libfirm/irmemory.h @@ -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,24 @@ 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_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 +77,15 @@ 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. */ @@ -77,11 +103,17 @@ const char *get_ir_alias_relation_name(ir_alias_relation rel); * 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) @@ -132,44 +164,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). @@ -179,11 +202,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.