From 561e8a90fdfe45ef935dbb16c6cf0389f2e7fef1 Mon Sep 17 00:00:00 2001 From: Zdenek Dvorak Date: Thu, 24 May 2007 16:02:12 +0200 Subject: re PR middle-end/32018 (ICE on optimization) PR middle-end/32018 * tree-ssa-threadupdate.c (thread_through_loop_header): Use set_loop_copy. (thread_through_all_blocks): Call initialize_original_copy_tables and free_original_copy_tables. * cfgloopmanip.c (duplicate_loop, duplicate_loop_to_header_edge): Use set_loop_copy. * tree-cfg.c (tree_duplicate_sese_region): Ditto. * cfghooks.c (duplicate_block): Use get_loop_copy. * cfg.c: Include cfgloop.h. (loop_copy): New hash table. (initialize_original_copy_tables): Initialize loop_copy table. (free_original_copy_tables): Free loop_copy table. (copy_original_table_clear, copy_original_table_set, set_loop_copy, get_loop_copy): New functions. (set_bb_original, set_bb_copy): Use copy_original_table_set. * cfgloop.h (struct loop): Remove copy field. * Makefile.in (cfg.o): Add CFGLOOP_H dependency. * basic-block.h (set_loop_copy, get_loop_copy): Declare. From-SVN: r125024 --- gcc/cfg.c | 119 +++++++++++++++++++++++++++++++++++++++++++------------------- 1 file changed, 83 insertions(+), 36 deletions(-) (limited to 'gcc/cfg.c') diff --git a/gcc/cfg.c b/gcc/cfg.c index 9f5da32..63d0530 100644 --- a/gcc/cfg.c +++ b/gcc/cfg.c @@ -66,6 +66,7 @@ Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA #include "ggc.h" #include "hashtab.h" #include "alloc-pool.h" +#include "cfgloop.h" /* The obstack on which the flow graph components are allocated. */ @@ -1027,6 +1028,9 @@ scale_bbs_frequencies_gcov_type (basic_block *bbs, int nbbs, gcov_type num, copies. */ static htab_t bb_original; static htab_t bb_copy; + +/* And between loops and copies. */ +static htab_t loop_copy; static alloc_pool original_copy_bb_pool; struct htab_bb_copy_original_entry @@ -1068,6 +1072,7 @@ initialize_original_copy_tables (void) bb_original = htab_create (10, bb_copy_original_hash, bb_copy_original_eq, NULL); bb_copy = htab_create (10, bb_copy_original_hash, bb_copy_original_eq, NULL); + loop_copy = htab_create (10, bb_copy_original_hash, bb_copy_original_eq, NULL); } /* Free the data structures to maintain mapping between blocks and @@ -1078,35 +1083,64 @@ free_original_copy_tables (void) gcc_assert (original_copy_bb_pool); htab_delete (bb_copy); htab_delete (bb_original); + htab_delete (loop_copy); free_alloc_pool (original_copy_bb_pool); bb_copy = NULL; bb_original = NULL; + loop_copy = NULL; original_copy_bb_pool = NULL; } +/* Removes the value associated with OBJ from table TAB. */ + +static void +copy_original_table_clear (htab_t tab, unsigned obj) +{ + void **slot; + struct htab_bb_copy_original_entry key, *elt; + + if (!original_copy_bb_pool) + return; + + key.index1 = obj; + slot = htab_find_slot (tab, &key, NO_INSERT); + if (!slot) + return; + + elt = *slot; + htab_clear_slot (tab, slot); + pool_free (original_copy_bb_pool, elt); +} + +/* Sets the value associated with OBJ in table TAB to VAL. + Do nothing when data structures are not initialized. */ + +static void +copy_original_table_set (htab_t tab, unsigned obj, unsigned val) +{ + struct htab_bb_copy_original_entry **slot; + struct htab_bb_copy_original_entry key; + + if (!original_copy_bb_pool) + return; + + key.index1 = obj; + slot = (struct htab_bb_copy_original_entry **) + htab_find_slot (tab, &key, INSERT); + if (!*slot) + { + *slot = pool_alloc (original_copy_bb_pool); + (*slot)->index1 = obj; + } + (*slot)->index2 = val; +} + /* Set original for basic block. Do nothing when data structures are not initialized so passes not needing this don't need to care. */ void set_bb_original (basic_block bb, basic_block original) { - if (original_copy_bb_pool) - { - struct htab_bb_copy_original_entry **slot; - struct htab_bb_copy_original_entry key; - - key.index1 = bb->index; - slot = - (struct htab_bb_copy_original_entry **) htab_find_slot (bb_original, - &key, INSERT); - if (*slot) - (*slot)->index2 = original->index; - else - { - *slot = pool_alloc (original_copy_bb_pool); - (*slot)->index1 = bb->index; - (*slot)->index2 = original->index; - } - } + copy_original_table_set (bb_original, bb->index, original->index); } /* Get the original basic block. */ @@ -1131,24 +1165,7 @@ get_bb_original (basic_block bb) void set_bb_copy (basic_block bb, basic_block copy) { - if (original_copy_bb_pool) - { - struct htab_bb_copy_original_entry **slot; - struct htab_bb_copy_original_entry key; - - key.index1 = bb->index; - slot = - (struct htab_bb_copy_original_entry **) htab_find_slot (bb_copy, - &key, INSERT); - if (*slot) - (*slot)->index2 = copy->index; - else - { - *slot = pool_alloc (original_copy_bb_pool); - (*slot)->index1 = bb->index; - (*slot)->index2 = copy->index; - } - } + copy_original_table_set (bb_copy, bb->index, copy->index); } /* Get the copy of basic block. */ @@ -1167,3 +1184,33 @@ get_bb_copy (basic_block bb) else return NULL; } + +/* Set copy for LOOP to COPY. Do nothing when data structures are not + initialized so passes not needing this don't need to care. */ + +void +set_loop_copy (struct loop *loop, struct loop *copy) +{ + if (!copy) + copy_original_table_clear (loop_copy, loop->num); + else + copy_original_table_set (loop_copy, loop->num, copy->num); +} + +/* Get the copy of LOOP. */ + +struct loop * +get_loop_copy (struct loop *loop) +{ + struct htab_bb_copy_original_entry *entry; + struct htab_bb_copy_original_entry key; + + gcc_assert (original_copy_bb_pool); + + key.index1 = loop->num; + entry = (struct htab_bb_copy_original_entry *) htab_find (loop_copy, &key); + if (entry) + return get_loop (entry->index2); + else + return NULL; +} -- cgit v1.1