/*
Exception b/d
*/
-static type *java_lang_Throwable_tp = NULL;
+static ir_type *java_lang_Throwable_tp = NULL;
-static type *get_java_lang_Throwable (void)
+static ir_type *get_java_lang_Throwable (void)
{
assert (NULL != java_lang_Throwable_tp);
return (java_lang_Throwable_tp);
}
-static void find_java_lang_Throwable (type *tp, void *_unused)
+static void find_java_lang_Throwable (ir_type *tp, void *_unused)
{
const char *name = get_type_name (tp);
/*
Ctors, Dtors for typalise_t-s
*/
-static typalise_t *ta_exact (type *tp)
+static typalise_t *ta_exact (ir_type *tp)
{
typalise_t *ta = xmalloc (sizeof (typalise_t));
ta->kind = type_exact;
return (ta);
}
-static typalise_t *ta_type (type *tp)
+static typalise_t *ta_type (ir_type *tp)
{
typalise_t *ta = xmalloc (sizeof (typalise_t));
ta->kind = type_type;
Find out whether otype is a subtype of stype.
Return non-zero iff otype is a subtype of stype.
*/
-static int is_subtype (type *otype, type *stype)
+static int is_subtype (ir_type *otype, ir_type *stype)
{
int n_sub = get_class_n_subtypes (stype);
int is_sub = FALSE;
}
for (i = 0; (!is_sub) && (i < n_sub); i ++) {
- type *sub = get_class_subtype (stype, i);
+ ir_type *sub = get_class_subtype (stype, i);
is_sub |= is_subtype (otype, sub);
}
Compute the closure of all subtypes of otype (including otype
itself)
*/
-static void _collect_subtypes (type *otype, lset_t *set)
+static void _collect_subtypes (ir_type *otype, lset_t *set)
{
int i, n_sub;
n_sub = get_class_n_subtypes (otype);
for (i = 0; i < n_sub; i ++) {
- type *sub = get_class_subtype (otype, i);
+ ir_type *sub = get_class_subtype (otype, i);
_collect_subtypes (sub, set);
}
}
-static lset_t *subtype_closure (type *otype)
+static lset_t *subtype_closure (ir_type *otype)
{
lset_t *set = lset_create ();
/**
Helper method for get_owner_types
*/
-static void _collect_owner_types (entity *method, ir_graph *graph, lset_t *tps)
+static void _collect_owner_types (ir_entity *method, ir_graph *graph, lset_t *tps)
{
int i, n_over;
n_over = get_entity_n_overwrittenby (method);
for (i = 0; i < n_over; i ++) {
- entity *ometh = get_entity_overwrittenby (method, i);
+ ir_entity *ometh = get_entity_overwrittenby (method, i);
_collect_owner_types (ometh, graph, tps);
}
static lset_t *get_owner_types (ir_graph *graph)
{
lset_t *tps = lset_create ();
- entity *meth = get_irg_entity (graph);
+ ir_entity *meth = get_irg_entity (graph);
_collect_owner_types (meth, graph, tps);
/**
Return a list containing all types of 'set' which are a subtype of 'type'.
*/
-static lset_t *filter_for_type (lset_t *set, type *stype)
+static lset_t *filter_for_type (lset_t *set, ir_type *stype)
{
- type *curs = (type*) lset_first (set);
+ ir_type *curs = (ir_type*) lset_first (set);
lset_t *lset = lset_create ();
while (NULL != curs) {
res = ta_join (two, one);
} break;
case (type_type): {
- type *one_type = one->res.type;
- type *two_type = two->res.type;
+ ir_type *one_type = one->res.type;
+ ir_type *two_type = two->res.type;
if (is_subtype (one_type, two_type)) {
ta_delete (one);
case (type_types): {
len += sprintf (buf+len, "one_of ");
- type *iter = lset_first (ta->res.types);
+ ir_type *iter = lset_first (ta->res.types);
int size = BUF_SIZE - len - 1;
while ((NULL != iter) && (0 < size)) {
method. Presumably, this is because clazz inherits the graph as
the implementation for a method.
*/
-static int uses_graph (type *clazz, entity *meth, ir_graph *graph)
+static int uses_graph (ir_type *clazz, ir_entity *meth, ir_graph *graph)
{
- type *g_clazz = get_entity_owner (meth);
+ ir_type *g_clazz = get_entity_owner (meth);
int i, n_over, use = FALSE;
if (g_clazz == clazz) {
/* else inherited or description */
n_over = get_entity_n_overwrittenby (meth); /* DOWN-wards */
for (i = 0; (i < n_over) && (!use); i ++) {
- entity *over = get_entity_overwrittenby (meth, i);
+ ir_entity *over = get_entity_overwrittenby (meth, i);
use |= uses_graph (clazz, over, graph);
}
return (res);
}
case (type_type): {
- entity *meth = get_irg_entity (graph);
- type *tp = get_entity_owner (meth);
+ ir_entity *meth = get_irg_entity (graph);
+ ir_type *tp = get_entity_owner (meth);
int res = is_subtype (tp, ta->res.type);
if (res) {
return (res);
}
case (type_types): {
- type *tp = get_entity_owner (get_irg_entity (graph));
+ ir_type *tp = get_entity_owner (get_irg_entity (graph));
return (lset_contains (ta->res.types, tp));
}
*/
static typalise_t *typalise_call (ir_node *call)
{
- entity *ent = NULL;
- type *tp = NULL;
+ ir_entity *ent = NULL;
+ ir_type *tp = NULL;
typalise_t *res = NULL;
ir_node *call_ptr = get_Call_ptr (call);
*/
static typalise_t *typalise_load (ir_node *load)
{
- entity *ent = NULL;
- type *tp = NULL;
+ ir_entity *ent = NULL;
+ ir_type *tp = NULL;
typalise_t *res = NULL;
ir_node *load_ptr = get_Load_ptr (load);
proj_in = get_Proj_pred (proj_in);
if (iro_Start == get_irn_opcode (proj_in)) {
/* aha, proj arg */
- ir_graph *graph = get_irn_irg (proj);
- entity *meth = get_irg_entity (graph);
+ ir_graph *graph = get_irn_irg (proj);
+ ir_entity *meth = get_irg_entity (graph);
long n = get_Proj_proj (proj);
- type *tp = get_method_param_type (get_entity_type (meth), n);
+ ir_type *tp = get_method_param_type (get_entity_type (meth), n);
if (is_Pointer_type (tp)) {
tp = get_pointer_points_to_type (tp);
}
cough_and_die (proj_in);
}
} else {
- opcode op = get_irn_opcode (proj_in);
+ ir_opcode op = get_irn_opcode (proj_in);
if ((iro_Load != op) && (iro_Alloc != op) && (iro_Call != op)) {
fprintf (stdout, "\n Proj (%s) not handled\n",
get_op_name (get_irn_op (proj_in)));
*/
typalise_t *typalise (ir_node *node)
{
- opcode op = get_irn_opcode (node);
+ ir_opcode op = get_irn_opcode (node);
typalise_t *res = NULL;
switch (op) {
case (iro_Cast): {
/* casts always succeed */
typalise_t *ta = NULL;
- type *tp = get_Cast_type (node);
+ ir_type *tp = get_Cast_type (node);
if (is_Pointer_type (tp)) {
tp = get_pointer_points_to_type (tp);
case (iro_Sel): {
/* FILTER */
/* it's call (sel (ptr)) or load (sel (ptr)) */
- entity *ent = get_Sel_entity (node);
- type *tp = get_entity_type (ent);
+ ir_entity *ent = get_Sel_entity (node);
+ ir_type *tp = get_entity_type (ent);
if (is_Method_type (tp)) {
/* obsoleted by typalise_call */
} break;
case (iro_Alloc): {
- type *type = get_Alloc_type (node);
+ ir_type *type = get_Alloc_type (node);
res = ta_exact (type);
} break;
case (iro_Call): {
/* presumably call (sel (proj (call))) */
ir_node *ptr = get_Call_ptr (node);
- entity *meth = NULL;
+ ir_entity *meth = NULL;
if (iro_Sel == get_irn_opcode (ptr)) {
meth = get_Sel_entity (ptr);
} else if (iro_SymConst == get_irn_opcode (ptr)) {
}
if (NULL != meth) {
- type *tp = get_method_res_type ((type*) meth, 0);
+ ir_type *tp = get_method_res_type ((ir_type*) meth, 0);
res = ta_type (tp);
} else {
/* could be anything */
case (iro_SymConst): {
if (get_SymConst_kind (node) == symconst_type_tag) {
- type *tp = get_SymConst_type (node);
+ ir_type *tp = get_SymConst_type (node);
res = ta_type (tp);
} else if (get_SymConst_kind (node) == symconst_addr_ent) {
- entity *ent = get_SymConst_entity (node);
- type *tp = get_entity_owner (ent);
+ ir_entity *ent = get_SymConst_entity (node);
+ ir_type *tp = get_entity_owner (ent);
while (is_Pointer_type (tp)) {
tp = get_pointer_points_to_type (tp);
\f
/*
$Log$
+ Revision 1.14 2007/01/16 15:45:42 beck
+ renamed type opcode to ir_opcode
+
+ Revision 1.13 2006/12/13 19:46:47 beck
+ rename type entity into ir_entity
+
+ Revision 1.12 2006/01/13 21:54:02 beck
+ renamed all types 'type' to 'ir_type'
+
Revision 1.11 2005/05/13 16:35:14 beck
made (void) prototypes
removed unused fprintf arguments
projects / libfirm / blobdiff