gcc/dominance.c

   1 /* Calculate (post)dominators in slightly super-linear time.
   2    Copyright (C) 2000, 2003, 2004 Free Software Foundation, Inc.
   3    Contributed by Michael Matz (matz@ifh.de).
   4
   5    This file is part of GCC.
   6
   7    GCC is free software; you can redistribute it and/or modify it
   8    under the terms of the GNU General Public License as published by
   9    the Free Software Foundation; either version 2, or (at your option)
  10    any later version.
  11
  12    GCC is distributed in the hope that it will be useful, but WITHOUT
  13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  15    License for more details.
  16
  17    You should have received a copy of the GNU General Public License
  18    along with GCC; see the file COPYING.  If not, write to the Free
  19    Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20    02111-1307, USA.  */
  21
  22 /* This file implements the well known algorithm from Lengauer and Tarjan
  23    to compute the dominators in a control flow graph.  A basic block D is said
  24    to dominate another block X, when all paths from the entry node of the CFG
  25    to X go also over D.  The dominance relation is a transitive reflexive
  26    relation and its minimal transitive reduction is a tree, called the
  27    dominator tree.  So for each block X besides the entry block exists a
  28    block I(X), called the immediate dominator of X, which is the parent of X
  29    in the dominator tree.
  30
  31    The algorithm computes this dominator tree implicitly by computing for
  32    each block its immediate dominator.  We use tree balancing and path
  33    compression, so its the O(e*a(e,v)) variant, where a(e,v) is the very
  34    slowly growing functional inverse of the Ackerman function.  */
  35
  36 #include "config.h"
  37 #include "system.h"
  38 #include "coretypes.h"
  39 #include "tm.h"
  40 #include "rtl.h"
  41 #include "hard-reg-set.h"
  42 #include "basic-block.h"
  43 #include "errors.h"
  44 #include "et-forest.h"
  45
  46 /* Whether the dominators and the postdominators are available.  */
  47 enum dom_state dom_computed[2];
  48
  49 /* We name our nodes with integers, beginning with 1.  Zero is reserved for
  50    'undefined' or 'end of list'.  The name of each node is given by the dfs
  51    number of the corresponding basic block.  Please note, that we include the
  52    artificial ENTRY_BLOCK (or EXIT_BLOCK in the post-dom case) in our lists to
  53    support multiple entry points.  As it has no real basic block index we use
  54    'last_basic_block' for that.  Its dfs number is of course 1.  */
  55
  56 /* Type of Basic Block aka. TBB */
  57 typedef unsigned int TBB;
  58
  59 /* We work in a poor-mans object oriented fashion, and carry an instance of
  60    this structure through all our 'methods'.  It holds various arrays
  61    reflecting the (sub)structure of the flowgraph.  Most of them are of type
  62    TBB and are also indexed by TBB.  */
  63
  64 struct dom_info
  65 {
  66   /* The parent of a node in the DFS tree.  */
  67   TBB *dfs_parent;
  68   /* For a node x key[x] is roughly the node nearest to the root from which
  69      exists a way to x only over nodes behind x.  Such a node is also called
  70      semidominator.  */
  71   TBB *key;
  72   /* The value in path_min[x] is the node y on the path from x to the root of
  73      the tree x is in with the smallest key[y].  */
  74   TBB *path_min;
  75   /* bucket[x] points to the first node of the set of nodes having x as key.  */
  76   TBB *bucket;
  77   /* And next_bucket[x] points to the next node.  */
  78   TBB *next_bucket;
  79   /* After the algorithm is done, dom[x] contains the immediate dominator
  80      of x.  */
  81   TBB *dom;
  82
  83   /* The following few fields implement the structures needed for disjoint
  84      sets.  */
  85   /* set_chain[x] is the next node on the path from x to the representant
  86      of the set containing x.  If set_chain[x]==0 then x is a root.  */
  87   TBB *set_chain;
  88   /* set_size[x] is the number of elements in the set named by x.  */
  89   unsigned int *set_size;
  90   /* set_child[x] is used for balancing the tree representing a set.  It can
  91      be understood as the next sibling of x.  */
  92   TBB *set_child;
  93
  94   /* If b is the number of a basic block (BB->index), dfs_order[b] is the
  95      number of that node in DFS order counted from 1.  This is an index
  96      into most of the other arrays in this structure.  */
  97   TBB *dfs_order;
  98   /* If x is the DFS-index of a node which corresponds with a basic block,
  99      dfs_to_bb[x] is that basic block.  Note, that in our structure there are
 100      more nodes that basic blocks, so only dfs_to_bb[dfs_order[bb->index]]==bb
 101      is true for every basic block bb, but not the opposite.  */
 102   basic_block *dfs_to_bb;
 103
 104   /* This is the next free DFS number when creating the DFS tree.  */
 105   unsigned int dfsnum;
 106   /* The number of nodes in the DFS tree (==dfsnum-1).  */
 107   unsigned int nodes;
 108
 109   /* Blocks with bits set here have a fake edge to EXIT.  These are used
 110      to turn a DFS forest into a proper tree.  */
 111   bitmap fake_exit_edge;
 112 };
 113
 114 static void init_dom_info (struct dom_info *, enum cdi_direction);
 115 static void free_dom_info (struct dom_info *);
 116 static void calc_dfs_tree_nonrec (struct dom_info *, basic_block,
 117                                   enum cdi_direction);
 118 static void calc_dfs_tree (struct dom_info *, enum cdi_direction);
 119 static void compress (struct dom_info *, TBB);
 120 static TBB eval (struct dom_info *, TBB);
 121 static void link_roots (struct dom_info *, TBB, TBB);
 122 static void calc_idoms (struct dom_info *, enum cdi_direction);
 123 void debug_dominance_info (enum cdi_direction);
 124
 125 /* Keeps track of the*/
 126 static unsigned n_bbs_in_dom_tree[2];
 127
 128 /* Helper macro for allocating and initializing an array,
 129    for aesthetic reasons.  */
 130 #define init_ar(var, type, num, content)                        \
 131   do                                                            \
 132     {                                                           \
 133       unsigned int i = 1;    /* Catch content == i.  */         \
 134       if (! (content))                                          \
 135         (var) = xcalloc ((num), sizeof (type));                 \
 136       else                                                      \
 137         {                                                       \
 138           (var) = xmalloc ((num) * sizeof (type));              \
 139           for (i = 0; i < num; i++)                             \
 140             (var)[i] = (content);                               \
 141         }                                                       \
 142     }                                                           \
 143   while (0)
 144
 145 /* Allocate all needed memory in a pessimistic fashion (so we round up).
 146    This initializes the contents of DI, which already must be allocated.  */
 147
 148 static void
 149 init_dom_info (struct dom_info *di, enum cdi_direction dir)
 150 {
 151   /* We need memory for n_basic_blocks nodes and the ENTRY_BLOCK or
 152      EXIT_BLOCK.  */
 153   unsigned int num = n_basic_blocks + 1 + 1;
 154   init_ar (di->dfs_parent, TBB, num, 0);
 155   init_ar (di->path_min, TBB, num, i);
 156   init_ar (di->key, TBB, num, i);
 157   init_ar (di->dom, TBB, num, 0);
 158
 159   init_ar (di->bucket, TBB, num, 0);
 160   init_ar (di->next_bucket, TBB, num, 0);
 161
 162   init_ar (di->set_chain, TBB, num, 0);
 163   init_ar (di->set_size, unsigned int, num, 1);
 164   init_ar (di->set_child, TBB, num, 0);
 165
 166   init_ar (di->dfs_order, TBB, (unsigned int) last_basic_block + 1, 0);
 167   init_ar (di->dfs_to_bb, basic_block, num, 0);
 168
 169   di->dfsnum = 1;
 170   di->nodes = 0;
 171
 172   di->fake_exit_edge = dir ? BITMAP_XMALLOC () : NULL;
 173 }
 174
 175 #undef init_ar
 176
 177 /* Free all allocated memory in DI, but not DI itself.  */
 178
 179 static void
 180 free_dom_info (struct dom_info *di)
 181 {
 182   free (di->dfs_parent);
 183   free (di->path_min);
 184   free (di->key);
 185   free (di->dom);
 186   free (di->bucket);
 187   free (di->next_bucket);
 188   free (di->set_chain);
 189   free (di->set_size);
 190   free (di->set_child);
 191   free (di->dfs_order);
 192   free (di->dfs_to_bb);
 193   BITMAP_XFREE (di->fake_exit_edge);
 194 }
 195
 196 /* The nonrecursive variant of creating a DFS tree.  DI is our working
 197    structure, BB the starting basic block for this tree and REVERSE
 198    is true, if predecessors should be visited instead of successors of a
 199    node.  After this is done all nodes reachable from BB were visited, have
 200    assigned their dfs number and are linked together to form a tree.  */
 201
 202 static void
 203 calc_dfs_tree_nonrec (struct dom_info *di, basic_block bb,
 204                       enum cdi_direction reverse)
 205 {
 206   /* We call this _only_ if bb is not already visited.  */
 207   edge e;
 208   TBB child_i, my_i = 0;
 209   edge *stack;
 210   int sp;
 211   /* Start block (ENTRY_BLOCK_PTR for forward problem, EXIT_BLOCK for backward
 212      problem).  */
 213   basic_block en_block;
 214   /* Ending block.  */
 215   basic_block ex_block;
 216
 217   stack = xmalloc ((n_basic_blocks + 3) * sizeof (edge));
 218   sp = 0;
 219
 220   /* Initialize our border blocks, and the first edge.  */
 221   if (reverse)
 222     {
 223       e = bb->pred;
 224       en_block = EXIT_BLOCK_PTR;
 225       ex_block = ENTRY_BLOCK_PTR;
 226     }
 227   else
 228     {
 229       e = bb->succ;
 230       en_block = ENTRY_BLOCK_PTR;
 231       ex_block = EXIT_BLOCK_PTR;
 232     }
 233
 234   /* When the stack is empty we break out of this loop.  */
 235   while (1)
 236     {
 237       basic_block bn;
 238
 239       /* This loop traverses edges e in depth first manner, and fills the
 240          stack.  */
 241       while (e)
 242         {
 243           edge e_next;
 244
 245           /* Deduce from E the current and the next block (BB and BN), and the
 246              next edge.  */
 247           if (reverse)
 248             {
 249               bn = e->src;
 250
 251               /* If the next node BN is either already visited or a border
 252                  block the current edge is useless, and simply overwritten
 253                  with the next edge out of the current node.  */
 254               if (bn == ex_block || di->dfs_order[bn->index])
 255                 {
 256                   e = e->pred_next;
 257                   continue;
 258                 }
 259               bb = e->dest;
 260               e_next = bn->pred;
 261             }
 262           else
 263             {
 264               bn = e->dest;
 265               if (bn == ex_block || di->dfs_order[bn->index])
 266                 {
 267                   e = e->succ_next;
 268                   continue;
 269                 }
 270               bb = e->src;
 271               e_next = bn->succ;
 272             }
 273
 274           gcc_assert (bn != en_block);
 275
 276           /* Fill the DFS tree info calculatable _before_ recursing.  */
 277           if (bb != en_block)
 278             my_i = di->dfs_order[bb->index];
 279           else
 280             my_i = di->dfs_order[last_basic_block];
 281           child_i = di->dfs_order[bn->index] = di->dfsnum++;
 282           di->dfs_to_bb[child_i] = bn;
 283           di->dfs_parent[child_i] = my_i;
 284
 285           /* Save the current point in the CFG on the stack, and recurse.  */
 286           stack[sp++] = e;
 287           e = e_next;
 288         }
 289
 290       if (!sp)
 291         break;
 292       e = stack[--sp];
 293
 294       /* OK.  The edge-list was exhausted, meaning normally we would
 295          end the recursion.  After returning from the recursive call,
 296          there were (may be) other statements which were run after a
 297          child node was completely considered by DFS.  Here is the
 298          point to do it in the non-recursive variant.
 299          E.g. The block just completed is in e->dest for forward DFS,
 300          the block not yet completed (the parent of the one above)
 301          in e->src.  This could be used e.g. for computing the number of
 302          descendants or the tree depth.  */
 303       if (reverse)
 304         e = e->pred_next;
 305       else
 306         e = e->succ_next;
 307     }
 308   free (stack);
 309 }
 310
 311 /* The main entry for calculating the DFS tree or forest.  DI is our working
 312    structure and REVERSE is true, if we are interested in the reverse flow
 313    graph.  In that case the result is not necessarily a tree but a forest,
 314    because there may be nodes from which the EXIT_BLOCK is unreachable.  */
 315
 316 static void
 317 calc_dfs_tree (struct dom_info *di, enum cdi_direction reverse)
 318 {
 319   /* The first block is the ENTRY_BLOCK (or EXIT_BLOCK if REVERSE).  */
 320   basic_block begin = reverse ? EXIT_BLOCK_PTR : ENTRY_BLOCK_PTR;
 321   di->dfs_order[last_basic_block] = di->dfsnum;
 322   di->dfs_to_bb[di->dfsnum] = begin;
 323   di->dfsnum++;
 324
 325   calc_dfs_tree_nonrec (di, begin, reverse);
 326
 327   if (reverse)
 328     {
 329       /* In the post-dom case we may have nodes without a path to EXIT_BLOCK.
 330          They are reverse-unreachable.  In the dom-case we disallow such
 331          nodes, but in post-dom we have to deal with them.
 332
 333          There are two situations in which this occurs.  First, noreturn
 334          functions.  Second, infinite loops.  In the first case we need to
 335          pretend that there is an edge to the exit block.  In the second
 336          case, we wind up with a forest.  We need to process all noreturn
 337          blocks before we know if we've got any infinite loops.  */
 338
 339       basic_block b;
 340       bool saw_unconnected = false;
 341
 342       FOR_EACH_BB_REVERSE (b)
 343         {
 344           if (b->succ)
 345             {
 346               if (di->dfs_order[b->index] == 0)
 347                 saw_unconnected = true;
 348               continue;
 349             }
 350           bitmap_set_bit (di->fake_exit_edge, b->index);
 351           di->dfs_order[b->index] = di->dfsnum;
 352           di->dfs_to_bb[di->dfsnum] = b;
 353           di->dfs_parent[di->dfsnum] = di->dfs_order[last_basic_block];
 354           di->dfsnum++;
 355           calc_dfs_tree_nonrec (di, b, reverse);
 356         }
 357
 358       if (saw_unconnected)
 359         {
 360           FOR_EACH_BB_REVERSE (b)
 361             {
 362               if (di->dfs_order[b->index])
 363                 continue;
 364               bitmap_set_bit (di->fake_exit_edge, b->index);
 365               di->dfs_order[b->index] = di->dfsnum;
 366               di->dfs_to_bb[di->dfsnum] = b;
 367               di->dfs_parent[di->dfsnum] = di->dfs_order[last_basic_block];
 368               di->dfsnum++;
 369               calc_dfs_tree_nonrec (di, b, reverse);
 370             }
 371         }
 372     }
 373
 374   di->nodes = di->dfsnum - 1;
 375
 376   /* This aborts e.g. when there is _no_ path from ENTRY to EXIT at all.  */
 377   gcc_assert (di->nodes == (unsigned int) n_basic_blocks + 1);
 378 }
 379
 380 /* Compress the path from V to the root of its set and update path_min at the
 381    same time.  After compress(di, V) set_chain[V] is the root of the set V is
 382    in and path_min[V] is the node with the smallest key[] value on the path
 383    from V to that root.  */
 384
 385 static void
 386 compress (struct dom_info *di, TBB v)
 387 {
 388   /* Btw. It's not worth to unrecurse compress() as the depth is usually not
 389      greater than 5 even for huge graphs (I've not seen call depth > 4).
 390      Also performance wise compress() ranges _far_ behind eval().  */
 391   TBB parent = di->set_chain[v];
 392   if (di->set_chain[parent])
 393     {
 394       compress (di, parent);
 395       if (di->key[di->path_min[parent]] < di->key[di->path_min[v]])
 396         di->path_min[v] = di->path_min[parent];
 397       di->set_chain[v] = di->set_chain[parent];
 398     }
 399 }
 400
 401 /* Compress the path from V to the set root of V if needed (when the root has
 402    changed since the last call).  Returns the node with the smallest key[]
 403    value on the path from V to the root.  */
 404
 405 static inline TBB
 406 eval (struct dom_info *di, TBB v)
 407 {
 408   /* The representant of the set V is in, also called root (as the set
 409      representation is a tree).  */
 410   TBB rep = di->set_chain[v];
 411
 412   /* V itself is the root.  */
 413   if (!rep)
 414     return di->path_min[v];
 415
 416   /* Compress only if necessary.  */
 417   if (di->set_chain[rep])
 418     {
 419       compress (di, v);
 420       rep = di->set_chain[v];
 421     }
 422
 423   if (di->key[di->path_min[rep]] >= di->key[di->path_min[v]])
 424     return di->path_min[v];
 425   else
 426     return di->path_min[rep];
 427 }
 428
 429 /* This essentially merges the two sets of V and W, giving a single set with
 430    the new root V.  The internal representation of these disjoint sets is a
 431    balanced tree.  Currently link(V,W) is only used with V being the parent
 432    of W.  */
 433
 434 static void
 435 link_roots (struct dom_info *di, TBB v, TBB w)
 436 {
 437   TBB s = w;
 438
 439   /* Rebalance the tree.  */
 440   while (di->key[di->path_min[w]] < di->key[di->path_min[di->set_child[s]]])
 441     {
 442       if (di->set_size[s] + di->set_size[di->set_child[di->set_child[s]]]
 443           >= 2 * di->set_size[di->set_child[s]])
 444         {
 445           di->set_chain[di->set_child[s]] = s;
 446           di->set_child[s] = di->set_child[di->set_child[s]];
 447         }
 448       else
 449         {
 450           di->set_size[di->set_child[s]] = di->set_size[s];
 451           s = di->set_chain[s] = di->set_child[s];
 452         }
 453     }
 454
 455   di->path_min[s] = di->path_min[w];
 456   di->set_size[v] += di->set_size[w];
 457   if (di->set_size[v] < 2 * di->set_size[w])
 458     {
 459       TBB tmp = s;
 460       s = di->set_child[v];
 461       di->set_child[v] = tmp;
 462     }
 463
 464   /* Merge all subtrees.  */
 465   while (s)
 466     {
 467       di->set_chain[s] = v;
 468       s = di->set_child[s];
 469     }
 470 }
 471
 472 /* This calculates the immediate dominators (or post-dominators if REVERSE is
 473    true).  DI is our working structure and should hold the DFS forest.
 474    On return the immediate dominator to node V is in di->dom[V].  */
 475
 476 static void
 477 calc_idoms (struct dom_info *di, enum cdi_direction reverse)
 478 {
 479   TBB v, w, k, par;
 480   basic_block en_block;
 481   if (reverse)
 482     en_block = EXIT_BLOCK_PTR;
 483   else
 484     en_block = ENTRY_BLOCK_PTR;
 485
 486   /* Go backwards in DFS order, to first look at the leafs.  */
 487   v = di->nodes;
 488   while (v > 1)
 489     {
 490       basic_block bb = di->dfs_to_bb[v];
 491       edge e, e_next;
 492
 493       par = di->dfs_parent[v];
 494       k = v;
 495       if (reverse)
 496         {
 497           e = bb->succ;
 498
 499           /* If this block has a fake edge to exit, process that first.  */
 500           if (bitmap_bit_p (di->fake_exit_edge, bb->index))
 501             {
 502               e_next = e;
 503               goto do_fake_exit_edge;
 504             }
 505         }
 506       else
 507         e = bb->pred;
 508
 509       /* Search all direct predecessors for the smallest node with a path
 510          to them.  That way we have the smallest node with also a path to
 511          us only over nodes behind us.  In effect we search for our
 512          semidominator.  */
 513       for (; e ; e = e_next)
 514         {
 515           TBB k1;
 516           basic_block b;
 517
 518           if (reverse)
 519             {
 520               b = e->dest;
 521               e_next = e->succ_next;
 522             }
 523           else
 524             {
 525               b = e->src;
 526               e_next = e->pred_next;
 527             }
 528           if (b == en_block)
 529             {
 530             do_fake_exit_edge:
 531               k1 = di->dfs_order[last_basic_block];
 532             }
 533           else
 534             k1 = di->dfs_order[b->index];
 535
 536           /* Call eval() only if really needed.  If k1 is above V in DFS tree,
 537              then we know, that eval(k1) == k1 and key[k1] == k1.  */
 538           if (k1 > v)
 539             k1 = di->key[eval (di, k1)];
 540           if (k1 < k)
 541             k = k1;
 542         }
 543
 544       di->key[v] = k;
 545       link_roots (di, par, v);
 546       di->next_bucket[v] = di->bucket[k];
 547       di->bucket[k] = v;
 548
 549       /* Transform semidominators into dominators.  */
 550       for (w = di->bucket[par]; w; w = di->next_bucket[w])
 551         {
 552           k = eval (di, w);
 553           if (di->key[k] < di->key[w])
 554             di->dom[w] = k;
 555           else
 556             di->dom[w] = par;
 557         }
 558       /* We don't need to cleanup next_bucket[].  */
 559       di->bucket[par] = 0;
 560       v--;
 561     }
 562
 563   /* Explicitly define the dominators.  */
 564   di->dom[1] = 0;
 565   for (v = 2; v <= di->nodes; v++)
 566     if (di->dom[v] != di->key[v])
 567       di->dom[v] = di->dom[di->dom[v]];
 568 }
 569
 570 /* Assign dfs numbers starting from NUM to NODE and its sons.  */
 571
 572 static void
 573 assign_dfs_numbers (struct et_node *node, int *num)
 574 {
 575   struct et_node *son;
 576
 577   node->dfs_num_in = (*num)++;
 578
 579   if (node->son)
 580     {
 581       assign_dfs_numbers (node->son, num);
 582       for (son = node->son->right; son != node->son; son = son->right)
 583         assign_dfs_numbers (son, num);
 584     }
 585
 586   node->dfs_num_out = (*num)++;
 587 }
 588
 589 /* Compute the data necessary for fast resolving of dominator queries in a
 590    static dominator tree.  */
 591
 592 static void
 593 compute_dom_fast_query (enum cdi_direction dir)
 594 {
 595   int num = 0;
 596   basic_block bb;
 597
 598   gcc_assert (dom_computed[dir] >= DOM_NO_FAST_QUERY);
 599
 600   if (dom_computed[dir] == DOM_OK)
 601     return;
 602
 603   FOR_ALL_BB (bb)
 604     {
 605       if (!bb->dom[dir]->father)
 606         assign_dfs_numbers (bb->dom[dir], &num);
 607     }
 608
 609   dom_computed[dir] = DOM_OK;
 610 }
 611
 612 /* The main entry point into this module.  DIR is set depending on whether
 613    we want to compute dominators or postdominators.  */
 614
 615 void
 616 calculate_dominance_info (enum cdi_direction dir)
 617 {
 618   struct dom_info di;
 619   basic_block b;
 620
 621   if (dom_computed[dir] == DOM_OK)
 622     return;
 623
 624   if (dom_computed[dir] != DOM_NO_FAST_QUERY)
 625     {
 626       if (dom_computed[dir] != DOM_NONE)
 627         free_dominance_info (dir);
 628
 629       gcc_assert (!n_bbs_in_dom_tree[dir]);
 630
 631       FOR_ALL_BB (b)
 632         {
 633           b->dom[dir] = et_new_tree (b);
 634         }
 635       n_bbs_in_dom_tree[dir] = n_basic_blocks + 2;
 636
 637       init_dom_info (&di, dir);
 638       calc_dfs_tree (&di, dir);
 639       calc_idoms (&di, dir);
 640
 641       FOR_EACH_BB (b)
 642         {
 643           TBB d = di.dom[di.dfs_order[b->index]];
 644
 645           if (di.dfs_to_bb[d])
 646             et_set_father (b->dom[dir], di.dfs_to_bb[d]->dom[dir]);
 647         }
 648
 649       free_dom_info (&di);
 650       dom_computed[dir] = DOM_NO_FAST_QUERY;
 651     }
 652
 653   compute_dom_fast_query (dir);
 654 }
 655
 656 /* Free dominance information for direction DIR.  */
 657 void
 658 free_dominance_info (enum cdi_direction dir)
 659 {
 660   basic_block bb;
 661
 662   if (!dom_computed[dir])
 663     return;
 664
 665   FOR_ALL_BB (bb)
 666     {
 667       delete_from_dominance_info (dir, bb);
 668     }
 669
 670   /* If there are any nodes left, something is wrong.  */
 671   gcc_assert (!n_bbs_in_dom_tree[dir]);
 672
 673   dom_computed[dir] = DOM_NONE;
 674 }
 675
 676 /* Return the immediate dominator of basic block BB.  */
 677 basic_block
 678 get_immediate_dominator (enum cdi_direction dir, basic_block bb)
 679 {
 680   struct et_node *node = bb->dom[dir];
 681
 682   gcc_assert (dom_computed[dir]);
 683
 684   if (!node->father)
 685     return NULL;
 686
 687   return node->father->data;
 688 }
 689
 690 /* Set the immediate dominator of the block possibly removing
 691    existing edge.  NULL can be used to remove any edge.  */
 692 inline void
 693 set_immediate_dominator (enum cdi_direction dir, basic_block bb,
 694                          basic_block dominated_by)
 695 {
 696   struct et_node *node = bb->dom[dir];
 697
 698   gcc_assert (dom_computed[dir]);
 699
 700   if (node->father)
 701     {
 702       if (node->father->data == dominated_by)
 703         return;
 704       et_split (node);
 705     }
 706
 707   if (dominated_by)
 708     et_set_father (node, dominated_by->dom[dir]);
 709
 710   if (dom_computed[dir] == DOM_OK)
 711     dom_computed[dir] = DOM_NO_FAST_QUERY;
 712 }
 713
 714 /* Store all basic blocks immediately dominated by BB into BBS and return
 715    their number.  */
 716 int
 717 get_dominated_by (enum cdi_direction dir, basic_block bb, basic_block **bbs)
 718 {
 719   int n;
 720   struct et_node *node = bb->dom[dir], *son = node->son, *ason;
 721
 722   gcc_assert (dom_computed[dir]);
 723
 724   if (!son)
 725     {
 726       *bbs = NULL;
 727       return 0;
 728     }
 729
 730   for (ason = son->right, n = 1; ason != son; ason = ason->right)
 731     n++;
 732
 733   *bbs = xmalloc (n * sizeof (basic_block));
 734   (*bbs)[0] = son->data;
 735   for (ason = son->right, n = 1; ason != son; ason = ason->right)
 736     (*bbs)[n++] = ason->data;
 737
 738   return n;
 739 }
 740
 741 /* Redirect all edges pointing to BB to TO.  */
 742 void
 743 redirect_immediate_dominators (enum cdi_direction dir, basic_block bb,
 744                                basic_block to)
 745 {
 746   struct et_node *bb_node = bb->dom[dir], *to_node = to->dom[dir], *son;
 747
 748   gcc_assert (dom_computed[dir]);
 749
 750   if (!bb_node->son)
 751     return;
 752
 753   while (bb_node->son)
 754     {
 755       son = bb_node->son;
 756
 757       et_split (son);
 758       et_set_father (son, to_node);
 759     }
 760
 761   if (dom_computed[dir] == DOM_OK)
 762     dom_computed[dir] = DOM_NO_FAST_QUERY;
 763 }
 764
 765 /* Find first basic block in the tree dominating both BB1 and BB2.  */
 766 basic_block
 767 nearest_common_dominator (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 768 {
 769   gcc_assert (dom_computed[dir]);
 770
 771   if (!bb1)
 772     return bb2;
 773   if (!bb2)
 774     return bb1;
 775
 776   return et_nca (bb1->dom[dir], bb2->dom[dir])->data;
 777 }
 778
 779 /* Return TRUE in case BB1 is dominated by BB2.  */
 780 bool
 781 dominated_by_p (enum cdi_direction dir, basic_block bb1, basic_block bb2)
 782 {
 783   struct et_node *n1 = bb1->dom[dir], *n2 = bb2->dom[dir];
 784
 785   gcc_assert (dom_computed[dir]);
 786
 787   if (dom_computed[dir] == DOM_OK)
 788     return (n1->dfs_num_in >= n2->dfs_num_in
 789             && n1->dfs_num_out <= n2->dfs_num_out);
 790
 791   return et_below (n1, n2);
 792 }
 793
 794 /* Verify invariants of dominator structure.  */
 795 void
 796 verify_dominators (enum cdi_direction dir)
 797 {
 798   int err = 0;
 799   basic_block bb;
 800
 801   gcc_assert (dom_computed[dir]);
 802
 803   FOR_EACH_BB (bb)
 804     {
 805       basic_block dom_bb;
 806
 807       dom_bb = recount_dominator (dir, bb);
 808       if (dom_bb != get_immediate_dominator (dir, bb))
 809         {
 810           error ("dominator of %d should be %d, not %d",
 811            bb->index, dom_bb->index, get_immediate_dominator(dir, bb)->index);
 812           err = 1;
 813         }
 814     }
 815
 816   if (dir == CDI_DOMINATORS
 817       && dom_computed[dir] >= DOM_NO_FAST_QUERY)
 818     {
 819       FOR_EACH_BB (bb)
 820         {
 821           if (!dominated_by_p (dir, bb, ENTRY_BLOCK_PTR))
 822             {
 823               error ("ENTRY does not dominate bb %d", bb->index);
 824               err = 1;
 825             }
 826         }
 827     }
 828
 829   gcc_assert (!err);
 830 }
 831
 832 /* Determine immediate dominator (or postdominator, according to DIR) of BB,
 833    assuming that dominators of other blocks are correct.  We also use it to
 834    recompute the dominators in a restricted area, by iterating it until it
 835    reaches a fixed point.  */
 836
 837 basic_block
 838 recount_dominator (enum cdi_direction dir, basic_block bb)
 839 {
 840   basic_block dom_bb = NULL;
 841   edge e;
 842
 843   gcc_assert (dom_computed[dir]);
 844
 845   if (dir == CDI_DOMINATORS)
 846     {
 847       for (e = bb->pred; e; e = e->pred_next)
 848         {
 849           /* Ignore the predecessors that either are not reachable from
 850              the entry block, or whose dominator was not determined yet.  */
 851           if (!dominated_by_p (dir, e->src, ENTRY_BLOCK_PTR))
 852             continue;
 853
 854           if (!dominated_by_p (dir, e->src, bb))
 855             dom_bb = nearest_common_dominator (dir, dom_bb, e->src);
 856         }
 857     }
 858   else
 859     {
 860       for (e = bb->succ; e; e = e->succ_next)
 861         {
 862           if (!dominated_by_p (dir, e->dest, bb))
 863             dom_bb = nearest_common_dominator (dir, dom_bb, e->dest);
 864         }
 865     }
 866
 867   return dom_bb;
 868 }
 869
 870 /* Iteratively recount dominators of BBS. The change is supposed to be local
 871    and not to grow further.  */
 872 void
 873 iterate_fix_dominators (enum cdi_direction dir, basic_block *bbs, int n)
 874 {
 875   int i, changed = 1;
 876   basic_block old_dom, new_dom;
 877
 878   gcc_assert (dom_computed[dir]);
 879
 880   for (i = 0; i < n; i++)
 881     set_immediate_dominator (dir, bbs[i], NULL);
 882
 883   while (changed)
 884     {
 885       changed = 0;
 886       for (i = 0; i < n; i++)
 887         {
 888           old_dom = get_immediate_dominator (dir, bbs[i]);
 889           new_dom = recount_dominator (dir, bbs[i]);
 890           if (old_dom != new_dom)
 891             {
 892               changed = 1;
 893               set_immediate_dominator (dir, bbs[i], new_dom);
 894             }
 895         }
 896     }
 897
 898   for (i = 0; i < n; i++)
 899     gcc_assert (get_immediate_dominator (dir, bbs[i]));
 900 }
 901
 902 void
 903 add_to_dominance_info (enum cdi_direction dir, basic_block bb)
 904 {
 905   gcc_assert (dom_computed[dir]);
 906   gcc_assert (!bb->dom[dir]);
 907
 908   n_bbs_in_dom_tree[dir]++;
 909
 910   bb->dom[dir] = et_new_tree (bb);
 911
 912   if (dom_computed[dir] == DOM_OK)
 913     dom_computed[dir] = DOM_NO_FAST_QUERY;
 914 }
 915
 916 void
 917 delete_from_dominance_info (enum cdi_direction dir, basic_block bb)
 918 {
 919   gcc_assert (dom_computed[dir]);
 920
 921   et_free_tree (bb->dom[dir]);
 922   bb->dom[dir] = NULL;
 923   n_bbs_in_dom_tree[dir]--;
 924
 925   if (dom_computed[dir] == DOM_OK)
 926     dom_computed[dir] = DOM_NO_FAST_QUERY;
 927 }
 928
 929 /* Returns the first son of BB in the dominator or postdominator tree
 930    as determined by DIR.  */
 931
 932 basic_block
 933 first_dom_son (enum cdi_direction dir, basic_block bb)
 934 {
 935   struct et_node *son = bb->dom[dir]->son;
 936
 937   return son ? son->data : NULL;
 938 }
 939
 940 /* Returns the next dominance son after BB in the dominator or postdominator
 941    tree as determined by DIR, or NULL if it was the last one.  */
 942
 943 basic_block
 944 next_dom_son (enum cdi_direction dir, basic_block bb)
 945 {
 946   struct et_node *next = bb->dom[dir]->right;
 947
 948   return next->father->son == next ? NULL : next->data;
 949 }
 950
 951 void
 952 debug_dominance_info (enum cdi_direction dir)
 953 {
 954   basic_block bb, bb2;
 955   FOR_EACH_BB (bb)
 956     if ((bb2 = get_immediate_dominator (dir, bb)))
 957       fprintf (stderr, "%i %i\n", bb->index, bb2->index);
 958 }