-/**
- * @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"
#include <assert.h>
-#ifdef HAVE_ALLOCA_H
-#include <alloca.h>
-#endif
-#ifdef HAVE_MALLOC_H
-#include <malloc.h>
-#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"
#include "ircons.h"
#include "irgmod.h"
#include "irflag_t.h"
+#include "xmalloc.h"
/* - statistics ---------------------------------------------- */
/* - 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;
* 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);
}
/** 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);
}
}
-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;
/* 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;
}
/* 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;
}
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);
*/
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;
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);
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);
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;
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);
}
}
projects / libfirm / blobdiff