From b2e11274ee969200b5e3e5135d05c4845de3a39f Mon Sep 17 00:00:00 2001 From: =?utf8?q?Christian=20Sch=C3=A4fer?= Date: Thu, 15 Jun 2000 16:08:06 +0000 Subject: [PATCH] *** empty log message *** [r17] --- ir/ir/Makefile | 2 +- ir/ir/ircons.c | 35 +++++++ ir/ir/ircons.h | 9 +- ir/ir/irgopt.c | 260 +++++++++++++++++++++++++++++++++++++++++++++++++ ir/ir/irgopt.h | 21 ++++ ir/ir/irnode.h | 10 +- ir/ir/iropt.c | 29 +----- ir/ir/iropt.h | 4 - 8 files changed, 330 insertions(+), 40 deletions(-) create mode 100644 ir/ir/irgopt.c create mode 100644 ir/ir/irgopt.h diff --git a/ir/ir/Makefile b/ir/ir/Makefile index a6ce23237..02fb0156a 100644 --- a/ir/ir/Makefile +++ b/ir/ir/Makefile @@ -22,7 +22,7 @@ X_INCLUDES = SHELL = /bin/sh MAKE = /usr/bin/make -MEMBERS = ircons.m irdump.m irflag.m irgmod.m irgraph.m \ +MEMBERS = ircons.m irdump.m irflag.m irgmod.m irgraph.m irgopt.m \ irgwalk.m irmode.m irnode.m irop.m iropt.m irvrfy.m CFILES = $(MEMBERS:.m=.c) diff --git a/ir/ir/ircons.c b/ir/ir/ircons.c index 7c4769795..485c86add 100644 --- a/ir/ir/ircons.c +++ b/ir/ir/ircons.c @@ -49,6 +49,41 @@ new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, /*********************************************** */ /** privat interfaces, for professional use only */ +/*CS*/ +inline ir_node * +new_r_Block (ir_graph *irg, int arity, ir_node **in) +{ + ir_node *res; + + return res; + +} + +ir_node * +new_r_Start (ir_graph *irg, ir_node *block) +{ + ir_node *res; + + res = new_ir_node (irg, block, op_Start, mode_T, 0, NULL); + + ir_vrfy (res); + return res; +} + + +ir_node * +new_r_End (ir_graph *irg, ir_node *block) +{ + ir_node *res; + + res = new_ir_node (irg, block, op_End, mode_X, -1, NULL); + + ir_vrfy (res); + return res; + +} + + /* Creates a Phi node with 0 predecessors */ inline ir_node * new_r_Phi0 (ir_graph *irg, ir_node *block, ir_mode *mode) diff --git a/ir/ir/ircons.h b/ir/ir/ircons.h index f130b7728..6088d7dde 100644 --- a/ir/ir/ircons.h +++ b/ir/ir/ircons.h @@ -929,7 +929,7 @@ /* Create a new irnode in irg, with an op, mode, arity and */ /* some incoming irnodes. */ /* If arity is negative, a node with a dynamic array is created. */ -/*CS inline ir_node *new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, +/* inline ir_node *new_ir_node (ir_graph *irg, ir_node *block, ir_op *op, ir_mode *mode, int arity, ir_node **in); */ /** These headers need not to be here. They are never used by the @@ -949,6 +949,9 @@ typedef struct Phi_in_stack { /* privat interfaces */ /* more detailed construction */ +ir_node *new_r_Block (ir_graph *irg, int arity, ir_node **in); +ir_node *new_r_Start (ir_graph *irg, ir_node *block); +ir_node *new_r_End (ir_graph *irg, ir_node *block); ir_node *new_r_Jmp (ir_graph *irg, ir_node *block); ir_node *new_r_Cond (ir_graph *irg, ir_node *block, ir_node *c); ir_node *new_r_Return (ir_graph *irg, ir_node *block, @@ -990,6 +993,8 @@ ir_node *new_r_Eor (ir_graph *irg, ir_node *block, ir_node *op1, ir_node *op2, ir_mode *mode); ir_node *new_r_Not (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode); +ir_node *new_r_Cmp (ir_graph *irg, ir_node *block, + ir_node *op1, ir_node *op2); ir_node *new_r_Shl (ir_graph *irg, ir_node *block, ir_node *op, ir_node *k, ir_mode *mode); ir_node *new_r_Shr (ir_graph *irg, ir_node *block, @@ -998,8 +1003,6 @@ ir_node *new_r_Shrs (ir_graph *irg, ir_node *block, ir_node *op, ir_node *k, ir_mode *mode); ir_node *new_r_Rot (ir_graph *irg, ir_node *block, ir_node *op, ir_node *k, ir_mode *mode); -ir_node *new_r_Cmp (ir_graph *irg, ir_node *block, - ir_node *op1, ir_node *op2); ir_node *new_r_Conv (ir_graph *irg, ir_node *block, ir_node *op, ir_mode *mode); ir_node *new_r_Phi (ir_graph *irg, ir_node *block, int arity, diff --git a/ir/ir/irgopt.c b/ir/ir/irgopt.c new file mode 100644 index 000000000..f8833515c --- /dev/null +++ b/ir/ir/irgopt.c @@ -0,0 +1,260 @@ +/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe +** All rights reserved. +** +** Author: Christian Schaefer +** +** dead node elemination +** walks one time through the whole graph and copies it into another graph, +** so unreachable nodes will be lost. +*/ + +# include "irgopt.h" +# include "irnode.h" +# include "iropt.h" +# include "irgwalk.h" +# include "irgraph.h" +# include "ircons.h" + +void +optimize_in_place_wrapper (ir_node *n, void *env) { + int i; + ir_node *optimized; + + /* optimize all sons after recursion, i.e., the sons' sons are + optimized already. */ + for (i = -1; i < get_irn_arity(n); i++) { + optimized = optimize_in_place(get_irn_n(n, i)); + set_irn_n(n, i, optimized); + } +} + + +void +local_optimize_graph (ir_graph *irg) { + ir_graph *rem = current_ir_graph; + current_ir_graph = irg; + + /* walk over the graph */ + irg_walk(irg->end, NULL, optimize_in_place_wrapper, NULL); + + current_ir_graph = rem; +} + +/* Remeber the new node in the old node, + by using a field that all nodes have. */ +void * +set_new_node (ir_node *old, ir_node *new) +{ + old->in[0] = new; + return old; +} + +/* Get this new node, before the old node is forgotton.*/ +ir_node * +get_new_node (ir_node * n) +{ + return n->in[0]; +} + + + +/* Create this node on a new obstack. */ +void +copy_node (ir_node *n, void *env) { + ir_node * res, a, b; + + if (is_binop(n)) { + a = get_binop_left(n); + b = get_binop_right(n); + } else if (is_unop(n)) { + a = get_unop_op(n); + } + + switch (get_irn_opcode(n)) { + case iro_Block: + int i; + ir_node **in [get_Block_n_cfgpreds(n)]; + for (i=0; i <(get_Return_n_res(n)); i++) { + in[i] = get_Block_cfgpred (n, i); + } + res = new_r_Block (current_ir_graph, get_Block_n_cfgpreds(n), in); + set_new_node(n, res); + break; + case iro_Start: + res = new_r_Start (current_ir_graph, get_new_node(n)); + set_new_node(n, res); + break; + case iro_End: + res = new_r_End (current_ir_graph, get_new_node(n)); + set_new_node(n, res); + break; + case iro_Jmp: + res = new_r_Jmp (current_ir_graph, get_new_node(n)); + set_new_node(n, res); + break; + case iro_Cond: + res = new_r_Cond (current_ir_graph, get_new_node(n), + get_Cond_selector(n)); + set_new_node(n, res); + break; + case iro_Return: + { + /*CS malloc*/ + int i; + ir_node **in [get_Return_n_res(n)]; + for (i=0; i <(get_Return_n_res(n)); i++) { + in[i] = get_Return_res (n, i); + } + res = new_r_Return (current_ir_graph, get_new_node(n), + get_Return_mem (n), get_Return_n_res(n), in); + set_new_node(n, res); + } + break; + case iro_Raise: + res = new_r_Raise (current_ir_graph, get_new_node(n), + get_Raise_mem(n), get_Raise_exoptr(n)); + set_new_node(n, res); + break; + case iro_Const: + res = new_r_Const (current_ir_graph, get_new_node(n), + get_irn_mode(n), get_Const_tarval(n)); + set_new_node(n, res); + break; + case iro_SymConst: + { + if (get_SymConst_kind(n) == type_tag || get_SymConst_kind(n) == size) + { + res = new_r_Raise (current_ir_graph, get_new_node(n), + get_SymConst_type(n), get_SymConst_kind (n)); + } + else + /* if get_SymConst_kind(n) == linkage_ptr_info */ + { + res = new_r_Raise (current_ir_graph, get_new_node(n), + get_SymConst_ptrinfo(n), get_SymConst_kind (n)); + } + set_new_node(n, res); + } + break; + case iro_Sel: + { + int i; + ir_node **in [get_Sel_n_index(n)]; + for (i=0; i <(get_Sel_n_index(n)); i++) { + in[i] = get_Sel_index (n, i); + } + res = new_r_Sel (current_ir_graph, get_new_node(n), + get_Sel_mem(n), get_Sel_ptr(n), get_Sel_n_index(n), + in, get_Sel_entity(n)); + set_new_node(n, res); + } + break; + case iro_Call: + { + int i; + ir_node **in [get_Call_arity(n)]; + for (i=0; i <(get_Call_arity(n)); i++) { + in[i] = get_Call_param (n, i); + } + res = new_r_Call (current_ir_graph, get_new_node(n), get_Call_mem(n), + get_Call_ptr(n), get_Call_arity(n), + in, get_Call_type (n)); + set_new_node(n, res); + } + break; + case iro_Add: + res = new_r_Add (current_ir_graph, get_new_node(n), + get_new_node(a), + get_new_node(b), get_irn_mode(n)); + set_new_node(n, res); + break; + case iro_Sub: + res = new_r_Sub (current_ir_graph, get_new_node(get_nodes_block(n)), + get_new_node(a), + get_new_node(b), get_irn_mode(n)); + set_new_node(n, res); + break; + case iro_Minus: + res = new_r_Minus (current_ir_graph, get_new_node(n), get_new_node(a), + get_irn_mode(n)); + set_new_node(n, res); + break; + case iro_Mul: + break; + case iro_Quot: + break; + case iro_DivMod: + break; + case iro_Div: + break; + case iro_Mod: + break; + case iro_Abs: + break; + case iro_And: + break; + case iro_Or: + break; + case iro_Eor: + break; + case iro_Not: + break; + case iro_Cmp: + break; + case iro_Shl: + break; + case iro_Shr: + break; + case iro_Shrs: + break; + case iro_Rot: + break; + case iro_Conv: + break; + case iro_Phi: + break; + case iro_Load: + break; + case iro_Store: + break; + case iro_Alloc: + break; + case iro_Free: + break; + case iro_Sync: + break; + case iro_Proj: + break; + case iro_Tuple: + break; + case iro_Id: + break; + case iro_Bad: + break; + } + +} + + +void +dead_node_elemination(ir_graph *irg) { + struct obstack *graveyard_obst; + struct obstack *rebirth_obst; + + /* A quiet place, where the old obstack can rest in peace, + until it will be cremated. */ + graveyard_obst = irg->obst; + + /* A new obstack, where the reachable nodes will be copied to. */ + rebirth_obst = (struct obstack *) xmalloc (sizeof (struct obstack)); + current_ir_graph->obst = rebirth_obst; + obstack_init (current_ir_graph->obst); + + /* Walks the graph once, and at the recursive way do the copy thing. + all reachable nodes will be copied to a new obstack. */ + irg_walk(irg->end, NULL, copy_node, NULL); + + /* Free memory from old unoptimized obstack */ + xfree (graveyard_obst); + +} diff --git a/ir/ir/irgopt.h b/ir/ir/irgopt.h new file mode 100644 index 000000000..aef48b4cb --- /dev/null +++ b/ir/ir/irgopt.h @@ -0,0 +1,21 @@ +/* Copyright (C) 1998 - 2000 by Universitaet Karlsruhe +** All rights reserved. +** +** Author: Christian Schaefer +** +** dead node elemination +** walks one time through the whole graph and copies it into another graph, +** so unreachable nodes will be lost. +*/ + +# ifndef _IRGOPT_H_ +# define _IRGOPT_H_ + +# include "irgraph.h" + + +void local_optimize_graph (ir_graph *irg); + +void dead_node_elemination(ir_graph *irg); + +# endif /* _IRGOPT_H_ */ diff --git a/ir/ir/irnode.h b/ir/ir/irnode.h index f5c4939c5..54ad3d0ff 100644 --- a/ir/ir/irnode.h +++ b/ir/ir/irnode.h @@ -67,10 +67,12 @@ typedef struct { } block_attr; typedef enum { - type_tag, /* The SymConst is a type tag for the given type. */ - size, /* The SymConst is the size of the given type. */ + type_tag, /* The SymConst is a type tag for the given type. + Type_or_id is type */ + size, /* The SymConst is the size of the given type. + Type_or_id is type */ linkage_ptr_info /* The SymConst is a symbolic pointer to be filled in - by the linker. */ + by the linker. Type_or_id is ident */ } symconst_kind; typedef union { @@ -156,7 +158,7 @@ typedef struct ir_node ir_node; /* Create a new irnode in irg, with an op, mode, arity and */ /* some incoming irnodes. */ /* If arity is negative, a node with a dynamic array is created. */ -/*CS inline ir_node *new_ir_node (int *irg, ir_node *block, ir_op *op, +/* inline ir_node *new_ir_node (int *irg, ir_node *block, ir_op *op, ir_mode *mode, int arity, ir_node **in); */ #endif diff --git a/ir/ir/iropt.c b/ir/ir/iropt.c index 68221c9ca..562bddf27 100644 --- a/ir/ir/iropt.c +++ b/ir/ir/iropt.c @@ -911,7 +911,7 @@ optimize (ir_node *n) /** common subexpression elimination **/ /* Checks whether n is already available. */ - /* The block input is used to distinguish different subexpressions. Right + /* The block input is used to distinguish different subexpressions. Right now all nodes are pinned to blocks, i.e., the cse only finds common subexpressions within a block. */ @@ -1020,30 +1020,3 @@ optimize_in_place (ir_node *n) return n; } - - -void -optimize_in_place_wrapper (ir_node *n, void *env) { - int i; - ir_node *optimized; - - /* optimize all sons after recursion, i.e., the sons' sons are - optimized already. */ - for (i = -1; i < get_irn_arity(n); i++) { - optimized = optimize_in_place(get_irn_n(n, i)); - set_irn_n(n, i, optimized); - } -} - - -void -optimize_graph (ir_graph *irg) -{ - ir_graph *rem = current_ir_graph; - current_ir_graph = irg; - - /* walk over the graph */ - irg_walk(irg->end, NULL, optimize_in_place_wrapper, NULL); - - current_ir_graph = rem; -} diff --git a/ir/ir/iropt.h b/ir/ir/iropt.h index 7f1389d17..20dc04dfa 100644 --- a/ir/ir/iropt.h +++ b/ir/ir/iropt.h @@ -32,8 +32,4 @@ void del_identities (pset *value_table); ir_node *optimize (ir_node *n); ir_node *optimize_in_place (ir_node *n); - -void optimize_graph (ir_graph *irg); - - # endif /* _IROPT_H_ */ -- 2.20.1