/*
- * 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.
*
/** The global memory disambiguator options. */
static unsigned global_mem_disamgig_opt = aa_opt_no_opt;
+/* Returns a human readable name for an alias relation. */
+const char *get_ir_alias_relation_name(ir_alias_relation rel) {
+#define X(a) case a: return #a
+ switch (rel) {
+ X(no_alias);
+ X(may_alias);
+ X(sure_alias);
+ default: assert(0); return "UNKNOWN";
+ }
+#undef X
+}
+
/* Get the memory disambiguator options for a graph. */
unsigned get_irg_memory_disambiguator_options(ir_graph *irg) {
unsigned opt = irg->mem_disambig_opt;
tarval *tv_size;
if (size == 0)
- return classify_tarval(tv) != TV_CLASSIFY_NULL ? no_alias : may_alias;
+ return tarval_is_null(tv) ? may_alias : no_alias;
tv_size = new_tarval_from_long(size, get_tarval_mode(tv));
return tarval_cmp(tv_size, tv) & (pn_Cmp_Eq|pn_Cmp_Lt) ? no_alias : may_alias;
} /* check_const */
* @param adr2 The second address.
*/
static ir_alias_relation different_sel_offsets(ir_node *sel1, ir_node *sel2) {
+ /* seems to be broken */
+#if 0
ir_entity *ent1 = get_Sel_entity(sel1);
ir_entity *ent2 = get_Sel_entity(sel2);
int i, check_arr = 0;
return have_no > 0 ? no_alias : sure_alias;
}
}
+#endif
return may_alias;
} /* different_sel_offsets */
{
ir_entity *ent1 = NULL, *ent2 = NULL;
- if (is_SymConst(adr1) && get_SymConst_kind(adr1) == symconst_addr_ent)
+ if (is_SymConst_addr_ent(adr1))
ent1 = get_SymConst_entity(adr1);
else if (is_Sel(adr1))
ent1 = get_Sel_entity(adr1);
- if (is_SymConst(adr2) && get_SymConst_kind(adr2) == symconst_addr_ent)
+ if (is_SymConst_addr_ent(adr2))
ent2 = get_SymConst_entity(adr2);
else if (is_Sel(adr2))
ent2 = get_Sel_entity(adr2);
if (is_Add(adr1)) {
/* first address is the result of a pointer addition */
ir_node *l1 = get_Add_left(adr1);
- ir_node *r1 = get_Add_right(adr1);
+ ir_node *r1 = get_Add_right(adr1);
if (l1 == adr2) {
found = check_const_offset(r1, size);
/**
* Returns true if an address represents a global variable.
+ *
+ * @param irn the node representing the address
*/
static INLINE int is_global_var(ir_node *irn) {
- return is_SymConst(irn) && get_SymConst_kind(irn) == symconst_addr_ent;
+ return is_SymConst_addr_ent(irn);
} /* is_global_var */
/**
/* Two save some code, sort the addresses by its id's. Beware, this
might break some things, so better check here. */
- assert(iro_SymConst < iro_Sel && iro_Sel < iro_Proj && "Code dependence breaked");
+ assert(iro_SymConst < iro_Sel && iro_Sel < iro_Proj && "Code dependence broken");
op1 = get_irn_opcode(adr1);
op2 = get_irn_opcode(adr2);
ir_node *base2 = find_base_adr(adr2, &ent2);
if (base1 == base2) {
- /* identical bases: check for different offsets */
- return different_sel_offsets(adr1, adr2);
- } else if (base2 == get_irg_frame(irg)) {
- /* both addresses are local variables and we know
- they are different (R1 a) */
- if (ent1 != ent2)
+ /* identical bases: both are local variables */
+ if (ent1 != ent2) {
+ /* both addresses are local variables and we know
+ they are different (R1 a) */
return no_alias;
+ } else {
+ /* same local var */
+ return different_sel_offsets(adr1, adr2);
+ }
} else if (base2 == get_irg_tls(irg)) {
/* the second one is a TLS variable so they are always
different (R1 d) */
ir_node *base2 = find_base_adr(adr2, &ent2);
if (base1 == base2)
- return different_sel_offsets(adr1, adr2);
+ if (ent1 != ent2) {
+ /* both addresses are tls variables and we know
+ they are different (R1 a) */
+ } else {
+ /* same tls var */
+ return different_sel_offsets(adr1, adr2);
+ }
else if (base2 == get_irg_frame(irg)) {
- /* the second one is a local variable so they are always
- different (R1 d) */
+ /* the first one is a tls variable, the second a local one,
+ they are different (R1 d) */
return no_alias;
- } else if (base2 == get_irg_tls(irg)) {
- /* both addresses are TLS variables and we know
- they are different (R1 a) */
- if (ent1 != ent2)
- return no_alias;
}
}
} else if (is_arg_Proj(base1)) {
/* the second address is a Sel */
ir_node *base2 = find_base_adr(adr2, &ent2);
- if (base1 == base2)
+ if (base1 == base2) {
+ /* same global var */
return different_sel_offsets(adr1, adr2);
+ }
else if (base2 == get_irg_frame(irg)) {
/* the second one is a local variable so they are always
different (R1 a) */
if (get_mode_size_bits(mode1) != get_mode_size_bits(mode2))
return no_alias;
+ /* cheap test: if only one is a reference mode, no alias */
+ if (mode_is_reference(mode1) != mode_is_reference(mode2))
+ return no_alias;
+
/* try rule R5 */
rel = different_types(adr1, adr2);
if (rel != may_alias)
ir_node *adr2, ir_mode *mode2)
{
ir_alias_relation rel = _get_alias_relation(irg, adr1, mode1, adr2, mode2);
+ DB((dbg, LEVEL_1, "alias(%+F, %+f) = %s\n", adr1, adr2, get_ir_alias_relation_name(rel)));
return rel;
} /* get_alias_relation */
if (get_entity_variability(ent) == variability_uninitialized)
return;
+ /* Beware: Methods initialized with "themself". This does not count as a taken
+ address. */
+ if (is_Method_type(get_entity_type(ent)))
+ return;
+
if (is_atomic_entity(ent)) {
/* let's check if it's an address */
n = get_atomic_ent_value(ent);
- if (is_SymConst(n) && get_SymConst_kind(n) == symconst_addr_ent) {
+ if (is_SymConst_addr_ent(n)) {
ir_entity *ent = get_SymConst_entity(n);
set_entity_address_taken(ent, ir_address_taken);
}
n = get_compound_ent_value(ent, i);
/* let's check if it's an address */
- if (is_SymConst(n) && get_SymConst_kind(n) == symconst_addr_ent) {
+ if (is_SymConst_addr_ent(n)) {
ir_entity *ent = get_SymConst_entity(n);
set_entity_address_taken(ent, ir_address_taken);
}
ir_entity *ent;
ir_address_taken_state state;
- if (is_SymConst(irn) && get_SymConst_kind(irn) == symconst_addr_ent) {
+ if (is_SymConst_addr_ent(irn)) {
/* A global. */
ent = get_SymConst_entity(irn);
} else if (is_Sel(irn) && get_Sel_ptr(irn) == tls) {
} /* assure_irp_globals_address_taken_computed */
+#include <adt/pmap.h>
+#include "typerep.h"
+
DEBUG_ONLY(static firm_dbg_module_t *dbgcall = NULL;)
+/** Maps method types to cloned method types. */
+static pmap *mtp_map;
+
+/**
+ * Clone a method type if not already cloned.
+ */
+static ir_type *clone_type_and_cache(ir_type *tp) {
+ static ident *prefix = NULL;
+ ir_type *res;
+ pmap_entry *e = pmap_find(mtp_map, tp);
+
+ if (e)
+ return e->value;
+
+ if (prefix == NULL)
+ prefix = new_id_from_chars("C", 1);
+
+ res = clone_type_method(tp, prefix);
+ pmap_insert(mtp_map, tp, res);
+ DB((dbgcall, LEVEL_2, "cloned type %+F into %+F\n", tp, res));
+
+ return res;
+} /* clone_type_and_cache */
+
/**
* Copy the calling conventions from the entities to the call type.
*/
-static void update_calls(ir_node *call, void *env) {
+static void update_calls_to_private(ir_node *call, void *env) {
(void) env;
if (is_Call(call)) {
ir_node *ptr = get_Call_ptr(call);
if (is_SymConst(ptr)) {
ir_entity *ent = get_SymConst_entity(ptr);
- ir_type *mtp = get_entity_type(ent);
ir_type *ctp = get_Call_type(call);
- if (mtp != ctp && get_method_additional_properties(mtp) & mtp_property_private) {
- set_method_additional_property(ctp, mtp_property_private);
- DB((dbgcall, LEVEL_1, "changed call to private method %+F\n", ent));
+ if (get_entity_additional_properties(ent) & mtp_property_private) {
+ if ((get_method_additional_properties(ctp) & mtp_property_private) == 0) {
+ ctp = clone_type_and_cache(ctp);
+ set_method_additional_property(ctp, mtp_property_private);
+ set_Call_type(call, ctp);
+ DB((dbgcall, LEVEL_1, "changed call to private method %+F\n", ent));
+ }
}
}
}
-}
+} /* update_calls_to_private */
/* Mark all private methods, i.e. those of which all call sites are known. */
void mark_private_methods(void) {
assure_irp_globals_address_taken_computed();
+ mtp_map = pmap_create();
+
/* first step: change the calling conventions of the local non-escaped entities */
for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
ir_graph *irg = get_irp_irg(i);
state == ir_address_not_taken) {
ir_type *mtp = get_entity_type(ent);
- set_method_additional_property(mtp, mtp_property_private);
- changed = 1;
+ set_entity_additional_property(ent, mtp_property_private);
DB((dbgcall, LEVEL_1, "found private method %+F\n", ent));
+ if ((get_method_additional_properties(mtp) & mtp_property_private) == 0) {
+ /* need a new type */
+ mtp = clone_type_and_cache(mtp);
+ set_entity_type(ent, mtp);
+ set_method_additional_property(mtp, mtp_property_private);
+ changed = 1;
+ }
}
}
if (changed)
- all_irg_walk(NULL, update_calls, NULL);
-}
+ all_irg_walk(NULL, update_calls_to_private, NULL);
+
+ pmap_destroy(mtp_map);
+} /* mark_private_methods */
projects / libfirm / blobdiff