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                              loop->loop_no, pred->index,
4138                              e->dest->index);
4139                   VEC_safe_push (edge, gc, loop->incoming, e);
4140                 }
4141             }
4142         }
4143
4144       for (pass = 0, retry = 1; retry && pass < 2; pass++)
4145         {
4146           edge e;
4147           edge_iterator ei;
4148           bool first = true;
4149           retry = 0;
4150
4151           FOR_EACH_EDGE (e, ei, loop->incoming)
4152             {
4153               if (first)
4154                 {
4155                   loop->incoming_src = e->src;
4156                   loop->incoming_dest = e->dest;
4157                   first = false;
4158                 }
4159               else
4160                 {
4161                   if (e->dest != loop->incoming_dest)
4162                     loop->incoming_dest = NULL;
4163                   if (e->src != loop->incoming_src)
4164                     loop->incoming_src = NULL;
4165                 }
4166               if (loop->incoming_src == NULL && loop->incoming_dest == NULL)
4167                 {
4168                   if (pass == 0)
4169                     {
4170                       if (dump_file)
4171                         fprintf (dump_file,
4172                                  ";; retrying loop %d with forwarder blocks\n",
4173                                  loop->loop_no);
4174                       retry = 1;
4175                       break;
4176                     }
4177                   loop->bad = 1;
4178                   if (dump_file)
4179                     fprintf (dump_file,
4180                              ";; can't find suitable entry for loop %d\n",
4181                              loop->loop_no);
4182                   goto out;
4183                 }
4184             }
4185           if (retry)
4186             {
4187               retry = 0;
4188               FOR_EACH_EDGE (e, ei, loop->incoming)
4189                 {
4190                   if (forwarder_block_p (e->src))
4191                     {
4192                       edge e2;
4193                       edge_iterator ei2;
4194
4195                       if (dump_file)
4196                         fprintf (dump_file,
4197                                  ";; Adding forwarder block %d to loop %d and retrying\n",
4198                                  e->src->index, loop->loop_no);
4199                       VEC_safe_push (basic_block, heap, loop->blocks, e->src);
4200                       bitmap_set_bit (loop->block_bitmap, e->src->index);
4201                       FOR_EACH_EDGE (e2, ei2, e->src->preds)
4202                         VEC_safe_push (edge, gc, loop->incoming, e2);
4203                       VEC_unordered_remove (edge, loop->incoming, ei.index);
4204                       retry = 1;
4205                       break;
4206                     }
4207                 }
4208             }
4209         }
4210     }
4211
4212  out:
4213   VEC_free (basic_block, heap, works);
4214 }
4215
4216 /* Analyze the structure of the loops in the current function.  Use STACK
4217    for bitmap allocations.  Returns all the valid candidates for hardware
4218    loops found in this function.  */
4219 static loop_info
4220 bfin_discover_loops (bitmap_obstack *stack, FILE *dump_file)
4221 {
4222   loop_info loops = NULL;
4223   loop_info loop;
4224   basic_block bb;
4225   bitmap tmp_bitmap;
4226   int nloops = 0;
4227
4228   /* Find all the possible loop tails.  This means searching for every
4229      loop_end instruction.  For each one found, create a loop_info
4230      structure and add the head block to the work list. */
4231   FOR_EACH_BB (bb)
4232     {
4233       rtx tail = BB_END (bb);
4234
4235       while (GET_CODE (tail) == NOTE)
4236         tail = PREV_INSN (tail);
4237
4238       bb->aux = NULL;
4239
4240       if (INSN_P (tail) && recog_memoized (tail) == CODE_FOR_loop_end)
4241         {
4242           rtx insn;
4243           /* A possible loop end */
4244
4245           /* There's a degenerate case we can handle - an empty loop consisting
4246              of only a back branch.  Handle that by deleting the branch.  */
4247           insn = BB_HEAD (BRANCH_EDGE (bb)->dest);
4248           if (next_real_insn (insn) == tail)
4249             {
4250               if (dump_file)
4251                 {
4252                   fprintf (dump_file, ";; degenerate loop ending at\n");
4253                   print_rtl_single (dump_file, tail);
4254                 }
4255               delete_insn_and_edges (tail);
4256               continue;
4257             }
4258
4259           loop = XNEW (struct loop_info);
4260           loop->next = loops;
4261           loops = loop;
4262           loop->loop_no = nloops++;
4263           loop->blocks = VEC_alloc (basic_block, heap, 20);
4264           loop->block_bitmap = BITMAP_ALLOC (stack);
4265           bb->aux = loop;
4266
4267           if (dump_file)
4268             {
4269               fprintf (dump_file, ";; potential loop %d ending at\n",
4270                        loop->loop_no);
4271               print_rtl_single (dump_file, tail);
4272             }
4273
4274           bfin_discover_loop (loop, bb, tail);
4275         }
4276     }
4277
4278   tmp_bitmap = BITMAP_ALLOC (stack);
4279   /* Compute loop nestings.  */
4280   for (loop = loops; loop; loop = loop->next)
4281     {
4282       loop_info other;
4283       if (loop->bad)
4284         continue;
4285
4286       for (other = loop->next; other; other = other->next)
4287         {
4288           if (other->bad)
4289             continue;
4290
4291           bitmap_and (tmp_bitmap, other->block_bitmap, loop->block_bitmap);
4292           if (bitmap_empty_p (tmp_bitmap))
4293             continue;
4294           if (bitmap_equal_p (tmp_bitmap, other->block_bitmap))
4295             {
4296               other->outer = loop;
4297               VEC_safe_push (loop_info, heap, loop->loops, other);
4298             }
4299           else if (bitmap_equal_p (tmp_bitmap, loop->block_bitmap))
4300             {
4301               loop->outer = other;
4302               VEC_safe_push (loop_info, heap, other->loops, loop);
4303             }
4304           else
4305             {
4306               if (dump_file)
4307                 fprintf (dump_file,
4308                          ";; can't find suitable nesting for loops %d and %d\n",
4309                          loop->loop_no, other->loop_no);
4310               loop->bad = other->bad = 1;
4311             }
4312         }
4313     }
4314   BITMAP_FREE (tmp_bitmap);
4315
4316   return loops;
4317 }
4318
4319 /* Free up the loop structures in LOOPS.  */
4320 static void
4321 free_loops (loop_info loops)
4322 {
4323   while (loops)
4324     {
4325       loop_info loop = loops;
4326       loops = loop->next;
4327       VEC_free (loop_info, heap, loop->loops);
4328       VEC_free (basic_block, heap, loop->blocks);
4329       BITMAP_FREE (loop->block_bitmap);
4330       XDELETE (loop);
4331     }
4332 }
4333
4334 #define BB_AUX_INDEX(BB) ((unsigned)(BB)->aux)
4335
4336 /* The taken-branch edge from the loop end can actually go forward.  Since the
4337    Blackfin's LSETUP instruction requires that the loop end be after the loop
4338    start, try to reorder a loop's basic blocks when we find such a case.  */
4339 static void
4340 bfin_reorder_loops (loop_info loops, FILE *dump_file)
4341 {
4342   basic_block bb;
4343   loop_info loop;
4344
4345   FOR_EACH_BB (bb)
4346     bb->aux = NULL;
4347   cfg_layout_initialize (0);
4348
4349   for (loop = loops; loop; loop = loop->next)
4350     {
4351       unsigned index;
4352       basic_block bb;
4353       edge e;
4354       edge_iterator ei;
4355
4356       if (loop->bad)
4357         continue;
4358
4359       /* Recreate an index for basic blocks that represents their order.  */
4360       for (bb = ENTRY_BLOCK_PTR->next_bb, index = 0;
4361            bb != EXIT_BLOCK_PTR;
4362            bb = bb->next_bb, index++)
4363         bb->aux = (PTR) index;
4364
4365       if (BB_AUX_INDEX (loop->head) < BB_AUX_INDEX (loop->tail))
4366         continue;
4367
4368       FOR_EACH_EDGE (e, ei, loop->head->succs)
4369         {
4370           if (bitmap_bit_p (loop->block_bitmap, e->dest->index)
4371               && BB_AUX_INDEX (e->dest) < BB_AUX_INDEX (loop->tail))
4372             {
4373               basic_block start_bb = e->dest;
4374               basic_block start_prev_bb = start_bb->prev_bb;
4375
4376               if (dump_file)
4377                 fprintf (dump_file, ";; Moving block %d before block %d\n",
4378                          loop->head->index, start_bb->index);
4379               loop->head->prev_bb->next_bb = loop->head->next_bb;
4380               loop->head->next_bb->prev_bb = loop->head->prev_bb;
4381
4382               loop->head->prev_bb = start_prev_bb;
4383               loop->head->next_bb = start_bb;
4384               start_prev_bb->next_bb = start_bb->prev_bb = loop->head;
4385               break;
4386             }
4387         }
4388       loops = loops->next;
4389     }
4390
4391   FOR_EACH_BB (bb)
4392     {
4393       if (bb->next_bb != EXIT_BLOCK_PTR)
4394         bb->aux = bb->next_bb;
4395       else
4396         bb->aux = NULL;
4397     }
4398   cfg_layout_finalize ();
4399   df_analyze ();
4400 }
4401
4402 /* Run from machine_dependent_reorg, this pass looks for doloop_end insns
4403    and tries to rewrite the RTL of these loops so that proper Blackfin
4404    hardware loops are generated.  */
4405
4406 static void
4407 bfin_reorg_loops (FILE *dump_file)
4408 {
4409   loop_info loops = NULL;
4410   loop_info loop;
4411   basic_block bb;
4412   bitmap_obstack stack;
4413
4414   bitmap_obstack_initialize (&stack);
4415
4416   if (dump_file)
4417     fprintf (dump_file, ";; Find loops, first pass\n\n");
4418
4419   loops = bfin_discover_loops (&stack, dump_file);
4420
4421   if (dump_file)
4422     bfin_dump_loops (loops);
4423
4424   bfin_reorder_loops (loops, dump_file);
4425   free_loops (loops);
4426
4427   if (dump_file)
4428     fprintf (dump_file, ";; Find loops, second pass\n\n");
4429
4430   loops = bfin_discover_loops (&stack, dump_file);
4431   if (dump_file)
4432     {
4433       fprintf (dump_file, ";; All loops found:\n\n");
4434       bfin_dump_loops (loops);
4435     }
4436
4437   /* Now apply the optimizations.  */
4438   for (loop = loops; loop; loop = loop->next)
4439     bfin_optimize_loop (loop);
4440
4441   if (dump_file)
4442     {
4443       fprintf (dump_file, ";; After hardware loops optimization:\n\n");
4444       bfin_dump_loops (loops);
4445     }
4446
4447   free_loops (loops);
4448
4449   if (dump_file)
4450     print_rtl (dump_file, get_insns ());
4451
4452   FOR_EACH_BB (bb)
4453     bb->aux = NULL;
4454 }
4455 \f
4456 /* Possibly generate a SEQUENCE out of three insns found in SLOT.
4457    Returns true if we modified the insn chain, false otherwise.  */
4458 static bool
4459 gen_one_bundle (rtx slot[3])
4460 {
4461   gcc_assert (slot[1] != NULL_RTX);
4462
4463   /* Don't add extra NOPs if optimizing for size.  */
4464   if (optimize_size
4465       && (slot[0] == NULL_RTX || slot[2] == NULL_RTX))
4466     return false;
4467
4468   /* Verify that we really can do the multi-issue.  */
4469   if (slot[0])
4470     {
4471       rtx t = NEXT_INSN (slot[0]);
4472       while (t != slot[1])
4473         {
4474           if (GET_CODE (t) != NOTE
4475               || NOTE_KIND (t) != NOTE_INSN_DELETED)
4476             return false;
4477           t = NEXT_INSN (t);
4478         }
4479     }
4480   if (slot[2])
4481     {
4482       rtx t = NEXT_INSN (slot[1]);
4483       while (t != slot[2])
4484         {
4485           if (GET_CODE (t) != NOTE
4486               || NOTE_KIND (t) != NOTE_INSN_DELETED)
4487             return false;
4488           t = NEXT_INSN (t);
4489         }
4490     }
4491
4492   if (slot[0] == NULL_RTX)
4493     {
4494       slot[0] = emit_insn_before (gen_mnop (), slot[1]);
4495       df_insn_rescan (slot[0]);
4496     }
4497   if (slot[2] == NULL_RTX)
4498     {
4499       slot[2] = emit_insn_after (gen_forced_nop (), slot[1]);
4500       df_insn_rescan (slot[2]);
4501     }
4502
4503   /* Avoid line number information being printed inside one bundle.  */
4504   if (INSN_LOCATOR (slot[1])
4505       && INSN_LOCATOR (slot[1]) != INSN_LOCATOR (slot[0]))
4506     INSN_LOCATOR (slot[1]) = INSN_LOCATOR (slot[0]);
4507   if (INSN_LOCATOR (slot[2])
4508       && INSN_LOCATOR (slot[2]) != INSN_LOCATOR (slot[0]))
4509     INSN_LOCATOR (slot[2]) = INSN_LOCATOR (slot[0]);
4510
4511   /* Terminate them with "|| " instead of ";" in the output.  */
4512   PUT_MODE (slot[0], SImode);
4513   PUT_MODE (slot[1], SImode);
4514   /* Terminate the bundle, for the benefit of reorder_var_tracking_notes.  */
4515   PUT_MODE (slot[2], QImode);
4516   return true;
4517 }
4518
4519 /* Go through all insns, and use the information generated during scheduling
4520    to generate SEQUENCEs to represent bundles of instructions issued
4521    simultaneously.  */
4522
4523 static void
4524 bfin_gen_bundles (void)
4525 {
4526   basic_block bb;
4527   FOR_EACH_BB (bb)
4528     {
4529       rtx insn, next;
4530       rtx slot[3];
4531       int n_filled = 0;
4532
4533       slot[0] = slot[1] = slot[2] = NULL_RTX;
4534       for (insn = BB_HEAD (bb);; insn = next)
4535         {
4536           int at_end;
4537           if (INSN_P (insn))
4538             {
4539               if (get_attr_type (insn) == TYPE_DSP32)
4540                 slot[0] = insn;
4541               else if (slot[1] == NULL_RTX)
4542                 slot[1] = insn;
4543               else
4544                 slot[2] = insn;
4545               n_filled++;
4546             }
4547
4548           next = NEXT_INSN (insn);
4549           while (next && insn != BB_END (bb)
4550                  && !(INSN_P (next)
4551                       && GET_CODE (PATTERN (next)) != USE
4552                       && GET_CODE (PATTERN (next)) != CLOBBER))
4553             {
4554               insn = next;
4555               next = NEXT_INSN (insn);
4556             }
4557
4558           /* BB_END can change due to emitting extra NOPs, so check here.  */
4559           at_end = insn == BB_END (bb);
4560           if (at_end || GET_MODE (next) == TImode)
4561             {
4562               if ((n_filled < 2
4563                    || !gen_one_bundle (slot))
4564                   && slot[0] != NULL_RTX)
4565                 {
4566                   rtx pat = PATTERN (slot[0]);
4567                   if (GET_CODE (pat) == SET
4568                       && GET_CODE (SET_SRC (pat)) == UNSPEC
4569                       && XINT (SET_SRC (pat), 1) == UNSPEC_32BIT)
4570                     {
4571                       SET_SRC (pat) = XVECEXP (SET_SRC (pat), 0, 0);
4572                       INSN_CODE (slot[0]) = -1;
4573                       df_insn_rescan (slot[0]);
4574                     }
4575                 }
4576               n_filled = 0;
4577               slot[0] = slot[1] = slot[2] = NULL_RTX;
4578             }
4579           if (at_end)
4580             break;
4581         }
4582     }
4583 }
4584
4585 /* Ensure that no var tracking notes are emitted in the middle of a
4586    three-instruction bundle.  */
4587
4588 static void
4589 reorder_var_tracking_notes (void)
4590 {
4591   basic_block bb;
4592   FOR_EACH_BB (bb)
4593     {
4594       rtx insn, next;
4595       rtx queue = NULL_RTX;
4596       bool in_bundle = false;
4597
4598       for (insn = BB_HEAD (bb); insn != BB_END (bb); insn = next)
4599         {
4600           next = NEXT_INSN (insn);
4601
4602           if (INSN_P (insn))
4603             {
4604               /* Emit queued up notes at the last instruction of a bundle.  */
4605               if (GET_MODE (insn) == QImode)
4606                 {
4607                   while (queue)
4608                     {
4609                       rtx next_queue = PREV_INSN (queue);
4610                       PREV_INSN (NEXT_INSN (insn)) = queue;
4611                       NEXT_INSN (queue) = NEXT_INSN (insn);
4612                       NEXT_INSN (insn) = queue;
4613                       PREV_INSN (queue) = insn;
4614                       queue = next_queue;
4615                     }
4616                   in_bundle = false;
4617                 }
4618               else if (GET_MODE (insn) == SImode)
4619                 in_bundle = true;
4620             }
4621           else if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION)
4622             {
4623               if (in_bundle)
4624                 {
4625                   rtx prev = PREV_INSN (insn);
4626                   PREV_INSN (next) = prev;
4627                   NEXT_INSN (prev) = next;
4628
4629                   PREV_INSN (insn) = queue;
4630                   queue = insn;
4631                 }
4632             }
4633         }
4634     }
4635 }
4636 \f
4637 /* On some silicon revisions, functions shorter than a certain number of cycles
4638    can cause unpredictable behaviour.  Work around this by adding NOPs as
4639    needed.  */
4640 static void
4641 workaround_rts_anomaly (void)
4642 {
4643   rtx insn, first_insn = NULL_RTX;
4644   int cycles = 4;
4645
4646   if (! ENABLE_WA_RETS)
4647     return;
4648
4649   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4650     {
4651       rtx pat;
4652
4653       if (BARRIER_P (insn))
4654         return;
4655
4656       if (NOTE_P (insn) || LABEL_P (insn))
4657         continue;
4658
4659       if (first_insn == NULL_RTX)
4660         first_insn = insn;
4661       pat = PATTERN (insn);
4662       if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
4663           || GET_CODE (pat) == ASM_INPUT || GET_CODE (pat) == ADDR_VEC
4664           || GET_CODE (pat) == ADDR_DIFF_VEC || asm_noperands (pat) >= 0)
4665         continue;
4666
4667       if (CALL_P (insn))
4668         return;
4669
4670       if (JUMP_P (insn))
4671         {
4672           if (recog_memoized (insn) == CODE_FOR_return_internal)
4673             break;
4674
4675           /* Nothing to worry about for direct jumps.  */
4676           if (!any_condjump_p (insn))
4677             return;
4678           if (cycles <= 1)
4679             return;
4680           cycles--;
4681         }
4682       else if (INSN_P (insn))
4683         {
4684           rtx pat = PATTERN (insn);
4685           int this_cycles = 1;
4686
4687           if (GET_CODE (pat) == PARALLEL)
4688             {
4689               if (push_multiple_operation (pat, VOIDmode)
4690                   || pop_multiple_operation (pat, VOIDmode))
4691                 this_cycles = n_regs_to_save;
4692             }
4693           else
4694             {
4695               enum insn_code icode = recog_memoized (insn);
4696               if (icode == CODE_FOR_link)
4697                 this_cycles = 4;
4698               else if (icode == CODE_FOR_unlink)
4699                 this_cycles = 3;
4700               else if (icode == CODE_FOR_mulsi3)
4701                 this_cycles = 5;
4702             }
4703           if (this_cycles >= cycles)
4704             return;
4705
4706           cycles -= this_cycles;
4707         }
4708     }
4709   while (cycles > 0)
4710     {
4711       emit_insn_before (gen_nop (), first_insn);
4712       cycles--;
4713     }
4714 }
4715
4716 /* Return an insn type for INSN that can be used by the caller for anomaly
4717    workarounds.  This differs from plain get_attr_type in that it handles
4718    SEQUENCEs.  */
4719
4720 static enum attr_type
4721 type_for_anomaly (rtx insn)
4722 {
4723   rtx pat = PATTERN (insn);
4724   if (GET_CODE (pat) == SEQUENCE)
4725     {
4726       enum attr_type t;
4727       t = get_attr_type (XVECEXP (pat, 0, 1));
4728       if (t == TYPE_MCLD)
4729         return t;
4730       t = get_attr_type (XVECEXP (pat, 0, 2));
4731       if (t == TYPE_MCLD)
4732         return t;
4733       return TYPE_MCST;
4734     }
4735   else
4736     return get_attr_type (insn);
4737 }
4738
4739 /* Return nonzero if INSN contains any loads that may trap.  It handles
4740    SEQUENCEs correctly.  */
4741
4742 static bool
4743 trapping_loads_p (rtx insn)
4744 {
4745   rtx pat = PATTERN (insn);
4746   if (GET_CODE (pat) == SEQUENCE)
4747     {
4748       enum attr_type t;
4749       t = get_attr_type (XVECEXP (pat, 0, 1));
4750       if (t == TYPE_MCLD
4751           && may_trap_p (SET_SRC (PATTERN (XVECEXP (pat, 0, 1)))))
4752         return true;
4753       t = get_attr_type (XVECEXP (pat, 0, 2));
4754       if (t == TYPE_MCLD
4755           && may_trap_p (SET_SRC (PATTERN (XVECEXP (pat, 0, 2)))))
4756         return true;
4757       return false;
4758     }
4759   else
4760     return may_trap_p (SET_SRC (single_set (insn)));
4761 }
4762
4763 /* This function acts like NEXT_INSN, but is aware of three-insn bundles and
4764    skips all subsequent parallel instructions if INSN is the start of such
4765    a group.  */
4766 static rtx
4767 find_next_insn_start (rtx insn)
4768 {
4769   if (GET_MODE (insn) == SImode)
4770     {
4771       while (GET_MODE (insn) != QImode)
4772         insn = NEXT_INSN (insn);
4773     }
4774   return NEXT_INSN (insn);
4775 }
4776
4777 /* Return INSN if it is of TYPE_MCLD.  Alternatively, if INSN is the start of
4778    a three-insn bundle, see if one of them is a load and return that if so.
4779    Return NULL_RTX if the insn does not contain loads.  */
4780 static rtx
4781 find_load (rtx insn)
4782 {
4783   if (get_attr_type (insn) == TYPE_MCLD)
4784     return insn;
4785   if (GET_MODE (insn) != SImode)
4786     return NULL_RTX;
4787   do {
4788     insn = NEXT_INSN (insn);
4789     if ((GET_MODE (insn) == SImode || GET_MODE (insn) == QImode)
4790         && get_attr_type (insn) == TYPE_MCLD)
4791       return insn;
4792   } while (GET_MODE (insn) != QImode);
4793   return NULL_RTX;
4794 }
4795
4796 static void
4797 workaround_speculation (void)
4798 {
4799   rtx insn, next;
4800   rtx last_condjump = NULL_RTX;
4801   int cycles_since_jump = INT_MAX;
4802
4803   if (! ENABLE_WA_SPECULATIVE_LOADS && ! ENABLE_WA_SPECULATIVE_SYNCS)
4804     return;
4805
4806   /* First pass: find predicted-false branches; if something after them
4807      needs nops, insert them or change the branch to predict true.  */
4808   for (insn = get_insns (); insn; insn = next)
4809     {
4810       rtx pat;
4811
4812       next = find_next_insn_start (insn);
4813
4814       if (NOTE_P (insn) || BARRIER_P (insn) || LABEL_P (insn))
4815         continue;
4816
4817       pat = PATTERN (insn);
4818       if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
4819           || GET_CODE (pat) == ASM_INPUT || GET_CODE (pat) == ADDR_VEC
4820           || GET_CODE (pat) == ADDR_DIFF_VEC || asm_noperands (pat) >= 0)
4821         continue;
4822
4823       if (JUMP_P (insn))
4824         {
4825           if (any_condjump_p (insn)
4826               && ! cbranch_predicted_taken_p (insn))
4827             {
4828               last_condjump = insn;
4829               cycles_since_jump = 0;
4830             }
4831           else
4832             cycles_since_jump = INT_MAX;
4833         }
4834       else if (INSN_P (insn))
4835         {
4836           rtx load_insn = find_load (insn);
4837           enum attr_type type = type_for_anomaly (insn);
4838           int delay_needed = 0;
4839           if (cycles_since_jump < INT_MAX)
4840             cycles_since_jump++;
4841
4842           if (load_insn && ENABLE_WA_SPECULATIVE_LOADS)
4843             {
4844               if (trapping_loads_p (load_insn))
4845                 delay_needed = 3;
4846             }
4847           else if (type == TYPE_SYNC && ENABLE_WA_SPECULATIVE_SYNCS)
4848             delay_needed = 4;
4849
4850           if (delay_needed > cycles_since_jump)
4851             {
4852               rtx pat;
4853               int num_clobbers;
4854               rtx *op = recog_data.operand;
4855
4856               delay_needed -= cycles_since_jump;
4857
4858               extract_insn (last_condjump);
4859               if (optimize_size)
4860                 {
4861                   pat = gen_cbranch_predicted_taken (op[0], op[1], op[2],
4862                                                      op[3]);
4863                   cycles_since_jump = INT_MAX;
4864                 }
4865               else
4866                 /* Do not adjust cycles_since_jump in this case, so that
4867                    we'll increase the number of NOPs for a subsequent insn
4868                    if necessary.  */
4869                 pat = gen_cbranch_with_nops (op[0], op[1], op[2], op[3],
4870                                              GEN_INT (delay_needed));
4871               PATTERN (last_condjump) = pat;
4872               INSN_CODE (last_condjump) = recog (pat, insn, &num_clobbers);
4873             }
4874         }
4875     }
4876   /* Second pass: for predicted-true branches, see if anything at the
4877      branch destination needs extra nops.  */
4878   if (! ENABLE_WA_SPECULATIVE_SYNCS)
4879     return;
4880
4881   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4882     {
4883       int cycles_since_jump;
4884       if (JUMP_P (insn)
4885           && any_condjump_p (insn)
4886           && (INSN_CODE (insn) == CODE_FOR_cbranch_predicted_taken
4887               || cbranch_predicted_taken_p (insn)))
4888         {
4889           rtx target = JUMP_LABEL (insn);
4890           rtx label = target;
4891           cycles_since_jump = 0;
4892           for (; target && cycles_since_jump < 3; target = NEXT_INSN (target))
4893             {
4894               rtx pat;
4895
4896               if (NOTE_P (target) || BARRIER_P (target) || LABEL_P (target))
4897                 continue;
4898
4899               pat = PATTERN (target);
4900               if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
4901                   || GET_CODE (pat) == ASM_INPUT || GET_CODE (pat) == ADDR_VEC
4902                   || GET_CODE (pat) == ADDR_DIFF_VEC || asm_noperands (pat) >= 0)
4903                 continue;
4904
4905               if (INSN_P (target))
4906                 {
4907                   enum attr_type type = type_for_anomaly (target);
4908                   int delay_needed = 0;
4909                   if (cycles_since_jump < INT_MAX)
4910                     cycles_since_jump++;
4911
4912                   if (type == TYPE_SYNC && ENABLE_WA_SPECULATIVE_SYNCS)
4913                     delay_needed = 2;
4914
4915                   if (delay_needed > cycles_since_jump)
4916                     {
4917                       rtx prev = prev_real_insn (label);
4918                       delay_needed -= cycles_since_jump;
4919                       if (dump_file)
4920                         fprintf (dump_file, "Adding %d nops after %d\n",
4921                                  delay_needed, INSN_UID (label));
4922                       if (JUMP_P (prev)
4923                           && INSN_CODE (prev) == CODE_FOR_cbranch_with_nops)
4924                         {
4925                           rtx x;
4926                           HOST_WIDE_INT v;
4927
4928                           if (dump_file)
4929                             fprintf (dump_file,
4930                                      "Reducing nops on insn %d.\n",
4931                                      INSN_UID (prev));
4932                           x = PATTERN (prev);
4933                           x = XVECEXP (x, 0, 1);
4934                           v = INTVAL (XVECEXP (x, 0, 0)) - delay_needed;
4935                           XVECEXP (x, 0, 0) = GEN_INT (v);
4936                         }
4937                       while (delay_needed-- > 0)
4938                         emit_insn_after (gen_nop (), label);
4939                       break;
4940                     }
4941                 }
4942             }
4943         }
4944     }
4945 }
4946
4947 /* We use the machine specific reorg pass for emitting CSYNC instructions
4948    after conditional branches as needed.
4949
4950    The Blackfin is unusual in that a code sequence like
4951      if cc jump label
4952      r0 = (p0)
4953    may speculatively perform the load even if the condition isn't true.  This
4954    happens for a branch that is predicted not taken, because the pipeline
4955    isn't flushed or stalled, so the early stages of the following instructions,
4956    which perform the memory reference, are allowed to execute before the
4957    jump condition is evaluated.
4958    Therefore, we must insert additional instructions in all places where this
4959    could lead to incorrect behavior.  The manual recommends CSYNC, while
4960    VDSP seems to use NOPs (even though its corresponding compiler option is
4961    named CSYNC).
4962
4963    When optimizing for speed, we emit NOPs, which seems faster than a CSYNC.
4964    When optimizing for size, we turn the branch into a predicted taken one.
4965    This may be slower due to mispredicts, but saves code size.  */
4966
4967 static void
4968 bfin_reorg (void)
4969 {
4970   /* We are freeing block_for_insn in the toplev to keep compatibility
4971      with old MDEP_REORGS that are not CFG based.  Recompute it now.  */
4972   compute_bb_for_insn ();
4973
4974   if (bfin_flag_schedule_insns2)
4975     {
4976       splitting_for_sched = 1;
4977       split_all_insns ();
4978       splitting_for_sched = 0;
4979
4980       timevar_push (TV_SCHED2);
4981       schedule_insns ();
4982       timevar_pop (TV_SCHED2);
4983
4984       /* Examine the schedule and insert nops as necessary for 64-bit parallel
4985          instructions.  */
4986       bfin_gen_bundles ();
4987     }
4988
4989   df_analyze ();
4990
4991   /* Doloop optimization */
4992   if (cfun->machine->has_hardware_loops)
4993     bfin_reorg_loops (dump_file);
4994
4995   workaround_speculation ();
4996
4997   if (bfin_flag_var_tracking)
4998     {
4999       timevar_push (TV_VAR_TRACKING);
5000       variable_tracking_main ();
5001       reorder_var_tracking_notes ();
5002       timevar_pop (TV_VAR_TRACKING);
5003     }
5004
5005   df_finish_pass (false);
5006
5007   workaround_rts_anomaly ();
5008 }
5009 \f
5010 /* Handle interrupt_handler, exception_handler and nmi_handler function
5011    attributes; arguments as in struct attribute_spec.handler.  */
5012
5013 static tree
5014 handle_int_attribute (tree *node, tree name,
5015                       tree args ATTRIBUTE_UNUSED,
5016                       int flags ATTRIBUTE_UNUSED,
5017                       bool *no_add_attrs)
5018 {
5019   tree x = *node;
5020   if (TREE_CODE (x) == FUNCTION_DECL)
5021     x = TREE_TYPE (x);
5022
5023   if (TREE_CODE (x) != FUNCTION_TYPE)
5024     {
5025       warning (OPT_Wattributes, "%qs attribute only applies to functions",
5026                IDENTIFIER_POINTER (name));
5027       *no_add_attrs = true;
5028     }
5029   else if (funkind (x) != SUBROUTINE)
5030     error ("multiple function type attributes specified");
5031
5032   return NULL_TREE;
5033 }
5034
5035 /* Return 0 if the attributes for two types are incompatible, 1 if they
5036    are compatible, and 2 if they are nearly compatible (which causes a
5037    warning to be generated).  */
5038
5039 static int
5040 bfin_comp_type_attributes (const_tree type1, const_tree type2)
5041 {
5042   e_funkind kind1, kind2;
5043
5044   if (TREE_CODE (type1) != FUNCTION_TYPE)
5045     return 1;
5046
5047   kind1 = funkind (type1);
5048   kind2 = funkind (type2);
5049
5050   if (kind1 != kind2)
5051     return 0;
5052
5053   /*  Check for mismatched modifiers */
5054   if (!lookup_attribute ("nesting", TYPE_ATTRIBUTES (type1))
5055       != !lookup_attribute ("nesting", TYPE_ATTRIBUTES (type2)))
5056     return 0;
5057
5058   if (!lookup_attribute ("saveall", TYPE_ATTRIBUTES (type1))
5059       != !lookup_attribute ("saveall", TYPE_ATTRIBUTES (type2)))
5060     return 0;
5061
5062   if (!lookup_attribute ("kspisusp", TYPE_ATTRIBUTES (type1))
5063       != !lookup_attribute ("kspisusp", TYPE_ATTRIBUTES (type2)))
5064     return 0;
5065
5066   if (!lookup_attribute ("longcall", TYPE_ATTRIBUTES (type1))
5067       != !lookup_attribute ("longcall", TYPE_ATTRIBUTES (type2)))
5068     return 0;
5069
5070   return 1;
5071 }
5072
5073 /* Handle a "longcall" or "shortcall" attribute; arguments as in
5074    struct attribute_spec.handler.  */
5075
5076 static tree
5077 bfin_handle_longcall_attribute (tree *node, tree name,
5078                                 tree args ATTRIBUTE_UNUSED,
5079                                 int flags ATTRIBUTE_UNUSED,
5080                                 bool *no_add_attrs)
5081 {
5082   if (TREE_CODE (*node) != FUNCTION_TYPE
5083       && TREE_CODE (*node) != FIELD_DECL
5084       && TREE_CODE (*node) != TYPE_DECL)
5085     {
5086       warning (OPT_Wattributes, "`%s' attribute only applies to functions",
5087                IDENTIFIER_POINTER (name));
5088       *no_add_attrs = true;
5089     }
5090
5091   if ((strcmp (IDENTIFIER_POINTER (name), "longcall") == 0
5092        && lookup_attribute ("shortcall", TYPE_ATTRIBUTES (*node)))
5093       || (strcmp (IDENTIFIER_POINTER (name), "shortcall") == 0
5094           && lookup_attribute ("longcall", TYPE_ATTRIBUTES (*node))))
5095     {
5096       warning (OPT_Wattributes,
5097                "can't apply both longcall and shortcall attributes to the same function");
5098       *no_add_attrs = true;
5099     }
5100
5101   return NULL_TREE;
5102 }
5103
5104 /* Handle a "l1_text" attribute; arguments as in
5105    struct attribute_spec.handler.  */
5106
5107 static tree
5108 bfin_handle_l1_text_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5109                                int ARG_UNUSED (flags), bool *no_add_attrs)
5110 {
5111   tree decl = *node;
5112
5113   if (TREE_CODE (decl) != FUNCTION_DECL)
5114     {
5115       error ("`%s' attribute only applies to functions",
5116              IDENTIFIER_POINTER (name));
5117       *no_add_attrs = true;
5118     }
5119
5120   /* The decl may have already been given a section attribute
5121      from a previous declaration. Ensure they match.  */
5122   else if (DECL_SECTION_NAME (decl) != NULL_TREE
5123            && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5124                       ".l1.text") != 0)
5125     {
5126       error ("section of %q+D conflicts with previous declaration",
5127              decl);
5128       *no_add_attrs = true;
5129     }
5130   else
5131     DECL_SECTION_NAME (decl) = build_string (9, ".l1.text");
5132
5133   return NULL_TREE;
5134 }
5135
5136 /* Handle a "l1_data", "l1_data_A" or "l1_data_B" attribute;
5137    arguments as in struct attribute_spec.handler.  */
5138
5139 static tree
5140 bfin_handle_l1_data_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5141                                int ARG_UNUSED (flags), bool *no_add_attrs)
5142 {
5143   tree decl = *node;
5144
5145   if (TREE_CODE (decl) != VAR_DECL)
5146     {
5147       error ("`%s' attribute only applies to variables",
5148              IDENTIFIER_POINTER (name));
5149       *no_add_attrs = true;
5150     }
5151   else if (current_function_decl != NULL_TREE
5152            && !TREE_STATIC (decl))
5153     {
5154       error ("`%s' attribute cannot be specified for local variables",
5155              IDENTIFIER_POINTER (name));
5156       *no_add_attrs = true;
5157     }
5158   else
5159     {
5160       const char *section_name;
5161
5162       if (strcmp (IDENTIFIER_POINTER (name), "l1_data") == 0)
5163         section_name = ".l1.data";
5164       else if (strcmp (IDENTIFIER_POINTER (name), "l1_data_A") == 0)
5165         section_name = ".l1.data.A";
5166       else if (strcmp (IDENTIFIER_POINTER (name), "l1_data_B") == 0)
5167         section_name = ".l1.data.B";
5168       else
5169         gcc_unreachable ();
5170
5171       /* The decl may have already been given a section attribute
5172          from a previous declaration. Ensure they match.  */
5173       if (DECL_SECTION_NAME (decl) != NULL_TREE
5174           && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5175                      section_name) != 0)
5176         {
5177           error ("section of %q+D conflicts with previous declaration",
5178                  decl);
5179           *no_add_attrs = true;
5180         }
5181       else
5182         DECL_SECTION_NAME (decl)
5183           = build_string (strlen (section_name) + 1, section_name);
5184     }
5185
5186  return NULL_TREE;
5187 }
5188
5189 /* Table of valid machine attributes.  */
5190 const struct attribute_spec bfin_attribute_table[] =
5191 {
5192   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
5193   { "interrupt_handler", 0, 0, false, true,  true, handle_int_attribute },
5194   { "exception_handler", 0, 0, false, true,  true, handle_int_attribute },
5195   { "nmi_handler", 0, 0, false, true,  true, handle_int_attribute },
5196   { "nesting", 0, 0, false, true,  true, NULL },
5197   { "kspisusp", 0, 0, false, true,  true, NULL },
5198   { "saveall", 0, 0, false, true,  true, NULL },
5199   { "longcall",  0, 0, false, true,  true,  bfin_handle_longcall_attribute },
5200   { "shortcall", 0, 0, false, true,  true,  bfin_handle_longcall_attribute },
5201   { "l1_text", 0, 0, true, false, false,  bfin_handle_l1_text_attribute },
5202   { "l1_data", 0, 0, true, false, false,  bfin_handle_l1_data_attribute },
5203   { "l1_data_A", 0, 0, true, false, false, bfin_handle_l1_data_attribute },
5204   { "l1_data_B", 0, 0, true, false, false,  bfin_handle_l1_data_attribute },
5205   { NULL, 0, 0, false, false, false, NULL }
5206 };
5207 \f
5208 /* Implementation of TARGET_ASM_INTEGER.  When using FD-PIC, we need to
5209    tell the assembler to generate pointers to function descriptors in
5210    some cases.  */
5211
5212 static bool
5213 bfin_assemble_integer (rtx value, unsigned int size, int aligned_p)
5214 {
5215   if (TARGET_FDPIC && size == UNITS_PER_WORD)
5216     {
5217       if (GET_CODE (value) == SYMBOL_REF
5218           && SYMBOL_REF_FUNCTION_P (value))
5219         {
5220           fputs ("\t.picptr\tfuncdesc(", asm_out_file);
5221           output_addr_const (asm_out_file, value);
5222           fputs (")\n", asm_out_file);
5223           return true;
5224         }
5225       if (!aligned_p)
5226         {
5227           /* We've set the unaligned SI op to NULL, so we always have to
5228              handle the unaligned case here.  */
5229           assemble_integer_with_op ("\t.4byte\t", value);
5230           return true;
5231         }
5232     }
5233   return default_assemble_integer (value, size, aligned_p);
5234 }
5235 \f
5236 /* Output the assembler code for a thunk function.  THUNK_DECL is the
5237    declaration for the thunk function itself, FUNCTION is the decl for
5238    the target function.  DELTA is an immediate constant offset to be
5239    added to THIS.  If VCALL_OFFSET is nonzero, the word at
5240    *(*this + vcall_offset) should be added to THIS.  */
5241
5242 static void
5243 bfin_output_mi_thunk (FILE *file ATTRIBUTE_UNUSED,
5244                       tree thunk ATTRIBUTE_UNUSED, HOST_WIDE_INT delta,
5245                       HOST_WIDE_INT vcall_offset, tree function)
5246 {
5247   rtx xops[3];
5248   /* The this parameter is passed as the first argument.  */
5249   rtx this_rtx = gen_rtx_REG (Pmode, REG_R0);
5250
5251   /* Adjust the this parameter by a fixed constant.  */
5252   if (delta)
5253     {
5254       xops[1] = this_rtx;
5255       if (delta >= -64 && delta <= 63)
5256         {
5257           xops[0] = GEN_INT (delta);
5258           output_asm_insn ("%1 += %0;", xops);
5259         }
5260       else if (delta >= -128 && delta < -64)
5261         {
5262           xops[0] = GEN_INT (delta + 64);
5263           output_asm_insn ("%1 += -64; %1 += %0;", xops);
5264         }
5265       else if (delta > 63 && delta <= 126)
5266         {
5267           xops[0] = GEN_INT (delta - 63);
5268           output_asm_insn ("%1 += 63; %1 += %0;", xops);
5269         }
5270       else
5271         {
5272           xops[0] = GEN_INT (delta);
5273           output_asm_insn ("r3.l = %h0; r3.h = %d0; %1 = %1 + r3;", xops);
5274         }
5275     }
5276
5277   /* Adjust the this parameter by a value stored in the vtable.  */
5278   if (vcall_offset)
5279     {
5280       rtx p2tmp = gen_rtx_REG (Pmode, REG_P2);
5281       rtx tmp = gen_rtx_REG (Pmode, REG_R3);
5282
5283       xops[1] = tmp;
5284       xops[2] = p2tmp;
5285       output_asm_insn ("%2 = r0; %2 = [%2];", xops);
5286
5287       /* Adjust the this parameter.  */
5288       xops[0] = gen_rtx_MEM (Pmode, plus_constant (p2tmp, vcall_offset));
5289       if (!memory_operand (xops[0], Pmode))
5290         {
5291           rtx tmp2 = gen_rtx_REG (Pmode, REG_P1);
5292           xops[0] = GEN_INT (vcall_offset);
5293           xops[1] = tmp2;
5294           output_asm_insn ("%h1 = %h0; %d1 = %d0; %2 = %2 + %1", xops);
5295           xops[0] = gen_rtx_MEM (Pmode, p2tmp);
5296         }
5297       xops[2] = this_rtx;
5298       output_asm_insn ("%1 = %0; %2 = %2 + %1;", xops);
5299     }
5300
5301   xops[0] = XEXP (DECL_RTL (function), 0);
5302   if (1 || !flag_pic || (*targetm.binds_local_p) (function))
5303     output_asm_insn ("jump.l\t%P0", xops);
5304 }
5305 \f
5306 /* Codes for all the Blackfin builtins.  */
5307 enum bfin_builtins
5308 {
5309   BFIN_BUILTIN_CSYNC,
5310   BFIN_BUILTIN_SSYNC,
5311   BFIN_BUILTIN_ONES,
5312   BFIN_BUILTIN_COMPOSE_2X16,
5313   BFIN_BUILTIN_EXTRACTLO,
5314   BFIN_BUILTIN_EXTRACTHI,
5315
5316   BFIN_BUILTIN_SSADD_2X16,
5317   BFIN_BUILTIN_SSSUB_2X16,
5318   BFIN_BUILTIN_SSADDSUB_2X16,
5319   BFIN_BUILTIN_SSSUBADD_2X16,
5320   BFIN_BUILTIN_MULT_2X16,
5321   BFIN_BUILTIN_MULTR_2X16,
5322   BFIN_BUILTIN_NEG_2X16,
5323   BFIN_BUILTIN_ABS_2X16,
5324   BFIN_BUILTIN_MIN_2X16,
5325   BFIN_BUILTIN_MAX_2X16,
5326
5327   BFIN_BUILTIN_SSADD_1X16,
5328   BFIN_BUILTIN_SSSUB_1X16,
5329   BFIN_BUILTIN_MULT_1X16,
5330   BFIN_BUILTIN_MULTR_1X16,
5331   BFIN_BUILTIN_NORM_1X16,
5332   BFIN_BUILTIN_NEG_1X16,
5333   BFIN_BUILTIN_ABS_1X16,
5334   BFIN_BUILTIN_MIN_1X16,
5335   BFIN_BUILTIN_MAX_1X16,
5336
5337   BFIN_BUILTIN_SUM_2X16,
5338   BFIN_BUILTIN_DIFFHL_2X16,
5339   BFIN_BUILTIN_DIFFLH_2X16,
5340
5341   BFIN_BUILTIN_SSADD_1X32,
5342   BFIN_BUILTIN_SSSUB_1X32,
5343   BFIN_BUILTIN_NORM_1X32,
5344   BFIN_BUILTIN_ROUND_1X32,
5345   BFIN_BUILTIN_NEG_1X32,
5346   BFIN_BUILTIN_ABS_1X32,
5347   BFIN_BUILTIN_MIN_1X32,
5348   BFIN_BUILTIN_MAX_1X32,
5349   BFIN_BUILTIN_MULT_1X32,
5350   BFIN_BUILTIN_MULT_1X32X32,
5351   BFIN_BUILTIN_MULT_1X32X32NS,
5352
5353   BFIN_BUILTIN_MULHISILL,
5354   BFIN_BUILTIN_MULHISILH,
5355   BFIN_BUILTIN_MULHISIHL,
5356   BFIN_BUILTIN_MULHISIHH,
5357
5358   BFIN_BUILTIN_LSHIFT_1X16,
5359   BFIN_BUILTIN_LSHIFT_2X16,
5360   BFIN_BUILTIN_SSASHIFT_1X16,
5361   BFIN_BUILTIN_SSASHIFT_2X16,
5362   BFIN_BUILTIN_SSASHIFT_1X32,
5363
5364   BFIN_BUILTIN_CPLX_MUL_16,
5365   BFIN_BUILTIN_CPLX_MAC_16,
5366   BFIN_BUILTIN_CPLX_MSU_16,
5367
5368   BFIN_BUILTIN_CPLX_MUL_16_S40,
5369   BFIN_BUILTIN_CPLX_MAC_16_S40,
5370   BFIN_BUILTIN_CPLX_MSU_16_S40,
5371
5372   BFIN_BUILTIN_CPLX_SQU,
5373
5374   BFIN_BUILTIN_LOADBYTES,
5375
5376   BFIN_BUILTIN_MAX
5377 };
5378
5379 #define def_builtin(NAME, TYPE, CODE)                                   \
5380 do {                                                                    \
5381   add_builtin_function ((NAME), (TYPE), (CODE), BUILT_IN_MD,            \
5382                        NULL, NULL_TREE);                                \
5383 } while (0)
5384
5385 /* Set up all builtin functions for this target.  */
5386 static void
5387 bfin_init_builtins (void)
5388 {
5389   tree V2HI_type_node = build_vector_type_for_mode (intHI_type_node, V2HImode);
5390   tree void_ftype_void
5391     = build_function_type (void_type_node, void_list_node);
5392   tree short_ftype_short
5393     = build_function_type_list (short_integer_type_node, short_integer_type_node,
5394                                 NULL_TREE);
5395   tree short_ftype_int_int
5396     = build_function_type_list (short_integer_type_node, integer_type_node,
5397                                 integer_type_node, NULL_TREE);
5398   tree int_ftype_int_int
5399     = build_function_type_list (integer_type_node, integer_type_node,
5400                                 integer_type_node, NULL_TREE);
5401   tree int_ftype_int
5402     = build_function_type_list (integer_type_node, integer_type_node,
5403                                 NULL_TREE);
5404   tree short_ftype_int
5405     = build_function_type_list (short_integer_type_node, integer_type_node,
5406                                 NULL_TREE);
5407   tree int_ftype_v2hi_v2hi
5408     = build_function_type_list (integer_type_node, V2HI_type_node,
5409                                 V2HI_type_node, NULL_TREE);
5410   tree v2hi_ftype_v2hi_v2hi
5411     = build_function_type_list (V2HI_type_node, V2HI_type_node,
5412                                 V2HI_type_node, NULL_TREE);
5413   tree v2hi_ftype_v2hi_v2hi_v2hi
5414     = build_function_type_list (V2HI_type_node, V2HI_type_node,
5415                                 V2HI_type_node, V2HI_type_node, NULL_TREE);
5416   tree v2hi_ftype_int_int
5417     = build_function_type_list (V2HI_type_node, integer_type_node,
5418                                 integer_type_node, NULL_TREE);
5419   tree v2hi_ftype_v2hi_int
5420     = build_function_type_list (V2HI_type_node, V2HI_type_node,
5421                                 integer_type_node, NULL_TREE);
5422   tree int_ftype_short_short
5423     = build_function_type_list (integer_type_node, short_integer_type_node,
5424                                 short_integer_type_node, NULL_TREE);
5425   tree v2hi_ftype_v2hi
5426     = build_function_type_list (V2HI_type_node, V2HI_type_node, NULL_TREE);
5427   tree short_ftype_v2hi
5428     = build_function_type_list (short_integer_type_node, V2HI_type_node,
5429                                 NULL_TREE);
5430   tree int_ftype_pint
5431     = build_function_type_list (integer_type_node,
5432                                 build_pointer_type (integer_type_node),
5433                                 NULL_TREE);
5434
5435   /* Add the remaining MMX insns with somewhat more complicated types.  */
5436   def_builtin ("__builtin_bfin_csync", void_ftype_void, BFIN_BUILTIN_CSYNC);
5437   def_builtin ("__builtin_bfin_ssync", void_ftype_void, BFIN_BUILTIN_SSYNC);
5438
5439   def_builtin ("__builtin_bfin_ones", short_ftype_int, BFIN_BUILTIN_ONES);
5440
5441   def_builtin ("__builtin_bfin_compose_2x16", v2hi_ftype_int_int,
5442                BFIN_BUILTIN_COMPOSE_2X16);
5443   def_builtin ("__builtin_bfin_extract_hi", short_ftype_v2hi,
5444                BFIN_BUILTIN_EXTRACTHI);
5445   def_builtin ("__builtin_bfin_extract_lo", short_ftype_v2hi,
5446                BFIN_BUILTIN_EXTRACTLO);
5447
5448   def_builtin ("__builtin_bfin_min_fr2x16", v2hi_ftype_v2hi_v2hi,
5449                BFIN_BUILTIN_MIN_2X16);
5450   def_builtin ("__builtin_bfin_max_fr2x16", v2hi_ftype_v2hi_v2hi,
5451                BFIN_BUILTIN_MAX_2X16);
5452
5453   def_builtin ("__builtin_bfin_add_fr2x16", v2hi_ftype_v2hi_v2hi,
5454                BFIN_BUILTIN_SSADD_2X16);
5455   def_builtin ("__builtin_bfin_sub_fr2x16", v2hi_ftype_v2hi_v2hi,
5456                BFIN_BUILTIN_SSSUB_2X16);
5457   def_builtin ("__builtin_bfin_dspaddsubsat", v2hi_ftype_v2hi_v2hi,
5458                BFIN_BUILTIN_SSADDSUB_2X16);
5459   def_builtin ("__builtin_bfin_dspsubaddsat", v2hi_ftype_v2hi_v2hi,
5460                BFIN_BUILTIN_SSSUBADD_2X16);
5461   def_builtin ("__builtin_bfin_mult_fr2x16", v2hi_ftype_v2hi_v2hi,
5462                BFIN_BUILTIN_MULT_2X16);
5463   def_builtin ("__builtin_bfin_multr_fr2x16", v2hi_ftype_v2hi_v2hi,
5464                BFIN_BUILTIN_MULTR_2X16);
5465   def_builtin ("__builtin_bfin_negate_fr2x16", v2hi_ftype_v2hi,
5466                BFIN_BUILTIN_NEG_2X16);
5467   def_builtin ("__builtin_bfin_abs_fr2x16", v2hi_ftype_v2hi,
5468                BFIN_BUILTIN_ABS_2X16);
5469
5470   def_builtin ("__builtin_bfin_min_fr1x16", short_ftype_int_int,
5471                BFIN_BUILTIN_MIN_1X16);
5472   def_builtin ("__builtin_bfin_max_fr1x16", short_ftype_int_int,
5473                BFIN_BUILTIN_MAX_1X16);
5474
5475   def_builtin ("__builtin_bfin_add_fr1x16", short_ftype_int_int,
5476                BFIN_BUILTIN_SSADD_1X16);
5477   def_builtin ("__builtin_bfin_sub_fr1x16", short_ftype_int_int,
5478                BFIN_BUILTIN_SSSUB_1X16);
5479   def_builtin ("__builtin_bfin_mult_fr1x16", short_ftype_int_int,
5480                BFIN_BUILTIN_MULT_1X16);
5481   def_builtin ("__builtin_bfin_multr_fr1x16", short_ftype_int_int,
5482                BFIN_BUILTIN_MULTR_1X16);
5483   def_builtin ("__builtin_bfin_negate_fr1x16", short_ftype_short,
5484                BFIN_BUILTIN_NEG_1X16);
5485   def_builtin ("__builtin_bfin_abs_fr1x16", short_ftype_short,
5486                BFIN_BUILTIN_ABS_1X16);
5487   def_builtin ("__builtin_bfin_norm_fr1x16", short_ftype_int,
5488                BFIN_BUILTIN_NORM_1X16);
5489
5490   def_builtin ("__builtin_bfin_sum_fr2x16", short_ftype_v2hi,
5491                BFIN_BUILTIN_SUM_2X16);
5492   def_builtin ("__builtin_bfin_diff_hl_fr2x16", short_ftype_v2hi,
5493                BFIN_BUILTIN_DIFFHL_2X16);
5494   def_builtin ("__builtin_bfin_diff_lh_fr2x16", short_ftype_v2hi,
5495                BFIN_BUILTIN_DIFFLH_2X16);
5496
5497   def_builtin ("__builtin_bfin_mulhisill", int_ftype_v2hi_v2hi,
5498                BFIN_BUILTIN_MULHISILL);
5499   def_builtin ("__builtin_bfin_mulhisihl", int_ftype_v2hi_v2hi,
5500                BFIN_BUILTIN_MULHISIHL);
5501   def_builtin ("__builtin_bfin_mulhisilh", int_ftype_v2hi_v2hi,
5502                BFIN_BUILTIN_MULHISILH);
5503   def_builtin ("__builtin_bfin_mulhisihh", int_ftype_v2hi_v2hi,
5504                BFIN_BUILTIN_MULHISIHH);
5505
5506   def_builtin ("__builtin_bfin_min_fr1x32", int_ftype_int_int,
5507                BFIN_BUILTIN_MIN_1X32);
5508   def_builtin ("__builtin_bfin_max_fr1x32", int_ftype_int_int,
5509                BFIN_BUILTIN_MAX_1X32);
5510
5511   def_builtin ("__builtin_bfin_add_fr1x32", int_ftype_int_int,
5512                BFIN_BUILTIN_SSADD_1X32);
5513   def_builtin ("__builtin_bfin_sub_fr1x32", int_ftype_int_int,
5514                BFIN_BUILTIN_SSSUB_1X32);
5515   def_builtin ("__builtin_bfin_negate_fr1x32", int_ftype_int,
5516                BFIN_BUILTIN_NEG_1X32);
5517   def_builtin ("__builtin_bfin_abs_fr1x32", int_ftype_int,
5518                BFIN_BUILTIN_ABS_1X32);
5519   def_builtin ("__builtin_bfin_norm_fr1x32", short_ftype_int,
5520                BFIN_BUILTIN_NORM_1X32);
5521   def_builtin ("__builtin_bfin_round_fr1x32", short_ftype_int,
5522                BFIN_BUILTIN_ROUND_1X32);
5523   def_builtin ("__builtin_bfin_mult_fr1x32", int_ftype_short_short,
5524                BFIN_BUILTIN_MULT_1X32);
5525   def_builtin ("__builtin_bfin_mult_fr1x32x32", int_ftype_int_int,
5526                BFIN_BUILTIN_MULT_1X32X32);
5527   def_builtin ("__builtin_bfin_mult_fr1x32x32NS", int_ftype_int_int,
5528                BFIN_BUILTIN_MULT_1X32X32NS);
5529
5530   /* Shifts.  */
5531   def_builtin ("__builtin_bfin_shl_fr1x16", short_ftype_int_int,
5532                BFIN_BUILTIN_SSASHIFT_1X16);
5533   def_builtin ("__builtin_bfin_shl_fr2x16", v2hi_ftype_v2hi_int,
5534                BFIN_BUILTIN_SSASHIFT_2X16);
5535   def_builtin ("__builtin_bfin_lshl_fr1x16", short_ftype_int_int,
5536                BFIN_BUILTIN_LSHIFT_1X16);
5537   def_builtin ("__builtin_bfin_lshl_fr2x16", v2hi_ftype_v2hi_int,
5538                BFIN_BUILTIN_LSHIFT_2X16);
5539   def_builtin ("__builtin_bfin_shl_fr1x32", int_ftype_int_int,
5540                BFIN_BUILTIN_SSASHIFT_1X32);
5541
5542   /* Complex numbers.  */
5543   def_builtin ("__builtin_bfin_cmplx_add", v2hi_ftype_v2hi_v2hi,
5544                BFIN_BUILTIN_SSADD_2X16);
5545   def_builtin ("__builtin_bfin_cmplx_sub", v2hi_ftype_v2hi_v2hi,
5546                BFIN_BUILTIN_SSSUB_2X16);
5547   def_builtin ("__builtin_bfin_cmplx_mul", v2hi_ftype_v2hi_v2hi,
5548                BFIN_BUILTIN_CPLX_MUL_16);
5549   def_builtin ("__builtin_bfin_cmplx_mac", v2hi_ftype_v2hi_v2hi_v2hi,
5550                BFIN_BUILTIN_CPLX_MAC_16);
5551   def_builtin ("__builtin_bfin_cmplx_msu", v2hi_ftype_v2hi_v2hi_v2hi,
5552                BFIN_BUILTIN_CPLX_MSU_16);
5553   def_builtin ("__builtin_bfin_cmplx_mul_s40", v2hi_ftype_v2hi_v2hi,
5554                BFIN_BUILTIN_CPLX_MUL_16_S40);
5555   def_builtin ("__builtin_bfin_cmplx_mac_s40", v2hi_ftype_v2hi_v2hi_v2hi,
5556                BFIN_BUILTIN_CPLX_MAC_16_S40);
5557   def_builtin ("__builtin_bfin_cmplx_msu_s40", v2hi_ftype_v2hi_v2hi_v2hi,
5558                BFIN_BUILTIN_CPLX_MSU_16_S40);
5559   def_builtin ("__builtin_bfin_csqu_fr16", v2hi_ftype_v2hi,
5560                BFIN_BUILTIN_CPLX_SQU);
5561
5562   /* "Unaligned" load.  */
5563   def_builtin ("__builtin_bfin_loadbytes", int_ftype_pint,
5564                BFIN_BUILTIN_LOADBYTES);
5565
5566 }
5567
5568
5569 struct builtin_description
5570 {
5571   const enum insn_code icode;
5572   const char *const name;
5573   const enum bfin_builtins code;
5574   int macflag;
5575 };
5576
5577 static const struct builtin_description bdesc_2arg[] =
5578 {
5579   { CODE_FOR_composev2hi, "__builtin_bfin_compose_2x16", BFIN_BUILTIN_COMPOSE_2X16, -1 },
5580
5581   { CODE_FOR_ssashiftv2hi3, "__builtin_bfin_shl_fr2x16", BFIN_BUILTIN_SSASHIFT_2X16, -1 },
5582   { CODE_FOR_ssashifthi3, "__builtin_bfin_shl_fr1x16", BFIN_BUILTIN_SSASHIFT_1X16, -1 },
5583   { CODE_FOR_lshiftv2hi3, "__builtin_bfin_lshl_fr2x16", BFIN_BUILTIN_LSHIFT_2X16, -1 },
5584   { CODE_FOR_lshifthi3, "__builtin_bfin_lshl_fr1x16", BFIN_BUILTIN_LSHIFT_1X16, -1 },
5585   { CODE_FOR_ssashiftsi3, "__builtin_bfin_shl_fr1x32", BFIN_BUILTIN_SSASHIFT_1X32, -1 },
5586
5587   { CODE_FOR_sminhi3, "__builtin_bfin_min_fr1x16", BFIN_BUILTIN_MIN_1X16, -1 },
5588   { CODE_FOR_smaxhi3, "__builtin_bfin_max_fr1x16", BFIN_BUILTIN_MAX_1X16, -1 },
5589   { CODE_FOR_ssaddhi3, "__builtin_bfin_add_fr1x16", BFIN_BUILTIN_SSADD_1X16, -1 },
5590   { CODE_FOR_sssubhi3, "__builtin_bfin_sub_fr1x16", BFIN_BUILTIN_SSSUB_1X16, -1 },
5591
5592   { CODE_FOR_sminsi3, "__builtin_bfin_min_fr1x32", BFIN_BUILTIN_MIN_1X32, -1 },
5593   { CODE_FOR_smaxsi3, "__builtin_bfin_max_fr1x32", BFIN_BUILTIN_MAX_1X32, -1 },
5594   { CODE_FOR_ssaddsi3, "__builtin_bfin_add_fr1x32", BFIN_BUILTIN_SSADD_1X32, -1 },
5595   { CODE_FOR_sssubsi3, "__builtin_bfin_sub_fr1x32", BFIN_BUILTIN_SSSUB_1X32, -1 },
5596
5597   { CODE_FOR_sminv2hi3, "__builtin_bfin_min_fr2x16", BFIN_BUILTIN_MIN_2X16, -1 },
5598   { CODE_FOR_smaxv2hi3, "__builtin_bfin_max_fr2x16", BFIN_BUILTIN_MAX_2X16, -1 },
5599   { CODE_FOR_ssaddv2hi3, "__builtin_bfin_add_fr2x16", BFIN_BUILTIN_SSADD_2X16, -1 },
5600   { CODE_FOR_sssubv2hi3, "__builtin_bfin_sub_fr2x16", BFIN_BUILTIN_SSSUB_2X16, -1 },
5601   { CODE_FOR_ssaddsubv2hi3, "__builtin_bfin_dspaddsubsat", BFIN_BUILTIN_SSADDSUB_2X16, -1 },
5602   { CODE_FOR_sssubaddv2hi3, "__builtin_bfin_dspsubaddsat", BFIN_BUILTIN_SSSUBADD_2X16, -1 },
5603
5604   { CODE_FOR_flag_mulhisi, "__builtin_bfin_mult_fr1x32", BFIN_BUILTIN_MULT_1X32, MACFLAG_NONE },
5605   { CODE_FOR_flag_mulhi, "__builtin_bfin_mult_fr1x16", BFIN_BUILTIN_MULT_1X16, MACFLAG_T },
5606   { CODE_FOR_flag_mulhi, "__builtin_bfin_multr_fr1x16", BFIN_BUILTIN_MULTR_1X16, MACFLAG_NONE },
5607   { CODE_FOR_flag_mulv2hi, "__builtin_bfin_mult_fr2x16", BFIN_BUILTIN_MULT_2X16, MACFLAG_T },
5608   { CODE_FOR_flag_mulv2hi, "__builtin_bfin_multr_fr2x16", BFIN_BUILTIN_MULTR_2X16, MACFLAG_NONE }
5609 };
5610
5611 static const struct builtin_description bdesc_1arg[] =
5612 {
5613   { CODE_FOR_loadbytes, "__builtin_bfin_loadbytes", BFIN_BUILTIN_LOADBYTES, 0 },
5614
5615   { CODE_FOR_ones, "__builtin_bfin_ones", BFIN_BUILTIN_ONES, 0 },
5616
5617   { CODE_FOR_signbitshi2, "__builtin_bfin_norm_fr1x16", BFIN_BUILTIN_NORM_1X16, 0 },
5618   { CODE_FOR_ssneghi2, "__builtin_bfin_negate_fr1x16", BFIN_BUILTIN_NEG_1X16, 0 },
5619   { CODE_FOR_abshi2, "__builtin_bfin_abs_fr1x16", BFIN_BUILTIN_ABS_1X16, 0 },
5620
5621   { CODE_FOR_signbitssi2, "__builtin_bfin_norm_fr1x32", BFIN_BUILTIN_NORM_1X32, 0 },
5622   { CODE_FOR_ssroundsi2, "__builtin_bfin_round_fr1x32", BFIN_BUILTIN_ROUND_1X32, 0 },
5623   { CODE_FOR_ssnegsi2, "__builtin_bfin_negate_fr1x32", BFIN_BUILTIN_NEG_1X32, 0 },
5624   { CODE_FOR_ssabssi2, "__builtin_bfin_abs_fr1x32", BFIN_BUILTIN_ABS_1X32, 0 },
5625
5626   { CODE_FOR_movv2hi_hi_low, "__builtin_bfin_extract_lo", BFIN_BUILTIN_EXTRACTLO, 0 },
5627   { CODE_FOR_movv2hi_hi_high, "__builtin_bfin_extract_hi", BFIN_BUILTIN_EXTRACTHI, 0 },
5628   { CODE_FOR_ssnegv2hi2, "__builtin_bfin_negate_fr2x16", BFIN_BUILTIN_NEG_2X16, 0 },
5629   { CODE_FOR_ssabsv2hi2, "__builtin_bfin_abs_fr2x16", BFIN_BUILTIN_ABS_2X16, 0 }
5630 };
5631
5632 /* Errors in the source file can cause expand_expr to return const0_rtx
5633    where we expect a vector.  To avoid crashing, use one of the vector
5634    clear instructions.  */
5635 static rtx
5636 safe_vector_operand (rtx x, enum machine_mode mode)
5637 {
5638   if (x != const0_rtx)
5639     return x;
5640   x = gen_reg_rtx (SImode);
5641
5642   emit_insn (gen_movsi (x, CONST0_RTX (SImode)));
5643   return gen_lowpart (mode, x);
5644 }
5645
5646 /* Subroutine of bfin_expand_builtin to take care of binop insns.  MACFLAG is -1
5647    if this is a normal binary op, or one of the MACFLAG_xxx constants.  */
5648
5649 static rtx
5650 bfin_expand_binop_builtin (enum insn_code icode, tree exp, rtx target,
5651                            int macflag)
5652 {
5653   rtx pat;
5654   tree arg0 = CALL_EXPR_ARG (exp, 0);
5655   tree arg1 = CALL_EXPR_ARG (exp, 1);
5656   rtx op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5657   rtx op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
5658   enum machine_mode op0mode = GET_MODE (op0);
5659   enum machine_mode op1mode = GET_MODE (op1);
5660   enum machine_mode tmode = insn_data[icode].operand[0].mode;
5661   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
5662   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
5663
5664   if (VECTOR_MODE_P (mode0))
5665     op0 = safe_vector_operand (op0, mode0);
5666   if (VECTOR_MODE_P (mode1))
5667     op1 = safe_vector_operand (op1, mode1);
5668
5669   if (! target
5670       || GET_MODE (target) != tmode
5671       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
5672     target = gen_reg_rtx (tmode);
5673
5674   if ((op0mode == SImode || op0mode == VOIDmode) && mode0 == HImode)
5675     {
5676       op0mode = HImode;
5677       op0 = gen_lowpart (HImode, op0);
5678     }
5679   if ((op1mode == SImode || op1mode == VOIDmode) && mode1 == HImode)
5680     {
5681       op1mode = HImode;
5682       op1 = gen_lowpart (HImode, op1);
5683     }
5684   /* In case the insn wants input operands in modes different from
5685      the result, abort.  */
5686   gcc_assert ((op0mode == mode0 || op0mode == VOIDmode)
5687               && (op1mode == mode1 || op1mode == VOIDmode));
5688
5689   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
5690     op0 = copy_to_mode_reg (mode0, op0);
5691   if (! (*insn_data[icode].operand[2].predicate) (op1, mode1))
5692     op1 = copy_to_mode_reg (mode1, op1);
5693
5694   if (macflag == -1)
5695     pat = GEN_FCN (icode) (target, op0, op1);
5696   else
5697     pat = GEN_FCN (icode) (target, op0, op1, GEN_INT (macflag));
5698   if (! pat)
5699     return 0;
5700
5701   emit_insn (pat);
5702   return target;
5703 }
5704
5705 /* Subroutine of bfin_expand_builtin to take care of unop insns.  */
5706
5707 static rtx
5708 bfin_expand_unop_builtin (enum insn_code icode, tree exp,
5709                           rtx target)
5710 {
5711   rtx pat;
5712   tree arg0 = CALL_EXPR_ARG (exp, 0);
5713   rtx op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5714   enum machine_mode op0mode = GET_MODE (op0);
5715   enum machine_mode tmode = insn_data[icode].operand[0].mode;
5716   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
5717
5718   if (! target
5719       || GET_MODE (target) != tmode
5720       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
5721     target = gen_reg_rtx (tmode);
5722
5723   if (VECTOR_MODE_P (mode0))
5724     op0 = safe_vector_operand (op0, mode0);
5725
5726   if (op0mode == SImode && mode0 == HImode)
5727     {
5728       op0mode = HImode;
5729       op0 = gen_lowpart (HImode, op0);
5730     }
5731   gcc_assert (op0mode == mode0 || op0mode == VOIDmode);
5732
5733   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
5734     op0 = copy_to_mode_reg (mode0, op0);
5735
5736   pat = GEN_FCN (icode) (target, op0);
5737   if (! pat)
5738     return 0;
5739   emit_insn (pat);
5740   return target;
5741 }
5742
5743 /* Expand an expression EXP that calls a built-in function,
5744    with result going to TARGET if that's convenient
5745    (and in mode MODE if that's convenient).
5746    SUBTARGET may be used as the target for computing one of EXP's operands.
5747    IGNORE is nonzero if the value is to be ignored.  */
5748
5749 static rtx
5750 bfin_expand_builtin (tree exp, rtx target ATTRIBUTE_UNUSED,
5751                      rtx subtarget ATTRIBUTE_UNUSED,
5752                      enum machine_mode mode ATTRIBUTE_UNUSED,
5753                      int ignore ATTRIBUTE_UNUSED)
5754 {
5755   size_t i;
5756   enum insn_code icode;
5757   const struct builtin_description *d;
5758   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
5759   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
5760   tree arg0, arg1, arg2;
5761   rtx op0, op1, op2, accvec, pat, tmp1, tmp2, a0reg, a1reg;
5762   enum machine_mode tmode, mode0;
5763
5764   switch (fcode)
5765     {
5766     case BFIN_BUILTIN_CSYNC:
5767       emit_insn (gen_csync ());
5768       return 0;
5769     case BFIN_BUILTIN_SSYNC:
5770       emit_insn (gen_ssync ());
5771       return 0;
5772
5773     case BFIN_BUILTIN_DIFFHL_2X16:
5774     case BFIN_BUILTIN_DIFFLH_2X16:
5775     case BFIN_BUILTIN_SUM_2X16:
5776       arg0 = CALL_EXPR_ARG (exp, 0);
5777       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5778       icode = (fcode == BFIN_BUILTIN_DIFFHL_2X16 ? CODE_FOR_subhilov2hi3
5779                : fcode == BFIN_BUILTIN_DIFFLH_2X16 ? CODE_FOR_sublohiv2hi3
5780                : CODE_FOR_ssaddhilov2hi3);
5781       tmode = insn_data[icode].operand[0].mode;
5782       mode0 = insn_data[icode].operand[1].mode;
5783
5784       if (! target
5785           || GET_MODE (target) != tmode
5786           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
5787         target = gen_reg_rtx (tmode);
5788
5789       if (VECTOR_MODE_P (mode0))
5790         op0 = safe_vector_operand (op0, mode0);
5791
5792       if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
5793         op0 = copy_to_mode_reg (mode0, op0);
5794
5795       pat = GEN_FCN (icode) (target, op0, op0);
5796       if (! pat)
5797         return 0;
5798       emit_insn (pat);
5799       return target;
5800
5801     case BFIN_BUILTIN_MULT_1X32X32:
5802     case BFIN_BUILTIN_MULT_1X32X32NS:
5803       arg0 = CALL_EXPR_ARG (exp, 0);
5804       arg1 = CALL_EXPR_ARG (exp, 1);
5805       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5806       op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
5807       if (! target
5808           || !register_operand (target, SImode))
5809         target = gen_reg_rtx (SImode);
5810
5811       a1reg = gen_rtx_REG (PDImode, REG_A1);
5812       a0reg = gen_rtx_REG (PDImode, REG_A0);
5813       tmp1 = gen_lowpart (V2HImode, op0);
5814       tmp2 = gen_lowpart (V2HImode, op1);
5815       emit_insn (gen_flag_macinit1hi (a1reg,
5816                                       gen_lowpart (HImode, op0),
5817                                       gen_lowpart (HImode, op1),
5818                                       GEN_INT (MACFLAG_FU)));
5819       emit_insn (gen_lshrpdi3 (a1reg, a1reg, GEN_INT (16)));
5820
5821       if (fcode == BFIN_BUILTIN_MULT_1X32X32)
5822         emit_insn (gen_flag_mul_macv2hi_parts_acconly (a0reg, a1reg, tmp1, tmp2,
5823                                                        const1_rtx, const1_rtx,
5824                                                        const1_rtx, const0_rtx, a1reg,
5825                                                        const0_rtx, GEN_INT (MACFLAG_NONE),
5826                                                        GEN_INT (MACFLAG_M)));
5827       else
5828         {
5829           /* For saturating multiplication, there's exactly one special case
5830              to be handled: multiplying the smallest negative value with
5831              itself.  Due to shift correction in fractional multiplies, this
5832              can overflow.  Iff this happens, OP2 will contain 1, which, when
5833              added in 32 bits to the smallest negative, wraps to the largest
5834              positive, which is the result we want.  */
5835           op2 = gen_reg_rtx (V2HImode);
5836           emit_insn (gen_packv2hi (op2, tmp1, tmp2, const0_rtx, const0_rtx));
5837           emit_insn (gen_movsibi (gen_rtx_REG (BImode, REG_CC),
5838                                   gen_lowpart (SImode, op2)));
5839           emit_insn (gen_flag_mul_macv2hi_parts_acconly_andcc0 (a0reg, a1reg, tmp1, tmp2,
5840                                                                 const1_rtx, const1_rtx,
5841                                                                 const1_rtx, const0_rtx, a1reg,
5842                                                                 const0_rtx, GEN_INT (MACFLAG_NONE),
5843                                                                 GEN_INT (MACFLAG_M)));
5844           op2 = gen_reg_rtx (SImode);
5845           emit_insn (gen_movbisi (op2, gen_rtx_REG (BImode, REG_CC)));
5846         }
5847       emit_insn (gen_flag_machi_parts_acconly (a1reg, tmp2, tmp1,
5848                                                const1_rtx, const0_rtx,
5849                                                a1reg, const0_rtx, GEN_INT (MACFLAG_M)));
5850       emit_insn (gen_ashrpdi3 (a1reg, a1reg, GEN_INT (15)));
5851       emit_insn (gen_sum_of_accumulators (target, a0reg, a0reg, a1reg));
5852       if (fcode == BFIN_BUILTIN_MULT_1X32X32NS)
5853         emit_insn (gen_addsi3 (target, target, op2));
5854       return target;
5855
5856     case BFIN_BUILTIN_CPLX_MUL_16:
5857     case BFIN_BUILTIN_CPLX_MUL_16_S40:
5858       arg0 = CALL_EXPR_ARG (exp, 0);
5859       arg1 = CALL_EXPR_ARG (exp, 1);
5860       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5861       op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
5862       accvec = gen_reg_rtx (V2PDImode);
5863
5864       if (! target
5865           || GET_MODE (target) != V2HImode
5866           || ! (*insn_data[icode].operand[0].predicate) (target, V2HImode))
5867         target = gen_reg_rtx (tmode);
5868       if (! register_operand (op0, GET_MODE (op0)))
5869         op0 = copy_to_mode_reg (GET_MODE (op0), op0);
5870       if (! register_operand (op1, GET_MODE (op1)))
5871         op1 = copy_to_mode_reg (GET_MODE (op1), op1);
5872
5873       if (fcode == BFIN_BUILTIN_CPLX_MUL_16)
5874         emit_insn (gen_flag_macinit1v2hi_parts (accvec, op0, op1, const0_rtx,
5875                                                 const0_rtx, const0_rtx,
5876                                                 const1_rtx, GEN_INT (MACFLAG_W32)));
5877       else
5878         emit_insn (gen_flag_macinit1v2hi_parts (accvec, op0, op1, const0_rtx,
5879                                                 const0_rtx, const0_rtx,
5880                                                 const1_rtx, GEN_INT (MACFLAG_NONE)));
5881       emit_insn (gen_flag_macv2hi_parts (target, op0, op1, const1_rtx,
5882                                          const1_rtx, const1_rtx,
5883                                          const0_rtx, accvec, const1_rtx, const0_rtx,
5884                                          GEN_INT (MACFLAG_NONE), accvec));
5885
5886       return target;
5887
5888     case BFIN_BUILTIN_CPLX_MAC_16:
5889     case BFIN_BUILTIN_CPLX_MSU_16:
5890     case BFIN_BUILTIN_CPLX_MAC_16_S40:
5891     case BFIN_BUILTIN_CPLX_MSU_16_S40:
5892       arg0 = CALL_EXPR_ARG (exp, 0);
5893       arg1 = CALL_EXPR_ARG (exp, 1);
5894       arg2 = CALL_EXPR_ARG (exp, 2);
5895       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5896       op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
5897       op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
5898       accvec = gen_reg_rtx (V2PDImode);
5899
5900       if (! target
5901           || GET_MODE (target) != V2HImode
5902           || ! (*insn_data[icode].operand[0].predicate) (target, V2HImode))
5903         target = gen_reg_rtx (tmode);
5904       if (! register_operand (op1, GET_MODE (op1)))
5905         op1 = copy_to_mode_reg (GET_MODE (op1), op1);
5906       if (! register_operand (op2, GET_MODE (op2)))
5907         op2 = copy_to_mode_reg (GET_MODE (op2), op2);
5908
5909       tmp1 = gen_reg_rtx (SImode);
5910       tmp2 = gen_reg_rtx (SImode);
5911       emit_insn (gen_ashlsi3 (tmp1, gen_lowpart (SImode, op0), GEN_INT (16)));
5912       emit_move_insn (tmp2, gen_lowpart (SImode, op0));
5913       emit_insn (gen_movstricthi_1 (gen_lowpart (HImode, tmp2), const0_rtx));
5914       emit_insn (gen_load_accumulator_pair (accvec, tmp1, tmp2));
5915       if (fcode == BFIN_BUILTIN_CPLX_MAC_16
5916           || fcode == BFIN_BUILTIN_CPLX_MSU_16)
5917         emit_insn (gen_flag_macv2hi_parts_acconly (accvec, op1, op2, const0_rtx,
5918                                                    const0_rtx, const0_rtx,
5919                                                    const1_rtx, accvec, const0_rtx,
5920                                                    const0_rtx,
5921                                                    GEN_INT (MACFLAG_W32)));
5922       else
5923         emit_insn (gen_flag_macv2hi_parts_acconly (accvec, op1, op2, const0_rtx,
5924                                                    const0_rtx, const0_rtx,
5925                                                    const1_rtx, accvec, const0_rtx,
5926                                                    const0_rtx,
5927                                                    GEN_INT (MACFLAG_NONE)));
5928       if (fcode == BFIN_BUILTIN_CPLX_MAC_16
5929           || fcode == BFIN_BUILTIN_CPLX_MAC_16_S40)
5930         {
5931           tmp1 = const1_rtx;
5932           tmp2 = const0_rtx;
5933         }
5934       else
5935         {
5936           tmp1 = const0_rtx;
5937           tmp2 = const1_rtx;
5938         }
5939       emit_insn (gen_flag_macv2hi_parts (target, op1, op2, const1_rtx,
5940                                          const1_rtx, const1_rtx,
5941                                          const0_rtx, accvec, tmp1, tmp2,
5942                                          GEN_INT (MACFLAG_NONE), accvec));
5943
5944       return target;
5945
5946     case BFIN_BUILTIN_CPLX_SQU:
5947       arg0 = CALL_EXPR_ARG (exp, 0);
5948       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5949       accvec = gen_reg_rtx (V2PDImode);
5950       icode = CODE_FOR_flag_mulv2hi;
5951       tmp1 = gen_reg_rtx (V2HImode);
5952       tmp2 = gen_reg_rtx (V2HImode);
5953
5954       if (! target
5955           || GET_MODE (target) != V2HImode
5956           || ! (*insn_data[icode].operand[0].predicate) (target, V2HImode))
5957         target = gen_reg_rtx (V2HImode);
5958       if (! register_operand (op0, GET_MODE (op0)))
5959         op0 = copy_to_mode_reg (GET_MODE (op0), op0);
5960
5961       emit_insn (gen_flag_mulv2hi (tmp1, op0, op0, GEN_INT (MACFLAG_NONE)));
5962
5963       emit_insn (gen_flag_mulhi_parts (tmp2, op0, op0, const0_rtx,
5964                                        const0_rtx, const1_rtx,
5965                                        GEN_INT (MACFLAG_NONE)));
5966
5967       emit_insn (gen_ssaddhi3_parts (target, tmp2, tmp2, const1_rtx,
5968                                           const0_rtx, const0_rtx));
5969
5970       emit_insn (gen_sssubhi3_parts (target, tmp1, tmp1, const0_rtx,
5971                                           const0_rtx, const1_rtx));
5972
5973       return target;
5974
5975     default:
5976       break;
5977     }
5978
5979   for (i = 0, d = bdesc_2arg; i < ARRAY_SIZE (bdesc_2arg); i++, d++)
5980     if (d->code == fcode)
5981       return bfin_expand_binop_builtin (d->icode, exp, target,
5982                                         d->macflag);
5983
5984   for (i = 0, d = bdesc_1arg; i < ARRAY_SIZE (bdesc_1arg); i++, d++)
5985     if (d->code == fcode)
5986       return bfin_expand_unop_builtin (d->icode, exp, target);
5987
5988   gcc_unreachable ();
5989 }
5990 \f
5991 #undef TARGET_INIT_BUILTINS
5992 #define TARGET_INIT_BUILTINS bfin_init_builtins
5993
5994 #undef TARGET_EXPAND_BUILTIN
5995 #define TARGET_EXPAND_BUILTIN bfin_expand_builtin
5996
5997 #undef TARGET_ASM_GLOBALIZE_LABEL
5998 #define TARGET_ASM_GLOBALIZE_LABEL bfin_globalize_label
5999
6000 #undef TARGET_ASM_FILE_START
6001 #define TARGET_ASM_FILE_START output_file_start
6002
6003 #undef TARGET_ATTRIBUTE_TABLE
6004 #define TARGET_ATTRIBUTE_TABLE bfin_attribute_table
6005
6006 #undef TARGET_COMP_TYPE_ATTRIBUTES
6007 #define TARGET_COMP_TYPE_ATTRIBUTES bfin_comp_type_attributes
6008
6009 #undef TARGET_RTX_COSTS
6010 #define TARGET_RTX_COSTS bfin_rtx_costs
6011
6012 #undef  TARGET_ADDRESS_COST
6013 #define TARGET_ADDRESS_COST bfin_address_cost
6014
6015 #undef  TARGET_ASM_INTEGER
6016 #define TARGET_ASM_INTEGER bfin_assemble_integer
6017
6018 #undef TARGET_MACHINE_DEPENDENT_REORG
6019 #define TARGET_MACHINE_DEPENDENT_REORG bfin_reorg
6020
6021 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
6022 #define TARGET_FUNCTION_OK_FOR_SIBCALL bfin_function_ok_for_sibcall
6023
6024 #undef TARGET_ASM_OUTPUT_MI_THUNK
6025 #define TARGET_ASM_OUTPUT_MI_THUNK bfin_output_mi_thunk
6026 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
6027 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
6028
6029 #undef TARGET_SCHED_ADJUST_COST
6030 #define TARGET_SCHED_ADJUST_COST bfin_adjust_cost
6031
6032 #undef TARGET_SCHED_ISSUE_RATE
6033 #define TARGET_SCHED_ISSUE_RATE bfin_issue_rate
6034
6035 #undef TARGET_PROMOTE_PROTOTYPES
6036 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
6037 #undef TARGET_PROMOTE_FUNCTION_ARGS
6038 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_const_tree_true
6039 #undef TARGET_PROMOTE_FUNCTION_RETURN
6040 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_const_tree_true
6041
6042 #undef TARGET_ARG_PARTIAL_BYTES
6043 #define TARGET_ARG_PARTIAL_BYTES bfin_arg_partial_bytes
6044
6045 #undef TARGET_PASS_BY_REFERENCE
6046 #define TARGET_PASS_BY_REFERENCE bfin_pass_by_reference
6047
6048 #undef TARGET_SETUP_INCOMING_VARARGS
6049 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
6050
6051 #undef TARGET_STRUCT_VALUE_RTX
6052 #define TARGET_STRUCT_VALUE_RTX bfin_struct_value_rtx
6053
6054 #undef TARGET_VECTOR_MODE_SUPPORTED_P
6055 #define TARGET_VECTOR_MODE_SUPPORTED_P bfin_vector_mode_supported_p
6056
6057 #undef TARGET_HANDLE_OPTION
6058 #define TARGET_HANDLE_OPTION bfin_handle_option
6059
6060 #undef TARGET_DEFAULT_TARGET_FLAGS
6061 #define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
6062
6063 #undef TARGET_SECONDARY_RELOAD
6064 #define TARGET_SECONDARY_RELOAD bfin_secondary_reload
6065
6066 #undef TARGET_DELEGITIMIZE_ADDRESS
6067 #define TARGET_DELEGITIMIZE_ADDRESS bfin_delegitimize_address
6068
6069 #undef TARGET_CANNOT_FORCE_CONST_MEM
6070 #define TARGET_CANNOT_FORCE_CONST_MEM bfin_cannot_force_const_mem
6071
6072 #undef TARGET_RETURN_IN_MEMORY
6073 #define TARGET_RETURN_IN_MEMORY bfin_return_in_memory
6074
6075 struct gcc_target targetm = TARGET_INITIALIZER;