Merge branch 'vendor/GCC50' - gcc 5.0 snapshot 1 FEB 2015
[dragonfly.git] / contrib / gcc-5.0 / gcc / mode-switching.c
1 /* CPU mode switching
2    Copyright (C) 1998-2015 Free Software Foundation, Inc.
3
4 This file is part of GCC.
5
6 GCC is free software; you can redistribute it and/or modify it under
7 the terms of the GNU General Public License as published by the Free
8 Software Foundation; either version 3, or (at your option) any later
9 version.
10
11 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
12 WARRANTY; without even the implied warranty of MERCHANTABILITY or
13 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
14 for more details.
15
16 You should have received a copy of the GNU General Public License
17 along with GCC; see the file COPYING3.  If not see
18 <http://www.gnu.org/licenses/>.  */
19
20 #include "config.h"
21 #include "system.h"
22 #include "coretypes.h"
23 #include "tm.h"
24 #include "target.h"
25 #include "rtl.h"
26 #include "regs.h"
27 #include "hard-reg-set.h"
28 #include "flags.h"
29 #include "insn-config.h"
30 #include "recog.h"
31 #include "predict.h"
32 #include "vec.h"
33 #include "hashtab.h"
34 #include "hash-set.h"
35 #include "machmode.h"
36 #include "input.h"
37 #include "function.h"
38 #include "dominance.h"
39 #include "cfg.h"
40 #include "cfgrtl.h"
41 #include "cfganal.h"
42 #include "lcm.h"
43 #include "cfgcleanup.h"
44 #include "basic-block.h"
45 #include "tm_p.h"
46 #include "tree-pass.h"
47 #include "df.h"
48 #include "emit-rtl.h"
49
50 /* We want target macros for the mode switching code to be able to refer
51    to instruction attribute values.  */
52 #include "insn-attr.h"
53
54 #ifdef OPTIMIZE_MODE_SWITCHING
55
56 /* The algorithm for setting the modes consists of scanning the insn list
57    and finding all the insns which require a specific mode.  Each insn gets
58    a unique struct seginfo element.  These structures are inserted into a list
59    for each basic block.  For each entity, there is an array of bb_info over
60    the flow graph basic blocks (local var 'bb_info'), which contains a list
61    of all insns within that basic block, in the order they are encountered.
62
63    For each entity, any basic block WITHOUT any insns requiring a specific
64    mode are given a single entry without a mode (each basic block in the
65    flow graph must have at least one entry in the segment table).
66
67    The LCM algorithm is then run over the flow graph to determine where to
68    place the sets to the highest-priority mode with respect to the first
69    insn in any one block.  Any adjustments required to the transparency
70    vectors are made, then the next iteration starts for the next-lower
71    priority mode, till for each entity all modes are exhausted.
72
73    More details can be found in the code of optimize_mode_switching.  */
74 \f
75 /* This structure contains the information for each insn which requires
76    either single or double mode to be set.
77    MODE is the mode this insn must be executed in.
78    INSN_PTR is the insn to be executed (may be the note that marks the
79    beginning of a basic block).
80    BBNUM is the flow graph basic block this insn occurs in.
81    NEXT is the next insn in the same basic block.  */
82 struct seginfo
83 {
84   int mode;
85   rtx_insn *insn_ptr;
86   int bbnum;
87   struct seginfo *next;
88   HARD_REG_SET regs_live;
89 };
90
91 struct bb_info
92 {
93   struct seginfo *seginfo;
94   int computing;
95   int mode_out;
96   int mode_in;
97 };
98
99 static struct seginfo * new_seginfo (int, rtx_insn *, int, HARD_REG_SET);
100 static void add_seginfo (struct bb_info *, struct seginfo *);
101 static void reg_dies (rtx, HARD_REG_SET *);
102 static void reg_becomes_live (rtx, const_rtx, void *);
103
104 /* Clear ode I from entity J in bitmap B.  */
105 #define clear_mode_bit(b, j, i) \
106        bitmap_clear_bit (b, (j * max_num_modes) + i)
107
108 /* Test mode I from entity J in bitmap B.  */
109 #define mode_bit_p(b, j, i) \
110        bitmap_bit_p (b, (j * max_num_modes) + i)
111
112 /* Set mode I from entity J in bitmal B.  */
113 #define set_mode_bit(b, j, i) \
114        bitmap_set_bit (b, (j * max_num_modes) + i)
115
116 /* Emit modes segments from EDGE_LIST associated with entity E.
117    INFO gives mode availability for each mode.  */
118
119 static bool
120 commit_mode_sets (struct edge_list *edge_list, int e, struct bb_info *info)
121 {
122   bool need_commit = false;
123
124   for (int ed = NUM_EDGES (edge_list) - 1; ed >= 0; ed--)
125     {
126       edge eg = INDEX_EDGE (edge_list, ed);
127       int mode;
128
129       if ((mode = (int)(intptr_t)(eg->aux)) != -1)
130         {
131           HARD_REG_SET live_at_edge;
132           basic_block src_bb = eg->src;
133           int cur_mode = info[src_bb->index].mode_out;
134           rtx mode_set;
135
136           REG_SET_TO_HARD_REG_SET (live_at_edge, df_get_live_out (src_bb));
137
138           rtl_profile_for_edge (eg);
139           start_sequence ();
140
141           targetm.mode_switching.emit (e, mode, cur_mode, live_at_edge);
142
143           mode_set = get_insns ();
144           end_sequence ();
145           default_rtl_profile ();
146
147           /* Do not bother to insert empty sequence.  */
148           if (mode_set == NULL_RTX)
149             continue;
150
151           /* We should not get an abnormal edge here.  */
152           gcc_assert (! (eg->flags & EDGE_ABNORMAL));
153
154           need_commit = true;
155           insert_insn_on_edge (mode_set, eg);
156         }
157     }
158
159   return need_commit;
160 }
161
162 /* Allocate a new BBINFO structure, initialized with the MODE, INSN,
163    and basic block BB parameters.
164    INSN may not be a NOTE_INSN_BASIC_BLOCK, unless it is an empty
165    basic block; that allows us later to insert instructions in a FIFO-like
166    manner.  */
167
168 static struct seginfo *
169 new_seginfo (int mode, rtx_insn *insn, int bb, HARD_REG_SET regs_live)
170 {
171   struct seginfo *ptr;
172
173   gcc_assert (!NOTE_INSN_BASIC_BLOCK_P (insn)
174               || insn == BB_END (NOTE_BASIC_BLOCK (insn)));
175   ptr = XNEW (struct seginfo);
176   ptr->mode = mode;
177   ptr->insn_ptr = insn;
178   ptr->bbnum = bb;
179   ptr->next = NULL;
180   COPY_HARD_REG_SET (ptr->regs_live, regs_live);
181   return ptr;
182 }
183
184 /* Add a seginfo element to the end of a list.
185    HEAD is a pointer to the list beginning.
186    INFO is the structure to be linked in.  */
187
188 static void
189 add_seginfo (struct bb_info *head, struct seginfo *info)
190 {
191   struct seginfo *ptr;
192
193   if (head->seginfo == NULL)
194     head->seginfo = info;
195   else
196     {
197       ptr = head->seginfo;
198       while (ptr->next != NULL)
199         ptr = ptr->next;
200       ptr->next = info;
201     }
202 }
203
204 /* Record in LIVE that register REG died.  */
205
206 static void
207 reg_dies (rtx reg, HARD_REG_SET *live)
208 {
209   int regno;
210
211   if (!REG_P (reg))
212     return;
213
214   regno = REGNO (reg);
215   if (regno < FIRST_PSEUDO_REGISTER)
216     remove_from_hard_reg_set (live, GET_MODE (reg), regno);
217 }
218
219 /* Record in LIVE that register REG became live.
220    This is called via note_stores.  */
221
222 static void
223 reg_becomes_live (rtx reg, const_rtx setter ATTRIBUTE_UNUSED, void *live)
224 {
225   int regno;
226
227   if (GET_CODE (reg) == SUBREG)
228     reg = SUBREG_REG (reg);
229
230   if (!REG_P (reg))
231     return;
232
233   regno = REGNO (reg);
234   if (regno < FIRST_PSEUDO_REGISTER)
235     add_to_hard_reg_set ((HARD_REG_SET *) live, GET_MODE (reg), regno);
236 }
237
238 /* Split the fallthrough edge to the exit block, so that we can note
239    that there NORMAL_MODE is required.  Return the new block if it's
240    inserted before the exit block.  Otherwise return null.  */
241
242 static basic_block
243 create_pre_exit (int n_entities, int *entity_map, const int *num_modes)
244 {
245   edge eg;
246   edge_iterator ei;
247   basic_block pre_exit;
248
249   /* The only non-call predecessor at this stage is a block with a
250      fallthrough edge; there can be at most one, but there could be
251      none at all, e.g. when exit is called.  */
252   pre_exit = 0;
253   FOR_EACH_EDGE (eg, ei, EXIT_BLOCK_PTR_FOR_FN (cfun)->preds)
254     if (eg->flags & EDGE_FALLTHRU)
255       {
256         basic_block src_bb = eg->src;
257         rtx_insn *last_insn;
258         rtx ret_reg;
259
260         gcc_assert (!pre_exit);
261         /* If this function returns a value at the end, we have to
262            insert the final mode switch before the return value copy
263            to its hard register.  */
264         if (EDGE_COUNT (EXIT_BLOCK_PTR_FOR_FN (cfun)->preds) == 1
265             && NONJUMP_INSN_P ((last_insn = BB_END (src_bb)))
266             && GET_CODE (PATTERN (last_insn)) == USE
267             && GET_CODE ((ret_reg = XEXP (PATTERN (last_insn), 0))) == REG)
268           {
269             int ret_start = REGNO (ret_reg);
270             int nregs = hard_regno_nregs[ret_start][GET_MODE (ret_reg)];
271             int ret_end = ret_start + nregs;
272             bool short_block = false;
273             bool multi_reg_return = false;
274             bool forced_late_switch = false;
275             rtx_insn *before_return_copy;
276
277             do
278               {
279                 rtx_insn *return_copy = PREV_INSN (last_insn);
280                 rtx return_copy_pat, copy_reg;
281                 int copy_start, copy_num;
282                 int j;
283
284                 if (NONDEBUG_INSN_P (return_copy))
285                   {
286                     /* When using SJLJ exceptions, the call to the
287                        unregister function is inserted between the
288                        clobber of the return value and the copy.
289                        We do not want to split the block before this
290                        or any other call; if we have not found the
291                        copy yet, the copy must have been deleted.  */
292                     if (CALL_P (return_copy))
293                       {
294                         short_block = true;
295                         break;
296                       }
297                     return_copy_pat = PATTERN (return_copy);
298                     switch (GET_CODE (return_copy_pat))
299                       {
300                       case USE:
301                         /* Skip USEs of multiple return registers.
302                            __builtin_apply pattern is also handled here.  */
303                         if (GET_CODE (XEXP (return_copy_pat, 0)) == REG
304                             && (targetm.calls.function_value_regno_p
305                                 (REGNO (XEXP (return_copy_pat, 0)))))
306                           {
307                             multi_reg_return = true;
308                             last_insn = return_copy;
309                             continue;
310                           }
311                         break;
312
313                       case ASM_OPERANDS:
314                         /* Skip barrier insns.  */
315                         if (!MEM_VOLATILE_P (return_copy_pat))
316                           break;
317
318                         /* Fall through.  */
319
320                       case ASM_INPUT:
321                       case UNSPEC_VOLATILE:
322                         last_insn = return_copy;
323                         continue;
324
325                       default:
326                         break;
327                       }
328
329                     /* If the return register is not (in its entirety)
330                        likely spilled, the return copy might be
331                        partially or completely optimized away.  */
332                     return_copy_pat = single_set (return_copy);
333                     if (!return_copy_pat)
334                       {
335                         return_copy_pat = PATTERN (return_copy);
336                         if (GET_CODE (return_copy_pat) != CLOBBER)
337                           break;
338                         else if (!optimize)
339                           {
340                             /* This might be (clobber (reg [<result>]))
341                                when not optimizing.  Then check if
342                                the previous insn is the clobber for
343                                the return register.  */
344                             copy_reg = SET_DEST (return_copy_pat);
345                             if (GET_CODE (copy_reg) == REG
346                                 && !HARD_REGISTER_NUM_P (REGNO (copy_reg)))
347                               {
348                                 if (INSN_P (PREV_INSN (return_copy)))
349                                   {
350                                     return_copy = PREV_INSN (return_copy);
351                                     return_copy_pat = PATTERN (return_copy);
352                                     if (GET_CODE (return_copy_pat) != CLOBBER)
353                                       break;
354                                   }
355                               }
356                           }
357                       }
358                     copy_reg = SET_DEST (return_copy_pat);
359                     if (GET_CODE (copy_reg) == REG)
360                       copy_start = REGNO (copy_reg);
361                     else if (GET_CODE (copy_reg) == SUBREG
362                              && GET_CODE (SUBREG_REG (copy_reg)) == REG)
363                       copy_start = REGNO (SUBREG_REG (copy_reg));
364                     else
365                       {
366                         /* When control reaches end of non-void function,
367                            there are no return copy insns at all.  This
368                            avoids an ice on that invalid function.  */
369                         if (ret_start + nregs == ret_end)
370                           short_block = true;
371                         break;
372                       }
373                     if (!targetm.calls.function_value_regno_p (copy_start))
374                       copy_num = 0;
375                     else
376                       copy_num
377                         = hard_regno_nregs[copy_start][GET_MODE (copy_reg)];
378
379                     /* If the return register is not likely spilled, - as is
380                        the case for floating point on SH4 - then it might
381                        be set by an arithmetic operation that needs a
382                        different mode than the exit block.  */
383                     for (j = n_entities - 1; j >= 0; j--)
384                       {
385                         int e = entity_map[j];
386                         int mode =
387                           targetm.mode_switching.needed (e, return_copy);
388
389                         if (mode != num_modes[e]
390                             && mode != targetm.mode_switching.exit (e))
391                           break;
392                       }
393                     if (j >= 0)
394                       {
395                         /* __builtin_return emits a sequence of loads to all
396                            return registers.  One of them might require
397                            another mode than MODE_EXIT, even if it is
398                            unrelated to the return value, so we want to put
399                            the final mode switch after it.  */
400                         if (multi_reg_return
401                             && targetm.calls.function_value_regno_p
402                                 (copy_start))
403                           forced_late_switch = true;
404
405                         /* For the SH4, floating point loads depend on fpscr,
406                            thus we might need to put the final mode switch
407                            after the return value copy.  That is still OK,
408                            because a floating point return value does not
409                            conflict with address reloads.  */
410                         if (copy_start >= ret_start
411                             && copy_start + copy_num <= ret_end
412                             && OBJECT_P (SET_SRC (return_copy_pat)))
413                           forced_late_switch = true;
414                         break;
415                       }
416                     if (copy_num == 0)
417                       {
418                         last_insn = return_copy;
419                         continue;
420                       }
421
422                     if (copy_start >= ret_start
423                         && copy_start + copy_num <= ret_end)
424                       nregs -= copy_num;
425                     else if (!multi_reg_return
426                              || !targetm.calls.function_value_regno_p
427                                  (copy_start))
428                       break;
429                     last_insn = return_copy;
430                   }
431                 /* ??? Exception handling can lead to the return value
432                    copy being already separated from the return value use,
433                    as in  unwind-dw2.c .
434                    Similarly, conditionally returning without a value,
435                    and conditionally using builtin_return can lead to an
436                    isolated use.  */
437                 if (return_copy == BB_HEAD (src_bb))
438                   {
439                     short_block = true;
440                     break;
441                   }
442                 last_insn = return_copy;
443               }
444             while (nregs);
445
446             /* If we didn't see a full return value copy, verify that there
447                is a plausible reason for this.  If some, but not all of the
448                return register is likely spilled, we can expect that there
449                is a copy for the likely spilled part.  */
450             gcc_assert (!nregs
451                         || forced_late_switch
452                         || short_block
453                         || !(targetm.class_likely_spilled_p
454                              (REGNO_REG_CLASS (ret_start)))
455                         || (nregs
456                             != hard_regno_nregs[ret_start][GET_MODE (ret_reg)])
457                         /* For multi-hard-register floating point
458                            values, sometimes the likely-spilled part
459                            is ordinarily copied first, then the other
460                            part is set with an arithmetic operation.
461                            This doesn't actually cause reload
462                            failures, so let it pass.  */
463                         || (GET_MODE_CLASS (GET_MODE (ret_reg)) != MODE_INT
464                             && nregs != 1));
465
466             if (!NOTE_INSN_BASIC_BLOCK_P (last_insn))
467               {
468                 before_return_copy
469                   = emit_note_before (NOTE_INSN_DELETED, last_insn);
470                 /* Instructions preceding LAST_INSN in the same block might
471                    require a different mode than MODE_EXIT, so if we might
472                    have such instructions, keep them in a separate block
473                    from pre_exit.  */
474                 src_bb = split_block (src_bb,
475                                       PREV_INSN (before_return_copy))->dest;
476               }
477             else
478               before_return_copy = last_insn;
479             pre_exit = split_block (src_bb, before_return_copy)->src;
480           }
481         else
482           {
483             pre_exit = split_edge (eg);
484           }
485       }
486
487   return pre_exit;
488 }
489
490 /* Find all insns that need a particular mode setting, and insert the
491    necessary mode switches.  Return true if we did work.  */
492
493 static int
494 optimize_mode_switching (void)
495 {
496   int e;
497   basic_block bb;
498   bool need_commit = false;
499   static const int num_modes[] = NUM_MODES_FOR_MODE_SWITCHING;
500 #define N_ENTITIES ARRAY_SIZE (num_modes)
501   int entity_map[N_ENTITIES];
502   struct bb_info *bb_info[N_ENTITIES];
503   int i, j;
504   int n_entities = 0;
505   int max_num_modes = 0;
506   bool emitted ATTRIBUTE_UNUSED = false;
507   basic_block post_entry = 0;
508   basic_block pre_exit = 0;
509   struct edge_list *edge_list = 0;
510
511   /* These bitmaps are used for the LCM algorithm.  */
512   sbitmap *kill, *del, *insert, *antic, *transp, *comp;
513   sbitmap *avin, *avout;
514
515   for (e = N_ENTITIES - 1; e >= 0; e--)
516     if (OPTIMIZE_MODE_SWITCHING (e))
517       {
518         int entry_exit_extra = 0;
519
520         /* Create the list of segments within each basic block.
521            If NORMAL_MODE is defined, allow for two extra
522            blocks split from the entry and exit block.  */
523         if (targetm.mode_switching.entry && targetm.mode_switching.exit)
524           entry_exit_extra = 3;
525
526         bb_info[n_entities]
527           = XCNEWVEC (struct bb_info,
528                       last_basic_block_for_fn (cfun) + entry_exit_extra);
529         entity_map[n_entities++] = e;
530         if (num_modes[e] > max_num_modes)
531           max_num_modes = num_modes[e];
532       }
533
534   if (! n_entities)
535     return 0;
536
537   /* Make sure if MODE_ENTRY is defined MODE_EXIT is defined.  */
538   gcc_assert ((targetm.mode_switching.entry && targetm.mode_switching.exit)
539               || (!targetm.mode_switching.entry
540                   && !targetm.mode_switching.exit));
541
542   if (targetm.mode_switching.entry && targetm.mode_switching.exit)
543     {
544       /* Split the edge from the entry block, so that we can note that
545          there NORMAL_MODE is supplied.  */
546       post_entry = split_edge (single_succ_edge (ENTRY_BLOCK_PTR_FOR_FN (cfun)));
547       pre_exit = create_pre_exit (n_entities, entity_map, num_modes);
548     }
549
550   df_analyze ();
551
552   /* Create the bitmap vectors.  */
553   antic = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
554                                 n_entities * max_num_modes);
555   transp = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
556                                  n_entities * max_num_modes);
557   comp = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
558                                n_entities * max_num_modes);
559   avin = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
560                                n_entities * max_num_modes);
561   avout = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
562                                 n_entities * max_num_modes);
563   kill = sbitmap_vector_alloc (last_basic_block_for_fn (cfun),
564                                n_entities * max_num_modes);
565
566   bitmap_vector_ones (transp, last_basic_block_for_fn (cfun));
567   bitmap_vector_clear (antic, last_basic_block_for_fn (cfun));
568   bitmap_vector_clear (comp, last_basic_block_for_fn (cfun));
569
570   for (j = n_entities - 1; j >= 0; j--)
571     {
572       int e = entity_map[j];
573       int no_mode = num_modes[e];
574       struct bb_info *info = bb_info[j];
575       rtx_insn *insn;
576
577       /* Determine what the first use (if any) need for a mode of entity E is.
578          This will be the mode that is anticipatable for this block.
579          Also compute the initial transparency settings.  */
580       FOR_EACH_BB_FN (bb, cfun)
581         {
582           struct seginfo *ptr;
583           int last_mode = no_mode;
584           bool any_set_required = false;
585           HARD_REG_SET live_now;
586
587           info[bb->index].mode_out = info[bb->index].mode_in = no_mode;
588
589           REG_SET_TO_HARD_REG_SET (live_now, df_get_live_in (bb));
590
591           /* Pretend the mode is clobbered across abnormal edges.  */
592           {
593             edge_iterator ei;
594             edge eg;
595             FOR_EACH_EDGE (eg, ei, bb->preds)
596               if (eg->flags & EDGE_COMPLEX)
597                 break;
598             if (eg)
599               {
600                 rtx_insn *ins_pos = BB_HEAD (bb);
601                 if (LABEL_P (ins_pos))
602                   ins_pos = NEXT_INSN (ins_pos);
603                 gcc_assert (NOTE_INSN_BASIC_BLOCK_P (ins_pos));
604                 if (ins_pos != BB_END (bb))
605                   ins_pos = NEXT_INSN (ins_pos);
606                 ptr = new_seginfo (no_mode, ins_pos, bb->index, live_now);
607                 add_seginfo (info + bb->index, ptr);
608                 for (i = 0; i < no_mode; i++)
609                   clear_mode_bit (transp[bb->index], j, i);
610               }
611           }
612
613           FOR_BB_INSNS (bb, insn)
614             {
615               if (INSN_P (insn))
616                 {
617                   int mode = targetm.mode_switching.needed (e, insn);
618                   rtx link;
619
620                   if (mode != no_mode && mode != last_mode)
621                     {
622                       any_set_required = true;
623                       last_mode = mode;
624                       ptr = new_seginfo (mode, insn, bb->index, live_now);
625                       add_seginfo (info + bb->index, ptr);
626                       for (i = 0; i < no_mode; i++)
627                         clear_mode_bit (transp[bb->index], j, i);
628                     }
629
630                   if (targetm.mode_switching.after)
631                     last_mode = targetm.mode_switching.after (e, last_mode,
632                                                               insn);
633
634                   /* Update LIVE_NOW.  */
635                   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
636                     if (REG_NOTE_KIND (link) == REG_DEAD)
637                       reg_dies (XEXP (link, 0), &live_now);
638
639                   note_stores (PATTERN (insn), reg_becomes_live, &live_now);
640                   for (link = REG_NOTES (insn); link; link = XEXP (link, 1))
641                     if (REG_NOTE_KIND (link) == REG_UNUSED)
642                       reg_dies (XEXP (link, 0), &live_now);
643                 }
644             }
645
646           info[bb->index].computing = last_mode;
647           /* Check for blocks without ANY mode requirements.
648              N.B. because of MODE_AFTER, last_mode might still
649              be different from no_mode, in which case we need to
650              mark the block as nontransparent.  */
651           if (!any_set_required)
652             {
653               ptr = new_seginfo (no_mode, BB_END (bb), bb->index, live_now);
654               add_seginfo (info + bb->index, ptr);
655               if (last_mode != no_mode)
656                 for (i = 0; i < no_mode; i++)
657                   clear_mode_bit (transp[bb->index], j, i);
658             }
659         }
660       if (targetm.mode_switching.entry && targetm.mode_switching.exit)
661         {
662           int mode = targetm.mode_switching.entry (e);
663
664           info[post_entry->index].mode_out =
665             info[post_entry->index].mode_in = no_mode;
666           if (pre_exit)
667             {
668               info[pre_exit->index].mode_out =
669                 info[pre_exit->index].mode_in = no_mode;
670             }
671
672           if (mode != no_mode)
673             {
674               bb = post_entry;
675
676               /* By always making this nontransparent, we save
677                  an extra check in make_preds_opaque.  We also
678                  need this to avoid confusing pre_edge_lcm when
679                  antic is cleared but transp and comp are set.  */
680               for (i = 0; i < no_mode; i++)
681                 clear_mode_bit (transp[bb->index], j, i);
682
683               /* Insert a fake computing definition of MODE into entry
684                  blocks which compute no mode. This represents the mode on
685                  entry.  */
686               info[bb->index].computing = mode;
687
688               if (pre_exit)
689                 info[pre_exit->index].seginfo->mode =
690                   targetm.mode_switching.exit (e);
691             }
692         }
693
694       /* Set the anticipatable and computing arrays.  */
695       for (i = 0; i < no_mode; i++)
696         {
697           int m = targetm.mode_switching.priority (entity_map[j], i);
698
699           FOR_EACH_BB_FN (bb, cfun)
700             {
701               if (info[bb->index].seginfo->mode == m)
702                 set_mode_bit (antic[bb->index], j, m);
703
704               if (info[bb->index].computing == m)
705                 set_mode_bit (comp[bb->index], j, m);
706             }
707         }
708     }
709
710   /* Calculate the optimal locations for the
711      placement mode switches to modes with priority I.  */
712
713   FOR_EACH_BB_FN (bb, cfun)
714     bitmap_not (kill[bb->index], transp[bb->index]);
715
716   edge_list = pre_edge_lcm_avs (n_entities * max_num_modes, transp, comp, antic,
717                                 kill, avin, avout, &insert, &del);
718
719   for (j = n_entities - 1; j >= 0; j--)
720     {
721       int no_mode = num_modes[entity_map[j]];
722
723       /* Insert all mode sets that have been inserted by lcm.  */
724
725       for (int ed = NUM_EDGES (edge_list) - 1; ed >= 0; ed--)
726         {
727           edge eg = INDEX_EDGE (edge_list, ed);
728
729           eg->aux = (void *)(intptr_t)-1;
730
731           for (i = 0; i < no_mode; i++)
732             {
733               int m = targetm.mode_switching.priority (entity_map[j], i);
734               if (mode_bit_p (insert[ed], j, m))
735                 {
736                   eg->aux = (void *)(intptr_t)m;
737                   break;
738                 }
739             }
740         }
741
742       FOR_EACH_BB_FN (bb, cfun)
743         {
744           struct bb_info *info = bb_info[j];
745           int last_mode = no_mode;
746
747           /* intialize mode in availability for bb.  */
748           for (i = 0; i < no_mode; i++)
749             if (mode_bit_p (avout[bb->index], j, i))
750               {
751                 if (last_mode == no_mode)
752                   last_mode = i;
753                 if (last_mode != i)
754                   {
755                     last_mode = no_mode;
756                     break;
757                   }
758               }
759           info[bb->index].mode_out = last_mode;
760
761           /* intialize mode out availability for bb.  */
762           last_mode = no_mode;
763           for (i = 0; i < no_mode; i++)
764             if (mode_bit_p (avin[bb->index], j, i))
765               {
766                 if (last_mode == no_mode)
767                   last_mode = i;
768                 if (last_mode != i)
769                   {
770                     last_mode = no_mode;
771                     break;
772                   }
773               }
774           info[bb->index].mode_in = last_mode;
775
776           for (i = 0; i < no_mode; i++)
777             if (mode_bit_p (del[bb->index], j, i))
778               info[bb->index].seginfo->mode = no_mode;
779         }
780
781       /* Now output the remaining mode sets in all the segments.  */
782
783       /* In case there was no mode inserted. the mode information on the edge
784          might not be complete.
785          Update mode info on edges and commit pending mode sets.  */
786       need_commit |= commit_mode_sets (edge_list, entity_map[j], bb_info[j]);
787
788       /* Reset modes for next entity.  */
789       clear_aux_for_edges ();
790
791       FOR_EACH_BB_FN (bb, cfun)
792         {
793           struct seginfo *ptr, *next;
794           int cur_mode = bb_info[j][bb->index].mode_in;
795
796           for (ptr = bb_info[j][bb->index].seginfo; ptr; ptr = next)
797             {
798               next = ptr->next;
799               if (ptr->mode != no_mode)
800                 {
801                   rtx_insn *mode_set;
802
803                   rtl_profile_for_bb (bb);
804                   start_sequence ();
805
806                   targetm.mode_switching.emit (entity_map[j], ptr->mode,
807                                                cur_mode, ptr->regs_live);
808                   mode_set = get_insns ();
809                   end_sequence ();
810
811                   /* modes kill each other inside a basic block.  */
812                   cur_mode = ptr->mode;
813
814                   /* Insert MODE_SET only if it is nonempty.  */
815                   if (mode_set != NULL_RTX)
816                     {
817                       emitted = true;
818                       if (NOTE_INSN_BASIC_BLOCK_P (ptr->insn_ptr))
819                         /* We need to emit the insns in a FIFO-like manner,
820                            i.e. the first to be emitted at our insertion
821                            point ends up first in the instruction steam.
822                            Because we made sure that NOTE_INSN_BASIC_BLOCK is
823                            only used for initially empty basic blocks, we
824                            can achieve this by appending at the end of
825                            the block.  */
826                         emit_insn_after
827                           (mode_set, BB_END (NOTE_BASIC_BLOCK (ptr->insn_ptr)));
828                       else
829                         emit_insn_before (mode_set, ptr->insn_ptr);
830                     }
831
832                   default_rtl_profile ();
833                 }
834
835               free (ptr);
836             }
837         }
838
839       free (bb_info[j]);
840     }
841
842   free_edge_list (edge_list);
843
844   /* Finished. Free up all the things we've allocated.  */
845   sbitmap_vector_free (del);
846   sbitmap_vector_free (insert);
847   sbitmap_vector_free (kill);
848   sbitmap_vector_free (antic);
849   sbitmap_vector_free (transp);
850   sbitmap_vector_free (comp);
851   sbitmap_vector_free (avin);
852   sbitmap_vector_free (avout);
853
854   if (need_commit)
855     commit_edge_insertions ();
856
857   if (targetm.mode_switching.entry && targetm.mode_switching.exit)
858     cleanup_cfg (CLEANUP_NO_INSN_DEL);
859   else if (!need_commit && !emitted)
860     return 0;
861
862   return 1;
863 }
864
865 #endif /* OPTIMIZE_MODE_SWITCHING */
866 \f
867 namespace {
868
869 const pass_data pass_data_mode_switching =
870 {
871   RTL_PASS, /* type */
872   "mode_sw", /* name */
873   OPTGROUP_NONE, /* optinfo_flags */
874   TV_MODE_SWITCH, /* tv_id */
875   0, /* properties_required */
876   0, /* properties_provided */
877   0, /* properties_destroyed */
878   0, /* todo_flags_start */
879   TODO_df_finish, /* todo_flags_finish */
880 };
881
882 class pass_mode_switching : public rtl_opt_pass
883 {
884 public:
885   pass_mode_switching (gcc::context *ctxt)
886     : rtl_opt_pass (pass_data_mode_switching, ctxt)
887   {}
888
889   /* opt_pass methods: */
890   /* The epiphany backend creates a second instance of this pass, so we need
891      a clone method.  */
892   opt_pass * clone () { return new pass_mode_switching (m_ctxt); }
893   virtual bool gate (function *)
894     {
895 #ifdef OPTIMIZE_MODE_SWITCHING
896       return true;
897 #else
898       return false;
899 #endif
900     }
901
902   virtual unsigned int execute (function *)
903     {
904 #ifdef OPTIMIZE_MODE_SWITCHING
905       optimize_mode_switching ();
906 #endif /* OPTIMIZE_MODE_SWITCHING */
907       return 0;
908     }
909
910 }; // class pass_mode_switching
911
912 } // anon namespace
913
914 rtl_opt_pass *
915 make_pass_mode_switching (gcc::context *ctxt)
916 {
917   return new pass_mode_switching (ctxt);
918 }