* pt.c (can_complete_type_without_circularity): Add static to

[pf3gnuchains/gcc-fork.git] / gcc / df.c

diff --git a/gcc/df.c b/gcc/df.c
index be36feb..d713168 100644 (file)
--- a/gcc/df.c
+++ b/gcc/df.c
@@ -171,12 +171,6 @@ Perhaps there should be a bitmap argument to df_analyse to specify
 #include "df.h"
 #include "fibheap.h"
 
-#define FOR_ALL_BBS(BB, CODE)                                  \
-do {                                                           \
-  int node_;                                                   \
-  for (node_ = 0; node_ < n_basic_blocks; node_++)             \
-    {(BB) = BASIC_BLOCK (node_); CODE;};} while (0)
-
 #define FOR_EACH_BB_IN_BITMAP(BITMAP, MIN, BB, CODE)           \
 do {                                                           \
   unsigned int node_;                                          \
@@ -406,8 +400,8 @@ df_bitmaps_alloc (df, flags)
      struct df *df;
      int flags;
 {
-  unsigned int i;
   int dflags = 0;
+  basic_block bb;
 
   /* Free the bitmaps if they need resizing.  */
   if ((flags & DF_LR) && df->n_regs < (unsigned int)max_reg_num ())
@@ -423,9 +417,8 @@ df_bitmaps_alloc (df, flags)
   df->n_defs = df->def_id;
   df->n_uses = df->use_id;
 
-  for (i = 0; i < df->n_bbs; i++)
+  FOR_EACH_BB (bb)
     {
-      basic_block bb = BASIC_BLOCK (i);
       struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
       if (flags & DF_RD && ! bb_info->rd_in)
@@ -474,11 +467,10 @@ df_bitmaps_free (df, flags)
      struct df *df ATTRIBUTE_UNUSED;
      int flags;
 {
-  unsigned int i;
+  basic_block bb;
 
-  for (i = 0; i < df->n_bbs; i++)
+  FOR_EACH_BB (bb)
     {
-      basic_block bb = BASIC_BLOCK (i);
       struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
       if (!bb_info)
@@ -534,7 +526,7 @@ df_alloc (df, n_regs)
      int n_regs;
 {
   int n_insns;
-  int i;
+  basic_block bb;
 
   gcc_obstack_init (&df_ref_obstack);
 
@@ -555,7 +547,7 @@ df_alloc (df, n_regs)
   df->uses = xmalloc (df->use_size * sizeof (*df->uses));
 
   df->n_regs = n_regs;
-  df->n_bbs = n_basic_blocks;
+  df->n_bbs = last_basic_block;
 
   /* Allocate temporary working array used during local dataflow analysis.  */
   df->reg_def_last = xmalloc (df->n_regs * sizeof (struct ref *));
@@ -569,11 +561,11 @@ df_alloc (df, n_regs)
 
   df->flags = 0;
 
-  df->bbs = xcalloc (df->n_bbs, sizeof (struct bb_info));
+  df->bbs = xcalloc (last_basic_block, sizeof (struct bb_info));
 
   df->all_blocks = BITMAP_XMALLOC ();
-  for (i = 0; i < n_basic_blocks; i++)
-    bitmap_set_bit (df->all_blocks, i);
+  FOR_EACH_BB (bb)
+    bitmap_set_bit (df->all_blocks, bb->index);
 }
 
 
@@ -633,8 +625,7 @@ static rtx df_reg_use_gen (regno)
   rtx reg;
   rtx use;
 
-  reg = regno >= FIRST_PSEUDO_REGISTER
-    ? regno_reg_rtx[regno] : gen_rtx_REG (reg_raw_mode[regno], regno);
+  reg = regno_reg_rtx[regno];
 
   use = gen_rtx_USE (GET_MODE (reg), reg);
   return use;
@@ -648,8 +639,7 @@ static rtx df_reg_clobber_gen (regno)
   rtx reg;
   rtx use;
 
-  reg = regno >= FIRST_PSEUDO_REGISTER
-    ? regno_reg_rtx[regno] : gen_rtx_REG (reg_raw_mode[regno], regno);
+  reg = regno_reg_rtx[regno];
 
   use = gen_rtx_CLOBBER (GET_MODE (reg), reg);
   return use;
@@ -905,7 +895,7 @@ df_ref_record (df, reg, loc, insn, ref_type, ref_flags)
       endregno = regno + HARD_REGNO_NREGS (regno, GET_MODE (reg));
 
       for (i = regno; i < endregno; i++)
-       df_ref_record_1 (df, gen_rtx_REG (reg_raw_mode[i], i),
+       df_ref_record_1 (df, regno_reg_rtx[i],
                         loc, insn, ref_type, ref_flags);
     }
   else
@@ -1946,6 +1936,8 @@ df_analyse_1 (df, blocks, flags, update)
   int aflags;
   int dflags;
   int i;
+  basic_block bb;
+
   dflags = 0;
   aflags = flags;
   if (flags & DF_UD_CHAIN)
@@ -2012,9 +2004,9 @@ df_analyse_1 (df, blocks, flags, update)
   df->dfs_order = xmalloc (sizeof(int) * n_basic_blocks);
   df->rc_order = xmalloc (sizeof(int) * n_basic_blocks);
   df->rts_order = xmalloc (sizeof(int) * n_basic_blocks);
-  df->inverse_dfs_map = xmalloc (sizeof(int) * n_basic_blocks);
-  df->inverse_rc_map = xmalloc (sizeof(int) * n_basic_blocks);
-  df->inverse_rts_map = xmalloc (sizeof(int) * n_basic_blocks);
+  df->inverse_dfs_map = xmalloc (sizeof(int) * last_basic_block);
+  df->inverse_rc_map = xmalloc (sizeof(int) * last_basic_block);
+  df->inverse_rts_map = xmalloc (sizeof(int) * last_basic_block);
 
   flow_depth_first_order_compute (df->dfs_order, df->rc_order);
   flow_reverse_top_sort_order_compute (df->rts_order);
@@ -2029,17 +2021,16 @@ df_analyse_1 (df, blocks, flags, update)
       /* Compute the sets of gens and kills for the defs of each bb.  */
       df_rd_local_compute (df, df->flags & DF_RD ? blocks : df->all_blocks);
       {
-       int i;
-       bitmap *in = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *out = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *gen = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *kill = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       for (i = 0; i < n_basic_blocks; i ++)
+       bitmap *in = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *out = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *gen = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *kill = xmalloc (sizeof (bitmap) * last_basic_block);
+       FOR_EACH_BB (bb)
          {
-           in[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->rd_in;
-           out[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->rd_out;
-           gen[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->rd_gen;
-           kill[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->rd_kill;
+           in[bb->index] = DF_BB_INFO (df, bb)->rd_in;
+           out[bb->index] = DF_BB_INFO (df, bb)->rd_out;
+           gen[bb->index] = DF_BB_INFO (df, bb)->rd_gen;
+           kill[bb->index] = DF_BB_INFO (df, bb)->rd_kill;
          }
        iterative_dataflow_bitmap (in, out, gen, kill, df->all_blocks,
                                   FORWARD, UNION, df_rd_transfer_function,
@@ -2066,17 +2057,16 @@ df_analyse_1 (df, blocks, flags, update)
         uses in each bb.  */
       df_ru_local_compute (df, df->flags & DF_RU ? blocks : df->all_blocks);
       {
-       int i;
-       bitmap *in = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *out = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *gen = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *kill = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       for (i = 0; i < n_basic_blocks; i ++)
+       bitmap *in = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *out = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *gen = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *kill = xmalloc (sizeof (bitmap) * last_basic_block);
+       FOR_EACH_BB (bb)
          {
-           in[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->ru_in;
-           out[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->ru_out;
-           gen[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->ru_gen;
-           kill[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->ru_kill;
+           in[bb->index] = DF_BB_INFO (df, bb)->ru_in;
+           out[bb->index] = DF_BB_INFO (df, bb)->ru_out;
+           gen[bb->index] = DF_BB_INFO (df, bb)->ru_gen;
+           kill[bb->index] = DF_BB_INFO (df, bb)->ru_kill;
          }
        iterative_dataflow_bitmap (in, out, gen, kill, df->all_blocks,
                                   BACKWARD, UNION, df_ru_transfer_function,
@@ -2106,17 +2096,16 @@ df_analyse_1 (df, blocks, flags, update)
       /* Compute the sets of defs and uses of live variables.  */
       df_lr_local_compute (df, df->flags & DF_LR ? blocks : df->all_blocks);
       {
-       int i;
-       bitmap *in = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *out = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *use = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       bitmap *def = xmalloc (sizeof (bitmap) * n_basic_blocks);
-       for (i = 0; i < n_basic_blocks; i ++)
+       bitmap *in = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *out = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *use = xmalloc (sizeof (bitmap) * last_basic_block);
+       bitmap *def = xmalloc (sizeof (bitmap) * last_basic_block);
+       FOR_EACH_BB (bb)
          {
-           in[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->lr_in;
-           out[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->lr_out;
-           use[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->lr_use;
-           def[i] = DF_BB_INFO (df, BASIC_BLOCK (i))->lr_def;
+           in[bb->index] = DF_BB_INFO (df, bb)->lr_in;
+           out[bb->index] = DF_BB_INFO (df, bb)->lr_out;
+           use[bb->index] = DF_BB_INFO (df, bb)->lr_use;
+           def[bb->index] = DF_BB_INFO (df, bb)->lr_def;
          }
        iterative_dataflow_bitmap (in, out, use, def, df->all_blocks,
                                   BACKWARD, UNION, df_lr_transfer_function,
@@ -2270,12 +2259,15 @@ df_modified_p (df, blocks)
      struct df *df;
      bitmap blocks;
 {
-  unsigned int j;
   int update = 0;
+  basic_block bb;
 
-  for (j = 0; j < df->n_bbs; j++)
-    if (bitmap_bit_p (df->bbs_modified, j)
-       && (! blocks || (blocks == (bitmap) -1) || bitmap_bit_p (blocks, j)))
+  if (!df->n_bbs)
+    return 0;
+
+  FOR_EACH_BB (bb)
+    if (bitmap_bit_p (df->bbs_modified, bb->index)
+       && (! blocks || (blocks == (bitmap) -1) || bitmap_bit_p (blocks, bb->index)))
     {
       update = 1;
       break;
@@ -2298,7 +2290,7 @@ df_analyse (df, blocks, flags)
 
   /* We could deal with additional basic blocks being created by
      rescanning everything again.  */
-  if (df->n_bbs && df->n_bbs != (unsigned int)n_basic_blocks)
+  if (df->n_bbs && df->n_bbs != (unsigned int) last_basic_block)
     abort ();
 
   update = df_modified_p (df, blocks);
@@ -2408,10 +2400,8 @@ df_refs_unlink (df, blocks)
     }
   else
     {
-      FOR_ALL_BBS (bb,
-      {
+      FOR_EACH_BB (bb)
        df_bb_refs_unlink (df, bb);
-      });
     }
 }
 #endif
@@ -3274,8 +3264,8 @@ df_dump (df, flags, file)
      int flags;
      FILE *file;
 {
-  unsigned int i;
   unsigned int j;
+  basic_block bb;
 
   if (! df || ! file)
     return;
@@ -3286,22 +3276,23 @@ df_dump (df, flags, file)
 
   if (flags & DF_RD)
     {
+      basic_block bb;
+
       fprintf (file, "Reaching defs:\n");
-      for (i = 0; i < df->n_bbs; i++)
+      FOR_EACH_BB (bb)
        {
-         basic_block bb = BASIC_BLOCK (i);
          struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
          if (! bb_info->rd_in)
            continue;
 
-         fprintf (file, "bb %d in  \t", i);
+         fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->rd_in);
-         fprintf (file, "bb %d gen \t", i);
+         fprintf (file, "bb %d gen \t", bb->index);
          dump_bitmap (file, bb_info->rd_gen);
-         fprintf (file, "bb %d kill\t", i);
+         fprintf (file, "bb %d kill\t", bb->index);
          dump_bitmap (file, bb_info->rd_kill);
-         fprintf (file, "bb %d out \t", i);
+         fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->rd_out);
        }
     }
@@ -3329,21 +3320,20 @@ df_dump (df, flags, file)
   if (flags & DF_RU)
     {
       fprintf (file, "Reaching uses:\n");
-      for (i = 0; i < df->n_bbs; i++)
+      FOR_EACH_BB (bb)
        {
-         basic_block bb = BASIC_BLOCK (i);
          struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
          if (! bb_info->ru_in)
            continue;
 
-         fprintf (file, "bb %d in  \t", i);
+         fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->ru_in);
-         fprintf (file, "bb %d gen \t", i);
+         fprintf (file, "bb %d gen \t", bb->index);
          dump_bitmap (file, bb_info->ru_gen);
-         fprintf (file, "bb %d kill\t", i);
+         fprintf (file, "bb %d kill\t", bb->index);
          dump_bitmap (file, bb_info->ru_kill);
-         fprintf (file, "bb %d out \t", i);
+         fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->ru_out);
        }
     }
@@ -3371,21 +3361,20 @@ df_dump (df, flags, file)
   if (flags & DF_LR)
     {
       fprintf (file, "Live regs:\n");
-      for (i = 0; i < df->n_bbs; i++)
+      FOR_EACH_BB (bb)
        {
-         basic_block bb = BASIC_BLOCK (i);
          struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
          if (! bb_info->lr_in)
            continue;
 
-         fprintf (file, "bb %d in  \t", i);
+         fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->lr_in);
-         fprintf (file, "bb %d use \t", i);
+         fprintf (file, "bb %d use \t", bb->index);
          dump_bitmap (file, bb_info->lr_use);
-         fprintf (file, "bb %d def \t", i);
+         fprintf (file, "bb %d def \t", bb->index);
          dump_bitmap (file, bb_info->lr_def);
-         fprintf (file, "bb %d out \t", i);
+         fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->lr_out);
        }
     }
@@ -3853,8 +3842,8 @@ iterative_dataflow_sbitmap (in, out, gen, kill, blocks,
   fibheap_t worklist;
   basic_block bb;
   sbitmap visited, pending;
-  pending = sbitmap_alloc (n_basic_blocks);
-  visited = sbitmap_alloc (n_basic_blocks);
+  pending = sbitmap_alloc (last_basic_block);
+  visited = sbitmap_alloc (last_basic_block);
   sbitmap_zero (pending);
   sbitmap_zero (visited);
   worklist = fibheap_new ();
@@ -3912,8 +3901,8 @@ iterative_dataflow_bitmap (in, out, gen, kill, blocks,
   fibheap_t worklist;
   basic_block bb;
   sbitmap visited, pending;
-  pending = sbitmap_alloc (n_basic_blocks);
-  visited = sbitmap_alloc (n_basic_blocks);
+  pending = sbitmap_alloc (last_basic_block);
+  visited = sbitmap_alloc (last_basic_block);
   sbitmap_zero (pending);
   sbitmap_zero (visited);
   worklist = fibheap_new ();