1 /* Control flow graph manipulation code for GNU compiler.
2 Copyright (C) 1987, 1988, 1992, 1993, 1994, 1995, 1996, 1997, 1998,
3 1999, 2000, 2001, 2002, 2003, 2004, 2005
4 Free Software Foundation, Inc.
6 This file is part of GCC.
8 GCC is free software; you can redistribute it and/or modify it under
9 the terms of the GNU General Public License as published by the Free
10 Software Foundation; either version 2, or (at your option) any later
13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
15 FITNESS FOR A PARTICULAR PURPOSE. See the GNU General Public License
18 You should have received a copy of the GNU General Public License
19 along with GCC; see the file COPYING. If not, write to the Free
20 Software Foundation, 51 Franklin Street, Fifth Floor, Boston, MA
23 /* This file contains low level functions to manipulate the CFG and
24 analyze it. All other modules should not transform the data structure
25 directly and use abstraction instead. The file is supposed to be
26 ordered bottom-up and should not contain any code dependent on a
27 particular intermediate language (RTL or trees).
29 Available functionality:
30 - Initialization/deallocation
31 init_flow, clear_edges
32 - Low level basic block manipulation
33 alloc_block, expunge_block
35 make_edge, make_single_succ_edge, cached_make_edge, remove_edge
36 - Low level edge redirection (without updating instruction chain)
37 redirect_edge_succ, redirect_edge_succ_nodup, redirect_edge_pred
38 - Dumping and debugging
39 dump_flow_info, debug_flow_info, dump_edge_info
40 - Allocation of AUX fields for basic blocks
41 alloc_aux_for_blocks, free_aux_for_blocks, alloc_aux_for_block
43 - Consistency checking
45 - Dumping and debugging
46 print_rtl_with_bb, dump_bb, debug_bb, debug_bb_n
51 #include "coretypes.h"
55 #include "hard-reg-set.h"
67 #include "alloc-pool.h"
69 /* The obstack on which the flow graph components are allocated. */
71 struct bitmap_obstack reg_obstack;
73 void debug_flow_info (void);
74 static void free_edge (edge);
76 #define RDIV(X,Y) (((X) + (Y) / 2) / (Y))
78 /* Called once at initialization time. */
84 cfun->cfg = ggc_alloc_cleared (sizeof (struct control_flow_graph));
86 ENTRY_BLOCK_PTR = ggc_alloc_cleared (sizeof (struct basic_block_def));
87 ENTRY_BLOCK_PTR->index = ENTRY_BLOCK;
88 EXIT_BLOCK_PTR = ggc_alloc_cleared (sizeof (struct basic_block_def));
89 EXIT_BLOCK_PTR->index = EXIT_BLOCK;
90 ENTRY_BLOCK_PTR->next_bb = EXIT_BLOCK_PTR;
91 EXIT_BLOCK_PTR->prev_bb = ENTRY_BLOCK_PTR;
94 /* Helper function for remove_edge and clear_edges. Frees edge structure
95 without actually unlinking it from the pred/succ lists. */
98 free_edge (edge e ATTRIBUTE_UNUSED)
104 /* Free the memory associated with the edge structures. */
115 FOR_EACH_EDGE (e, ei, bb->succs)
117 VEC_truncate (edge, bb->succs, 0);
118 VEC_truncate (edge, bb->preds, 0);
121 FOR_EACH_EDGE (e, ei, ENTRY_BLOCK_PTR->succs)
123 VEC_truncate (edge, EXIT_BLOCK_PTR->preds, 0);
124 VEC_truncate (edge, ENTRY_BLOCK_PTR->succs, 0);
126 gcc_assert (!n_edges);
129 /* Allocate memory for basic_block. */
135 bb = ggc_alloc_cleared (sizeof (*bb));
139 /* Link block B to chain after AFTER. */
141 link_block (basic_block b, basic_block after)
143 b->next_bb = after->next_bb;
146 b->next_bb->prev_bb = b;
149 /* Unlink block B from chain. */
151 unlink_block (basic_block b)
153 b->next_bb->prev_bb = b->prev_bb;
154 b->prev_bb->next_bb = b->next_bb;
159 /* Sequentially order blocks and compact the arrays. */
161 compact_blocks (void)
169 BASIC_BLOCK (i) = bb;
174 gcc_assert (i == n_basic_blocks);
176 for (; i < last_basic_block; i++)
177 BASIC_BLOCK (i) = NULL;
179 last_basic_block = n_basic_blocks;
182 /* Remove block B from the basic block array. */
185 expunge_block (basic_block b)
188 BASIC_BLOCK (b->index) = NULL;
190 /* We should be able to ggc_free here, but we are not.
191 The dead SSA_NAMES are left pointing to dead statements that are pointing
192 to dead basic blocks making garbage collector to die.
193 We should be able to release all dead SSA_NAMES and at the same time we should
194 clear out BB pointer of dead statements consistently. */
197 /* Connect E to E->src. */
202 VEC_safe_push (edge, gc, e->src->succs, e);
205 /* Connect E to E->dest. */
208 connect_dest (edge e)
210 basic_block dest = e->dest;
211 VEC_safe_push (edge, gc, dest->preds, e);
212 e->dest_idx = EDGE_COUNT (dest->preds) - 1;
215 /* Disconnect edge E from E->src. */
218 disconnect_src (edge e)
220 basic_block src = e->src;
224 for (ei = ei_start (src->succs); (tmp = ei_safe_edge (ei)); )
228 VEC_unordered_remove (edge, src->succs, ei.index);
238 /* Disconnect edge E from E->dest. */
241 disconnect_dest (edge e)
243 basic_block dest = e->dest;
244 unsigned int dest_idx = e->dest_idx;
246 VEC_unordered_remove (edge, dest->preds, dest_idx);
248 /* If we removed an edge in the middle of the edge vector, we need
249 to update dest_idx of the edge that moved into the "hole". */
250 if (dest_idx < EDGE_COUNT (dest->preds))
251 EDGE_PRED (dest, dest_idx)->dest_idx = dest_idx;
254 /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
255 created edge. Use this only if you are sure that this edge can't
256 possibly already exist. */
259 unchecked_make_edge (basic_block src, basic_block dst, int flags)
262 e = ggc_alloc_cleared (sizeof (*e));
272 execute_on_growing_pred (e);
277 /* Create an edge connecting SRC and DST with FLAGS optionally using
278 edge cache CACHE. Return the new edge, NULL if already exist. */
281 cached_make_edge (sbitmap edge_cache, basic_block src, basic_block dst, int flags)
283 if (edge_cache == NULL
284 || src == ENTRY_BLOCK_PTR
285 || dst == EXIT_BLOCK_PTR)
286 return make_edge (src, dst, flags);
288 /* Does the requested edge already exist? */
289 if (! TEST_BIT (edge_cache, dst->index))
291 /* The edge does not exist. Create one and update the
293 SET_BIT (edge_cache, dst->index);
294 return unchecked_make_edge (src, dst, flags);
297 /* At this point, we know that the requested edge exists. Adjust
298 flags if necessary. */
301 edge e = find_edge (src, dst);
308 /* Create an edge connecting SRC and DEST with flags FLAGS. Return newly
309 created edge or NULL if already exist. */
312 make_edge (basic_block src, basic_block dest, int flags)
314 edge e = find_edge (src, dest);
316 /* Make sure we don't add duplicate edges. */
323 return unchecked_make_edge (src, dest, flags);
326 /* Create an edge connecting SRC to DEST and set probability by knowing
327 that it is the single edge leaving SRC. */
330 make_single_succ_edge (basic_block src, basic_block dest, int flags)
332 edge e = make_edge (src, dest, flags);
334 e->probability = REG_BR_PROB_BASE;
335 e->count = src->count;
339 /* This function will remove an edge from the flow graph. */
344 remove_predictions_associated_with_edge (e);
345 execute_on_shrinking_pred (e);
353 /* Redirect an edge's successor from one block to another. */
356 redirect_edge_succ (edge e, basic_block new_succ)
358 execute_on_shrinking_pred (e);
364 /* Reconnect the edge to the new successor block. */
367 execute_on_growing_pred (e);
370 /* Like previous but avoid possible duplicate edge. */
373 redirect_edge_succ_nodup (edge e, basic_block new_succ)
377 s = find_edge (e->src, new_succ);
380 s->flags |= e->flags;
381 s->probability += e->probability;
382 if (s->probability > REG_BR_PROB_BASE)
383 s->probability = REG_BR_PROB_BASE;
384 s->count += e->count;
389 redirect_edge_succ (e, new_succ);
394 /* Redirect an edge's predecessor from one block to another. */
397 redirect_edge_pred (edge e, basic_block new_pred)
403 /* Reconnect the edge to the new predecessor block. */
407 /* Clear all basic block flags, with the exception of partitioning. */
409 clear_bb_flags (void)
413 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
414 bb->flags = (BB_PARTITION (bb) | (bb->flags & BB_DISABLE_SCHEDULE)
415 | (bb->flags & BB_RTL));
418 /* Check the consistency of profile information. We can't do that
419 in verify_flow_info, as the counts may get invalid for incompletely
420 solved graphs, later eliminating of conditionals or roundoff errors.
421 It is still practical to have them reported for debugging of simple
424 check_bb_profile (basic_block bb, FILE * file)
431 if (profile_status == PROFILE_ABSENT)
434 if (bb != EXIT_BLOCK_PTR)
436 FOR_EACH_EDGE (e, ei, bb->succs)
437 sum += e->probability;
438 if (EDGE_COUNT (bb->succs) && abs (sum - REG_BR_PROB_BASE) > 100)
439 fprintf (file, "Invalid sum of outgoing probabilities %.1f%%\n",
440 sum * 100.0 / REG_BR_PROB_BASE);
442 FOR_EACH_EDGE (e, ei, bb->succs)
444 if (EDGE_COUNT (bb->succs)
445 && (lsum - bb->count > 100 || lsum - bb->count < -100))
446 fprintf (file, "Invalid sum of outgoing counts %i, should be %i\n",
447 (int) lsum, (int) bb->count);
449 if (bb != ENTRY_BLOCK_PTR)
452 FOR_EACH_EDGE (e, ei, bb->preds)
453 sum += EDGE_FREQUENCY (e);
454 if (abs (sum - bb->frequency) > 100)
456 "Invalid sum of incoming frequencies %i, should be %i\n",
459 FOR_EACH_EDGE (e, ei, bb->preds)
461 if (lsum - bb->count > 100 || lsum - bb->count < -100)
462 fprintf (file, "Invalid sum of incoming counts %i, should be %i\n",
463 (int) lsum, (int) bb->count);
468 dump_flow_info (FILE *file)
472 /* There are no pseudo registers after reload. Don't dump them. */
473 if (reg_n_info && !reload_completed)
475 unsigned int i, max = max_reg_num ();
476 fprintf (file, "%d registers.\n", max);
477 for (i = FIRST_PSEUDO_REGISTER; i < max; i++)
480 enum reg_class class, altclass;
482 fprintf (file, "\nRegister %d used %d times across %d insns",
483 i, REG_N_REFS (i), REG_LIVE_LENGTH (i));
484 if (REG_BASIC_BLOCK (i) >= 0)
485 fprintf (file, " in block %d", REG_BASIC_BLOCK (i));
487 fprintf (file, "; set %d time%s", REG_N_SETS (i),
488 (REG_N_SETS (i) == 1) ? "" : "s");
489 if (regno_reg_rtx[i] != NULL && REG_USERVAR_P (regno_reg_rtx[i]))
490 fprintf (file, "; user var");
491 if (REG_N_DEATHS (i) != 1)
492 fprintf (file, "; dies in %d places", REG_N_DEATHS (i));
493 if (REG_N_CALLS_CROSSED (i) == 1)
494 fprintf (file, "; crosses 1 call");
495 else if (REG_N_CALLS_CROSSED (i))
496 fprintf (file, "; crosses %d calls", REG_N_CALLS_CROSSED (i));
497 if (regno_reg_rtx[i] != NULL
498 && PSEUDO_REGNO_BYTES (i) != UNITS_PER_WORD)
499 fprintf (file, "; %d bytes", PSEUDO_REGNO_BYTES (i));
501 class = reg_preferred_class (i);
502 altclass = reg_alternate_class (i);
503 if (class != GENERAL_REGS || altclass != ALL_REGS)
505 if (altclass == ALL_REGS || class == ALL_REGS)
506 fprintf (file, "; pref %s", reg_class_names[(int) class]);
507 else if (altclass == NO_REGS)
508 fprintf (file, "; %s or none", reg_class_names[(int) class]);
510 fprintf (file, "; pref %s, else %s",
511 reg_class_names[(int) class],
512 reg_class_names[(int) altclass]);
515 if (regno_reg_rtx[i] != NULL && REG_POINTER (regno_reg_rtx[i]))
516 fprintf (file, "; pointer");
517 fprintf (file, ".\n");
521 fprintf (file, "\n%d basic blocks, %d edges.\n", n_basic_blocks, n_edges);
527 fprintf (file, "\nBasic block %d ", bb->index);
528 fprintf (file, "prev %d, next %d, ",
529 bb->prev_bb->index, bb->next_bb->index);
530 fprintf (file, "loop_depth %d, count ", bb->loop_depth);
531 fprintf (file, HOST_WIDEST_INT_PRINT_DEC, bb->count);
532 fprintf (file, ", freq %i", bb->frequency);
533 if (maybe_hot_bb_p (bb))
534 fprintf (file, ", maybe hot");
535 if (probably_never_executed_bb_p (bb))
536 fprintf (file, ", probably never executed");
537 fprintf (file, ".\n");
539 fprintf (file, "Predecessors: ");
540 FOR_EACH_EDGE (e, ei, bb->preds)
541 dump_edge_info (file, e, 0);
543 fprintf (file, "\nSuccessors: ");
544 FOR_EACH_EDGE (e, ei, bb->succs)
545 dump_edge_info (file, e, 1);
547 if (bb->flags & BB_RTL)
549 if (bb->il.rtl->global_live_at_start)
551 fprintf (file, "\nRegisters live at start:");
552 dump_regset (bb->il.rtl->global_live_at_start, file);
555 if (bb->il.rtl->global_live_at_end)
557 fprintf (file, "\nRegisters live at end:");
558 dump_regset (bb->il.rtl->global_live_at_end, file);
563 check_bb_profile (bb, file);
570 debug_flow_info (void)
572 dump_flow_info (stderr);
576 dump_edge_info (FILE *file, edge e, int do_succ)
578 basic_block side = (do_succ ? e->dest : e->src);
580 if (side == ENTRY_BLOCK_PTR)
581 fputs (" ENTRY", file);
582 else if (side == EXIT_BLOCK_PTR)
583 fputs (" EXIT", file);
585 fprintf (file, " %d", side->index);
588 fprintf (file, " [%.1f%%] ", e->probability * 100.0 / REG_BR_PROB_BASE);
592 fprintf (file, " count:");
593 fprintf (file, HOST_WIDEST_INT_PRINT_DEC, e->count);
598 static const char * const bitnames[] = {
599 "fallthru", "ab", "abcall", "eh", "fake", "dfs_back",
600 "can_fallthru", "irreducible", "sibcall", "loop_exit",
601 "true", "false", "exec"
604 int i, flags = e->flags;
607 for (i = 0; flags; i++)
608 if (flags & (1 << i))
614 if (i < (int) ARRAY_SIZE (bitnames))
615 fputs (bitnames[i], file);
617 fprintf (file, "%d", i);
625 /* Simple routines to easily allocate AUX fields of basic blocks. */
627 static struct obstack block_aux_obstack;
628 static void *first_block_aux_obj = 0;
629 static struct obstack edge_aux_obstack;
630 static void *first_edge_aux_obj = 0;
632 /* Allocate a memory block of SIZE as BB->aux. The obstack must
633 be first initialized by alloc_aux_for_blocks. */
636 alloc_aux_for_block (basic_block bb, int size)
638 /* Verify that aux field is clear. */
639 gcc_assert (!bb->aux && first_block_aux_obj);
640 bb->aux = obstack_alloc (&block_aux_obstack, size);
641 memset (bb->aux, 0, size);
644 /* Initialize the block_aux_obstack and if SIZE is nonzero, call
645 alloc_aux_for_block for each basic block. */
648 alloc_aux_for_blocks (int size)
650 static int initialized;
654 gcc_obstack_init (&block_aux_obstack);
658 /* Check whether AUX data are still allocated. */
659 gcc_assert (!first_block_aux_obj);
661 first_block_aux_obj = obstack_alloc (&block_aux_obstack, 0);
666 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
667 alloc_aux_for_block (bb, size);
671 /* Clear AUX pointers of all blocks. */
674 clear_aux_for_blocks (void)
678 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, NULL, next_bb)
682 /* Free data allocated in block_aux_obstack and clear AUX pointers
686 free_aux_for_blocks (void)
688 gcc_assert (first_block_aux_obj);
689 obstack_free (&block_aux_obstack, first_block_aux_obj);
690 first_block_aux_obj = NULL;
692 clear_aux_for_blocks ();
695 /* Allocate a memory edge of SIZE as BB->aux. The obstack must
696 be first initialized by alloc_aux_for_edges. */
699 alloc_aux_for_edge (edge e, int size)
701 /* Verify that aux field is clear. */
702 gcc_assert (!e->aux && first_edge_aux_obj);
703 e->aux = obstack_alloc (&edge_aux_obstack, size);
704 memset (e->aux, 0, size);
707 /* Initialize the edge_aux_obstack and if SIZE is nonzero, call
708 alloc_aux_for_edge for each basic edge. */
711 alloc_aux_for_edges (int size)
713 static int initialized;
717 gcc_obstack_init (&edge_aux_obstack);
721 /* Check whether AUX data are still allocated. */
722 gcc_assert (!first_edge_aux_obj);
724 first_edge_aux_obj = obstack_alloc (&edge_aux_obstack, 0);
729 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
734 FOR_EACH_EDGE (e, ei, bb->succs)
735 alloc_aux_for_edge (e, size);
740 /* Clear AUX pointers of all edges. */
743 clear_aux_for_edges (void)
748 FOR_BB_BETWEEN (bb, ENTRY_BLOCK_PTR, EXIT_BLOCK_PTR, next_bb)
751 FOR_EACH_EDGE (e, ei, bb->succs)
756 /* Free data allocated in edge_aux_obstack and clear AUX pointers
760 free_aux_for_edges (void)
762 gcc_assert (first_edge_aux_obj);
763 obstack_free (&edge_aux_obstack, first_edge_aux_obj);
764 first_edge_aux_obj = NULL;
766 clear_aux_for_edges ();
770 debug_bb (basic_block bb)
772 dump_bb (bb, stderr, 0);
778 basic_block bb = BASIC_BLOCK (n);
779 dump_bb (bb, stderr, 0);
783 /* Dumps cfg related information about basic block BB to FILE. */
786 dump_cfg_bb_info (FILE *file, basic_block bb)
791 static const char * const bb_bitnames[] =
793 "dirty", "new", "reachable", "visited", "irreducible_loop", "superblock"
795 const unsigned n_bitnames = sizeof (bb_bitnames) / sizeof (char *);
798 fprintf (file, "Basic block %d", bb->index);
799 for (i = 0; i < n_bitnames; i++)
800 if (bb->flags & (1 << i))
803 fprintf (file, " (");
805 fprintf (file, ", ");
807 fprintf (file, bb_bitnames[i]);
811 fprintf (file, "\n");
813 fprintf (file, "Predecessors: ");
814 FOR_EACH_EDGE (e, ei, bb->preds)
815 dump_edge_info (file, e, 0);
817 fprintf (file, "\nSuccessors: ");
818 FOR_EACH_EDGE (e, ei, bb->succs)
819 dump_edge_info (file, e, 1);
820 fprintf (file, "\n\n");
823 /* Dumps a brief description of cfg to FILE. */
826 brief_dump_cfg (FILE *file)
832 dump_cfg_bb_info (file, bb);
836 /* An edge originally destinating BB of FREQUENCY and COUNT has been proved to
837 leave the block by TAKEN_EDGE. Update profile of BB such that edge E can be
838 redirected to destination of TAKEN_EDGE.
840 This function may leave the profile inconsistent in the case TAKEN_EDGE
841 frequency or count is believed to be lower than FREQUENCY or COUNT
844 update_bb_profile_for_threading (basic_block bb, int edge_frequency,
845 gcov_type count, edge taken_edge)
855 fprintf (dump_file, "bb %i count became negative after threading",
860 /* Compute the probability of TAKEN_EDGE being reached via threaded edge.
861 Watch for overflows. */
863 prob = edge_frequency * REG_BR_PROB_BASE / bb->frequency;
866 if (prob > taken_edge->probability)
869 fprintf (dump_file, "Jump threading proved probability of edge "
870 "%i->%i too small (it is %i, should be %i).\n",
871 taken_edge->src->index, taken_edge->dest->index,
872 taken_edge->probability, prob);
873 prob = taken_edge->probability;
876 /* Now rescale the probabilities. */
877 taken_edge->probability -= prob;
878 prob = REG_BR_PROB_BASE - prob;
879 bb->frequency -= edge_frequency;
880 if (bb->frequency < 0)
885 fprintf (dump_file, "Edge frequencies of bb %i has been reset, "
886 "frequency of block should end up being 0, it is %i\n",
887 bb->index, bb->frequency);
888 EDGE_SUCC (bb, 0)->probability = REG_BR_PROB_BASE;
889 ei = ei_start (bb->succs);
891 for (; (c = ei_safe_edge (ei)); ei_next (&ei))
894 else if (prob != REG_BR_PROB_BASE)
896 int scale = 65536 * REG_BR_PROB_BASE / prob;
898 FOR_EACH_EDGE (c, ei, bb->succs)
899 c->probability = (c->probability * scale) / 65536;
902 gcc_assert (bb == taken_edge->src);
903 taken_edge->count -= count;
904 if (taken_edge->count < 0)
907 fprintf (dump_file, "edge %i->%i count became negative after threading",
908 taken_edge->src->index, taken_edge->dest->index);
909 taken_edge->count = 0;
913 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
914 by NUM/DEN, in int arithmetic. May lose some accuracy. */
916 scale_bbs_frequencies_int (basic_block *bbs, int nbbs, int num, int den)
920 for (i = 0; i < nbbs; i++)
923 bbs[i]->frequency = (bbs[i]->frequency * num) / den;
924 bbs[i]->count = RDIV (bbs[i]->count * num, den);
925 FOR_EACH_EDGE (e, ei, bbs[i]->succs)
926 e->count = (e->count * num) /den;
930 /* Multiply all frequencies of basic blocks in array BBS of length NBBS
931 by NUM/DEN, in gcov_type arithmetic. More accurate than previous
932 function but considerably slower. */
934 scale_bbs_frequencies_gcov_type (basic_block *bbs, int nbbs, gcov_type num,
940 for (i = 0; i < nbbs; i++)
943 bbs[i]->frequency = (bbs[i]->frequency * num) / den;
944 bbs[i]->count = RDIV (bbs[i]->count * num, den);
945 FOR_EACH_EDGE (e, ei, bbs[i]->succs)
946 e->count = (e->count * num) /den;
950 /* Data structures used to maintain mapping between basic blocks and
952 static htab_t bb_original;
953 static htab_t bb_copy;
954 static alloc_pool original_copy_bb_pool;
956 struct htab_bb_copy_original_entry
958 /* Block we are attaching info to. */
960 /* Index of original or copy (depending on the hashtable) */
965 bb_copy_original_hash (const void *p)
967 struct htab_bb_copy_original_entry *data
968 = ((struct htab_bb_copy_original_entry *)p);
973 bb_copy_original_eq (const void *p, const void *q)
975 struct htab_bb_copy_original_entry *data
976 = ((struct htab_bb_copy_original_entry *)p);
977 struct htab_bb_copy_original_entry *data2
978 = ((struct htab_bb_copy_original_entry *)q);
980 return data->index1 == data2->index1;
983 /* Initialize the data structures to maintain mapping between blocks
986 initialize_original_copy_tables (void)
988 gcc_assert (!original_copy_bb_pool);
989 original_copy_bb_pool
990 = create_alloc_pool ("original_copy",
991 sizeof (struct htab_bb_copy_original_entry), 10);
992 bb_original = htab_create (10, bb_copy_original_hash,
993 bb_copy_original_eq, NULL);
994 bb_copy = htab_create (10, bb_copy_original_hash, bb_copy_original_eq, NULL);
997 /* Free the data structures to maintain mapping between blocks and
1000 free_original_copy_tables (void)
1002 gcc_assert (original_copy_bb_pool);
1003 htab_delete (bb_copy);
1004 htab_delete (bb_original);
1005 free_alloc_pool (original_copy_bb_pool);
1008 original_copy_bb_pool = NULL;
1011 /* Set original for basic block. Do nothing when data structures are not
1012 initialized so passes not needing this don't need to care. */
1014 set_bb_original (basic_block bb, basic_block original)
1016 if (original_copy_bb_pool)
1018 struct htab_bb_copy_original_entry **slot;
1019 struct htab_bb_copy_original_entry key;
1021 key.index1 = bb->index;
1023 (struct htab_bb_copy_original_entry **) htab_find_slot (bb_original,
1026 (*slot)->index2 = original->index;
1029 *slot = pool_alloc (original_copy_bb_pool);
1030 (*slot)->index1 = bb->index;
1031 (*slot)->index2 = original->index;
1036 /* Get the original basic block. */
1038 get_bb_original (basic_block bb)
1040 struct htab_bb_copy_original_entry *entry;
1041 struct htab_bb_copy_original_entry key;
1043 gcc_assert (original_copy_bb_pool);
1045 key.index1 = bb->index;
1046 entry = (struct htab_bb_copy_original_entry *) htab_find (bb_original, &key);
1048 return BASIC_BLOCK (entry->index2);
1053 /* Set copy for basic block. Do nothing when data structures are not
1054 initialized so passes not needing this don't need to care. */
1056 set_bb_copy (basic_block bb, basic_block copy)
1058 if (original_copy_bb_pool)
1060 struct htab_bb_copy_original_entry **slot;
1061 struct htab_bb_copy_original_entry key;
1063 key.index1 = bb->index;
1065 (struct htab_bb_copy_original_entry **) htab_find_slot (bb_copy,
1068 (*slot)->index2 = copy->index;
1071 *slot = pool_alloc (original_copy_bb_pool);
1072 (*slot)->index1 = bb->index;
1073 (*slot)->index2 = copy->index;
1078 /* Get the copy of basic block. */
1080 get_bb_copy (basic_block bb)
1082 struct htab_bb_copy_original_entry *entry;
1083 struct htab_bb_copy_original_entry key;
1085 gcc_assert (original_copy_bb_pool);
1087 key.index1 = bb->index;
1088 entry = (struct htab_bb_copy_original_entry *) htab_find (bb_copy, &key);
1090 return BASIC_BLOCK (entry->index2);