2 * Copyright (C) 1995-2008 University of Karlsruhe. All right reserved.
4 * This file is part of libFirm.
6 * This file may be distributed and/or modified under the terms of the
7 * GNU General Public License version 2 as published by the Free Software
8 * Foundation and appearing in the file LICENSE.GPL included in the
9 * packaging of this file.
11 * Licensees holding valid libFirm Professional Edition licenses may use
12 * this file in accordance with the libFirm Commercial License.
13 * Agreement provided with the Software.
15 * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE
16 * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR
22 * @brief Optimize polymorphic Sel and Load nodes.
23 * @author Goetz Lindenmaier, Michael Beck
26 * This file subsumes optimization code from cgana.
30 #include "iroptimize.h"
38 #include "iropt_dbg.h"
42 * Checks if a graph allocates new memory and returns the
43 * type of the newly allocated entity.
44 * Returns NULL if the graph did not represent an Allocation.
46 * The default implementation hecks for Alloc nodes only.
48 ir_type *default_firm_get_Alloc(ir_node *n) {
51 return get_Alloc_type(n);
56 typedef ir_type *(*get_Alloc_func)(ir_node *n);
58 /** The get_Alloc function */
59 static get_Alloc_func firm_get_Alloc = default_firm_get_Alloc;
61 /** Set a new get_Alloc_func and returns the old one. */
62 get_Alloc_func firm_set_Alloc_func(get_Alloc_func newf) {
63 get_Alloc_func old = firm_get_Alloc;
64 firm_get_Alloc = newf;
68 /** Return dynamic type of ptr.
70 * If we can deduct the dynamic type from the firm nodes
71 * by a limited test we return the dynamic type. Else
72 * we return unknown_type.
74 * If we find a dynamic type this means that the pointer always points
75 * to an object of this type during runtime. We resolved polymorphy.
77 static ir_type *get_dynamic_type(ir_node *ptr) {
80 /* skip Cast and Confirm nodes */
82 ir_opcode code = get_irn_opcode(ptr);
86 ptr = get_Cast_op(ptr);
89 ptr = get_Confirm_value(ptr);
96 tp = (*firm_get_Alloc)(ptr);
97 return tp ? tp : firm_unknown_type;
101 * Check, if an entity is final, i.e. is not anymore overridden.
103 static int is_final_ent(ir_entity *ent) {
104 if (is_entity_final(ent)) {
105 /* not possible to override this entity. */
108 if (get_opt_closed_world() && get_entity_n_overwrittenby(ent) == 0) {
109 /* we have a closed world, so simply check how often it was
117 * Transform Sel[method] to SymC[method] if possible.
119 ir_node *transform_node_Sel(ir_node *node) {
120 ir_node *new_node, *ptr;
122 ir_entity *ent = get_Sel_entity(node);
124 if (get_irp_phase_state() == phase_building) return node;
126 if (!(get_opt_optimize() && get_opt_dyn_meth_dispatch()))
129 if (!is_Method_type(get_entity_type(ent)))
132 /* If the entity is a leave in the inheritance tree,
133 we can replace the Sel by a constant. */
134 if (is_final_ent(ent)) {
135 /* In dead code, we might call a leave entity that is a description.
136 Do not turn the Sel to a SymConst. */
137 if (get_entity_peculiarity(ent) == peculiarity_description) {
138 /* We could remove the Call depending on this Sel. */
141 ir_node *rem_block = get_cur_block();
142 set_cur_block(get_nodes_block(node));
143 new_node = copy_const_value(get_irn_dbg_info(node), get_atomic_ent_value(ent));
144 set_cur_block(rem_block);
145 DBG_OPT_POLY(node, new_node);
150 /* If we know the dynamic type, we can replace the Sel by a constant. */
151 ptr = get_Sel_ptr(node); /* The address we select from. */
152 dyn_tp = get_dynamic_type(ptr); /* The runtime type of ptr. */
154 if (dyn_tp != firm_unknown_type) {
155 ir_entity *called_ent;
158 /* We know which method will be called, no dispatch necessary. */
159 called_ent = resolve_ent_polymorphy(dyn_tp, ent);
160 /* called_ent may not be description: has no Address/Const to Call! */
161 assert(get_entity_peculiarity(called_ent) != peculiarity_description);
163 rem_block = get_cur_block();
164 set_cur_block(get_nodes_block(node));
165 new_node = copy_const_value(get_irn_dbg_info(node), get_atomic_ent_value(called_ent));
166 set_cur_block(rem_block);
167 DBG_OPT_POLY(node, new_node);
175 /* Transform Load(Sel(Alloc)[constant static entity])
176 * to Const[constant static entity value].
178 * This function returns a node replacing the Proj(Load)[Value].
179 * If this is actually called in transform_node, we must build
180 * a tuple, or replace the Projs of the load.
181 * Therefore we call this optimization in ldstopt().
183 ir_node *transform_polymorph_Load(ir_node *load) {
184 ir_node *new_node = NULL;
185 ir_node *field_ptr, *ptr;
189 if (!(get_opt_optimize() && get_opt_dyn_meth_dispatch()))
192 field_ptr = get_Load_ptr(load);
194 if (! is_Sel(field_ptr)) return load;
196 ent = get_Sel_entity(field_ptr);
197 if ((get_entity_allocation(ent) != allocation_static) ||
198 (get_entity_variability(ent) != variability_constant) )
201 /* If the entity is a leave in the inheritance tree,
202 we can replace the Sel by a constant. */
203 if ((get_irp_phase_state() != phase_building) && is_final_ent(ent)) {
204 new_node = get_atomic_ent_value(ent);
206 /* If we know the dynamic type, we can replace the Sel by a constant. */
207 ptr = get_Sel_ptr(field_ptr); /* The address we select from. */
208 dyn_tp = get_dynamic_type(ptr); /* The runtime type of ptr. */
210 if (dyn_tp != firm_unknown_type) {
211 ir_entity *loaded_ent;
213 /* We know which method will be called, no dispatch necessary. */
214 loaded_ent = resolve_ent_polymorphy(dyn_tp, ent);
215 /* called_ent may not be description: has no Address/Const to Call! */
216 assert(get_entity_peculiarity(loaded_ent) != peculiarity_description);
217 new_node = get_atomic_ent_value(loaded_ent);
220 if (new_node != NULL) {
221 new_node = can_replace_load_by_const(load, new_node);
222 if (new_node != NULL) {
223 DBG_OPT_POLY(field_ptr, new_node);