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
3104 int
3105 push_multiple_operation (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3106 {
3107   int lastdreg = 8, lastpreg = 6;
3108   int i, group;
3109
3110   first_preg_to_save = lastpreg;
3111   first_dreg_to_save = lastdreg;
3112   for (i = 1, group = 0; i < XVECLEN (op, 0) - 1; i++)
3113     {
3114       rtx t = XVECEXP (op, 0, i);
3115       rtx src, dest;
3116       int regno;
3117
3118       if (GET_CODE (t) != SET)
3119         return 0;
3120
3121       src = SET_SRC (t);
3122       dest = SET_DEST (t);
3123       if (GET_CODE (dest) != MEM || ! REG_P (src))
3124         return 0;
3125       dest = XEXP (dest, 0);
3126       if (GET_CODE (dest) != PLUS
3127           || ! REG_P (XEXP (dest, 0))
3128           || REGNO (XEXP (dest, 0)) != REG_SP
3129           || GET_CODE (XEXP (dest, 1)) != CONST_INT
3130           || INTVAL (XEXP (dest, 1)) != -i * 4)
3131         return 0;
3132
3133       regno = REGNO (src);
3134       if (group == 0)
3135         {
3136           if (D_REGNO_P (regno))
3137             {
3138               group = 1;
3139               first_dreg_to_save = lastdreg = regno - REG_R0;
3140             }
3141           else if (regno >= REG_P0 && regno <= REG_P7)
3142             {
3143               group = 2;
3144               first_preg_to_save = lastpreg = regno - REG_P0;
3145             }
3146           else
3147             return 0;
3148
3149           continue;
3150         }
3151
3152       if (group == 1)
3153         {
3154           if (regno >= REG_P0 && regno <= REG_P7)
3155             {
3156               group = 2;
3157               first_preg_to_save = lastpreg = regno - REG_P0;
3158             }
3159           else if (regno != REG_R0 + lastdreg + 1)
3160             return 0;
3161           else
3162             lastdreg++;
3163         }
3164       else if (group == 2)
3165         {
3166           if (regno != REG_P0 + lastpreg + 1)
3167             return 0;
3168           lastpreg++;
3169         }
3170     }
3171   return 1;
3172 }
3173
3174 int
3175 pop_multiple_operation (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
3176 {
3177   int lastdreg = 8, lastpreg = 6;
3178   int i, group;
3179
3180   for (i = 1, group = 0; i < XVECLEN (op, 0); i++)
3181     {
3182       rtx t = XVECEXP (op, 0, i);
3183       rtx src, dest;
3184       int regno;
3185
3186       if (GET_CODE (t) != SET)
3187         return 0;
3188
3189       src = SET_SRC (t);
3190       dest = SET_DEST (t);
3191       if (GET_CODE (src) != MEM || ! REG_P (dest))
3192         return 0;
3193       src = XEXP (src, 0);
3194
3195       if (i == 1)
3196         {
3197           if (! REG_P (src) || REGNO (src) != REG_SP)
3198             return 0;
3199         }
3200       else if (GET_CODE (src) != PLUS
3201                || ! REG_P (XEXP (src, 0))
3202                || REGNO (XEXP (src, 0)) != REG_SP
3203                || GET_CODE (XEXP (src, 1)) != CONST_INT
3204                || INTVAL (XEXP (src, 1)) != (i - 1) * 4)
3205         return 0;
3206
3207       regno = REGNO (dest);
3208       if (group == 0)
3209         {
3210           if (regno == REG_R7)
3211             {
3212               group = 1;
3213               lastdreg = 7;
3214             }
3215           else if (regno != REG_P0 + lastpreg - 1)
3216             return 0;
3217           else
3218             lastpreg--;
3219         }
3220       else if (group == 1)
3221         {
3222           if (regno != REG_R0 + lastdreg - 1)
3223             return 0;
3224           else
3225             lastdreg--;
3226         }
3227     }
3228   first_dreg_to_save = lastdreg;
3229   first_preg_to_save = lastpreg;
3230   return 1;
3231 }
3232
3233 /* Emit assembly code for one multi-register push described by INSN, with
3234    operands in OPERANDS.  */
3235
3236 void
3237 output_push_multiple (rtx insn, rtx *operands)
3238 {
3239   char buf[80];
3240   int ok;
3241
3242   /* Validate the insn again, and compute first_[dp]reg_to_save. */
3243   ok = push_multiple_operation (PATTERN (insn), VOIDmode);
3244   gcc_assert (ok);
3245
3246   if (first_dreg_to_save == 8)
3247     sprintf (buf, "[--sp] = ( p5:%d );\n", first_preg_to_save);
3248   else if (first_preg_to_save == 6)
3249     sprintf (buf, "[--sp] = ( r7:%d );\n", first_dreg_to_save);
3250   else
3251     sprintf (buf, "[--sp] = ( r7:%d, p5:%d );\n",
3252              first_dreg_to_save, first_preg_to_save);
3253
3254   output_asm_insn (buf, operands);
3255 }
3256
3257 /* Emit assembly code for one multi-register pop described by INSN, with
3258    operands in OPERANDS.  */
3259
3260 void
3261 output_pop_multiple (rtx insn, rtx *operands)
3262 {
3263   char buf[80];
3264   int ok;
3265
3266   /* Validate the insn again, and compute first_[dp]reg_to_save. */
3267   ok = pop_multiple_operation (PATTERN (insn), VOIDmode);
3268   gcc_assert (ok);
3269
3270   if (first_dreg_to_save == 8)
3271     sprintf (buf, "( p5:%d ) = [sp++];\n", first_preg_to_save);
3272   else if (first_preg_to_save == 6)
3273     sprintf (buf, "( r7:%d ) = [sp++];\n", first_dreg_to_save);
3274   else
3275     sprintf (buf, "( r7:%d, p5:%d ) = [sp++];\n",
3276              first_dreg_to_save, first_preg_to_save);
3277
3278   output_asm_insn (buf, operands);
3279 }
3280
3281 /* Adjust DST and SRC by OFFSET bytes, and generate one move in mode MODE.  */
3282
3283 static void
3284 single_move_for_movmem (rtx dst, rtx src, enum machine_mode mode, HOST_WIDE_INT offset)
3285 {
3286   rtx scratch = gen_reg_rtx (mode);
3287   rtx srcmem, dstmem;
3288
3289   srcmem = adjust_address_nv (src, mode, offset);
3290   dstmem = adjust_address_nv (dst, mode, offset);
3291   emit_move_insn (scratch, srcmem);
3292   emit_move_insn (dstmem, scratch);
3293 }
3294
3295 /* Expand a string move operation of COUNT_EXP bytes from SRC to DST, with
3296    alignment ALIGN_EXP.  Return true if successful, false if we should fall
3297    back on a different method.  */
3298
3299 bool
3300 bfin_expand_movmem (rtx dst, rtx src, rtx count_exp, rtx align_exp)
3301 {
3302   rtx srcreg, destreg, countreg;
3303   HOST_WIDE_INT align = 0;
3304   unsigned HOST_WIDE_INT count = 0;
3305
3306   if (GET_CODE (align_exp) == CONST_INT)
3307     align = INTVAL (align_exp);
3308   if (GET_CODE (count_exp) == CONST_INT)
3309     {
3310       count = INTVAL (count_exp);
3311 #if 0
3312       if (!TARGET_INLINE_ALL_STRINGOPS && count > 64)
3313         return false;
3314 #endif
3315     }
3316
3317   /* If optimizing for size, only do single copies inline.  */
3318   if (optimize_size)
3319     {
3320       if (count == 2 && align < 2)
3321         return false;
3322       if (count == 4 && align < 4)
3323         return false;
3324       if (count != 1 && count != 2 && count != 4)
3325         return false;
3326     }
3327   if (align < 2 && count != 1)
3328     return false;
3329
3330   destreg = copy_to_mode_reg (Pmode, XEXP (dst, 0));
3331   if (destreg != XEXP (dst, 0))
3332     dst = replace_equiv_address_nv (dst, destreg);
3333   srcreg = copy_to_mode_reg (Pmode, XEXP (src, 0));
3334   if (srcreg != XEXP (src, 0))
3335     src = replace_equiv_address_nv (src, srcreg);
3336
3337   if (count != 0 && align >= 2)
3338     {
3339       unsigned HOST_WIDE_INT offset = 0;
3340
3341       if (align >= 4)
3342         {
3343           if ((count & ~3) == 4)
3344             {
3345               single_move_for_movmem (dst, src, SImode, offset);
3346               offset = 4;
3347             }
3348           else if (count & ~3)
3349             {
3350               HOST_WIDE_INT new_count = ((count >> 2) & 0x3fffffff) - 1;
3351               countreg = copy_to_mode_reg (Pmode, GEN_INT (new_count));
3352
3353               emit_insn (gen_rep_movsi (destreg, srcreg, countreg, destreg, srcreg));
3354             }
3355           if (count & 2)
3356             {
3357               single_move_for_movmem (dst, src, HImode, offset);
3358               offset += 2;
3359             }
3360         }
3361       else
3362         {
3363           if ((count & ~1) == 2)
3364             {
3365               single_move_for_movmem (dst, src, HImode, offset);
3366               offset = 2;
3367             }
3368           else if (count & ~1)
3369             {
3370               HOST_WIDE_INT new_count = ((count >> 1) & 0x7fffffff) - 1;
3371               countreg = copy_to_mode_reg (Pmode, GEN_INT (new_count));
3372
3373               emit_insn (gen_rep_movhi (destreg, srcreg, countreg, destreg, srcreg));
3374             }
3375         }
3376       if (count & 1)
3377         {
3378           single_move_for_movmem (dst, src, QImode, offset);
3379         }
3380       return true;
3381     }
3382   return false;
3383 }
3384 \f
3385 /* Compute the alignment for a local variable.
3386    TYPE is the data type, and ALIGN is the alignment that
3387    the object would ordinarily have.  The value of this macro is used
3388    instead of that alignment to align the object.  */
3389
3390 int
3391 bfin_local_alignment (tree type, int align)
3392 {
3393   /* Increasing alignment for (relatively) big types allows the builtin
3394      memcpy can use 32 bit loads/stores.  */
3395   if (TYPE_SIZE (type)
3396       && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
3397       && (TREE_INT_CST_LOW (TYPE_SIZE (type)) > 8
3398           || TREE_INT_CST_HIGH (TYPE_SIZE (type))) && align < 32)
3399     return 32;
3400   return align;
3401 }
3402 \f
3403 /* Implement TARGET_SCHED_ISSUE_RATE.  */
3404
3405 static int
3406 bfin_issue_rate (void)
3407 {
3408   return 3;
3409 }
3410
3411 static int
3412 bfin_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
3413 {
3414   enum attr_type insn_type, dep_insn_type;
3415   int dep_insn_code_number;
3416
3417   /* Anti and output dependencies have zero cost.  */
3418   if (REG_NOTE_KIND (link) != 0)
3419     return 0;
3420
3421   dep_insn_code_number = recog_memoized (dep_insn);
3422
3423   /* If we can't recognize the insns, we can't really do anything.  */
3424   if (dep_insn_code_number < 0 || recog_memoized (insn) < 0)
3425     return cost;
3426
3427   insn_type = get_attr_type (insn);
3428   dep_insn_type = get_attr_type (dep_insn);
3429
3430   if (dep_insn_type == TYPE_MOVE || dep_insn_type == TYPE_MCLD)
3431     {
3432       rtx pat = PATTERN (dep_insn);
3433       if (GET_CODE (pat) == PARALLEL)
3434         pat = XVECEXP (pat, 0, 0);
3435       rtx dest = SET_DEST (pat);
3436       rtx src = SET_SRC (pat);
3437       if (! ADDRESS_REGNO_P (REGNO (dest))
3438           || ! (MEM_P (src) || D_REGNO_P (REGNO (src))))
3439         return cost;
3440       return cost + (dep_insn_type == TYPE_MOVE ? 4 : 3);
3441     }
3442
3443   return cost;
3444 }
3445
3446 \f
3447 /* Increment the counter for the number of loop instructions in the
3448    current function.  */
3449
3450 void
3451 bfin_hardware_loop (void)
3452 {
3453   cfun->machine->has_hardware_loops++;
3454 }
3455
3456 /* Maximum loop nesting depth.  */
3457 #define MAX_LOOP_DEPTH 2
3458
3459 /* Maximum size of a loop.  */
3460 #define MAX_LOOP_LENGTH 2042
3461
3462 /* Maximum distance of the LSETUP instruction from the loop start.  */
3463 #define MAX_LSETUP_DISTANCE 30
3464
3465 /* We need to keep a vector of loops */
3466 typedef struct loop_info *loop_info;
3467 DEF_VEC_P (loop_info);
3468 DEF_VEC_ALLOC_P (loop_info,heap);
3469
3470 /* Information about a loop we have found (or are in the process of
3471    finding).  */
3472 struct loop_info GTY (())
3473 {
3474   /* loop number, for dumps */
3475   int loop_no;
3476
3477   /* All edges that jump into and out of the loop.  */
3478   VEC(edge,gc) *incoming;
3479
3480   /* We can handle two cases: all incoming edges have the same destination
3481      block, or all incoming edges have the same source block.  These two
3482      members are set to the common source or destination we found, or NULL
3483      if different blocks were found.  If both are NULL the loop can't be
3484      optimized.  */
3485   basic_block incoming_src;
3486   basic_block incoming_dest;
3487
3488   /* First block in the loop.  This is the one branched to by the loop_end
3489      insn.  */
3490   basic_block head;
3491
3492   /* Last block in the loop (the one with the loop_end insn).  */
3493   basic_block tail;
3494
3495   /* The successor block of the loop.  This is the one the loop_end insn
3496      falls into.  */
3497   basic_block successor;
3498
3499   /* The last instruction in the tail.  */
3500   rtx last_insn;
3501
3502   /* The loop_end insn.  */
3503   rtx loop_end;
3504
3505   /* The iteration register.  */
3506   rtx iter_reg;
3507
3508   /* The new initialization insn.  */
3509   rtx init;
3510
3511   /* The new initialization instruction.  */
3512   rtx loop_init;
3513
3514   /* The new label placed at the beginning of the loop. */
3515   rtx start_label;
3516
3517   /* The new label placed at the end of the loop. */
3518   rtx end_label;
3519
3520   /* The length of the loop.  */
3521   int length;
3522
3523   /* The nesting depth of the loop.  */
3524   int depth;
3525
3526   /* Nonzero if we can't optimize this loop.  */
3527   int bad;
3528
3529   /* True if we have visited this loop.  */
3530   int visited;
3531
3532   /* True if this loop body clobbers any of LC0, LT0, or LB0.  */
3533   int clobber_loop0;
3534
3535   /* True if this loop body clobbers any of LC1, LT1, or LB1.  */
3536   int clobber_loop1;
3537
3538   /* Next loop in the graph. */
3539   struct loop_info *next;
3540
3541   /* Immediate outer loop of this loop.  */
3542   struct loop_info *outer;
3543
3544   /* Vector of blocks only within the loop, including those within
3545      inner loops.  */
3546   VEC (basic_block,heap) *blocks;
3547
3548   /* Same information in a bitmap.  */
3549   bitmap block_bitmap;
3550
3551   /* Vector of inner loops within this loop  */
3552   VEC (loop_info,heap) *loops;
3553 };
3554
3555 static void
3556 bfin_dump_loops (loop_info loops)
3557 {
3558   loop_info loop;
3559
3560   for (loop = loops; loop; loop = loop->next)
3561     {
3562       loop_info i;
3563       basic_block b;
3564       unsigned ix;
3565
3566       fprintf (dump_file, ";; loop %d: ", loop->loop_no);
3567       if (loop->bad)
3568         fprintf (dump_file, "(bad) ");
3569       fprintf (dump_file, "{head:%d, depth:%d}", loop->head->index, loop->depth);
3570
3571       fprintf (dump_file, " blocks: [ ");
3572       for (ix = 0; VEC_iterate (basic_block, loop->blocks, ix, b); ix++)
3573         fprintf (dump_file, "%d ", b->index);
3574       fprintf (dump_file, "] ");
3575
3576       fprintf (dump_file, " inner loops: [ ");
3577       for (ix = 0; VEC_iterate (loop_info, loop->loops, ix, i); ix++)
3578         fprintf (dump_file, "%d ", i->loop_no);
3579       fprintf (dump_file, "]\n");
3580     }
3581   fprintf (dump_file, "\n");
3582 }
3583
3584 /* Scan the blocks of LOOP (and its inferiors) looking for basic block
3585    BB. Return true, if we find it.  */
3586
3587 static bool
3588 bfin_bb_in_loop (loop_info loop, basic_block bb)
3589 {
3590   return bitmap_bit_p (loop->block_bitmap, bb->index);
3591 }
3592
3593 /* Scan the blocks of LOOP (and its inferiors) looking for uses of
3594    REG.  Return true, if we find any.  Don't count the loop's loop_end
3595    insn if it matches LOOP_END.  */
3596
3597 static bool
3598 bfin_scan_loop (loop_info loop, rtx reg, rtx loop_end)
3599 {
3600   unsigned ix;
3601   basic_block bb;
3602
3603   for (ix = 0; VEC_iterate (basic_block, loop->blocks, ix, bb); ix++)
3604     {
3605       rtx insn;
3606
3607       for (insn = BB_HEAD (bb);
3608            insn != NEXT_INSN (BB_END (bb));
3609            insn = NEXT_INSN (insn))
3610         {
3611           if (!INSN_P (insn))
3612             continue;
3613           if (insn == loop_end)
3614             continue;
3615           if (reg_mentioned_p (reg, PATTERN (insn)))
3616             return true;
3617         }
3618     }
3619   return false;
3620 }
3621
3622 /* Estimate the length of INSN conservatively.  */
3623
3624 static int
3625 length_for_loop (rtx insn)
3626 {
3627   int length = 0;
3628   if (JUMP_P (insn) && any_condjump_p (insn) && !optimize_size)
3629     {
3630       if (ENABLE_WA_SPECULATIVE_SYNCS)
3631         length = 8;
3632       else if (ENABLE_WA_SPECULATIVE_LOADS)
3633         length = 6;
3634     }
3635   else if (LABEL_P (insn))
3636     {
3637       if (ENABLE_WA_SPECULATIVE_SYNCS)
3638         length = 4;
3639     }
3640
3641   if (INSN_P (insn))
3642     length += get_attr_length (insn);
3643
3644   return length;
3645 }
3646
3647 /* Optimize LOOP.  */
3648
3649 static void
3650 bfin_optimize_loop (loop_info loop)
3651 {
3652   basic_block bb;
3653   loop_info inner;
3654   rtx insn, init_insn, last_insn, nop_insn;
3655   rtx loop_init, start_label, end_label;
3656   rtx reg_lc0, reg_lc1, reg_lt0, reg_lt1, reg_lb0, reg_lb1;
3657   rtx iter_reg;
3658   rtx lc_reg, lt_reg, lb_reg;
3659   rtx seq, seq_end;
3660   int length;
3661   unsigned ix;
3662   int inner_depth = 0;
3663
3664   if (loop->visited)
3665     return;
3666
3667   loop->visited = 1;
3668
3669   if (loop->bad)
3670     {
3671       if (dump_file)
3672         fprintf (dump_file, ";; loop %d bad when found\n", loop->loop_no);
3673       goto bad_loop;
3674     }
3675
3676   /* Every loop contains in its list of inner loops every loop nested inside
3677      it, even if there are intermediate loops.  This works because we're doing
3678      a depth-first search here and never visit a loop more than once.  */
3679   for (ix = 0; VEC_iterate (loop_info, loop->loops, ix, inner); ix++)
3680     {
3681       bfin_optimize_loop (inner);
3682
3683       if (!inner->bad && inner_depth < inner->depth)
3684         {
3685           inner_depth = inner->depth;
3686
3687           loop->clobber_loop0 |= inner->clobber_loop0;
3688           loop->clobber_loop1 |= inner->clobber_loop1;
3689         }
3690     }
3691
3692   loop->depth = inner_depth + 1;
3693   if (loop->depth > MAX_LOOP_DEPTH)
3694     {
3695       if (dump_file)
3696         fprintf (dump_file, ";; loop %d too deep\n", loop->loop_no);
3697       goto bad_loop;
3698     }
3699
3700   /* Get the loop iteration register.  */
3701   iter_reg = loop->iter_reg;
3702
3703   if (!DPREG_P (iter_reg))
3704     {
3705       if (dump_file)
3706         fprintf (dump_file, ";; loop %d iteration count NOT in PREG or DREG\n",
3707                  loop->loop_no);
3708       goto bad_loop;
3709     }
3710
3711   if (loop->incoming_src)
3712     {
3713       /* Make sure the predecessor is before the loop start label, as required by
3714          the LSETUP instruction.  */
3715       length = 0;
3716       for (insn = BB_END (loop->incoming_src);
3717            insn && insn != loop->start_label;
3718            insn = NEXT_INSN (insn))
3719         length += length_for_loop (insn);
3720
3721       if (!insn)
3722         {
3723           if (dump_file)
3724             fprintf (dump_file, ";; loop %d lsetup not before loop_start\n",
3725                      loop->loop_no);
3726           goto bad_loop;
3727         }
3728
3729       if (length > MAX_LSETUP_DISTANCE)
3730         {
3731           if (dump_file)
3732             fprintf (dump_file, ";; loop %d lsetup too far away\n", loop->loop_no);
3733           goto bad_loop;
3734         }
3735     }
3736
3737   /* Check if start_label appears before loop_end and calculate the
3738      offset between them.  We calculate the length of instructions
3739      conservatively.  */
3740   length = 0;
3741   for (insn = loop->start_label;
3742        insn && insn != loop->loop_end;
3743        insn = NEXT_INSN (insn))
3744     length += length_for_loop (insn);
3745
3746   if (!insn)
3747     {
3748       if (dump_file)
3749         fprintf (dump_file, ";; loop %d start_label not before loop_end\n",
3750                  loop->loop_no);
3751       goto bad_loop;
3752     }
3753
3754   loop->length = length;
3755   if (loop->length > MAX_LOOP_LENGTH)
3756     {
3757       if (dump_file)
3758         fprintf (dump_file, ";; loop %d too long\n", loop->loop_no);
3759       goto bad_loop;
3760     }
3761
3762   /* Scan all the blocks to make sure they don't use iter_reg.  */
3763   if (bfin_scan_loop (loop, iter_reg, loop->loop_end))
3764     {
3765       if (dump_file)
3766         fprintf (dump_file, ";; loop %d uses iterator\n", loop->loop_no);
3767       goto bad_loop;
3768     }
3769
3770   /* Scan all the insns to see if the loop body clobber
3771      any hardware loop registers. */
3772
3773   reg_lc0 = gen_rtx_REG (SImode, REG_LC0);
3774   reg_lc1 = gen_rtx_REG (SImode, REG_LC1);
3775   reg_lt0 = gen_rtx_REG (SImode, REG_LT0);
3776   reg_lt1 = gen_rtx_REG (SImode, REG_LT1);
3777   reg_lb0 = gen_rtx_REG (SImode, REG_LB0);
3778   reg_lb1 = gen_rtx_REG (SImode, REG_LB1);
3779
3780   for (ix = 0; VEC_iterate (basic_block, loop->blocks, ix, bb); ix++)
3781     {
3782       rtx insn;
3783
3784       for (insn = BB_HEAD (bb);
3785            insn != NEXT_INSN (BB_END (bb));
3786            insn = NEXT_INSN (insn))
3787         {
3788           if (!INSN_P (insn))
3789             continue;
3790
3791           if (reg_set_p (reg_lc0, insn)
3792               || reg_set_p (reg_lt0, insn)
3793               || reg_set_p (reg_lb0, insn))
3794             loop->clobber_loop0 = 1;
3795
3796           if (reg_set_p (reg_lc1, insn)
3797               || reg_set_p (reg_lt1, insn)
3798               || reg_set_p (reg_lb1, insn))
3799             loop->clobber_loop1 |= 1;
3800         }
3801     }
3802
3803   if ((loop->clobber_loop0 && loop->clobber_loop1)
3804       || (loop->depth == MAX_LOOP_DEPTH && loop->clobber_loop0))
3805     {
3806       loop->depth = MAX_LOOP_DEPTH + 1;
3807       if (dump_file)
3808         fprintf (dump_file, ";; loop %d no loop reg available\n",
3809                  loop->loop_no);
3810       goto bad_loop;
3811     }
3812
3813   /* There should be an instruction before the loop_end instruction
3814      in the same basic block. And the instruction must not be
3815      - JUMP
3816      - CONDITIONAL BRANCH
3817      - CALL
3818      - CSYNC
3819      - SSYNC
3820      - Returns (RTS, RTN, etc.)  */
3821
3822   bb = loop->tail;
3823   last_insn = PREV_INSN (loop->loop_end);
3824
3825   while (1)
3826     {
3827       for (; last_insn != PREV_INSN (BB_HEAD (bb));
3828            last_insn = PREV_INSN (last_insn))
3829         if (INSN_P (last_insn))
3830           break;
3831
3832       if (last_insn != PREV_INSN (BB_HEAD (bb)))
3833         break;
3834
3835       if (single_pred_p (bb)
3836           && single_pred (bb) != ENTRY_BLOCK_PTR)
3837         {
3838           bb = single_pred (bb);
3839           last_insn = BB_END (bb);
3840           continue;
3841         }
3842       else
3843         {
3844           last_insn = NULL_RTX;
3845           break;
3846         }
3847     }
3848
3849   if (!last_insn)
3850     {
3851       if (dump_file)
3852         fprintf (dump_file, ";; loop %d has no last instruction\n",
3853                  loop->loop_no);
3854       goto bad_loop;
3855     }
3856
3857   if (JUMP_P (last_insn))
3858     {
3859       loop_info inner = (loop_info) bb->aux;
3860       if (inner
3861           && inner->outer == loop
3862           && inner->loop_end == last_insn
3863           && inner->depth == 1)
3864         /* This jump_insn is the exact loop_end of an inner loop
3865            and to be optimized away. So use the inner's last_insn.  */
3866         last_insn = inner->last_insn;
3867       else
3868         {
3869           if (dump_file)
3870             fprintf (dump_file, ";; loop %d has bad last instruction\n",
3871                      loop->loop_no);
3872           goto bad_loop;
3873         }
3874     }
3875   else if (CALL_P (last_insn)
3876            || (GET_CODE (PATTERN (last_insn)) != SEQUENCE
3877                && get_attr_type (last_insn) == TYPE_SYNC)
3878            || recog_memoized (last_insn) == CODE_FOR_return_internal)
3879     {
3880       if (dump_file)
3881         fprintf (dump_file, ";; loop %d has bad last instruction\n",
3882                  loop->loop_no);
3883       goto bad_loop;
3884     }
3885
3886   if (GET_CODE (PATTERN (last_insn)) == ASM_INPUT
3887       || asm_noperands (PATTERN (last_insn)) >= 0
3888       || (GET_CODE (PATTERN (last_insn)) != SEQUENCE
3889           && get_attr_seq_insns (last_insn) == SEQ_INSNS_MULTI))
3890     {
3891       nop_insn = emit_insn_after (gen_nop (), last_insn);
3892       last_insn = nop_insn;
3893     }
3894
3895   loop->last_insn = last_insn;
3896
3897   /* The loop is good for replacement.  */
3898   start_label = loop->start_label;
3899   end_label = gen_label_rtx ();
3900   iter_reg = loop->iter_reg;
3901
3902   if (loop->depth == 1 && !loop->clobber_loop1)
3903     {
3904       lc_reg = reg_lc1;
3905       lt_reg = reg_lt1;
3906       lb_reg = reg_lb1;
3907       loop->clobber_loop1 = 1;
3908     }
3909   else
3910     {
3911       lc_reg = reg_lc0;
3912       lt_reg = reg_lt0;
3913       lb_reg = reg_lb0;
3914       loop->clobber_loop0 = 1;
3915     }
3916
3917   /* If iter_reg is a DREG, we need generate an instruction to load
3918      the loop count into LC register. */
3919   if (D_REGNO_P (REGNO (iter_reg)))
3920     {
3921       init_insn = gen_movsi (lc_reg, iter_reg);
3922       loop_init = gen_lsetup_without_autoinit (lt_reg, start_label,
3923                                                lb_reg, end_label,
3924                                                lc_reg);
3925     }
3926   else if (P_REGNO_P (REGNO (iter_reg)))
3927     {
3928       init_insn = NULL_RTX;
3929       loop_init = gen_lsetup_with_autoinit (lt_reg, start_label,
3930                                             lb_reg, end_label,
3931                                             lc_reg, iter_reg);
3932     }
3933   else
3934     gcc_unreachable ();
3935
3936   loop->init = init_insn;
3937   loop->end_label = end_label;
3938   loop->loop_init = loop_init;
3939
3940   if (dump_file)
3941     {
3942       fprintf (dump_file, ";; replacing loop %d initializer with\n",
3943                loop->loop_no);
3944       print_rtl_single (dump_file, loop->loop_init);
3945       fprintf (dump_file, ";; replacing loop %d terminator with\n",
3946                loop->loop_no);
3947       print_rtl_single (dump_file, loop->loop_end);
3948     }
3949
3950   start_sequence ();
3951
3952   if (loop->init != NULL_RTX)
3953     emit_insn (loop->init);
3954   seq_end = emit_insn (loop->loop_init);
3955
3956   seq = get_insns ();
3957   end_sequence ();
3958
3959   if (loop->incoming_src)
3960     {
3961       rtx prev = BB_END (loop->incoming_src);
3962       if (VEC_length (edge, loop->incoming) > 1
3963           || !(VEC_last (edge, loop->incoming)->flags & EDGE_FALLTHRU))
3964         {
3965           gcc_assert (JUMP_P (prev));
3966           prev = PREV_INSN (prev);
3967         }
3968       emit_insn_after (seq, prev);
3969     }
3970   else
3971     {
3972       basic_block new_bb;
3973       edge e;
3974       edge_iterator ei;
3975
3976       if (loop->head != loop->incoming_dest)
3977         {
3978           FOR_EACH_EDGE (e, ei, loop->head->preds)
3979             {
3980               if (e->flags & EDGE_FALLTHRU)
3981                 {
3982                   rtx newjump = gen_jump (loop->start_label);
3983                   emit_insn_before (newjump, BB_HEAD (loop->head));
3984                   new_bb = create_basic_block (newjump, newjump, loop->head->prev_bb);
3985                   gcc_assert (new_bb = loop->head->prev_bb);
3986                   break;
3987                 }
3988             }
3989         }
3990
3991       emit_insn_before (seq, BB_HEAD (loop->head));
3992       seq = emit_label_before (gen_label_rtx (), seq);
3993
3994       new_bb = create_basic_block (seq, seq_end, loop->head->prev_bb);
3995       FOR_EACH_EDGE (e, ei, loop->incoming)
3996         {
3997           if (!(e->flags & EDGE_FALLTHRU)
3998               || e->dest != loop->head)
3999             redirect_edge_and_branch_force (e, new_bb);
4000           else
4001             redirect_edge_succ (e, new_bb);
4002         }
4003     }
4004
4005   delete_insn (loop->loop_end);
4006   /* Insert the loop end label before the last instruction of the loop.  */
4007   emit_label_before (loop->end_label, loop->last_insn);
4008
4009   return;
4010
4011  bad_loop:
4012
4013   if (dump_file)
4014     fprintf (dump_file, ";; loop %d is bad\n", loop->loop_no);
4015
4016   loop->bad = 1;
4017
4018   if (DPREG_P (loop->iter_reg))
4019     {
4020       /* If loop->iter_reg is a DREG or PREG, we can split it here
4021          without scratch register.  */
4022       rtx insn;
4023
4024       emit_insn_before (gen_addsi3 (loop->iter_reg,
4025                                     loop->iter_reg,
4026                                     constm1_rtx),
4027                         loop->loop_end);
4028
4029       emit_insn_before (gen_cmpsi (loop->iter_reg, const0_rtx),
4030                         loop->loop_end);
4031
4032       insn = emit_jump_insn_before (gen_bne (loop->start_label),
4033                                     loop->loop_end);
4034
4035       JUMP_LABEL (insn) = loop->start_label;
4036       LABEL_NUSES (loop->start_label)++;
4037       delete_insn (loop->loop_end);
4038     }
4039 }
4040
4041 /* Called from bfin_reorg_loops when a potential loop end is found.  LOOP is
4042    a newly set up structure describing the loop, it is this function's
4043    responsibility to fill most of it.  TAIL_BB and TAIL_INSN point to the
4044    loop_end insn and its enclosing basic block.  */
4045
4046 static void
4047 bfin_discover_loop (loop_info loop, basic_block tail_bb, rtx tail_insn)
4048 {
4049   unsigned dwork = 0;
4050   basic_block bb;
4051   VEC (basic_block,heap) *works = VEC_alloc (basic_block,heap,20);
4052
4053   loop->tail = tail_bb;
4054   loop->head = BRANCH_EDGE (tail_bb)->dest;
4055   loop->successor = FALLTHRU_EDGE (tail_bb)->dest;
4056   loop->loop_end = tail_insn;
4057   loop->last_insn = NULL_RTX;
4058   loop->iter_reg = SET_DEST (XVECEXP (PATTERN (tail_insn), 0, 1));
4059   loop->depth = loop->length = 0;
4060   loop->visited = 0;
4061   loop->clobber_loop0 = loop->clobber_loop1 = 0;
4062   loop->outer = NULL;
4063   loop->loops = NULL;
4064   loop->incoming = VEC_alloc (edge, gc, 2);
4065   loop->init = loop->loop_init = NULL_RTX;
4066   loop->start_label = XEXP (XEXP (SET_SRC (XVECEXP (PATTERN (tail_insn), 0, 0)), 1), 0);
4067   loop->end_label = NULL_RTX;
4068   loop->bad = 0;
4069
4070   VEC_safe_push (basic_block, heap, works, loop->head);
4071
4072   while (VEC_iterate (basic_block, works, dwork++, bb))
4073     {
4074       edge e;
4075       edge_iterator ei;
4076       if (bb == EXIT_BLOCK_PTR)
4077         {
4078           /* We've reached the exit block.  The loop must be bad. */
4079           if (dump_file)
4080             fprintf (dump_file,
4081                      ";; Loop is bad - reached exit block while scanning\n");
4082           loop->bad = 1;
4083           break;
4084         }
4085
4086       if (bitmap_bit_p (loop->block_bitmap, bb->index))
4087         continue;
4088
4089       /* We've not seen this block before.  Add it to the loop's
4090          list and then add each successor to the work list.  */
4091
4092       VEC_safe_push (basic_block, heap, loop->blocks, bb);
4093       bitmap_set_bit (loop->block_bitmap, bb->index);
4094
4095       if (bb != tail_bb)
4096         {
4097           FOR_EACH_EDGE (e, ei, bb->succs)
4098             {
4099               basic_block succ = EDGE_SUCC (bb, ei.index)->dest;
4100               if (!REGNO_REG_SET_P (df_get_live_in (succ),
4101                                     REGNO (loop->iter_reg)))
4102                 continue;
4103               if (!VEC_space (basic_block, works, 1))
4104                 {
4105                   if (dwork)
4106                     {
4107                       VEC_block_remove (basic_block, works, 0, dwork);
4108                       dwork = 0;
4109                     }
4110                   else
4111                     VEC_reserve (basic_block, heap, works, 1);
4112                 }
4113               VEC_quick_push (basic_block, works, succ);
4114             }
4115         }
4116     }
4117
4118   /* Find the predecessor, and make sure nothing else jumps into this loop.  */
4119   if (!loop->bad)
4120     {
4121       int pass, retry;
4122       for (dwork = 0; VEC_iterate (basic_block, loop->blocks, dwork, bb); dwork++)
4123         {
4124           edge e;
4125           edge_iterator ei;
4126           FOR_EACH_EDGE (e, ei, bb->preds)
4127             {
4128               basic_block pred = e->src;
4129
4130               if (!bfin_bb_in_loop (loop, pred))
4131                 {
4132                   if (dump_file)
4133                     fprintf (dump_file, ";; Loop %d: incoming edge %d -> %d\n",
4134                              loop->loop_no, pred->index,
4135                              e->dest->index);
4136                   VEC_safe_push (edge, gc, loop->incoming, e);
4137                 }
4138             }
4139         }
4140
4141       for (pass = 0, retry = 1; retry && pass < 2; pass++)
4142         {
4143           edge e;
4144           edge_iterator ei;
4145           bool first = true;
4146           retry = 0;
4147
4148           FOR_EACH_EDGE (e, ei, loop->incoming)
4149             {
4150               if (first)
4151                 {
4152                   loop->incoming_src = e->src;
4153                   loop->incoming_dest = e->dest;
4154                   first = false;
4155                 }
4156               else
4157                 {
4158                   if (e->dest != loop->incoming_dest)
4159                     loop->incoming_dest = NULL;
4160                   if (e->src != loop->incoming_src)
4161                     loop->incoming_src = NULL;
4162                 }
4163               if (loop->incoming_src == NULL && loop->incoming_dest == NULL)
4164                 {
4165                   if (pass == 0)
4166                     {
4167                       if (dump_file)
4168                         fprintf (dump_file,
4169                                  ";; retrying loop %d with forwarder blocks\n",
4170                                  loop->loop_no);
4171                       retry = 1;
4172                       break;
4173                     }
4174                   loop->bad = 1;
4175                   if (dump_file)
4176                     fprintf (dump_file,
4177                              ";; can't find suitable entry for loop %d\n",
4178                              loop->loop_no);
4179                   goto out;
4180                 }
4181             }
4182           if (retry)
4183             {
4184               retry = 0;
4185               FOR_EACH_EDGE (e, ei, loop->incoming)
4186                 {
4187                   if (forwarder_block_p (e->src))
4188                     {
4189                       edge e2;
4190                       edge_iterator ei2;
4191
4192                       if (dump_file)
4193                         fprintf (dump_file,
4194                                  ";; Adding forwarder block %d to loop %d and retrying\n",
4195                                  e->src->index, loop->loop_no);
4196                       VEC_safe_push (basic_block, heap, loop->blocks, e->src);
4197                       bitmap_set_bit (loop->block_bitmap, e->src->index);
4198                       FOR_EACH_EDGE (e2, ei2, e->src->preds)
4199                         VEC_safe_push (edge, gc, loop->incoming, e2);
4200                       VEC_unordered_remove (edge, loop->incoming, ei.index);
4201                       retry = 1;
4202                       break;
4203                     }
4204                 }
4205             }
4206         }
4207     }
4208
4209  out:
4210   VEC_free (basic_block, heap, works);
4211 }
4212
4213 /* Analyze the structure of the loops in the current function.  Use STACK
4214    for bitmap allocations.  Returns all the valid candidates for hardware
4215    loops found in this function.  */
4216 static loop_info
4217 bfin_discover_loops (bitmap_obstack *stack, FILE *dump_file)
4218 {
4219   loop_info loops = NULL;
4220   loop_info loop;
4221   basic_block bb;
4222   bitmap tmp_bitmap;
4223   int nloops = 0;
4224
4225   /* Find all the possible loop tails.  This means searching for every
4226      loop_end instruction.  For each one found, create a loop_info
4227      structure and add the head block to the work list. */
4228   FOR_EACH_BB (bb)
4229     {
4230       rtx tail = BB_END (bb);
4231
4232       while (GET_CODE (tail) == NOTE)
4233         tail = PREV_INSN (tail);
4234
4235       bb->aux = NULL;
4236
4237       if (INSN_P (tail) && recog_memoized (tail) == CODE_FOR_loop_end)
4238         {
4239           rtx insn;
4240           /* A possible loop end */
4241
4242           /* There's a degenerate case we can handle - an empty loop consisting
4243              of only a back branch.  Handle that by deleting the branch.  */
4244           insn = BB_HEAD (BRANCH_EDGE (bb)->dest);
4245           if (next_real_insn (insn) == tail)
4246             {
4247               if (dump_file)
4248                 {
4249                   fprintf (dump_file, ";; degenerate loop ending at\n");
4250                   print_rtl_single (dump_file, tail);
4251                 }
4252               delete_insn_and_edges (tail);
4253               continue;
4254             }
4255
4256           loop = XNEW (struct loop_info);
4257           loop->next = loops;
4258           loops = loop;
4259           loop->loop_no = nloops++;
4260           loop->blocks = VEC_alloc (basic_block, heap, 20);
4261           loop->block_bitmap = BITMAP_ALLOC (stack);
4262           bb->aux = loop;
4263
4264           if (dump_file)
4265             {
4266               fprintf (dump_file, ";; potential loop %d ending at\n",
4267                        loop->loop_no);
4268               print_rtl_single (dump_file, tail);
4269             }
4270
4271           bfin_discover_loop (loop, bb, tail);
4272         }
4273     }
4274
4275   tmp_bitmap = BITMAP_ALLOC (stack);
4276   /* Compute loop nestings.  */
4277   for (loop = loops; loop; loop = loop->next)
4278     {
4279       loop_info other;
4280       if (loop->bad)
4281         continue;
4282
4283       for (other = loop->next; other; other = other->next)
4284         {
4285           if (other->bad)
4286             continue;
4287
4288           bitmap_and (tmp_bitmap, other->block_bitmap, loop->block_bitmap);
4289           if (bitmap_empty_p (tmp_bitmap))
4290             continue;
4291           if (bitmap_equal_p (tmp_bitmap, other->block_bitmap))
4292             {
4293               other->outer = loop;
4294               VEC_safe_push (loop_info, heap, loop->loops, other);
4295             }
4296           else if (bitmap_equal_p (tmp_bitmap, loop->block_bitmap))
4297             {
4298               loop->outer = other;
4299               VEC_safe_push (loop_info, heap, other->loops, loop);
4300             }
4301           else
4302             {
4303               if (dump_file)
4304                 fprintf (dump_file,
4305                          ";; can't find suitable nesting for loops %d and %d\n",
4306                          loop->loop_no, other->loop_no);
4307               loop->bad = other->bad = 1;
4308             }
4309         }
4310     }
4311   BITMAP_FREE (tmp_bitmap);
4312
4313   return loops;
4314 }
4315
4316 /* Free up the loop structures in LOOPS.  */
4317 static void
4318 free_loops (loop_info loops)
4319 {
4320   while (loops)
4321     {
4322       loop_info loop = loops;
4323       loops = loop->next;
4324       VEC_free (loop_info, heap, loop->loops);
4325       VEC_free (basic_block, heap, loop->blocks);
4326       BITMAP_FREE (loop->block_bitmap);
4327       XDELETE (loop);
4328     }
4329 }
4330
4331 #define BB_AUX_INDEX(BB) ((unsigned)(BB)->aux)
4332
4333 /* The taken-branch edge from the loop end can actually go forward.  Since the
4334    Blackfin's LSETUP instruction requires that the loop end be after the loop
4335    start, try to reorder a loop's basic blocks when we find such a case.  */
4336 static void
4337 bfin_reorder_loops (loop_info loops, FILE *dump_file)
4338 {
4339   basic_block bb;
4340   loop_info loop;
4341
4342   FOR_EACH_BB (bb)
4343     bb->aux = NULL;
4344   cfg_layout_initialize (0);
4345
4346   for (loop = loops; loop; loop = loop->next)
4347     {
4348       unsigned index;
4349       basic_block bb;
4350       edge e;
4351       edge_iterator ei;
4352
4353       if (loop->bad)
4354         continue;
4355
4356       /* Recreate an index for basic blocks that represents their order.  */
4357       for (bb = ENTRY_BLOCK_PTR->next_bb, index = 0;
4358            bb != EXIT_BLOCK_PTR;
4359            bb = bb->next_bb, index++)
4360         bb->aux = (PTR) index;
4361
4362       if (BB_AUX_INDEX (loop->head) < BB_AUX_INDEX (loop->tail))
4363         continue;
4364
4365       FOR_EACH_EDGE (e, ei, loop->head->succs)
4366         {
4367           if (bitmap_bit_p (loop->block_bitmap, e->dest->index)
4368               && BB_AUX_INDEX (e->dest) < BB_AUX_INDEX (loop->tail))
4369             {
4370               basic_block start_bb = e->dest;
4371               basic_block start_prev_bb = start_bb->prev_bb;
4372
4373               if (dump_file)
4374                 fprintf (dump_file, ";; Moving block %d before block %d\n",
4375                          loop->head->index, start_bb->index);
4376               loop->head->prev_bb->next_bb = loop->head->next_bb;
4377               loop->head->next_bb->prev_bb = loop->head->prev_bb;
4378
4379               loop->head->prev_bb = start_prev_bb;
4380               loop->head->next_bb = start_bb;
4381               start_prev_bb->next_bb = start_bb->prev_bb = loop->head;
4382               break;
4383             }
4384         }
4385       loops = loops->next;
4386     }
4387
4388   FOR_EACH_BB (bb)
4389     {
4390       if (bb->next_bb != EXIT_BLOCK_PTR)
4391         bb->aux = bb->next_bb;
4392       else
4393         bb->aux = NULL;
4394     }
4395   cfg_layout_finalize ();
4396   df_analyze ();
4397 }
4398
4399 /* Run from machine_dependent_reorg, this pass looks for doloop_end insns
4400    and tries to rewrite the RTL of these loops so that proper Blackfin
4401    hardware loops are generated.  */
4402
4403 static void
4404 bfin_reorg_loops (FILE *dump_file)
4405 {
4406   loop_info loops = NULL;
4407   loop_info loop;
4408   basic_block bb;
4409   bitmap_obstack stack;
4410
4411   bitmap_obstack_initialize (&stack);
4412
4413   if (dump_file)
4414     fprintf (dump_file, ";; Find loops, first pass\n\n");
4415
4416   loops = bfin_discover_loops (&stack, dump_file);
4417
4418   if (dump_file)
4419     bfin_dump_loops (loops);
4420
4421   bfin_reorder_loops (loops, dump_file);
4422   free_loops (loops);
4423
4424   if (dump_file)
4425     fprintf (dump_file, ";; Find loops, second pass\n\n");
4426
4427   loops = bfin_discover_loops (&stack, dump_file);
4428   if (dump_file)
4429     {
4430       fprintf (dump_file, ";; All loops found:\n\n");
4431       bfin_dump_loops (loops);
4432     }
4433
4434   /* Now apply the optimizations.  */
4435   for (loop = loops; loop; loop = loop->next)
4436     bfin_optimize_loop (loop);
4437
4438   if (dump_file)
4439     {
4440       fprintf (dump_file, ";; After hardware loops optimization:\n\n");
4441       bfin_dump_loops (loops);
4442     }
4443
4444   free_loops (loops);
4445
4446   if (dump_file)
4447     print_rtl (dump_file, get_insns ());
4448
4449   FOR_EACH_BB (bb)
4450     bb->aux = NULL;
4451 }
4452 \f
4453 /* Possibly generate a SEQUENCE out of three insns found in SLOT.
4454    Returns true if we modified the insn chain, false otherwise.  */
4455 static bool
4456 gen_one_bundle (rtx slot[3])
4457 {
4458   gcc_assert (slot[1] != NULL_RTX);
4459
4460   /* Verify that we really can do the multi-issue.  */
4461   if (slot[0])
4462     {
4463       rtx t = NEXT_INSN (slot[0]);
4464       while (t != slot[1])
4465         {
4466           if (GET_CODE (t) != NOTE
4467               || NOTE_KIND (t) != NOTE_INSN_DELETED)
4468             return false;
4469           t = NEXT_INSN (t);
4470         }
4471     }
4472   if (slot[2])
4473     {
4474       rtx t = NEXT_INSN (slot[1]);
4475       while (t != slot[2])
4476         {
4477           if (GET_CODE (t) != NOTE
4478               || NOTE_KIND (t) != NOTE_INSN_DELETED)
4479             return false;
4480           t = NEXT_INSN (t);
4481         }
4482     }
4483
4484   if (slot[0] == NULL_RTX)
4485     {
4486       slot[0] = emit_insn_before (gen_mnop (), slot[1]);
4487       df_insn_rescan (slot[0]);
4488     }
4489   if (slot[2] == NULL_RTX)
4490     {
4491       slot[2] = emit_insn_after (gen_forced_nop (), slot[1]);
4492       df_insn_rescan (slot[2]);
4493     }
4494
4495   /* Avoid line number information being printed inside one bundle.  */
4496   if (INSN_LOCATOR (slot[1])
4497       && INSN_LOCATOR (slot[1]) != INSN_LOCATOR (slot[0]))
4498     INSN_LOCATOR (slot[1]) = INSN_LOCATOR (slot[0]);
4499   if (INSN_LOCATOR (slot[2])
4500       && INSN_LOCATOR (slot[2]) != INSN_LOCATOR (slot[0]))
4501     INSN_LOCATOR (slot[2]) = INSN_LOCATOR (slot[0]);
4502
4503   /* Terminate them with "|| " instead of ";" in the output.  */
4504   PUT_MODE (slot[0], SImode);
4505   PUT_MODE (slot[1], SImode);
4506   /* Terminate the bundle, for the benefit of reorder_var_tracking_notes.  */
4507   PUT_MODE (slot[2], QImode);
4508   return true;
4509 }
4510
4511 /* Go through all insns, and use the information generated during scheduling
4512    to generate SEQUENCEs to represent bundles of instructions issued
4513    simultaneously.  */
4514
4515 static void
4516 bfin_gen_bundles (void)
4517 {
4518   basic_block bb;
4519   FOR_EACH_BB (bb)
4520     {
4521       rtx insn, next;
4522       rtx slot[3];
4523       int n_filled = 0;
4524
4525       slot[0] = slot[1] = slot[2] = NULL_RTX;
4526       for (insn = BB_HEAD (bb);; insn = next)
4527         {
4528           int at_end;
4529           if (INSN_P (insn))
4530             {
4531               if (get_attr_type (insn) == TYPE_DSP32)
4532                 slot[0] = insn;
4533               else if (slot[1] == NULL_RTX)
4534                 slot[1] = insn;
4535               else
4536                 slot[2] = insn;
4537               n_filled++;
4538             }
4539
4540           next = NEXT_INSN (insn);
4541           while (next && insn != BB_END (bb)
4542                  && !(INSN_P (next)
4543                       && GET_CODE (PATTERN (next)) != USE
4544                       && GET_CODE (PATTERN (next)) != CLOBBER))
4545             {
4546               insn = next;
4547               next = NEXT_INSN (insn);
4548             }
4549
4550           /* BB_END can change due to emitting extra NOPs, so check here.  */
4551           at_end = insn == BB_END (bb);
4552           if (at_end || GET_MODE (next) == TImode)
4553             {
4554               if ((n_filled < 2
4555                    || !gen_one_bundle (slot))
4556                   && slot[0] != NULL_RTX)
4557                 {
4558                   rtx pat = PATTERN (slot[0]);
4559                   if (GET_CODE (pat) == SET
4560                       && GET_CODE (SET_SRC (pat)) == UNSPEC
4561                       && XINT (SET_SRC (pat), 1) == UNSPEC_32BIT)
4562                     {
4563                       SET_SRC (pat) = XVECEXP (SET_SRC (pat), 0, 0);
4564                       INSN_CODE (slot[0]) = -1;
4565                       df_insn_rescan (slot[0]);
4566                     }
4567                 }
4568               n_filled = 0;
4569               slot[0] = slot[1] = slot[2] = NULL_RTX;
4570             }
4571           if (at_end)
4572             break;
4573         }
4574     }
4575 }
4576
4577 /* Ensure that no var tracking notes are emitted in the middle of a
4578    three-instruction bundle.  */
4579
4580 static void
4581 reorder_var_tracking_notes (void)
4582 {
4583   basic_block bb;
4584   FOR_EACH_BB (bb)
4585     {
4586       rtx insn, next;
4587       rtx queue = NULL_RTX;
4588       bool in_bundle = false;
4589
4590       for (insn = BB_HEAD (bb); insn != BB_END (bb); insn = next)
4591         {
4592           next = NEXT_INSN (insn);
4593
4594           if (INSN_P (insn))
4595             {
4596               /* Emit queued up notes at the last instruction of a bundle.  */
4597               if (GET_MODE (insn) == QImode)
4598                 {
4599                   while (queue)
4600                     {
4601                       rtx next_queue = PREV_INSN (queue);
4602                       PREV_INSN (NEXT_INSN (insn)) = queue;
4603                       NEXT_INSN (queue) = NEXT_INSN (insn);
4604                       NEXT_INSN (insn) = queue;
4605                       PREV_INSN (queue) = insn;
4606                       queue = next_queue;
4607                     }
4608                   in_bundle = false;
4609                 }
4610               else if (GET_MODE (insn) == SImode)
4611                 in_bundle = true;
4612             }
4613           else if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_VAR_LOCATION)
4614             {
4615               if (in_bundle)
4616                 {
4617                   rtx prev = PREV_INSN (insn);
4618                   PREV_INSN (next) = prev;
4619                   NEXT_INSN (prev) = next;
4620
4621                   PREV_INSN (insn) = queue;
4622                   queue = insn;
4623                 }
4624             }
4625         }
4626     }
4627 }
4628 \f
4629 /* Return an insn type for INSN that can be used by the caller for anomaly
4630    workarounds.  This differs from plain get_attr_type in that it handles
4631    SEQUENCEs.  */
4632
4633 static enum attr_type
4634 type_for_anomaly (rtx insn)
4635 {
4636   rtx pat = PATTERN (insn);
4637   if (GET_CODE (pat) == SEQUENCE)
4638     {
4639       enum attr_type t;
4640       t = get_attr_type (XVECEXP (pat, 0, 1));
4641       if (t == TYPE_MCLD)
4642         return t;
4643       t = get_attr_type (XVECEXP (pat, 0, 2));
4644       if (t == TYPE_MCLD)
4645         return t;
4646       return TYPE_MCST;
4647     }
4648   else
4649     return get_attr_type (insn);
4650 }
4651
4652 /* Return nonzero if INSN contains any loads that may trap.  It handles
4653    SEQUENCEs correctly.  */
4654
4655 static bool
4656 trapping_loads_p (rtx insn)
4657 {
4658   rtx pat = PATTERN (insn);
4659   if (GET_CODE (pat) == SEQUENCE)
4660     {
4661       enum attr_type t;
4662       t = get_attr_type (XVECEXP (pat, 0, 1));
4663       if (t == TYPE_MCLD
4664           && may_trap_p (SET_SRC (PATTERN (XVECEXP (pat, 0, 1)))))
4665         return true;
4666       t = get_attr_type (XVECEXP (pat, 0, 2));
4667       if (t == TYPE_MCLD
4668           && may_trap_p (SET_SRC (PATTERN (XVECEXP (pat, 0, 2)))))
4669         return true;
4670       return false;
4671     }
4672   else
4673     return may_trap_p (SET_SRC (single_set (insn)));
4674 }
4675
4676 /* This function acts like NEXT_INSN, but is aware of three-insn bundles and
4677    skips all subsequent parallel instructions if INSN is the start of such
4678    a group.  */
4679 static rtx
4680 find_next_insn_start (rtx insn)
4681 {
4682   if (GET_MODE (insn) == SImode)
4683     {
4684       while (GET_MODE (insn) != QImode)
4685         insn = NEXT_INSN (insn);
4686     }
4687   return NEXT_INSN (insn);
4688 }
4689
4690 /* Return INSN if it is of TYPE_MCLD.  Alternatively, if INSN is the start of
4691    a three-insn bundle, see if one of them is a load and return that if so.
4692    Return NULL_RTX if the insn does not contain loads.  */
4693 static rtx
4694 find_load (rtx insn)
4695 {
4696   if (get_attr_type (insn) == TYPE_MCLD)
4697     return insn;
4698   if (GET_MODE (insn) != SImode)
4699     return NULL_RTX;
4700   do {
4701     insn = NEXT_INSN (insn);
4702     if ((GET_MODE (insn) == SImode || GET_MODE (insn) == QImode)
4703         && get_attr_type (insn) == TYPE_MCLD)
4704       return insn;
4705   } while (GET_MODE (insn) != QImode);
4706   return NULL_RTX;
4707 }
4708
4709 /* We use the machine specific reorg pass for emitting CSYNC instructions
4710    after conditional branches as needed.
4711
4712    The Blackfin is unusual in that a code sequence like
4713      if cc jump label
4714      r0 = (p0)
4715    may speculatively perform the load even if the condition isn't true.  This
4716    happens for a branch that is predicted not taken, because the pipeline
4717    isn't flushed or stalled, so the early stages of the following instructions,
4718    which perform the memory reference, are allowed to execute before the
4719    jump condition is evaluated.
4720    Therefore, we must insert additional instructions in all places where this
4721    could lead to incorrect behavior.  The manual recommends CSYNC, while
4722    VDSP seems to use NOPs (even though its corresponding compiler option is
4723    named CSYNC).
4724
4725    When optimizing for speed, we emit NOPs, which seems faster than a CSYNC.
4726    When optimizing for size, we turn the branch into a predicted taken one.
4727    This may be slower due to mispredicts, but saves code size.  */
4728
4729 static void
4730 bfin_reorg (void)
4731 {
4732   rtx insn, next;
4733   rtx last_condjump = NULL_RTX;
4734   int cycles_since_jump = INT_MAX;
4735
4736   /* We are freeing block_for_insn in the toplev to keep compatibility
4737      with old MDEP_REORGS that are not CFG based.  Recompute it now.  */
4738   compute_bb_for_insn ();
4739
4740   if (bfin_flag_schedule_insns2)
4741     {
4742       splitting_for_sched = 1;
4743       split_all_insns ();
4744       splitting_for_sched = 0;
4745
4746       timevar_push (TV_SCHED2);
4747       schedule_insns ();
4748       timevar_pop (TV_SCHED2);
4749
4750       /* Examine the schedule and insert nops as necessary for 64-bit parallel
4751          instructions.  */
4752       bfin_gen_bundles ();
4753     }
4754
4755   df_analyze ();
4756
4757   /* Doloop optimization */
4758   if (cfun->machine->has_hardware_loops)
4759     bfin_reorg_loops (dump_file);
4760
4761   if (! ENABLE_WA_SPECULATIVE_LOADS && ! ENABLE_WA_SPECULATIVE_SYNCS)
4762     return;
4763
4764   /* First pass: find predicted-false branches; if something after them
4765      needs nops, insert them or change the branch to predict true.  */
4766   for (insn = get_insns (); insn; insn = next)
4767     {
4768       rtx pat;
4769
4770       next = find_next_insn_start (insn);
4771
4772       if (NOTE_P (insn) || BARRIER_P (insn) || LABEL_P (insn))
4773         continue;
4774
4775       pat = PATTERN (insn);
4776       if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
4777           || GET_CODE (pat) == ASM_INPUT || GET_CODE (pat) == ADDR_VEC
4778           || GET_CODE (pat) == ADDR_DIFF_VEC || asm_noperands (pat) >= 0)
4779         continue;
4780
4781       if (JUMP_P (insn))
4782         {
4783           if (any_condjump_p (insn)
4784               && ! cbranch_predicted_taken_p (insn))
4785             {
4786               last_condjump = insn;
4787               cycles_since_jump = 0;
4788             }
4789           else
4790             cycles_since_jump = INT_MAX;
4791         }
4792       else if (INSN_P (insn))
4793         {
4794           rtx load_insn = find_load (insn);
4795           enum attr_type type = type_for_anomaly (insn);
4796           int delay_needed = 0;
4797           if (cycles_since_jump < INT_MAX)
4798             cycles_since_jump++;
4799
4800           if (load_insn && ENABLE_WA_SPECULATIVE_LOADS)
4801             {
4802               if (trapping_loads_p (load_insn))
4803                 delay_needed = 3;
4804             }
4805           else if (type == TYPE_SYNC && ENABLE_WA_SPECULATIVE_SYNCS)
4806             delay_needed = 4;
4807
4808           if (delay_needed > cycles_since_jump)
4809             {
4810               rtx pat;
4811               int num_clobbers;
4812               rtx *op = recog_data.operand;
4813
4814               delay_needed -= cycles_since_jump;
4815
4816               extract_insn (last_condjump);
4817               if (optimize_size)
4818                 {
4819                   pat = gen_cbranch_predicted_taken (op[0], op[1], op[2],
4820                                                      op[3]);
4821                   cycles_since_jump = INT_MAX;
4822                 }
4823               else
4824                 /* Do not adjust cycles_since_jump in this case, so that
4825                    we'll increase the number of NOPs for a subsequent insn
4826                    if necessary.  */
4827                 pat = gen_cbranch_with_nops (op[0], op[1], op[2], op[3],
4828                                              GEN_INT (delay_needed));
4829               PATTERN (last_condjump) = pat;
4830               INSN_CODE (last_condjump) = recog (pat, insn, &num_clobbers);
4831             }
4832         }
4833     }
4834   /* Second pass: for predicted-true branches, see if anything at the
4835      branch destination needs extra nops.  */
4836   if (! ENABLE_WA_SPECULATIVE_SYNCS)
4837     return;
4838
4839   if (! ENABLE_WA_RETS)
4840     return;
4841
4842   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
4843     {
4844       if (JUMP_P (insn)
4845           && any_condjump_p (insn)
4846           && (INSN_CODE (insn) == CODE_FOR_cbranch_predicted_taken
4847               || cbranch_predicted_taken_p (insn)))
4848         {
4849           rtx target = JUMP_LABEL (insn);
4850           rtx label = target;
4851           cycles_since_jump = 0;
4852           for (; target && cycles_since_jump < 3; target = NEXT_INSN (target))
4853             {
4854               rtx pat;
4855
4856               if (NOTE_P (target) || BARRIER_P (target) || LABEL_P (target))
4857                 continue;
4858
4859               pat = PATTERN (target);
4860               if (GET_CODE (pat) == USE || GET_CODE (pat) == CLOBBER
4861                   || GET_CODE (pat) == ASM_INPUT || GET_CODE (pat) == ADDR_VEC
4862                   || GET_CODE (pat) == ADDR_DIFF_VEC || asm_noperands (pat) >= 0)
4863                 continue;
4864
4865               if (INSN_P (target))
4866                 {
4867                   enum attr_type type = type_for_anomaly (target);
4868                   int delay_needed = 0;
4869                   if (cycles_since_jump < INT_MAX)
4870                     cycles_since_jump++;
4871
4872                   if (type == TYPE_SYNC && ENABLE_WA_SPECULATIVE_SYNCS)
4873                     delay_needed = 2;
4874
4875                   if (delay_needed > cycles_since_jump)
4876                     {
4877                       rtx prev = prev_real_insn (label);
4878                       delay_needed -= cycles_since_jump;
4879                       if (dump_file)
4880                         fprintf (dump_file, "Adding %d nops after %d\n",
4881                                  delay_needed, INSN_UID (label));
4882                       if (JUMP_P (prev)
4883                           && INSN_CODE (prev) == CODE_FOR_cbranch_with_nops)
4884                         {
4885                           rtx x;
4886                           HOST_WIDE_INT v;
4887
4888                           if (dump_file)
4889                             fprintf (dump_file,
4890                                      "Reducing nops on insn %d.\n",
4891                                      INSN_UID (prev));
4892                           x = PATTERN (prev);
4893                           x = XVECEXP (x, 0, 1);
4894                           v = INTVAL (XVECEXP (x, 0, 0)) - delay_needed;
4895                           XVECEXP (x, 0, 0) = GEN_INT (v);
4896                         }
4897                       while (delay_needed-- > 0)
4898                         emit_insn_after (gen_nop (), label);
4899                       break;
4900                     }
4901                 }
4902             }
4903         }
4904     }
4905
4906   if (bfin_flag_var_tracking)
4907     {
4908       timevar_push (TV_VAR_TRACKING);
4909       variable_tracking_main ();
4910       reorder_var_tracking_notes ();
4911       timevar_pop (TV_VAR_TRACKING);
4912     }
4913   df_finish_pass (false);
4914 }
4915 \f
4916 /* Handle interrupt_handler, exception_handler and nmi_handler function
4917    attributes; arguments as in struct attribute_spec.handler.  */
4918
4919 static tree
4920 handle_int_attribute (tree *node, tree name,
4921                       tree args ATTRIBUTE_UNUSED,
4922                       int flags ATTRIBUTE_UNUSED,
4923                       bool *no_add_attrs)
4924 {
4925   tree x = *node;
4926   if (TREE_CODE (x) == FUNCTION_DECL)
4927     x = TREE_TYPE (x);
4928
4929   if (TREE_CODE (x) != FUNCTION_TYPE)
4930     {
4931       warning (OPT_Wattributes, "%qs attribute only applies to functions",
4932                IDENTIFIER_POINTER (name));
4933       *no_add_attrs = true;
4934     }
4935   else if (funkind (x) != SUBROUTINE)
4936     error ("multiple function type attributes specified");
4937
4938   return NULL_TREE;
4939 }
4940
4941 /* Return 0 if the attributes for two types are incompatible, 1 if they
4942    are compatible, and 2 if they are nearly compatible (which causes a
4943    warning to be generated).  */
4944
4945 static int
4946 bfin_comp_type_attributes (const_tree type1, const_tree type2)
4947 {
4948   e_funkind kind1, kind2;
4949
4950   if (TREE_CODE (type1) != FUNCTION_TYPE)
4951     return 1;
4952
4953   kind1 = funkind (type1);
4954   kind2 = funkind (type2);
4955
4956   if (kind1 != kind2)
4957     return 0;
4958
4959   /*  Check for mismatched modifiers */
4960   if (!lookup_attribute ("nesting", TYPE_ATTRIBUTES (type1))
4961       != !lookup_attribute ("nesting", TYPE_ATTRIBUTES (type2)))
4962     return 0;
4963
4964   if (!lookup_attribute ("saveall", TYPE_ATTRIBUTES (type1))
4965       != !lookup_attribute ("saveall", TYPE_ATTRIBUTES (type2)))
4966     return 0;
4967
4968   if (!lookup_attribute ("kspisusp", TYPE_ATTRIBUTES (type1))
4969       != !lookup_attribute ("kspisusp", TYPE_ATTRIBUTES (type2)))
4970     return 0;
4971
4972   if (!lookup_attribute ("longcall", TYPE_ATTRIBUTES (type1))
4973       != !lookup_attribute ("longcall", TYPE_ATTRIBUTES (type2)))
4974     return 0;
4975
4976   return 1;
4977 }
4978
4979 /* Handle a "longcall" or "shortcall" attribute; arguments as in
4980    struct attribute_spec.handler.  */
4981
4982 static tree
4983 bfin_handle_longcall_attribute (tree *node, tree name,
4984                                 tree args ATTRIBUTE_UNUSED,
4985                                 int flags ATTRIBUTE_UNUSED,
4986                                 bool *no_add_attrs)
4987 {
4988   if (TREE_CODE (*node) != FUNCTION_TYPE
4989       && TREE_CODE (*node) != FIELD_DECL
4990       && TREE_CODE (*node) != TYPE_DECL)
4991     {
4992       warning (OPT_Wattributes, "`%s' attribute only applies to functions",
4993                IDENTIFIER_POINTER (name));
4994       *no_add_attrs = true;
4995     }
4996
4997   if ((strcmp (IDENTIFIER_POINTER (name), "longcall") == 0
4998        && lookup_attribute ("shortcall", TYPE_ATTRIBUTES (*node)))
4999       || (strcmp (IDENTIFIER_POINTER (name), "shortcall") == 0
5000           && lookup_attribute ("longcall", TYPE_ATTRIBUTES (*node))))
5001     {
5002       warning (OPT_Wattributes,
5003                "can't apply both longcall and shortcall attributes to the same function");
5004       *no_add_attrs = true;
5005     }
5006
5007   return NULL_TREE;
5008 }
5009
5010 /* Handle a "l1_text" attribute; arguments as in
5011    struct attribute_spec.handler.  */
5012
5013 static tree
5014 bfin_handle_l1_text_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5015                                int ARG_UNUSED (flags), bool *no_add_attrs)
5016 {
5017   tree decl = *node;
5018
5019   if (TREE_CODE (decl) != FUNCTION_DECL)
5020     {
5021       error ("`%s' attribute only applies to functions",
5022              IDENTIFIER_POINTER (name));
5023       *no_add_attrs = true;
5024     }
5025
5026   /* The decl may have already been given a section attribute
5027      from a previous declaration. Ensure they match.  */
5028   else if (DECL_SECTION_NAME (decl) != NULL_TREE
5029            && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5030                       ".l1.text") != 0)
5031     {
5032       error ("section of %q+D conflicts with previous declaration",
5033              decl);
5034       *no_add_attrs = true;
5035     }
5036   else
5037     DECL_SECTION_NAME (decl) = build_string (9, ".l1.text");
5038
5039   return NULL_TREE;
5040 }
5041
5042 /* Handle a "l1_data", "l1_data_A" or "l1_data_B" attribute;
5043    arguments as in struct attribute_spec.handler.  */
5044
5045 static tree
5046 bfin_handle_l1_data_attribute (tree *node, tree name, tree ARG_UNUSED (args),
5047                                int ARG_UNUSED (flags), bool *no_add_attrs)
5048 {
5049   tree decl = *node;
5050
5051   if (TREE_CODE (decl) != VAR_DECL)
5052     {
5053       error ("`%s' attribute only applies to variables",
5054              IDENTIFIER_POINTER (name));
5055       *no_add_attrs = true;
5056     }
5057   else if (current_function_decl != NULL_TREE
5058            && !TREE_STATIC (decl))
5059     {
5060       error ("`%s' attribute cannot be specified for local variables",
5061              IDENTIFIER_POINTER (name));
5062       *no_add_attrs = true;
5063     }
5064   else
5065     {
5066       const char *section_name;
5067
5068       if (strcmp (IDENTIFIER_POINTER (name), "l1_data") == 0)
5069         section_name = ".l1.data";
5070       else if (strcmp (IDENTIFIER_POINTER (name), "l1_data_A") == 0)
5071         section_name = ".l1.data.A";
5072       else if (strcmp (IDENTIFIER_POINTER (name), "l1_data_B") == 0)
5073         section_name = ".l1.data.B";
5074       else
5075         gcc_unreachable ();
5076
5077       /* The decl may have already been given a section attribute
5078          from a previous declaration. Ensure they match.  */
5079       if (DECL_SECTION_NAME (decl) != NULL_TREE
5080           && strcmp (TREE_STRING_POINTER (DECL_SECTION_NAME (decl)),
5081                      section_name) != 0)
5082         {
5083           error ("section of %q+D conflicts with previous declaration",
5084                  decl);
5085           *no_add_attrs = true;
5086         }
5087       else
5088         DECL_SECTION_NAME (decl)
5089           = build_string (strlen (section_name) + 1, section_name);
5090     }
5091
5092  return NULL_TREE;
5093 }
5094
5095 /* Table of valid machine attributes.  */
5096 const struct attribute_spec bfin_attribute_table[] =
5097 {
5098   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
5099   { "interrupt_handler", 0, 0, false, true,  true, handle_int_attribute },
5100   { "exception_handler", 0, 0, false, true,  true, handle_int_attribute },
5101   { "nmi_handler", 0, 0, false, true,  true, handle_int_attribute },
5102   { "nesting", 0, 0, false, true,  true, NULL },
5103   { "kspisusp", 0, 0, false, true,  true, NULL },
5104   { "saveall", 0, 0, false, true,  true, NULL },
5105   { "longcall",  0, 0, false, true,  true,  bfin_handle_longcall_attribute },
5106   { "shortcall", 0, 0, false, true,  true,  bfin_handle_longcall_attribute },
5107   { "l1_text", 0, 0, true, false, false,  bfin_handle_l1_text_attribute },
5108   { "l1_data", 0, 0, true, false, false,  bfin_handle_l1_data_attribute },
5109   { "l1_data_A", 0, 0, true, false, false, bfin_handle_l1_data_attribute },
5110   { "l1_data_B", 0, 0, true, false, false,  bfin_handle_l1_data_attribute },
5111   { NULL, 0, 0, false, false, false, NULL }
5112 };
5113 \f
5114 /* Implementation of TARGET_ASM_INTEGER.  When using FD-PIC, we need to
5115    tell the assembler to generate pointers to function descriptors in
5116    some cases.  */
5117
5118 static bool
5119 bfin_assemble_integer (rtx value, unsigned int size, int aligned_p)
5120 {
5121   if (TARGET_FDPIC && size == UNITS_PER_WORD)
5122     {
5123       if (GET_CODE (value) == SYMBOL_REF
5124           && SYMBOL_REF_FUNCTION_P (value))
5125         {
5126           fputs ("\t.picptr\tfuncdesc(", asm_out_file);
5127           output_addr_const (asm_out_file, value);
5128           fputs (")\n", asm_out_file);
5129           return true;
5130         }
5131       if (!aligned_p)
5132         {
5133           /* We've set the unaligned SI op to NULL, so we always have to
5134              handle the unaligned case here.  */
5135           assemble_integer_with_op ("\t.4byte\t", value);
5136           return true;
5137         }
5138     }
5139   return default_assemble_integer (value, size, aligned_p);
5140 }
5141 \f
5142 /* Output the assembler code for a thunk function.  THUNK_DECL is the
5143    declaration for the thunk function itself, FUNCTION is the decl for
5144    the target function.  DELTA is an immediate constant offset to be
5145    added to THIS.  If VCALL_OFFSET is nonzero, the word at
5146    *(*this + vcall_offset) should be added to THIS.  */
5147
5148 static void
5149 bfin_output_mi_thunk (FILE *file ATTRIBUTE_UNUSED,
5150                       tree thunk ATTRIBUTE_UNUSED, HOST_WIDE_INT delta,
5151                       HOST_WIDE_INT vcall_offset, tree function)
5152 {
5153   rtx xops[3];
5154   /* The this parameter is passed as the first argument.  */
5155   rtx this_rtx = gen_rtx_REG (Pmode, REG_R0);
5156
5157   /* Adjust the this parameter by a fixed constant.  */
5158   if (delta)
5159     {
5160       xops[1] = this_rtx;
5161       if (delta >= -64 && delta <= 63)
5162         {
5163           xops[0] = GEN_INT (delta);
5164           output_asm_insn ("%1 += %0;", xops);
5165         }
5166       else if (delta >= -128 && delta < -64)
5167         {
5168           xops[0] = GEN_INT (delta + 64);
5169           output_asm_insn ("%1 += -64; %1 += %0;", xops);
5170         }
5171       else if (delta > 63 && delta <= 126)
5172         {
5173           xops[0] = GEN_INT (delta - 63);
5174           output_asm_insn ("%1 += 63; %1 += %0;", xops);
5175         }
5176       else
5177         {
5178           xops[0] = GEN_INT (delta);
5179           output_asm_insn ("r3.l = %h0; r3.h = %d0; %1 = %1 + r3;", xops);
5180         }
5181     }
5182
5183   /* Adjust the this parameter by a value stored in the vtable.  */
5184   if (vcall_offset)
5185     {
5186       rtx p2tmp = gen_rtx_REG (Pmode, REG_P2);
5187       rtx tmp = gen_rtx_REG (Pmode, REG_R3);
5188
5189       xops[1] = tmp;
5190       xops[2] = p2tmp;
5191       output_asm_insn ("%2 = r0; %2 = [%2];", xops);
5192
5193       /* Adjust the this parameter.  */
5194       xops[0] = gen_rtx_MEM (Pmode, plus_constant (p2tmp, vcall_offset));
5195       if (!memory_operand (xops[0], Pmode))
5196         {
5197           rtx tmp2 = gen_rtx_REG (Pmode, REG_P1);
5198           xops[0] = GEN_INT (vcall_offset);
5199           xops[1] = tmp2;
5200           output_asm_insn ("%h1 = %h0; %d1 = %d0; %2 = %2 + %1", xops);
5201           xops[0] = gen_rtx_MEM (Pmode, p2tmp);
5202         }
5203       xops[2] = this_rtx;
5204       output_asm_insn ("%1 = %0; %2 = %2 + %1;", xops);
5205     }
5206
5207   xops[0] = XEXP (DECL_RTL (function), 0);
5208   if (1 || !flag_pic || (*targetm.binds_local_p) (function))
5209     output_asm_insn ("jump.l\t%P0", xops);
5210 }
5211 \f
5212 /* Codes for all the Blackfin builtins.  */
5213 enum bfin_builtins
5214 {
5215   BFIN_BUILTIN_CSYNC,
5216   BFIN_BUILTIN_SSYNC,
5217   BFIN_BUILTIN_ONES,
5218   BFIN_BUILTIN_COMPOSE_2X16,
5219   BFIN_BUILTIN_EXTRACTLO,
5220   BFIN_BUILTIN_EXTRACTHI,
5221
5222   BFIN_BUILTIN_SSADD_2X16,
5223   BFIN_BUILTIN_SSSUB_2X16,
5224   BFIN_BUILTIN_SSADDSUB_2X16,
5225   BFIN_BUILTIN_SSSUBADD_2X16,
5226   BFIN_BUILTIN_MULT_2X16,
5227   BFIN_BUILTIN_MULTR_2X16,
5228   BFIN_BUILTIN_NEG_2X16,
5229   BFIN_BUILTIN_ABS_2X16,
5230   BFIN_BUILTIN_MIN_2X16,
5231   BFIN_BUILTIN_MAX_2X16,
5232
5233   BFIN_BUILTIN_SSADD_1X16,
5234   BFIN_BUILTIN_SSSUB_1X16,
5235   BFIN_BUILTIN_MULT_1X16,
5236   BFIN_BUILTIN_MULTR_1X16,
5237   BFIN_BUILTIN_NORM_1X16,
5238   BFIN_BUILTIN_NEG_1X16,
5239   BFIN_BUILTIN_ABS_1X16,
5240   BFIN_BUILTIN_MIN_1X16,
5241   BFIN_BUILTIN_MAX_1X16,
5242
5243   BFIN_BUILTIN_SUM_2X16,
5244   BFIN_BUILTIN_DIFFHL_2X16,
5245   BFIN_BUILTIN_DIFFLH_2X16,
5246
5247   BFIN_BUILTIN_SSADD_1X32,
5248   BFIN_BUILTIN_SSSUB_1X32,
5249   BFIN_BUILTIN_NORM_1X32,
5250   BFIN_BUILTIN_ROUND_1X32,
5251   BFIN_BUILTIN_NEG_1X32,
5252   BFIN_BUILTIN_ABS_1X32,
5253   BFIN_BUILTIN_MIN_1X32,
5254   BFIN_BUILTIN_MAX_1X32,
5255   BFIN_BUILTIN_MULT_1X32,
5256   BFIN_BUILTIN_MULT_1X32X32,
5257   BFIN_BUILTIN_MULT_1X32X32NS,
5258
5259   BFIN_BUILTIN_MULHISILL,
5260   BFIN_BUILTIN_MULHISILH,
5261   BFIN_BUILTIN_MULHISIHL,
5262   BFIN_BUILTIN_MULHISIHH,
5263
5264   BFIN_BUILTIN_LSHIFT_1X16,
5265   BFIN_BUILTIN_LSHIFT_2X16,
5266   BFIN_BUILTIN_SSASHIFT_1X16,
5267   BFIN_BUILTIN_SSASHIFT_2X16,
5268   BFIN_BUILTIN_SSASHIFT_1X32,
5269
5270   BFIN_BUILTIN_CPLX_MUL_16,
5271   BFIN_BUILTIN_CPLX_MAC_16,
5272   BFIN_BUILTIN_CPLX_MSU_16,
5273
5274   BFIN_BUILTIN_CPLX_MUL_16_S40,
5275   BFIN_BUILTIN_CPLX_MAC_16_S40,
5276   BFIN_BUILTIN_CPLX_MSU_16_S40,
5277
5278   BFIN_BUILTIN_CPLX_SQU,
5279
5280   BFIN_BUILTIN_LOADBYTES,
5281
5282   BFIN_BUILTIN_MAX
5283 };
5284
5285 #define def_builtin(NAME, TYPE, CODE)                                   \
5286 do {                                                                    \
5287   add_builtin_function ((NAME), (TYPE), (CODE), BUILT_IN_MD,            \
5288                        NULL, NULL_TREE);                                \
5289 } while (0)
5290
5291 /* Set up all builtin functions for this target.  */
5292 static void
5293 bfin_init_builtins (void)
5294 {
5295   tree V2HI_type_node = build_vector_type_for_mode (intHI_type_node, V2HImode);
5296   tree void_ftype_void
5297     = build_function_type (void_type_node, void_list_node);
5298   tree short_ftype_short
5299     = build_function_type_list (short_integer_type_node, short_integer_type_node,
5300                                 NULL_TREE);
5301   tree short_ftype_int_int
5302     = build_function_type_list (short_integer_type_node, integer_type_node,
5303                                 integer_type_node, NULL_TREE);
5304   tree int_ftype_int_int
5305     = build_function_type_list (integer_type_node, integer_type_node,
5306                                 integer_type_node, NULL_TREE);
5307   tree int_ftype_int
5308     = build_function_type_list (integer_type_node, integer_type_node,
5309                                 NULL_TREE);
5310   tree short_ftype_int
5311     = build_function_type_list (short_integer_type_node, integer_type_node,
5312                                 NULL_TREE);
5313   tree int_ftype_v2hi_v2hi
5314     = build_function_type_list (integer_type_node, V2HI_type_node,
5315                                 V2HI_type_node, NULL_TREE);
5316   tree v2hi_ftype_v2hi_v2hi
5317     = build_function_type_list (V2HI_type_node, V2HI_type_node,
5318                                 V2HI_type_node, NULL_TREE);
5319   tree v2hi_ftype_v2hi_v2hi_v2hi
5320     = build_function_type_list (V2HI_type_node, V2HI_type_node,
5321                                 V2HI_type_node, V2HI_type_node, NULL_TREE);
5322   tree v2hi_ftype_int_int
5323     = build_function_type_list (V2HI_type_node, integer_type_node,
5324                                 integer_type_node, NULL_TREE);
5325   tree v2hi_ftype_v2hi_int
5326     = build_function_type_list (V2HI_type_node, V2HI_type_node,
5327                                 integer_type_node, NULL_TREE);
5328   tree int_ftype_short_short
5329     = build_function_type_list (integer_type_node, short_integer_type_node,
5330                                 short_integer_type_node, NULL_TREE);
5331   tree v2hi_ftype_v2hi
5332     = build_function_type_list (V2HI_type_node, V2HI_type_node, NULL_TREE);
5333   tree short_ftype_v2hi
5334     = build_function_type_list (short_integer_type_node, V2HI_type_node,
5335                                 NULL_TREE);
5336   tree int_ftype_pint
5337     = build_function_type_list (integer_type_node,
5338                                 build_pointer_type (integer_type_node),
5339                                 NULL_TREE);
5340
5341   /* Add the remaining MMX insns with somewhat more complicated types.  */
5342   def_builtin ("__builtin_bfin_csync", void_ftype_void, BFIN_BUILTIN_CSYNC);
5343   def_builtin ("__builtin_bfin_ssync", void_ftype_void, BFIN_BUILTIN_SSYNC);
5344
5345   def_builtin ("__builtin_bfin_ones", short_ftype_int, BFIN_BUILTIN_ONES);
5346
5347   def_builtin ("__builtin_bfin_compose_2x16", v2hi_ftype_int_int,
5348                BFIN_BUILTIN_COMPOSE_2X16);
5349   def_builtin ("__builtin_bfin_extract_hi", short_ftype_v2hi,
5350                BFIN_BUILTIN_EXTRACTHI);
5351   def_builtin ("__builtin_bfin_extract_lo", short_ftype_v2hi,
5352                BFIN_BUILTIN_EXTRACTLO);
5353
5354   def_builtin ("__builtin_bfin_min_fr2x16", v2hi_ftype_v2hi_v2hi,
5355                BFIN_BUILTIN_MIN_2X16);
5356   def_builtin ("__builtin_bfin_max_fr2x16", v2hi_ftype_v2hi_v2hi,
5357                BFIN_BUILTIN_MAX_2X16);
5358
5359   def_builtin ("__builtin_bfin_add_fr2x16", v2hi_ftype_v2hi_v2hi,
5360                BFIN_BUILTIN_SSADD_2X16);
5361   def_builtin ("__builtin_bfin_sub_fr2x16", v2hi_ftype_v2hi_v2hi,
5362                BFIN_BUILTIN_SSSUB_2X16);
5363   def_builtin ("__builtin_bfin_dspaddsubsat", v2hi_ftype_v2hi_v2hi,
5364                BFIN_BUILTIN_SSADDSUB_2X16);
5365   def_builtin ("__builtin_bfin_dspsubaddsat", v2hi_ftype_v2hi_v2hi,
5366                BFIN_BUILTIN_SSSUBADD_2X16);
5367   def_builtin ("__builtin_bfin_mult_fr2x16", v2hi_ftype_v2hi_v2hi,
5368                BFIN_BUILTIN_MULT_2X16);
5369   def_builtin ("__builtin_bfin_multr_fr2x16", v2hi_ftype_v2hi_v2hi,
5370                BFIN_BUILTIN_MULTR_2X16);
5371   def_builtin ("__builtin_bfin_negate_fr2x16", v2hi_ftype_v2hi,
5372                BFIN_BUILTIN_NEG_2X16);
5373   def_builtin ("__builtin_bfin_abs_fr2x16", v2hi_ftype_v2hi,
5374                BFIN_BUILTIN_ABS_2X16);
5375
5376   def_builtin ("__builtin_bfin_min_fr1x16", short_ftype_int_int,
5377                BFIN_BUILTIN_MIN_1X16);
5378   def_builtin ("__builtin_bfin_max_fr1x16", short_ftype_int_int,
5379                BFIN_BUILTIN_MAX_1X16);
5380
5381   def_builtin ("__builtin_bfin_add_fr1x16", short_ftype_int_int,
5382                BFIN_BUILTIN_SSADD_1X16);
5383   def_builtin ("__builtin_bfin_sub_fr1x16", short_ftype_int_int,
5384                BFIN_BUILTIN_SSSUB_1X16);
5385   def_builtin ("__builtin_bfin_mult_fr1x16", short_ftype_int_int,
5386                BFIN_BUILTIN_MULT_1X16);
5387   def_builtin ("__builtin_bfin_multr_fr1x16", short_ftype_int_int,
5388                BFIN_BUILTIN_MULTR_1X16);
5389   def_builtin ("__builtin_bfin_negate_fr1x16", short_ftype_short,
5390                BFIN_BUILTIN_NEG_1X16);
5391   def_builtin ("__builtin_bfin_abs_fr1x16", short_ftype_short,
5392                BFIN_BUILTIN_ABS_1X16);
5393   def_builtin ("__builtin_bfin_norm_fr1x16", short_ftype_int,
5394                BFIN_BUILTIN_NORM_1X16);
5395
5396   def_builtin ("__builtin_bfin_sum_fr2x16", short_ftype_v2hi,
5397                BFIN_BUILTIN_SUM_2X16);
5398   def_builtin ("__builtin_bfin_diff_hl_fr2x16", short_ftype_v2hi,
5399                BFIN_BUILTIN_DIFFHL_2X16);
5400   def_builtin ("__builtin_bfin_diff_lh_fr2x16", short_ftype_v2hi,
5401                BFIN_BUILTIN_DIFFLH_2X16);
5402
5403   def_builtin ("__builtin_bfin_mulhisill", int_ftype_v2hi_v2hi,
5404                BFIN_BUILTIN_MULHISILL);
5405   def_builtin ("__builtin_bfin_mulhisihl", int_ftype_v2hi_v2hi,
5406                BFIN_BUILTIN_MULHISIHL);
5407   def_builtin ("__builtin_bfin_mulhisilh", int_ftype_v2hi_v2hi,
5408                BFIN_BUILTIN_MULHISILH);
5409   def_builtin ("__builtin_bfin_mulhisihh", int_ftype_v2hi_v2hi,
5410                BFIN_BUILTIN_MULHISIHH);
5411
5412   def_builtin ("__builtin_bfin_min_fr1x32", int_ftype_int_int,
5413                BFIN_BUILTIN_MIN_1X32);
5414   def_builtin ("__builtin_bfin_max_fr1x32", int_ftype_int_int,
5415                BFIN_BUILTIN_MAX_1X32);
5416
5417   def_builtin ("__builtin_bfin_add_fr1x32", int_ftype_int_int,
5418                BFIN_BUILTIN_SSADD_1X32);
5419   def_builtin ("__builtin_bfin_sub_fr1x32", int_ftype_int_int,
5420                BFIN_BUILTIN_SSSUB_1X32);
5421   def_builtin ("__builtin_bfin_negate_fr1x32", int_ftype_int,
5422                BFIN_BUILTIN_NEG_1X32);
5423   def_builtin ("__builtin_bfin_abs_fr1x32", int_ftype_int,
5424                BFIN_BUILTIN_ABS_1X32);
5425   def_builtin ("__builtin_bfin_norm_fr1x32", short_ftype_int,
5426                BFIN_BUILTIN_NORM_1X32);
5427   def_builtin ("__builtin_bfin_round_fr1x32", short_ftype_int,
5428                BFIN_BUILTIN_ROUND_1X32);
5429   def_builtin ("__builtin_bfin_mult_fr1x32", int_ftype_short_short,
5430                BFIN_BUILTIN_MULT_1X32);
5431   def_builtin ("__builtin_bfin_mult_fr1x32x32", int_ftype_int_int,
5432                BFIN_BUILTIN_MULT_1X32X32);
5433   def_builtin ("__builtin_bfin_mult_fr1x32x32NS", int_ftype_int_int,
5434                BFIN_BUILTIN_MULT_1X32X32NS);
5435
5436   /* Shifts.  */
5437   def_builtin ("__builtin_bfin_shl_fr1x16", short_ftype_int_int,
5438                BFIN_BUILTIN_SSASHIFT_1X16);
5439   def_builtin ("__builtin_bfin_shl_fr2x16", v2hi_ftype_v2hi_int,
5440                BFIN_BUILTIN_SSASHIFT_2X16);
5441   def_builtin ("__builtin_bfin_lshl_fr1x16", short_ftype_int_int,
5442                BFIN_BUILTIN_LSHIFT_1X16);
5443   def_builtin ("__builtin_bfin_lshl_fr2x16", v2hi_ftype_v2hi_int,
5444                BFIN_BUILTIN_LSHIFT_2X16);
5445   def_builtin ("__builtin_bfin_shl_fr1x32", int_ftype_int_int,
5446                BFIN_BUILTIN_SSASHIFT_1X32);
5447
5448   /* Complex numbers.  */
5449   def_builtin ("__builtin_bfin_cmplx_add", v2hi_ftype_v2hi_v2hi,
5450                BFIN_BUILTIN_SSADD_2X16);
5451   def_builtin ("__builtin_bfin_cmplx_sub", v2hi_ftype_v2hi_v2hi,
5452                BFIN_BUILTIN_SSSUB_2X16);
5453   def_builtin ("__builtin_bfin_cmplx_mul", v2hi_ftype_v2hi_v2hi,
5454                BFIN_BUILTIN_CPLX_MUL_16);
5455   def_builtin ("__builtin_bfin_cmplx_mac", v2hi_ftype_v2hi_v2hi_v2hi,
5456                BFIN_BUILTIN_CPLX_MAC_16);
5457   def_builtin ("__builtin_bfin_cmplx_msu", v2hi_ftype_v2hi_v2hi_v2hi,
5458                BFIN_BUILTIN_CPLX_MSU_16);
5459   def_builtin ("__builtin_bfin_cmplx_mul_s40", v2hi_ftype_v2hi_v2hi,
5460                BFIN_BUILTIN_CPLX_MUL_16_S40);
5461   def_builtin ("__builtin_bfin_cmplx_mac_s40", v2hi_ftype_v2hi_v2hi_v2hi,
5462                BFIN_BUILTIN_CPLX_MAC_16_S40);
5463   def_builtin ("__builtin_bfin_cmplx_msu_s40", v2hi_ftype_v2hi_v2hi_v2hi,
5464                BFIN_BUILTIN_CPLX_MSU_16_S40);
5465   def_builtin ("__builtin_bfin_csqu_fr16", v2hi_ftype_v2hi,
5466                BFIN_BUILTIN_CPLX_SQU);
5467
5468   /* "Unaligned" load.  */
5469   def_builtin ("__builtin_bfin_loadbytes", int_ftype_pint,
5470                BFIN_BUILTIN_LOADBYTES);
5471
5472 }
5473
5474
5475 struct builtin_description
5476 {
5477   const enum insn_code icode;
5478   const char *const name;
5479   const enum bfin_builtins code;
5480   int macflag;
5481 };
5482
5483 static const struct builtin_description bdesc_2arg[] =
5484 {
5485   { CODE_FOR_composev2hi, "__builtin_bfin_compose_2x16", BFIN_BUILTIN_COMPOSE_2X16, -1 },
5486
5487   { CODE_FOR_ssashiftv2hi3, "__builtin_bfin_shl_fr2x16", BFIN_BUILTIN_SSASHIFT_2X16, -1 },
5488   { CODE_FOR_ssashifthi3, "__builtin_bfin_shl_fr1x16", BFIN_BUILTIN_SSASHIFT_1X16, -1 },
5489   { CODE_FOR_lshiftv2hi3, "__builtin_bfin_lshl_fr2x16", BFIN_BUILTIN_LSHIFT_2X16, -1 },
5490   { CODE_FOR_lshifthi3, "__builtin_bfin_lshl_fr1x16", BFIN_BUILTIN_LSHIFT_1X16, -1 },
5491   { CODE_FOR_ssashiftsi3, "__builtin_bfin_shl_fr1x32", BFIN_BUILTIN_SSASHIFT_1X32, -1 },
5492
5493   { CODE_FOR_sminhi3, "__builtin_bfin_min_fr1x16", BFIN_BUILTIN_MIN_1X16, -1 },
5494   { CODE_FOR_smaxhi3, "__builtin_bfin_max_fr1x16", BFIN_BUILTIN_MAX_1X16, -1 },
5495   { CODE_FOR_ssaddhi3, "__builtin_bfin_add_fr1x16", BFIN_BUILTIN_SSADD_1X16, -1 },
5496   { CODE_FOR_sssubhi3, "__builtin_bfin_sub_fr1x16", BFIN_BUILTIN_SSSUB_1X16, -1 },
5497
5498   { CODE_FOR_sminsi3, "__builtin_bfin_min_fr1x32", BFIN_BUILTIN_MIN_1X32, -1 },
5499   { CODE_FOR_smaxsi3, "__builtin_bfin_max_fr1x32", BFIN_BUILTIN_MAX_1X32, -1 },
5500   { CODE_FOR_ssaddsi3, "__builtin_bfin_add_fr1x32", BFIN_BUILTIN_SSADD_1X32, -1 },
5501   { CODE_FOR_sssubsi3, "__builtin_bfin_sub_fr1x32", BFIN_BUILTIN_SSSUB_1X32, -1 },
5502
5503   { CODE_FOR_sminv2hi3, "__builtin_bfin_min_fr2x16", BFIN_BUILTIN_MIN_2X16, -1 },
5504   { CODE_FOR_smaxv2hi3, "__builtin_bfin_max_fr2x16", BFIN_BUILTIN_MAX_2X16, -1 },
5505   { CODE_FOR_ssaddv2hi3, "__builtin_bfin_add_fr2x16", BFIN_BUILTIN_SSADD_2X16, -1 },
5506   { CODE_FOR_sssubv2hi3, "__builtin_bfin_sub_fr2x16", BFIN_BUILTIN_SSSUB_2X16, -1 },
5507   { CODE_FOR_ssaddsubv2hi3, "__builtin_bfin_dspaddsubsat", BFIN_BUILTIN_SSADDSUB_2X16, -1 },
5508   { CODE_FOR_sssubaddv2hi3, "__builtin_bfin_dspsubaddsat", BFIN_BUILTIN_SSSUBADD_2X16, -1 },
5509
5510   { CODE_FOR_flag_mulhisi, "__builtin_bfin_mult_fr1x32", BFIN_BUILTIN_MULT_1X32, MACFLAG_NONE },
5511   { CODE_FOR_flag_mulhi, "__builtin_bfin_mult_fr1x16", BFIN_BUILTIN_MULT_1X16, MACFLAG_T },
5512   { CODE_FOR_flag_mulhi, "__builtin_bfin_multr_fr1x16", BFIN_BUILTIN_MULTR_1X16, MACFLAG_NONE },
5513   { CODE_FOR_flag_mulv2hi, "__builtin_bfin_mult_fr2x16", BFIN_BUILTIN_MULT_2X16, MACFLAG_T },
5514   { CODE_FOR_flag_mulv2hi, "__builtin_bfin_multr_fr2x16", BFIN_BUILTIN_MULTR_2X16, MACFLAG_NONE }
5515 };
5516
5517 static const struct builtin_description bdesc_1arg[] =
5518 {
5519   { CODE_FOR_loadbytes, "__builtin_bfin_loadbytes", BFIN_BUILTIN_LOADBYTES, 0 },
5520
5521   { CODE_FOR_ones, "__builtin_bfin_ones", BFIN_BUILTIN_ONES, 0 },
5522
5523   { CODE_FOR_signbitshi2, "__builtin_bfin_norm_fr1x16", BFIN_BUILTIN_NORM_1X16, 0 },
5524   { CODE_FOR_ssneghi2, "__builtin_bfin_negate_fr1x16", BFIN_BUILTIN_NEG_1X16, 0 },
5525   { CODE_FOR_abshi2, "__builtin_bfin_abs_fr1x16", BFIN_BUILTIN_ABS_1X16, 0 },
5526
5527   { CODE_FOR_signbitssi2, "__builtin_bfin_norm_fr1x32", BFIN_BUILTIN_NORM_1X32, 0 },
5528   { CODE_FOR_ssroundsi2, "__builtin_bfin_round_fr1x32", BFIN_BUILTIN_ROUND_1X32, 0 },
5529   { CODE_FOR_ssnegsi2, "__builtin_bfin_negate_fr1x32", BFIN_BUILTIN_NEG_1X32, 0 },
5530   { CODE_FOR_ssabssi2, "__builtin_bfin_abs_fr1x32", BFIN_BUILTIN_ABS_1X32, 0 },
5531
5532   { CODE_FOR_movv2hi_hi_low, "__builtin_bfin_extract_lo", BFIN_BUILTIN_EXTRACTLO, 0 },
5533   { CODE_FOR_movv2hi_hi_high, "__builtin_bfin_extract_hi", BFIN_BUILTIN_EXTRACTHI, 0 },
5534   { CODE_FOR_ssnegv2hi2, "__builtin_bfin_negate_fr2x16", BFIN_BUILTIN_NEG_2X16, 0 },
5535   { CODE_FOR_ssabsv2hi2, "__builtin_bfin_abs_fr2x16", BFIN_BUILTIN_ABS_2X16, 0 }
5536 };
5537
5538 /* Errors in the source file can cause expand_expr to return const0_rtx
5539    where we expect a vector.  To avoid crashing, use one of the vector
5540    clear instructions.  */
5541 static rtx
5542 safe_vector_operand (rtx x, enum machine_mode mode)
5543 {
5544   if (x != const0_rtx)
5545     return x;
5546   x = gen_reg_rtx (SImode);
5547
5548   emit_insn (gen_movsi (x, CONST0_RTX (SImode)));
5549   return gen_lowpart (mode, x);
5550 }
5551
5552 /* Subroutine of bfin_expand_builtin to take care of binop insns.  MACFLAG is -1
5553    if this is a normal binary op, or one of the MACFLAG_xxx constants.  */
5554
5555 static rtx
5556 bfin_expand_binop_builtin (enum insn_code icode, tree exp, rtx target,
5557                            int macflag)
5558 {
5559   rtx pat;
5560   tree arg0 = CALL_EXPR_ARG (exp, 0);
5561   tree arg1 = CALL_EXPR_ARG (exp, 1);
5562   rtx op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5563   rtx op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
5564   enum machine_mode op0mode = GET_MODE (op0);
5565   enum machine_mode op1mode = GET_MODE (op1);
5566   enum machine_mode tmode = insn_data[icode].operand[0].mode;
5567   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
5568   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
5569
5570   if (VECTOR_MODE_P (mode0))
5571     op0 = safe_vector_operand (op0, mode0);
5572   if (VECTOR_MODE_P (mode1))
5573     op1 = safe_vector_operand (op1, mode1);
5574
5575   if (! target
5576       || GET_MODE (target) != tmode
5577       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
5578     target = gen_reg_rtx (tmode);
5579
5580   if ((op0mode == SImode || op0mode == VOIDmode) && mode0 == HImode)
5581     {
5582       op0mode = HImode;
5583       op0 = gen_lowpart (HImode, op0);
5584     }
5585   if ((op1mode == SImode || op1mode == VOIDmode) && mode1 == HImode)
5586     {
5587       op1mode = HImode;
5588       op1 = gen_lowpart (HImode, op1);
5589     }
5590   /* In case the insn wants input operands in modes different from
5591      the result, abort.  */
5592   gcc_assert ((op0mode == mode0 || op0mode == VOIDmode)
5593               && (op1mode == mode1 || op1mode == VOIDmode));
5594
5595   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
5596     op0 = copy_to_mode_reg (mode0, op0);
5597   if (! (*insn_data[icode].operand[2].predicate) (op1, mode1))
5598     op1 = copy_to_mode_reg (mode1, op1);
5599
5600   if (macflag == -1)
5601     pat = GEN_FCN (icode) (target, op0, op1);
5602   else
5603     pat = GEN_FCN (icode) (target, op0, op1, GEN_INT (macflag));
5604   if (! pat)
5605     return 0;
5606
5607   emit_insn (pat);
5608   return target;
5609 }
5610
5611 /* Subroutine of bfin_expand_builtin to take care of unop insns.  */
5612
5613 static rtx
5614 bfin_expand_unop_builtin (enum insn_code icode, tree exp,
5615                           rtx target)
5616 {
5617   rtx pat;
5618   tree arg0 = CALL_EXPR_ARG (exp, 0);
5619   rtx op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5620   enum machine_mode op0mode = GET_MODE (op0);
5621   enum machine_mode tmode = insn_data[icode].operand[0].mode;
5622   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
5623
5624   if (! target
5625       || GET_MODE (target) != tmode
5626       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
5627     target = gen_reg_rtx (tmode);
5628
5629   if (VECTOR_MODE_P (mode0))
5630     op0 = safe_vector_operand (op0, mode0);
5631
5632   if (op0mode == SImode && mode0 == HImode)
5633     {
5634       op0mode = HImode;
5635       op0 = gen_lowpart (HImode, op0);
5636     }
5637   gcc_assert (op0mode == mode0 || op0mode == VOIDmode);
5638
5639   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
5640     op0 = copy_to_mode_reg (mode0, op0);
5641
5642   pat = GEN_FCN (icode) (target, op0);
5643   if (! pat)
5644     return 0;
5645   emit_insn (pat);
5646   return target;
5647 }
5648
5649 /* Expand an expression EXP that calls a built-in function,
5650    with result going to TARGET if that's convenient
5651    (and in mode MODE if that's convenient).
5652    SUBTARGET may be used as the target for computing one of EXP's operands.
5653    IGNORE is nonzero if the value is to be ignored.  */
5654
5655 static rtx
5656 bfin_expand_builtin (tree exp, rtx target ATTRIBUTE_UNUSED,
5657                      rtx subtarget ATTRIBUTE_UNUSED,
5658                      enum machine_mode mode ATTRIBUTE_UNUSED,
5659                      int ignore ATTRIBUTE_UNUSED)
5660 {
5661   size_t i;
5662   enum insn_code icode;
5663   const struct builtin_description *d;
5664   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
5665   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
5666   tree arg0, arg1, arg2;
5667   rtx op0, op1, op2, accvec, pat, tmp1, tmp2, a0reg, a1reg;
5668   enum machine_mode tmode, mode0;
5669
5670   switch (fcode)
5671     {
5672     case BFIN_BUILTIN_CSYNC:
5673       emit_insn (gen_csync ());
5674       return 0;
5675     case BFIN_BUILTIN_SSYNC:
5676       emit_insn (gen_ssync ());
5677       return 0;
5678
5679     case BFIN_BUILTIN_DIFFHL_2X16:
5680     case BFIN_BUILTIN_DIFFLH_2X16:
5681     case BFIN_BUILTIN_SUM_2X16:
5682       arg0 = CALL_EXPR_ARG (exp, 0);
5683       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5684       icode = (fcode == BFIN_BUILTIN_DIFFHL_2X16 ? CODE_FOR_subhilov2hi3
5685                : fcode == BFIN_BUILTIN_DIFFLH_2X16 ? CODE_FOR_sublohiv2hi3
5686                : CODE_FOR_ssaddhilov2hi3);
5687       tmode = insn_data[icode].operand[0].mode;
5688       mode0 = insn_data[icode].operand[1].mode;
5689
5690       if (! target
5691           || GET_MODE (target) != tmode
5692           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
5693         target = gen_reg_rtx (tmode);
5694
5695       if (VECTOR_MODE_P (mode0))
5696         op0 = safe_vector_operand (op0, mode0);
5697
5698       if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
5699         op0 = copy_to_mode_reg (mode0, op0);
5700
5701       pat = GEN_FCN (icode) (target, op0, op0);
5702       if (! pat)
5703         return 0;
5704       emit_insn (pat);
5705       return target;
5706
5707     case BFIN_BUILTIN_MULT_1X32X32:
5708     case BFIN_BUILTIN_MULT_1X32X32NS:
5709       arg0 = CALL_EXPR_ARG (exp, 0);
5710       arg1 = CALL_EXPR_ARG (exp, 1);
5711       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5712       op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
5713       if (! target
5714           || !register_operand (target, SImode))
5715         target = gen_reg_rtx (SImode);
5716
5717       a1reg = gen_rtx_REG (PDImode, REG_A1);
5718       a0reg = gen_rtx_REG (PDImode, REG_A0);
5719       tmp1 = gen_lowpart (V2HImode, op0);
5720       tmp2 = gen_lowpart (V2HImode, op1);
5721       emit_insn (gen_flag_macinit1hi (a1reg,
5722                                       gen_lowpart (HImode, op0),
5723                                       gen_lowpart (HImode, op1),
5724                                       GEN_INT (MACFLAG_FU)));
5725       emit_insn (gen_lshrpdi3 (a1reg, a1reg, GEN_INT (16)));
5726
5727       if (fcode == BFIN_BUILTIN_MULT_1X32X32)
5728         emit_insn (gen_flag_mul_macv2hi_parts_acconly (a0reg, a1reg, tmp1, tmp2,
5729                                                        const1_rtx, const1_rtx,
5730                                                        const1_rtx, const0_rtx, a1reg,
5731                                                        const0_rtx, GEN_INT (MACFLAG_NONE),
5732                                                        GEN_INT (MACFLAG_M)));
5733       else
5734         {
5735           /* For saturating multiplication, there's exactly one special case
5736              to be handled: multiplying the smallest negative value with
5737              itself.  Due to shift correction in fractional multiplies, this
5738              can overflow.  Iff this happens, OP2 will contain 1, which, when
5739              added in 32 bits to the smallest negative, wraps to the largest
5740              positive, which is the result we want.  */
5741           op2 = gen_reg_rtx (V2HImode);
5742           emit_insn (gen_packv2hi (op2, tmp1, tmp2, const0_rtx, const0_rtx));
5743           emit_insn (gen_movsibi (gen_rtx_REG (BImode, REG_CC),
5744                                   gen_lowpart (SImode, op2)));
5745           emit_insn (gen_flag_mul_macv2hi_parts_acconly_andcc0 (a0reg, a1reg, tmp1, tmp2,
5746                                                                 const1_rtx, const1_rtx,
5747                                                                 const1_rtx, const0_rtx, a1reg,
5748                                                                 const0_rtx, GEN_INT (MACFLAG_NONE),
5749                                                                 GEN_INT (MACFLAG_M)));
5750           op2 = gen_reg_rtx (SImode);
5751           emit_insn (gen_movbisi (op2, gen_rtx_REG (BImode, REG_CC)));
5752         }
5753       emit_insn (gen_flag_machi_parts_acconly (a1reg, tmp2, tmp1,
5754                                                const1_rtx, const0_rtx,
5755                                                a1reg, const0_rtx, GEN_INT (MACFLAG_M)));
5756       emit_insn (gen_ashrpdi3 (a1reg, a1reg, GEN_INT (15)));
5757       emit_insn (gen_sum_of_accumulators (target, a0reg, a0reg, a1reg));
5758       if (fcode == BFIN_BUILTIN_MULT_1X32X32NS)
5759         emit_insn (gen_addsi3 (target, target, op2));
5760       return target;
5761
5762     case BFIN_BUILTIN_CPLX_MUL_16:
5763     case BFIN_BUILTIN_CPLX_MUL_16_S40:
5764       arg0 = CALL_EXPR_ARG (exp, 0);
5765       arg1 = CALL_EXPR_ARG (exp, 1);
5766       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5767       op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
5768       accvec = gen_reg_rtx (V2PDImode);
5769
5770       if (! target
5771           || GET_MODE (target) != V2HImode
5772           || ! (*insn_data[icode].operand[0].predicate) (target, V2HImode))
5773         target = gen_reg_rtx (tmode);
5774       if (! register_operand (op0, GET_MODE (op0)))
5775         op0 = copy_to_mode_reg (GET_MODE (op0), op0);
5776       if (! register_operand (op1, GET_MODE (op1)))
5777         op1 = copy_to_mode_reg (GET_MODE (op1), op1);
5778
5779       if (fcode == BFIN_BUILTIN_CPLX_MUL_16)
5780         emit_insn (gen_flag_macinit1v2hi_parts (accvec, op0, op1, const0_rtx,
5781                                                 const0_rtx, const0_rtx,
5782                                                 const1_rtx, GEN_INT (MACFLAG_W32)));
5783       else
5784         emit_insn (gen_flag_macinit1v2hi_parts (accvec, op0, op1, const0_rtx,
5785                                                 const0_rtx, const0_rtx,
5786                                                 const1_rtx, GEN_INT (MACFLAG_NONE)));
5787       emit_insn (gen_flag_macv2hi_parts (target, op0, op1, const1_rtx,
5788                                          const1_rtx, const1_rtx,
5789                                          const0_rtx, accvec, const1_rtx, const0_rtx,
5790                                          GEN_INT (MACFLAG_NONE), accvec));
5791
5792       return target;
5793
5794     case BFIN_BUILTIN_CPLX_MAC_16:
5795     case BFIN_BUILTIN_CPLX_MSU_16:
5796     case BFIN_BUILTIN_CPLX_MAC_16_S40:
5797     case BFIN_BUILTIN_CPLX_MSU_16_S40:
5798       arg0 = CALL_EXPR_ARG (exp, 0);
5799       arg1 = CALL_EXPR_ARG (exp, 1);
5800       arg2 = CALL_EXPR_ARG (exp, 2);
5801       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5802       op1 = expand_expr (arg1, NULL_RTX, VOIDmode, 0);
5803       op2 = expand_expr (arg2, NULL_RTX, VOIDmode, 0);
5804       accvec = gen_reg_rtx (V2PDImode);
5805
5806       if (! target
5807           || GET_MODE (target) != V2HImode
5808           || ! (*insn_data[icode].operand[0].predicate) (target, V2HImode))
5809         target = gen_reg_rtx (tmode);
5810       if (! register_operand (op1, GET_MODE (op1)))
5811         op1 = copy_to_mode_reg (GET_MODE (op1), op1);
5812       if (! register_operand (op2, GET_MODE (op2)))
5813         op2 = copy_to_mode_reg (GET_MODE (op2), op2);
5814
5815       tmp1 = gen_reg_rtx (SImode);
5816       tmp2 = gen_reg_rtx (SImode);
5817       emit_insn (gen_ashlsi3 (tmp1, gen_lowpart (SImode, op0), GEN_INT (16)));
5818       emit_move_insn (tmp2, gen_lowpart (SImode, op0));
5819       emit_insn (gen_movstricthi_1 (gen_lowpart (HImode, tmp2), const0_rtx));
5820       emit_insn (gen_load_accumulator_pair (accvec, tmp1, tmp2));
5821       if (fcode == BFIN_BUILTIN_CPLX_MAC_16
5822           || fcode == BFIN_BUILTIN_CPLX_MSU_16)
5823         emit_insn (gen_flag_macv2hi_parts_acconly (accvec, op1, op2, const0_rtx,
5824                                                    const0_rtx, const0_rtx,
5825                                                    const1_rtx, accvec, const0_rtx,
5826                                                    const0_rtx,
5827                                                    GEN_INT (MACFLAG_W32)));
5828       else
5829         emit_insn (gen_flag_macv2hi_parts_acconly (accvec, op1, op2, const0_rtx,
5830                                                    const0_rtx, const0_rtx,
5831                                                    const1_rtx, accvec, const0_rtx,
5832                                                    const0_rtx,
5833                                                    GEN_INT (MACFLAG_NONE)));
5834       if (fcode == BFIN_BUILTIN_CPLX_MAC_16
5835           || fcode == BFIN_BUILTIN_CPLX_MAC_16_S40)
5836         {
5837           tmp1 = const1_rtx;
5838           tmp2 = const0_rtx;
5839         }
5840       else
5841         {
5842           tmp1 = const0_rtx;
5843           tmp2 = const1_rtx;
5844         }
5845       emit_insn (gen_flag_macv2hi_parts (target, op1, op2, const1_rtx,
5846                                          const1_rtx, const1_rtx,
5847                                          const0_rtx, accvec, tmp1, tmp2,
5848                                          GEN_INT (MACFLAG_NONE), accvec));
5849
5850       return target;
5851
5852     case BFIN_BUILTIN_CPLX_SQU:
5853       arg0 = CALL_EXPR_ARG (exp, 0);
5854       op0 = expand_expr (arg0, NULL_RTX, VOIDmode, 0);
5855       accvec = gen_reg_rtx (V2PDImode);
5856       icode = CODE_FOR_flag_mulv2hi;
5857       tmp1 = gen_reg_rtx (V2HImode);
5858       tmp2 = gen_reg_rtx (V2HImode);
5859
5860       if (! target
5861           || GET_MODE (target) != V2HImode
5862           || ! (*insn_data[icode].operand[0].predicate) (target, V2HImode))
5863         target = gen_reg_rtx (V2HImode);
5864       if (! register_operand (op0, GET_MODE (op0)))
5865         op0 = copy_to_mode_reg (GET_MODE (op0), op0);
5866
5867       emit_insn (gen_flag_mulv2hi (tmp1, op0, op0, GEN_INT (MACFLAG_NONE)));
5868
5869       emit_insn (gen_flag_mulhi_parts (tmp2, op0, op0, const0_rtx,
5870                                        const0_rtx, const1_rtx,
5871                                        GEN_INT (MACFLAG_NONE)));
5872
5873       emit_insn (gen_ssaddhi3_parts (target, tmp2, tmp2, const1_rtx,
5874                                           const0_rtx, const0_rtx));
5875
5876       emit_insn (gen_sssubhi3_parts (target, tmp1, tmp1, const0_rtx,
5877                                           const0_rtx, const1_rtx));
5878
5879       return target;
5880
5881     default:
5882       break;
5883     }
5884
5885   for (i = 0, d = bdesc_2arg; i < ARRAY_SIZE (bdesc_2arg); i++, d++)
5886     if (d->code == fcode)
5887       return bfin_expand_binop_builtin (d->icode, exp, target,
5888                                         d->macflag);
5889
5890   for (i = 0, d = bdesc_1arg; i < ARRAY_SIZE (bdesc_1arg); i++, d++)
5891     if (d->code == fcode)
5892       return bfin_expand_unop_builtin (d->icode, exp, target);
5893
5894   gcc_unreachable ();
5895 }
5896 \f
5897 #undef TARGET_INIT_BUILTINS
5898 #define TARGET_INIT_BUILTINS bfin_init_builtins
5899
5900 #undef TARGET_EXPAND_BUILTIN
5901 #define TARGET_EXPAND_BUILTIN bfin_expand_builtin
5902
5903 #undef TARGET_ASM_GLOBALIZE_LABEL
5904 #define TARGET_ASM_GLOBALIZE_LABEL bfin_globalize_label
5905
5906 #undef TARGET_ASM_FILE_START
5907 #define TARGET_ASM_FILE_START output_file_start
5908
5909 #undef TARGET_ATTRIBUTE_TABLE
5910 #define TARGET_ATTRIBUTE_TABLE bfin_attribute_table
5911
5912 #undef TARGET_COMP_TYPE_ATTRIBUTES
5913 #define TARGET_COMP_TYPE_ATTRIBUTES bfin_comp_type_attributes
5914
5915 #undef TARGET_RTX_COSTS
5916 #define TARGET_RTX_COSTS bfin_rtx_costs
5917
5918 #undef  TARGET_ADDRESS_COST
5919 #define TARGET_ADDRESS_COST bfin_address_cost
5920
5921 #undef  TARGET_ASM_INTEGER
5922 #define TARGET_ASM_INTEGER bfin_assemble_integer
5923
5924 #undef TARGET_MACHINE_DEPENDENT_REORG
5925 #define TARGET_MACHINE_DEPENDENT_REORG bfin_reorg
5926
5927 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
5928 #define TARGET_FUNCTION_OK_FOR_SIBCALL bfin_function_ok_for_sibcall
5929
5930 #undef TARGET_ASM_OUTPUT_MI_THUNK
5931 #define TARGET_ASM_OUTPUT_MI_THUNK bfin_output_mi_thunk
5932 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
5933 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
5934
5935 #undef TARGET_SCHED_ADJUST_COST
5936 #define TARGET_SCHED_ADJUST_COST bfin_adjust_cost
5937
5938 #undef TARGET_SCHED_ISSUE_RATE
5939 #define TARGET_SCHED_ISSUE_RATE bfin_issue_rate
5940
5941 #undef TARGET_PROMOTE_PROTOTYPES
5942 #define TARGET_PROMOTE_PROTOTYPES hook_bool_const_tree_true
5943 #undef TARGET_PROMOTE_FUNCTION_ARGS
5944 #define TARGET_PROMOTE_FUNCTION_ARGS hook_bool_const_tree_true
5945 #undef TARGET_PROMOTE_FUNCTION_RETURN
5946 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_const_tree_true
5947
5948 #undef TARGET_ARG_PARTIAL_BYTES
5949 #define TARGET_ARG_PARTIAL_BYTES bfin_arg_partial_bytes
5950
5951 #undef TARGET_PASS_BY_REFERENCE
5952 #define TARGET_PASS_BY_REFERENCE bfin_pass_by_reference
5953
5954 #undef TARGET_SETUP_INCOMING_VARARGS
5955 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
5956
5957 #undef TARGET_STRUCT_VALUE_RTX
5958 #define TARGET_STRUCT_VALUE_RTX bfin_struct_value_rtx
5959
5960 #undef TARGET_VECTOR_MODE_SUPPORTED_P
5961 #define TARGET_VECTOR_MODE_SUPPORTED_P bfin_vector_mode_supported_p
5962
5963 #undef TARGET_HANDLE_OPTION
5964 #define TARGET_HANDLE_OPTION bfin_handle_option
5965
5966 #undef TARGET_DEFAULT_TARGET_FLAGS
5967 #define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
5968
5969 #undef TARGET_SECONDARY_RELOAD
5970 #define TARGET_SECONDARY_RELOAD bfin_secondary_reload
5971
5972 #undef TARGET_DELEGITIMIZE_ADDRESS
5973 #define TARGET_DELEGITIMIZE_ADDRESS bfin_delegitimize_address
5974
5975 #undef TARGET_CANNOT_FORCE_CONST_MEM
5976 #define TARGET_CANNOT_FORCE_CONST_MEM bfin_cannot_force_const_mem
5977
5978 #undef TARGET_RETURN_IN_MEMORY
5979 #define TARGET_RETURN_IN_MEMORY bfin_return_in_memory
5980
5981 struct gcc_target targetm = TARGET_INITIALIZER;