*
*/
#ifdef HAVE_CONFIG_H
-# include <config.h>
+# include "config.h"
+#endif
+
+#ifdef HAVE_STRING_H
+# include <string.h>
#endif
-#include <stdlib.h>
#include "cgana.h"
#include "rta.h"
+#include "xmalloc.h"
#include "irnode_t.h"
#include "irmode_t.h"
#include "irprog_t.h"
#include "irdump.h"
-#include "firmstat.h"
+#include "irhooks.h"
/* Eindeutige Adresse zur Markierung von besuchten Knoten und zur
* Darstellung der unbekannten Methode. */
*/
static void collect_impls(entity *method, eset *set, int *size, bool *open) {
int i;
+ entity *impl;
+
#if 0
if (get_entity_peculiarity(method) == peculiarity_existent) {
if ((get_entity_visibility(method) == visibility_external_allocated)
remember that there are more methods called. */
/* @@@ We could also add unknown_entity, or the entities with the
unknown irgs. The first case would result in the exact same
- behaviour: all unknown irgs are represented by the one and only
+ behavior: all unknown irgs are represented by the one and only
unknown entity. If we add all entities, we known the number of
entities possibly called, and whether there are real unknown
entities, i.e, such not represented in the type description.
- This would be better for an analyses: it could rule out more
+ This would be better for an analysis: it could rule out more
cases. */
- entity *impl = method;
+ impl = method;
if (get_entity_peculiarity(method) == peculiarity_inherited)
impl = get_inherited_methods_implementation(method);
return arr;
}
-/** Analyse address computations.
+/** Analyze address computations.
*
* - If the node is a SymConst(name) replace it by SymConst(ent) if possible.
* - If the node is a Sel:
if (get_SymConst_kind(node) == symconst_addr_name) {
pmap_entry * entry = pmap_find(ldname_map, (void *) get_SymConst_name(node));
if (entry != NULL) { /* Method is declared in the compiled code */
- entity * ent = entry->value;
- if (get_opt_normalize() && (get_entity_visibility(ent) != visibility_external_allocated)) { /* Meth. is defined */
- set_irg_current_block(current_ir_graph, get_nodes_block(node));
- ir_node *new_node = copy_const_value(get_atomic_ent_value(ent));
+ entity * ent = entry->value;
+ if (get_opt_normalize() && (get_entity_visibility(ent) != visibility_external_allocated)) { /* Meth. is defined */
+ ir_node *new_node;
+
+ set_irg_current_block(current_ir_graph, get_nodes_block(node));
+ new_node = copy_const_value(get_atomic_ent_value(ent));
- DBG_OPT_CSTEVAL(node, new_node);
+ DBG_OPT_CSTEVAL(node, new_node);
- assert(get_entity_irg(ent));
- DDMN(new_node);
- exchange(node, new_node);
- }
+ assert(get_entity_irg(ent));
+ DDMN(new_node);
+ exchange(node, new_node);
+ }
}
}
}
else if (get_irn_op(node) == op_Sel &&
- is_method_type(get_entity_type(get_Sel_entity(node)))) {
+ is_Method_type(get_entity_type(get_Sel_entity(node)))) {
entity * ent = get_Sel_entity(node);
/* Sel from Alloc: replace by constant */
/* Gib eine Warnung aus wenn die Entitaet eine Beschreibung ist
fuer die es keine Implementierung gibt. */
if (get_entity_peculiarity(ent) == peculiarity_description) {
- /* This is possible: We call a method in a dead part of the program. */
+ /* This is possible: We call a method in a dead part of the program. */
} else {
- DDMN(node);
- assert(0); /* Why should this happen ??? */
+ DDMN(node);
+ assert(0); /* Why should this happen ??? */
//exchange(node, new_Bad());
}
} else {
assert(entities == NULL);
entities = eset_create();
- for (i = get_irp_n_allirgs() - 1; i >= 0; --i) {
- entity * ent = get_irg_entity(get_irp_allirg(i));
- /* Nur extern sichtbare Methode können überhaupt mit SymConst
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+ ir_graph *irg = get_irp_irg(i);
+ entity * ent = get_irg_entity(irg);
+ /* Nur extern sichtbare Methoden können überhaupt mit SymConst
* aufgerufen werden. */
if (get_entity_visibility(ent) != visibility_local) {
pmap_insert(ldname_map, (void *) get_entity_ld_ident(ent), ent);
assert(sel && get_irn_op(sel) == op_Sel);
ent = get_Sel_entity(sel);
- assert(is_method_type(get_entity_type(ent))); /* what else? */
+ assert(is_Method_type(get_entity_type(ent))); /* what else? */
arr = get_entity_link(ent);
if (arr) {
return arr;
case iro_SymConst:
if (get_SymConst_kind(node) == symconst_addr_ent) {
entity * ent = get_SymConst_entity(node);
- assert(ent && is_method_type(get_entity_type(ent)));
+ assert(ent && is_Method_type(get_entity_type(ent)));
eset_insert(methods, ent);
} else {
assert(get_SymConst_kind(node) == symconst_addr_name);
static void callee_ana(void) {
int i;
/* Alle Graphen analysieren. */
- for (i = get_irp_n_allirgs() - 1; i >= 0; --i) {
- irg_walk_graph(get_irp_allirg(i), callee_walker, remove_Tuples, NULL);
- set_irg_callee_info_state(get_irp_allirg(i), irg_callee_info_consistent);
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+ irg_walk_graph(get_irp_irg(i), callee_walker, remove_Tuples, NULL);
+ set_irg_callee_info_state(get_irp_irg(i), irg_callee_info_consistent);
}
set_irp_callee_info_state(irg_callee_info_consistent);
}
switch (get_irn_opcode(node)) {
case iro_Sel: {
entity * ent = get_Sel_entity(node);
- if (is_method_type(get_entity_type(ent))) {
+ if (is_Method_type(get_entity_type(ent))) {
for (i = get_Sel_n_methods(node) - 1; i >= 0; --i) {
- eset_insert(set, get_Sel_method(node, i));
+ eset_insert(set, get_Sel_method(node, i));
}
}
break;
case iro_SymConst:
if (get_SymConst_kind(node) == symconst_addr_ent) {
entity * ent = get_SymConst_entity(node);
- if (is_method_type(get_entity_type(ent))) {
+ if (is_Method_type(get_entity_type(ent))) {
eset_insert(set, ent);
}
} else {
entity ** arr = NEW_ARR_F(entity *, 0);
entity * ent;
- for (i = get_irp_n_allirgs() - 1; i >= 0; --i) {
- ir_graph * irg = get_irp_allirg(i);
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+ ir_graph * irg = get_irp_irg(i);
entity * ent = get_irg_entity(irg);
/* insert "external visible" methods. */
if (get_entity_visibility(ent) != visibility_local) {
}
/* insert sticky methods, too */
- for (i = get_irp_n_allirgs() - 1; i >= 0; --i) {
- ir_graph * irg = get_irp_allirg(i);
+ for (i = get_irp_n_irgs() - 1; i >= 0; --i) {
+ ir_graph * irg = get_irp_irg(i);
entity * ent = get_irg_entity(irg);
/* insert "external visible" methods. */
if (get_entity_stickyness (ent) == stickyness_sticky) {
/* Convert the flexible array to an array that can be handled
by standard C. */
- p = (entity **)malloc(sizeof(*p) * ARR_LEN(free_meths));
+ p = xmalloc(sizeof(*p) * ARR_LEN(free_meths));
memcpy(p, free_meths, ARR_LEN(free_meths) * sizeof(*p));
*length = ARR_LEN(free_meths);
projects / libfirm / blobdiff