OSDN Git Service

* lcm.c: Move all mode-switching related functions from here...
[pf3gnuchains/gcc-fork.git] / gcc / lcm.c
index 210e4d6..330068e 100644 (file)
--- a/gcc/lcm.c
+++ b/gcc/lcm.c
@@ -809,676 +809,3 @@ pre_edge_rev_lcm (FILE *file ATTRIBUTE_UNUSED, int n_exprs, sbitmap *transp,
   return edge_list;
 }
 
-/* Mode switching:
-
-   The algorithm for setting the modes consists of scanning the insn list
-   and finding all the insns which require a specific mode.  Each insn gets
-   a unique struct seginfo element.  These structures are inserted into a list
-   for each basic block.  For each entity, there is an array of bb_info over
-   the flow graph basic blocks (local var 'bb_info'), and contains a list
-   of all insns within that basic block, in the order they are encountered.
-
-   For each entity, any basic block WITHOUT any insns requiring a specific
-   mode are given a single entry, without a mode.  (Each basic block
-   in the flow graph must have at least one entry in the segment table.)
-
-   The LCM algorithm is then run over the flow graph to determine where to
-   place the sets to the highest-priority value in respect of first the first
-   insn in any one block.  Any adjustments required to the transparency
-   vectors are made, then the next iteration starts for the next-lower
-   priority mode, till for each entity all modes are exhausted.
-
-   More details are located in the code for optimize_mode_switching().  */
-
-/* This structure contains the information for each insn which requires
-   either single or double mode to be set.
-   MODE is the mode this insn must be executed in.
-   INSN_PTR is the insn to be executed (may be the note that marks the
-   beginning of a basic block).
-   BBNUM is the flow graph basic block this insn occurs in.
-   NEXT is the next insn in the same basic block.  */
-struct seginfo
-{
-  int mode;
-  rtx insn_ptr;
-  int bbnum;
-  struct seginfo *next;
-  HARD_REG_SET regs_live;
-};
-
-struct bb_info
-{
-  struct seginfo *seginfo;
-  int computing;
-};
-
-/* These bitmaps are used for the LCM algorithm.  */
-
-#ifdef OPTIMIZE_MODE_SWITCHING
-static sbitmap *antic;
-static sbitmap *transp;
-static sbitmap *comp;
-
-static struct seginfo * new_seginfo (int, rtx, int, HARD_REG_SET);
-static void add_seginfo (struct bb_info *, struct seginfo *);
-static void reg_dies (rtx, HARD_REG_SET);
-static void reg_becomes_live (rtx, rtx, void *);
-static void make_preds_opaque (basic_block, int);
-#endif
-\f
-#ifdef OPTIMIZE_MODE_SWITCHING
-
-/* This function will allocate a new BBINFO structure, initialized
-   with the MODE, INSN, and basic block BB parameters.  */
-
-static struct seginfo *
-new_seginfo (int mode, rtx insn, int bb, HARD_REG_SET regs_live)
-{
-  struct seginfo *ptr;
-  ptr = xmalloc (sizeof (struct seginfo));
-  ptr->mode = mode;
-  ptr->insn_ptr = insn;
-  ptr->bbnum = bb;
-  ptr->next = NULL;
-  COPY_HARD_REG_SET (ptr->regs_live, regs_live);
-  return ptr;
-}
-
-/* Add a seginfo element to the end of a list.
-   HEAD is a pointer to the list beginning.
-   INFO is the structure to be linked in.  */
-
-static void
-add_seginfo (struct bb_info *head, struct seginfo *info)
-{
-  struct seginfo *ptr;
-
-  if (head->seginfo == NULL)
-    head->seginfo = info;
-  else
-    {
-      ptr = head->seginfo;
-      while (ptr->next != NULL)
-       ptr = ptr->next;
-      ptr->next = info;
-    }
-}
-
-/* Make all predecessors of basic block B opaque, recursively, till we hit
-   some that are already non-transparent, or an edge where aux is set; that
-   denotes that a mode set is to be done on that edge.
-   J is the bit number in the bitmaps that corresponds to the entity that
-   we are currently handling mode-switching for.  */
-
-static void
-make_preds_opaque (basic_block b, int j)
-{
-  edge e;
-  edge_iterator ei;
-
-  FOR_EACH_EDGE (e, ei, b->preds)
-    {
-      basic_block pb = e->src;
-
-      if (e->aux || ! TEST_BIT (transp[pb->index], j))
-       continue;
-
-      RESET_BIT (transp[pb->index], j);
-      make_preds_opaque (pb, j);
-    }
-}
-
-/* Record in LIVE that register REG died.  */
-
-static void
-reg_dies (rtx reg, HARD_REG_SET live)
-{
-  int regno, nregs;
-
-  if (!REG_P (reg))
-    return;
-
-  regno = REGNO (reg);
-  if (regno < FIRST_PSEUDO_REGISTER)
-    for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
-        nregs--)
-      CLEAR_HARD_REG_BIT (live, regno + nregs);
-}
-
-/* Record in LIVE that register REG became live.
-   This is called via note_stores.  */
-
-static void
-reg_becomes_live (rtx reg, rtx setter ATTRIBUTE_UNUSED, void *live)
-{
-  int regno, nregs;
-
-  if (GET_CODE (reg) == SUBREG)
-    reg = SUBREG_REG (reg);
-
-  if (!REG_P (reg))
-    return;
-
-  regno = REGNO (reg);
-  if (regno < FIRST_PSEUDO_REGISTER)
-    for (nregs = hard_regno_nregs[regno][GET_MODE (reg)] - 1; nregs >= 0;
-        nregs--)
-      SET_HARD_REG_BIT (* (HARD_REG_SET *) live, regno + nregs);
-}
-
-/* Make sure if MODE_ENTRY is defined the MODE_EXIT is defined
-   and vice versa.  */
-#if defined (MODE_ENTRY) != defined (MODE_EXIT)
- #error "Both MODE_ENTRY and MODE_EXIT must be defined"
-#endif
-
-#if defined (MODE_ENTRY) && defined (MODE_EXIT)
-/* Split the fallthrough edge to the exit block, so that we can note
-   that there NORMAL_MODE is required.  Return the new block if it's
-   inserted before the exit block.  Otherwise return null.  */
-
-static basic_block
-create_pre_exit (int n_entities, int *entity_map, const int *num_modes)
-{
-  edge eg;
-  edge_iterator ei;
-  basic_block pre_exit;
-
-  /* The only non-call predecessor at this stage is a block with a
-     fallthrough edge; there can be at most one, but there could be
-     none at all, e.g. when exit is called.  */
-  pre_exit = 0;
-  FOR_EACH_EDGE (eg, ei, EXIT_BLOCK_PTR->preds)
-    if (eg->flags & EDGE_FALLTHRU)
-      {
-       basic_block src_bb = eg->src;
-       regset live_at_end = src_bb->global_live_at_end;
-       rtx last_insn, ret_reg;
-
-       gcc_assert (!pre_exit);
-       /* If this function returns a value at the end, we have to
-          insert the final mode switch before the return value copy
-          to its hard register.  */
-       if (EDGE_COUNT (EXIT_BLOCK_PTR->preds) == 1
-           && NONJUMP_INSN_P ((last_insn = BB_END (src_bb)))
-           && GET_CODE (PATTERN (last_insn)) == USE
-           && GET_CODE ((ret_reg = XEXP (PATTERN (last_insn), 0))) == REG)
-         {
-           int ret_start = REGNO (ret_reg);
-           int nregs = hard_regno_nregs[ret_start][GET_MODE (ret_reg)];
-           int ret_end = ret_start + nregs;
-           int short_block = 0;
-           int maybe_builtin_apply = 0;
-           int forced_late_switch = 0;
-           rtx before_return_copy;
-
-           do
-             {
-               rtx return_copy = PREV_INSN (last_insn);
-               rtx return_copy_pat, copy_reg;
-               int copy_start, copy_num;
-               int j;
-
-               if (INSN_P (return_copy))
-                 {
-                   if (GET_CODE (PATTERN (return_copy)) == USE
-                       && GET_CODE (XEXP (PATTERN (return_copy), 0)) == REG
-                       && (FUNCTION_VALUE_REGNO_P
-                           (REGNO (XEXP (PATTERN (return_copy), 0)))))
-                     {
-                       maybe_builtin_apply = 1;
-                       last_insn = return_copy;
-                       continue;
-                     }
-                   /* If the return register is not (in its entirety)
-                      likely spilled, the return copy might be
-                      partially or completely optimized away.  */
-                   return_copy_pat = single_set (return_copy);
-                   if (!return_copy_pat)
-                     {
-                       return_copy_pat = PATTERN (return_copy);
-                       if (GET_CODE (return_copy_pat) != CLOBBER)
-                         break;
-                     }
-                   copy_reg = SET_DEST (return_copy_pat);
-                   if (GET_CODE (copy_reg) == REG)
-                     copy_start = REGNO (copy_reg);
-                   else if (GET_CODE (copy_reg) == SUBREG
-                            && GET_CODE (SUBREG_REG (copy_reg)) == REG)
-                     copy_start = REGNO (SUBREG_REG (copy_reg));
-                   else
-                     break;
-                   if (copy_start >= FIRST_PSEUDO_REGISTER)
-                     break;
-                   copy_num
-                     = hard_regno_nregs[copy_start][GET_MODE (copy_reg)];
-
-                   /* If the return register is not likely spilled, - as is
-                      the case for floating point on SH4 - then it might
-                      be set by an arithmetic operation that needs a
-                      different mode than the exit block.  */
-                   for (j = n_entities - 1; j >= 0; j--)
-                     {
-                       int e = entity_map[j];
-                       int mode = MODE_NEEDED (e, return_copy);
-
-                       if (mode != num_modes[e] && mode != MODE_EXIT (e))
-                         break;
-                     }
-                   if (j >= 0)
-                     {
-                       /* For the SH4, floating point loads depend on fpscr,
-                          thus we might need to put the final mode switch
-                          after the return value copy.  That is still OK,
-                          because a floating point return value does not
-                          conflict with address reloads.  */
-                       if (copy_start >= ret_start
-                           && copy_start + copy_num <= ret_end
-                           && OBJECT_P (SET_SRC (return_copy_pat)))
-                         forced_late_switch = 1;
-                       break;
-                     }
-
-                   if (copy_start >= ret_start
-                       && copy_start + copy_num <= ret_end)
-                     nregs -= copy_num;
-                   else if (!maybe_builtin_apply
-                            || !FUNCTION_VALUE_REGNO_P (copy_start))
-                     break;
-                   last_insn = return_copy;
-                 }
-               /* ??? Exception handling can lead to the return value
-                  copy being already separated from the return value use,
-                  as in  unwind-dw2.c .
-                  Similarly, conditionally returning without a value,
-                  and conditionally using builtin_return can lead to an
-                  isolated use.  */
-               if (return_copy == BB_HEAD (src_bb))
-                 {
-                   short_block = 1;
-                   break;
-                 }
-               last_insn = return_copy;
-             }
-           while (nregs);
-           
-           /* If we didn't see a full return value copy, verify that there
-              is a plausible reason for this.  If some, but not all of the
-              return register is likely spilled, we can expect that there
-              is a copy for the likely spilled part.  */
-           gcc_assert (!nregs
-                       || forced_late_switch
-                       || short_block
-                       || !(CLASS_LIKELY_SPILLED_P
-                            (REGNO_REG_CLASS (ret_start)))
-                       || (nregs
-                           != hard_regno_nregs[ret_start][GET_MODE (ret_reg)])
-                       /* For multi-hard-register floating point
-                          values, sometimes the likely-spilled part
-                          is ordinarily copied first, then the other
-                          part is set with an arithmetic operation.
-                          This doesn't actually cause reload
-                          failures, so let it pass.  */
-                       || (GET_MODE_CLASS (GET_MODE (ret_reg)) != MODE_INT
-                           && nregs != 1));
-           
-           if (INSN_P (last_insn))
-             {
-               before_return_copy
-                 = emit_note_before (NOTE_INSN_DELETED, last_insn);
-               /* Instructions preceding LAST_INSN in the same block might
-                  require a different mode than MODE_EXIT, so if we might
-                  have such instructions, keep them in a separate block
-                  from pre_exit.  */
-               if (last_insn != BB_HEAD (src_bb))
-                 src_bb = split_block (src_bb,
-                                       PREV_INSN (before_return_copy))->dest;
-             }
-           else
-             before_return_copy = last_insn;
-           pre_exit = split_block (src_bb, before_return_copy)->src;
-         }
-       else
-         {
-           pre_exit = split_edge (eg);
-           COPY_REG_SET (pre_exit->global_live_at_start, live_at_end);
-           COPY_REG_SET (pre_exit->global_live_at_end, live_at_end);
-         }
-      }
-
-  return pre_exit;
-}
-#endif
-
-/* Find all insns that need a particular mode setting, and insert the
-   necessary mode switches.  Return true if we did work.  */
-
-int
-optimize_mode_switching (FILE *file)
-{
-  rtx insn;
-  int e;
-  basic_block bb;
-  int need_commit = 0;
-  sbitmap *kill;
-  struct edge_list *edge_list;
-  static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING;
-#define N_ENTITIES ARRAY_SIZE (num_modes)
-  int entity_map[N_ENTITIES];
-  struct bb_info *bb_info[N_ENTITIES];
-  int i, j;
-  int n_entities;
-  int max_num_modes = 0;
-  bool emited = false;
-  basic_block post_entry ATTRIBUTE_UNUSED, pre_exit ATTRIBUTE_UNUSED;
-
-  clear_bb_flags ();
-
-  for (e = N_ENTITIES - 1, n_entities = 0; e >= 0; e--)
-    if (OPTIMIZE_MODE_SWITCHING (e))
-      {
-       int entry_exit_extra = 0;
-
-       /* Create the list of segments within each basic block.
-          If NORMAL_MODE is defined, allow for two extra
-          blocks split from the entry and exit block.  */
-#if defined (MODE_ENTRY) && defined (MODE_EXIT)
-       entry_exit_extra = 3;
-#endif
-       bb_info[n_entities]
-         = xcalloc (last_basic_block + entry_exit_extra, sizeof **bb_info);
-       entity_map[n_entities++] = e;
-       if (num_modes[e] > max_num_modes)
-         max_num_modes = num_modes[e];
-      }
-
-  if (! n_entities)
-    return 0;
-
-#if defined (MODE_ENTRY) && defined (MODE_EXIT)
-  /* Split the edge from the entry block, so that we can note that
-     there NORMAL_MODE is supplied.  */
-  post_entry = split_edge (single_succ_edge (ENTRY_BLOCK_PTR));
-  pre_exit = create_pre_exit (n_entities, entity_map, num_modes);
-#endif
-
-  /* Create the bitmap vectors.  */
-
-  antic = sbitmap_vector_alloc (last_basic_block, n_entities);
-  transp = sbitmap_vector_alloc (last_basic_block, n_entities);
-  comp = sbitmap_vector_alloc (last_basic_block, n_entities);
-
-  sbitmap_vector_ones (transp, last_basic_block);
-
-  for (j = n_entities - 1; j >= 0; j--)
-    {
-      int e = entity_map[j];
-      int no_mode = num_modes[e];
-      struct bb_info *info = bb_info[j];
-
-      /* Determine what the first use (if any) need for a mode of entity E is.
-        This will be the mode that is anticipatable for this block.
-        Also compute the initial transparency settings.  */
-      FOR_EACH_BB (bb)
-       {
-         struct seginfo *ptr;
-         int last_mode = no_mode;
-         HARD_REG_SET live_now;
-
-         REG_SET_TO_HARD_REG_SET (live_now,
-                                  bb->global_live_at_start);
-         for (insn = BB_HEAD (bb);
-              insn != NULL && insn != NEXT_INSN (BB_END (bb));
-              insn = NEXT_INSN (insn))
-           {
-             if (INSN_P (insn))
-               {
-                 int mode = MODE_NEEDED (e, insn);
-                 rtx link;
-
-                 if (mode != no_mode && mode != last_mode)
-                   {
-                     last_mode = mode;
-                     ptr = new_seginfo (mode, insn, bb->index, live_now);
-                     add_seginfo (info + bb->index, ptr);
-                     RESET_BIT (transp[bb->index], j);
-                   }
-#ifdef MODE_AFTER
-                 last_mode = MODE_AFTER (last_mode, insn);
-#endif
-                 /* Update LIVE_NOW.  */
-                 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
-                   if (REG_NOTE_KIND (link) == REG_DEAD)
-                     reg_dies (XEXP (link, 0), live_now);
-
-                 note_stores (PATTERN (insn), reg_becomes_live, &live_now);
-                 for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
-                   if (REG_NOTE_KIND (link) == REG_UNUSED)
-                     reg_dies (XEXP (link, 0), live_now);
-               }
-           }
-
-         info[bb->index].computing = last_mode;
-         /* Check for blocks without ANY mode requirements.  */
-         if (last_mode == no_mode)
-           {
-             ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now);
-             add_seginfo (info + bb->index, ptr);
-           }
-       }
-#if defined (MODE_ENTRY) && defined (MODE_EXIT)
-      {
-       int mode = MODE_ENTRY (e);
-
-       if (mode != no_mode)
-         {
-           bb = post_entry;
-
-           /* By always making this nontransparent, we save
-              an extra check in make_preds_opaque.  We also
-              need this to avoid confusing pre_edge_lcm when
-              antic is cleared but transp and comp are set.  */
-           RESET_BIT (transp[bb->index], j);
-
-           /* Insert a fake computing definition of MODE into entry
-              blocks which compute no mode. This represents the mode on
-              entry.  */
-           info[bb->index].computing = mode;
-
-           if (pre_exit)
-             info[pre_exit->index].seginfo->mode = MODE_EXIT (e);
-         }
-      }
-#endif /* NORMAL_MODE */
-    }
-
-  kill = sbitmap_vector_alloc (last_basic_block, n_entities);
-  for (i = 0; i < max_num_modes; i++)
-    {
-      int current_mode[N_ENTITIES];
-      sbitmap *delete;
-      sbitmap *insert;
-
-      /* Set the anticipatable and computing arrays.  */
-      sbitmap_vector_zero (antic, last_basic_block);
-      sbitmap_vector_zero (comp, last_basic_block);
-      for (j = n_entities - 1; j >= 0; j--)
-       {
-         int m = current_mode[j] = MODE_PRIORITY_TO_MODE (entity_map[j], i);
-         struct bb_info *info = bb_info[j];
-
-         FOR_EACH_BB (bb)
-           {
-             if (info[bb->index].seginfo->mode == m)
-               SET_BIT (antic[bb->index], j);
-
-             if (info[bb->index].computing == m)
-               SET_BIT (comp[bb->index], j);
-           }
-       }
-
-      /* Calculate the optimal locations for the
-        placement mode switches to modes with priority I.  */
-
-      FOR_EACH_BB (bb)
-       sbitmap_not (kill[bb->index], transp[bb->index]);
-      edge_list = pre_edge_lcm (file, 1, transp, comp, antic,
-                               kill, &insert, &delete);
-
-      for (j = n_entities - 1; j >= 0; j--)
-       {
-         /* Insert all mode sets that have been inserted by lcm.  */
-         int no_mode = num_modes[entity_map[j]];
-
-         /* Wherever we have moved a mode setting upwards in the flow graph,
-            the blocks between the new setting site and the now redundant
-            computation ceases to be transparent for any lower-priority
-            mode of the same entity.  First set the aux field of each
-            insertion site edge non-transparent, then propagate the new
-            non-transparency from the redundant computation upwards till
-            we hit an insertion site or an already non-transparent block.  */
-         for (e = NUM_EDGES (edge_list) - 1; e >= 0; e--)
-           {
-             edge eg = INDEX_EDGE (edge_list, e);
-             int mode;
-             basic_block src_bb;
-             HARD_REG_SET live_at_edge;
-             rtx mode_set;
-
-             eg->aux = 0;
-
-             if (! TEST_BIT (insert[e], j))
-               continue;
-
-             eg->aux = (void *)1;
-
-             mode = current_mode[j];
-             src_bb = eg->src;
-
-             REG_SET_TO_HARD_REG_SET (live_at_edge,
-                                      src_bb->global_live_at_end);
-
-             start_sequence ();
-             EMIT_MODE_SET (entity_map[j], mode, live_at_edge);
-             mode_set = get_insns ();
-             end_sequence ();
-
-             /* Do not bother to insert empty sequence.  */
-             if (mode_set == NULL_RTX)
-               continue;
-
-             /* If this is an abnormal edge, we'll insert at the end
-                of the previous block.  */
-             if (eg->flags & EDGE_ABNORMAL)
-               {
-                 emited = true;
-                 if (JUMP_P (BB_END (src_bb)))
-                   emit_insn_before (mode_set, BB_END (src_bb));
-                 else
-                   {
-                     /* It doesn't make sense to switch to normal
-                        mode after a CALL_INSN.  The cases in which a
-                        CALL_INSN may have an abnormal edge are
-                        sibcalls and EH edges.  In the case of
-                        sibcalls, the dest basic-block is the
-                        EXIT_BLOCK, that runs in normal mode; it is
-                        assumed that a sibcall insn requires normal
-                        mode itself, so no mode switch would be
-                        required after the call (it wouldn't make
-                        sense, anyway).  In the case of EH edges, EH
-                        entry points also start in normal mode, so a
-                        similar reasoning applies.  */
-                     gcc_assert (NONJUMP_INSN_P (BB_END (src_bb)));
-                     emit_insn_after (mode_set, BB_END (src_bb));
-                   }
-                 bb_info[j][src_bb->index].computing = mode;
-                 RESET_BIT (transp[src_bb->index], j);
-               }
-             else
-               {
-                 need_commit = 1;
-                 insert_insn_on_edge (mode_set, eg);
-               }
-           }
-
-         FOR_EACH_BB_REVERSE (bb)
-           if (TEST_BIT (delete[bb->index], j))
-             {
-               make_preds_opaque (bb, j);
-               /* Cancel the 'deleted' mode set.  */
-               bb_info[j][bb->index].seginfo->mode = no_mode;
-             }
-       }
-
-      sbitmap_vector_free (delete);
-      sbitmap_vector_free (insert);
-      clear_aux_for_edges ();
-      free_edge_list (edge_list);
-    }
-
-  /* Now output the remaining mode sets in all the segments.  */
-  for (j = n_entities - 1; j >= 0; j--)
-    {
-      int no_mode = num_modes[entity_map[j]];
-
-      FOR_EACH_BB_REVERSE (bb)
-       {
-         struct seginfo *ptr, *next;
-         for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next)
-           {
-             next = ptr->next;
-             if (ptr->mode != no_mode)
-               {
-                 rtx mode_set;
-
-                 start_sequence ();
-                 EMIT_MODE_SET (entity_map[j], ptr->mode, ptr->regs_live);
-                 mode_set = get_insns ();
-                 end_sequence ();
-
-                 /* Insert MODE_SET only if it is nonempty.  */
-                 if (mode_set != NULL_RTX)
-                   {
-                     emited = true;
-                     if (NOTE_P (ptr->insn_ptr)
-                         && (NOTE_LINE_NUMBER (ptr->insn_ptr)
-                             == NOTE_INSN_BASIC_BLOCK))
-                       emit_insn_after (mode_set, ptr->insn_ptr);
-                     else
-                       emit_insn_before (mode_set, ptr->insn_ptr);
-                   }
-               }
-
-             free (ptr);
-           }
-       }
-
-      free (bb_info[j]);
-    }
-
-  /* Finished. Free up all the things we've allocated.  */
-
-  sbitmap_vector_free (kill);
-  sbitmap_vector_free (antic);
-  sbitmap_vector_free (transp);
-  sbitmap_vector_free (comp);
-
-  if (need_commit)
-    commit_edge_insertions ();
-
-#if defined (MODE_ENTRY) && defined (MODE_EXIT)
-  cleanup_cfg (CLEANUP_NO_INSN_DEL);
-#else
-  if (!need_commit && !emited)
-    return 0;
-#endif
-
-  max_regno = max_reg_num ();
-  allocate_reg_info (max_regno, FALSE, FALSE);
-  update_life_info_in_dirty_blocks (UPDATE_LIFE_GLOBAL_RM_NOTES,
-                                   (PROP_DEATH_NOTES | PROP_KILL_DEAD_CODE
-                                    | PROP_SCAN_DEAD_CODE));
-
-  return 1;
-}
-#endif /* OPTIMIZE_MODE_SWITCHING */