X-Git-Url: http://nsz.repo.hu/git/?a=blobdiff_plain;f=ir%2Fopt%2Fcombo.c;h=e1b8abbe013edcd855916f6d3ccd6fdfcd373cd5;hb=52d1c7c57180cdb6aa12be48a1d41a961dc85174;hp=6d3f30f715dddf9ab1f815fc4025fb645042f68a;hpb=e7820d1d46bfe2eae7dcaed57ed6ef52cc6a382c;p=libfirm

diff --git a/ir/opt/combo.c b/ir/opt/combo.c
index 6d3f30f71..e1b8abbe0 100644
--- a/ir/opt/combo.c
+++ b/ir/opt/combo.c
@@ -63,7 +63,6 @@
 #include <assert.h>
 
 #include "iroptimize.h"
-#include "archop.h"
 #include "irflag.h"
 #include "ircons.h"
 #include "list.h"
@@ -82,7 +81,7 @@
 #include "array_t.h"
 #include "error.h"
 #include "irnodeset.h"
-
+#include "irpass.h"
 #include "tv_t.h"
 
 #include "irprintf.h"
@@ -112,6 +111,10 @@ struct opcode_key_t {
 	union {
 		long      proj;   /**< For Proj nodes, its proj number */
 		ir_entity *ent;   /**< For Sel Nodes, its entity */
+		int       intVal; /**< For Conv/Div Nodes: strict/remainderless */
+		unsigned  uintVal;/**< for Builtin: the kind */
+		ir_node   *block; /**< for Block: itself */
+		void      *ptr;   /**< generic pointer for hash/cmp */
 	} u;
 };
 
@@ -193,7 +196,6 @@ typedef struct environment_t {
 	partition_t     *touched;       /**< the touched set. */
 	partition_t     *initial;       /**< The initial partition. */
 	set             *opcode2id_map; /**< The opcodeMode->id map. */
-	pmap            *type2id_map;   /**< The type->id map. */
 	ir_node         **kept_memory;  /**< Array of memory nodes that must be kept. */
 	int             end_idx;        /**< -1 for local and 0 for global congruences. */
 	int             lambda_input;   /**< Captured argument for lambda_partition(). */
@@ -281,12 +283,27 @@ static void check_opcode(const partition_t *Z) {
 			case iro_Sel:
 				key.u.ent = get_Sel_entity(irn);
 				break;
+			case iro_Conv:
+				key.u.intVal = get_Conv_strict(irn);
+				break;
+			case iro_Div:
+				key.u.intVal = get_Div_no_remainder(irn);
+				break;
+			case iro_Block:
+				key.u.block = irn;
+				break;
+			case iro_Load:
+				key.mode = get_Load_mode(irn);
+				break;
+			case iro_Builtin:
+				key.u.intVal = get_Builtin_kind(irn);
+				break;
 			default:
 				break;
 			}
 			first = 0;
 		} else {
-			assert(key.code  == get_irn_opcode(irn));
+			assert((unsigned)key.code  == get_irn_opcode(irn));
 			assert(key.mode  == get_irn_mode(irn));
 			assert(key.arity == get_irn_arity(irn));
 
@@ -297,6 +314,21 @@ static void check_opcode(const partition_t *Z) {
 			case iro_Sel:
 				assert(key.u.ent == get_Sel_entity(irn));
 				break;
+			case iro_Conv:
+				assert(key.u.intVal == get_Conv_strict(irn));
+				break;
+			case iro_Div:
+				assert(key.u.intVal == get_Div_no_remainder(irn));
+				break;
+			case iro_Block:
+				assert(key.u.block == irn);
+				break;
+			case iro_Load:
+				assert(key.mode == get_Load_mode(irn));
+				break;
+			case iro_Builtin:
+				assert(key.u.intVal == (int) get_Builtin_kind(irn));
+				break;
 			default:
 				break;
 			}
@@ -319,6 +351,8 @@ static void check_all_partitions(environment_t *env) {
 			assert(leader != node && leader->part == node->part);
 		}
 	}
+#else
+	(void) env;
 #endif
 }
 
@@ -326,13 +360,19 @@ static void check_all_partitions(environment_t *env) {
  * Check list.
  */
 static void do_check_list(const node_t *list, int ofs, const partition_t *Z) {
-	const node_t *e;
 
+#ifndef NDEBUG
+	const node_t *e;
 #define NEXT(e)  *((const node_t **)((char *)(e) + (ofs)))
 	for (e = list; e != NULL; e = NEXT(e)) {
 		assert(e->part == Z);
 	}
 #undef NEXT
+#else
+	(void) list;
+	(void) ofs;
+	(void) Z;
+#endif
 }  /* ido_check_list */
 
 /**
@@ -538,7 +578,7 @@ static listmap_entry_t *listmap_find(listmap_t *map, void *id) {
  * @return a hash value for the given opcode map entry
  */
 static unsigned opcode_hash(const opcode_key_t *entry) {
-	return (entry->mode - (ir_mode *)0) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ent) + entry->arity;
+	return (entry->mode - (ir_mode *)0) * 9 + entry->code + entry->u.proj * 3 + HASH_PTR(entry->u.ptr) + entry->arity;
 }  /* opcode_hash */
 
 /**
@@ -551,7 +591,9 @@ static int cmp_opcode(const void *elt, const void *key, size_t size) {
 	(void) size;
 	return o1->code != o2->code || o1->mode != o2->mode ||
 	       o1->arity != o2->arity ||
-	       o1->u.proj != o2->u.proj || o1->u.ent != o2->u.ent;
+	       o1->u.proj != o2->u.proj ||
+	       o1->u.intVal != o2->u.intVal || /* this already checks uIntVal */
+	       o1->u.ptr != o2->u.ptr;
 }  /* cmp_opcode */
 
 /**
@@ -623,7 +665,7 @@ static inline void add_to_worklist(partition_t *X, environment_t *env) {
  * @return a newly allocated partition
  */
 static inline partition_t *new_partition(environment_t *env) {
-	partition_t *part = obstack_alloc(&env->obst, sizeof(*part));
+	partition_t *part = OALLOC(&env->obst, partition_t);
 
 	INIT_LIST_HEAD(&part->Leader);
 	INIT_LIST_HEAD(&part->Follower);
@@ -682,7 +724,7 @@ static inline lattice_elem_t get_partition_type(const partition_t *X) {
  */
 static node_t *create_partition_node(ir_node *irn, partition_t *part, environment_t *env) {
 	/* create a partition node and place it in the partition */
-	node_t *node = obstack_alloc(&env->obst, sizeof(*node));
+	node_t *node = OALLOC(&env->obst, node_t);
 
 	INIT_LIST_HEAD(&node->node_list);
 	INIT_LIST_HEAD(&node->cprop_list);
@@ -1012,10 +1054,6 @@ static int is_real_follower(const ir_node *irn, int input) {
 		if (is_tarval(pred->type.tv) && tarval_is_all_one(pred->type.tv))
 			return 0;
 		break;
-	case iro_Min:
-	case iro_Max:
-		/* all inputs are followers */
-		return 1;
 	default:
 		assert(!"opcode not implemented yet");
 		break;
@@ -1400,13 +1438,10 @@ static void collect_touched(list_head *list, int idx, environment_t *env) {
 /**
  * Collect commutative nodes to the touched list.
  *
- * @param X     the partition of the list
  * @param list  the list which contains the nodes that must be evaluated
  * @param env   the environment
  */
-static void collect_commutative_touched(partition_t *X, list_head *list, environment_t *env) {
-	int     first      = 1;
-	int     both_input = 0;
+static void collect_commutative_touched(list_head *list, environment_t *env) {
 	node_t  *x, *y;
 
 	list_for_each_entry(node_t, x, list, node_list) {
@@ -1445,21 +1480,7 @@ static void collect_commutative_touched(partition_t *X, list_head *list, environ
 			/* Partitions of constants should not be split simply because their Nodes have unequal
 			   functions or incongruent inputs. */
 			if (type_is_neither_top_nor_const(y->type)) {
-				int    other_idx = edge->pos ^ 1;
-				node_t *other    = get_irn_node(get_irn_n(succ, other_idx));
-				int    equal     = X == other->part;
-
-				/*
-				 * Note: op(a, a) is NOT congruent to op(a, b).
-				 * So, either all touch nodes must have both inputs congruent,
-				 * or not. We decide this by the first occurred node.
-				 */
-				if (first) {
-					first      = 0;
-					both_input = equal;
-				}
-				if (both_input == equal)
-					add_to_touched(y, env);
+				add_to_touched(y, env);
 			}
 		}
 	}
@@ -1487,13 +1508,16 @@ static void cause_splits(environment_t *env) {
 		/* empty the touched set: already done, just clear the list */
 		env->touched = NULL;
 
-		collect_commutative_touched(X, &X->Leader, env);
-		collect_commutative_touched(X, &X->Follower, env);
+		collect_commutative_touched(&X->Leader, env);
+		collect_commutative_touched(&X->Follower, env);
 
 		for (Z = env->touched; Z != NULL; Z = N) {
-			node_t   *e;
-			node_t   *touched  = Z->touched;
-			unsigned n_touched = Z->n_touched;
+			node_t   *e, *n;
+			node_t   *touched     = Z->touched;
+			node_t   *touched_aa  = NULL;
+			node_t   *touched_ab  = NULL;
+			unsigned n_touched_aa = 0;
+			unsigned n_touched_ab = 0;
 
 			assert(Z->touched != NULL);
 
@@ -1504,18 +1528,45 @@ static void cause_splits(environment_t *env) {
 			Z->on_touched = 0;
 
 			/* Empty local Z.touched. */
-			for (e = touched; e != NULL; e = e->next) {
+			for (e = touched; e != NULL; e = n) {
+				node_t *left  = get_irn_node(get_irn_n(e->node, 0));
+				node_t *right = get_irn_node(get_irn_n(e->node, 1));
+
 				assert(e->is_follower == 0);
 				e->on_touched = 0;
+				n = e->next;
+
+				/*
+				 * Note: op(a, a) is NOT congruent to op(a, b).
+				 * So, we must split the touched list.
+				 */
+				if (left->part == right->part) {
+					e->next = touched_aa;
+					touched_aa = e;
+					++n_touched_aa;
+				} else {
+					e->next = touched_ab;
+					touched_ab = e;
+					++n_touched_ab;
+				}
 			}
+			assert(n_touched_aa + n_touched_ab == Z->n_touched);
 			Z->touched   = NULL;
 			Z->n_touched = 0;
 
-			if (0 < n_touched && n_touched < Z->n_leader) {
-				DB((dbg, LEVEL_2, "Split part%d by touched\n", Z->nr));
-				split(&Z, touched, env);
+			if (0 < n_touched_aa && n_touched_aa < Z->n_leader) {
+				partition_t *Z_prime = Z;
+				DB((dbg, LEVEL_2, "Split part%d by touched_aa\n", Z_prime->nr));
+				split(&Z_prime, touched_aa, env);
 			} else
-				assert(n_touched <= Z->n_leader);
+				assert(n_touched_aa <= Z->n_leader);
+
+			if (0 < n_touched_ab && n_touched_ab < Z->n_leader) {
+				partition_t *Z_prime = Z;
+				DB((dbg, LEVEL_2, "Split part%d by touched_ab\n", Z_prime->nr));
+				split(&Z_prime, touched_ab, env);
+			} else
+				assert(n_touched_ab <= Z->n_leader);
 		}
 	}
 
@@ -1638,6 +1689,27 @@ static void *lambda_opcode(const node_t *node, environment_t *env) {
 	case iro_Sel:
 		key.u.ent = get_Sel_entity(irn);
 		break;
+	case iro_Conv:
+		key.u.intVal = get_Conv_strict(irn);
+		break;
+	case iro_Div:
+		key.u.intVal = get_Div_no_remainder(irn);
+		break;
+	case iro_Block:
+		/*
+		 * Some ugliness here: Two Blocks having the same
+		 * IJmp predecessor would be congruent, which of course is wrong.
+		 * We fix it by never letting blocks be congruent
+		 * which cannot be detected by combo either.
+		 */
+		key.u.block = irn;
+		break;
+	case iro_Load:
+		key.mode = get_Load_mode(irn);
+		break;
+	case iro_Builtin:
+		key.u.intVal = get_Builtin_kind(irn);
+		break;
 	default:
 		break;
 	}
@@ -1671,7 +1743,6 @@ static void *lambda_partition(const node_t *node, environment_t *env) {
 
 	pred = i == -1 ? get_irn_n(skipped, i) : get_irn_n(node->node, i);
 	p    = get_irn_node(pred);
-
 	return p->part;
 }  /* lambda_partition */
 
@@ -1863,8 +1934,8 @@ static void compute_Block(node_t *node) {
 	int     i;
 	ir_node *block = node->node;
 
-	if (block == get_irg_start_block(current_ir_graph)) {
-		/* start block is always reachable */
+	if (block == get_irg_start_block(current_ir_graph) || has_Block_entity(block)) {
+		/* start block and labelled blocks are always reachable */
 		node->type.tv = tarval_reachable;
 		return;
 	}
@@ -1905,7 +1976,7 @@ static void compute_Unknown(node_t *node) {
 	 * It would be safe to compute Top IF it can be assured, that only Cmp
 	 * nodes are inputs to Conds. We check that first.
 	 * This is the way Frontends typically build Firm, but some optimizations
-	 * (cond_eval for instance) might replace them by Phib's...
+	 * (jump threading for instance) might replace them by Phib's...
 	 */
 	node->type.tv = tarval_UNKNOWN;
 }  /* compute_Unknown */
@@ -2325,7 +2396,7 @@ static void compute_Proj_Cond(node_t *node, ir_node *cond) {
 			node->type.tv = tarval_reachable;
 		} else if (selector->type.tv == tarval_top) {
 			if (tarval_UNKNOWN == tarval_top &&
-			    pnc == get_Cond_defaultProj(cond)) {
+			    pnc == get_Cond_default_proj(cond)) {
 				/* a switch based of Top is always "default" */
 				node->type.tv = tarval_reachable;
 			} else {
@@ -2333,7 +2404,7 @@ static void compute_Proj_Cond(node_t *node, ir_node *cond) {
 			}
 		} else {
 			long value = get_tarval_long(selector->type.tv);
-			if (pnc == get_Cond_defaultProj(cond)) {
+			if (pnc == get_Cond_default_proj(cond)) {
 				/* default switch, have to check ALL other cases */
 				int i;
 
@@ -2430,94 +2501,6 @@ static void compute_Confirm(node_t *node) {
 	node->type = pred->type;
 }  /* compute_Confirm */
 
-/**
- * (Re-)compute the type for a Max.
- *
- * @param node  the node
- */
-static void compute_Max(node_t *node) {
-	ir_node        *op = node->node;
-	node_t         *l  = get_irn_node(get_binop_left(op));
-	node_t         *r  = get_irn_node(get_binop_right(op));
-	lattice_elem_t a   = l->type;
-	lattice_elem_t b   = r->type;
-
-	if (a.tv == tarval_top || b.tv == tarval_top) {
-		node->type.tv = tarval_top;
-	} else if (is_con(a) && is_con(b)) {
-		/* both nodes are constants, we can probably do something */
-		if (a.tv == b.tv) {
-			/* this case handles SymConsts as well */
-			node->type = a;
-		} else {
-			ir_mode *mode   = get_irn_mode(op);
-			tarval  *tv_min = get_mode_min(mode);
-
-			if (a.tv == tv_min)
-				node->type = b;
-			else if (b.tv == tv_min)
-				node->type = a;
-			else if (is_tarval(a.tv) && is_tarval(b.tv)) {
-				if (tarval_cmp(a.tv, b.tv) & pn_Cmp_Gt)
-					node->type.tv = a.tv;
-				else
-					node->type.tv = b.tv;
-			} else {
-				node->type.tv = tarval_bad;
-			}
-		}
-	} else if (r->part == l->part) {
-		/* both nodes congruent, we can probably do something */
-		node->type = a;
-	} else {
-		node->type.tv = tarval_bottom;
-	}
-}  /* compute_Max */
-
-/**
- * (Re-)compute the type for a Min.
- *
- * @param node  the node
- */
-static void compute_Min(node_t *node) {
-	ir_node        *op = node->node;
-	node_t         *l  = get_irn_node(get_binop_left(op));
-	node_t         *r  = get_irn_node(get_binop_right(op));
-	lattice_elem_t a   = l->type;
-	lattice_elem_t b   = r->type;
-
-	if (a.tv == tarval_top || b.tv == tarval_top) {
-		node->type.tv = tarval_top;
-	} else if (is_con(a) && is_con(b)) {
-		/* both nodes are constants, we can probably do something */
-		if (a.tv == b.tv) {
-			/* this case handles SymConsts as well */
-			node->type = a;
-		} else {
-			ir_mode *mode   = get_irn_mode(op);
-			tarval  *tv_max = get_mode_max(mode);
-
-			if (a.tv == tv_max)
-				node->type = b;
-			else if (b.tv == tv_max)
-				node->type = a;
-			else if (is_tarval(a.tv) && is_tarval(b.tv)) {
-				if (tarval_cmp(a.tv, b.tv) & pn_Cmp_Gt)
-					node->type.tv = a.tv;
-				else
-					node->type.tv = b.tv;
-			} else {
-				node->type.tv = tarval_bad;
-			}
-		}
-	} else if (r->part == l->part) {
-		/* both nodes congruent, we can probably do something */
-		node->type = a;
-	} else {
-		node->type.tv = tarval_bottom;
-	}
-}  /* compute_Min */
-
 /**
  * (Re-)compute the type for a given node.
  *
@@ -2729,54 +2712,6 @@ static node_t *identity_Mux(node_t *node) {
 	return node;
 }  /* identity_Mux */
 
-/**
- * Calculates the Identity for Min nodes.
- */
-static node_t *identity_Min(node_t *node) {
-	ir_node *op   = node->node;
-	node_t  *a    = get_irn_node(get_binop_left(op));
-	node_t  *b    = get_irn_node(get_binop_right(op));
-	ir_mode *mode = get_irn_mode(op);
-	tarval  *tv_max;
-
-	if (a->part == b->part) {
-		/* leader of multiple predecessors */
-		return a;
-	}
-
-	/* works even with NaN */
-	tv_max = get_mode_max(mode);
-	if (a->type.tv == tv_max)
-		return b;
-	if (b->type.tv == tv_max)
-		return a;
-	return node;
-}  /* identity_Min */
-
-/**
- * Calculates the Identity for Max nodes.
- */
-static node_t *identity_Max(node_t *node) {
-	ir_node *op   = node->node;
-	node_t  *a    = get_irn_node(get_binop_left(op));
-	node_t  *b    = get_irn_node(get_binop_right(op));
-	ir_mode *mode = get_irn_mode(op);
-	tarval  *tv_min;
-
-	if (a->part == b->part) {
-		/* leader of multiple predecessors */
-		return a;
-	}
-
-	/* works even with NaN */
-	tv_min = get_mode_min(mode);
-	if (a->type.tv == tv_min)
-		return b;
-	if (b->type.tv == tv_min)
-		return a;
-	return node;
-}  /* identity_Max */
-
 /**
  * Calculates the Identity for nodes.
  */
@@ -2805,10 +2740,6 @@ static node_t *identity(node_t *node) {
 		return identity_Confirm(node);
 	case iro_Mux:
 		return identity_Mux(node);
-	case iro_Min:
-		return identity_Min(node);
-	case iro_Max:
-		return identity_Max(node);
 	default:
 		return node;
 	}
@@ -3039,10 +2970,11 @@ static int only_one_reachable_proj(ir_node *n) {
  * Return non-zero if the control flow predecessor node pred
  * is the only reachable control flow exit of its block.
  *
- * @param pred  the control flow exit
+ * @param pred   the control flow exit
+ * @param block  the destination block
  */
-static int can_exchange(ir_node *pred) {
-	if (is_Start(pred))
+static int can_exchange(ir_node *pred, ir_node *block) {
+	if (is_Start(pred) || has_Block_entity(block))
 		return 0;
 	else if (is_Jmp(pred))
 		return 1;
@@ -3108,7 +3040,7 @@ static void apply_cf(ir_node *block, void *ctx) {
 		/* only one predecessor combine */
 		ir_node *pred = skip_Proj(get_Block_cfgpred(block, 0));
 
-		if (can_exchange(pred)) {
+		if (can_exchange(pred, block)) {
 			ir_node *new_block = get_nodes_block(pred);
 			DB((dbg, LEVEL_1, "Fuse %+F with %+F\n", block, new_block));
 			DBG_OPT_COMBO(block, new_block, FS_OPT_COMBO_CF);
@@ -3159,7 +3091,7 @@ static void apply_cf(ir_node *block, void *ctx) {
 		if (is_tarval(node->type.tv) && tarval_is_constant(node->type.tv)) {
 			/* this Phi is replaced by a constant */
 			tarval  *tv = node->type.tv;
-			ir_node *c  = new_r_Const(current_ir_graph, block, get_tarval_mode(tv), tv);
+			ir_node *c  = new_Const(tv);
 
 			set_irn_node(c, node);
 			node->node = c;
@@ -3199,7 +3131,7 @@ static void apply_cf(ir_node *block, void *ctx) {
 		/* this Block has only one live predecessor */
 		ir_node *pred = skip_Proj(in_X[0]);
 
-		if (can_exchange(pred)) {
+		if (can_exchange(pred, block)) {
 			ir_node *new_block = get_nodes_block(pred);
 			DBG_OPT_COMBO(block, new_block, FS_OPT_COMBO_CF);
 			exchange(block, new_block);
@@ -3228,7 +3160,7 @@ static void exchange_leader(ir_node *irn, ir_node *leader) {
 		ir_node  *block = get_nodes_block(leader);
 		dbg_info *dbg   = get_irn_dbg_info(irn);
 
-		leader = new_rd_Conv(dbg, current_ir_graph, block, leader, mode);
+		leader = new_rd_Conv(dbg, block, leader, mode);
 	}
 	exchange(irn, leader);
 }  /* exchange_leader */
@@ -3351,7 +3283,7 @@ static void apply_result(ir_node *irn, void *ctx) {
 
 				if (is_Cond(cond)) {
 					if (only_one_reachable_proj(cond)) {
-						ir_node *jmp = new_r_Jmp(current_ir_graph, block->node);
+						ir_node *jmp = new_r_Jmp(block->node);
 						set_irn_node(jmp, node);
 						node->node = jmp;
 						DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, jmp));
@@ -3382,7 +3314,7 @@ static void apply_result(ir_node *irn, void *ctx) {
 				 */
 				if (! is_Const(irn) && get_irn_mode(irn) != mode_T) {
 					/* can be replaced by a constant */
-					ir_node *c = new_r_Const(current_ir_graph, block->node, get_tarval_mode(tv), tv);
+					ir_node *c = new_Const(tv);
 					set_irn_node(c, node);
 					node->node = c;
 					DB((dbg, LEVEL_1, "%+F is replaced by %+F\n", irn, c));
@@ -3393,7 +3325,7 @@ static void apply_result(ir_node *irn, void *ctx) {
 			} else if (is_entity(node->type.sym.entity_p)) {
 				if (! is_SymConst(irn)) {
 					/* can be replaced by a SymConst */
-					ir_node *symc = new_r_SymConst(current_ir_graph, block->node, get_irn_mode(irn), node->type.sym, symconst_addr_ent);
+					ir_node *symc = new_r_SymConst(current_ir_graph, get_irn_mode(irn), node->type.sym, symconst_addr_ent);
 					set_irn_node(symc, node);
 					node->node = symc;
 
@@ -3498,11 +3430,6 @@ static void set_compute_functions(void) {
 	SET(Return);
 	SET(End);
 	SET(Call);
-
-	if (op_Max != NULL)
-		SET(Max);
-	if (op_Min != NULL)
-		SET(Min);
 }  /* set_compute_functions */
 
 /**
@@ -3552,7 +3479,6 @@ void combo(ir_graph *irg) {
 	env.dbg_list       = NULL;
 #endif
 	env.opcode2id_map  = new_set(cmp_opcode, iro_Last * 4);
-	env.type2id_map    = pmap_create();
 	env.kept_memory    = NEW_ARR_F(ir_node *, 0);
 	env.end_idx        = get_opt_global_cse() ? 0 : -1;
 	env.lambda_input   = 0;
@@ -3635,6 +3561,7 @@ void combo(ir_graph *irg) {
 		set_irg_extblk_inconsistent(irg);
 		set_irg_doms_inconsistent(irg);
 		set_irg_loopinfo_inconsistent(irg);
+		set_irg_entity_usage_state(irg, ir_entity_usage_not_computed);
 	}
 
 	ir_free_resources(irg, IR_RESOURCE_IRN_LINK | IR_RESOURCE_PHI_LIST);
@@ -3643,7 +3570,6 @@ void combo(ir_graph *irg) {
 	DEBUG_ONLY(set_dump_node_vcgattr_hook(NULL));
 
 	DEL_ARR_F(env.kept_memory);
-	pmap_destroy(env.type2id_map);
 	del_set(env.opcode2id_map);
 	obstack_free(&env.obst, NULL);
 
@@ -3651,3 +3577,9 @@ void combo(ir_graph *irg) {
 	set_value_of_func(NULL);
 	current_ir_graph = rem;
 }  /* combo */
+
+/* Creates an ir_graph pass for combo. */
+ir_graph_pass_t *combo_pass(const char *name)
+{
+	return def_graph_pass(name ? name : "combo", combo);
+}  /* combo_pass */