OSDN Git Service

(root) / pf3gnuchains / gcc-fork.git / blobdiff
? search:
summary | shortlog | log | commit | commitdiff | tree
raw | inline | side by side
* 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 c598faf..d713168 100644 (file)
--- a/gcc/df.c
+++ b/gcc/df.c
@@ -417,7 +417,7 @@ df_bitmaps_alloc (df, flags)
   df->n_defs = df->def_id;
   df->n_uses = df->use_id;
 
-  FOR_ALL_BB (bb)
+  FOR_EACH_BB (bb)
     {
       struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
@@ -469,7 +469,7 @@ df_bitmaps_free (df, flags)
 {
   basic_block bb;
 
-  FOR_ALL_BB (bb)
+  FOR_EACH_BB (bb)
     {
       struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
@@ -564,8 +564,8 @@ df_alloc (df, n_regs)
   df->bbs = xcalloc (last_basic_block, sizeof (struct bb_info));
 
   df->all_blocks = BITMAP_XMALLOC ();
-  FOR_ALL_BB (bb)
-    bitmap_set_bit (df->all_blocks, bb->sindex);
+  FOR_EACH_BB (bb)
+    bitmap_set_bit (df->all_blocks, bb->index);
 }
 
 
@@ -625,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;
@@ -640,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;
@@ -897,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
@@ -1941,7 +1939,7 @@ df_analyse_1 (df, blocks, flags, update)
   basic_block bb;
 
   dflags = 0;
-  aflags = flags; 
+  aflags = flags;
   if (flags & DF_UD_CHAIN)
     aflags |= DF_RD | DF_RD_CHAIN;
 
@@ -2003,16 +2001,16 @@ df_analyse_1 (df, blocks, flags, update)
       df_reg_use_chain_create (df, blocks);
     }
 
-  df->dfs_order = xmalloc (sizeof(int) * num_basic_blocks);
-  df->rc_order = xmalloc (sizeof(int) * num_basic_blocks);
-  df->rts_order = xmalloc (sizeof(int) * num_basic_blocks);
+  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) * 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);
-  for (i = 0; i < num_basic_blocks; i ++)
+  for (i = 0; i < n_basic_blocks; i ++)
    {
      df->inverse_dfs_map[df->dfs_order[i]] = i;
      df->inverse_rc_map[df->rc_order[i]] = i;
@@ -2027,12 +2025,12 @@ df_analyse_1 (df, blocks, flags, update)
        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_ALL_BB (bb)
+       FOR_EACH_BB (bb)
          {
-           in[bb->sindex] = DF_BB_INFO (df, bb)->rd_in;
-           out[bb->sindex] = DF_BB_INFO (df, bb)->rd_out;
-           gen[bb->sindex] = DF_BB_INFO (df, bb)->rd_gen;
-           kill[bb->sindex] = DF_BB_INFO (df, bb)->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,
@@ -2063,12 +2061,12 @@ df_analyse_1 (df, blocks, flags, update)
        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_ALL_BB (bb)
+       FOR_EACH_BB (bb)
          {
-           in[bb->sindex] = DF_BB_INFO (df, bb)->ru_in;
-           out[bb->sindex] = DF_BB_INFO (df, bb)->ru_out;
-           gen[bb->sindex] = DF_BB_INFO (df, bb)->ru_gen;
-           kill[bb->sindex] = DF_BB_INFO (df, bb)->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,
@@ -2102,12 +2100,12 @@ df_analyse_1 (df, blocks, flags, update)
        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_ALL_BB (bb)
+       FOR_EACH_BB (bb)
          {
-           in[bb->sindex] = DF_BB_INFO (df, bb)->lr_in;
-           out[bb->sindex] = DF_BB_INFO (df, bb)->lr_out;
-           use[bb->sindex] = DF_BB_INFO (df, bb)->lr_use;
-           def[bb->sindex] = DF_BB_INFO (df, bb)->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,
@@ -2267,9 +2265,9 @@ df_modified_p (df, blocks)
   if (!df->n_bbs)
     return 0;
 
-  FOR_ALL_BB (bb)
-    if (bitmap_bit_p (df->bbs_modified, bb->sindex)
-       && (! blocks || (blocks == (bitmap) -1) || bitmap_bit_p (blocks, bb->sindex)))
+  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;
@@ -2402,7 +2400,7 @@ df_refs_unlink (df, blocks)
     }
   else
     {
-      FOR_ALL_BB (bb)
+      FOR_EACH_BB (bb)
        df_bb_refs_unlink (df, bb);
     }
 }
@@ -2451,7 +2449,7 @@ df_insn_modify (df, bb, insn)
   if (uid >= df->insn_size)
     df_insn_table_realloc (df, 0);
 
-  bitmap_set_bit (df->bbs_modified, bb->sindex);
+  bitmap_set_bit (df->bbs_modified, bb->index);
   bitmap_set_bit (df->insns_modified, uid);
 
   /* For incremental updating on the fly, perhaps we could make a copy
@@ -3267,6 +3265,7 @@ df_dump (df, flags, file)
      FILE *file;
 {
   unsigned int j;
+  basic_block bb;
 
   if (! df || ! file)
     return;
@@ -3280,20 +3279,20 @@ df_dump (df, flags, file)
       basic_block bb;
 
       fprintf (file, "Reaching defs:\n");
-      FOR_ALL_BB (bb)
+      FOR_EACH_BB (bb)
        {
          struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
          if (! bb_info->rd_in)
            continue;
 
-         fprintf (file, "bb %d in  \t", bb->sindex);
+         fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->rd_in);
-         fprintf (file, "bb %d gen \t", bb->sindex);
+         fprintf (file, "bb %d gen \t", bb->index);
          dump_bitmap (file, bb_info->rd_gen);
-         fprintf (file, "bb %d kill\t", bb->sindex);
+         fprintf (file, "bb %d kill\t", bb->index);
          dump_bitmap (file, bb_info->rd_kill);
-         fprintf (file, "bb %d out \t", bb->sindex);
+         fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->rd_out);
        }
     }
@@ -3320,23 +3319,21 @@ df_dump (df, flags, file)
 
   if (flags & DF_RU)
     {
-      basic_block bb;
-
       fprintf (file, "Reaching uses:\n");
-      FOR_ALL_BB (bb)
+      FOR_EACH_BB (bb)
        {
          struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
          if (! bb_info->ru_in)
            continue;
 
-         fprintf (file, "bb %d in  \t", bb->sindex);
+         fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->ru_in);
-         fprintf (file, "bb %d gen \t", bb->sindex);
+         fprintf (file, "bb %d gen \t", bb->index);
          dump_bitmap (file, bb_info->ru_gen);
-         fprintf (file, "bb %d kill\t", bb->sindex);
+         fprintf (file, "bb %d kill\t", bb->index);
          dump_bitmap (file, bb_info->ru_kill);
-         fprintf (file, "bb %d out \t", bb->sindex);
+         fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->ru_out);
        }
     }
@@ -3363,23 +3360,21 @@ df_dump (df, flags, file)
 
   if (flags & DF_LR)
     {
-      basic_block bb;
-
       fprintf (file, "Live regs:\n");
-      FOR_ALL_BB (bb)
+      FOR_EACH_BB (bb)
        {
          struct bb_info *bb_info = DF_BB_INFO (df, bb);
 
          if (! bb_info->lr_in)
            continue;
 
-         fprintf (file, "bb %d in  \t", bb->sindex);
+         fprintf (file, "bb %d in  \t", bb->index);
          dump_bitmap (file, bb_info->lr_in);
-         fprintf (file, "bb %d use \t", bb->sindex);
+         fprintf (file, "bb %d use \t", bb->index);
          dump_bitmap (file, bb_info->lr_use);
-         fprintf (file, "bb %d def \t", bb->sindex);
+         fprintf (file, "bb %d def \t", bb->index);
          dump_bitmap (file, bb_info->lr_def);
-         fprintf (file, "bb %d out \t", bb->sindex);
+         fprintf (file, "bb %d out \t", bb->index);
          dump_bitmap (file, bb_info->lr_out);
        }
     }
@@ -3402,7 +3397,7 @@ df_dump (df, flags, file)
                basic_block bb = df_regno_bb (df, j);
 
                if (bb)
-                 fprintf (file, " bb %d", bb->sindex);
+                 fprintf (file, " bb %d", bb->index);
                else
                  fprintf (file, " bb ?");
              }
@@ -3603,11 +3598,11 @@ hybrid_search_bitmap (block, in, out, gen, kill, dir,
      void *data;
 {
   int changed;
-  int i = block->sindex;
+  int i = block->index;
   edge e;
-  basic_block bb = block;
-  SET_BIT (visited, block->sindex);
-  if (TEST_BIT (pending, block->sindex))
+  basic_block bb= block;
+  SET_BIT (visited, block->index);
+  if (TEST_BIT (pending, block->index))
     {
       if (dir == FORWARD)
        {
@@ -3620,10 +3615,10 @@ hybrid_search_bitmap (block, in, out, gen, kill, dir,
              switch (conf_op)
                {
                case UNION:
-                 bitmap_a_or_b (in[i], in[i], out[e->src->sindex]);
+                 bitmap_a_or_b (in[i], in[i], out[e->src->index]);
                  break;
                case INTERSECTION:
-                 bitmap_a_and_b (in[i], in[i], out[e->src->sindex]);
+                 bitmap_a_and_b (in[i], in[i], out[e->src->index]);
                  break;
                }
            }
@@ -3639,10 +3634,10 @@ hybrid_search_bitmap (block, in, out, gen, kill, dir,
              switch (conf_op)
                {
                case UNION:
-                 bitmap_a_or_b (out[i], out[i], in[e->dest->sindex]);
+                 bitmap_a_or_b (out[i], out[i], in[e->dest->index]);
                  break;
                case INTERSECTION:
-                 bitmap_a_and_b (out[i], out[i], in[e->dest->sindex]);
+                 bitmap_a_and_b (out[i], out[i], in[e->dest->index]);
                  break;
                }
            }
@@ -3656,18 +3651,18 @@ hybrid_search_bitmap (block, in, out, gen, kill, dir,
            {
              for (e = bb->succ; e != 0; e = e->succ_next)
                {
-                 if (e->dest == EXIT_BLOCK_PTR || e->dest == block)
+                 if (e->dest == EXIT_BLOCK_PTR || e->dest->index == i)
                    continue;
-                 SET_BIT (pending, e->dest->sindex);
+                 SET_BIT (pending, e->dest->index);
                }
            }
          else
            {
              for (e = bb->pred; e != 0; e = e->pred_next)
                {
-                 if (e->src == ENTRY_BLOCK_PTR || e->dest == block)
+                 if (e->src == ENTRY_BLOCK_PTR || e->dest->index == i)
                    continue;
-                 SET_BIT (pending, e->src->sindex);
+                 SET_BIT (pending, e->src->index);
                }
            }
        }
@@ -3676,11 +3671,11 @@ hybrid_search_bitmap (block, in, out, gen, kill, dir,
     {
       for (e = bb->succ; e != 0; e = e->succ_next)
        {
-         if (e->dest == EXIT_BLOCK_PTR || e->dest == block)
+         if (e->dest == EXIT_BLOCK_PTR || e->dest->index == i)
            continue;
-         if (!TEST_BIT (visited, e->dest->sindex))
-           hybrid_search_bitmap (e->dest, in, out, gen, kill, dir, 
-                                 conf_op, transfun, visited, pending, 
+         if (!TEST_BIT (visited, e->dest->index))
+           hybrid_search_bitmap (e->dest, in, out, gen, kill, dir,
+                                 conf_op, transfun, visited, pending,
                                  data);
        }
     }
@@ -3688,9 +3683,9 @@ hybrid_search_bitmap (block, in, out, gen, kill, dir,
     {
       for (e = bb->pred; e != 0; e = e->pred_next)
        {
-         if (e->src == ENTRY_BLOCK_PTR || e->src == block)
+         if (e->src == ENTRY_BLOCK_PTR || e->src->index == i)
            continue;
-         if (!TEST_BIT (visited, e->src->sindex))
+         if (!TEST_BIT (visited, e->src->index))
            hybrid_search_bitmap (e->src, in, out, gen, kill, dir,
                                  conf_op, transfun, visited, pending,
                                  data);
@@ -3714,11 +3709,11 @@ hybrid_search_sbitmap (block, in, out, gen, kill, dir,
      void *data;
 {
   int changed;
-  int i = block->sindex;
+  int i = block->index;
   edge e;
-  basic_block bb = block;
-  SET_BIT (visited, block->sindex);
-  if (TEST_BIT (pending, block->sindex))
+  basic_block bb= block;
+  SET_BIT (visited, block->index);
+  if (TEST_BIT (pending, block->index))
     {
       if (dir == FORWARD)
        {
@@ -3731,10 +3726,10 @@ hybrid_search_sbitmap (block, in, out, gen, kill, dir,
              switch (conf_op)
                {
                case UNION:
-                 sbitmap_a_or_b (in[i], in[i], out[e->src->sindex]);
+                 sbitmap_a_or_b (in[i], in[i], out[e->src->index]);
                  break;
                case INTERSECTION:
-                 sbitmap_a_and_b (in[i], in[i], out[e->src->sindex]);
+                 sbitmap_a_and_b (in[i], in[i], out[e->src->index]);
                  break;
                }
            }
@@ -3750,10 +3745,10 @@ hybrid_search_sbitmap (block, in, out, gen, kill, dir,
              switch (conf_op)
                {
                case UNION:
-                 sbitmap_a_or_b (out[i], out[i], in[e->dest->sindex]);
+                 sbitmap_a_or_b (out[i], out[i], in[e->dest->index]);
                  break;
                case INTERSECTION:
-                 sbitmap_a_and_b (out[i], out[i], in[e->dest->sindex]);
+                 sbitmap_a_and_b (out[i], out[i], in[e->dest->index]);
                  break;
                }
            }
@@ -3767,18 +3762,18 @@ hybrid_search_sbitmap (block, in, out, gen, kill, dir,
            {
              for (e = bb->succ; e != 0; e = e->succ_next)
                {
-                 if (e->dest == EXIT_BLOCK_PTR || e->dest == block)
+                 if (e->dest == EXIT_BLOCK_PTR || e->dest->index == i)
                    continue;
-                 SET_BIT (pending, e->dest->sindex);
+                 SET_BIT (pending, e->dest->index);
                }
            }
          else
            {
              for (e = bb->pred; e != 0; e = e->pred_next)
                {
-                 if (e->src == ENTRY_BLOCK_PTR || e->dest == block)
+                 if (e->src == ENTRY_BLOCK_PTR || e->dest->index == i)
                    continue;
-                 SET_BIT (pending, e->src->sindex);
+                 SET_BIT (pending, e->src->index);
                }
            }
        }
@@ -3787,9 +3782,9 @@ hybrid_search_sbitmap (block, in, out, gen, kill, dir,
     {
       for (e = bb->succ; e != 0; e = e->succ_next)
        {
-         if (e->dest == EXIT_BLOCK_PTR || e->dest == block)
+         if (e->dest == EXIT_BLOCK_PTR || e->dest->index == i)
            continue;
-         if (!TEST_BIT (visited, e->dest->sindex))
+         if (!TEST_BIT (visited, e->dest->index))
            hybrid_search_sbitmap (e->dest, in, out, gen, kill, dir,
                                   conf_op, transfun, visited, pending,
                                   data);
@@ -3799,9 +3794,9 @@ hybrid_search_sbitmap (block, in, out, gen, kill, dir,
     {
       for (e = bb->pred; e != 0; e = e->pred_next)
        {
-         if (e->src == ENTRY_BLOCK_PTR || e->src == block)
+         if (e->src == ENTRY_BLOCK_PTR || e->src->index == i)
            continue;
-         if (!TEST_BIT (visited, e->src->sindex))
+         if (!TEST_BIT (visited, e->src->index))
            hybrid_search_sbitmap (e->src, in, out, gen, kill, dir,
                                   conf_op, transfun, visited, pending,
                                   data);
@@ -3867,7 +3862,7 @@ iterative_dataflow_sbitmap (in, out, gen, kill, blocks,
        {
          i = (size_t) fibheap_extract_min (worklist);
          bb = BASIC_BLOCK (i);
-         if (!TEST_BIT (visited, bb->sindex))
+         if (!TEST_BIT (visited, bb->index))
            hybrid_search_sbitmap (bb, in, out, gen, kill, dir,
                                   conf_op, transfun, visited, pending, data);
        }
@@ -3926,7 +3921,7 @@ iterative_dataflow_bitmap (in, out, gen, kill, blocks,
        {
          i = (size_t) fibheap_extract_min (worklist);
          bb = BASIC_BLOCK (i);
-         if (!TEST_BIT (visited, bb->sindex))
+         if (!TEST_BIT (visited, bb->index))
            hybrid_search_bitmap (bb, in, out, gen, kill, dir,
                                  conf_op, transfun, visited, pending, data);
        }
About OSDN
Find Software
Develop Software
Help