X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Ftropt.c;h=d2bc5eaefadf9c018c965657c0eb54373a4a70a0;hb=fe4dd08ecc09bf5c9e63cc2d2cb756295af7b423;hp=c9a0a7396708867fcf5338a49d81802e7af67b17;hpb=5995f2379898a205a2d18fbd9fe840810f42025d;p=libfirm diff --git a/ir/opt/tropt.c b/ir/opt/tropt.c index c9a0a7396..d2bc5eaef 100644 --- a/ir/opt/tropt.c +++ b/ir/opt/tropt.c @@ -1,17 +1,28 @@ -/** - * @file tropt.c +/* + * Copyright (C) 1995-2007 University of Karlsruhe. All right reserved. + * + * This file is part of libFirm. + * + * This file may be distributed and/or modified under the terms of the + * GNU General Public License version 2 as published by the Free Software + * Foundation and appearing in the file LICENSE.GPL included in the + * packaging of this file. * - * Project: libFIRM - * File name: ir/opt/tropt.c - * Purpose: Optimize the type representation. - * Author: Goetz Lindenmaier - * Modified by: - * Created: 20.4.2005 - * CVS-ID: $Id$ - * Copyright: (c) 2005 Universität Karlsruhe - * Licence: This file protected by GPL - GNU GENERAL PUBLIC LICENSE. + * Licensees holding valid libFirm Professional Edition licenses may use + * this file in accordance with the libFirm Commercial License. + * Agreement provided with the Software. * - * Perform optimizations of the type representation. + * This file is provided AS IS with NO WARRANTY OF ANY KIND, INCLUDING THE + * WARRANTY OF DESIGN, MERCHANTABILITY AND FITNESS FOR A PARTICULAR + * PURPOSE. + */ + +/** + * @file + * @brief Perform optimizations of the type representation. + * @date 20.4.2005 + * @author Goetz Lindenmaier + * @version $Id$ */ #ifdef HAVE_CONFIG_H #include "config.h" @@ -19,19 +30,8 @@ #include -#ifdef HAVE_ALLOCA_H -#include -#endif -#ifdef HAVE_MALLOC_H -#include -#endif - -#include "tropt.h" - +#include "iroptimize.h" #include "irprog.h" -#include "mangle.h" - -#include "tr_inheritance.h" #include "irtypeinfo.h" #include "irgwalk.h" #include "irsimpletype.h" @@ -39,6 +39,7 @@ #include "ircons.h" #include "irgmod.h" #include "irflag_t.h" +#include "xmalloc.h" /* - statistics ---------------------------------------------- */ @@ -48,7 +49,7 @@ static int n_sels_concretized = 0; /* - Cast normalization. ------------------------------------- */ -static type *default_gen_pointer_type_to(type *tp); +static ir_type *default_gen_pointer_type_to(ir_type *tp); #define PTR_TYPE_SUFFIX "cc_ptr_tp" /* class cast pointer type. */ static ident *ptr_type_suffix = NULL; @@ -58,8 +59,8 @@ static gen_pointer_type_to_func gen_pointer_type_to = default_gen_pointer_type_t * Find a pointer type to a given type. * Uses and updates trouts if available. */ -static type *default_gen_pointer_type_to(type *tp) { - type *res = NULL; +static ir_type *default_gen_pointer_type_to(ir_type *tp) { + ir_type *res = NULL; if (get_trouts_state() == outs_consistent) { if (get_type_n_pointertypes_to(tp) > 0) { res = get_type_pointertype_to(tp, 0); @@ -81,7 +82,7 @@ static type *default_gen_pointer_type_to(type *tp) { } /** Return a type that is a depth times pointer to type. */ -static type *pointerize_type(type *tp, int depth) { +static ir_type *pointerize_type(ir_type *tp, int depth) { for (; depth > 0; --depth) { tp = gen_pointer_type_to(tp); } @@ -89,8 +90,8 @@ static type *pointerize_type(type *tp, int depth) { } -static ir_node *normalize_values_type(type *totype, ir_node *pred) { - type *fromtype = get_irn_typeinfo_type(pred); +static ir_node *normalize_values_type(ir_type *totype, ir_node *pred) { + ir_type *fromtype = get_irn_typeinfo_type(pred); ir_node *new_cast = pred; int ref_depth = 0; @@ -117,11 +118,11 @@ static ir_node *normalize_values_type(type *totype, ir_node *pred) { /* downcast */ while (get_class_subtype_index(fromtype, totype) == -1) { /* Insert a cast to a subtype of fromtype. */ - type *new_type = NULL; + ir_type *new_type = NULL; ir_node *new_cast; int i, n_subtypes = get_class_n_subtypes(fromtype); for (i = 0; i < n_subtypes && !new_type; ++i) { - type *new_sub = get_class_subtype(fromtype, i); + ir_type *new_sub = get_class_subtype(fromtype, i); if (is_SuperClass_of(new_sub, totype)) new_type = new_sub; } @@ -140,10 +141,10 @@ static ir_node *normalize_values_type(type *totype, ir_node *pred) { /* upcast */ while (get_class_supertype_index(fromtype, totype) == -1) { /* Insert a cast to a supertype of fromtype. */ - type *new_type = NULL; + ir_type *new_type = NULL; int i, n_supertypes = get_class_n_supertypes(fromtype); for (i = 0; i < n_supertypes && !new_type; ++i) { - type *new_super = get_class_supertype(fromtype, i); + ir_type *new_super = get_class_supertype(fromtype, i); if (is_SubClass_of(new_super, totype)) new_type = new_super; } @@ -165,12 +166,12 @@ static void normalize_irn_class_cast(ir_node *n, void *env) { ir_node *res; if (get_irn_op(n) == op_Cast) { ir_node *pred = get_Cast_op(n); - type *totype = get_Cast_type(n); + ir_type *totype = get_Cast_type(n); res = normalize_values_type(totype, pred); set_Cast_op(n, res); } else if (get_irn_op(n) == op_Call) { int i, n_params = get_Call_n_params(n); - type *tp = get_Call_type(n); + ir_type *tp = get_Call_type(n); for (i = 0; i < n_params; ++i) { res = normalize_values_type(get_method_param_type(tp, i), get_Call_param(n, i)); set_Call_param(n, i, res); @@ -239,7 +240,7 @@ void normalize_irp_class_casts(gen_pointer_type_to_func gppt_fct) { */ static void cancel_out_casts(ir_node *cast) { ir_node *orig, *pred = get_Cast_op(cast); - type *tp_cast, *tp_pred, *tp_orig; + ir_type *tp_cast, *tp_pred, *tp_orig; int ref_depth = 0; if (get_irn_op(pred) != op_Cast) return; @@ -288,8 +289,8 @@ static void cancel_out_casts(ir_node *cast) { static void concretize_selected_entity(ir_node *sel) { ir_node *cast, *ptr = get_Sel_ptr(sel); - type *orig_tp, *cast_tp; - entity *new_ent, *sel_ent; + ir_type *orig_tp, *cast_tp; + ir_entity *new_ent, *sel_ent; sel_ent = get_Sel_entity(sel); cast = get_Sel_ptr(sel); @@ -330,7 +331,7 @@ static void concretize_Phi_type(ir_node *phi) { int i, n_preds = get_Phi_n_preds(phi); ir_node **pred = alloca(n_preds * sizeof(ir_node *)); ir_node *new; - type *totype, *fromtype; + ir_type *totype, *fromtype; if (n_preds == 0) return; pred[0] = get_Phi_pred(phi, 0); @@ -362,7 +363,7 @@ static void concretize_Phi_type(ir_node *phi) { void remove_Cmp_Null_cast(ir_node *cmp) { ir_node *cast, *null, *new_null; int cast_pos, null_pos; - type *fromtype; + ir_type *fromtype; cast = get_Cmp_left(cmp); cast_pos = 0; @@ -417,7 +418,7 @@ void optimize_class_casts(void) { set_irg_outs_inconsistent(get_irp_irg(i)); if (get_opt_optimize_class_casts_verbose() && get_firm_verbosity()) { - printf(" Cast optimization: %d Casts removed, %d sels concretized.\n", + printf(" Cast optimization: %d Casts removed, %d Sels concretized.\n", n_casts_removed, n_sels_concretized); } }