#include "debug.h"
#include "error.h"
#include "typerep.h"
+#include "irpass.h"
/** The debug handle. */
DEBUG_ONLY(static firm_dbg_module_t *dbg = NULL;)
}
/* Get the memory disambiguator options for a graph. */
-unsigned get_irg_memory_disambiguator_options(ir_graph *irg) {
+unsigned get_irg_memory_disambiguator_options(const ir_graph *irg) {
unsigned opt = irg->mem_disambig_opt;
if (opt & aa_opt_inherited)
return global_mem_disamgig_opt;
*
* @return the base address.
*/
-static ir_node *find_base_adr(ir_node *sel, ir_entity **pEnt) {
+static ir_node *find_base_adr(const ir_node *sel, ir_entity **pEnt) {
ir_node *ptr = get_Sel_ptr(sel);
while (is_Sel(ptr)) {
*
* @return ir_no_alias if the Const is greater, ir_may_alias else
*/
-static ir_alias_relation check_const(ir_node *cns, int size) {
+static ir_alias_relation check_const(const ir_node *cns, int size) {
tarval *tv = get_Const_tarval(cns);
tarval *tv_size;
* ir_no_alias iff they ALWAYS differ more than size
* ir_may_alias else
*/
-static ir_alias_relation different_index(ir_node *idx1, ir_node *idx2, int size) {
+static ir_alias_relation different_index(const ir_node *idx1, const ir_node *idx2, int size) {
if (idx1 == idx2)
return ir_sure_alias;
if (is_Const(idx1) && is_Const(idx2)) {
* @param adr1 The first address.
* @param adr2 The second address.
*/
-static ir_alias_relation different_sel_offsets(ir_node *sel1, ir_node *sel2) {
+static ir_alias_relation different_sel_offsets(const ir_node *sel1, const ir_node *sel2) {
/* seems to be broken */
(void) sel1;
(void) sel2;
* @param adr1 The first address.
* @param adr2 The second address.
*/
-static ir_alias_relation different_types(ir_node *adr1, ir_node *adr2)
+static ir_alias_relation different_types(const ir_node *adr1, const ir_node *adr2)
{
ir_entity *ent1 = NULL, *ent2 = NULL;
*
* @param node the Proj node to test
*/
-static int is_malloc_Result(ir_node *node) {
+static int is_malloc_Result(const ir_node *node) {
node = get_Proj_pred(node);
if (! is_Proj(node))
return 0;
* @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)
+ir_storage_class_class_t classify_pointer(const ir_graph *irg, const ir_node *irn, const ir_entity *ent)
{
ir_storage_class_class_t res = ir_sc_pointer;
if (is_Global(irn)) {
/**
* If adr represents a Bitfield Sel, skip it
*/
-static ir_node *skip_Bitfield_Sels(ir_node *adr) {
+static const ir_node *skip_Bitfield_Sels(const ir_node *adr) {
if (is_Sel(adr)) {
ir_entity *ent = get_Sel_entity(adr);
ir_type *bf_type = get_entity_type(ent);
* @return found memory relation
*/
static ir_alias_relation _get_alias_relation(
- ir_graph *irg,
- ir_node *adr1, ir_mode *mode1,
- ir_node *adr2, ir_mode *mode2)
+ const ir_graph *irg,
+ const ir_node *adr1, const ir_mode *mode1,
+ const ir_node *adr2, const ir_mode *mode2)
{
ir_entity *ent1, *ent2;
unsigned options;
long offset1 = 0;
long offset2 = 0;
- ir_node *base1;
- ir_node *base2;
- ir_node *orig_adr1 = adr1;
- ir_node *orig_adr2 = adr2;
+ const ir_node *base1;
+ const ir_node *base2;
+ const ir_node *orig_adr1 = adr1;
+ const ir_node *orig_adr2 = adr2;
unsigned mode_size;
ir_storage_class_class_t class1, class2, mod1, mod2;
int have_const_offsets;
* Determine the alias relation between two addresses.
*/
ir_alias_relation get_alias_relation(
- ir_graph *irg,
- ir_node *adr1, ir_mode *mode1,
- ir_node *adr2, ir_mode *mode2)
+ const ir_graph *irg,
+ const ir_node *adr1, const ir_mode *mode1,
+ const ir_node *adr2, const 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)));
/** An entry in the relation cache. */
typedef struct mem_disambig_entry {
- ir_node *adr1; /**< The first address. */
- ir_node *adr2; /**< The second address. */
+ const ir_node *adr1; /**< The first address. */
+ const ir_mode *mode1; /**< The first address mode. */
+ const ir_node *adr2; /**< The second address. */
+ const ir_mode *mode2; /**< The second address mode. */
ir_alias_relation result; /**< The alias relation result. */
} mem_disambig_entry;
const mem_disambig_entry *p2 = key;
(void) size;
- return p1->adr1 == p2->adr1 && p1->adr2 == p2->adr2;
+ return p1->adr1 == p2->adr1 && p1->adr2 == p2->adr2 &&
+ p1->mode1 == p2->mode1 && p1->mode2 == p2->mode2;
} /* cmp_mem_disambig_entry */
/**
* Determine the alias relation between two addresses.
*/
ir_alias_relation get_alias_relation_ex(
- ir_graph *irg,
- ir_node *adr1, ir_mode *mode1,
- ir_node *adr2, ir_mode *mode2)
+ const ir_graph *irg,
+ const ir_node *adr1, const ir_mode *mode1,
+ const ir_node *adr2, const ir_mode *mode2)
{
mem_disambig_entry key, *entry;
return ir_may_alias;
if (get_irn_opcode(adr1) > get_irn_opcode(adr2)) {
- ir_node *t = adr1;
+ const ir_node *t = adr1;
adr1 = adr2;
adr2 = t;
}
- key.adr1 = adr1;
- key.adr2 = adr2;
+ key.adr1 = adr1;
+ key.adr2 = adr2;
+ key.mode1 = mode1;
+ key.mode2 = mode2;
entry = set_find(result_cache, &key, sizeof(key), HASH_ENTRY(adr1, adr2));
if (entry != NULL)
return entry->result;
*
* @return non-zero if the Load/Store is a hidden cast, zero else
*/
-static int is_hidden_cast(ir_mode *mode, ir_mode *ent_mode) {
+static int is_hidden_cast(const ir_mode *mode, const ir_mode *ent_mode) {
if (ent_mode == NULL)
return false;
break;
case iro_Sel: {
ir_entity *entity = get_Sel_entity(succ);
- /* this analyis can't handle unions correctly */
+ /* this analysis can't handle unions correctly */
if (is_Union_type(get_entity_owner(entity))) {
res |= ir_usage_unknown;
break;
ir_entity *entity;
ir_entity_usage flags;
- if (!is_Sel(succ))
+ if (!is_Sel(succ))
continue;
entity = get_Sel_entity(succ);
/**
* Initialize the entity_usage flag for a global type like type.
*/
-static void init_entity_usage(ir_type * tp) {
+static void init_entity_usage(ir_type *tp) {
int i;
/* We have to be conservative: All external visible entities are unknown */
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 */
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));
+ DB((dbgcall, LEVEL_1, "changed call to private method %+F using cloned type %+F\n", ent, ctp));
}
}
}
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);
+ set_entity_type(ent, mtp);
+ DB((dbgcall, LEVEL_2, "changed entity type of %+F to %+F\n", ent, mtp));
changed = 1;
}
}
pmap_destroy(mtp_map);
} /* mark_private_methods */
+
+/* create a pass for mark_private_methods() */
+ir_prog_pass_t *mark_private_methods_pass(const char *name) {
+ return def_prog_pass(name ? name : "mark_private_methods", mark_private_methods);
+} /* mark_private_methods_pass */