From: Götz Lindenmaier Date: Wed, 9 Mar 2005 16:15:57 +0000 (+0000) Subject: optimize polymorphic field accesses X-Git-Url: http://nsz.repo.hu/git/?a=commitdiff_plain;h=8eb0a1256d88d68e762c1f087bffadca68dc5c12;p=libfirm optimize polymorphic field accesses [r5324] --- diff --git a/ir/opt/Makefile.in b/ir/opt/Makefile.in index 9ee10adbb..ce235fd5f 100644 --- a/ir/opt/Makefile.in +++ b/ir/opt/Makefile.in @@ -16,13 +16,13 @@ topdir = ../.. subdir := ir/ir INSTALL_HEADERS = cfopt.h tailrec.h ldstopt.h strength_red.h reassoc.h \ - loop_unrolling.h + loop_unrolling.h opt_polymorphy.h SOURCES = $(INSTALL_HEADERS) SOURCES += Makefile.in \ cfopt.c tailrec.c strength_red.c ldstopt.c reassoc.c \ - loop_unrolling.c ifconv.c scalar_replace.c + loop_unrolling.c ifconv.c scalar_replace.c opt_polymorphy.c include $(topdir)/MakeRules diff --git a/ir/opt/ldstopt.c b/ir/opt/ldstopt.c index d792260b5..4070a87a5 100644 --- a/ir/opt/ldstopt.c +++ b/ir/opt/ldstopt.c @@ -36,6 +36,11 @@ # include "irflag_t.h" # include "array.h" # include "irhooks.h" +# include "opt_polymorphy.h" + +#ifdef DO_CACHEOPT +#include "cacheopt/cachesim.h" +#endif #undef IMAX #define IMAX(a,b) ((a) > (b) ? (a) : (b)) @@ -234,7 +239,7 @@ static void collect_nodes(ir_node *node, void *env) } /** - * returns a entity if the address ptr points to a constant one. + * Returns an entity if the address ptr points to a constant one. */ static entity *find_constant_entity(ir_node *ptr) { @@ -248,6 +253,15 @@ static entity *find_constant_entity(ir_node *ptr) entity *ent = get_Sel_entity(ptr); type *tp = get_entity_owner(ent); + /* Do not fiddle about polymorphy. */ + if (is_Class_type(get_entity_owner(ent)) && + ((get_entity_n_overwrites(ent) != 0) || + (get_entity_n_overwrittenby(ent) != 0) ) ) + return NULL; + + if (variability_constant == get_entity_variability(ent)) + return ent; + if (is_Array_type(tp)) { /* check bounds */ int i, n; @@ -287,6 +301,38 @@ static entity *find_constant_entity(ir_node *ptr) } } +static long get_Sel_array_index_long(ir_node *n, int dim) { + ir_node *index = get_Sel_index(n, dim); + assert(get_irn_op(index) == op_Const); + return get_tarval_long(get_Const_tarval(index)); +} + +compound_graph_path *rec_get_accessed_path(ir_node *ptr, int depth) { + compound_graph_path *res; + if (get_irn_op(ptr) == op_SymConst) { + assert(get_SymConst_kind(ptr) == symconst_addr_ent); + entity *root = get_SymConst_entity(ptr); + res = new_compound_graph_path(get_entity_type(root), depth); + } else { + assert(get_irn_op(ptr) == op_Sel); + res = rec_get_accessed_path(get_Sel_ptr(ptr), depth+1); + entity *field = get_Sel_entity(ptr); + int path_len = get_compound_graph_path_length(res); + int pos = path_len - depth -1; + set_compound_graph_path_node(res, pos, field); + if (is_Array_type(get_entity_owner(field))) { + assert(get_Sel_n_indexs(ptr) == 1 && "multi dim arrays not implemented"); + set_compound_graph_path_array_index(res, pos, get_Sel_array_index_long(ptr, 0)); + } + } + return res; +} + +compound_graph_path *get_accessed_path(ir_node *ptr) { + return rec_get_accessed_path(ptr, 0); +} + + /** * optimize a Load */ @@ -354,6 +400,23 @@ static int optimize_load(ir_node *load) /* the mem of the Load. Must still be returned after optimization */ mem = get_Load_mem(load); + /* Load from a constant polymorphic field, where we can resolve + polymorphy. */ + ir_node *new_node = transform_node_Load(load); + if (new_node != load) { + if (info->projs[pn_Load_M]) { + exchange(info->projs[pn_Load_M], mem); + info->projs[pn_Load_M] = NULL; + } + if (info->projs[pn_Load_X_except]) { + exchange(info->projs[pn_Load_X_except], new_Bad()); + info->projs[pn_Load_X_except] = NULL; + } + if (info->projs[pn_Load_res]) + exchange(info->projs[pn_Load_res], new_node); + return 1; + } + /* check if we can determine the entity that will be loaded */ ent = find_constant_entity(ptr); if (ent) { @@ -395,12 +458,39 @@ static int optimize_load(ir_node *load) } else if (variability_constant == get_entity_variability(ent)) { printf(">>>>>>>>>>>>> Found access to constant entity %s in function %s\n", get_entity_name(ent), - get_entity_name(get_irg_entity(current_ir_graph))); + get_entity_name(get_irg_entity(current_ir_graph))); + printf(" load: "); DDMN(load); + printf(" ptr: "); DDMN(ptr); + + compound_graph_path *path = get_accessed_path(ptr); + assert(is_proper_compound_graph_path(path, get_compound_graph_path_length(path)-1)); + ir_node *c = get_compound_ent_value_by_path(ent, path); + + printf(" cons: "); DDMN(c); + + if (info->projs[pn_Load_M]) + exchange(info->projs[pn_Load_M], mem); + if (info->projs[pn_Load_res]) + exchange(info->projs[pn_Load_res], copy_const_value(c)); + + { + int j; + for (j = 0; j < get_compound_graph_path_length(path); ++j) { + entity *node = get_compound_graph_path_node(path, j); + fprintf(stdout, ".%s", get_entity_name(node)); + if (is_Array_type(get_entity_owner(node))) + fprintf(stdout, "[%d]", get_compound_graph_path_array_index(path, j)); + } + printf("\n"); + } + } /* we changed the irg, but try further */ res = 1; } + + } /* Check, if the address of this load is used more than once. @@ -587,7 +677,7 @@ static int optimize_phi(ir_node *phi, void *env) { walk_env_t *wenv = env; int i, n; - ir_node *store, *ptr, *block, *phiM, *phiD, *exc, *projM; + ir_node *store, *old_store, *ptr, *block, *phiM, *phiD, *exc, *projM; ir_mode *mode; ir_node **inM, **inD; int *idx; @@ -604,6 +694,7 @@ static int optimize_phi(ir_node *phi, void *env) return 0; store = skip_Proj(get_Phi_pred(phi, 0)); + old_store = store; if (get_irn_op(store) != op_Store) return 0; @@ -687,6 +778,10 @@ static int optimize_phi(ir_node *phi, void *env) /* fourth step: create the Store */ store = new_rd_Store(db, current_ir_graph, block, phiM, ptr, phiD); +#ifdef DO_CACHEOPT + co_set_irn_name(store, co_get_irn_ident(old_store)); +#endif + projM = new_rd_Proj(NULL, current_ir_graph, block, store, mode_M, pn_Store_M); info = get_ldst_info(store, wenv); diff --git a/ir/opt/opt_polymorphy.c b/ir/opt/opt_polymorphy.c new file mode 100644 index 000000000..3e3ada34d --- /dev/null +++ b/ir/opt/opt_polymorphy.c @@ -0,0 +1,150 @@ +/* + * Project: libFIRM + * File name: ir/opt/opt_polymorphy + * Purpose: Optimize polymorphic Sel nodes. + * Author: + * Created: + * CVS-ID: $Id$ + * Copyright: (c) 2005 Universität Karlsruhe + * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + */ + +#include "irprog_t.h" +#include "entity_t.h" +#include "type_t.h" +#include "irop.h" +#include "irnode_t.h" +#include "ircons.h" + +#include "iropt_dbg.h" +#include "irflag_t.h" + +/** Return dynamic type of ptr. + * + * If we can deduct the dynamic type from the firm nodes + * by a limited test we return the dynamic type. Else + * we return unknown_type. + * + * If we find a dynamic type this means that the pointer always points + * to an object of this type during runtime. We resolved polymorphy. + */ +static type *get_dynamic_type(ir_node *ptr) { + ptr = skip_Cast(skip_Proj(ptr)); + if (get_irn_op(ptr) == op_Alloc) + return get_Alloc_type(ptr); + return firm_unknown_type; +} + +/* + * Transform Sel(Alloc)[method] + * to SymC[method] + */ +ir_node *transform_node_Sel(ir_node *node) +{ + entity *ent = get_Sel_entity(node); + ir_node *new_node; + + if (get_irp_phase_state() == phase_building) return node; + + if (!(get_opt_optimize() && get_opt_dyn_meth_dispatch())) + return node; + + if (!is_Method_type(get_entity_type(ent))) + return node; + + /* If the entity is a leave in the inheritance tree, + we can replace the Sel by a constant. */ + if ((get_irp_phase_state() != phase_building) && (get_entity_n_overwrittenby(ent) == 0)) { + /* In dead code, we might call a leave entity that is a description. + Do not turn the Sel to a SymConst. */ + if (get_entity_peculiarity(ent) == peculiarity_description) { + /* We could remove the Call depending on this Sel. */ + new_node = node; + } else { + ir_node *rem_block = get_cur_block(); + set_cur_block(get_nodes_block(node)); + new_node = copy_const_value(get_atomic_ent_value(ent)); + set_cur_block(rem_block); + DBG_OPT_POLY_ALLOC(node, new_node); + } + + return new_node; + } + + /* If we know the dynamic type, we can replace the Sel by a constant. */ + ir_node *ptr = get_Sel_ptr(node); /* The address we select from. */ + type *dyn_tp = get_dynamic_type(ptr); /* The runtime type of ptr. */ + + if (dyn_tp != firm_unknown_type) { + entity *called_ent; + + /* We know which method will be called, no dispatch necessary. */ + called_ent = resolve_ent_polymorphy(dyn_tp, ent); + /* called_ent may not be description: has no Address/Const to Call! */ + assert(get_entity_peculiarity(called_ent) != peculiarity_description); + + ir_node *rem_block = get_cur_block(); + set_cur_block(get_nodes_block(node)); + new_node = copy_const_value(get_atomic_ent_value(called_ent)); + set_cur_block(rem_block); + DBG_OPT_POLY_ALLOC(node, new_node); + + return new_node; + } + + return node; +} + +/* Transform Load(Sel(Alloc)[constant static entity]) + * to Const[constant static entity value]. + * + * This function returns a node replacing the Proj(Load)[Value]. + * If this is actually called in transform_node, we must build + * a tuple, or replace the Projs of the load. + * Therefore we call this optimization in ldstopt. + */ +ir_node *transform_node_Load(ir_node *n) +{ + if (!(get_opt_optimize() && get_opt_dyn_meth_dispatch())) + return n; + + ir_node *field_ptr = get_Load_ptr(n); + + if (get_irn_op(field_ptr) != op_Sel) return n; + + entity *ent = get_Sel_entity(field_ptr); + ir_node *new_node; + + if ((get_entity_allocation(ent) != allocation_static) || + (get_entity_variability(ent) != variability_constant) ) + return n; + + /* If the entity is a leave in the inheritance tree, + we can replace the Sel by a constant. */ + if ((get_irp_phase_state() != phase_building) && (get_entity_n_overwrittenby(ent) == 0)) { + new_node = copy_const_value(get_atomic_ent_value(ent)); + DBG_OPT_POLY_ALLOC(field_ptr, new_node); + + return new_node; + } + + /* If we know the dynamic type, we can replace the Sel by a constant. */ + ir_node *ptr = get_Sel_ptr(field_ptr); /* The address we select from. */ + type *dyn_tp = get_dynamic_type(ptr); /* The runtime type of ptr. */ + + if (dyn_tp != firm_unknown_type) { + entity *loaded_ent; + + /* We know which method will be called, no dispatch necessary. */ + loaded_ent = resolve_ent_polymorphy(dyn_tp, ent); + /* called_ent may not be description: has no Address/Const to Call! */ + assert(get_entity_peculiarity(loaded_ent) != peculiarity_description); + + new_node = copy_const_value(get_atomic_ent_value(loaded_ent)); + DBG_OPT_POLY_ALLOC(field_ptr, new_node); + + return new_node; + } + + return n; +} diff --git a/ir/opt/opt_polymorphy.h b/ir/opt/opt_polymorphy.h new file mode 100644 index 000000000..8ba92c03f --- /dev/null +++ b/ir/opt/opt_polymorphy.h @@ -0,0 +1,38 @@ +/* + * Project: libFIRM + * File name: ir/opt/opt_polymorphy.h + * Purpose: Optimize polymorphic Sel and Load nodes. + * Author: + * Created: + * CVS-ID: $Id$ + * Copyright: (c) 2005 Universität Karlsruhe + * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + */ + +/** @file + * + * This file subsumes optimization code from cgana. + */ + +#ifndef _OPT_POLYMORPHY_H_ +#define _OPT_POLYMORPHY_H_ + +#include "irnode.h" + +/** + * Transform Sel(Alloc)[method] + * to SymC[method] + */ +ir_node *transform_node_Sel(ir_node *node); + +/** Transform Load(Sel(Alloc)[constant static entity]) + * to Const[constant static entity value]. + * + * This function returns a node replacing the Proj(Load)[Value]. + * If this is actually called in transform_node, we must build + * a tuple, or replace the Projs of the load. + * Therefore we call this optimization in ldstopt. + */ +ir_node *transform_node_Load(ir_node *n); + +#endif /* _OPT_POLYMORPHY_H_ */