OSDN Git Service

7ff1379f2c9f4e9a37628a6bd5928525eb97c471
[pf3gnuchains/gcc-fork.git] / gcc / config / bfin / bfin.c
1 /* The Blackfin code generation auxiliary output file.
2    Copyright (C) 2005, 2006, 2007, 2008 Free Software Foundation, Inc.
3    Contributed by Analog Devices.
4
5    This file is part of GCC.
6
7    GCC is free software; you can redistribute it and/or modify it
8    under the terms of the GNU General Public License as published
9    by the Free Software Foundation; either version 3, or (at your
10    option) any later version.
11
12    GCC is distributed in the hope that it will be useful, but WITHOUT
13    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
14    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
15    License for more details.
16
17    You should have received a copy of the GNU General Public License
18    along with GCC; see the file COPYING3.  If not see
19    <http://www.gnu.org/licenses/>.  */
20
21 #include "config.h"
22 #include "system.h"
23 #include "coretypes.h"
24 #include "tm.h"
25 #include "rtl.h"
26 #include "regs.h"
27 #include "hard-reg-set.h"
28 #include "real.h"
29 #include "insn-config.h"
30 #include "insn-codes.h"
31 #include "conditions.h"
32 #include "insn-flags.h"
33 #include "output.h"
34 #include "insn-attr.h"
35 #include "tree.h"
36 #include "flags.h"
37 #include "except.h"
38 #include "function.h"
39 #include "input.h"
40 #include "target.h"
41 #include "target-def.h"
42 #include "expr.h"
43 #include "toplev.h"
44 #include "recog.h"
45 #include "optabs.h"
46 #include "ggc.h"
47 #include "integrate.h"
48 #include "cgraph.h"
49 #include "langhooks.h"
50 #include "bfin-protos.h"
51 #include "tm-preds.h"
52 #include "tm-constrs.h"
53 #include "gt-bfin.h"
54 #include "basic-block.h"
55 #include "cfglayout.h"
56 #include "timevar.h"
57 #include "df.h"
58
59 /* A C structure for machine-specific, per-function data.
60    This is added to the cfun structure.  */
61 struct machine_function GTY(())
62 {
63   int has_hardware_loops;
64 };
65
66 /* Test and compare insns in bfin.md store the information needed to
67    generate branch and scc insns here.  */
68 rtx bfin_compare_op0, bfin_compare_op1;
69
70 /* RTX for condition code flag register and RETS register */
71 extern GTY(()) rtx bfin_cc_rtx;
72 extern GTY(()) rtx bfin_rets_rtx;
73 rtx bfin_cc_rtx, bfin_rets_rtx;
74
75 int max_arg_registers = 0;
76
77 /* Arrays used when emitting register names.  */
78 const char *short_reg_names[]  =  SHORT_REGISTER_NAMES;
79 const char *high_reg_names[]   =  HIGH_REGISTER_NAMES;
80 const char *dregs_pair_names[] =  DREGS_PAIR_NAMES;
81 const char *byte_reg_names[]   =  BYTE_REGISTER_NAMES;
82
83 static int arg_regs[] = FUNCTION_ARG_REGISTERS;
84
85 /* Nonzero if -mshared-library-id was given.  */
86 static int bfin_lib_id_given;
87
88 /* Nonzero if -fschedule-insns2 was given.  We override it and
89    call the scheduler ourselves during reorg.  */
90 static int bfin_flag_schedule_insns2;
91
92 /* Determines whether we run variable tracking in machine dependent
93    reorganization.  */
94 static int bfin_flag_var_tracking;
95
96 /* -mcpu support */
97 bfin_cpu_t bfin_cpu_type = BFIN_CPU_UNKNOWN;
98
99 /* -msi-revision support. There are three special values:
100    -1      -msi-revision=none.
101    0xffff  -msi-revision=any.  */
102 int bfin_si_revision;
103
104 /* The workarounds enabled */
105 unsigned int bfin_workarounds = 0;
106
107 struct bfin_cpu
108 {
109   const char *name;
110   bfin_cpu_t type;
111   int si_revision;
112   unsigned int workarounds;
113 };
114
115 struct bfin_cpu bfin_cpus[] =
116 {
117   {"bf522", BFIN_CPU_BF522, 0x0001,
118    WA_SPECULATIVE_LOADS | WA_RETS},
119   {"bf522", BFIN_CPU_BF522, 0x0000,
120    WA_SPECULATIVE_LOADS | WA_RETS},
121
122   {"bf523", BFIN_CPU_BF523, 0x0001,
123    WA_SPECULATIVE_LOADS | WA_RETS},
124   {"bf523", BFIN_CPU_BF523, 0x0000,
125    WA_SPECULATIVE_LOADS | WA_RETS},
126
127   {"bf524", BFIN_CPU_BF524, 0x0001,
128    WA_SPECULATIVE_LOADS | WA_RETS},
129   {"bf524", BFIN_CPU_BF524, 0x0000,
130    WA_SPECULATIVE_LOADS | WA_RETS},
131
132   {"bf525", BFIN_CPU_BF525, 0x0001,
133    WA_SPECULATIVE_LOADS | WA_RETS},
134   {"bf525", BFIN_CPU_BF525, 0x0000,
135    WA_SPECULATIVE_LOADS | WA_RETS},
136
137   {"bf526", BFIN_CPU_BF526, 0x0001,
138    WA_SPECULATIVE_LOADS | WA_RETS},
139   {"bf526", BFIN_CPU_BF526, 0x0000,
140    WA_SPECULATIVE_LOADS | WA_RETS},
141
142   {"bf527", BFIN_CPU_BF527, 0x0001,
143    WA_SPECULATIVE_LOADS | WA_RETS},
144   {"bf527", BFIN_CPU_BF527, 0x0000,
145    WA_SPECULATIVE_LOADS | WA_RETS},
146
147   {"bf531", BFIN_CPU_BF531, 0x0005,
148    WA_SPECULATIVE_LOADS | WA_RETS},
149   {"bf531", BFIN_CPU_BF531, 0x0004,
150    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
151   {"bf531", BFIN_CPU_BF531, 0x0003,
152    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
153
154   {"bf532", BFIN_CPU_BF532, 0x0005,
155    WA_SPECULATIVE_LOADS | WA_RETS},
156   {"bf532", BFIN_CPU_BF532, 0x0004,
157    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
158   {"bf532", BFIN_CPU_BF532, 0x0003,
159    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
160
161   {"bf533", BFIN_CPU_BF533, 0x0005,
162    WA_SPECULATIVE_LOADS | WA_RETS},
163   {"bf533", BFIN_CPU_BF533, 0x0004,
164    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
165   {"bf533", BFIN_CPU_BF533, 0x0003,
166    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
167
168   {"bf534", BFIN_CPU_BF534, 0x0003,
169    WA_SPECULATIVE_LOADS | WA_RETS},
170   {"bf534", BFIN_CPU_BF534, 0x0002,
171    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
172   {"bf534", BFIN_CPU_BF534, 0x0001,
173    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
174
175   {"bf536", BFIN_CPU_BF536, 0x0003,
176    WA_SPECULATIVE_LOADS | WA_RETS},
177   {"bf536", BFIN_CPU_BF536, 0x0002,
178    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
179   {"bf536", BFIN_CPU_BF536, 0x0001,
180    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
181
182   {"bf537", BFIN_CPU_BF537, 0x0003,
183    WA_SPECULATIVE_LOADS | WA_RETS},
184   {"bf537", BFIN_CPU_BF537, 0x0002,
185    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
186   {"bf537", BFIN_CPU_BF537, 0x0001,
187    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
188
189   {"bf538", BFIN_CPU_BF538, 0x0004,
190    WA_SPECULATIVE_LOADS | WA_RETS},
191   {"bf538", BFIN_CPU_BF538, 0x0003,
192    WA_SPECULATIVE_LOADS | WA_RETS},
193   {"bf538", BFIN_CPU_BF538, 0x0002,
194    WA_SPECULATIVE_LOADS | WA_RETS},
195
196   {"bf539", BFIN_CPU_BF539, 0x0004,
197    WA_SPECULATIVE_LOADS | WA_RETS},
198   {"bf539", BFIN_CPU_BF539, 0x0003,
199    WA_SPECULATIVE_LOADS | WA_RETS},
200   {"bf539", BFIN_CPU_BF539, 0x0002,
201    WA_SPECULATIVE_LOADS | WA_RETS},
202
203   {"bf542", BFIN_CPU_BF542, 0x0001,
204    WA_SPECULATIVE_LOADS | WA_RETS},
205   {"bf542", BFIN_CPU_BF542, 0x0000,
206    WA_SPECULATIVE_LOADS | WA_RETS},
207
208   {"bf544", BFIN_CPU_BF544, 0x0001,
209    WA_SPECULATIVE_LOADS | WA_RETS},
210   {"bf544", BFIN_CPU_BF544, 0x0000,
211    WA_SPECULATIVE_LOADS | WA_RETS},
212
213   {"bf547", BFIN_CPU_BF547, 0x0001,
214    WA_SPECULATIVE_LOADS | WA_RETS},
215   {"bf547", BFIN_CPU_BF547, 0x0000,
216    WA_SPECULATIVE_LOADS | WA_RETS},
217
218   {"bf548", BFIN_CPU_BF548, 0x0001,
219    WA_SPECULATIVE_LOADS | WA_RETS},
220   {"bf548", BFIN_CPU_BF548, 0x0000,
221    WA_SPECULATIVE_LOADS | WA_RETS},
222
223   {"bf549", BFIN_CPU_BF549, 0x0001,
224    WA_SPECULATIVE_LOADS | WA_RETS},
225   {"bf549", BFIN_CPU_BF549, 0x0000,
226    WA_SPECULATIVE_LOADS | WA_RETS},
227
228   {"bf561", BFIN_CPU_BF561, 0x0005, WA_RETS},
229   {"bf561", BFIN_CPU_BF561, 0x0003,
230    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
231   {"bf561", BFIN_CPU_BF561, 0x0002,
232    WA_SPECULATIVE_LOADS | WA_SPECULATIVE_SYNCS | WA_RETS},
233
234   {NULL, 0, 0, 0}
235 };
236
237 int splitting_for_sched;
238
239 static void
240 bfin_globalize_label (FILE *stream, const char *name)
241 {
242   fputs (".global ", stream);
243   assemble_name (stream, name);
244   fputc (';',stream);
245   fputc ('\n',stream);
246 }
247
248 static void 
249 output_file_start (void) 
250 {
251   FILE *file = asm_out_file;
252   int i;
253
254   /* Variable tracking should be run after all optimizations which change order
255      of insns.  It also needs a valid CFG.  This can't be done in
256      override_options, because flag_var_tracking is finalized after
257      that.  */
258   bfin_flag_var_tracking = flag_var_tracking;
259   flag_var_tracking = 0;
260
261   fprintf (file, ".file \"%s\";\n", input_filename);
262   
263   for (i = 0; arg_regs[i] >= 0; i++)
264     ;
265   max_arg_registers = i;        /* how many arg reg used  */
266 }
267
268 /* Called early in the compilation to conditionally modify
269    fixed_regs/call_used_regs.  */
270
271 void 
272 conditional_register_usage (void)
273 {
274   /* initialize condition code flag register rtx */
275   bfin_cc_rtx = gen_rtx_REG (BImode, REG_CC);
276   bfin_rets_rtx = gen_rtx_REG (Pmode, REG_RETS);
277 }
278
279 /* Examine machine-dependent attributes of function type FUNTYPE and return its
280    type.  See the definition of E_FUNKIND.  */
281
282 static e_funkind
283 funkind (const_tree funtype)
284 {
285   tree attrs = TYPE_ATTRIBUTES (funtype);
286   if (lookup_attribute ("interrupt_handler", attrs))
287     return INTERRUPT_HANDLER;
288   else if (lookup_attribute ("exception_handler", attrs))
289     return EXCPT_HANDLER;
290   else if (lookup_attribute ("nmi_handler", attrs))
291     return NMI_HANDLER;
292   else
293     return SUBROUTINE;
294 }
295 \f
296 /* Legitimize PIC addresses.  If the address is already position-independent,
297    we return ORIG.  Newly generated position-independent addresses go into a
298    reg.  This is REG if nonzero, otherwise we allocate register(s) as
299    necessary.  PICREG is the register holding the pointer to the PIC offset
300    table.  */
301
302 static rtx
303 legitimize_pic_address (rtx orig, rtx reg, rtx picreg)
304 {
305   rtx addr = orig;
306   rtx new_rtx = orig;
307
308   if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == LABEL_REF)
309     {
310       int unspec;
311       rtx tmp;
312
313       if (TARGET_ID_SHARED_LIBRARY)
314         unspec = UNSPEC_MOVE_PIC;
315       else if (GET_CODE (addr) == SYMBOL_REF
316                && SYMBOL_REF_FUNCTION_P (addr))
317         unspec = UNSPEC_FUNCDESC_GOT17M4;
318       else
319         unspec = UNSPEC_MOVE_FDPIC;
320
321       if (reg == 0)
322         {
323           gcc_assert (can_create_pseudo_p ());
324           reg = gen_reg_rtx (Pmode);
325         }
326
327       tmp = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, addr), unspec);
328       new_rtx = gen_const_mem (Pmode, gen_rtx_PLUS (Pmode, picreg, tmp));
329
330       emit_move_insn (reg, new_rtx);
331       if (picreg == pic_offset_table_rtx)
332         crtl->uses_pic_offset_table = 1;
333       return reg;
334     }
335
336   else if (GET_CODE (addr) == CONST || GET_CODE (addr) == PLUS)
337     {
338       rtx base;
339
340       if (GET_CODE (addr) == CONST)
341         {
342           addr = XEXP (addr, 0);
343           gcc_assert (GET_CODE (addr) == PLUS);
344         }
345
346       if (XEXP (addr, 0) == picreg)
347         return orig;
348
349       if (reg == 0)
350         {
351           gcc_assert (can_create_pseudo_p ());
352           reg = gen_reg_rtx (Pmode);
353         }
354
355       base = legitimize_pic_address (XEXP (addr, 0), reg, picreg);
356       addr = legitimize_pic_address (XEXP (addr, 1),
357                                      base == reg ? NULL_RTX : reg,
358                                      picreg);
359
360       if (GET_CODE (addr) == CONST_INT)
361         {
362           gcc_assert (! reload_in_progress && ! reload_completed);
363           addr = force_reg (Pmode, addr);
364         }
365
366       if (GET_CODE (addr) == PLUS && CONSTANT_P (XEXP (addr, 1)))
367         {
368           base = gen_rtx_PLUS (Pmode, base, XEXP (addr, 0));
369           addr = XEXP (addr, 1);
370         }
371
372       return gen_rtx_PLUS (Pmode, base, addr);
373     }
374
375   return new_rtx;
376 }
377 \f
378 /* Stack frame layout. */
379
380 /* For a given REGNO, determine whether it must be saved in the function
381    prologue.  IS_INTHANDLER specifies whether we're generating a normal
382    prologue or an interrupt/exception one.  */
383 static bool
384 must_save_p (bool is_inthandler, unsigned regno)
385 {
386   if (D_REGNO_P (regno))
387     {
388       bool is_eh_return_reg = false;
389       if (crtl->calls_eh_return)
390         {
391           unsigned j;
392           for (j = 0; ; j++)
393             {
394               unsigned test = EH_RETURN_DATA_REGNO (j);
395               if (test == INVALID_REGNUM)
396                 break;
397               if (test == regno)
398                 is_eh_return_reg = true;
399             }
400         }
401
402       return (is_eh_return_reg
403               || (df_regs_ever_live_p (regno)
404                   && !fixed_regs[regno]
405                   && (is_inthandler || !call_used_regs[regno])));
406     }
407   else if (P_REGNO_P (regno))
408     {
409       return ((df_regs_ever_live_p (regno)
410                && !fixed_regs[regno]
411                && (is_inthandler || !call_used_regs[regno]))
412               || (!TARGET_FDPIC
413                   && regno == PIC_OFFSET_TABLE_REGNUM
414                   && (crtl->uses_pic_offset_table
415                       || (TARGET_ID_SHARED_LIBRARY && !current_function_is_leaf))));
416     }
417   else
418     return ((is_inthandler || !call_used_regs[regno])
419             && (df_regs_ever_live_p (regno)
420                 || (!leaf_function_p () && call_used_regs[regno])));
421
422 }
423
424 /* Compute the number of DREGS to save with a push_multiple operation.
425    This could include registers that aren't modified in the function,
426    since push_multiple only takes a range of registers.
427    If IS_INTHANDLER, then everything that is live must be saved, even
428    if normally call-clobbered.
429    If CONSECUTIVE, return the number of registers we can save in one
430    instruction with a push/pop multiple instruction.  */
431
432 static int
433 n_dregs_to_save (bool is_inthandler, bool consecutive)
434 {
435   int count = 0;
436   unsigned i;
437
438   for (i = REG_R7 + 1; i-- != REG_R0;)
439     {
440       if (must_save_p (is_inthandler, i))
441         count++;
442       else if (consecutive)
443         return count;
444     }
445   return count;
446 }
447
448 /* Like n_dregs_to_save, but compute number of PREGS to save.  */
449
450 static int
451 n_pregs_to_save (bool is_inthandler, bool consecutive)
452 {
453   int count = 0;
454   unsigned i;
455
456   for (i = REG_P5 + 1; i-- != REG_P0;)
457     if (must_save_p (is_inthandler, i))
458       count++;
459     else if (consecutive)
460       return count;
461   return count;
462 }
463
464 /* Determine if we are going to save the frame pointer in the prologue.  */
465
466 static bool
467 must_save_fp_p (void)
468 {
469   return frame_pointer_needed || df_regs_ever_live_p (REG_FP);
470 }
471
472 static bool
473 stack_frame_needed_p (void)
474 {
475   /* EH return puts a new return address into the frame using an
476      address relative to the frame pointer.  */
477   if (crtl->calls_eh_return)
478     return true;
479   return frame_pointer_needed;
480 }
481
482 /* Emit code to save registers in the prologue.  SAVEALL is nonzero if we
483    must save all registers; this is used for interrupt handlers.
484    SPREG contains (reg:SI REG_SP).  IS_INTHANDLER is true if we're doing
485    this for an interrupt (or exception) handler.  */
486
487 static void
488 expand_prologue_reg_save (rtx spreg, int saveall, bool is_inthandler)
489 {
490   rtx predec1 = gen_rtx_PRE_DEC (SImode, spreg);
491   rtx predec = gen_rtx_MEM (SImode, predec1);
492   int ndregs = saveall ? 8 : n_dregs_to_save (is_inthandler, false);
493   int npregs = saveall ? 6 : n_pregs_to_save (is_inthandler, false);
494   int ndregs_consec = saveall ? 8 : n_dregs_to_save (is_inthandler, true);
495   int npregs_consec = saveall ? 6 : n_pregs_to_save (is_inthandler, true);
496   int dregno, pregno;
497   int total_consec = ndregs_consec + npregs_consec;
498   int i, d_to_save;
499
500   if (saveall || is_inthandler)
501     {
502       rtx insn = emit_move_insn (predec, gen_rtx_REG (SImode, REG_ASTAT));
503       RTX_FRAME_RELATED_P (insn) = 1;
504     }
505
506   if (total_consec != 0)
507     {
508       rtx insn;
509       rtx val = GEN_INT (-total_consec * 4);
510       rtx pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_consec + 2));
511
512       XVECEXP (pat, 0, 0) = gen_rtx_UNSPEC (VOIDmode, gen_rtvec (1, val),
513                                             UNSPEC_PUSH_MULTIPLE);
514       XVECEXP (pat, 0, total_consec + 1) = gen_rtx_SET (VOIDmode, spreg,
515                                                         gen_rtx_PLUS (Pmode,
516                                                                       spreg,
517                                                                       val));
518       RTX_FRAME_RELATED_P (XVECEXP (pat, 0, total_consec + 1)) = 1;
519       d_to_save = ndregs_consec;
520       dregno = REG_R7 + 1 - ndregs_consec;
521       pregno = REG_P5 + 1 - npregs_consec;
522       for (i = 0; i < total_consec; i++)
523         {
524           rtx memref = gen_rtx_MEM (word_mode,
525                                     gen_rtx_PLUS (Pmode, spreg,
526                                                   GEN_INT (- i * 4 - 4)));
527           rtx subpat;
528           if (d_to_save > 0)
529             {
530               subpat = gen_rtx_SET (VOIDmode, memref, gen_rtx_REG (word_mode,
531                                                                    dregno++));
532               d_to_save--;
533             }
534           else
535             {
536               subpat = gen_rtx_SET (VOIDmode, memref, gen_rtx_REG (word_mode,
537                                                                    pregno++));
538             }
539           XVECEXP (pat, 0, i + 1) = subpat;
540           RTX_FRAME_RELATED_P (subpat) = 1;
541         }
542       insn = emit_insn (pat);
543       RTX_FRAME_RELATED_P (insn) = 1;
544     }
545
546   for (dregno = REG_R0; ndregs != ndregs_consec; dregno++)
547     {
548       if (must_save_p (is_inthandler, dregno))
549         {
550           rtx insn = emit_move_insn (predec, gen_rtx_REG (word_mode, dregno));
551           RTX_FRAME_RELATED_P (insn) = 1;
552           ndregs--;
553         }
554     }
555   for (pregno = REG_P0; npregs != npregs_consec; pregno++)
556     {
557       if (must_save_p (is_inthandler, pregno))
558         {
559           rtx insn = emit_move_insn (predec, gen_rtx_REG (word_mode, pregno));
560           RTX_FRAME_RELATED_P (insn) = 1;
561           npregs--;
562         }
563     }
564   for (i = REG_P7 + 1; i < REG_CC; i++)
565     if (saveall 
566         || (is_inthandler
567             && (df_regs_ever_live_p (i)
568                 || (!leaf_function_p () && call_used_regs[i]))))
569       {
570         rtx insn;
571         if (i == REG_A0 || i == REG_A1)
572           insn = emit_move_insn (gen_rtx_MEM (PDImode, predec1),
573                                  gen_rtx_REG (PDImode, i));
574         else
575           insn = emit_move_insn (predec, gen_rtx_REG (SImode, i));
576         RTX_FRAME_RELATED_P (insn) = 1;
577       }
578 }
579
580 /* Emit code to restore registers in the epilogue.  SAVEALL is nonzero if we
581    must save all registers; this is used for interrupt handlers.
582    SPREG contains (reg:SI REG_SP).  IS_INTHANDLER is true if we're doing
583    this for an interrupt (or exception) handler.  */
584
585 static void
586 expand_epilogue_reg_restore (rtx spreg, bool saveall, bool is_inthandler)
587 {
588   rtx postinc1 = gen_rtx_POST_INC (SImode, spreg);
589   rtx postinc = gen_rtx_MEM (SImode, postinc1);
590
591   int ndregs = saveall ? 8 : n_dregs_to_save (is_inthandler, false);
592   int npregs = saveall ? 6 : n_pregs_to_save (is_inthandler, false);
593   int ndregs_consec = saveall ? 8 : n_dregs_to_save (is_inthandler, true);
594   int npregs_consec = saveall ? 6 : n_pregs_to_save (is_inthandler, true);
595   int total_consec = ndregs_consec + npregs_consec;
596   int i, regno;
597   rtx insn;
598
599   /* A slightly crude technique to stop flow from trying to delete "dead"
600      insns.  */
601   MEM_VOLATILE_P (postinc) = 1;
602
603   for (i = REG_CC - 1; i > REG_P7; i--)
604     if (saveall
605         || (is_inthandler
606             && (df_regs_ever_live_p (i)
607                 || (!leaf_function_p () && call_used_regs[i]))))
608       {
609         if (i == REG_A0 || i == REG_A1)
610           {
611             rtx mem = gen_rtx_MEM (PDImode, postinc1);
612             MEM_VOLATILE_P (mem) = 1;
613             emit_move_insn (gen_rtx_REG (PDImode, i), mem);
614           }
615         else
616           emit_move_insn (gen_rtx_REG (SImode, i), postinc);
617       }
618
619   regno = REG_P5 - npregs_consec;
620   for (; npregs != npregs_consec; regno--)
621     {
622       if (must_save_p (is_inthandler, regno))
623         {
624           emit_move_insn (gen_rtx_REG (word_mode, regno), postinc);
625           npregs--;
626         }
627     }
628   regno = REG_R7 - ndregs_consec;
629   for (; ndregs != ndregs_consec; regno--)
630     {
631       if (must_save_p (is_inthandler, regno))
632         {
633           emit_move_insn (gen_rtx_REG (word_mode, regno), postinc);
634           ndregs--;
635         }
636     }
637
638   if (total_consec != 0)
639     {
640       rtx pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (total_consec + 1));
641       XVECEXP (pat, 0, 0)
642         = gen_rtx_SET (VOIDmode, spreg,
643                        gen_rtx_PLUS (Pmode, spreg,
644                                      GEN_INT (total_consec * 4)));
645
646       if (npregs_consec > 0)
647         regno = REG_P5 + 1;
648       else
649         regno = REG_R7 + 1;
650
651       for (i = 0; i < total_consec; i++)
652         {
653           rtx addr = (i > 0
654                       ? gen_rtx_PLUS (Pmode, spreg, GEN_INT (i * 4))
655                       : spreg);
656           rtx memref = gen_rtx_MEM (word_mode, addr);
657
658           regno--;
659           XVECEXP (pat, 0, i + 1)
660             = gen_rtx_SET (VOIDmode, gen_rtx_REG (word_mode, regno), memref);
661
662           if (npregs_consec > 0)
663             {
664               if (--npregs_consec == 0)
665                 regno = REG_R7 + 1;
666             }
667         }
668
669       insn = emit_insn (pat);
670       RTX_FRAME_RELATED_P (insn) = 1;
671     }
672   if (saveall || is_inthandler)
673     emit_move_insn (gen_rtx_REG (SImode, REG_ASTAT), postinc);
674 }
675
676 /* Perform any needed actions needed for a function that is receiving a
677    variable number of arguments.
678
679    CUM is as above.
680
681    MODE and TYPE are the mode and type of the current parameter.
682
683    PRETEND_SIZE is a variable that should be set to the amount of stack
684    that must be pushed by the prolog to pretend that our caller pushed
685    it.
686
687    Normally, this macro will push all remaining incoming registers on the
688    stack and set PRETEND_SIZE to the length of the registers pushed.  
689
690    Blackfin specific :
691    - VDSP C compiler manual (our ABI) says that a variable args function
692      should save the R0, R1 and R2 registers in the stack.
693    - The caller will always leave space on the stack for the
694      arguments that are passed in registers, so we dont have
695      to leave any extra space.
696    - now, the vastart pointer can access all arguments from the stack.  */
697
698 static void
699 setup_incoming_varargs (CUMULATIVE_ARGS *cum,
700                         enum machine_mode mode ATTRIBUTE_UNUSED,
701                         tree type ATTRIBUTE_UNUSED, int *pretend_size,
702                         int no_rtl)
703 {
704   rtx mem;
705   int i;
706
707   if (no_rtl)
708     return;
709
710   /* The move for named arguments will be generated automatically by the
711      compiler.  We need to generate the move rtx for the unnamed arguments
712      if they are in the first 3 words.  We assume at least 1 named argument
713      exists, so we never generate [ARGP] = R0 here.  */
714
715   for (i = cum->words + 1; i < max_arg_registers; i++)
716     {
717       mem = gen_rtx_MEM (Pmode,
718                          plus_constant (arg_pointer_rtx, (i * UNITS_PER_WORD)));
719       emit_move_insn (mem, gen_rtx_REG (Pmode, i));
720     }
721
722   *pretend_size = 0;
723 }
724
725 /* Value should be nonzero if functions must have frame pointers.
726    Zero means the frame pointer need not be set up (and parms may
727    be accessed via the stack pointer) in functions that seem suitable.  */
728
729 int
730 bfin_frame_pointer_required (void) 
731 {
732   e_funkind fkind = funkind (TREE_TYPE (current_function_decl));
733
734   if (fkind != SUBROUTINE)
735     return 1;
736
737   /* We turn on -fomit-frame-pointer if -momit-leaf-frame-pointer is used,
738      so we have to override it for non-leaf functions.  */
739   if (TARGET_OMIT_LEAF_FRAME_POINTER && ! current_function_is_leaf)
740     return 1;
741
742   return 0;
743 }
744
745 /* Return the number of registers pushed during the prologue.  */
746
747 static int
748 n_regs_saved_by_prologue (void)
749 {
750   e_funkind fkind = funkind (TREE_TYPE (current_function_decl));
751   bool is_inthandler = fkind != SUBROUTINE;
752   tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
753   bool all = (lookup_attribute ("saveall", attrs) != NULL_TREE
754               || (is_inthandler && !current_function_is_leaf));
755   int ndregs = all ? 8 : n_dregs_to_save (is_inthandler, false);
756   int npregs = all ? 6 : n_pregs_to_save (is_inthandler, false);
757   int n = ndregs + npregs;
758   int i;
759
760   if (all || stack_frame_needed_p ())
761     /* We use a LINK instruction in this case.  */
762     n += 2;
763   else
764     {
765       if (must_save_fp_p ())
766         n++;
767       if (! current_function_is_leaf)
768         n++;
769     }
770
771   if (fkind != SUBROUTINE || all)
772     /* Increment once for ASTAT.  */
773     n++;
774
775   if (fkind != SUBROUTINE)
776     {
777       /* RETE/X/N.  */
778       if (lookup_attribute ("nesting", attrs))
779         n++;
780     }
781
782   for (i = REG_P7 + 1; i < REG_CC; i++)
783     if (all
784         || (fkind != SUBROUTINE
785             && (df_regs_ever_live_p (i)
786                 || (!leaf_function_p () && call_used_regs[i]))))
787       n += i == REG_A0 || i == REG_A1 ? 2 : 1;
788
789   return n;
790 }
791
792 /* Return the offset between two registers, one to be eliminated, and the other
793    its replacement, at the start of a routine.  */
794
795 HOST_WIDE_INT
796 bfin_initial_elimination_offset (int from, int to)
797 {
798   HOST_WIDE_INT offset = 0;
799
800   if (from == ARG_POINTER_REGNUM)
801     offset = n_regs_saved_by_prologue () * 4;
802
803   if (to == STACK_POINTER_REGNUM)
804     {
805       if (crtl->outgoing_args_size >= FIXED_STACK_AREA)
806         offset += crtl->outgoing_args_size;
807       else if (crtl->outgoing_args_size)
808         offset += FIXED_STACK_AREA;
809
810       offset += get_frame_size ();
811     }
812
813   return offset;
814 }
815
816 /* Emit code to load a constant CONSTANT into register REG; setting
817    RTX_FRAME_RELATED_P on all insns we generate if RELATED is true.
818    Make sure that the insns we generate need not be split.  */
819
820 static void
821 frame_related_constant_load (rtx reg, HOST_WIDE_INT constant, bool related)
822 {
823   rtx insn;
824   rtx cst = GEN_INT (constant);
825
826   if (constant >= -32768 && constant < 65536)
827     insn = emit_move_insn (reg, cst);
828   else
829     {
830       /* We don't call split_load_immediate here, since dwarf2out.c can get
831          confused about some of the more clever sequences it can generate.  */
832       insn = emit_insn (gen_movsi_high (reg, cst));
833       if (related)
834         RTX_FRAME_RELATED_P (insn) = 1;
835       insn = emit_insn (gen_movsi_low (reg, reg, cst));
836     }
837   if (related)
838     RTX_FRAME_RELATED_P (insn) = 1;
839 }
840
841 /* Generate efficient code to add a value to a P register.
842    Set RTX_FRAME_RELATED_P on the generated insns if FRAME is nonzero.
843    EPILOGUE_P is zero if this function is called for prologue,
844    otherwise it's nonzero. And it's less than zero if this is for
845    sibcall epilogue.  */
846
847 static void
848 add_to_reg (rtx reg, HOST_WIDE_INT value, int frame, int epilogue_p)
849 {
850   if (value == 0)
851     return;
852
853   /* Choose whether to use a sequence using a temporary register, or
854      a sequence with multiple adds.  We can add a signed 7-bit value
855      in one instruction.  */
856   if (value > 120 || value < -120)
857     {
858       rtx tmpreg;
859       rtx tmpreg2;
860       rtx insn;
861
862       tmpreg2 = NULL_RTX;
863
864       /* For prologue or normal epilogue, P1 can be safely used
865          as the temporary register. For sibcall epilogue, we try to find
866          a call used P register, which will be restored in epilogue.
867          If we cannot find such a P register, we have to use one I register
868          to help us.  */
869
870       if (epilogue_p >= 0)
871         tmpreg = gen_rtx_REG (SImode, REG_P1);
872       else
873         {
874           int i;
875           for (i = REG_P0; i <= REG_P5; i++)
876             if ((df_regs_ever_live_p (i) && ! call_used_regs[i])
877                 || (!TARGET_FDPIC
878                     && i == PIC_OFFSET_TABLE_REGNUM
879                     && (crtl->uses_pic_offset_table
880                         || (TARGET_ID_SHARED_LIBRARY
881                             && ! current_function_is_leaf))))
882               break;
883           if (i <= REG_P5)
884             tmpreg = gen_rtx_REG (SImode, i);
885           else
886             {
887               tmpreg = gen_rtx_REG (SImode, REG_P1);
888               tmpreg2 = gen_rtx_REG (SImode, REG_I0);
889               emit_move_insn (tmpreg2, tmpreg);
890             }
891         }
892
893       if (frame)
894         frame_related_constant_load (tmpreg, value, TRUE);
895       else
896         insn = emit_move_insn (tmpreg, GEN_INT (value));
897
898       insn = emit_insn (gen_addsi3 (reg, reg, tmpreg));
899       if (frame)
900         RTX_FRAME_RELATED_P (insn) = 1;
901
902       if (tmpreg2 != NULL_RTX)
903         emit_move_insn (tmpreg, tmpreg2);
904     }
905   else
906     do
907       {
908         int size = value;
909         rtx insn;
910
911         if (size > 60)
912           size = 60;
913         else if (size < -60)
914           /* We could use -62, but that would leave the stack unaligned, so
915              it's no good.  */
916           size = -60;
917
918         insn = emit_insn (gen_addsi3 (reg, reg, GEN_INT (size)));
919         if (frame)
920           RTX_FRAME_RELATED_P (insn) = 1;
921         value -= size;
922       }
923     while (value != 0);
924 }
925
926 /* Generate a LINK insn for a frame sized FRAME_SIZE.  If this constant
927    is too large, generate a sequence of insns that has the same effect.
928    SPREG contains (reg:SI REG_SP).  */
929
930 static void
931 emit_link_insn (rtx spreg, HOST_WIDE_INT frame_size)
932 {
933   HOST_WIDE_INT link_size = frame_size;
934   rtx insn;
935   int i;
936
937   if (link_size > 262140)
938     link_size = 262140;
939
940   /* Use a LINK insn with as big a constant as possible, then subtract
941      any remaining size from the SP.  */
942   insn = emit_insn (gen_link (GEN_INT (-8 - link_size)));
943   RTX_FRAME_RELATED_P (insn) = 1;
944
945   for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
946     {
947       rtx set = XVECEXP (PATTERN (insn), 0, i);
948       gcc_assert (GET_CODE (set) == SET);
949       RTX_FRAME_RELATED_P (set) = 1;
950     }
951
952   frame_size -= link_size;
953
954   if (frame_size > 0)
955     {
956       /* Must use a call-clobbered PREG that isn't the static chain.  */
957       rtx tmpreg = gen_rtx_REG (Pmode, REG_P1);
958
959       frame_related_constant_load (tmpreg, -frame_size, TRUE);
960       insn = emit_insn (gen_addsi3 (spreg, spreg, tmpreg));
961       RTX_FRAME_RELATED_P (insn) = 1;
962     }
963 }
964
965 /* Return the number of bytes we must reserve for outgoing arguments
966    in the current function's stack frame.  */
967
968 static HOST_WIDE_INT
969 arg_area_size (void)
970 {
971   if (crtl->outgoing_args_size)
972     {
973       if (crtl->outgoing_args_size >= FIXED_STACK_AREA)
974         return crtl->outgoing_args_size;
975       else
976         return FIXED_STACK_AREA;
977     }
978   return 0;
979 }
980
981 /* Save RETS and FP, and allocate a stack frame.  ALL is true if the
982    function must save all its registers (true only for certain interrupt
983    handlers).  */
984
985 static void
986 do_link (rtx spreg, HOST_WIDE_INT frame_size, bool all)
987 {
988   frame_size += arg_area_size ();
989
990   if (all || stack_frame_needed_p ()
991       || (must_save_fp_p () && ! current_function_is_leaf))
992     emit_link_insn (spreg, frame_size);
993   else
994     {
995       if (! current_function_is_leaf)
996         {
997           rtx pat = gen_movsi (gen_rtx_MEM (Pmode,
998                                             gen_rtx_PRE_DEC (Pmode, spreg)),
999                                bfin_rets_rtx);
1000           rtx insn = emit_insn (pat);
1001           RTX_FRAME_RELATED_P (insn) = 1;
1002         }
1003       if (must_save_fp_p ())
1004         {
1005           rtx pat = gen_movsi (gen_rtx_MEM (Pmode,
1006                                             gen_rtx_PRE_DEC (Pmode, spreg)),
1007                                gen_rtx_REG (Pmode, REG_FP));
1008           rtx insn = emit_insn (pat);
1009           RTX_FRAME_RELATED_P (insn) = 1;
1010         }
1011       add_to_reg (spreg, -frame_size, 1, 0);
1012     }
1013 }
1014
1015 /* Like do_link, but used for epilogues to deallocate the stack frame.
1016    EPILOGUE_P is zero if this function is called for prologue,
1017    otherwise it's nonzero. And it's less than zero if this is for
1018    sibcall epilogue.  */
1019
1020 static void
1021 do_unlink (rtx spreg, HOST_WIDE_INT frame_size, bool all, int epilogue_p)
1022 {
1023   frame_size += arg_area_size ();
1024
1025   if (all || stack_frame_needed_p ())
1026     emit_insn (gen_unlink ());
1027   else 
1028     {
1029       rtx postinc = gen_rtx_MEM (Pmode, gen_rtx_POST_INC (Pmode, spreg));
1030
1031       add_to_reg (spreg, frame_size, 0, epilogue_p);
1032       if (must_save_fp_p ())
1033         {
1034           rtx fpreg = gen_rtx_REG (Pmode, REG_FP);
1035           emit_move_insn (fpreg, postinc);
1036           emit_use (fpreg);
1037         }
1038       if (! current_function_is_leaf)
1039         {
1040           emit_move_insn (bfin_rets_rtx, postinc);
1041           emit_use (bfin_rets_rtx);
1042         }
1043     }
1044 }
1045
1046 /* Generate a prologue suitable for a function of kind FKIND.  This is
1047    called for interrupt and exception handler prologues.
1048    SPREG contains (reg:SI REG_SP).  */
1049
1050 static void
1051 expand_interrupt_handler_prologue (rtx spreg, e_funkind fkind, bool all)
1052 {
1053   HOST_WIDE_INT frame_size = get_frame_size ();
1054   rtx predec1 = gen_rtx_PRE_DEC (SImode, spreg);
1055   rtx predec = gen_rtx_MEM (SImode, predec1);
1056   rtx insn;
1057   tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
1058   tree kspisusp = lookup_attribute ("kspisusp", attrs);
1059
1060   if (kspisusp)
1061     {
1062       insn = emit_move_insn (spreg, gen_rtx_REG (Pmode, REG_USP));
1063       RTX_FRAME_RELATED_P (insn) = 1;
1064     }
1065
1066   /* We need space on the stack in case we need to save the argument
1067      registers.  */
1068   if (fkind == EXCPT_HANDLER)
1069     {
1070       insn = emit_insn (gen_addsi3 (spreg, spreg, GEN_INT (-12)));
1071       RTX_FRAME_RELATED_P (insn) = 1;
1072     }
1073
1074   /* If we're calling other functions, they won't save their call-clobbered
1075      registers, so we must save everything here.  */
1076   if (!current_function_is_leaf)
1077     all = true;
1078   expand_prologue_reg_save (spreg, all, true);
1079
1080   if (lookup_attribute ("nesting", attrs))
1081     {
1082       rtx srcreg = gen_rtx_REG (Pmode, (fkind == EXCPT_HANDLER ? REG_RETX
1083                                         : fkind == NMI_HANDLER ? REG_RETN
1084                                         : REG_RETI));
1085       insn = emit_move_insn (predec, srcreg);
1086       RTX_FRAME_RELATED_P (insn) = 1;
1087     }
1088
1089   do_link (spreg, frame_size, all);
1090
1091   if (fkind == EXCPT_HANDLER)
1092     {
1093       rtx r0reg = gen_rtx_REG (SImode, REG_R0);
1094       rtx r1reg = gen_rtx_REG (SImode, REG_R1);
1095       rtx r2reg = gen_rtx_REG (SImode, REG_R2);
1096       rtx insn;
1097
1098       insn = emit_move_insn (r0reg, gen_rtx_REG (SImode, REG_SEQSTAT));
1099       insn = emit_insn (gen_ashrsi3 (r0reg, r0reg, GEN_INT (26)));
1100       insn = emit_insn (gen_ashlsi3 (r0reg, r0reg, GEN_INT (26)));
1101       insn = emit_move_insn (r1reg, spreg);
1102       insn = emit_move_insn (r2reg, gen_rtx_REG (Pmode, REG_FP));
1103       insn = emit_insn (gen_addsi3 (r2reg, r2reg, GEN_INT (8)));
1104     }
1105 }
1106
1107 /* Generate an epilogue suitable for a function of kind FKIND.  This is
1108    called for interrupt and exception handler epilogues.
1109    SPREG contains (reg:SI REG_SP).  */
1110
1111 static void
1112 expand_interrupt_handler_epilogue (rtx spreg, e_funkind fkind, bool all)
1113 {
1114   tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
1115   rtx postinc1 = gen_rtx_POST_INC (SImode, spreg);
1116   rtx postinc = gen_rtx_MEM (SImode, postinc1);
1117
1118   /* A slightly crude technique to stop flow from trying to delete "dead"
1119      insns.  */
1120   MEM_VOLATILE_P (postinc) = 1;
1121
1122   do_unlink (spreg, get_frame_size (), all, 1);
1123
1124   if (lookup_attribute ("nesting", attrs))
1125     {
1126       rtx srcreg = gen_rtx_REG (Pmode, (fkind == EXCPT_HANDLER ? REG_RETX
1127                                         : fkind == NMI_HANDLER ? REG_RETN
1128                                         : REG_RETI));
1129       emit_move_insn (srcreg, postinc);
1130     }
1131
1132   /* If we're calling other functions, they won't save their call-clobbered
1133      registers, so we must save (and restore) everything here.  */
1134   if (!current_function_is_leaf)
1135     all = true;
1136
1137   expand_epilogue_reg_restore (spreg, all, true);
1138
1139   /* Deallocate any space we left on the stack in case we needed to save the
1140      argument registers.  */
1141   if (fkind == EXCPT_HANDLER)
1142     emit_insn (gen_addsi3 (spreg, spreg, GEN_INT (12)));
1143
1144   emit_jump_insn (gen_return_internal (GEN_INT (fkind)));
1145 }
1146
1147 /* Used while emitting the prologue to generate code to load the correct value
1148    into the PIC register, which is passed in DEST.  */
1149
1150 static rtx
1151 bfin_load_pic_reg (rtx dest)
1152 {
1153   struct cgraph_local_info *i = NULL;
1154   rtx addr, insn;
1155  
1156   i = cgraph_local_info (current_function_decl);
1157  
1158   /* Functions local to the translation unit don't need to reload the
1159      pic reg, since the caller always passes a usable one.  */
1160   if (i && i->local)
1161     return pic_offset_table_rtx;
1162       
1163   if (bfin_lib_id_given)
1164     addr = plus_constant (pic_offset_table_rtx, -4 - bfin_library_id * 4);
1165   else
1166     addr = gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
1167                          gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
1168                                          UNSPEC_LIBRARY_OFFSET));
1169   insn = emit_insn (gen_movsi (dest, gen_rtx_MEM (Pmode, addr)));
1170   return dest;
1171 }
1172
1173 /* Generate RTL for the prologue of the current function.  */
1174
1175 void
1176 bfin_expand_prologue (void)
1177 {
1178   HOST_WIDE_INT frame_size = get_frame_size ();
1179   rtx spreg = gen_rtx_REG (Pmode, REG_SP);
1180   e_funkind fkind = funkind (TREE_TYPE (current_function_decl));
1181   rtx pic_reg_loaded = NULL_RTX;
1182   tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
1183   bool all = lookup_attribute ("saveall", attrs) != NULL_TREE;
1184
1185   if (fkind != SUBROUTINE)
1186     {
1187       expand_interrupt_handler_prologue (spreg, fkind, all);
1188       return;
1189     }
1190
1191   if (crtl->limit_stack
1192       || (TARGET_STACK_CHECK_L1
1193           && !DECL_NO_LIMIT_STACK (current_function_decl)))
1194     {
1195       HOST_WIDE_INT offset
1196         = bfin_initial_elimination_offset (ARG_POINTER_REGNUM,
1197                                            STACK_POINTER_REGNUM);
1198       rtx lim = crtl->limit_stack ? stack_limit_rtx : NULL_RTX;
1199       rtx p2reg = gen_rtx_REG (Pmode, REG_P2);
1200
1201       if (!lim)
1202         {
1203           emit_move_insn (p2reg, gen_int_mode (0xFFB00000, SImode));
1204           emit_move_insn (p2reg, gen_rtx_MEM (Pmode, p2reg));
1205           lim = p2reg;
1206         }
1207       if (GET_CODE (lim) == SYMBOL_REF)
1208         {
1209           if (TARGET_ID_SHARED_LIBRARY)
1210             {
1211               rtx p1reg = gen_rtx_REG (Pmode, REG_P1);
1212               rtx val;
1213               pic_reg_loaded = bfin_load_pic_reg (p2reg);
1214               val = legitimize_pic_address (stack_limit_rtx, p1reg,
1215                                             pic_reg_loaded);
1216               emit_move_insn (p1reg, val);
1217               frame_related_constant_load (p2reg, offset, FALSE);
1218               emit_insn (gen_addsi3 (p2reg, p2reg, p1reg));
1219               lim = p2reg;
1220             }
1221           else
1222             {
1223               rtx limit = plus_constant (lim, offset);
1224               emit_move_insn (p2reg, limit);
1225               lim = p2reg;
1226             }
1227         }
1228       else
1229         {
1230           if (lim != p2reg)
1231             emit_move_insn (p2reg, lim);
1232           add_to_reg (p2reg, offset, 0, 0);
1233           lim = p2reg;
1234         }
1235       emit_insn (gen_compare_lt (bfin_cc_rtx, spreg, lim));
1236       emit_insn (gen_trapifcc ());
1237     }
1238   expand_prologue_reg_save (spreg, all, false);
1239
1240   do_link (spreg, frame_size, false);
1241
1242   if (TARGET_ID_SHARED_LIBRARY
1243       && !TARGET_SEP_DATA
1244       && (crtl->uses_pic_offset_table
1245           || !current_function_is_leaf))
1246     bfin_load_pic_reg (pic_offset_table_rtx);
1247 }
1248
1249 /* Generate RTL for the epilogue of the current function.  NEED_RETURN is zero
1250    if this is for a sibcall.  EH_RETURN is nonzero if we're expanding an
1251    eh_return pattern. SIBCALL_P is true if this is a sibcall epilogue,
1252    false otherwise.  */
1253
1254 void
1255 bfin_expand_epilogue (int need_return, int eh_return, bool sibcall_p)
1256 {
1257   rtx spreg = gen_rtx_REG (Pmode, REG_SP);
1258   e_funkind fkind = funkind (TREE_TYPE (current_function_decl));
1259   int e = sibcall_p ? -1 : 1;
1260   tree attrs = TYPE_ATTRIBUTES (TREE_TYPE (current_function_decl));
1261   bool all = lookup_attribute ("saveall", attrs) != NULL_TREE;
1262
1263   if (fkind != SUBROUTINE)
1264     {
1265       expand_interrupt_handler_epilogue (spreg, fkind, all);
1266       return;
1267     }
1268
1269   do_unlink (spreg, get_frame_size (), false, e);
1270
1271   expand_epilogue_reg_restore (spreg, all, false);
1272
1273   /* Omit the return insn if this is for a sibcall.  */
1274   if (! need_return)
1275     return;
1276
1277   if (eh_return)
1278     emit_insn (gen_addsi3 (spreg, spreg, gen_rtx_REG (Pmode, REG_P2)));
1279
1280   emit_jump_insn (gen_return_internal (GEN_INT (SUBROUTINE)));
1281 }
1282 \f
1283 /* Return nonzero if register OLD_REG can be renamed to register NEW_REG.  */
1284
1285 int
1286 bfin_hard_regno_rename_ok (unsigned int old_reg ATTRIBUTE_UNUSED,
1287                            unsigned int new_reg)
1288 {
1289   /* Interrupt functions can only use registers that have already been
1290      saved by the prologue, even if they would normally be
1291      call-clobbered.  */
1292
1293   if (funkind (TREE_TYPE (current_function_decl)) != SUBROUTINE
1294       && !df_regs_ever_live_p (new_reg))
1295     return 0;
1296
1297   return 1;
1298 }
1299
1300 /* Return the value of the return address for the frame COUNT steps up
1301    from the current frame, after the prologue.
1302    We punt for everything but the current frame by returning const0_rtx.  */
1303
1304 rtx
1305 bfin_return_addr_rtx (int count)
1306 {
1307   if (count != 0)
1308     return const0_rtx;
1309
1310   return get_hard_reg_initial_val (Pmode, REG_RETS);
1311 }
1312
1313 /* Try machine-dependent ways of modifying an illegitimate address X
1314    to be legitimate.  If we find one, return the new, valid address,
1315    otherwise return NULL_RTX.
1316
1317    OLDX is the address as it was before break_out_memory_refs was called.
1318    In some cases it is useful to look at this to decide what needs to be done.
1319
1320    MODE is the mode of the memory reference.  */
1321
1322 rtx
1323 legitimize_address (rtx x ATTRIBUTE_UNUSED, rtx oldx ATTRIBUTE_UNUSED,
1324                     enum machine_mode mode ATTRIBUTE_UNUSED)
1325 {
1326   return NULL_RTX;
1327 }
1328
1329 static rtx
1330 bfin_delegitimize_address (rtx orig_x)
1331 {
1332   rtx x = orig_x;
1333
1334   if (GET_CODE (x) != MEM)
1335     return orig_x;
1336
1337   x = XEXP (x, 0);
1338   if (GET_CODE (x) == PLUS
1339       && GET_CODE (XEXP (x, 1)) == UNSPEC
1340       && XINT (XEXP (x, 1), 1) == UNSPEC_MOVE_PIC
1341       && GET_CODE (XEXP (x, 0)) == REG
1342       && REGNO (XEXP (x, 0)) == PIC_OFFSET_TABLE_REGNUM)
1343     return XVECEXP (XEXP (x, 1), 0, 0);
1344
1345   return orig_x;
1346 }
1347
1348 /* This predicate is used to compute the length of a load/store insn.
1349    OP is a MEM rtx, we return nonzero if its addressing mode requires a
1350    32-bit instruction.  */
1351
1352 int
1353 effective_address_32bit_p (rtx op, enum machine_mode mode) 
1354 {
1355   HOST_WIDE_INT offset;
1356
1357   mode = GET_MODE (op);
1358   op = XEXP (op, 0);
1359
1360   if (GET_CODE (op) != PLUS)
1361     {
1362       gcc_assert (REG_P (op) || GET_CODE (op) == POST_INC
1363                   || GET_CODE (op) == PRE_DEC || GET_CODE (op) == POST_DEC);
1364       return 0;
1365     }
1366
1367   if (GET_CODE (XEXP (op, 1)) == UNSPEC)
1368     return 1;
1369
1370   offset = INTVAL (XEXP (op, 1));
1371
1372   /* All byte loads use a 16-bit offset.  */
1373   if (GET_MODE_SIZE (mode) == 1)
1374     return 1;
1375
1376   if (GET_MODE_SIZE (mode) == 4)
1377     {
1378       /* Frame pointer relative loads can use a negative offset, all others
1379          are restricted to a small positive one.  */
1380       if (XEXP (op, 0) == frame_pointer_rtx)
1381         return offset < -128 || offset > 60;
1382       return offset < 0 || offset > 60;
1383     }
1384
1385   /* Must be HImode now.  */
1386   return offset < 0 || offset > 30;
1387 }
1388
1389 /* Returns true if X is a memory reference using an I register.  */
1390 bool
1391 bfin_dsp_memref_p (rtx x)
1392 {
1393   if (! MEM_P (x))
1394     return false;
1395   x = XEXP (x, 0);
1396   if (GET_CODE (x) == POST_INC || GET_CODE (x) == PRE_INC
1397       || GET_CODE (x) == POST_DEC || GET_CODE (x) == PRE_DEC)
1398     x = XEXP (x, 0);
1399   return IREG_P (x);
1400 }
1401
1402 /* Return cost of the memory address ADDR.
1403    All addressing modes are equally cheap on the Blackfin.  */
1404
1405 static int
1406 bfin_address_cost (rtx addr ATTRIBUTE_UNUSED, bool speed ATTRIBUTE_UNUSED)
1407 {
1408   return 1;
1409 }
1410
1411 /* Subroutine of print_operand; used to print a memory reference X to FILE.  */
1412
1413 void
1414 print_address_operand (FILE *file, rtx x)
1415 {
1416   switch (GET_CODE (x))
1417     {
1418     case PLUS:
1419       output_address (XEXP (x, 0));
1420       fprintf (file, "+");
1421       output_address (XEXP (x, 1));
1422       break;
1423
1424     case PRE_DEC:
1425       fprintf (file, "--");
1426       output_address (XEXP (x, 0));    
1427       break;
1428     case POST_INC:
1429       output_address (XEXP (x, 0));
1430       fprintf (file, "++");
1431       break;
1432     case POST_DEC:
1433       output_address (XEXP (x, 0));
1434       fprintf (file, "--");
1435       break;
1436
1437     default:
1438       gcc_assert (GET_CODE (x) != MEM);
1439       print_operand (file, x, 0);
1440       break;
1441     }
1442 }
1443
1444 /* Adding intp DImode support by Tony
1445  * -- Q: (low  word)
1446  * -- R: (high word)
1447  */
1448
1449 void
1450 print_operand (FILE *file, rtx x, char code)
1451 {
1452   enum machine_mode mode;
1453
1454   if (code == '!')
1455     {
1456       if (GET_MODE (current_output_insn) == SImode)
1457         fprintf (file, " ||");
1458       else
1459         fprintf (file, ";");
1460       return;
1461     }
1462
1463   mode = GET_MODE (x);
1464
1465   switch (code)
1466     {
1467     case 'j':
1468       switch (GET_CODE (x))
1469         {
1470         case EQ:
1471           fprintf (file, "e");
1472           break;
1473         case NE:
1474           fprintf (file, "ne");
1475           break;
1476         case GT:
1477           fprintf (file, "g");
1478           break;
1479         case LT:
1480           fprintf (file, "l");
1481           break;
1482         case GE:
1483           fprintf (file, "ge");
1484           break;
1485         case LE:
1486           fprintf (file, "le");
1487           break;
1488         case GTU:
1489           fprintf (file, "g");
1490           break;
1491         case LTU:
1492           fprintf (file, "l");
1493           break;
1494         case GEU:
1495           fprintf (file, "ge");
1496           break;
1497         case LEU:
1498           fprintf (file, "le");
1499           break;
1500         default:
1501           output_operand_lossage ("invalid %%j value");
1502         }
1503       break;
1504     
1505     case 'J':                                    /* reverse logic */
1506       switch (GET_CODE(x))
1507         {
1508         case EQ:
1509           fprintf (file, "ne");
1510           break;
1511         case NE:
1512           fprintf (file, "e");
1513           break;
1514         case GT:
1515           fprintf (file, "le");
1516           break;
1517         case LT:
1518           fprintf (file, "ge");
1519           break;
1520         case GE:
1521           fprintf (file, "l");
1522           break;
1523         case LE:
1524           fprintf (file, "g");
1525           break;
1526         case GTU:
1527           fprintf (file, "le");
1528           break;
1529         case LTU:
1530           fprintf (file, "ge");
1531           break;
1532         case GEU:
1533           fprintf (file, "l");
1534           break;
1535         case LEU:
1536           fprintf (file, "g");
1537           break;
1538         default:
1539           output_operand_lossage ("invalid %%J value");
1540         }
1541       break;
1542
1543     default:
1544       switch (GET_CODE (x))
1545         {
1546         case REG:
1547           if (code == 'h')
1548             {
1549               if (REGNO (x) < 32)
1550                 fprintf (file, "%s", short_reg_names[REGNO (x)]);
1551               else
1552                 output_operand_lossage ("invalid operand for code '%c'", code);
1553             }
1554           else if (code == 'd')
1555             {
1556               if (REGNO (x) < 32)
1557                 fprintf (file, "%s", high_reg_names[REGNO (x)]);
1558               else
1559                 output_operand_lossage ("invalid operand for code '%c'", code);
1560             }
1561           else if (code == 'w')
1562             {
1563               if (REGNO (x) == REG_A0 || REGNO (x) == REG_A1)
1564                 fprintf (file, "%s.w", reg_names[REGNO (x)]);
1565               else
1566                 output_operand_lossage ("invalid operand for code '%c'", code);
1567             }
1568           else if (code == 'x')
1569             {
1570               if (REGNO (x) == REG_A0 || REGNO (x) == REG_A1)
1571                 fprintf (file, "%s.x", reg_names[REGNO (x)]);
1572               else
1573                 output_operand_lossage ("invalid operand for code '%c'", code);
1574             }
1575           else if (code == 'v')
1576             {
1577               if (REGNO (x) == REG_A0)
1578                 fprintf (file, "AV0");
1579               else if (REGNO (x) == REG_A1)
1580                 fprintf (file, "AV1");
1581               else
1582                 output_operand_lossage ("invalid operand for code '%c'", code);
1583             }
1584           else if (code == 'D')
1585             {
1586               if (D_REGNO_P (REGNO (x)))
1587                 fprintf (file, "%s", dregs_pair_names[REGNO (x)]);
1588               else
1589                 output_operand_lossage ("invalid operand for code '%c'", code);
1590             }
1591           else if (code == 'H')
1592             {
1593               if ((mode == DImode || mode == DFmode) && REG_P (x))
1594                 fprintf (file, "%s", reg_names[REGNO (x) + 1]);
1595               else
1596                 output_operand_lossage ("invalid operand for code '%c'", code);
1597             }
1598           else if (code == 'T')
1599             {
1600               if (D_REGNO_P (REGNO (x)))
1601                 fprintf (file, "%s", byte_reg_names[REGNO (x)]);
1602               else
1603                 output_operand_lossage ("invalid operand for code '%c'", code);
1604             }
1605           else 
1606             fprintf (file, "%s", reg_names[REGNO (x)]);
1607           break;
1608
1609         case MEM:
1610           fputc ('[', file);
1611           x = XEXP (x,0);
1612           print_address_operand (file, x);
1613           fputc (']', file);
1614           break;
1615
1616         case CONST_INT:
1617           if (code == 'M')
1618             {
1619               switch (INTVAL (x))
1620                 {
1621                 case MACFLAG_NONE:
1622                   break;
1623                 case MACFLAG_FU:
1624                   fputs ("(FU)", file);
1625                   break;
1626                 case MACFLAG_T:
1627                   fputs ("(T)", file);
1628                   break;
1629                 case MACFLAG_TFU:
1630                   fputs ("(TFU)", file);
1631                   break;
1632                 case MACFLAG_W32:
1633                   fputs ("(W32)", file);
1634                   break;
1635                 case MACFLAG_IS:
1636                   fputs ("(IS)", file);
1637                   break;
1638                 case MACFLAG_IU:
1639                   fputs ("(IU)", file);
1640                   break;
1641                 case MACFLAG_IH:
1642                   fputs ("(IH)", file);
1643                   break;
1644                 case MACFLAG_M:
1645                   fputs ("(M)", file);
1646                   break;
1647                 case MACFLAG_IS_M:
1648                   fputs ("(IS,M)", file);
1649                   break;
1650                 case MACFLAG_ISS2:
1651                   fputs ("(ISS2)", file);
1652                   break;
1653                 case MACFLAG_S2RND:
1654                   fputs ("(S2RND)", file);
1655                   break;
1656                 default:
1657                   gcc_unreachable ();
1658                 }
1659               break;
1660             }
1661           else if (code == 'b')
1662             {
1663               if (INTVAL (x) == 0)
1664                 fputs ("+=", file);
1665               else if (INTVAL (x) == 1)
1666                 fputs ("-=", file);
1667               else
1668                 gcc_unreachable ();
1669               break;
1670             }
1671           /* Moves to half registers with d or h modifiers always use unsigned
1672              constants.  */
1673           else if (code == 'd')
1674             x = GEN_INT ((INTVAL (x) >> 16) & 0xffff);
1675           else if (code == 'h')
1676             x = GEN_INT (INTVAL (x) & 0xffff);
1677           else if (code == 'N')
1678             x = GEN_INT (-INTVAL (x));
1679           else if (code == 'X')
1680             x = GEN_INT (exact_log2 (0xffffffff & INTVAL (x)));
1681           else if (code == 'Y')
1682             x = GEN_INT (exact_log2 (0xffffffff & ~INTVAL (x)));
1683           else if (code == 'Z')
1684             /* Used for LINK insns.  */
1685             x = GEN_INT (-8 - INTVAL (x));
1686
1687           /* fall through */
1688
1689         case SYMBOL_REF:
1690           output_addr_const (file, x);
1691           break;
1692
1693         case CONST_DOUBLE:
1694           output_operand_lossage ("invalid const_double operand");
1695           break;
1696
1697         case UNSPEC:
1698           switch (XINT (x, 1))
1699             {
1700             case UNSPEC_MOVE_PIC:
1701               output_addr_const (file, XVECEXP (x, 0, 0));
1702               fprintf (file, "@GOT");
1703               break;
1704
1705             case UNSPEC_MOVE_FDPIC:
1706               output_addr_const (file, XVECEXP (x, 0, 0));
1707               fprintf (file, "@GOT17M4");
1708               break;
1709
1710             case UNSPEC_FUNCDESC_GOT17M4:
1711               output_addr_const (file, XVECEXP (x, 0, 0));
1712               fprintf (file, "@FUNCDESC_GOT17M4");
1713               break;
1714
1715             case UNSPEC_LIBRARY_OFFSET:
1716               fprintf (file, "_current_shared_library_p5_offset_");
1717               break;
1718
1719             default:
1720               gcc_unreachable ();
1721             }
1722           break;
1723
1724         default:
1725           output_addr_const (file, x);
1726         }
1727     }
1728 }
1729 \f
1730 /* Argument support functions.  */
1731
1732 /* Initialize a variable CUM of type CUMULATIVE_ARGS
1733    for a call to a function whose data type is FNTYPE.
1734    For a library call, FNTYPE is 0.  
1735    VDSP C Compiler manual, our ABI says that
1736    first 3 words of arguments will use R0, R1 and R2.
1737 */
1738
1739 void
1740 init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype,
1741                       rtx libname ATTRIBUTE_UNUSED)
1742 {
1743   static CUMULATIVE_ARGS zero_cum;
1744
1745   *cum = zero_cum;
1746
1747   /* Set up the number of registers to use for passing arguments.  */
1748
1749   cum->nregs = max_arg_registers;
1750   cum->arg_regs = arg_regs;
1751
1752   cum->call_cookie = CALL_NORMAL;
1753   /* Check for a longcall attribute.  */
1754   if (fntype && lookup_attribute ("shortcall", TYPE_ATTRIBUTES (fntype)))
1755     cum->call_cookie |= CALL_SHORT;
1756   else if (fntype && lookup_attribute ("longcall", TYPE_ATTRIBUTES (fntype)))
1757     cum->call_cookie |= CALL_LONG;
1758
1759   return;
1760 }
1761
1762 /* Update the data in CUM to advance over an argument
1763    of mode MODE and data type TYPE.
1764    (TYPE is null for libcalls where that information may not be available.)  */
1765
1766 void
1767 function_arg_advance (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
1768                       int named ATTRIBUTE_UNUSED)
1769 {
1770   int count, bytes, words;
1771
1772   bytes = (mode == BLKmode) ? int_size_in_bytes (type) : GET_MODE_SIZE (mode);
1773   words = (bytes + UNITS_PER_WORD - 1) / UNITS_PER_WORD;
1774
1775   cum->words += words;
1776   cum->nregs -= words;
1777
1778   if (cum->nregs <= 0)
1779     {
1780       cum->nregs = 0;
1781       cum->arg_regs = NULL;
1782     }
1783   else
1784     {
1785       for (count = 1; count <= words; count++)
1786         cum->arg_regs++;
1787     }
1788
1789   return;
1790 }
1791
1792 /* Define where to put the arguments to a function.
1793    Value is zero to push the argument on the stack,
1794    or a hard register in which to store the argument.
1795
1796    MODE is the argument's machine mode.
1797    TYPE is the data type of the argument (as a tree).
1798     This is null for libcalls where that information may
1799     not be available.
1800    CUM is a variable of type CUMULATIVE_ARGS which gives info about
1801     the preceding args and about the function being called.
1802    NAMED is nonzero if this argument is a named parameter
1803     (otherwise it is an extra parameter matching an ellipsis).  */
1804
1805 struct rtx_def *
1806 function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
1807               int named ATTRIBUTE_UNUSED)
1808 {
1809   int bytes
1810     = (mode == BLKmode) ? int_size_in_bytes (type) : GET_MODE_SIZE (mode);
1811
1812   if (mode == VOIDmode)
1813     /* Compute operand 2 of the call insn.  */
1814     return GEN_INT (cum->call_cookie);
1815
1816   if (bytes == -1)
1817     return NULL_RTX;
1818
1819   if (cum->nregs)
1820     return gen_rtx_REG (mode, *(cum->arg_regs));
1821
1822   return NULL_RTX;
1823 }
1824
1825 /* For an arg passed partly in registers and partly in memory,
1826    this is the number of bytes passed in registers.
1827    For args passed entirely in registers or entirely in memory, zero.
1828
1829    Refer VDSP C Compiler manual, our ABI.
1830    First 3 words are in registers. So, if an argument is larger
1831    than the registers available, it will span the register and
1832    stack.   */
1833
1834 static int
1835 bfin_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
1836                         tree type ATTRIBUTE_UNUSED,
1837                         bool named ATTRIBUTE_UNUSED)
1838 {
1839   int bytes
1840     = (mode == BLKmode) ? int_size_in_bytes (type) : GET_MODE_SIZE (mode);
1841   int bytes_left = cum->nregs * UNITS_PER_WORD;
1842   
1843   if (bytes == -1)
1844     return 0;
1845
1846   if (bytes_left == 0)
1847     return 0;
1848   if (bytes > bytes_left)
1849     return bytes_left;
1850   return 0;
1851 }
1852
1853 /* Variable sized types are passed by reference.  */
1854
1855 static bool
1856 bfin_pass_by_reference (CUMULATIVE_ARGS *cum ATTRIBUTE_UNUSED,
1857                         enum machine_mode mode ATTRIBUTE_UNUSED,
1858                         const_tree type, bool named ATTRIBUTE_UNUSED)
1859 {
1860   return type && TREE_CODE (TYPE_SIZE (type)) != INTEGER_CST;
1861 }
1862
1863 /* Decide whether a type should be returned in memory (true)
1864    or in a register (false).  This is called by the macro
1865    TARGET_RETURN_IN_MEMORY.  */
1866
1867 static bool
1868 bfin_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
1869 {
1870   int size = int_size_in_bytes (type);
1871   return size > 2 * UNITS_PER_WORD || size == -1;
1872 }
1873
1874 /* Register in which address to store a structure value
1875    is passed to a function.  */
1876 static rtx
1877 bfin_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED,
1878                       int incoming ATTRIBUTE_UNUSED)
1879 {
1880   return gen_rtx_REG (Pmode, REG_P0);
1881 }
1882
1883 /* Return true when register may be used to pass function parameters.  */
1884
1885 bool 
1886 function_arg_regno_p (int n)
1887 {
1888   int i;
1889   for (i = 0; arg_regs[i] != -1; i++)
1890     if (n == arg_regs[i])
1891       return true;
1892   return false;
1893 }
1894
1895 /* Returns 1 if OP contains a symbol reference */
1896
1897 int
1898 symbolic_reference_mentioned_p (rtx op)
1899 {
1900   register const char *fmt;
1901   register int i;
1902
1903   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
1904     return 1;
1905
1906   fmt = GET_RTX_FORMAT (GET_CODE (op));
1907   for (i = GET_RTX_LENGTH (GET_CODE (op)) - 1; i >= 0; i--)
1908     {
1909       if (fmt[i] == 'E')
1910         {
1911           register int j;
1912
1913           for (j = XVECLEN (op, i) - 1; j >= 0; j--)
1914             if (symbolic_reference_mentioned_p (XVECEXP (op, i, j)))
1915               return 1;
1916         }
1917
1918       else if (fmt[i] == 'e' && symbolic_reference_mentioned_p (XEXP (op, i)))
1919         return 1;
1920     }
1921
1922   return 0;
1923 }
1924
1925 /* Decide whether we can make a sibling call to a function.  DECL is the
1926    declaration of the function being targeted by the call and EXP is the
1927    CALL_EXPR representing the call.  */
1928
1929 static bool
1930 bfin_function_ok_for_sibcall (tree decl ATTRIBUTE_UNUSED,
1931                               tree exp ATTRIBUTE_UNUSED)
1932 {
1933   struct cgraph_local_info *this_func, *called_func;
1934   e_funkind fkind = funkind (TREE_TYPE (current_function_decl));
1935   if (fkind != SUBROUTINE)
1936     return false;
1937   if (!TARGET_ID_SHARED_LIBRARY || TARGET_SEP_DATA)
1938     return true;
1939
1940   /* When compiling for ID shared libraries, can't sibcall a local function
1941      from a non-local function, because the local function thinks it does
1942      not need to reload P5 in the prologue, but the sibcall wil pop P5 in the
1943      sibcall epilogue, and we end up with the wrong value in P5.  */
1944
1945   if (!decl)
1946     /* Not enough information.  */
1947     return false;
1948  
1949   this_func = cgraph_local_info (current_function_decl);
1950   called_func = cgraph_local_info (decl);
1951   return !called_func->local || this_func->local;
1952 }
1953 \f
1954 /* Emit RTL insns to initialize the variable parts of a trampoline at
1955    TRAMP. FNADDR is an RTX for the address of the function's pure
1956    code.  CXT is an RTX for the static chain value for the function.  */
1957
1958 void
1959 initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
1960 {
1961   rtx t1 = copy_to_reg (fnaddr);
1962   rtx t2 = copy_to_reg (cxt);
1963   rtx addr;
1964   int i = 0;
1965
1966   if (TARGET_FDPIC)
1967     {
1968       rtx a = memory_address (Pmode, plus_constant (tramp, 8));
1969       addr = memory_address (Pmode, tramp);
1970       emit_move_insn (gen_rtx_MEM (SImode, addr), a);
1971       i = 8;
1972     }
1973
1974   addr = memory_address (Pmode, plus_constant (tramp, i + 2));
1975   emit_move_insn (gen_rtx_MEM (HImode, addr), gen_lowpart (HImode, t1));
1976   emit_insn (gen_ashrsi3 (t1, t1, GEN_INT (16)));
1977   addr = memory_address (Pmode, plus_constant (tramp, i + 6));
1978   emit_move_insn (gen_rtx_MEM (HImode, addr), gen_lowpart (HImode, t1));
1979
1980   addr = memory_address (Pmode, plus_constant (tramp, i + 10));
1981   emit_move_insn (gen_rtx_MEM (HImode, addr), gen_lowpart (HImode, t2));
1982   emit_insn (gen_ashrsi3 (t2, t2, GEN_INT (16)));
1983   addr = memory_address (Pmode, plus_constant (tramp, i + 14));
1984   emit_move_insn (gen_rtx_MEM (HImode, addr), gen_lowpart (HImode, t2));
1985 }
1986
1987 /* Emit insns to move operands[1] into operands[0].  */
1988
1989 void
1990 emit_pic_move (rtx *operands, enum machine_mode mode ATTRIBUTE_UNUSED)
1991 {
1992   rtx temp = reload_in_progress ? operands[0] : gen_reg_rtx (Pmode);
1993
1994   gcc_assert (!TARGET_FDPIC || !(reload_in_progress || reload_completed));
1995   if (GET_CODE (operands[0]) == MEM && SYMBOLIC_CONST (operands[1]))
1996     operands[1] = force_reg (SImode, operands[1]);
1997   else
1998     operands[1] = legitimize_pic_address (operands[1], temp,
1999                                           TARGET_FDPIC ? OUR_FDPIC_REG
2000                                           : pic_offset_table_rtx);
2001 }
2002
2003 /* Expand a move operation in mode MODE.  The operands are in OPERANDS.
2004    Returns true if no further code must be generated, false if the caller
2005    should generate an insn to move OPERANDS[1] to OPERANDS[0].  */
2006
2007 bool
2008 expand_move (rtx *operands, enum machine_mode mode)
2009 {
2010   rtx op = operands[1];
2011   if ((TARGET_ID_SHARED_LIBRARY || TARGET_FDPIC)
2012       && SYMBOLIC_CONST (op))
2013     emit_pic_move (operands, mode);
2014   else if (mode == SImode && GET_CODE (op) == CONST
2015            && GET_CODE (XEXP (op, 0)) == PLUS
2016            && GET_CODE (XEXP (XEXP (op, 0), 0)) == SYMBOL_REF
2017            && !bfin_legitimate_constant_p (op))
2018     {
2019       rtx dest = operands[0];
2020       rtx op0, op1;
2021       gcc_assert (!reload_in_progress && !reload_completed);
2022       op = XEXP (op, 0);
2023       op0 = force_reg (mode, XEXP (op, 0));
2024       op1 = XEXP (op, 1);
2025       if (!insn_data[CODE_FOR_addsi3].operand[2].predicate (op1, mode))
2026         op1 = force_reg (mode, op1);
2027       if (GET_CODE (dest) == MEM)
2028         dest = gen_reg_rtx (mode);
2029       emit_insn (gen_addsi3 (dest, op0, op1));
2030       if (dest == operands[0])
2031         return true;
2032       operands[1] = dest;
2033     }
2034   /* Don't generate memory->memory or constant->memory moves, go through a
2035      register */
2036   else if ((reload_in_progress | reload_completed) == 0
2037            && GET_CODE (operands[0]) == MEM
2038            && GET_CODE (operands[1]) != REG)
2039     operands[1] = force_reg (mode, operands[1]);
2040   return false;
2041 }
2042 \f
2043 /* Split one or more DImode RTL references into pairs of SImode
2044    references.  The RTL can be REG, offsettable MEM, integer constant, or
2045    CONST_DOUBLE.  "operands" is a pointer to an array of DImode RTL to
2046    split and "num" is its length.  lo_half and hi_half are output arrays
2047    that parallel "operands".  */
2048
2049 void
2050 split_di (rtx operands[], int num, rtx lo_half[], rtx hi_half[])
2051 {
2052   while (num--)
2053     {
2054       rtx op = operands[num];
2055
2056       /* simplify_subreg refuse to split volatile memory addresses,
2057          but we still have to handle it.  */
2058       if (GET_CODE (op) == MEM)
2059         {
2060           lo_half[num] = adjust_address (op, SImode, 0);
2061           hi_half[num] = adjust_address (op, SImode, 4);
2062         }
2063       else
2064         {
2065           lo_half[num] = simplify_gen_subreg (SImode, op,
2066                                               GET_MODE (op) == VOIDmode
2067                                               ? DImode : GET_MODE (op), 0);
2068           hi_half[num] = simplify_gen_subreg (SImode, op,
2069                                               GET_MODE (op) == VOIDmode
2070                                               ? DImode : GET_MODE (op), 4);
2071         }
2072     }
2073 }
2074 \f
2075 bool
2076 bfin_longcall_p (rtx op, int call_cookie)
2077 {
2078   gcc_assert (GET_CODE (op) == SYMBOL_REF);
2079   if (call_cookie & CALL_SHORT)
2080     return 0;
2081   if (call_cookie & CALL_LONG)
2082     return 1;
2083   if (TARGET_LONG_CALLS)
2084     return 1;
2085   return 0;
2086 }
2087
2088 /* Expand a call instruction.  FNADDR is the call target, RETVAL the return value.
2089    COOKIE is a CONST_INT holding the call_cookie prepared init_cumulative_args.
2090    SIBCALL is nonzero if this is a sibling call.  */
2091
2092 void
2093 bfin_expand_call (rtx retval, rtx fnaddr, rtx callarg1, rtx cookie, int sibcall)
2094 {
2095   rtx use = NULL, call;
2096   rtx callee = XEXP (fnaddr, 0);
2097   int nelts = 2 + !!sibcall;
2098   rtx pat;
2099   rtx picreg = get_hard_reg_initial_val (SImode, FDPIC_REGNO);
2100   int n;
2101
2102   /* In an untyped call, we can get NULL for operand 2.  */
2103   if (cookie == NULL_RTX)
2104     cookie = const0_rtx;
2105
2106   /* Static functions and indirect calls don't need the pic register.  */
2107   if (!TARGET_FDPIC && flag_pic
2108       && GET_CODE (callee) == SYMBOL_REF
2109       && !SYMBOL_REF_LOCAL_P (callee))
2110     use_reg (&use, pic_offset_table_rtx);
2111
2112   if (TARGET_FDPIC)
2113     {
2114       int caller_has_l1_text, callee_has_l1_text;
2115
2116       caller_has_l1_text = callee_has_l1_text = 0;
2117
2118       if (lookup_attribute ("l1_text",
2119                             DECL_ATTRIBUTES (cfun->decl)) != NULL_TREE)
2120         caller_has_l1_text = 1;
2121
2122       if (GET_CODE (callee) == SYMBOL_REF
2123           && SYMBOL_REF_DECL (callee) && DECL_P (SYMBOL_REF_DECL (callee))
2124           && lookup_attribute
2125                ("l1_text",
2126                 DECL_ATTRIBUTES (SYMBOL_REF_DECL (callee))) != NULL_TREE)
2127         callee_has_l1_text = 1;
2128
2129       if (GET_CODE (callee) != SYMBOL_REF
2130           || bfin_longcall_p (callee, INTVAL (cookie))
2131           || (GET_CODE (callee) == SYMBOL_REF
2132               && !SYMBOL_REF_LOCAL_P (callee)
2133               && TARGET_INLINE_PLT)
2134           || caller_has_l1_text != callee_has_l1_text
2135           || (caller_has_l1_text && callee_has_l1_text
2136               && (GET_CODE (callee) != SYMBOL_REF
2137                   || !SYMBOL_REF_LOCAL_P (callee))))
2138         {
2139           rtx addr = callee;
2140           if (! address_operand (addr, Pmode))
2141             addr = force_reg (Pmode, addr);
2142
2143           fnaddr = gen_reg_rtx (SImode);
2144           emit_insn (gen_load_funcdescsi (fnaddr, addr));
2145           fnaddr = gen_rtx_MEM (Pmode, fnaddr);
2146
2147           picreg = gen_reg_rtx (SImode);
2148           emit_insn (gen_load_funcdescsi (picreg,
2149                                           plus_constant (addr, 4)));
2150         }
2151
2152       nelts++;
2153     }
2154   else if ((!register_no_elim_operand (callee, Pmode)
2155             && GET_CODE (callee) != SYMBOL_REF)
2156            || (GET_CODE (callee) == SYMBOL_REF
2157                && ((TARGET_ID_SHARED_LIBRARY && !TARGET_LEAF_ID_SHARED_LIBRARY)
2158                    || bfin_longcall_p (callee, INTVAL (cookie)))))
2159     {
2160       callee = copy_to_mode_reg (Pmode, callee);
2161       fnaddr = gen_rtx_MEM (Pmode, callee);
2162     }
2163   call = gen_rtx_CALL (VOIDmode, fnaddr, callarg1);
2164
2165   if (retval)
2166     call = gen_rtx_SET (VOIDmode, retval, call);
2167
2168   pat = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nelts));
2169   n = 0;
2170   XVECEXP (pat, 0, n++) = call;
2171   if (TARGET_FDPIC)
2172     XVECEXP (pat, 0, n++) = gen_rtx_USE (VOIDmode, picreg);
2173   XVECEXP (pat, 0, n++) = gen_rtx_USE (VOIDmode, cookie);
2174   if (sibcall)
2175     XVECEXP (pat, 0, n++) = gen_rtx_RETURN (VOIDmode);
2176   call = emit_call_insn (pat);
2177   if (use)
2178     CALL_INSN_FUNCTION_USAGE (call) = use;
2179 }
2180 \f
2181 /* Return 1 if hard register REGNO can hold a value of machine-mode MODE.  */
2182
2183 int
2184 hard_regno_mode_ok (int regno, enum machine_mode mode)
2185 {
2186   /* Allow only dregs to store value of mode HI or QI */
2187   enum reg_class rclass = REGNO_REG_CLASS (regno);
2188
2189   if (mode == CCmode)
2190     return 0;
2191
2192   if (mode == V2HImode)
2193     return D_REGNO_P (regno);
2194   if (rclass == CCREGS)
2195     return mode == BImode;
2196   if (mode == PDImode || mode == V2PDImode)
2197     return regno == REG_A0 || regno == REG_A1;
2198
2199   /* Allow all normal 32-bit regs, except REG_M3, in case regclass ever comes
2200      up with a bad register class (such as ALL_REGS) for DImode.  */
2201   if (mode == DImode)
2202     return regno < REG_M3;
2203
2204   if (mode == SImode
2205       && TEST_HARD_REG_BIT (reg_class_contents[PROLOGUE_REGS], regno))
2206     return 1;
2207
2208   return TEST_HARD_REG_BIT (reg_class_contents[MOST_REGS], regno);
2209 }
2210
2211 /* Implements target hook vector_mode_supported_p.  */
2212
2213 static bool
2214 bfin_vector_mode_supported_p (enum machine_mode mode)
2215 {
2216   return mode == V2HImode;
2217 }
2218
2219 /* Return the cost of moving data from a register in class CLASS1 to
2220    one in class CLASS2.  A cost of 2 is the default.  */
2221
2222 int
2223 bfin_register_move_cost (enum machine_mode mode,
2224                          enum reg_class class1, enum reg_class class2)
2225 {
2226   /* These need secondary reloads, so they're more expensive.  */
2227   if ((class1 == CCREGS && class2 != DREGS)
2228       || (class1 != DREGS && class2 == CCREGS))
2229     return 4;
2230
2231   /* If optimizing for size, always prefer reg-reg over reg-memory moves.  */
2232   if (optimize_size)
2233     return 2;
2234
2235   /* There are some stalls involved when moving from a DREG to a different
2236      class reg, and using the value in one of the following instructions.
2237      Attempt to model this by slightly discouraging such moves.  */
2238   if (class1 == DREGS && class2 != DREGS)
2239     return 2 * 2;
2240
2241   if (GET_MODE_CLASS (mode) == MODE_INT)
2242     {
2243       /* Discourage trying to use the accumulators.  */
2244       if (TEST_HARD_REG_BIT (reg_class_contents[class1], REG_A0)
2245           || TEST_HARD_REG_BIT (reg_class_contents[class1], REG_A1)
2246           || TEST_HARD_REG_BIT (reg_class_contents[class2], REG_A0)
2247           || TEST_HARD_REG_BIT (reg_class_contents[class2], REG_A1))
2248         return 20;
2249     }
2250   return 2;
2251 }
2252
2253 /* Return the cost of moving data of mode M between a
2254    register and memory.  A value of 2 is the default; this cost is
2255    relative to those in `REGISTER_MOVE_COST'.
2256
2257    ??? In theory L1 memory has single-cycle latency.  We should add a switch
2258    that tells the compiler whether we expect to use only L1 memory for the
2259    program; it'll make the costs more accurate.  */
2260
2261 int
2262 bfin_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
2263                        enum reg_class rclass,
2264                        int in ATTRIBUTE_UNUSED)
2265 {
2266   /* Make memory accesses slightly more expensive than any register-register
2267      move.  Also, penalize non-DP registers, since they need secondary
2268      reloads to load and store.  */
2269   if (! reg_class_subset_p (rclass, DPREGS))
2270     return 10;
2271
2272   return 8;
2273 }
2274
2275 /* Inform reload about cases where moving X with a mode MODE to a register in
2276    RCLASS requires an extra scratch register.  Return the class needed for the
2277    scratch register.  */
2278
2279 static enum reg_class
2280 bfin_secondary_reload (bool in_p, rtx x, enum reg_class rclass,
2281                        enum machine_mode mode, secondary_reload_info *sri)
2282 {
2283   /* If we have HImode or QImode, we can only use DREGS as secondary registers;
2284      in most other cases we can also use PREGS.  */
2285   enum reg_class default_class = GET_MODE_SIZE (mode) >= 4 ? DPREGS : DREGS;
2286   enum reg_class x_class = NO_REGS;
2287   enum rtx_code code = GET_CODE (x);
2288
2289   if (code == SUBREG)
2290     x = SUBREG_REG (x), code = GET_CODE (x);
2291   if (REG_P (x))
2292     {
2293       int regno = REGNO (x);
2294       if (regno >= FIRST_PSEUDO_REGISTER)
2295         regno = reg_renumber[regno];
2296
2297       if (regno == -1)
2298         code = MEM;
2299       else
2300         x_class = REGNO_REG_CLASS (regno);
2301     }
2302
2303   /* We can be asked to reload (plus (FP) (large_constant)) into a DREG.
2304      This happens as a side effect of register elimination, and we need
2305      a scratch register to do it.  */
2306   if (fp_plus_const_operand (x, mode))
2307     {
2308       rtx op2 = XEXP (x, 1);
2309       int large_constant_p = ! satisfies_constraint_Ks7 (op2);
2310
2311       if (rclass == PREGS || rclass == PREGS_CLOBBERED)
2312         return NO_REGS;
2313       /* If destination is a DREG, we can do this without a scratch register
2314          if the constant is valid for an add instruction.  */
2315       if ((rclass == DREGS || rclass == DPREGS)
2316           && ! large_constant_p)
2317         return NO_REGS;
2318       /* Reloading to anything other than a DREG?  Use a PREG scratch
2319          register.  */
2320       sri->icode = CODE_FOR_reload_insi;
2321       return NO_REGS;
2322     }
2323
2324   /* Data can usually be moved freely between registers of most classes.
2325      AREGS are an exception; they can only move to or from another register
2326      in AREGS or one in DREGS.  They can also be assigned the constant 0.  */
2327   if (x_class == AREGS || x_class == EVEN_AREGS || x_class == ODD_AREGS)
2328     return (rclass == DREGS || rclass == AREGS || rclass == EVEN_AREGS
2329             || rclass == ODD_AREGS
2330             ? NO_REGS : DREGS);
2331
2332   if (rclass == AREGS || rclass == EVEN_AREGS || rclass == ODD_AREGS)
2333     {
2334       if (code == MEM)
2335         {
2336           sri->icode = in_p ? CODE_FOR_reload_inpdi : CODE_FOR_reload_outpdi;
2337           return NO_REGS;
2338         }
2339
2340       if (x != const0_rtx && x_class != DREGS)
2341         {
2342           return DREGS;
2343         }
2344       else
2345         return NO_REGS;
2346     }
2347
2348   /* CCREGS can only be moved from/to DREGS.  */
2349   if (rclass == CCREGS && x_class != DREGS)
2350     return DREGS;
2351   if (x_class == CCREGS && rclass != DREGS)
2352     return DREGS;
2353
2354   /* All registers other than AREGS can load arbitrary constants.  The only
2355      case that remains is MEM.  */
2356   if (code == MEM)
2357     if (! reg_class_subset_p (rclass, default_class))
2358       return default_class;
2359
2360   return NO_REGS;
2361 }
2362 \f
2363 /* Implement TARGET_HANDLE_OPTION.  */
2364
2365 static bool
2366 bfin_handle_option (size_t code, const char *arg, int value)
2367 {
2368   switch (code)
2369     {
2370     case OPT_mshared_library_id_:
2371       if (value > MAX_LIBRARY_ID)
2372         error ("-mshared-library-id=%s is not between 0 and %d",
2373                arg, MAX_LIBRARY_ID);
2374       bfin_lib_id_given = 1;
2375       return true;
2376
2377     case OPT_mcpu_:
2378       {
2379         const char *p, *q;
2380         int i;
2381
2382         i = 0;
2383         while ((p = bfin_cpus[i].name) != NULL)
2384           {
2385             if (strncmp (arg, p, strlen (p)) == 0)
2386               break;
2387             i++;
2388           }
2389
2390         if (p == NULL)
2391           {
2392             error ("-mcpu=%s is not valid", arg);
2393             return false;
2394           }
2395
2396         bfin_cpu_type = bfin_cpus[i].type;
2397
2398         q = arg + strlen (p);
2399
2400         if (*q == '\0')
2401           {
2402             bfin_si_revision = bfin_cpus[i].si_revision;
2403             bfin_workarounds |= bfin_cpus[i].workarounds;
2404           }
2405         else if (strcmp (q, "-none") == 0)
2406           bfin_si_revision = -1;
2407         else if (strcmp (q, "-any") == 0)
2408           {
2409             bfin_si_revision = 0xffff;
2410             while (bfin_cpus[i].type == bfin_cpu_type)
2411               {
2412                 bfin_workarounds |= bfin_cpus[i].workarounds;
2413                 i++;
2414               }
2415           }
2416         else
2417           {
2418             unsigned int si_major, si_minor;
2419             int rev_len, n;
2420
2421             rev_len = strlen (q);
2422
2423             if (sscanf (q, "-%u.%u%n", &si_major, &si_minor, &n) != 2
2424                 || n != rev_len
2425                 || si_major > 0xff || si_minor > 0xff)
2426               {
2427               invalid_silicon_revision:
2428                 error ("-mcpu=%s has invalid silicon revision", arg);
2429                 return false;
2430               }
2431
2432             bfin_si_revision = (si_major << 8) | si_minor;
2433
2434             while (bfin_cpus[i].type == bfin_cpu_type
2435                    && bfin_cpus[i].si_revision != bfin_si_revision)
2436               i++;
2437
2438             if (bfin_cpus[i].type != bfin_cpu_type)
2439               goto invalid_silicon_revision;
2440
2441             bfin_workarounds |= bfin_cpus[i].workarounds;
2442           }
2443
2444         return true;
2445       }
2446
2447     default:
2448       return true;
2449     }
2450 }
2451
2452 static struct machine_function *
2453 bfin_init_machine_status (void)
2454 {
2455   struct machine_function *f;
2456
2457   f = GGC_CNEW (struct machine_function);
2458
2459   return f;
2460 }
2461
2462 /* Implement the macro OVERRIDE_OPTIONS.  */
2463
2464 void
2465 override_options (void)
2466 {
2467   /* If processor type is not specified, enable all workarounds.  */
2468   if (bfin_cpu_type == BFIN_CPU_UNKNOWN)
2469     {
2470       int i;
2471
2472       for (i = 0; bfin_cpus[i].name != NULL; i++)
2473         bfin_workarounds |= bfin_cpus[i].workarounds;
2474
2475       bfin_si_revision = 0xffff;
2476     }
2477
2478   if (bfin_csync_anomaly == 1)
2479     bfin_workarounds |= WA_SPECULATIVE_SYNCS;
2480   else if (bfin_csync_anomaly == 0)
2481     bfin_workarounds &= ~WA_SPECULATIVE_SYNCS;
2482
2483   if (bfin_specld_anomaly == 1)
2484     bfin_workarounds |= WA_SPECULATIVE_LOADS;
2485   else if (bfin_specld_anomaly == 0)
2486     bfin_workarounds &= ~WA_SPECULATIVE_LOADS;
2487
2488   if (TARGET_OMIT_LEAF_FRAME_POINTER)
2489     flag_omit_frame_pointer = 1;
2490
2491   /* Library identification */
2492   if (bfin_lib_id_given && ! TARGET_ID_SHARED_LIBRARY)
2493     error ("-mshared-library-id= specified without -mid-shared-library");
2494
2495   if (stack_limit_rtx && TARGET_STACK_CHECK_L1)
2496     error ("Can't use multiple stack checking methods together.");
2497
2498   if (TARGET_ID_SHARED_LIBRARY && TARGET_FDPIC)
2499     error ("ID shared libraries and FD-PIC mode can't be used together.");
2500
2501   /* Don't allow the user to specify -mid-shared-library and -msep-data
2502      together, as it makes little sense from a user's point of view...  */
2503   if (TARGET_SEP_DATA && TARGET_ID_SHARED_LIBRARY)
2504     error ("cannot specify both -msep-data and -mid-shared-library");
2505   /* ... internally, however, it's nearly the same.  */
2506   if (TARGET_SEP_DATA)
2507     target_flags |= MASK_ID_SHARED_LIBRARY | MASK_LEAF_ID_SHARED_LIBRARY;
2508
2509   if (TARGET_ID_SHARED_LIBRARY && flag_pic == 0)
2510     flag_pic = 1;
2511
2512   /* There is no single unaligned SI op for PIC code.  Sometimes we
2513      need to use ".4byte" and sometimes we need to use ".picptr".
2514      See bfin_assemble_integer for details.  */
2515   if (TARGET_FDPIC)
2516     targetm.asm_out.unaligned_op.si = 0;
2517
2518   /* Silently turn off flag_pic if not doing FDPIC or ID shared libraries,
2519      since we don't support it and it'll just break.  */
2520   if (flag_pic && !TARGET_FDPIC && !TARGET_ID_SHARED_LIBRARY)
2521     flag_pic = 0;
2522
2523   if (TARGET_MULTICORE && bfin_cpu_type != BFIN_CPU_BF561)
2524     error ("-mmulticore can only be used with BF561");
2525
2526   if (TARGET_COREA && !TARGET_MULTICORE)
2527     error ("-mcorea should be used with -mmulticore");
2528
2529   if (TARGET_COREB && !TARGET_MULTICORE)
2530     error ("-mcoreb should be used with -mmulticore");
2531
2532   if (TARGET_COREA && TARGET_COREB)
2533     error ("-mcorea and -mcoreb can't be used together");
2534
2535   flag_schedule_insns = 0;
2536
2537   /* Passes after sched2 can break the helpful TImode annotations that
2538      haifa-sched puts on every insn.  Just do scheduling in reorg.  */
2539   bfin_flag_schedule_insns2 = flag_schedule_insns_after_reload;
2540   flag_schedule_insns_after_reload = 0;
2541
2542   init_machine_status = bfin_init_machine_status;
2543 }
2544
2545 /* Return the destination address of BRANCH.
2546    We need to use this instead of get_attr_length, because the
2547    cbranch_with_nops pattern conservatively sets its length to 6, and
2548    we still prefer to use shorter sequences.  */
2549
2550 static int
2551 branch_dest (rtx branch)
2552 {
2553   rtx dest;
2554   int dest_uid;
2555   rtx pat = PATTERN (branch);
2556   if (GET_CODE (pat) == PARALLEL)
2557     pat = XVECEXP (pat, 0, 0);
2558   dest = SET_SRC (pat);
2559   if (GET_CODE (dest) == IF_THEN_ELSE)
2560     dest = XEXP (dest, 1);
2561   dest = XEXP (dest, 0);
2562   dest_uid = INSN_UID (dest);
2563   return INSN_ADDRESSES (dest_uid);
2564 }
2565
2566 /* Return nonzero if INSN is annotated with a REG_BR_PROB note that indicates
2567    it's a branch that's predicted taken.  */
2568
2569 static int
2570 cbranch_predicted_taken_p (rtx insn)
2571 {
2572   rtx x = find_reg_note (insn, REG_BR_PROB, 0);
2573
2574   if (x)
2575     {
2576       int pred_val = INTVAL (XEXP (x, 0));
2577
2578       return pred_val >= REG_BR_PROB_BASE / 2;
2579     }
2580
2581   return 0;
2582 }
2583
2584 /* Templates for use by asm_conditional_branch.  */
2585
2586 static const char *ccbranch_templates[][3] = {
2587   { "if !cc jump %3;",  "if cc jump 4 (bp); jump.s %3;",  "if cc jump 6 (bp); jump.l %3;" },
2588   { "if cc jump %3;",   "if !cc jump 4 (bp); jump.s %3;", "if !cc jump 6 (bp); jump.l %3;" },
2589   { "if !cc jump %3 (bp);",  "if cc jump 4; jump.s %3;",  "if cc jump 6; jump.l %3;" },
2590   { "if cc jump %3 (bp);",  "if !cc jump 4; jump.s %3;",  "if !cc jump 6; jump.l %3;" },
2591 };
2592
2593 /* Output INSN, which is a conditional branch instruction with operands
2594    OPERANDS.
2595
2596    We deal with the various forms of conditional branches that can be generated
2597    by bfin_reorg to prevent the hardware from doing speculative loads, by
2598    - emitting a sufficient number of nops, if N_NOPS is nonzero, or
2599    - always emitting the branch as predicted taken, if PREDICT_TAKEN is true.
2600    Either of these is only necessary if the branch is short, otherwise the
2601    template we use ends in an unconditional jump which flushes the pipeline
2602    anyway.  */
2603
2604 void
2605 asm_conditional_branch (rtx insn, rtx *operands, int n_nops, int predict_taken)
2606 {
2607   int offset = branch_dest (insn) - INSN_ADDRESSES (INSN_UID (insn));
2608   /* Note : offset for instructions like if cc jmp; jump.[sl] offset
2609             is to be taken from start of if cc rather than jump.
2610             Range for jump.s is (-4094, 4096) instead of (-4096, 4094)
2611   */
2612   int len = (offset >= -1024 && offset <= 1022 ? 0
2613              : offset >= -4094 && offset <= 4096 ? 1
2614              : 2);
2615   int bp = predict_taken && len == 0 ? 1 : cbranch_predicted_taken_p (insn);
2616   int idx = (bp << 1) | (GET_CODE (operands[0]) == EQ ? BRF : BRT);
2617   output_asm_insn (ccbranch_templates[idx][len], operands);
2618   gcc_assert (n_nops == 0 || !bp);
2619   if (len == 0)
2620     while (n_nops-- > 0)
2621       output_asm_insn ("nop;", NULL);
2622 }
2623
2624 /* Emit rtl for a comparison operation CMP in mode MODE.  Operands have been
2625    stored in bfin_compare_op0 and bfin_compare_op1 already.  */
2626
2627 rtx
2628 bfin_gen_compare (rtx cmp, enum machine_mode mode ATTRIBUTE_UNUSED)
2629 {
2630   enum rtx_code code1, code2;
2631   rtx op0 = bfin_compare_op0, op1 = bfin_compare_op1;
2632   rtx tem = bfin_cc_rtx;
2633   enum rtx_code code = GET_CODE (cmp);
2634
2635   /* If we have a BImode input, then we already have a compare result, and
2636      do not need to emit another comparison.  */
2637   if (GET_MODE (op0) == BImode)
2638     {
2639       gcc_assert ((code == NE || code == EQ) && op1 == const0_rtx);
2640       tem = op0, code2 = code;
2641     }
2642   else
2643     {
2644       switch (code) {
2645         /* bfin has these conditions */
2646       case EQ:
2647       case LT:
2648       case LE:
2649       case LEU:
2650       case LTU:
2651         code1 = code;
2652         code2 = NE;
2653         break;
2654       default:
2655         code1 = reverse_condition (code);
2656         code2 = EQ;
2657         break;
2658       }
2659       emit_insn (gen_rtx_SET (BImode, tem,
2660                               gen_rtx_fmt_ee (code1, BImode, op0, op1)));
2661     }
2662
2663   return gen_rtx_fmt_ee (code2, BImode, tem, CONST0_RTX (BImode));
2664 }
2665 \f
2666 /* Return nonzero iff C has exactly one bit set if it is interpreted
2667    as a 32-bit constant.  */
2668
2669 int
2670 log2constp (unsigned HOST_WIDE_INT c)
2671 {
2672   c &= 0xFFFFFFFF;
2673   return c != 0 && (c & (c-1)) == 0;
2674 }
2675
2676 /* Returns the number of consecutive least significant zeros in the binary
2677    representation of *V.
2678    We modify *V to contain the original value arithmetically shifted right by
2679    the number of zeroes.  */
2680
2681 static int
2682 shiftr_zero (HOST_WIDE_INT *v)
2683 {
2684   unsigned HOST_WIDE_INT tmp = *v;
2685   unsigned HOST_WIDE_INT sgn;
2686   int n = 0;
2687
2688   if (tmp == 0)
2689     return 0;
2690
2691   sgn = tmp & ((unsigned HOST_WIDE_INT) 1 << (HOST_BITS_PER_WIDE_INT - 1));
2692   while ((tmp & 0x1) == 0 && n <= 32)
2693     {
2694       tmp = (tmp >> 1) | sgn;
2695       n++;
2696     }
2697   *v = tmp;
2698   return n;
2699 }
2700
2701 /* After reload, split the load of an immediate constant.  OPERANDS are the
2702    operands of the movsi_insn pattern which we are splitting.  We return
2703    nonzero if we emitted a sequence to load the constant, zero if we emitted
2704    nothing because we want to use the splitter's default sequence.  */
2705
2706 int
2707 split_load_immediate (rtx operands[])
2708 {
2709   HOST_WIDE_INT val = INTVAL (operands[1]);
2710   HOST_WIDE_INT tmp;
2711   HOST_WIDE_INT shifted = val;
2712   HOST_WIDE_INT shifted_compl = ~val;
2713   int num_zero = shiftr_zero (&shifted);
2714   int num_compl_zero = shiftr_zero (&shifted_compl);
2715   unsigned int regno = REGNO (operands[0]);
2716
2717   /* This case takes care of single-bit set/clear constants, which we could
2718      also implement with BITSET/BITCLR.  */
2719   if (num_zero
2720       && shifted >= -32768 && shifted < 65536
2721       && (D_REGNO_P (regno)
2722           || (regno >= REG_P0 && regno <= REG_P7 && num_zero <= 2)))
2723     {
2724       emit_insn (gen_movsi (operands[0], GEN_INT (shifted)));
2725       emit_insn (gen_ashlsi3 (operands[0], operands[0], GEN_INT (num_zero)));
2726       return 1;
2727     }
2728
2729   tmp = val & 0xFFFF;
2730   tmp |= -(tmp & 0x8000);
2731
2732   /* If high word has one bit set or clear, try to use a bit operation.  */
2733   if (D_REGNO_P (regno))
2734     {
2735       if (log2constp (val & 0xFFFF0000))
2736         {
2737           emit_insn (gen_movsi (operands[0], GEN_INT (val & 0xFFFF)));
2738           emit_insn (gen_iorsi3 (operands[0], operands[0], GEN_INT (val & 0xFFFF0000)));
2739           return 1;
2740         }
2741       else if (log2constp (val | 0xFFFF) && (val & 0x8000) != 0)
2742         {
2743           emit_insn (gen_movsi (operands[0], GEN_INT (tmp)));
2744           emit_insn (gen_andsi3 (operands[0], operands[0], GEN_INT (val | 0xFFFF)));
2745         }
2746     }
2747
2748   if (D_REGNO_P (regno))
2749     {
2750       if (tmp >= -64 && tmp <= 63)
2751         {
2752           emit_insn (gen_movsi (operands[0], GEN_INT (tmp)));
2753           emit_insn (gen_movstricthi_high (operands[0], GEN_INT (val & -65536)));
2754           return 1;
2755         }
2756
2757       if ((val & 0xFFFF0000) == 0)
2758         {
2759           emit_insn (gen_movsi (operands[0], const0_rtx));
2760           emit_insn (gen_movsi_low (operands[0], operands[0], operands[1]));
2761           return 1;
2762         }
2763
2764       if ((val & 0xFFFF0000) == 0xFFFF0000)
2765         {
2766           emit_insn (gen_movsi (operands[0], constm1_rtx));
2767           emit_insn (gen_movsi_low (operands[0], operands[0], operands[1]));
2768           return 1;
2769         }
2770     }
2771
2772   /* Need DREGs for the remaining case.  */
2773   if (regno > REG_R7)
2774     return 0;
2775
2776   if (optimize_size
2777       && num_compl_zero && shifted_compl >= -64 && shifted_compl <= 63)
2778     {
2779       /* If optimizing for size, generate a sequence that has more instructions
2780          but is shorter.  */
2781       emit_insn (gen_movsi (operands[0], GEN_INT (shifted_compl)));
2782       emit_insn (gen_ashlsi3 (operands[0], operands[0],
2783                               GEN_INT (num_compl_zero)));
2784       emit_insn (gen_one_cmplsi2 (operands[0], operands[0]));
2785       return 1;
2786     }
2787   return 0;
2788 }
2789 \f
2790 /* Return true if the legitimate memory address for a memory operand of mode
2791    MODE.  Return false if not.  */
2792
2793 static bool
2794 bfin_valid_add (enum machine_mode mode, HOST_WIDE_INT value)
2795 {
2796   unsigned HOST_WIDE_INT v = value > 0 ? value : -value;
2797   int sz = GET_MODE_SIZE (mode);
2798   int shift = sz == 1 ? 0 : sz == 2 ? 1 : 2;
2799   /* The usual offsettable_memref machinery doesn't work so well for this
2800      port, so we deal with the problem here.  */
2801   if (value > 0 && sz == 8)
2802     v += 4;
2803   return (v & ~(0x7fff << shift)) == 0;
2804 }
2805
2806 static bool
2807 bfin_valid_reg_p (unsigned int regno, int strict, enum machine_mode mode,
2808                   enum rtx_code outer_code)
2809 {
2810   if (strict)
2811     return REGNO_OK_FOR_BASE_STRICT_P (regno, mode, outer_code, SCRATCH);
2812   else
2813     return REGNO_OK_FOR_BASE_NONSTRICT_P (regno, mode, outer_code, SCRATCH);
2814 }
2815
2816 bool
2817 bfin_legitimate_address_p (enum machine_mode mode, rtx x, int strict)
2818 {
2819   switch (GET_CODE (x)) {
2820   case REG:
2821     if (bfin_valid_reg_p (REGNO (x), strict, mode, MEM))
2822       return true;
2823     break;
2824   case PLUS:
2825     if (REG_P (XEXP (x, 0))
2826         && bfin_valid_reg_p (REGNO (XEXP (x, 0)), strict, mode, PLUS)
2827         && ((GET_CODE (XEXP (x, 1)) == UNSPEC && mode == SImode)
2828             || (GET_CODE (XEXP (x, 1)) == CONST_INT
2829                 && bfin_valid_add (mode, INTVAL (XEXP (x, 1))))))
2830       return true;
2831     break;
2832   case POST_INC:
2833   case POST_DEC:
2834     if (LEGITIMATE_MODE_FOR_AUTOINC_P (mode)
2835         && REG_P (XEXP (x, 0))
2836         && bfin_valid_reg_p (REGNO (XEXP (x, 0)), strict, mode, POST_INC))
2837       return true;
2838   case PRE_DEC:
2839     if (LEGITIMATE_MODE_FOR_AUTOINC_P (mode)
2840         && XEXP (x, 0) == stack_pointer_rtx
2841         && REG_P (XEXP (x, 0))
2842         && bfin_valid_reg_p (REGNO (XEXP (x, 0)), strict, mode, PRE_DEC))
2843       return true;
2844     break;
2845   default:
2846     break;
2847   }
2848   return false;
2849 }
2850
2851 /* Decide whether we can force certain constants to memory.  If we
2852    decide we can't, the caller should be able to cope with it in
2853    another way.  */
2854
2855 static bool
2856 bfin_cannot_force_const_mem (rtx x ATTRIBUTE_UNUSED)
2857 {
2858   /* We have only one class of non-legitimate constants, and our movsi
2859      expander knows how to handle them.  Dropping these constants into the
2860      data section would only shift the problem - we'd still get relocs
2861      outside the object, in the data section rather than the text section.  */
2862   return true;
2863 }
2864
2865 /* Ensure that for any constant of the form symbol + offset, the offset
2866    remains within the object.  Any other constants are ok.
2867    This ensures that flat binaries never have to deal with relocations
2868    crossing section boundaries.  */
2869
2870 bool
2871 bfin_legitimate_constant_p (rtx x)
2872 {
2873   rtx sym;
2874   HOST_WIDE_INT offset;
2875
2876   if (GET_CODE (x) != CONST)
2877     return true;
2878
2879   x = XEXP (x, 0);
2880   gcc_assert (GET_CODE (x) == PLUS);
2881
2882   sym = XEXP (x, 0);
2883   x = XEXP (x, 1);
2884   if (GET_CODE (sym) != SYMBOL_REF
2885       || GET_CODE (x) != CONST_INT)
2886     return true;
2887   offset = INTVAL (x);
2888
2889   if (SYMBOL_REF_DECL (sym) == 0)
2890     return true;
2891   if (offset < 0
2892       || offset >= int_size_in_bytes (TREE_TYPE (SYMBOL_REF_DECL (sym))))
2893     return false;
2894
2895   return true;
2896 }
2897
2898 static bool
2899 bfin_rtx_costs (rtx x, int code, int outer_code, int *total, bool speed)
2900 {
2901   int cost2 = COSTS_N_INSNS (1);
2902   rtx op0, op1;
2903
2904   switch (code)
2905     {
2906     case CONST_INT:
2907       if (outer_code == SET || outer_code == PLUS)
2908         *total = satisfies_constraint_Ks7 (x) ? 0 : cost2;
2909       else if (outer_code == AND)
2910         *total = log2constp (~INTVAL (x)) ? 0 : cost2;
2911       else if (outer_code == LE || outer_code == LT || outer_code == EQ)
2912         *total = (INTVAL (x) >= -4 && INTVAL (x) <= 3) ? 0 : cost2;
2913       else if (outer_code == LEU || outer_code == LTU)
2914         *total = (INTVAL (x) >= 0 && INTVAL (x) <= 7) ? 0 : cost2;
2915       else if (outer_code == MULT)
2916         *total = (INTVAL (x) == 2 || INTVAL (x) == 4) ? 0 : cost2;
2917       else if (outer_code == ASHIFT && (INTVAL (x) == 1 || INTVAL (x) == 2))
2918         *total = 0;
2919       else if (outer_code == ASHIFT || outer_code == ASHIFTRT
2920                || outer_code == LSHIFTRT)
2921         *total = (INTVAL (x) >= 0 && INTVAL (x) <= 31) ? 0 : cost2;
2922       else if (outer_code == IOR || outer_code == XOR)
2923         *total = (INTVAL (x) & (INTVAL (x) - 1)) == 0 ? 0 : cost2;
2924       else
2925         *total = cost2;
2926       return true;
2927
2928     case CONST:
2929     case LABEL_REF:
2930     case SYMBOL_REF:
2931     case CONST_DOUBLE:
2932       *total = COSTS_N_INSNS (2);
2933       return true;
2934
2935     case PLUS:
2936       op0 = XEXP (x, 0);
2937       op1 = XEXP (x, 1);
2938       if (GET_MODE (x) == SImode)
2939         {
2940           if (GET_CODE (op0) == MULT
2941               && GET_CODE (XEXP (op0, 1)) == CONST_INT)
2942             {
2943               HOST_WIDE_INT val = INTVAL (XEXP (op0, 1));
2944               if (val == 2 || val == 4)
2945                 {
2946                   *total = cost2;
2947                   *total += rtx_cost (XEXP (op0, 0), outer_code, speed);
2948                   *total += rtx_cost (op1, outer_code, speed);
2949                   return true;
2950                 }
2951             }
2952           *total = cost2;
2953           if (GET_CODE (op0) != REG
2954               && (GET_CODE (op0) != SUBREG || GET_CODE (SUBREG_REG (op0)) != REG))
2955             *total += rtx_cost (op0, SET, speed);
2956 #if 0 /* We'd like to do this for accuracy, but it biases the loop optimizer
2957          towards creating too many induction variables.  */
2958           if (!reg_or_7bit_operand (op1, SImode))
2959             *total += rtx_cost (op1, SET, speed);
2960 #endif
2961         }
2962       else if (GET_MODE (x) == DImode)
2963         {
2964           *total = 6 * cost2;
2965           if (GET_CODE (op1) != CONST_INT
2966               || !satisfies_constraint_Ks7 (op1))
2967             *total += rtx_cost (op1, PLUS, speed);
2968           if (GET_CODE (op0) != REG
2969               && (GET_CODE (op0) != SUBREG || GET_CODE (SUBREG_REG (op0)) != REG))
2970             *total += rtx_cost (op0, PLUS, speed);
2971         }
2972       return true;
2973
2974     case MINUS:
2975       if (GET_MODE (x) == DImode)
2976         *total = 6 * cost2;
2977       else
2978         *total = cost2;
2979       return true;
2980       
2981     case ASHIFT: 
2982     case ASHIFTRT:
2983     case LSHIFTRT:
2984       if (GET_MODE (x) == DImode)
2985         *total = 6 * cost2;
2986       else
2987         *total = cost2;
2988
2989       op0 = XEXP (x, 0);
2990       op1 = XEXP (x, 1);
2991       if (GET_CODE (op0) != REG
2992           && (GET_CODE (op0) != SUBREG || GET_CODE (SUBREG_REG (op0)) != REG))
2993         *total += rtx_cost (op0, code, speed);
2994
2995       return true;
2996           
2997     case IOR:
2998     case AND:
2999     case XOR:
3000       op0 = XEXP (x, 0);
3001       op1 = XEXP (x, 1);
3002
3003       /* Handle special cases of IOR: rotates, ALIGN insns, movstricthi_high.  */
3004       if (code == IOR)
3005         {
3006           if ((GET_CODE (op0) == LSHIFTRT && GET_CODE (op1) == ASHIFT)
3007               || (GET_CODE (op0) == ASHIFT && GET_CODE (op1) == ZERO_EXTEND)
3008               || (GET_CODE (op0) == ASHIFT && GET_CODE (op1) == LSHIFTRT)
3009               || (GET_CODE (op0) == AND && GET_CODE (op1) == CONST_INT))
3010             {
3011               *total = cost2;
3012               return true;
3013             }
3014         }
3015
3016       if (GET_CODE (op0) != REG
3017           && (GET_CODE (op0) != SUBREG || GET_CODE (SUBREG_REG (op0)) != REG))
3018         *total += rtx_cost (op0, code, speed);
3019
3020       if (GET_MODE (x) == DImode)
3021         {
3022           *total = 2 * cost2;
3023           return true;
3024         }
3025       *total = cost2;
3026       if (GET_MODE (x) != SImode)
3027         return true;
3028
3029       if (code == AND)
3030         {
3031           if (! rhs_andsi3_operand (XEXP (x, 1), SImode))
3032             *total += rtx_cost (XEXP (x, 1), code, speed);
3033         }
3034       else
3035         {
3036           if (! regorlog2_operand (XEXP (x, 1), SImode))
3037             *total += rtx_cost (XEXP (x, 1), code, speed);
3038         }
3039
3040       return true;
3041
3042     case ZERO_EXTRACT:
3043     case SIGN_EXTRACT:
3044       if (outer_code == SET
3045           && XEXP (x, 1) == const1_rtx
3046           && GET_CODE (XEXP (x, 2)) == CONST_INT)
3047         {
3048           *total = 2 * cost2;
3049           return true;
3050         }
3051       /* fall through */
3052
3053     case SIGN_EXTEND:
3054     case ZERO_EXTEND:
3055       *total = cost2;
3056       return true;
3057
3058     case MULT:
3059         {
3060           op0 = XEXP (x, 0);
3061           op1 = XEXP (x, 1);
3062           if (GET_CODE (op0) == GET_CODE (op1)
3063               && (GET_CODE (op0) == ZERO_EXTEND
3064                   || GET_CODE (op0) == SIGN_EXTEND))
3065             {
3066               *total = COSTS_N_INSNS (1);
3067               op0 = XEXP (op0, 0);
3068               op1 = XEXP (op1, 0);
3069             }
3070           else if (!speed)
3071             *total = COSTS_N_INSNS (1);
3072           else
3073             *total = COSTS_N_INSNS (3);
3074
3075           if (GET_CODE (op0) != REG
3076               && (GET_CODE (op0) != SUBREG || GET_CODE (SUBREG_REG (op0)) != REG))
3077             *total += rtx_cost (op0, MULT, speed);
3078           if (GET_CODE (op1) != REG
3079               && (GET_CODE (op1) != SUBREG || GET_CODE (SUBREG_REG (op1)) != REG))
3080             *total += rtx_cost (op1, MULT, speed);
3081         }
3082       return true;
3083
3084     case UDIV:
3085     case UMOD:
3086       *total = COSTS_N_INSNS (32);
3087       return true;
3088
3089     case VEC_CONCAT:
3090     case VEC_SELECT:
3091       if (outer_code == SET)
3092         *total = cost2;
3093       return true;
3094
3095     default:
3096       return false;
3097     }
3098 }
3099 \f
3100 /* Used for communication between {push,pop}_multiple_operation (which
3101    we use not only as a predicate) and the corresponding output functions.  */
3102 static int first_preg_to_save, first_dreg_to_save;
3103 static int n_regs_to_save;
3104
3105 int
3106 push_multiple_operation (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3107 {
3108   int lastdreg = 8, lastpreg = 6;
3109   int i, group;
3110
3111   first_preg_to_save = lastpreg;
3112   first_dreg_to_save = lastdreg;
3113   for (i = 1, group = 0; i < XVECLEN (op, 0) - 1; i++)
3114     {
3115       rtx t = XVECEXP (op, 0, i);
3116       rtx src, dest;
3117       int regno;
3118
3119       if (GET_CODE (t) != SET)
3120         return 0;
3121
3122       src = SET_SRC (t);
3123       dest = SET_DEST (t);
3124       if (GET_CODE (dest) != MEM || ! REG_P (src))
3125         return 0;
3126       dest = XEXP (dest, 0);
3127       if (GET_CODE (dest) != PLUS
3128           || ! REG_P (XEXP (dest, 0))
3129           || REGNO (XEXP (dest, 0)) != REG_SP
3130           || GET_CODE (XEXP (dest, 1)) != CONST_INT
3131           || INTVAL (XEXP (dest, 1)) != -i * 4)
3132         return 0;
3133
3134       regno = REGNO (src);
3135       if (group == 0)
3136         {
3137           if (D_REGNO_P (regno))
3138             {
3139               group = 1;
3140               first_dreg_to_save = lastdreg = regno - REG_R0;
3141             }
3142           else if (regno >= REG_P0 && regno <= REG_P7)
3143             {
3144               group = 2;
3145               first_preg_to_save = lastpreg = regno - REG_P0;
3146             }
3147           else
3148             return 0;
3149
3150           continue;
3151         }
3152
3153       if (group == 1)
3154         {
3155           if (regno >= REG_P0 && regno <= REG_P7)
3156             {
3157               group = 2;
3158               first_preg_to_save = lastpreg = regno - REG_P0;
3159             }
3160           else if (regno != REG_R0 + lastdreg + 1)
3161             return 0;
3162           else
3163             lastdreg++;
3164         }
3165       else if (group == 2)
3166         {
3167           if (regno != REG_P0 + lastpreg + 1)
3168             return 0;
3169           lastpreg++;
3170         }
3171     }
3172   n_regs_to_save = 8 - first_dreg_to_save + 6 - first_preg_to_save;
3173   return 1;
3174 }
3175
3176 int
3177 pop_multiple_operation (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3178 {
3179   int lastdreg = 8, lastpreg = 6;
3180   int i, group;
3181
3182   for (i = 1, group = 0; i < XVECLEN (op, 0); i++)
3183     {
3184       rtx t = XVECEXP (op, 0, i);
3185       rtx src, dest;
3186       int regno;
3187
3188       if (GET_CODE (t) != SET)
3189         return 0;
3190
3191       src = SET_SRC (t);
3192       dest = SET_DEST (t);
3193       if (GET_CODE (src) != MEM || ! REG_P (dest))
3194         return 0;
3195       src = XEXP (src, 0);
3196
3197       if (i == 1)
3198         {
3199           if (! REG_P (src) || REGNO (src) != REG_SP)
3200             return 0;
3201         }
3202       else if (GET_CODE (src) != PLUS
3203                || ! REG_P (XEXP (src, 0))
3204                || REGNO (XEXP (src, 0)) != REG_SP
3205                || GET_CODE (XEXP (src, 1)) != CONST_INT
3206                || INTVAL (XEXP (src, 1)) != (i - 1) * 4)
3207         return 0;
3208
3209       regno = REGNO (dest);
3210       if (group == 0)
3211         {
3212           if (regno == REG_R7)
3213             {
3214               group = 1;
3215               lastdreg = 7;
3216             }
3217           else if (regno != REG_P0 + lastpreg - 1)
3218             return 0;
3219           else
3220             lastpreg--;
3221         }
3222       else if (group == 1)
3223         {
3224           if (regno != REG_R0 + lastdreg - 1)
3225             return 0;
3226           else
3227             lastdreg--;
3228         }
3229     }
3230   first_dreg_to_save = lastdreg;
3231   first_preg_to_save = lastpreg;
3232   n_regs_to_save = 8 - first_dreg_to_save + 6 - first_preg_to_save;
3233   return 1;
3234 }
3235
3236 /* Emit assembly code for one multi-register push described by INSN, with
3237    operands in OPERANDS.  */
3238
3239 void
3240 output_push_multiple (rtx insn, rtx *operands)
3241 {
3242   char buf[80];
3243   int ok;
3244   
3245   /* Validate the insn again, and compute first_[dp]reg_to_save. */
3246   ok = push_multiple_operation (PATTERN (insn), VOIDmode);
3247   gcc_assert (ok);
3248   
3249   if (first_dreg_to_save == 8)
3250     sprintf (buf, "[--sp] = ( p5:%d );\n", first_preg_to_save);
3251   else if (first_preg_to_save == 6)
3252     sprintf (buf, "[--sp] = ( r7:%d );\n", first_dreg_to_save);
3253   else
3254     sprintf (buf, "[--sp] = ( r7:%d, p5:%d );\n",
3255              first_dreg_to_save, first_preg_to_save);
3256
3257   output_asm_insn (buf, operands);
3258 }
3259
3260 /* Emit assembly code for one multi-register pop described by INSN, with
3261    operands in OPERANDS.  */
3262
3263 void
3264 output_pop_multiple (rtx insn, rtx *operands)
3265 {
3266   char buf[80];
3267   int ok;
3268   
3269   /* Validate the insn again, and compute first_[dp]reg_to_save. */
3270   ok = pop_multiple_operation (PATTERN (insn), VOIDmode);
3271   gcc_assert (ok);
3272
3273   if (first_dreg_to_save == 8)
3274     sprintf (buf, "( p5:%d ) = [sp++];\n", first_preg_to_save);
3275   else if (first_preg_to_save == 6)
3276     sprintf (buf, "( r7:%d ) = [sp++];\n", first_dreg_to_save);
3277   else
3278     sprintf (buf, "( r7:%d, p5:%d ) = [sp++];\n",
3279              first_dreg_to_save, first_preg_to_save);
3280
3281   output_asm_insn (buf, operands);
3282 }
3283
3284 /* Adjust DST and SRC by OFFSET bytes, and generate one move in mode MODE.  */
3285
3286 static void
3287 single_move_for_movmem (rtx dst, rtx src, enum machine_mode mode, HOST_WIDE_INT offset)
3288 {
3289   rtx scratch = gen_reg_rtx (mode);
3290   rtx srcmem, dstmem;
3291
3292   srcmem = adjust_address_nv (src, mode, offset);
3293   dstmem = adjust_address_nv (dst, mode, offset);
3294   emit_move_insn (scratch, srcmem);
3295   emit_move_insn (dstmem, scratch);
3296 }
3297
3298 /* Expand a string move operation of COUNT_EXP bytes from SRC to DST, with
3299    alignment ALIGN_EXP.  Return true if successful, false if we should fall
3300    back on a different method.  */
3301
3302 bool
3303 bfin_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp)
3304 {
3305   rtx srcreg, destreg, countreg;
3306   HOST_WIDE_INT align = 0;
3307   unsigned HOST_WIDE_INT count = 0;
3308
3309   if (GET_CODE (align_exp) == CONST_INT)
3310     align = INTVAL (align_exp);
3311   if (GET_CODE (count_exp) == CONST_INT)
3312     {
3313       count = INTVAL (count_exp);
3314 #if 0
3315       if (!TARGET_INLINE_ALL_STRINGOPS && count > 64)
3316         return false;
3317 #endif
3318     }
3319
3320   /* If optimizing for size, only do single copies inline.  */
3321   if (optimize_size)
3322     {
3323       if (count == 2 && align < 2)
3324         return false;
3325       if (count == 4 && align < 4)
3326         return false;
3327       if (count != 1 && count != 2 && count != 4)
3328         return false;
3329     }
3330   if (align < 2 && count != 1)
3331     return false;
3332
3333   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
3334   if (destreg != XEXP (dst, 0))
3335     dst = replace_equiv_address_nv (dst, destreg);
3336   srcreg = copy_to_mode_reg (Pmode, XEXP (src, 0));
3337   if (srcreg != XEXP (src, 0))
3338     src = replace_equiv_address_nv (src, srcreg);
3339
3340   if (count != 0 && align >= 2)
3341     {
3342       unsigned HOST_WIDE_INT offset = 0;
3343
3344       if (align >= 4)
3345         {
3346           if ((count & ~3) == 4)
3347             {
3348               single_move_for_movmem (dst, src, SImode, offset);
3349               offset = 4;
3350             }
3351           else if (count & ~3)
3352             {
3353               HOST_WIDE_INT new_count = ((count >> 2) & 0x3fffffff) - 1;
3354               countreg = copy_to_mode_reg (Pmode, GEN_INT (new_count));
3355
3356               emit_insn (gen_rep_movsi (destreg, srcreg, countreg, destreg, srcreg));
3357             }
3358           if (count & 2)
3359             {
3360               single_move_for_movmem (dst, src, HImode, offset);
3361               offset += 2;
3362             }
3363         }
3364       else
3365         {
3366           if ((count & ~1) == 2)
3367             {
3368               single_move_for_movmem (dst, src, HImode, offset);
3369               offset = 2;
3370             }
3371           else if (count & ~1)
3372             {
3373               HOST_WIDE_INT new_count = ((count >> 1) & 0x7fffffff) - 1;
3374               countreg = copy_to_mode_reg (Pmode, GEN_INT (new_count));
3375
3376               emit_insn (gen_rep_movhi (destreg, srcreg, countreg, destreg, srcreg));
3377             }
3378         }
3379       if (count & 1)
3380         {
3381           single_move_for_movmem (dst, src, QImode, offset);
3382         }
3383       return true;
3384     }
3385   return false;
3386 }
3387 \f
3388 /* Compute the alignment for a local variable.
3389    TYPE is the data type, and ALIGN is the alignment that
3390    the object would ordinarily have.  The value of this macro is used
3391    instead of that alignment to align the object.  */
3392
3393 int
3394 bfin_local_alignment (tree type, int align)
3395 {
3396   /* Increasing alignment for (relatively) big types allows the builtin
3397      memcpy can use 32 bit loads/stores.  */
3398   if (TYPE_SIZE (type)
3399       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
3400       && (TREE_INT_CST_LOW (TYPE_SIZE (type)) > 8
3401           || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 32)
3402     return 32;
3403   return align;
3404 }
3405 \f
3406 /* Implement TARGET_SCHED_ISSUE_RATE.  */
3407
3408 static int
3409 bfin_issue_rate (void)
3410 {
3411   return 3;
3412 }
3413
3414 static int
3415 bfin_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
3416 {
3417   enum attr_type insn_type, dep_insn_type;
3418   int dep_insn_code_number;
3419
3420   /* Anti and output dependencies have zero cost.  */
3421   if (REG_NOTE_KIND (link) != 0)
3422     return 0;
3423
3424   dep_insn_code_number = recog_memoized (dep_insn);
3425
3426   /* If we can't recognize the insns, we can't really do anything.  */
3427   if (dep_insn_code_number < 0 || recog_memoized (insn) < 0)
3428     return cost;
3429
3430   insn_type = get_attr_type (insn);
3431   dep_insn_type = get_attr_type (dep_insn);
3432
3433   if (dep_insn_type == TYPE_MOVE || dep_insn_type == TYPE_MCLD)
3434     {
3435       rtx pat = PATTERN (dep_insn);
3436       if (GET_CODE (pat) == PARALLEL)
3437         pat = XVECEXP (pat, 0, 0);
3438       rtx dest = SET_DEST (pat);
3439       rtx src = SET_SRC (pat);
3440       if (! ADDRESS_REGNO_P (REGNO (dest))
3441           || ! (MEM_P (src) || D_REGNO_P (REGNO (src))))
3442         return cost;
3443       return cost + (dep_insn_type == TYPE_MOVE ? 4 : 3);
3444     }
3445
3446   return cost;
3447 }
3448
3449 \f
3450 /* Increment the counter for the number of loop instructions in the
3451    current function.  */
3452
3453 void
3454 bfin_hardware_loop (void)
3455 {
3456   cfun->machine->has_hardware_loops++;
3457 }
3458
3459 /* Maximum loop nesting depth.  */
3460 #define MAX_LOOP_DEPTH 2
3461
3462 /* Maximum size of a loop.  */
3463 #define MAX_LOOP_LENGTH 2042
3464
3465 /* Maximum distance of the LSETUP instruction from the loop start.  */
3466 #define MAX_LSETUP_DISTANCE 30
3467
3468 /* We need to keep a vector of loops */
3469 typedef struct loop_info *loop_info;
3470 DEF_VEC_P (loop_info);
3471 DEF_VEC_ALLOC_P (loop_info,heap);
3472
3473 /* Information about a loop we have found (or are in the process of
3474    finding).  */
3475 struct loop_info GTY (())
3476 {
3477   /* loop number, for dumps */
3478   int loop_no;
3479
3480   /* All edges that jump into and out of the loop.  */
3481   VEC(edge,gc) *incoming;
3482
3483   /* We can handle two cases: all incoming edges have the same destination
3484      block, or all incoming edges have the same source block.  These two
3485      members are set to the common source or destination we found, or NULL
3486      if different blocks were found.  If both are NULL the loop can't be
3487      optimized.  */
3488   basic_block incoming_src;
3489   basic_block incoming_dest;
3490
3491   /* First block in the loop.  This is the one branched to by the loop_end
3492      insn.  */
3493   basic_block head;
3494
3495   /* Last block in the loop (the one with the loop_end insn).  */
3496   basic_block tail;
3497
3498   /* The successor block of the loop.  This is the one the loop_end insn
3499      falls into.  */
3500   basic_block successor;
3501
3502   /* The last instruction in the tail.  */
3503   rtx last_insn;
3504
3505   /* The loop_end insn.  */
3506   rtx loop_end;
3507
3508   /* The iteration register.  */
3509   rtx iter_reg;
3510
3511   /* The new initialization insn.  */
3512   rtx init;
3513
3514   /* The new initialization instruction.  */
3515   rtx loop_init;
3516
3517   /* The new label placed at the beginning of the loop. */
3518   rtx start_label;
3519
3520   /* The new label placed at the end of the loop. */
3521   rtx end_label;
3522
3523   /* The length of the loop.  */
3524   int length;
3525
3526   /* The nesting depth of the loop.  */
3527   int depth;
3528
3529   /* Nonzero if we can't optimize this loop.  */
3530   int bad;
3531
3532   /* True if we have visited this loop.  */
3533   int visited;
3534
3535   /* True if this loop body clobbers any of LC0, LT0, or LB0.  */
3536   int clobber_loop0;
3537
3538   /* True if this loop body clobbers any of LC1, LT1, or LB1.  */
3539   int clobber_loop1;
3540
3541   /* Next loop in the graph. */
3542   struct loop_info *next;
3543
3544   /* Immediate outer loop of this loop.  */
3545   struct loop_info *outer;
3546
3547   /* Vector of blocks only within the loop, including those within
3548      inner loops.  */
3549   VEC (basic_block,heap) *blocks;
3550
3551   /* Same information in a bitmap.  */
3552   bitmap block_bitmap;
3553
3554   /* Vector of inner loops within this loop  */
3555   VEC (loop_info,heap) *loops;
3556 };
3557
3558 static void
3559 bfin_dump_loops (loop_info loops)
3560 {
3561   loop_info loop;
3562
3563   for (loop = loops; loop; loop = loop->next)
3564     {
3565       loop_info i;
3566       basic_block b;
3567       unsigned ix;
3568
3569       fprintf (dump_file, ";; loop %d: ", loop->loop_no);
3570       if (loop->bad)
3571         fprintf (dump_file, "(bad) ");
3572       fprintf (dump_file, "{head:%d, depth:%d}", loop->head->index, loop->depth);
3573
3574       fprintf (dump_file, " blocks: [ ");
3575       for (ix = 0; VEC_iterate (basic_block, loop->blocks, ix, b); ix++)
3576         fprintf (dump_file, "%d ", b->index);
3577       fprintf (dump_file, "] ");
3578
3579       fprintf (dump_file, " inner loops: [ ");
3580       for (ix = 0; VEC_iterate (loop_info, loop->loops, ix, i); ix++)
3581         fprintf (dump_file, "%d ", i->loop_no);
3582       fprintf (dump_file, "]\n");
3583     }
3584   fprintf (dump_file, "\n");
3585 }
3586
3587 /* Scan the blocks of LOOP (and its inferiors) looking for basic block
3588    BB. Return true, if we find it.  */
3589
3590 static bool
3591 bfin_bb_in_loop (loop_info loop, basic_block bb)
3592 {
3593   return bitmap_bit_p (loop->block_bitmap, bb->index);
3594 }
3595
3596 /* Scan the blocks of LOOP (and its inferiors) looking for uses of
3597    REG.  Return true, if we find any.  Don't count the loop's loop_end
3598    insn if it matches LOOP_END.  */
3599
3600 static bool
3601 bfin_scan_loop (loop_info loop, rtx reg, rtx loop_end)
3602 {
3603   unsigned ix;
3604   basic_block bb;
3605
3606   for (ix = 0; VEC_iterate (basic_block, loop->blocks, ix, bb); ix++)
3607     {
3608       rtx insn;
3609
3610       for (insn = BB_HEAD (bb);
3611            insn != NEXT_INSN (BB_END (bb));
3612            insn = NEXT_INSN (insn))
3613         {
3614           if (!INSN_P (insn))
3615             continue;
3616           if (insn == loop_end)
3617             continue;
3618           if (reg_mentioned_p (reg, PATTERN (insn)))
3619             return true;
3620         }
3621     }
3622   return false;
3623 }
3624
3625 /* Estimate the length of INSN conservatively.  */
3626
3627 static int
3628 length_for_loop (rtx insn)
3629 {
3630   int length = 0;
3631   if (JUMP_P (insn) && any_condjump_p (insn) && !optimize_size)
3632     {
3633       if (ENABLE_WA_SPECULATIVE_SYNCS)
3634         length = 8;
3635       else if (ENABLE_WA_SPECULATIVE_LOADS)
3636         length = 6;
3637     }
3638   else if (LABEL_P (insn))
3639     {
3640       if (ENABLE_WA_SPECULATIVE_SYNCS)
3641         length = 4;
3642     }
3643
3644   if (INSN_P (insn))
3645     length += get_attr_length (insn);
3646
3647   return length;
3648 }
3649
3650 /* Optimize LOOP.  */
3651
3652 static void
3653 bfin_optimize_loop (loop_info loop)
3654 {
3655   basic_block bb;
3656   loop_info inner;
3657   rtx insn, init_insn, last_insn, nop_insn;
3658   rtx loop_init, start_label, end_label;
3659   rtx reg_lc0, reg_lc1, reg_lt0, reg_lt1, reg_lb0, reg_lb1;
3660   rtx iter_reg;
3661   rtx lc_reg, lt_reg, lb_reg;
3662   rtx seq, seq_end;
3663   int length;
3664   unsigned ix;
3665   int inner_depth = 0;
3666
3667   if (loop->visited)
3668     return;
3669
3670   loop->visited = 1;
3671
3672   if (loop->bad)
3673     {
3674       if (dump_file)
3675         fprintf (dump_file, ";; loop %d bad when found\n", loop->loop_no);
3676       goto bad_loop;
3677     }
3678
3679   /* Every loop contains in its list of inner loops every loop nested inside
3680      it, even if there are intermediate loops.  This works because we're doing
3681      a depth-first search here and never visit a loop more than once.  */
3682   for (ix = 0; VEC_iterate (loop_info, loop->loops, ix, inner); ix++)
3683     {
3684       bfin_optimize_loop (inner);
3685
3686       if (!inner->bad && inner_depth < inner->depth)
3687         {
3688           inner_depth = inner->depth;
3689
3690           loop->clobber_loop0 |= inner->clobber_loop0;
3691           loop->clobber_loop1 |= inner->clobber_loop1;
3692         }
3693     }
3694
3695   loop->depth = inner_depth + 1;
3696   if (loop->depth > MAX_LOOP_DEPTH)
3697     {
3698       if (dump_file)
3699         fprintf (dump_file, ";; loop %d too deep\n", loop->loop_no);
3700       goto bad_loop;
3701     }
3702
3703   /* Get the loop iteration register.  */
3704   iter_reg = loop->iter_reg;
3705
3706   if (!DPREG_P (iter_reg))
3707     {
3708       if (dump_file)
3709         fprintf (dump_file, ";; loop %d iteration count NOT in PREG or DREG\n",
3710                  loop->loop_no);
3711       goto bad_loop;
3712     }
3713
3714   if (loop->incoming_src)
3715     {
3716       /* Make sure the predecessor is before the loop start label, as required by
3717          the LSETUP instruction.  */
3718       length = 0;
3719       for (insn = BB_END (loop->incoming_src);
3720            insn && insn != loop->start_label;
3721            insn = NEXT_INSN (insn))
3722         length += length_for_loop (insn);
3723       
3724       if (!insn)
3725         {
3726           if (dump_file)
3727             fprintf (dump_file, ";; loop %d lsetup not before loop_start\n",
3728                      loop->loop_no);
3729           goto bad_loop;
3730         }
3731
3732       if (length > MAX_LSETUP_DISTANCE)
3733         {
3734           if (dump_file)
3735             fprintf (dump_file, ";; loop %d lsetup too far away\n", loop->loop_no);
3736           goto bad_loop;
3737         }
3738     }
3739
3740   /* Check if start_label appears before loop_end and calculate the
3741      offset between them.  We calculate the length of instructions
3742      conservatively.  */
3743   length = 0;
3744   for (insn = loop->start_label;
3745        insn && insn != loop->loop_end;
3746        insn = NEXT_INSN (insn))
3747     length += length_for_loop (insn);
3748
3749   if (!insn)
3750     {
3751       if (dump_file)
3752         fprintf (dump_file, ";; loop %d start_label not before loop_end\n",
3753                  loop->loop_no);
3754       goto bad_loop;
3755     }
3756
3757   loop->length = length;
3758   if (loop->length > MAX_LOOP_LENGTH)
3759     {
3760       if (dump_file)
3761         fprintf (dump_file, ";; loop %d too long\n", loop->loop_no);
3762       goto bad_loop;
3763     }
3764
3765   /* Scan all the blocks to make sure they don't use iter_reg.  */
3766   if (bfin_scan_loop (loop, iter_reg, loop->loop_end))
3767     {
3768       if (dump_file)
3769         fprintf (dump_file, ";; loop %d uses iterator\n", loop->loop_no);
3770       goto bad_loop;
3771     }
3772
3773   /* Scan all the insns to see if the loop body clobber
3774      any hardware loop registers. */
3775
3776   reg_lc0 = gen_rtx_REG (SImode, REG_LC0);
3777   reg_lc1 = gen_rtx_REG (SImode, REG_LC1);
3778   reg_lt0 = gen_rtx_REG (SImode, REG_LT0);
3779   reg_lt1 = gen_rtx_REG (SImode, REG_LT1);
3780   reg_lb0 = gen_rtx_REG (SImode, REG_LB0);
3781   reg_lb1 = gen_rtx_REG (SImode, REG_LB1);
3782
3783   for (ix = 0; VEC_iterate (basic_block, loop->blocks, ix, bb); ix++)
3784     {
3785       rtx insn;
3786
3787       for (insn = BB_HEAD (bb);
3788            insn != NEXT_INSN (BB_END (bb));
3789            insn = NEXT_INSN (insn))
3790         {
3791           if (!INSN_P (insn))
3792             continue;
3793
3794           if (reg_set_p (reg_lc0, insn)
3795               || reg_set_p (reg_lt0, insn)
3796               || reg_set_p (reg_lb0, insn))
3797             loop->clobber_loop0 = 1;
3798           
3799           if (reg_set_p (reg_lc1, insn)
3800               || reg_set_p (reg_lt1, insn)
3801               || reg_set_p (reg_lb1, insn))
3802             loop->clobber_loop1 |= 1;
3803         }
3804     }
3805
3806   if ((loop->clobber_loop0 && loop->clobber_loop1)
3807       || (loop->depth == MAX_LOOP_DEPTH && loop->clobber_loop0))
3808     {
3809       loop->depth = MAX_LOOP_DEPTH + 1;
3810       if (dump_file)
3811         fprintf (dump_file, ";; loop %d no loop reg available\n",
3812                  loop->loop_no);
3813       goto bad_loop;
3814     }
3815
3816   /* There should be an instruction before the loop_end instruction
3817      in the same basic block. And the instruction must not be
3818      - JUMP
3819      - CONDITIONAL BRANCH
3820      - CALL
3821      - CSYNC
3822      - SSYNC
3823      - Returns (RTS, RTN, etc.)  */
3824
3825   bb = loop->tail;
3826   last_insn = PREV_INSN (loop->loop_end);
3827
3828   while (1)
3829     {
3830       for (; last_insn != PREV_INSN (BB_HEAD (bb));
3831            last_insn = PREV_INSN (last_insn))
3832         if (INSN_P (last_insn))
3833           break;
3834
3835       if (last_insn != PREV_INSN (BB_HEAD (bb)))
3836         break;
3837
3838       if (single_pred_p (bb)
3839           && single_pred (bb) != ENTRY_BLOCK_PTR)
3840         {
3841           bb = single_pred (bb);
3842           last_insn = BB_END (bb);
3843           continue;
3844         }
3845       else
3846         {
3847           last_insn = NULL_RTX;
3848           break;
3849         }
3850     }
3851
3852   if (!last_insn)
3853     {
3854       if (dump_file)
3855         fprintf (dump_file, ";; loop %d has no last instruction\n",
3856                  loop->loop_no);
3857       goto bad_loop;
3858     }
3859
3860   if (JUMP_P (last_insn))
3861     {
3862       loop_info inner = (loop_info) bb->aux;
3863       if (inner
3864           && inner->outer == loop
3865           && inner->loop_end == last_insn
3866           && inner->depth == 1)
3867         /* This jump_insn is the exact loop_end of an inner loop
3868            and to be optimized away. So use the inner's last_insn.  */
3869         last_insn = inner->last_insn;
3870       else
3871         {
3872           if (dump_file)
3873             fprintf (dump_file, ";; loop %d has bad last instruction\n",
3874                      loop->loop_no);
3875           goto bad_loop;
3876         }
3877     }
3878   else if (CALL_P (last_insn)
3879            || (GET_CODE (PATTERN (last_insn)) != SEQUENCE
3880                && get_attr_type (last_insn) == TYPE_SYNC)
3881            || recog_memoized (last_insn) == CODE_FOR_return_internal)
3882     {
3883       if (dump_file)
3884         fprintf (dump_file, ";; loop %d has bad last instruction\n",
3885                  loop->loop_no);
3886       goto bad_loop;
3887     }
3888
3889   if (GET_CODE (PATTERN (last_insn)) == ASM_INPUT
3890       || asm_noperands (PATTERN (last_insn)) >= 0
3891       || (GET_CODE (PATTERN (last_insn)) != SEQUENCE
3892           && get_attr_seq_insns (last_insn) == SEQ_INSNS_MULTI))
3893     {
3894       nop_insn = emit_insn_after (gen_nop (), last_insn);
3895       last_insn = nop_insn;
3896     }
3897
3898   loop->last_insn = last_insn;
3899
3900   /* The loop is good for replacement.  */
3901   start_label = loop->start_label;
3902   end_label = gen_label_rtx ();
3903   iter_reg = loop->iter_reg;
3904
3905   if (loop->depth == 1 && !loop->clobber_loop1)
3906     {
3907       lc_reg = reg_lc1;
3908       lt_reg = reg_lt1;
3909       lb_reg = reg_lb1;
3910       loop->clobber_loop1 = 1;
3911     }
3912   else
3913     {
3914       lc_reg = reg_lc0;
3915       lt_reg = reg_lt0;
3916       lb_reg = reg_lb0;
3917       loop->clobber_loop0 = 1;
3918     }
3919
3920   /* If iter_reg is a DREG, we need generate an instruction to load
3921      the loop count into LC register. */
3922   if (D_REGNO_P (REGNO (iter_reg)))
3923     {
3924       init_insn = gen_movsi (lc_reg, iter_reg);
3925       loop_init = gen_lsetup_without_autoinit (lt_reg, start_label,
3926                                                lb_reg, end_label,
3927                                                lc_reg);
3928     }
3929   else if (P_REGNO_P (REGNO (iter_reg)))
3930     {
3931       init_insn = NULL_RTX;
3932       loop_init = gen_lsetup_with_autoinit (lt_reg, start_label,
3933                                             lb_reg, end_label,
3934                                             lc_reg, iter_reg);
3935     }
3936   else
3937     gcc_unreachable ();
3938
3939   loop->init = init_insn;
3940   loop->end_label = end_label;
3941   loop->loop_init = loop_init;
3942
3943   if (dump_file)
3944     {
3945       fprintf (dump_file, ";; replacing loop %d initializer with\n",
3946                loop->loop_no);
3947       print_rtl_single (dump_file, loop->loop_init);
3948       fprintf (dump_file, ";; replacing loop %d terminator with\n",
3949                loop->loop_no);
3950       print_rtl_single (dump_file, loop->loop_end);
3951     }
3952
3953   start_sequence ();
3954
3955   if (loop->init != NULL_RTX)
3956     emit_insn (loop->init);
3957   seq_end = emit_insn (loop->loop_init);
3958
3959   seq = get_insns ();
3960   end_sequence ();
3961
3962   if (loop->incoming_src)
3963     {
3964       rtx prev = BB_END (loop->incoming_src);
3965       if (VEC_length (edge, loop->incoming) > 1
3966           || !(VEC_last (edge, loop->incoming)->flags & EDGE_FALLTHRU))
3967         {
3968           gcc_assert (JUMP_P (prev));
3969           prev = PREV_INSN (prev);
3970         }
3971       emit_insn_after (seq, prev);
3972     }
3973   else
3974     {
3975       basic_block new_bb;
3976       edge e;
3977       edge_iterator ei;
3978       
3979       if (loop->head != loop->incoming_dest)
3980         {
3981           FOR_EACH_EDGE (e, ei, loop->head->preds)
3982             {
3983               if (e->flags & EDGE_FALLTHRU)
3984                 {
3985                   rtx newjump = gen_jump (loop->start_label);
3986                   emit_insn_before (newjump, BB_HEAD (loop->head));
3987                   new_bb = create_basic_block (newjump, newjump, loop->head->prev_bb);
3988                   gcc_assert (new_bb = loop->head->prev_bb);
3989                   break;
3990                 }
3991             }
3992         }
3993
3994       emit_insn_before (seq, BB_HEAD (loop->head));
3995       seq = emit_label_before (gen_label_rtx (), seq);
3996
3997       new_bb = create_basic_block (seq, seq_end, loop->head->prev_bb);
3998       FOR_EACH_EDGE (e, ei, loop->incoming)
3999         {
4000           if (!(e->flags & EDGE_FALLTHRU)
4001               || e->dest != loop->head)
4002             redirect_edge_and_branch_force (e, new_bb);
4003           else
4004             redirect_edge_succ (e, new_bb);
4005         }
4006     }
4007   
4008   delete_insn (loop->loop_end);
4009   /* Insert the loop end label before the last instruction of the loop.  */
4010   emit_label_before (loop->end_label, loop->last_insn);
4011
4012   return;
4013
4014  bad_loop:
4015
4016   if (dump_file)
4017     fprintf (dump_file, ";; loop %d is bad\n", loop->loop_no);
4018
4019   loop->bad = 1;
4020
4021   if (DPREG_P (loop->iter_reg))
4022     {
4023       /* If loop->iter_reg is a DREG or PREG, we can split it here
4024          without scratch register.  */
4025       rtx insn;
4026
4027       emit_insn_before (gen_addsi3 (loop->iter_reg,
4028                                     loop->iter_reg,
4029                                     constm1_rtx),
4030                         loop->loop_end);
4031
4032       emit_insn_before (gen_cmpsi (loop->iter_reg, const0_rtx),
4033                         loop->loop_end);
4034
4035       insn = emit_jump_insn_before (gen_bne (loop->start_label),
4036                                     loop->loop_end);
4037
4038       JUMP_LABEL (insn) = loop->start_label;
4039       LABEL_NUSES (loop->start_label)++;
4040       delete_insn (loop->loop_end);
4041     }
4042 }
4043
4044 /* Called from bfin_reorg_loops when a potential loop end is found.  LOOP is
4045    a newly set up structure describing the loop, it is this function's
4046    responsibility to fill most of it.  TAIL_BB and TAIL_INSN point to the
4047    loop_end insn and its enclosing basic block.  */
4048
4049 static void
4050 bfin_discover_loop (loop_info loop, basic_block tail_bb, rtx tail_insn)
4051 {
4052   unsigned dwork = 0;
4053   basic_block bb;
4054   VEC (basic_block,heap) *works = VEC_alloc (basic_block,heap,20);
4055
4056   loop->tail = tail_bb;
4057   loop->head = BRANCH_EDGE (tail_bb)->dest;
4058   loop->successor = FALLTHRU_EDGE (tail_bb)->dest;
4059   loop->loop_end = tail_insn;
4060   loop->last_insn = NULL_RTX;
4061   loop->iter_reg = SET_DEST (XVECEXP (PATTERN (tail_insn), 0, 1));
4062   loop->depth = loop->length = 0;
4063   loop->visited = 0;
4064   loop->clobber_loop0 = loop->clobber_loop1 = 0;
4065   loop->outer = NULL;
4066   loop->loops = NULL;
4067   loop->incoming = VEC_alloc (edge, gc, 2);
4068   loop->init = loop->loop_init = NULL_RTX;
4069   loop->start_label = XEXP (XEXP (SET_SRC (XVECEXP (PATTERN (tail_insn), 0, 0)), 1), 0);
4070   loop->end_label = NULL_RTX;
4071   loop->bad = 0;
4072
4073   VEC_safe_push (basic_block, heap, works, loop->head);
4074
4075   while (VEC_iterate (basic_block, works, dwork++, bb))
4076     {
4077       edge e;
4078       edge_iterator ei;
4079       if (bb == EXIT_BLOCK_PTR)
4080         {
4081           /* We've reached the exit block.  The loop must be bad. */
4082           if (dump_file)
4083             fprintf (dump_file,
4084                      ";; Loop is bad - reached exit block while scanning\n");
4085           loop->bad = 1;
4086           break;
4087         }
4088
4089       if (bitmap_bit_p (loop->block_bitmap, bb->index))
4090         continue;
4091
4092       /* We've not seen this block before.  Add it to the loop's
4093          list and then add each successor to the work list.  */
4094
4095       VEC_safe_push (basic_block, heap, loop->blocks, bb);
4096       bitmap_set_bit (loop->block_bitmap, bb->index);
4097
4098       if (bb != tail_bb)
4099         {
4100           FOR_EACH_EDGE (e, ei, bb->succs)
4101             {
4102               basic_block succ = EDGE_SUCC (bb, ei.index)->dest;
4103               if (!REGNO_REG_SET_P (df_get_live_in (succ),
4104                                     REGNO (loop->iter_reg)))
4105                 continue;
4106               if (!VEC_space (basic_block, works, 1))
4107                 {
4108                   if (dwork)
4109                     {
4110                       VEC_block_remove (basic_block, works, 0, dwork);
4111                       dwork = 0;
4112                     }
4113                   else
4114                     VEC_reserve (basic_block, heap, works, 1);
4115                 }
4116               VEC_quick_push (basic_block, works, succ);
4117             }
4118         }
4119     }
4120
4121   /* Find the predecessor, and make sure nothing else jumps into this loop.  */
4122   if (!loop->bad)
4123     {
4124       int pass, retry;
4125       for (dwork = 0; VEC_iterate (basic_block, loop->blocks, dwork, bb); dwork++)
4126         {
4127           edge e;
4128           edge_iterator ei;
4129           FOR_EACH_EDGE (e, ei, bb->preds)
4130             {
4131               basic_block pred = e->src;
4132
4133               if (!bfin_bb_in_loop (loop, pred))
4134                 {
4135                   if (dump_file)
4136                     fprintf (dump_file, ";; Loop %d: incoming edge %d -> %d\n",
4137