gcc/config/rs6000/rs6000.c

   1 /* Subroutines used for code generation on IBM RS/6000.
   2    Copyright (C) 1991, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010, 2011
   4    Free Software Foundation, Inc.
   5    Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
   6
   7    This file is part of GCC.
   8
   9    GCC is free software; you can redistribute it and/or modify it
  10    under the terms of the GNU General Public License as published
  11    by the Free Software Foundation; either version 3, or (at your
  12    option) any later version.
  13
  14    GCC is distributed in the hope that it will be useful, but WITHOUT
  15    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
  16    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
  17    License for more details.
  18
  19    You should have received a copy of the GNU General Public License
  20    along with GCC; see the file COPYING3.  If not see
  21    <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "rtl.h"
  28 #include "regs.h"
  29 #include "hard-reg-set.h"
  30 #include "insn-config.h"
  31 #include "conditions.h"
  32 #include "insn-attr.h"
  33 #include "flags.h"
  34 #include "recog.h"
  35 #include "obstack.h"
  36 #include "tree.h"
  37 #include "expr.h"
  38 #include "optabs.h"
  39 #include "except.h"
  40 #include "function.h"
  41 #include "output.h"
  42 #include "basic-block.h"
  43 #include "integrate.h"
  44 #include "diagnostic-core.h"
  45 #include "toplev.h"
  46 #include "ggc.h"
  47 #include "hashtab.h"
  48 #include "tm_p.h"
  49 #include "target.h"
  50 #include "target-def.h"
  51 #include "common/common-target.h"
  52 #include "langhooks.h"
  53 #include "reload.h"
  54 #include "cfglayout.h"
  55 #include "cfgloop.h"
  56 #include "sched-int.h"
  57 #include "gimple.h"
  58 #include "tree-flow.h"
  59 #include "intl.h"
  60 #include "params.h"
  61 #include "tm-constrs.h"
  62 #include "opts.h"
  63 #if TARGET_XCOFF
  64 #include "xcoffout.h"  /* get declarations of xcoff_*_section_name */
  65 #endif
  66 #if TARGET_MACHO
  67 #include "gstab.h"  /* for N_SLINE */
  68 #endif
  69
  70 #ifndef TARGET_NO_PROTOTYPE
  71 #define TARGET_NO_PROTOTYPE 0
  72 #endif
  73
  74 #define min(A,B)        ((A) < (B) ? (A) : (B))
  75 #define max(A,B)        ((A) > (B) ? (A) : (B))
  76
  77 /* Structure used to define the rs6000 stack */
  78 typedef struct rs6000_stack {
  79   int reload_completed;         /* stack info won't change from here on */
  80   int first_gp_reg_save;        /* first callee saved GP register used */
  81   int first_fp_reg_save;        /* first callee saved FP register used */
  82   int first_altivec_reg_save;   /* first callee saved AltiVec register used */
  83   int lr_save_p;                /* true if the link reg needs to be saved */
  84   int cr_save_p;                /* true if the CR reg needs to be saved */
  85   unsigned int vrsave_mask;     /* mask of vec registers to save */
  86   int push_p;                   /* true if we need to allocate stack space */
  87   int calls_p;                  /* true if the function makes any calls */
  88   int world_save_p;             /* true if we're saving *everything*:
  89                                    r13-r31, cr, f14-f31, vrsave, v20-v31  */
  90   enum rs6000_abi abi;          /* which ABI to use */
  91   int gp_save_offset;           /* offset to save GP regs from initial SP */
  92   int fp_save_offset;           /* offset to save FP regs from initial SP */
  93   int altivec_save_offset;      /* offset to save AltiVec regs from initial SP */
  94   int lr_save_offset;           /* offset to save LR from initial SP */
  95   int cr_save_offset;           /* offset to save CR from initial SP */
  96   int vrsave_save_offset;       /* offset to save VRSAVE from initial SP */
  97   int spe_gp_save_offset;       /* offset to save spe 64-bit gprs  */
  98   int varargs_save_offset;      /* offset to save the varargs registers */
  99   int ehrd_offset;              /* offset to EH return data */
 100   int reg_size;                 /* register size (4 or 8) */
 101   HOST_WIDE_INT vars_size;      /* variable save area size */
 102   int parm_size;                /* outgoing parameter size */
 103   int save_size;                /* save area size */
 104   int fixed_size;               /* fixed size of stack frame */
 105   int gp_size;                  /* size of saved GP registers */
 106   int fp_size;                  /* size of saved FP registers */
 107   int altivec_size;             /* size of saved AltiVec registers */
 108   int cr_size;                  /* size to hold CR if not in save_size */
 109   int vrsave_size;              /* size to hold VRSAVE if not in save_size */
 110   int altivec_padding_size;     /* size of altivec alignment padding if
 111                                    not in save_size */
 112   int spe_gp_size;              /* size of 64-bit GPR save size for SPE */
 113   int spe_padding_size;
 114   HOST_WIDE_INT total_size;     /* total bytes allocated for stack */
 115   int spe_64bit_regs_used;
 116   int savres_strategy;
 117 } rs6000_stack_t;
 118
 119 /* A C structure for machine-specific, per-function data.
 120    This is added to the cfun structure.  */
 121 typedef struct GTY(()) machine_function
 122 {
 123   /* Some local-dynamic symbol.  */
 124   const char *some_ld_name;
 125   /* Whether the instruction chain has been scanned already.  */
 126   int insn_chain_scanned_p;
 127   /* Flags if __builtin_return_address (n) with n >= 1 was used.  */
 128   int ra_needs_full_frame;
 129   /* Flags if __builtin_return_address (0) was used.  */
 130   int ra_need_lr;
 131   /* Cache lr_save_p after expansion of builtin_eh_return.  */
 132   int lr_save_state;
 133   /* Whether we need to save the TOC to the reserved stack location in the
 134      function prologue.  */
 135   bool save_toc_in_prologue;
 136   /* Offset from virtual_stack_vars_rtx to the start of the ABI_V4
 137      varargs save area.  */
 138   HOST_WIDE_INT varargs_save_offset;
 139   /* Temporary stack slot to use for SDmode copies.  This slot is
 140      64-bits wide and is allocated early enough so that the offset
 141      does not overflow the 16-bit load/store offset field.  */
 142   rtx sdmode_stack_slot;
 143 } machine_function;
 144
 145 /* Support targetm.vectorize.builtin_mask_for_load.  */
 146 static GTY(()) tree altivec_builtin_mask_for_load;
 147
 148 /* Set to nonzero once AIX common-mode calls have been defined.  */
 149 static GTY(()) int common_mode_defined;
 150
 151 /* Label number of label created for -mrelocatable, to call to so we can
 152    get the address of the GOT section */
 153 static int rs6000_pic_labelno;
 154
 155 #ifdef USING_ELFOS_H
 156 /* Counter for labels which are to be placed in .fixup.  */
 157 int fixuplabelno = 0;
 158 #endif
 159
 160 /* Whether to use variant of AIX ABI for PowerPC64 Linux.  */
 161 int dot_symbols;
 162
 163 /* Specify the machine mode that pointers have.  After generation of rtl, the
 164    compiler makes no further distinction between pointers and any other objects
 165    of this machine mode.  The type is unsigned since not all things that
 166    include rs6000.h also include machmode.h.  */
 167 unsigned rs6000_pmode;
 168
 169 /* Width in bits of a pointer.  */
 170 unsigned rs6000_pointer_size;
 171
 172 #ifdef HAVE_AS_GNU_ATTRIBUTE
 173 /* Flag whether floating point values have been passed/returned.  */
 174 static bool rs6000_passes_float;
 175 /* Flag whether vector values have been passed/returned.  */
 176 static bool rs6000_passes_vector;
 177 /* Flag whether small (<= 8 byte) structures have been returned.  */
 178 static bool rs6000_returns_struct;
 179 #endif
 180
 181 /* Value is TRUE if register/mode pair is acceptable.  */
 182 bool rs6000_hard_regno_mode_ok_p[NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
 183
 184 /* Maximum number of registers needed for a given register class and mode.  */
 185 unsigned char rs6000_class_max_nregs[NUM_MACHINE_MODES][LIM_REG_CLASSES];
 186
 187 /* How many registers are needed for a given register and mode.  */
 188 unsigned char rs6000_hard_regno_nregs[NUM_MACHINE_MODES][FIRST_PSEUDO_REGISTER];
 189
 190 /* Map register number to register class.  */
 191 enum reg_class rs6000_regno_regclass[FIRST_PSEUDO_REGISTER];
 192
 193 /* Reload functions based on the type and the vector unit.  */
 194 static enum insn_code rs6000_vector_reload[NUM_MACHINE_MODES][2];
 195
 196 static int dbg_cost_ctrl;
 197
 198 /* Built in types.  */
 199 tree rs6000_builtin_types[RS6000_BTI_MAX];
 200 tree rs6000_builtin_decls[RS6000_BUILTIN_COUNT];
 201
 202 /* Flag to say the TOC is initialized */
 203 int toc_initialized;
 204 char toc_label_name[10];
 205
 206 /* Cached value of rs6000_variable_issue. This is cached in
 207    rs6000_variable_issue hook and returned from rs6000_sched_reorder2.  */
 208 static short cached_can_issue_more;
 209
 210 static GTY(()) section *read_only_data_section;
 211 static GTY(()) section *private_data_section;
 212 static GTY(()) section *read_only_private_data_section;
 213 static GTY(()) section *sdata2_section;
 214 static GTY(()) section *toc_section;
 215
 216 struct builtin_description
 217 {
 218   /* mask is not const because we're going to alter it below.  This
 219      nonsense will go away when we rewrite the -march infrastructure
 220      to give us more target flag bits.  */
 221   unsigned int mask;
 222   const enum insn_code icode;
 223   const char *const name;
 224   const enum rs6000_builtins code;
 225 };
 226
 227 /* Describe the vector unit used for modes.  */
 228 enum rs6000_vector rs6000_vector_unit[NUM_MACHINE_MODES];
 229 enum rs6000_vector rs6000_vector_mem[NUM_MACHINE_MODES];
 230
 231 /* Register classes for various constraints that are based on the target
 232    switches.  */
 233 enum reg_class rs6000_constraints[RS6000_CONSTRAINT_MAX];
 234
 235 /* Describe the alignment of a vector.  */
 236 int rs6000_vector_align[NUM_MACHINE_MODES];
 237
 238 /* Map selected modes to types for builtins.  */
 239 static GTY(()) tree builtin_mode_to_type[MAX_MACHINE_MODE][2];
 240
 241 /* What modes to automatically generate reciprocal divide estimate (fre) and
 242    reciprocal sqrt (frsqrte) for.  */
 243 unsigned char rs6000_recip_bits[MAX_MACHINE_MODE];
 244
 245 /* Masks to determine which reciprocal esitmate instructions to generate
 246    automatically.  */
 247 enum rs6000_recip_mask {
 248   RECIP_SF_DIV          = 0x001,        /* Use divide estimate */
 249   RECIP_DF_DIV          = 0x002,
 250   RECIP_V4SF_DIV        = 0x004,
 251   RECIP_V2DF_DIV        = 0x008,
 252
 253   RECIP_SF_RSQRT        = 0x010,        /* Use reciprocal sqrt estimate.  */
 254   RECIP_DF_RSQRT        = 0x020,
 255   RECIP_V4SF_RSQRT      = 0x040,
 256   RECIP_V2DF_RSQRT      = 0x080,
 257
 258   /* Various combination of flags for -mrecip=xxx.  */
 259   RECIP_NONE            = 0,
 260   RECIP_ALL             = (RECIP_SF_DIV | RECIP_DF_DIV | RECIP_V4SF_DIV
 261                            | RECIP_V2DF_DIV | RECIP_SF_RSQRT | RECIP_DF_RSQRT
 262                            | RECIP_V4SF_RSQRT | RECIP_V2DF_RSQRT),
 263
 264   RECIP_HIGH_PRECISION  = RECIP_ALL,
 265
 266   /* On low precision machines like the power5, don't enable double precision
 267      reciprocal square root estimate, since it isn't accurate enough.  */
 268   RECIP_LOW_PRECISION   = (RECIP_ALL & ~(RECIP_DF_RSQRT | RECIP_V2DF_RSQRT))
 269 };
 270
 271 /* -mrecip options.  */
 272 static struct
 273 {
 274   const char *string;           /* option name */
 275   unsigned int mask;            /* mask bits to set */
 276 } recip_options[] = {
 277   { "all",       RECIP_ALL },
 278   { "none",      RECIP_NONE },
 279   { "div",       (RECIP_SF_DIV | RECIP_DF_DIV | RECIP_V4SF_DIV
 280                   | RECIP_V2DF_DIV) },
 281   { "divf",      (RECIP_SF_DIV | RECIP_V4SF_DIV) },
 282   { "divd",      (RECIP_DF_DIV | RECIP_V2DF_DIV) },
 283   { "rsqrt",     (RECIP_SF_RSQRT | RECIP_DF_RSQRT | RECIP_V4SF_RSQRT
 284                   | RECIP_V2DF_RSQRT) },
 285   { "rsqrtf",    (RECIP_SF_RSQRT | RECIP_V4SF_RSQRT) },
 286   { "rsqrtd",    (RECIP_DF_RSQRT | RECIP_V2DF_RSQRT) },
 287 };
 288
 289 /* 2 argument gen function typedef.  */
 290 typedef rtx (*gen_2arg_fn_t) (rtx, rtx, rtx);
 291
 292 \f
 293 /* Target cpu costs.  */
 294
 295 struct processor_costs {
 296   const int mulsi;        /* cost of SImode multiplication.  */
 297   const int mulsi_const;  /* cost of SImode multiplication by constant.  */
 298   const int mulsi_const9; /* cost of SImode mult by short constant.  */
 299   const int muldi;        /* cost of DImode multiplication.  */
 300   const int divsi;        /* cost of SImode division.  */
 301   const int divdi;        /* cost of DImode division.  */
 302   const int fp;           /* cost of simple SFmode and DFmode insns.  */
 303   const int dmul;         /* cost of DFmode multiplication (and fmadd).  */
 304   const int sdiv;         /* cost of SFmode division (fdivs).  */
 305   const int ddiv;         /* cost of DFmode division (fdiv).  */
 306   const int cache_line_size;    /* cache line size in bytes. */
 307   const int l1_cache_size;      /* size of l1 cache, in kilobytes.  */
 308   const int l2_cache_size;      /* size of l2 cache, in kilobytes.  */
 309   const int simultaneous_prefetches; /* number of parallel prefetch
 310                                         operations.  */
 311 };
 312
 313 const struct processor_costs *rs6000_cost;
 314
 315 /* Processor costs (relative to an add) */
 316
 317 /* Instruction size costs on 32bit processors.  */
 318 static const
 319 struct processor_costs size32_cost = {
 320   COSTS_N_INSNS (1),    /* mulsi */
 321   COSTS_N_INSNS (1),    /* mulsi_const */
 322   COSTS_N_INSNS (1),    /* mulsi_const9 */
 323   COSTS_N_INSNS (1),    /* muldi */
 324   COSTS_N_INSNS (1),    /* divsi */
 325   COSTS_N_INSNS (1),    /* divdi */
 326   COSTS_N_INSNS (1),    /* fp */
 327   COSTS_N_INSNS (1),    /* dmul */
 328   COSTS_N_INSNS (1),    /* sdiv */
 329   COSTS_N_INSNS (1),    /* ddiv */
 330   32,
 331   0,
 332   0,
 333   0,
 334 };
 335
 336 /* Instruction size costs on 64bit processors.  */
 337 static const
 338 struct processor_costs size64_cost = {
 339   COSTS_N_INSNS (1),    /* mulsi */
 340   COSTS_N_INSNS (1),    /* mulsi_const */
 341   COSTS_N_INSNS (1),    /* mulsi_const9 */
 342   COSTS_N_INSNS (1),    /* muldi */
 343   COSTS_N_INSNS (1),    /* divsi */
 344   COSTS_N_INSNS (1),    /* divdi */
 345   COSTS_N_INSNS (1),    /* fp */
 346   COSTS_N_INSNS (1),    /* dmul */
 347   COSTS_N_INSNS (1),    /* sdiv */
 348   COSTS_N_INSNS (1),    /* ddiv */
 349   128,
 350   0,
 351   0,
 352   0,
 353 };
 354
 355 /* Instruction costs on RIOS1 processors.  */
 356 static const
 357 struct processor_costs rios1_cost = {
 358   COSTS_N_INSNS (5),    /* mulsi */
 359   COSTS_N_INSNS (4),    /* mulsi_const */
 360   COSTS_N_INSNS (3),    /* mulsi_const9 */
 361   COSTS_N_INSNS (5),    /* muldi */
 362   COSTS_N_INSNS (19),   /* divsi */
 363   COSTS_N_INSNS (19),   /* divdi */
 364   COSTS_N_INSNS (2),    /* fp */
 365   COSTS_N_INSNS (2),    /* dmul */
 366   COSTS_N_INSNS (19),   /* sdiv */
 367   COSTS_N_INSNS (19),   /* ddiv */
 368   128,                  /* cache line size */
 369   64,                   /* l1 cache */
 370   512,                  /* l2 cache */
 371   0,                    /* streams */
 372 };
 373
 374 /* Instruction costs on RIOS2 processors.  */
 375 static const
 376 struct processor_costs rios2_cost = {
 377   COSTS_N_INSNS (2),    /* mulsi */
 378   COSTS_N_INSNS (2),    /* mulsi_const */
 379   COSTS_N_INSNS (2),    /* mulsi_const9 */
 380   COSTS_N_INSNS (2),    /* muldi */
 381   COSTS_N_INSNS (13),   /* divsi */
 382   COSTS_N_INSNS (13),   /* divdi */
 383   COSTS_N_INSNS (2),    /* fp */
 384   COSTS_N_INSNS (2),    /* dmul */
 385   COSTS_N_INSNS (17),   /* sdiv */
 386   COSTS_N_INSNS (17),   /* ddiv */
 387   256,                  /* cache line size */
 388   256,                  /* l1 cache */
 389   1024,                 /* l2 cache */
 390   0,                    /* streams */
 391 };
 392
 393 /* Instruction costs on RS64A processors.  */
 394 static const
 395 struct processor_costs rs64a_cost = {
 396   COSTS_N_INSNS (20),   /* mulsi */
 397   COSTS_N_INSNS (12),   /* mulsi_const */
 398   COSTS_N_INSNS (8),    /* mulsi_const9 */
 399   COSTS_N_INSNS (34),   /* muldi */
 400   COSTS_N_INSNS (65),   /* divsi */
 401   COSTS_N_INSNS (67),   /* divdi */
 402   COSTS_N_INSNS (4),    /* fp */
 403   COSTS_N_INSNS (4),    /* dmul */
 404   COSTS_N_INSNS (31),   /* sdiv */
 405   COSTS_N_INSNS (31),   /* ddiv */
 406   128,                  /* cache line size */
 407   128,                  /* l1 cache */
 408   2048,                 /* l2 cache */
 409   1,                    /* streams */
 410 };
 411
 412 /* Instruction costs on MPCCORE processors.  */
 413 static const
 414 struct processor_costs mpccore_cost = {
 415   COSTS_N_INSNS (2),    /* mulsi */
 416   COSTS_N_INSNS (2),    /* mulsi_const */
 417   COSTS_N_INSNS (2),    /* mulsi_const9 */
 418   COSTS_N_INSNS (2),    /* muldi */
 419   COSTS_N_INSNS (6),    /* divsi */
 420   COSTS_N_INSNS (6),    /* divdi */
 421   COSTS_N_INSNS (4),    /* fp */
 422   COSTS_N_INSNS (5),    /* dmul */
 423   COSTS_N_INSNS (10),   /* sdiv */
 424   COSTS_N_INSNS (17),   /* ddiv */
 425   32,                   /* cache line size */
 426   4,                    /* l1 cache */
 427   16,                   /* l2 cache */
 428   1,                    /* streams */
 429 };
 430
 431 /* Instruction costs on PPC403 processors.  */
 432 static const
 433 struct processor_costs ppc403_cost = {
 434   COSTS_N_INSNS (4),    /* mulsi */
 435   COSTS_N_INSNS (4),    /* mulsi_const */
 436   COSTS_N_INSNS (4),    /* mulsi_const9 */
 437   COSTS_N_INSNS (4),    /* muldi */
 438   COSTS_N_INSNS (33),   /* divsi */
 439   COSTS_N_INSNS (33),   /* divdi */
 440   COSTS_N_INSNS (11),   /* fp */
 441   COSTS_N_INSNS (11),   /* dmul */
 442   COSTS_N_INSNS (11),   /* sdiv */
 443   COSTS_N_INSNS (11),   /* ddiv */
 444   32,                   /* cache line size */
 445   4,                    /* l1 cache */
 446   16,                   /* l2 cache */
 447   1,                    /* streams */
 448 };
 449
 450 /* Instruction costs on PPC405 processors.  */
 451 static const
 452 struct processor_costs ppc405_cost = {
 453   COSTS_N_INSNS (5),    /* mulsi */
 454   COSTS_N_INSNS (4),    /* mulsi_const */
 455   COSTS_N_INSNS (3),    /* mulsi_const9 */
 456   COSTS_N_INSNS (5),    /* muldi */
 457   COSTS_N_INSNS (35),   /* divsi */
 458   COSTS_N_INSNS (35),   /* divdi */
 459   COSTS_N_INSNS (11),   /* fp */
 460   COSTS_N_INSNS (11),   /* dmul */
 461   COSTS_N_INSNS (11),   /* sdiv */
 462   COSTS_N_INSNS (11),   /* ddiv */
 463   32,                   /* cache line size */
 464   16,                   /* l1 cache */
 465   128,                  /* l2 cache */
 466   1,                    /* streams */
 467 };
 468
 469 /* Instruction costs on PPC440 processors.  */
 470 static const
 471 struct processor_costs ppc440_cost = {
 472   COSTS_N_INSNS (3),    /* mulsi */
 473   COSTS_N_INSNS (2),    /* mulsi_const */
 474   COSTS_N_INSNS (2),    /* mulsi_const9 */
 475   COSTS_N_INSNS (3),    /* muldi */
 476   COSTS_N_INSNS (34),   /* divsi */
 477   COSTS_N_INSNS (34),   /* divdi */
 478   COSTS_N_INSNS (5),    /* fp */
 479   COSTS_N_INSNS (5),    /* dmul */
 480   COSTS_N_INSNS (19),   /* sdiv */
 481   COSTS_N_INSNS (33),   /* ddiv */
 482   32,                   /* cache line size */
 483   32,                   /* l1 cache */
 484   256,                  /* l2 cache */
 485   1,                    /* streams */
 486 };
 487
 488 /* Instruction costs on PPC476 processors.  */
 489 static const
 490 struct processor_costs ppc476_cost = {
 491   COSTS_N_INSNS (4),    /* mulsi */
 492   COSTS_N_INSNS (4),    /* mulsi_const */
 493   COSTS_N_INSNS (4),    /* mulsi_const9 */
 494   COSTS_N_INSNS (4),    /* muldi */
 495   COSTS_N_INSNS (11),   /* divsi */
 496   COSTS_N_INSNS (11),   /* divdi */
 497   COSTS_N_INSNS (6),    /* fp */
 498   COSTS_N_INSNS (6),    /* dmul */
 499   COSTS_N_INSNS (19),   /* sdiv */
 500   COSTS_N_INSNS (33),   /* ddiv */
 501   32,                   /* l1 cache line size */
 502   32,                   /* l1 cache */
 503   512,                  /* l2 cache */
 504   1,                    /* streams */
 505 };
 506
 507 /* Instruction costs on PPC601 processors.  */
 508 static const
 509 struct processor_costs ppc601_cost = {
 510   COSTS_N_INSNS (5),    /* mulsi */
 511   COSTS_N_INSNS (5),    /* mulsi_const */
 512   COSTS_N_INSNS (5),    /* mulsi_const9 */
 513   COSTS_N_INSNS (5),    /* muldi */
 514   COSTS_N_INSNS (36),   /* divsi */
 515   COSTS_N_INSNS (36),   /* divdi */
 516   COSTS_N_INSNS (4),    /* fp */
 517   COSTS_N_INSNS (5),    /* dmul */
 518   COSTS_N_INSNS (17),   /* sdiv */
 519   COSTS_N_INSNS (31),   /* ddiv */
 520   32,                   /* cache line size */
 521   32,                   /* l1 cache */
 522   256,                  /* l2 cache */
 523   1,                    /* streams */
 524 };
 525
 526 /* Instruction costs on PPC603 processors.  */
 527 static const
 528 struct processor_costs ppc603_cost = {
 529   COSTS_N_INSNS (5),    /* mulsi */
 530   COSTS_N_INSNS (3),    /* mulsi_const */
 531   COSTS_N_INSNS (2),    /* mulsi_const9 */
 532   COSTS_N_INSNS (5),    /* muldi */
 533   COSTS_N_INSNS (37),   /* divsi */
 534   COSTS_N_INSNS (37),   /* divdi */
 535   COSTS_N_INSNS (3),    /* fp */
 536   COSTS_N_INSNS (4),    /* dmul */
 537   COSTS_N_INSNS (18),   /* sdiv */
 538   COSTS_N_INSNS (33),   /* ddiv */
 539   32,                   /* cache line size */
 540   8,                    /* l1 cache */
 541   64,                   /* l2 cache */
 542   1,                    /* streams */
 543 };
 544
 545 /* Instruction costs on PPC604 processors.  */
 546 static const
 547 struct processor_costs ppc604_cost = {
 548   COSTS_N_INSNS (4),    /* mulsi */
 549   COSTS_N_INSNS (4),    /* mulsi_const */
 550   COSTS_N_INSNS (4),    /* mulsi_const9 */
 551   COSTS_N_INSNS (4),    /* muldi */
 552   COSTS_N_INSNS (20),   /* divsi */
 553   COSTS_N_INSNS (20),   /* divdi */
 554   COSTS_N_INSNS (3),    /* fp */
 555   COSTS_N_INSNS (3),    /* dmul */
 556   COSTS_N_INSNS (18),   /* sdiv */
 557   COSTS_N_INSNS (32),   /* ddiv */
 558   32,                   /* cache line size */
 559   16,                   /* l1 cache */
 560   512,                  /* l2 cache */
 561   1,                    /* streams */
 562 };
 563
 564 /* Instruction costs on PPC604e processors.  */
 565 static const
 566 struct processor_costs ppc604e_cost = {
 567   COSTS_N_INSNS (2),    /* mulsi */
 568   COSTS_N_INSNS (2),    /* mulsi_const */
 569   COSTS_N_INSNS (2),    /* mulsi_const9 */
 570   COSTS_N_INSNS (2),    /* muldi */
 571   COSTS_N_INSNS (20),   /* divsi */
 572   COSTS_N_INSNS (20),   /* divdi */
 573   COSTS_N_INSNS (3),    /* fp */
 574   COSTS_N_INSNS (3),    /* dmul */
 575   COSTS_N_INSNS (18),   /* sdiv */
 576   COSTS_N_INSNS (32),   /* ddiv */
 577   32,                   /* cache line size */
 578   32,                   /* l1 cache */
 579   1024,                 /* l2 cache */
 580   1,                    /* streams */
 581 };
 582
 583 /* Instruction costs on PPC620 processors.  */
 584 static const
 585 struct processor_costs ppc620_cost = {
 586   COSTS_N_INSNS (5),    /* mulsi */
 587   COSTS_N_INSNS (4),    /* mulsi_const */
 588   COSTS_N_INSNS (3),    /* mulsi_const9 */
 589   COSTS_N_INSNS (7),    /* muldi */
 590   COSTS_N_INSNS (21),   /* divsi */
 591   COSTS_N_INSNS (37),   /* divdi */
 592   COSTS_N_INSNS (3),    /* fp */
 593   COSTS_N_INSNS (3),    /* dmul */
 594   COSTS_N_INSNS (18),   /* sdiv */
 595   COSTS_N_INSNS (32),   /* ddiv */
 596   128,                  /* cache line size */
 597   32,                   /* l1 cache */
 598   1024,                 /* l2 cache */
 599   1,                    /* streams */
 600 };
 601
 602 /* Instruction costs on PPC630 processors.  */
 603 static const
 604 struct processor_costs ppc630_cost = {
 605   COSTS_N_INSNS (5),    /* mulsi */
 606   COSTS_N_INSNS (4),    /* mulsi_const */
 607   COSTS_N_INSNS (3),    /* mulsi_const9 */
 608   COSTS_N_INSNS (7),    /* muldi */
 609   COSTS_N_INSNS (21),   /* divsi */
 610   COSTS_N_INSNS (37),   /* divdi */
 611   COSTS_N_INSNS (3),    /* fp */
 612   COSTS_N_INSNS (3),    /* dmul */
 613   COSTS_N_INSNS (17),   /* sdiv */
 614   COSTS_N_INSNS (21),   /* ddiv */
 615   128,                  /* cache line size */
 616   64,                   /* l1 cache */
 617   1024,                 /* l2 cache */
 618   1,                    /* streams */
 619 };
 620
 621 /* Instruction costs on Cell processor.  */
 622 /* COSTS_N_INSNS (1) ~ one add.  */
 623 static const
 624 struct processor_costs ppccell_cost = {
 625   COSTS_N_INSNS (9/2)+2,    /* mulsi */
 626   COSTS_N_INSNS (6/2),    /* mulsi_const */
 627   COSTS_N_INSNS (6/2),    /* mulsi_const9 */
 628   COSTS_N_INSNS (15/2)+2,   /* muldi */
 629   COSTS_N_INSNS (38/2),   /* divsi */
 630   COSTS_N_INSNS (70/2),   /* divdi */
 631   COSTS_N_INSNS (10/2),   /* fp */
 632   COSTS_N_INSNS (10/2),   /* dmul */
 633   COSTS_N_INSNS (74/2),   /* sdiv */
 634   COSTS_N_INSNS (74/2),   /* ddiv */
 635   128,                  /* cache line size */
 636   32,                   /* l1 cache */
 637   512,                  /* l2 cache */
 638   6,                    /* streams */
 639 };
 640
 641 /* Instruction costs on PPC750 and PPC7400 processors.  */
 642 static const
 643 struct processor_costs ppc750_cost = {
 644   COSTS_N_INSNS (5),    /* mulsi */
 645   COSTS_N_INSNS (3),    /* mulsi_const */
 646   COSTS_N_INSNS (2),    /* mulsi_const9 */
 647   COSTS_N_INSNS (5),    /* muldi */
 648   COSTS_N_INSNS (17),   /* divsi */
 649   COSTS_N_INSNS (17),   /* divdi */
 650   COSTS_N_INSNS (3),    /* fp */
 651   COSTS_N_INSNS (3),    /* dmul */
 652   COSTS_N_INSNS (17),   /* sdiv */
 653   COSTS_N_INSNS (31),   /* ddiv */
 654   32,                   /* cache line size */
 655   32,                   /* l1 cache */
 656   512,                  /* l2 cache */
 657   1,                    /* streams */
 658 };
 659
 660 /* Instruction costs on PPC7450 processors.  */
 661 static const
 662 struct processor_costs ppc7450_cost = {
 663   COSTS_N_INSNS (4),    /* mulsi */
 664   COSTS_N_INSNS (3),    /* mulsi_const */
 665   COSTS_N_INSNS (3),    /* mulsi_const9 */
 666   COSTS_N_INSNS (4),    /* muldi */
 667   COSTS_N_INSNS (23),   /* divsi */
 668   COSTS_N_INSNS (23),   /* divdi */
 669   COSTS_N_INSNS (5),    /* fp */
 670   COSTS_N_INSNS (5),    /* dmul */
 671   COSTS_N_INSNS (21),   /* sdiv */
 672   COSTS_N_INSNS (35),   /* ddiv */
 673   32,                   /* cache line size */
 674   32,                   /* l1 cache */
 675   1024,                 /* l2 cache */
 676   1,                    /* streams */
 677 };
 678
 679 /* Instruction costs on PPC8540 processors.  */
 680 static const
 681 struct processor_costs ppc8540_cost = {
 682   COSTS_N_INSNS (4),    /* mulsi */
 683   COSTS_N_INSNS (4),    /* mulsi_const */
 684   COSTS_N_INSNS (4),    /* mulsi_const9 */
 685   COSTS_N_INSNS (4),    /* muldi */
 686   COSTS_N_INSNS (19),   /* divsi */
 687   COSTS_N_INSNS (19),   /* divdi */
 688   COSTS_N_INSNS (4),    /* fp */
 689   COSTS_N_INSNS (4),    /* dmul */
 690   COSTS_N_INSNS (29),   /* sdiv */
 691   COSTS_N_INSNS (29),   /* ddiv */
 692   32,                   /* cache line size */
 693   32,                   /* l1 cache */
 694   256,                  /* l2 cache */
 695   1,                    /* prefetch streams /*/
 696 };
 697
 698 /* Instruction costs on E300C2 and E300C3 cores.  */
 699 static const
 700 struct processor_costs ppce300c2c3_cost = {
 701   COSTS_N_INSNS (4),    /* mulsi */
 702   COSTS_N_INSNS (4),    /* mulsi_const */
 703   COSTS_N_INSNS (4),    /* mulsi_const9 */
 704   COSTS_N_INSNS (4),    /* muldi */
 705   COSTS_N_INSNS (19),   /* divsi */
 706   COSTS_N_INSNS (19),   /* divdi */
 707   COSTS_N_INSNS (3),    /* fp */
 708   COSTS_N_INSNS (4),    /* dmul */
 709   COSTS_N_INSNS (18),   /* sdiv */
 710   COSTS_N_INSNS (33),   /* ddiv */
 711   32,
 712   16,                   /* l1 cache */
 713   16,                   /* l2 cache */
 714   1,                    /* prefetch streams /*/
 715 };
 716
 717 /* Instruction costs on PPCE500MC processors.  */
 718 static const
 719 struct processor_costs ppce500mc_cost = {
 720   COSTS_N_INSNS (4),    /* mulsi */
 721   COSTS_N_INSNS (4),    /* mulsi_const */
 722   COSTS_N_INSNS (4),    /* mulsi_const9 */
 723   COSTS_N_INSNS (4),    /* muldi */
 724   COSTS_N_INSNS (14),   /* divsi */
 725   COSTS_N_INSNS (14),   /* divdi */
 726   COSTS_N_INSNS (8),    /* fp */
 727   COSTS_N_INSNS (10),   /* dmul */
 728   COSTS_N_INSNS (36),   /* sdiv */
 729   COSTS_N_INSNS (66),   /* ddiv */
 730   64,                   /* cache line size */
 731   32,                   /* l1 cache */
 732   128,                  /* l2 cache */
 733   1,                    /* prefetch streams /*/
 734 };
 735
 736 /* Instruction costs on PPCE500MC64 processors.  */
 737 static const
 738 struct processor_costs ppce500mc64_cost = {
 739   COSTS_N_INSNS (4),    /* mulsi */
 740   COSTS_N_INSNS (4),    /* mulsi_const */
 741   COSTS_N_INSNS (4),    /* mulsi_const9 */
 742   COSTS_N_INSNS (4),    /* muldi */
 743   COSTS_N_INSNS (14),   /* divsi */
 744   COSTS_N_INSNS (14),   /* divdi */
 745   COSTS_N_INSNS (4),    /* fp */
 746   COSTS_N_INSNS (10),   /* dmul */
 747   COSTS_N_INSNS (36),   /* sdiv */
 748   COSTS_N_INSNS (66),   /* ddiv */
 749   64,                   /* cache line size */
 750   32,                   /* l1 cache */
 751   128,                  /* l2 cache */
 752   1,                    /* prefetch streams /*/
 753 };
 754
 755 /* Instruction costs on AppliedMicro Titan processors.  */
 756 static const
 757 struct processor_costs titan_cost = {
 758   COSTS_N_INSNS (5),    /* mulsi */
 759   COSTS_N_INSNS (5),    /* mulsi_const */
 760   COSTS_N_INSNS (5),    /* mulsi_const9 */
 761   COSTS_N_INSNS (5),    /* muldi */
 762   COSTS_N_INSNS (18),   /* divsi */
 763   COSTS_N_INSNS (18),   /* divdi */
 764   COSTS_N_INSNS (10),   /* fp */
 765   COSTS_N_INSNS (10),   /* dmul */
 766   COSTS_N_INSNS (46),   /* sdiv */
 767   COSTS_N_INSNS (72),   /* ddiv */
 768   32,                   /* cache line size */
 769   32,                   /* l1 cache */
 770   512,                  /* l2 cache */
 771   1,                    /* prefetch streams /*/
 772 };
 773
 774 /* Instruction costs on POWER4 and POWER5 processors.  */
 775 static const
 776 struct processor_costs power4_cost = {
 777   COSTS_N_INSNS (3),    /* mulsi */
 778   COSTS_N_INSNS (2),    /* mulsi_const */
 779   COSTS_N_INSNS (2),    /* mulsi_const9 */
 780   COSTS_N_INSNS (4),    /* muldi */
 781   COSTS_N_INSNS (18),   /* divsi */
 782   COSTS_N_INSNS (34),   /* divdi */
 783   COSTS_N_INSNS (3),    /* fp */
 784   COSTS_N_INSNS (3),    /* dmul */
 785   COSTS_N_INSNS (17),   /* sdiv */
 786   COSTS_N_INSNS (17),   /* ddiv */
 787   128,                  /* cache line size */
 788   32,                   /* l1 cache */
 789   1024,                 /* l2 cache */
 790   8,                    /* prefetch streams /*/
 791 };
 792
 793 /* Instruction costs on POWER6 processors.  */
 794 static const
 795 struct processor_costs power6_cost = {
 796   COSTS_N_INSNS (8),    /* mulsi */
 797   COSTS_N_INSNS (8),    /* mulsi_const */
 798   COSTS_N_INSNS (8),    /* mulsi_const9 */
 799   COSTS_N_INSNS (8),    /* muldi */
 800   COSTS_N_INSNS (22),   /* divsi */
 801   COSTS_N_INSNS (28),   /* divdi */
 802   COSTS_N_INSNS (3),    /* fp */
 803   COSTS_N_INSNS (3),    /* dmul */
 804   COSTS_N_INSNS (13),   /* sdiv */
 805   COSTS_N_INSNS (16),   /* ddiv */
 806   128,                  /* cache line size */
 807   64,                   /* l1 cache */
 808   2048,                 /* l2 cache */
 809   16,                   /* prefetch streams */
 810 };
 811
 812 /* Instruction costs on POWER7 processors.  */
 813 static const
 814 struct processor_costs power7_cost = {
 815   COSTS_N_INSNS (2),    /* mulsi */
 816   COSTS_N_INSNS (2),    /* mulsi_const */
 817   COSTS_N_INSNS (2),    /* mulsi_const9 */
 818   COSTS_N_INSNS (2),    /* muldi */
 819   COSTS_N_INSNS (18),   /* divsi */
 820   COSTS_N_INSNS (34),   /* divdi */
 821   COSTS_N_INSNS (3),    /* fp */
 822   COSTS_N_INSNS (3),    /* dmul */
 823   COSTS_N_INSNS (13),   /* sdiv */
 824   COSTS_N_INSNS (16),   /* ddiv */
 825   128,                  /* cache line size */
 826   32,                   /* l1 cache */
 827   256,                  /* l2 cache */
 828   12,                   /* prefetch streams */
 829 };
 830
 831 /* Instruction costs on POWER A2 processors.  */
 832 static const
 833 struct processor_costs ppca2_cost = {
 834   COSTS_N_INSNS (16),    /* mulsi */
 835   COSTS_N_INSNS (16),    /* mulsi_const */
 836   COSTS_N_INSNS (16),    /* mulsi_const9 */
 837   COSTS_N_INSNS (16),   /* muldi */
 838   COSTS_N_INSNS (22),   /* divsi */
 839   COSTS_N_INSNS (28),   /* divdi */
 840   COSTS_N_INSNS (3),    /* fp */
 841   COSTS_N_INSNS (3),    /* dmul */
 842   COSTS_N_INSNS (59),   /* sdiv */
 843   COSTS_N_INSNS (72),   /* ddiv */
 844   64,
 845   16,                   /* l1 cache */
 846   2048,                 /* l2 cache */
 847   16,                   /* prefetch streams */
 848 };
 849
 850 \f
 851 /* Table that classifies rs6000 builtin functions (pure, const, etc.).  */
 852 #undef RS6000_BUILTIN
 853 #undef RS6000_BUILTIN_EQUATE
 854 #define RS6000_BUILTIN(NAME, TYPE) TYPE,
 855 #define RS6000_BUILTIN_EQUATE(NAME, VALUE)
 856
 857 static const enum rs6000_btc builtin_classify[(int)RS6000_BUILTIN_COUNT] =
 858 {
 859 #include "rs6000-builtin.def"
 860 };
 861
 862 #undef RS6000_BUILTIN
 863 #undef RS6000_BUILTIN_EQUATE
 864
 865 /* Support for -mveclibabi=<xxx> to control which vector library to use.  */
 866 static tree (*rs6000_veclib_handler) (tree, tree, tree);
 867
 868 \f
 869 static bool rs6000_function_ok_for_sibcall (tree, tree);
 870 static const char *rs6000_invalid_within_doloop (const_rtx);
 871 static bool rs6000_legitimate_address_p (enum machine_mode, rtx, bool);
 872 static bool rs6000_debug_legitimate_address_p (enum machine_mode, rtx, bool);
 873 static rtx rs6000_generate_compare (rtx, enum machine_mode);
 874 static void rs6000_emit_stack_tie (void);
 875 static bool spe_func_has_64bit_regs_p (void);
 876 static rtx gen_frame_mem_offset (enum machine_mode, rtx, int);
 877 static unsigned rs6000_hash_constant (rtx);
 878 static unsigned toc_hash_function (const void *);
 879 static int toc_hash_eq (const void *, const void *);
 880 static bool reg_offset_addressing_ok_p (enum machine_mode);
 881 static bool virtual_stack_registers_memory_p (rtx);
 882 static bool constant_pool_expr_p (rtx);
 883 static bool legitimate_small_data_p (enum machine_mode, rtx);
 884 static bool legitimate_lo_sum_address_p (enum machine_mode, rtx, int);
 885 static struct machine_function * rs6000_init_machine_status (void);
 886 static bool rs6000_assemble_integer (rtx, unsigned int, int);
 887 static bool no_global_regs_above (int, bool);
 888 #if defined (HAVE_GAS_HIDDEN) && !defined (TARGET_MACHO)
 889 static void rs6000_assemble_visibility (tree, int);
 890 #endif
 891 static int rs6000_ra_ever_killed (void);
 892 static bool rs6000_attribute_takes_identifier_p (const_tree);
 893 static tree rs6000_handle_longcall_attribute (tree *, tree, tree, int, bool *);
 894 static tree rs6000_handle_altivec_attribute (tree *, tree, tree, int, bool *);
 895 static bool rs6000_ms_bitfield_layout_p (const_tree);
 896 static tree rs6000_handle_struct_attribute (tree *, tree, tree, int, bool *);
 897 static void rs6000_eliminate_indexed_memrefs (rtx operands[2]);
 898 static const char *rs6000_mangle_type (const_tree);
 899 static void rs6000_set_default_type_attributes (tree);
 900 static rtx rs6000_savres_routine_sym (rs6000_stack_t *, bool, bool, bool);
 901 static rtx rs6000_emit_stack_reset (rs6000_stack_t *, rtx, rtx, int, bool);
 902 static bool rs6000_reg_live_or_pic_offset_p (int);
 903 static tree rs6000_builtin_vectorized_libmass (tree, tree, tree);
 904 static tree rs6000_builtin_vectorized_function (tree, tree, tree);
 905 static void rs6000_restore_saved_cr (rtx, int);
 906 static bool rs6000_output_addr_const_extra (FILE *, rtx);
 907 static void rs6000_output_function_prologue (FILE *, HOST_WIDE_INT);
 908 static void rs6000_output_function_epilogue (FILE *, HOST_WIDE_INT);
 909 static void rs6000_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT,
 910                                     tree);
 911 static rtx rs6000_emit_set_long_const (rtx, HOST_WIDE_INT, HOST_WIDE_INT);
 912 static bool rs6000_return_in_memory (const_tree, const_tree);
 913 static rtx rs6000_function_value (const_tree, const_tree, bool);
 914 static void rs6000_file_start (void);
 915 #if TARGET_ELF
 916 static int rs6000_elf_reloc_rw_mask (void);
 917 static void rs6000_elf_asm_out_constructor (rtx, int) ATTRIBUTE_UNUSED;
 918 static void rs6000_elf_asm_out_destructor (rtx, int) ATTRIBUTE_UNUSED;
 919 static void rs6000_elf_file_end (void) ATTRIBUTE_UNUSED;
 920 static void rs6000_elf_asm_init_sections (void);
 921 static section *rs6000_elf_select_rtx_section (enum machine_mode, rtx,
 922                                                unsigned HOST_WIDE_INT);
 923 static void rs6000_elf_encode_section_info (tree, rtx, int)
 924      ATTRIBUTE_UNUSED;
 925 #endif
 926 static bool rs6000_use_blocks_for_constant_p (enum machine_mode, const_rtx);
 927 static void rs6000_alloc_sdmode_stack_slot (void);
 928 static void rs6000_instantiate_decls (void);
 929 #if TARGET_XCOFF
 930 static void rs6000_xcoff_asm_output_anchor (rtx);
 931 static void rs6000_xcoff_asm_globalize_label (FILE *, const char *);
 932 static void rs6000_xcoff_asm_init_sections (void);
 933 static int rs6000_xcoff_reloc_rw_mask (void);
 934 static void rs6000_xcoff_asm_named_section (const char *, unsigned int, tree);
 935 static section *rs6000_xcoff_select_section (tree, int,
 936                                              unsigned HOST_WIDE_INT);
 937 static void rs6000_xcoff_unique_section (tree, int);
 938 static section *rs6000_xcoff_select_rtx_section
 939   (enum machine_mode, rtx, unsigned HOST_WIDE_INT);
 940 static const char * rs6000_xcoff_strip_name_encoding (const char *);
 941 static unsigned int rs6000_xcoff_section_type_flags (tree, const char *, int);
 942 static void rs6000_xcoff_file_start (void);
 943 static void rs6000_xcoff_file_end (void);
 944 #endif
 945 static int rs6000_variable_issue (FILE *, int, rtx, int);
 946 static int rs6000_register_move_cost (enum machine_mode,
 947                                       reg_class_t, reg_class_t);
 948 static int rs6000_memory_move_cost (enum machine_mode, reg_class_t, bool);
 949 static bool rs6000_rtx_costs (rtx, int, int, int, int *, bool);
 950 static bool rs6000_debug_rtx_costs (rtx, int, int, int, int *, bool);
 951 static int rs6000_debug_address_cost (rtx, bool);
 952 static int rs6000_adjust_cost (rtx, rtx, rtx, int);
 953 static int rs6000_debug_adjust_cost (rtx, rtx, rtx, int);
 954 static void rs6000_sched_init (FILE *, int, int);
 955 static bool is_microcoded_insn (rtx);
 956 static bool is_nonpipeline_insn (rtx);
 957 static bool is_cracked_insn (rtx);
 958 static bool is_branch_slot_insn (rtx);
 959 static bool is_load_insn (rtx);
 960 static rtx get_store_dest (rtx pat);
 961 static bool is_store_insn (rtx);
 962 static bool set_to_load_agen (rtx,rtx);
 963 static bool adjacent_mem_locations (rtx,rtx);
 964 static int rs6000_adjust_priority (rtx, int);
 965 static int rs6000_issue_rate (void);
 966 static bool rs6000_is_costly_dependence (dep_t, int, int);
 967 static rtx get_next_active_insn (rtx, rtx);
 968 static bool insn_terminates_group_p (rtx , enum group_termination);
 969 static bool insn_must_be_first_in_group (rtx);
 970 static bool insn_must_be_last_in_group (rtx);
 971 static bool is_costly_group (rtx *, rtx);
 972 static int force_new_group (int, FILE *, rtx *, rtx, bool *, int, int *);
 973 static int redefine_groups (FILE *, int, rtx, rtx);
 974 static int pad_groups (FILE *, int, rtx, rtx);
 975 static void rs6000_sched_finish (FILE *, int);
 976 static int rs6000_sched_reorder (FILE *, int, rtx *, int *, int);
 977 static int rs6000_sched_reorder2 (FILE *, int, rtx *, int *, int);
 978 static int rs6000_use_sched_lookahead (void);
 979 static int rs6000_use_sched_lookahead_guard (rtx);
 980 static void * rs6000_alloc_sched_context (void);
 981 static void rs6000_init_sched_context (void *, bool);
 982 static void rs6000_set_sched_context (void *);
 983 static void rs6000_free_sched_context (void *);
 984 static tree rs6000_builtin_reciprocal (unsigned int, bool, bool);
 985 static tree rs6000_builtin_mask_for_load (void);
 986 static tree rs6000_builtin_mul_widen_even (tree);
 987 static tree rs6000_builtin_mul_widen_odd (tree);
 988 static tree rs6000_builtin_conversion (unsigned int, tree, tree);
 989 static bool rs6000_builtin_support_vector_misalignment (enum
 990                                                         machine_mode,
 991                                                         const_tree,
 992                                                         int, bool);
 993 static int rs6000_builtin_vectorization_cost (enum vect_cost_for_stmt,
 994                                               tree, int);
 995 static enum machine_mode rs6000_preferred_simd_mode (enum machine_mode);
 996
 997 static void def_builtin (int, const char *, tree, int);
 998 static bool rs6000_vector_alignment_reachable (const_tree, bool);
 999 static void rs6000_init_builtins (void);
1000 static tree rs6000_builtin_decl (unsigned, bool);
1001
1002 static rtx rs6000_expand_unop_builtin (enum insn_code, tree, rtx);
1003 static rtx rs6000_expand_binop_builtin (enum insn_code, tree, rtx);
1004 static rtx rs6000_expand_ternop_builtin (enum insn_code, tree, rtx);
1005 static rtx rs6000_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
1006 static void altivec_init_builtins (void);
1007 static unsigned builtin_hash_function (const void *);
1008 static int builtin_hash_eq (const void *, const void *);
1009 static tree builtin_function_type (enum machine_mode, enum machine_mode,
1010                                    enum machine_mode, enum machine_mode,
1011                                    enum rs6000_builtins, const char *name);
1012 static void rs6000_common_init_builtins (void);
1013 static void rs6000_init_libfuncs (void);
1014
1015 static void paired_init_builtins (void);
1016 static rtx paired_expand_builtin (tree, rtx, bool *);
1017 static rtx paired_expand_lv_builtin (enum insn_code, tree, rtx);
1018 static rtx paired_expand_stv_builtin (enum insn_code, tree);
1019 static rtx paired_expand_predicate_builtin (enum insn_code, tree, rtx);
1020
1021 static void enable_mask_for_builtins (struct builtin_description *, int,
1022                                       enum rs6000_builtins,
1023                                       enum rs6000_builtins);
1024 static void spe_init_builtins (void);
1025 static rtx spe_expand_builtin (tree, rtx, bool *);
1026 static rtx spe_expand_stv_builtin (enum insn_code, tree);
1027 static rtx spe_expand_predicate_builtin (enum insn_code, tree, rtx);
1028 static rtx spe_expand_evsel_builtin (enum insn_code, tree, rtx);
1029 static int rs6000_emit_int_cmove (rtx, rtx, rtx, rtx);
1030 static rs6000_stack_t *rs6000_stack_info (void);
1031 static void debug_stack_info (rs6000_stack_t *);
1032
1033 static rtx altivec_expand_builtin (tree, rtx, bool *);
1034 static rtx altivec_expand_ld_builtin (tree, rtx, bool *);
1035 static rtx altivec_expand_st_builtin (tree, rtx, bool *);
1036 static rtx altivec_expand_dst_builtin (tree, rtx, bool *);
1037 static rtx altivec_expand_abs_builtin (enum insn_code, tree, rtx);
1038 static rtx altivec_expand_predicate_builtin (enum insn_code, tree, rtx);
1039 static rtx altivec_expand_stv_builtin (enum insn_code, tree);
1040 static rtx altivec_expand_vec_init_builtin (tree, tree, rtx);
1041 static rtx altivec_expand_vec_set_builtin (tree);
1042 static rtx altivec_expand_vec_ext_builtin (tree, rtx);
1043 static int get_element_number (tree, tree);
1044 static void rs6000_option_override (void);
1045 static int rs6000_loop_align_max_skip (rtx);
1046 static int first_altivec_reg_to_save (void);
1047 static unsigned int compute_vrsave_mask (void);
1048 static void compute_save_world_info (rs6000_stack_t *info_ptr);
1049 static void is_altivec_return_reg (rtx, void *);
1050 static rtx generate_set_vrsave (rtx, rs6000_stack_t *, int);
1051 int easy_vector_constant (rtx, enum machine_mode);
1052 static rtx rs6000_dwarf_register_span (rtx);
1053 static void rs6000_init_dwarf_reg_sizes_extra (tree);
1054 static rtx rs6000_legitimize_address (rtx, rtx, enum machine_mode);
1055 static rtx rs6000_debug_legitimize_address (rtx, rtx, enum machine_mode);
1056 static rtx rs6000_legitimize_tls_address (rtx, enum tls_model);
1057 static void rs6000_output_dwarf_dtprel (FILE *, int, rtx) ATTRIBUTE_UNUSED;
1058 static rtx rs6000_delegitimize_address (rtx);
1059 static rtx rs6000_tls_get_addr (void);
1060 static rtx rs6000_got_sym (void);
1061 static int rs6000_tls_symbol_ref_1 (rtx *, void *);
1062 static const char *rs6000_get_some_local_dynamic_name (void);
1063 static int rs6000_get_some_local_dynamic_name_1 (rtx *, void *);
1064 static rtx rs6000_complex_function_value (enum machine_mode);
1065 static rtx rs6000_spe_function_arg (const CUMULATIVE_ARGS *,
1066                                     enum machine_mode, const_tree);
1067 static void rs6000_darwin64_record_arg_advance_flush (CUMULATIVE_ARGS *,
1068                                                       HOST_WIDE_INT, int);
1069 static void rs6000_darwin64_record_arg_advance_recurse (CUMULATIVE_ARGS *,
1070                                                         const_tree,
1071                                                         HOST_WIDE_INT);
1072 static void rs6000_darwin64_record_arg_flush (CUMULATIVE_ARGS *,
1073                                               HOST_WIDE_INT,
1074                                               rtx[], int *);
1075 static void rs6000_darwin64_record_arg_recurse (CUMULATIVE_ARGS *,
1076                                                 const_tree, HOST_WIDE_INT,
1077                                                 rtx[], int *);
1078 static rtx rs6000_darwin64_record_arg (CUMULATIVE_ARGS *, const_tree, bool, bool);
1079 static rtx rs6000_mixed_function_arg (enum machine_mode, const_tree, int);
1080 static void rs6000_function_arg_advance (cumulative_args_t, enum machine_mode,
1081                                          const_tree, bool);
1082 static rtx rs6000_function_arg (cumulative_args_t, enum machine_mode,
1083                                 const_tree, bool);
1084 static unsigned int rs6000_function_arg_boundary (enum machine_mode,
1085                                                   const_tree);
1086 static void rs6000_move_block_from_reg (int regno, rtx x, int nregs);
1087 static void setup_incoming_varargs (cumulative_args_t,
1088                                     enum machine_mode, tree,
1089                                     int *, int);
1090 static bool rs6000_pass_by_reference (cumulative_args_t, enum machine_mode,
1091                                       const_tree, bool);
1092 static int rs6000_arg_partial_bytes (cumulative_args_t, enum machine_mode,
1093                                      tree, bool);
1094 static const char *invalid_arg_for_unprototyped_fn (const_tree, const_tree, const_tree);
1095 #if TARGET_MACHO
1096 static void macho_branch_islands (void);
1097 static int no_previous_def (tree function_name);
1098 static tree get_prev_label (tree function_name);
1099 static void rs6000_darwin_file_start (void);
1100 #endif
1101
1102 static tree rs6000_build_builtin_va_list (void);
1103 static void rs6000_va_start (tree, rtx);
1104 static tree rs6000_gimplify_va_arg (tree, tree, gimple_seq *, gimple_seq *);
1105 static bool rs6000_must_pass_in_stack (enum machine_mode, const_tree);
1106 static bool rs6000_scalar_mode_supported_p (enum machine_mode);
1107 static bool rs6000_vector_mode_supported_p (enum machine_mode);
1108 static rtx rs6000_emit_vector_compare_inner (enum rtx_code, rtx, rtx);
1109 static rtx rs6000_emit_vector_compare (enum rtx_code, rtx, rtx,
1110                                        enum machine_mode);
1111 static tree rs6000_stack_protect_fail (void);
1112
1113 static rtx rs6000_legitimize_reload_address (rtx, enum machine_mode, int, int,
1114                                              int, int *);
1115
1116 static rtx rs6000_debug_legitimize_reload_address (rtx, enum machine_mode, int,
1117                                                    int, int, int *);
1118
1119 rtx (*rs6000_legitimize_reload_address_ptr) (rtx, enum machine_mode, int, int,
1120                                              int, int *)
1121   = rs6000_legitimize_reload_address;
1122
1123 static bool rs6000_mode_dependent_address_p (const_rtx);
1124 static bool rs6000_mode_dependent_address (const_rtx);
1125 static bool rs6000_debug_mode_dependent_address (const_rtx);
1126 static bool (*rs6000_mode_dependent_address_ptr) (const_rtx)
1127   = rs6000_mode_dependent_address;
1128
1129 static enum reg_class rs6000_secondary_reload_class (enum reg_class,
1130                                                      enum machine_mode, rtx);
1131 static enum reg_class rs6000_debug_secondary_reload_class (enum reg_class,
1132                                                            enum machine_mode,
1133                                                            rtx);
1134 enum reg_class (*rs6000_secondary_reload_class_ptr) (enum reg_class,
1135                                                      enum machine_mode, rtx)
1136   = rs6000_secondary_reload_class;
1137
1138 static enum reg_class rs6000_preferred_reload_class (rtx, enum reg_class);
1139 static enum reg_class rs6000_debug_preferred_reload_class (rtx,
1140                                                            enum reg_class);
1141 enum reg_class (*rs6000_preferred_reload_class_ptr) (rtx, enum reg_class)
1142   = rs6000_preferred_reload_class;
1143
1144 static bool rs6000_secondary_memory_needed (enum reg_class, enum reg_class,
1145                                             enum machine_mode);
1146
1147 static bool rs6000_debug_secondary_memory_needed (enum reg_class,
1148                                                   enum reg_class,
1149                                                   enum machine_mode);
1150
1151 bool (*rs6000_secondary_memory_needed_ptr) (enum reg_class, enum reg_class,
1152                                             enum machine_mode)
1153   = rs6000_secondary_memory_needed;
1154
1155 static bool rs6000_cannot_change_mode_class (enum machine_mode,
1156                                              enum machine_mode,
1157                                              enum reg_class);
1158 static bool rs6000_debug_cannot_change_mode_class (enum machine_mode,
1159                                                    enum machine_mode,
1160                                                    enum reg_class);
1161
1162 bool (*rs6000_cannot_change_mode_class_ptr) (enum machine_mode,
1163                                              enum machine_mode,
1164                                              enum reg_class)
1165   = rs6000_cannot_change_mode_class;
1166
1167 static reg_class_t rs6000_secondary_reload (bool, rtx, reg_class_t,
1168                                             enum machine_mode,
1169                                             struct secondary_reload_info *);
1170
1171 const int INSN_NOT_AVAILABLE = -1;
1172 static enum machine_mode rs6000_eh_return_filter_mode (void);
1173 static bool rs6000_can_eliminate (const int, const int);
1174 static void rs6000_conditional_register_usage (void);
1175 static void rs6000_trampoline_init (rtx, tree, rtx);
1176 static bool rs6000_cannot_force_const_mem (enum machine_mode, rtx);
1177 static bool rs6000_legitimate_constant_p (enum machine_mode, rtx);
1178 static bool rs6000_save_toc_in_prologue_p (void);
1179 static void rs6000_code_end (void) ATTRIBUTE_UNUSED;
1180
1181 /* Hash table stuff for keeping track of TOC entries.  */
1182
1183 struct GTY(()) toc_hash_struct
1184 {
1185   /* `key' will satisfy CONSTANT_P; in fact, it will satisfy
1186      ASM_OUTPUT_SPECIAL_POOL_ENTRY_P.  */
1187   rtx key;
1188   enum machine_mode key_mode;
1189   int labelno;
1190 };
1191
1192 static GTY ((param_is (struct toc_hash_struct))) htab_t toc_hash_table;
1193
1194 /* Hash table to keep track of the argument types for builtin functions.  */
1195
1196 struct GTY(()) builtin_hash_struct
1197 {
1198   tree type;
1199   enum machine_mode mode[4];    /* return value + 3 arguments.  */
1200   unsigned char uns_p[4];       /* and whether the types are unsigned.  */
1201 };
1202
1203 static GTY ((param_is (struct builtin_hash_struct))) htab_t builtin_hash_table;
1204
1205 static bool rs6000_valid_attribute_p (tree, tree, tree, int);
1206 static void rs6000_function_specific_save (struct cl_target_option *);
1207 static void rs6000_function_specific_restore (struct cl_target_option *);
1208 static void rs6000_function_specific_print (FILE *, int,
1209                                             struct cl_target_option *);
1210 static bool rs6000_can_inline_p (tree, tree);
1211 static void rs6000_set_current_function (tree);
1212
1213 \f
1214 /* Default register names.  */
1215 char rs6000_reg_names[][8] =
1216 {
1217       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1218       "8",  "9", "10", "11", "12", "13", "14", "15",
1219      "16", "17", "18", "19", "20", "21", "22", "23",
1220      "24", "25", "26", "27", "28", "29", "30", "31",
1221       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1222       "8",  "9", "10", "11", "12", "13", "14", "15",
1223      "16", "17", "18", "19", "20", "21", "22", "23",
1224      "24", "25", "26", "27", "28", "29", "30", "31",
1225      "mq", "lr", "ctr","ap",
1226       "0",  "1",  "2",  "3",  "4",  "5",  "6",  "7",
1227       "ca",
1228       /* AltiVec registers.  */
1229       "0",  "1",  "2",  "3",  "4",  "5",  "6", "7",
1230       "8",  "9",  "10", "11", "12", "13", "14", "15",
1231       "16", "17", "18", "19", "20", "21", "22", "23",
1232       "24", "25", "26", "27", "28", "29", "30", "31",
1233       "vrsave", "vscr",
1234       /* SPE registers.  */
1235       "spe_acc", "spefscr",
1236       /* Soft frame pointer.  */
1237       "sfp"
1238 };
1239
1240 #ifdef TARGET_REGNAMES
1241 static const char alt_reg_names[][8] =
1242 {
1243    "%r0",   "%r1",  "%r2",  "%r3",  "%r4",  "%r5",  "%r6",  "%r7",
1244    "%r8",   "%r9", "%r10", "%r11", "%r12", "%r13", "%r14", "%r15",
1245   "%r16",  "%r17", "%r18", "%r19", "%r20", "%r21", "%r22", "%r23",
1246   "%r24",  "%r25", "%r26", "%r27", "%r28", "%r29", "%r30", "%r31",
1247    "%f0",   "%f1",  "%f2",  "%f3",  "%f4",  "%f5",  "%f6",  "%f7",
1248    "%f8",   "%f9", "%f10", "%f11", "%f12", "%f13", "%f14", "%f15",
1249   "%f16",  "%f17", "%f18", "%f19", "%f20", "%f21", "%f22", "%f23",
1250   "%f24",  "%f25", "%f26", "%f27", "%f28", "%f29", "%f30", "%f31",
1251     "mq",    "lr",  "ctr",   "ap",
1252   "%cr0",  "%cr1", "%cr2", "%cr3", "%cr4", "%cr5", "%cr6", "%cr7",
1253    "ca",
1254   /* AltiVec registers.  */
1255    "%v0",  "%v1",  "%v2",  "%v3",  "%v4",  "%v5",  "%v6", "%v7",
1256    "%v8",  "%v9", "%v10", "%v11", "%v12", "%v13", "%v14", "%v15",
1257   "%v16", "%v17", "%v18", "%v19", "%v20", "%v21", "%v22", "%v23",
1258   "%v24", "%v25", "%v26", "%v27", "%v28", "%v29", "%v30", "%v31",
1259   "vrsave", "vscr",
1260   /* SPE registers.  */
1261   "spe_acc", "spefscr",
1262   /* Soft frame pointer.  */
1263   "sfp"
1264 };
1265 #endif
1266
1267 /* Table of valid machine attributes.  */
1268
1269 static const struct attribute_spec rs6000_attribute_table[] =
1270 {
1271   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler,
1272        affects_type_identity } */
1273   { "altivec",   1, 1, false, true,  false, rs6000_handle_altivec_attribute,
1274     false },
1275   { "longcall",  0, 0, false, true,  true,  rs6000_handle_longcall_attribute,
1276     false },
1277   { "shortcall", 0, 0, false, true,  true,  rs6000_handle_longcall_attribute,
1278     false },
1279   { "ms_struct", 0, 0, false, false, false, rs6000_handle_struct_attribute,
1280     false },
1281   { "gcc_struct", 0, 0, false, false, false, rs6000_handle_struct_attribute,
1282     false },
1283 #ifdef SUBTARGET_ATTRIBUTE_TABLE
1284   SUBTARGET_ATTRIBUTE_TABLE,
1285 #endif
1286   { NULL,        0, 0, false, false, false, NULL, false }
1287 };
1288 \f
1289 #ifndef MASK_STRICT_ALIGN
1290 #define MASK_STRICT_ALIGN 0
1291 #endif
1292 #ifndef TARGET_PROFILE_KERNEL
1293 #define TARGET_PROFILE_KERNEL 0
1294 #endif
1295
1296 /* The VRSAVE bitmask puts bit %v0 as the most significant bit.  */
1297 #define ALTIVEC_REG_BIT(REGNO) (0x80000000 >> ((REGNO) - FIRST_ALTIVEC_REGNO))
1298 \f
1299 /* Initialize the GCC target structure.  */
1300 #undef TARGET_ATTRIBUTE_TABLE
1301 #define TARGET_ATTRIBUTE_TABLE rs6000_attribute_table
1302 #undef TARGET_SET_DEFAULT_TYPE_ATTRIBUTES
1303 #define TARGET_SET_DEFAULT_TYPE_ATTRIBUTES rs6000_set_default_type_attributes
1304 #undef TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P
1305 #define TARGET_ATTRIBUTE_TAKES_IDENTIFIER_P rs6000_attribute_takes_identifier_p
1306
1307 #undef TARGET_ASM_ALIGNED_DI_OP
1308 #define TARGET_ASM_ALIGNED_DI_OP DOUBLE_INT_ASM_OP
1309
1310 /* Default unaligned ops are only provided for ELF.  Find the ops needed
1311    for non-ELF systems.  */
1312 #ifndef OBJECT_FORMAT_ELF
1313 #if TARGET_XCOFF
1314 /* For XCOFF.  rs6000_assemble_integer will handle unaligned DIs on
1315    64-bit targets.  */
1316 #undef TARGET_ASM_UNALIGNED_HI_OP
1317 #define TARGET_ASM_UNALIGNED_HI_OP "\t.vbyte\t2,"
1318 #undef TARGET_ASM_UNALIGNED_SI_OP
1319 #define TARGET_ASM_UNALIGNED_SI_OP "\t.vbyte\t4,"
1320 #undef TARGET_ASM_UNALIGNED_DI_OP
1321 #define TARGET_ASM_UNALIGNED_DI_OP "\t.vbyte\t8,"
1322 #else
1323 /* For Darwin.  */
1324 #undef TARGET_ASM_UNALIGNED_HI_OP
1325 #define TARGET_ASM_UNALIGNED_HI_OP "\t.short\t"
1326 #undef TARGET_ASM_UNALIGNED_SI_OP
1327 #define TARGET_ASM_UNALIGNED_SI_OP "\t.long\t"
1328 #undef TARGET_ASM_UNALIGNED_DI_OP
1329 #define TARGET_ASM_UNALIGNED_DI_OP "\t.quad\t"
1330 #undef TARGET_ASM_ALIGNED_DI_OP
1331 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
1332 #endif
1333 #endif
1334
1335 /* This hook deals with fixups for relocatable code and DI-mode objects
1336    in 64-bit code.  */
1337 #undef TARGET_ASM_INTEGER
1338 #define TARGET_ASM_INTEGER rs6000_assemble_integer
1339
1340 #if defined (HAVE_GAS_HIDDEN) && !defined (TARGET_MACHO)
1341 #undef TARGET_ASM_ASSEMBLE_VISIBILITY
1342 #define TARGET_ASM_ASSEMBLE_VISIBILITY rs6000_assemble_visibility
1343 #endif
1344
1345 #undef TARGET_HAVE_TLS
1346 #define TARGET_HAVE_TLS HAVE_AS_TLS
1347
1348 #undef TARGET_CANNOT_FORCE_CONST_MEM
1349 #define TARGET_CANNOT_FORCE_CONST_MEM rs6000_cannot_force_const_mem
1350
1351 #undef TARGET_DELEGITIMIZE_ADDRESS
1352 #define TARGET_DELEGITIMIZE_ADDRESS rs6000_delegitimize_address
1353
1354 #undef TARGET_ASM_FUNCTION_PROLOGUE
1355 #define TARGET_ASM_FUNCTION_PROLOGUE rs6000_output_function_prologue
1356 #undef TARGET_ASM_FUNCTION_EPILOGUE
1357 #define TARGET_ASM_FUNCTION_EPILOGUE rs6000_output_function_epilogue
1358
1359 #undef TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA
1360 #define TARGET_ASM_OUTPUT_ADDR_CONST_EXTRA rs6000_output_addr_const_extra
1361
1362 #undef TARGET_LEGITIMIZE_ADDRESS
1363 #define TARGET_LEGITIMIZE_ADDRESS rs6000_legitimize_address
1364
1365 #undef  TARGET_SCHED_VARIABLE_ISSUE
1366 #define TARGET_SCHED_VARIABLE_ISSUE rs6000_variable_issue
1367
1368 #undef TARGET_SCHED_ISSUE_RATE
1369 #define TARGET_SCHED_ISSUE_RATE rs6000_issue_rate
1370 #undef TARGET_SCHED_ADJUST_COST
1371 #define TARGET_SCHED_ADJUST_COST rs6000_adjust_cost
1372 #undef TARGET_SCHED_ADJUST_PRIORITY
1373 #define TARGET_SCHED_ADJUST_PRIORITY rs6000_adjust_priority
1374 #undef TARGET_SCHED_IS_COSTLY_DEPENDENCE
1375 #define TARGET_SCHED_IS_COSTLY_DEPENDENCE rs6000_is_costly_dependence
1376 #undef TARGET_SCHED_INIT
1377 #define TARGET_SCHED_INIT rs6000_sched_init
1378 #undef TARGET_SCHED_FINISH
1379 #define TARGET_SCHED_FINISH rs6000_sched_finish
1380 #undef TARGET_SCHED_REORDER
1381 #define TARGET_SCHED_REORDER rs6000_sched_reorder
1382 #undef TARGET_SCHED_REORDER2
1383 #define TARGET_SCHED_REORDER2 rs6000_sched_reorder2
1384
1385 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
1386 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD rs6000_use_sched_lookahead
1387
1388 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD
1389 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD_GUARD rs6000_use_sched_lookahead_guard
1390
1391 #undef TARGET_SCHED_ALLOC_SCHED_CONTEXT
1392 #define TARGET_SCHED_ALLOC_SCHED_CONTEXT rs6000_alloc_sched_context
1393 #undef TARGET_SCHED_INIT_SCHED_CONTEXT
1394 #define TARGET_SCHED_INIT_SCHED_CONTEXT rs6000_init_sched_context
1395 #undef TARGET_SCHED_SET_SCHED_CONTEXT
1396 #define TARGET_SCHED_SET_SCHED_CONTEXT rs6000_set_sched_context
1397 #undef TARGET_SCHED_FREE_SCHED_CONTEXT
1398 #define TARGET_SCHED_FREE_SCHED_CONTEXT rs6000_free_sched_context
1399
1400 #undef TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD
1401 #define TARGET_VECTORIZE_BUILTIN_MASK_FOR_LOAD rs6000_builtin_mask_for_load
1402 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN
1403 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_EVEN rs6000_builtin_mul_widen_even
1404 #undef TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD
1405 #define TARGET_VECTORIZE_BUILTIN_MUL_WIDEN_ODD rs6000_builtin_mul_widen_odd
1406 #undef TARGET_VECTORIZE_BUILTIN_CONVERSION
1407 #define TARGET_VECTORIZE_BUILTIN_CONVERSION rs6000_builtin_conversion
1408 #undef TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT
1409 #define TARGET_VECTORIZE_SUPPORT_VECTOR_MISALIGNMENT            \
1410   rs6000_builtin_support_vector_misalignment
1411 #undef TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE
1412 #define TARGET_VECTORIZE_VECTOR_ALIGNMENT_REACHABLE rs6000_vector_alignment_reachable
1413 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST
1414 #define TARGET_VECTORIZE_BUILTIN_VECTORIZATION_COST \
1415   rs6000_builtin_vectorization_cost
1416 #undef TARGET_VECTORIZE_PREFERRED_SIMD_MODE
1417 #define TARGET_VECTORIZE_PREFERRED_SIMD_MODE \
1418   rs6000_preferred_simd_mode
1419
1420 #undef TARGET_INIT_BUILTINS
1421 #define TARGET_INIT_BUILTINS rs6000_init_builtins
1422 #undef TARGET_BUILTIN_DECL
1423 #define TARGET_BUILTIN_DECL rs6000_builtin_decl
1424
1425 #undef TARGET_EXPAND_BUILTIN
1426 #define TARGET_EXPAND_BUILTIN rs6000_expand_builtin
1427
1428 #undef TARGET_MANGLE_TYPE
1429 #define TARGET_MANGLE_TYPE rs6000_mangle_type
1430
1431 #undef TARGET_INIT_LIBFUNCS
1432 #define TARGET_INIT_LIBFUNCS rs6000_init_libfuncs
1433
1434 #if TARGET_MACHO
1435 #undef TARGET_BINDS_LOCAL_P
1436 #define TARGET_BINDS_LOCAL_P darwin_binds_local_p
1437 #endif
1438
1439 #undef TARGET_MS_BITFIELD_LAYOUT_P
1440 #define TARGET_MS_BITFIELD_LAYOUT_P rs6000_ms_bitfield_layout_p
1441
1442 #undef TARGET_ASM_OUTPUT_MI_THUNK
1443 #define TARGET_ASM_OUTPUT_MI_THUNK rs6000_output_mi_thunk
1444
1445 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
1446 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
1447
1448 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
1449 #define TARGET_FUNCTION_OK_FOR_SIBCALL rs6000_function_ok_for_sibcall
1450
1451 #undef TARGET_INVALID_WITHIN_DOLOOP
1452 #define TARGET_INVALID_WITHIN_DOLOOP rs6000_invalid_within_doloop
1453
1454 #undef TARGET_REGISTER_MOVE_COST
1455 #define TARGET_REGISTER_MOVE_COST rs6000_register_move_cost
1456 #undef TARGET_MEMORY_MOVE_COST
1457 #define TARGET_MEMORY_MOVE_COST rs6000_memory_move_cost
1458 #undef TARGET_RTX_COSTS
1459 #define TARGET_RTX_COSTS rs6000_rtx_costs
1460 #undef TARGET_ADDRESS_COST
1461 #define TARGET_ADDRESS_COST hook_int_rtx_bool_0
1462
1463 #undef TARGET_DWARF_REGISTER_SPAN
1464 #define TARGET_DWARF_REGISTER_SPAN rs6000_dwarf_register_span
1465
1466 #undef TARGET_INIT_DWARF_REG_SIZES_EXTRA
1467 #define TARGET_INIT_DWARF_REG_SIZES_EXTRA rs6000_init_dwarf_reg_sizes_extra
1468
1469 /* On rs6000, function arguments are promoted, as are function return
1470    values.  */
1471 #undef TARGET_PROMOTE_FUNCTION_MODE
1472 #define TARGET_PROMOTE_FUNCTION_MODE default_promote_function_mode_always_promote
1473
1474 #undef TARGET_RETURN_IN_MEMORY
1475 #define TARGET_RETURN_IN_MEMORY rs6000_return_in_memory
1476
1477 #undef TARGET_SETUP_INCOMING_VARARGS
1478 #define TARGET_SETUP_INCOMING_VARARGS setup_incoming_varargs
1479
1480 /* Always strict argument naming on rs6000.  */
1481 #undef TARGET_STRICT_ARGUMENT_NAMING
1482 #define TARGET_STRICT_ARGUMENT_NAMING hook_bool_CUMULATIVE_ARGS_true
1483 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
1484 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED hook_bool_CUMULATIVE_ARGS_true
1485 #undef TARGET_SPLIT_COMPLEX_ARG
1486 #define TARGET_SPLIT_COMPLEX_ARG hook_bool_const_tree_true
1487 #undef TARGET_MUST_PASS_IN_STACK
1488 #define TARGET_MUST_PASS_IN_STACK rs6000_must_pass_in_stack
1489 #undef TARGET_PASS_BY_REFERENCE
1490 #define TARGET_PASS_BY_REFERENCE rs6000_pass_by_reference
1491 #undef TARGET_ARG_PARTIAL_BYTES
1492 #define TARGET_ARG_PARTIAL_BYTES rs6000_arg_partial_bytes
1493 #undef TARGET_FUNCTION_ARG_ADVANCE
1494 #define TARGET_FUNCTION_ARG_ADVANCE rs6000_function_arg_advance
1495 #undef TARGET_FUNCTION_ARG
1496 #define TARGET_FUNCTION_ARG rs6000_function_arg
1497 #undef TARGET_FUNCTION_ARG_BOUNDARY
1498 #define TARGET_FUNCTION_ARG_BOUNDARY rs6000_function_arg_boundary
1499
1500 #undef TARGET_BUILD_BUILTIN_VA_LIST
1501 #define TARGET_BUILD_BUILTIN_VA_LIST rs6000_build_builtin_va_list
1502
1503 #undef TARGET_EXPAND_BUILTIN_VA_START
1504 #define TARGET_EXPAND_BUILTIN_VA_START rs6000_va_start
1505
1506 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
1507 #define TARGET_GIMPLIFY_VA_ARG_EXPR rs6000_gimplify_va_arg
1508
1509 #undef TARGET_EH_RETURN_FILTER_MODE
1510 #define TARGET_EH_RETURN_FILTER_MODE rs6000_eh_return_filter_mode
1511
1512 #undef TARGET_SCALAR_MODE_SUPPORTED_P
1513 #define TARGET_SCALAR_MODE_SUPPORTED_P rs6000_scalar_mode_supported_p
1514
1515 #undef TARGET_VECTOR_MODE_SUPPORTED_P
1516 #define TARGET_VECTOR_MODE_SUPPORTED_P rs6000_vector_mode_supported_p
1517
1518 #undef TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN
1519 #define TARGET_INVALID_ARG_FOR_UNPROTOTYPED_FN invalid_arg_for_unprototyped_fn
1520
1521 #undef TARGET_ASM_LOOP_ALIGN_MAX_SKIP
1522 #define TARGET_ASM_LOOP_ALIGN_MAX_SKIP rs6000_loop_align_max_skip
1523
1524 #undef TARGET_OPTION_OVERRIDE
1525 #define TARGET_OPTION_OVERRIDE rs6000_option_override
1526
1527 #undef TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION
1528 #define TARGET_VECTORIZE_BUILTIN_VECTORIZED_FUNCTION \
1529   rs6000_builtin_vectorized_function
1530
1531 #ifndef TARGET_MACHO
1532 #undef TARGET_STACK_PROTECT_FAIL
1533 #define TARGET_STACK_PROTECT_FAIL rs6000_stack_protect_fail
1534 #endif
1535
1536 /* MPC604EUM 3.5.2 Weak Consistency between Multiple Processors
1537    The PowerPC architecture requires only weak consistency among
1538    processors--that is, memory accesses between processors need not be
1539    sequentially consistent and memory accesses among processors can occur
1540    in any order. The ability to order memory accesses weakly provides
1541    opportunities for more efficient use of the system bus. Unless a
1542    dependency exists, the 604e allows read operations to precede store
1543    operations.  */
1544 #undef TARGET_RELAXED_ORDERING
1545 #define TARGET_RELAXED_ORDERING true
1546
1547 #ifdef HAVE_AS_TLS
1548 #undef TARGET_ASM_OUTPUT_DWARF_DTPREL
1549 #define TARGET_ASM_OUTPUT_DWARF_DTPREL rs6000_output_dwarf_dtprel
1550 #endif
1551
1552 /* Use a 32-bit anchor range.  This leads to sequences like:
1553
1554         addis   tmp,anchor,high
1555         add     dest,tmp,low
1556
1557    where tmp itself acts as an anchor, and can be shared between
1558    accesses to the same 64k page.  */
1559 #undef TARGET_MIN_ANCHOR_OFFSET
1560 #define TARGET_MIN_ANCHOR_OFFSET -0x7fffffff - 1
1561 #undef TARGET_MAX_ANCHOR_OFFSET
1562 #define TARGET_MAX_ANCHOR_OFFSET 0x7fffffff
1563 #undef TARGET_USE_BLOCKS_FOR_CONSTANT_P
1564 #define TARGET_USE_BLOCKS_FOR_CONSTANT_P rs6000_use_blocks_for_constant_p
1565
1566 #undef TARGET_BUILTIN_RECIPROCAL
1567 #define TARGET_BUILTIN_RECIPROCAL rs6000_builtin_reciprocal
1568
1569 #undef TARGET_EXPAND_TO_RTL_HOOK
1570 #define TARGET_EXPAND_TO_RTL_HOOK rs6000_alloc_sdmode_stack_slot
1571
1572 #undef TARGET_INSTANTIATE_DECLS
1573 #define TARGET_INSTANTIATE_DECLS rs6000_instantiate_decls
1574
1575 #undef TARGET_SECONDARY_RELOAD
1576 #define TARGET_SECONDARY_RELOAD rs6000_secondary_reload
1577
1578 #undef TARGET_LEGITIMATE_ADDRESS_P
1579 #define TARGET_LEGITIMATE_ADDRESS_P rs6000_legitimate_address_p
1580
1581 #undef TARGET_MODE_DEPENDENT_ADDRESS_P
1582 #define TARGET_MODE_DEPENDENT_ADDRESS_P rs6000_mode_dependent_address_p
1583
1584 #undef TARGET_CAN_ELIMINATE
1585 #define TARGET_CAN_ELIMINATE rs6000_can_eliminate
1586
1587 #undef TARGET_CONDITIONAL_REGISTER_USAGE
1588 #define TARGET_CONDITIONAL_REGISTER_USAGE rs6000_conditional_register_usage
1589
1590 #undef TARGET_TRAMPOLINE_INIT
1591 #define TARGET_TRAMPOLINE_INIT rs6000_trampoline_init
1592
1593 #undef TARGET_FUNCTION_VALUE
1594 #define TARGET_FUNCTION_VALUE rs6000_function_value
1595
1596 #undef TARGET_OPTION_VALID_ATTRIBUTE_P
1597 #define TARGET_OPTION_VALID_ATTRIBUTE_P rs6000_valid_attribute_p
1598
1599 #undef TARGET_OPTION_SAVE
1600 #define TARGET_OPTION_SAVE rs6000_function_specific_save
1601
1602 #undef TARGET_OPTION_RESTORE
1603 #define TARGET_OPTION_RESTORE rs6000_function_specific_restore
1604
1605 #undef TARGET_OPTION_PRINT
1606 #define TARGET_OPTION_PRINT rs6000_function_specific_print
1607
1608 #undef TARGET_CAN_INLINE_P
1609 #define TARGET_CAN_INLINE_P rs6000_can_inline_p
1610
1611 #undef TARGET_SET_CURRENT_FUNCTION
1612 #define TARGET_SET_CURRENT_FUNCTION rs6000_set_current_function
1613
1614 #undef TARGET_LEGITIMATE_CONSTANT_P
1615 #define TARGET_LEGITIMATE_CONSTANT_P rs6000_legitimate_constant_p
1616
1617 \f
1618
1619 /* Simplifications for entries below.  */
1620
1621 enum {
1622   POWERPC_BASE_MASK = MASK_POWERPC | MASK_NEW_MNEMONICS,
1623   POWERPC_7400_MASK = POWERPC_BASE_MASK | MASK_PPC_GFXOPT | MASK_ALTIVEC
1624 };
1625
1626 /* Some OSs don't support saving the high part of 64-bit registers on context
1627    switch.  Other OSs don't support saving Altivec registers.  On those OSs, we
1628    don't touch the MASK_POWERPC64 or MASK_ALTIVEC settings; if the user wants
1629    either, the user must explicitly specify them and we won't interfere with
1630    the user's specification.  */
1631
1632 enum {
1633   POWER_MASKS = MASK_POWER | MASK_POWER2 | MASK_MULTIPLE | MASK_STRING,
1634   POWERPC_MASKS = (POWERPC_BASE_MASK | MASK_PPC_GPOPT | MASK_STRICT_ALIGN
1635                    | MASK_PPC_GFXOPT | MASK_POWERPC64 | MASK_ALTIVEC
1636                    | MASK_MFCRF | MASK_POPCNTB | MASK_FPRND | MASK_MULHW
1637                    | MASK_DLMZB | MASK_CMPB | MASK_MFPGPR | MASK_DFP
1638                    | MASK_POPCNTD | MASK_VSX | MASK_ISEL | MASK_NO_UPDATE
1639                    | MASK_RECIP_PRECISION)
1640 };
1641
1642 /* Masks for instructions set at various powerpc ISAs.  */
1643 enum {
1644   ISA_2_1_MASKS = MASK_MFCRF,
1645   ISA_2_2_MASKS = (ISA_2_1_MASKS | MASK_POPCNTB),
1646   ISA_2_4_MASKS = (ISA_2_2_MASKS | MASK_FPRND),
1647
1648   /* For ISA 2.05, do not add MFPGPR, since it isn't in ISA 2.06, and don't add
1649      ALTIVEC, since in general it isn't a win on power6.  In ISA 2.04, fsel,
1650      fre, fsqrt, etc. were no longer documented as optional.  Group masks by
1651      server and embedded. */
1652   ISA_2_5_MASKS_EMBEDDED = (ISA_2_2_MASKS | MASK_CMPB | MASK_RECIP_PRECISION
1653                             | MASK_PPC_GFXOPT | MASK_PPC_GPOPT),
1654   ISA_2_5_MASKS_SERVER = (ISA_2_5_MASKS_EMBEDDED | MASK_DFP),
1655
1656   /* For ISA 2.06, don't add ISEL, since in general it isn't a win, but
1657      altivec is a win so enable it.  */
1658   ISA_2_6_MASKS_EMBEDDED = (ISA_2_5_MASKS_EMBEDDED | MASK_POPCNTD),
1659   ISA_2_6_MASKS_SERVER = (ISA_2_5_MASKS_SERVER | MASK_POPCNTD | MASK_ALTIVEC
1660                           | MASK_VSX)
1661 };
1662
1663 struct rs6000_ptt
1664 {
1665   const char *const name;               /* Canonical processor name.  */
1666   const enum processor_type processor;  /* Processor type enum value.  */
1667   const int target_enable;              /* Target flags to enable.  */
1668 };
1669
1670 static struct rs6000_ptt const processor_target_table[] =
1671 {
1672 #define RS6000_CPU(NAME, CPU, FLAGS) { NAME, CPU, FLAGS },
1673 #include "rs6000-cpus.def"
1674 #undef RS6000_CPU
1675 };
1676
1677 /* Look up a processor name for -mcpu=xxx and -mtune=xxx.  Return -1 if the
1678    name is invalid.  */
1679
1680 static int
1681 rs6000_cpu_name_lookup (const char *name)
1682 {
1683   size_t i;
1684
1685   if (name != NULL)
1686     {
1687       for (i = 0; i < ARRAY_SIZE (processor_target_table); i++)
1688         if (! strcmp (name, processor_target_table[i].name))
1689           return (int)i;
1690     }
1691
1692   return -1;
1693 }
1694
1695 \f
1696 /* Return number of consecutive hard regs needed starting at reg REGNO
1697    to hold something of mode MODE.
1698    This is ordinarily the length in words of a value of mode MODE
1699    but can be less for certain modes in special long registers.
1700
1701    For the SPE, GPRs are 64 bits but only 32 bits are visible in
1702    scalar instructions.  The upper 32 bits are only available to the
1703    SIMD instructions.
1704
1705    POWER and PowerPC GPRs hold 32 bits worth;
1706    PowerPC64 GPRs and FPRs point register holds 64 bits worth.  */
1707
1708 static int
1709 rs6000_hard_regno_nregs_internal (int regno, enum machine_mode mode)
1710 {
1711   unsigned HOST_WIDE_INT reg_size;
1712
1713   if (FP_REGNO_P (regno))
1714     reg_size = (VECTOR_MEM_VSX_P (mode)
1715                 ? UNITS_PER_VSX_WORD
1716                 : UNITS_PER_FP_WORD);
1717
1718   else if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1719     reg_size = UNITS_PER_SPE_WORD;
1720
1721   else if (ALTIVEC_REGNO_P (regno))
1722     reg_size = UNITS_PER_ALTIVEC_WORD;
1723
1724   /* The value returned for SCmode in the E500 double case is 2 for
1725      ABI compatibility; storing an SCmode value in a single register
1726      would require function_arg and rs6000_spe_function_arg to handle
1727      SCmode so as to pass the value correctly in a pair of
1728      registers.  */
1729   else if (TARGET_E500_DOUBLE && FLOAT_MODE_P (mode) && mode != SCmode
1730            && !DECIMAL_FLOAT_MODE_P (mode))
1731     reg_size = UNITS_PER_FP_WORD;
1732
1733   else
1734     reg_size = UNITS_PER_WORD;
1735
1736   return (GET_MODE_SIZE (mode) + reg_size - 1) / reg_size;
1737 }
1738
1739 /* Value is 1 if hard register REGNO can hold a value of machine-mode
1740    MODE.  */
1741 static int
1742 rs6000_hard_regno_mode_ok (int regno, enum machine_mode mode)
1743 {
1744   int last_regno = regno + rs6000_hard_regno_nregs[mode][regno] - 1;
1745
1746   /* VSX registers that overlap the FPR registers are larger than for non-VSX
1747      implementations.  Don't allow an item to be split between a FP register
1748      and an Altivec register.  */
1749   if (VECTOR_MEM_VSX_P (mode))
1750     {
1751       if (FP_REGNO_P (regno))
1752         return FP_REGNO_P (last_regno);
1753
1754       if (ALTIVEC_REGNO_P (regno))
1755         return ALTIVEC_REGNO_P (last_regno);
1756     }
1757
1758   /* The GPRs can hold any mode, but values bigger than one register
1759      cannot go past R31.  */
1760   if (INT_REGNO_P (regno))
1761     return INT_REGNO_P (last_regno);
1762
1763   /* The float registers (except for VSX vector modes) can only hold floating
1764      modes and DImode.  This excludes the 32-bit decimal float mode for
1765      now.  */
1766   if (FP_REGNO_P (regno))
1767     {
1768       if (SCALAR_FLOAT_MODE_P (mode)
1769           && (mode != TDmode || (regno % 2) == 0)
1770           && FP_REGNO_P (last_regno))
1771         return 1;
1772
1773       if (GET_MODE_CLASS (mode) == MODE_INT
1774           && GET_MODE_SIZE (mode) == UNITS_PER_FP_WORD)
1775         return 1;
1776
1777       if (PAIRED_SIMD_REGNO_P (regno) && TARGET_PAIRED_FLOAT
1778           && PAIRED_VECTOR_MODE (mode))
1779         return 1;
1780
1781       return 0;
1782     }
1783
1784   /* The CR register can only hold CC modes.  */
1785   if (CR_REGNO_P (regno))
1786     return GET_MODE_CLASS (mode) == MODE_CC;
1787
1788   if (CA_REGNO_P (regno))
1789     return mode == BImode;
1790
1791   /* AltiVec only in AldyVec registers.  */
1792   if (ALTIVEC_REGNO_P (regno))
1793     return VECTOR_MEM_ALTIVEC_OR_VSX_P (mode);
1794
1795   /* ...but GPRs can hold SIMD data on the SPE in one register.  */
1796   if (SPE_SIMD_REGNO_P (regno) && TARGET_SPE && SPE_VECTOR_MODE (mode))
1797     return 1;
1798
1799   /* We cannot put TImode anywhere except general register and it must be able
1800      to fit within the register set.  In the future, allow TImode in the
1801      Altivec or VSX registers.  */
1802
1803   return GET_MODE_SIZE (mode) <= UNITS_PER_WORD;
1804 }
1805
1806 /* Print interesting facts about registers.  */
1807 static void
1808 rs6000_debug_reg_print (int first_regno, int last_regno, const char *reg_name)
1809 {
1810   int r, m;
1811
1812   for (r = first_regno; r <= last_regno; ++r)
1813     {
1814       const char *comma = "";
1815       int len;
1816
1817       if (first_regno == last_regno)
1818         fprintf (stderr, "%s:\t", reg_name);
1819       else
1820         fprintf (stderr, "%s%d:\t", reg_name, r - first_regno);
1821
1822       len = 8;
1823       for (m = 0; m < NUM_MACHINE_MODES; ++m)
1824         if (rs6000_hard_regno_mode_ok_p[m][r] && rs6000_hard_regno_nregs[m][r])
1825           {
1826             if (len > 70)
1827               {
1828                 fprintf (stderr, ",\n\t");
1829                 len = 8;
1830                 comma = "";
1831               }
1832
1833             if (rs6000_hard_regno_nregs[m][r] > 1)
1834               len += fprintf (stderr, "%s%s/%d", comma, GET_MODE_NAME (m),
1835                              rs6000_hard_regno_nregs[m][r]);
1836             else
1837               len += fprintf (stderr, "%s%s", comma, GET_MODE_NAME (m));
1838
1839             comma = ", ";
1840           }
1841
1842       if (call_used_regs[r])
1843         {
1844           if (len > 70)
1845             {
1846               fprintf (stderr, ",\n\t");
1847               len = 8;
1848               comma = "";
1849             }
1850
1851           len += fprintf (stderr, "%s%s", comma, "call-used");
1852           comma = ", ";
1853         }
1854
1855       if (fixed_regs[r])
1856         {
1857           if (len > 70)
1858             {
1859               fprintf (stderr, ",\n\t");
1860               len = 8;
1861               comma = "";
1862             }
1863
1864           len += fprintf (stderr, "%s%s", comma, "fixed");
1865           comma = ", ";
1866         }
1867
1868       if (len > 70)
1869         {
1870           fprintf (stderr, ",\n\t");
1871           comma = "";
1872         }
1873
1874       fprintf (stderr, "%sregno = %d\n", comma, r);
1875     }
1876 }
1877
1878 #define DEBUG_FMT_D "%-32s= %d\n"
1879 #define DEBUG_FMT_S "%-32s= %s\n"
1880
1881 /* Print various interesting information with -mdebug=reg.  */
1882 static void
1883 rs6000_debug_reg_global (void)
1884 {
1885   static const char *const tf[2] = { "false", "true" };
1886   const char *nl = (const char *)0;
1887   int m;
1888   char costly_num[20];
1889   char nop_num[20];
1890   const char *costly_str;
1891   const char *nop_str;
1892   const char *trace_str;
1893   const char *abi_str;
1894   const char *cmodel_str;
1895
1896   /* Map enum rs6000_vector to string.  */
1897   static const char *rs6000_debug_vector_unit[] = {
1898     "none",
1899     "altivec",
1900     "vsx",
1901     "paired",
1902     "spe",
1903     "other"
1904   };
1905
1906   fprintf (stderr, "Register information: (last virtual reg = %d)\n",
1907            LAST_VIRTUAL_REGISTER);
1908   rs6000_debug_reg_print (0, 31, "gr");
1909   rs6000_debug_reg_print (32, 63, "fp");
1910   rs6000_debug_reg_print (FIRST_ALTIVEC_REGNO,
1911                           LAST_ALTIVEC_REGNO,
1912                           "vs");
1913   rs6000_debug_reg_print (LR_REGNO, LR_REGNO, "lr");
1914   rs6000_debug_reg_print (CTR_REGNO, CTR_REGNO, "ctr");
1915   rs6000_debug_reg_print (CR0_REGNO, CR7_REGNO, "cr");
1916   rs6000_debug_reg_print (MQ_REGNO, MQ_REGNO, "mq");
1917   rs6000_debug_reg_print (CA_REGNO, CA_REGNO, "ca");
1918   rs6000_debug_reg_print (VRSAVE_REGNO, VRSAVE_REGNO, "vrsave");
1919   rs6000_debug_reg_print (VSCR_REGNO, VSCR_REGNO, "vscr");
1920   rs6000_debug_reg_print (SPE_ACC_REGNO, SPE_ACC_REGNO, "spe_a");
1921   rs6000_debug_reg_print (SPEFSCR_REGNO, SPEFSCR_REGNO, "spe_f");
1922
1923   fprintf (stderr,
1924            "\n"
1925            "d  reg_class = %s\n"
1926            "f  reg_class = %s\n"
1927            "v  reg_class = %s\n"
1928            "wa reg_class = %s\n"
1929            "wd reg_class = %s\n"
1930            "wf reg_class = %s\n"
1931            "ws reg_class = %s\n\n",
1932            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_d]],
1933            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_f]],
1934            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_v]],
1935            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wa]],
1936            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wd]],
1937            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_wf]],
1938            reg_class_names[rs6000_constraints[RS6000_CONSTRAINT_ws]]);
1939
1940   for (m = 0; m < NUM_MACHINE_MODES; ++m)
1941     if (rs6000_vector_unit[m] || rs6000_vector_mem[m])
1942       {
1943         nl = "\n";
1944         fprintf (stderr, "Vector mode: %-5s arithmetic: %-8s move: %-8s\n",
1945                  GET_MODE_NAME (m),
1946                  rs6000_debug_vector_unit[ rs6000_vector_unit[m] ],
1947                  rs6000_debug_vector_unit[ rs6000_vector_mem[m] ]);
1948       }
1949
1950   if (nl)
1951     fputs (nl, stderr);
1952
1953   if (rs6000_recip_control)
1954     {
1955       fprintf (stderr, "\nReciprocal mask = 0x%x\n", rs6000_recip_control);
1956
1957       for (m = 0; m < NUM_MACHINE_MODES; ++m)
1958         if (rs6000_recip_bits[m])
1959           {
1960             fprintf (stderr,
1961                      "Reciprocal estimate mode: %-5s divide: %s rsqrt: %s\n",
1962                      GET_MODE_NAME (m),
1963                      (RS6000_RECIP_AUTO_RE_P (m)
1964                       ? "auto"
1965                       : (RS6000_RECIP_HAVE_RE_P (m) ? "have" : "none")),
1966                      (RS6000_RECIP_AUTO_RSQRTE_P (m)
1967                       ? "auto"
1968                       : (RS6000_RECIP_HAVE_RSQRTE_P (m) ? "have" : "none")));
1969           }
1970
1971       fputs ("\n", stderr);
1972     }
1973
1974   if (rs6000_cpu_index >= 0)
1975     fprintf (stderr, DEBUG_FMT_S, "cpu",
1976              processor_target_table[rs6000_cpu_index].name);
1977
1978   if (rs6000_tune_index >= 0)
1979     fprintf (stderr, DEBUG_FMT_S, "tune",
1980              processor_target_table[rs6000_tune_index].name);
1981
1982   switch (rs6000_sched_costly_dep)
1983     {
1984     case max_dep_latency:
1985       costly_str = "max_dep_latency";
1986       break;
1987
1988     case no_dep_costly:
1989       costly_str = "no_dep_costly";
1990       break;
1991
1992     case all_deps_costly:
1993       costly_str = "all_deps_costly";
1994       break;
1995
1996     case true_store_to_load_dep_costly:
1997       costly_str = "true_store_to_load_dep_costly";
1998       break;
1999
2000     case store_to_load_dep_costly:
2001       costly_str = "store_to_load_dep_costly";
2002       break;
2003
2004     default:
2005       costly_str = costly_num;
2006       sprintf (costly_num, "%d", (int)rs6000_sched_costly_dep);
2007       break;
2008     }
2009
2010   fprintf (stderr, DEBUG_FMT_S, "sched_costly_dep", costly_str);
2011
2012   switch (rs6000_sched_insert_nops)
2013     {
2014     case sched_finish_regroup_exact:
2015       nop_str = "sched_finish_regroup_exact";
2016       break;
2017
2018     case sched_finish_pad_groups:
2019       nop_str = "sched_finish_pad_groups";
2020       break;
2021
2022     case sched_finish_none:
2023       nop_str = "sched_finish_none";
2024       break;
2025
2026     default:
2027       nop_str = nop_num;
2028       sprintf (nop_num, "%d", (int)rs6000_sched_insert_nops);
2029       break;
2030     }
2031
2032   fprintf (stderr, DEBUG_FMT_S, "sched_insert_nops", nop_str);
2033
2034   switch (rs6000_sdata)
2035     {
2036     default:
2037     case SDATA_NONE:
2038       break;
2039
2040     case SDATA_DATA:
2041       fprintf (stderr, DEBUG_FMT_S, "sdata", "data");
2042       break;
2043
2044     case SDATA_SYSV:
2045       fprintf (stderr, DEBUG_FMT_S, "sdata", "sysv");
2046       break;
2047
2048     case SDATA_EABI:
2049       fprintf (stderr, DEBUG_FMT_S, "sdata", "eabi");
2050       break;
2051
2052     }
2053
2054   switch (rs6000_traceback)
2055     {
2056     case traceback_default:     trace_str = "default";  break;
2057     case traceback_none:        trace_str = "none";     break;
2058     case traceback_part:        trace_str = "part";     break;
2059     case traceback_full:        trace_str = "full";     break;
2060     default:                    trace_str = "unknown";  break;
2061     }
2062
2063   fprintf (stderr, DEBUG_FMT_S, "traceback", trace_str);
2064
2065   switch (rs6000_current_cmodel)
2066     {
2067     case CMODEL_SMALL:  cmodel_str = "small";   break;
2068     case CMODEL_MEDIUM: cmodel_str = "medium";  break;
2069     case CMODEL_LARGE:  cmodel_str = "large";   break;
2070     default:            cmodel_str = "unknown"; break;
2071     }
2072
2073   fprintf (stderr, DEBUG_FMT_S, "cmodel", cmodel_str);
2074
2075   switch (rs6000_current_abi)
2076     {
2077     case ABI_NONE:      abi_str = "none";       break;
2078     case ABI_AIX:       abi_str = "aix";        break;
2079     case ABI_V4:        abi_str = "V4";         break;
2080     case ABI_DARWIN:    abi_str = "darwin";     break;
2081     default:            abi_str = "unknown";    break;
2082     }
2083
2084   fprintf (stderr, DEBUG_FMT_S, "abi", abi_str);
2085
2086   if (rs6000_altivec_abi)
2087     fprintf (stderr, DEBUG_FMT_S, "altivec_abi", "true");
2088
2089   if (rs6000_spe_abi)
2090     fprintf (stderr, DEBUG_FMT_S, "spe_abi", "true");
2091
2092   if (rs6000_darwin64_abi)
2093     fprintf (stderr, DEBUG_FMT_S, "darwin64_abi", "true");
2094
2095   if (rs6000_float_gprs)
2096     fprintf (stderr, DEBUG_FMT_S, "float_gprs", "true");
2097
2098   fprintf (stderr, DEBUG_FMT_S, "always_hint", tf[!!rs6000_always_hint]);
2099   fprintf (stderr, DEBUG_FMT_S, "align_branch",
2100            tf[!!rs6000_align_branch_targets]);
2101   fprintf (stderr, DEBUG_FMT_D, "tls_size", rs6000_tls_size);
2102   fprintf (stderr, DEBUG_FMT_D, "long_double_size",
2103            rs6000_long_double_type_size);
2104   fprintf (stderr, DEBUG_FMT_D, "sched_restricted_insns_priority",
2105            (int)rs6000_sched_restricted_insns_priority);
2106 }
2107
2108 /* Initialize the various global tables that are based on register size.  */
2109 static void
2110 rs6000_init_hard_regno_mode_ok (bool global_init_p)
2111 {
2112   int r, m, c;
2113   int align64;
2114   int align32;
2115
2116   /* Precalculate REGNO_REG_CLASS.  */
2117   rs6000_regno_regclass[0] = GENERAL_REGS;
2118   for (r = 1; r < 32; ++r)
2119     rs6000_regno_regclass[r] = BASE_REGS;
2120
2121   for (r = 32; r < 64; ++r)
2122     rs6000_regno_regclass[r] = FLOAT_REGS;
2123
2124   for (r = 64; r < FIRST_PSEUDO_REGISTER; ++r)
2125     rs6000_regno_regclass[r] = NO_REGS;
2126
2127   for (r = FIRST_ALTIVEC_REGNO; r <= LAST_ALTIVEC_REGNO; ++r)
2128     rs6000_regno_regclass[r] = ALTIVEC_REGS;
2129
2130   rs6000_regno_regclass[CR0_REGNO] = CR0_REGS;
2131   for (r = CR1_REGNO; r <= CR7_REGNO; ++r)
2132     rs6000_regno_regclass[r] = CR_REGS;
2133
2134   rs6000_regno_regclass[MQ_REGNO] = MQ_REGS;
2135   rs6000_regno_regclass[LR_REGNO] = LINK_REGS;
2136   rs6000_regno_regclass[CTR_REGNO] = CTR_REGS;
2137   rs6000_regno_regclass[CA_REGNO] = CA_REGS;
2138   rs6000_regno_regclass[VRSAVE_REGNO] = VRSAVE_REGS;
2139   rs6000_regno_regclass[VSCR_REGNO] = VRSAVE_REGS;
2140   rs6000_regno_regclass[SPE_ACC_REGNO] = SPE_ACC_REGS;
2141   rs6000_regno_regclass[SPEFSCR_REGNO] = SPEFSCR_REGS;
2142   rs6000_regno_regclass[ARG_POINTER_REGNUM] = BASE_REGS;
2143   rs6000_regno_regclass[FRAME_POINTER_REGNUM] = BASE_REGS;
2144
2145   /* Precalculate vector information, this must be set up before the
2146      rs6000_hard_regno_nregs_internal below.  */
2147   for (m = 0; m < NUM_MACHINE_MODES; ++m)
2148     {
2149       rs6000_vector_unit[m] = rs6000_vector_mem[m] = VECTOR_NONE;
2150       rs6000_vector_reload[m][0] = CODE_FOR_nothing;
2151       rs6000_vector_reload[m][1] = CODE_FOR_nothing;
2152     }
2153
2154   for (c = 0; c < (int)(int)RS6000_CONSTRAINT_MAX; c++)
2155     rs6000_constraints[c] = NO_REGS;
2156
2157   /* The VSX hardware allows native alignment for vectors, but control whether the compiler
2158      believes it can use native alignment or still uses 128-bit alignment.  */
2159   if (TARGET_VSX && !TARGET_VSX_ALIGN_128)
2160     {
2161       align64 = 64;
2162       align32 = 32;
2163     }
2164   else
2165     {
2166       align64 = 128;
2167       align32 = 128;
2168     }
2169
2170   /* V2DF mode, VSX only.  */
2171   if (TARGET_VSX)
2172     {
2173       rs6000_vector_unit[V2DFmode] = VECTOR_VSX;
2174       rs6000_vector_mem[V2DFmode] = VECTOR_VSX;
2175       rs6000_vector_align[V2DFmode] = align64;
2176     }
2177
2178   /* V4SF mode, either VSX or Altivec.  */
2179   if (TARGET_VSX)
2180     {
2181       rs6000_vector_unit[V4SFmode] = VECTOR_VSX;
2182       rs6000_vector_mem[V4SFmode] = VECTOR_VSX;
2183       rs6000_vector_align[V4SFmode] = align32;
2184     }
2185   else if (TARGET_ALTIVEC)
2186     {
2187       rs6000_vector_unit[V4SFmode] = VECTOR_ALTIVEC;
2188       rs6000_vector_mem[V4SFmode] = VECTOR_ALTIVEC;
2189       rs6000_vector_align[V4SFmode] = align32;
2190     }
2191
2192   /* V16QImode, V8HImode, V4SImode are Altivec only, but possibly do VSX loads
2193      and stores. */
2194   if (TARGET_ALTIVEC)
2195     {
2196       rs6000_vector_unit[V4SImode] = VECTOR_ALTIVEC;
2197       rs6000_vector_unit[V8HImode] = VECTOR_ALTIVEC;
2198       rs6000_vector_unit[V16QImode] = VECTOR_ALTIVEC;
2199       rs6000_vector_align[V4SImode] = align32;
2200       rs6000_vector_align[V8HImode] = align32;
2201       rs6000_vector_align[V16QImode] = align32;
2202
2203       if (TARGET_VSX)
2204         {
2205           rs6000_vector_mem[V4SImode] = VECTOR_VSX;
2206           rs6000_vector_mem[V8HImode] = VECTOR_VSX;
2207           rs6000_vector_mem[V16QImode] = VECTOR_VSX;
2208         }
2209       else
2210         {
2211           rs6000_vector_mem[V4SImode] = VECTOR_ALTIVEC;
2212           rs6000_vector_mem[V8HImode] = VECTOR_ALTIVEC;
2213           rs6000_vector_mem[V16QImode] = VECTOR_ALTIVEC;
2214         }
2215     }
2216
2217   /* V2DImode, only allow under VSX, which can do V2DI insert/splat/extract.
2218      Altivec doesn't have 64-bit support.  */
2219   if (TARGET_VSX)
2220     {
2221       rs6000_vector_mem[V2DImode] = VECTOR_VSX;
2222       rs6000_vector_unit[V2DImode] = VECTOR_NONE;
2223       rs6000_vector_align[V2DImode] = align64;
2224     }
2225
2226   /* DFmode, see if we want to use the VSX unit.  */
2227   if (TARGET_VSX && TARGET_VSX_SCALAR_DOUBLE)
2228     {
2229       rs6000_vector_unit[DFmode] = VECTOR_VSX;
2230       rs6000_vector_mem[DFmode]
2231         = (TARGET_VSX_SCALAR_MEMORY ? VECTOR_VSX : VECTOR_NONE);
2232       rs6000_vector_align[DFmode] = align64;
2233     }
2234
2235   /* TODO add SPE and paired floating point vector support.  */
2236
2237   /* Register class constaints for the constraints that depend on compile
2238      switches.  */
2239   if (TARGET_HARD_FLOAT && TARGET_FPRS)
2240     rs6000_constraints[RS6000_CONSTRAINT_f] = FLOAT_REGS;
2241
2242   if (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
2243     rs6000_constraints[RS6000_CONSTRAINT_d] = FLOAT_REGS;
2244
2245   if (TARGET_VSX)
2246     {
2247       /* At present, we just use VSX_REGS, but we have different constraints
2248          based on the use, in case we want to fine tune the default register
2249          class used.  wa = any VSX register, wf = register class to use for
2250          V4SF, wd = register class to use for V2DF, and ws = register classs to
2251          use for DF scalars.  */
2252       rs6000_constraints[RS6000_CONSTRAINT_wa] = VSX_REGS;
2253       rs6000_constraints[RS6000_CONSTRAINT_wf] = VSX_REGS;
2254       rs6000_constraints[RS6000_CONSTRAINT_wd] = VSX_REGS;
2255       rs6000_constraints[RS6000_CONSTRAINT_ws] = (TARGET_VSX_SCALAR_MEMORY
2256                                                   ? VSX_REGS
2257                                                   : FLOAT_REGS);
2258     }
2259
2260   if (TARGET_ALTIVEC)
2261     rs6000_constraints[RS6000_CONSTRAINT_v] = ALTIVEC_REGS;
2262
2263   /* Set up the reload helper functions.  */
2264   if (TARGET_VSX || TARGET_ALTIVEC)
2265     {
2266       if (TARGET_64BIT)
2267         {
2268           rs6000_vector_reload[V16QImode][0] = CODE_FOR_reload_v16qi_di_store;
2269           rs6000_vector_reload[V16QImode][1] = CODE_FOR_reload_v16qi_di_load;
2270           rs6000_vector_reload[V8HImode][0]  = CODE_FOR_reload_v8hi_di_store;
2271           rs6000_vector_reload[V8HImode][1]  = CODE_FOR_reload_v8hi_di_load;
2272           rs6000_vector_reload[V4SImode][0]  = CODE_FOR_reload_v4si_di_store;
2273           rs6000_vector_reload[V4SImode][1]  = CODE_FOR_reload_v4si_di_load;
2274           rs6000_vector_reload[V2DImode][0]  = CODE_FOR_reload_v2di_di_store;
2275           rs6000_vector_reload[V2DImode][1]  = CODE_FOR_reload_v2di_di_load;
2276           rs6000_vector_reload[V4SFmode][0]  = CODE_FOR_reload_v4sf_di_store;
2277           rs6000_vector_reload[V4SFmode][1]  = CODE_FOR_reload_v4sf_di_load;
2278           rs6000_vector_reload[V2DFmode][0]  = CODE_FOR_reload_v2df_di_store;
2279           rs6000_vector_reload[V2DFmode][1]  = CODE_FOR_reload_v2df_di_load;
2280         }
2281       else
2282         {
2283           rs6000_vector_reload[V16QImode][0] = CODE_FOR_reload_v16qi_si_store;
2284           rs6000_vector_reload[V16QImode][1] = CODE_FOR_reload_v16qi_si_load;
2285           rs6000_vector_reload[V8HImode][0]  = CODE_FOR_reload_v8hi_si_store;
2286           rs6000_vector_reload[V8HImode][1]  = CODE_FOR_reload_v8hi_si_load;
2287           rs6000_vector_reload[V4SImode][0]  = CODE_FOR_reload_v4si_si_store;
2288           rs6000_vector_reload[V4SImode][1]  = CODE_FOR_reload_v4si_si_load;
2289           rs6000_vector_reload[V2DImode][0]  = CODE_FOR_reload_v2di_si_store;
2290           rs6000_vector_reload[V2DImode][1]  = CODE_FOR_reload_v2di_si_load;
2291           rs6000_vector_reload[V4SFmode][0]  = CODE_FOR_reload_v4sf_si_store;
2292           rs6000_vector_reload[V4SFmode][1]  = CODE_FOR_reload_v4sf_si_load;
2293           rs6000_vector_reload[V2DFmode][0]  = CODE_FOR_reload_v2df_si_store;
2294           rs6000_vector_reload[V2DFmode][1]  = CODE_FOR_reload_v2df_si_load;
2295         }
2296     }
2297
2298   /* Precalculate HARD_REGNO_NREGS.  */
2299   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
2300     for (m = 0; m < NUM_MACHINE_MODES; ++m)
2301       rs6000_hard_regno_nregs[m][r]
2302         = rs6000_hard_regno_nregs_internal (r, (enum machine_mode)m);
2303
2304   /* Precalculate HARD_REGNO_MODE_OK.  */
2305   for (r = 0; r < FIRST_PSEUDO_REGISTER; ++r)
2306     for (m = 0; m < NUM_MACHINE_MODES; ++m)
2307       if (rs6000_hard_regno_mode_ok (r, (enum machine_mode)m))
2308         rs6000_hard_regno_mode_ok_p[m][r] = true;
2309
2310   /* Precalculate CLASS_MAX_NREGS sizes.  */
2311   for (c = 0; c < LIM_REG_CLASSES; ++c)
2312     {
2313       int reg_size;
2314
2315       if (TARGET_VSX && VSX_REG_CLASS_P (c))
2316         reg_size = UNITS_PER_VSX_WORD;
2317
2318       else if (c == ALTIVEC_REGS)
2319         reg_size = UNITS_PER_ALTIVEC_WORD;
2320
2321       else if (c == FLOAT_REGS)
2322         reg_size = UNITS_PER_FP_WORD;
2323
2324       else
2325         reg_size = UNITS_PER_WORD;
2326
2327       for (m = 0; m < NUM_MACHINE_MODES; ++m)
2328         rs6000_class_max_nregs[m][c]
2329           = (GET_MODE_SIZE (m) + reg_size - 1) / reg_size;
2330     }
2331
2332   if (TARGET_E500_DOUBLE)
2333     rs6000_class_max_nregs[DFmode][GENERAL_REGS] = 1;
2334
2335   /* Calculate which modes to automatically generate code to use a the
2336      reciprocal divide and square root instructions.  In the future, possibly
2337      automatically generate the instructions even if the user did not specify
2338      -mrecip.  The older machines double precision reciprocal sqrt estimate is
2339      not accurate enough.  */
2340   memset (rs6000_recip_bits, 0, sizeof (rs6000_recip_bits));
2341   if (TARGET_FRES)
2342     rs6000_recip_bits[SFmode] = RS6000_RECIP_MASK_HAVE_RE;
2343   if (TARGET_FRE)
2344     rs6000_recip_bits[DFmode] = RS6000_RECIP_MASK_HAVE_RE;
2345   if (VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode))
2346     rs6000_recip_bits[V4SFmode] = RS6000_RECIP_MASK_HAVE_RE;
2347   if (VECTOR_UNIT_VSX_P (V2DFmode))
2348     rs6000_recip_bits[V2DFmode] = RS6000_RECIP_MASK_HAVE_RE;
2349
2350   if (TARGET_FRSQRTES)
2351     rs6000_recip_bits[SFmode] |= RS6000_RECIP_MASK_HAVE_RSQRTE;
2352   if (TARGET_FRSQRTE)
2353     rs6000_recip_bits[DFmode] |= RS6000_RECIP_MASK_HAVE_RSQRTE;
2354   if (VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode))
2355     rs6000_recip_bits[V4SFmode] |= RS6000_RECIP_MASK_HAVE_RSQRTE;
2356   if (VECTOR_UNIT_VSX_P (V2DFmode))
2357     rs6000_recip_bits[V2DFmode] |= RS6000_RECIP_MASK_HAVE_RSQRTE;
2358
2359   if (rs6000_recip_control)
2360     {
2361       if (!flag_finite_math_only)
2362         warning (0, "-mrecip requires -ffinite-math or -ffast-math");
2363       if (flag_trapping_math)
2364         warning (0, "-mrecip requires -fno-trapping-math or -ffast-math");
2365       if (!flag_reciprocal_math)
2366         warning (0, "-mrecip requires -freciprocal-math or -ffast-math");
2367       if (flag_finite_math_only && !flag_trapping_math && flag_reciprocal_math)
2368         {
2369           if (RS6000_RECIP_HAVE_RE_P (SFmode)
2370               && (rs6000_recip_control & RECIP_SF_DIV) != 0)
2371             rs6000_recip_bits[SFmode] |= RS6000_RECIP_MASK_AUTO_RE;
2372
2373           if (RS6000_RECIP_HAVE_RE_P (DFmode)
2374               && (rs6000_recip_control & RECIP_DF_DIV) != 0)
2375             rs6000_recip_bits[DFmode] |= RS6000_RECIP_MASK_AUTO_RE;
2376
2377           if (RS6000_RECIP_HAVE_RE_P (V4SFmode)
2378               && (rs6000_recip_control & RECIP_V4SF_DIV) != 0)
2379             rs6000_recip_bits[V4SFmode] |= RS6000_RECIP_MASK_AUTO_RE;
2380
2381           if (RS6000_RECIP_HAVE_RE_P (V2DFmode)
2382               && (rs6000_recip_control & RECIP_V2DF_DIV) != 0)
2383             rs6000_recip_bits[V2DFmode] |= RS6000_RECIP_MASK_AUTO_RE;
2384
2385           if (RS6000_RECIP_HAVE_RSQRTE_P (SFmode)
2386               && (rs6000_recip_control & RECIP_SF_RSQRT) != 0)
2387             rs6000_recip_bits[SFmode] |= RS6000_RECIP_MASK_AUTO_RSQRTE;
2388
2389           if (RS6000_RECIP_HAVE_RSQRTE_P (DFmode)
2390               && (rs6000_recip_control & RECIP_DF_RSQRT) != 0)
2391             rs6000_recip_bits[DFmode] |= RS6000_RECIP_MASK_AUTO_RSQRTE;
2392
2393           if (RS6000_RECIP_HAVE_RSQRTE_P (V4SFmode)
2394               && (rs6000_recip_control & RECIP_V4SF_RSQRT) != 0)
2395             rs6000_recip_bits[V4SFmode] |= RS6000_RECIP_MASK_AUTO_RSQRTE;
2396
2397           if (RS6000_RECIP_HAVE_RSQRTE_P (V2DFmode)
2398               && (rs6000_recip_control & RECIP_V2DF_RSQRT) != 0)
2399             rs6000_recip_bits[V2DFmode] |= RS6000_RECIP_MASK_AUTO_RSQRTE;
2400         }
2401     }
2402
2403   if (global_init_p || TARGET_DEBUG_TARGET)
2404     {
2405       if (TARGET_DEBUG_REG)
2406         rs6000_debug_reg_global ();
2407
2408       if (TARGET_DEBUG_COST || TARGET_DEBUG_REG)
2409         fprintf (stderr,
2410                  "SImode variable mult cost       = %d\n"
2411                  "SImode constant mult cost       = %d\n"
2412                  "SImode short constant mult cost = %d\n"
2413                  "DImode multipliciation cost     = %d\n"
2414                  "SImode division cost            = %d\n"
2415                  "DImode division cost            = %d\n"
2416                  "Simple fp operation cost        = %d\n"
2417                  "DFmode multiplication cost      = %d\n"
2418                  "SFmode division cost            = %d\n"
2419                  "DFmode division cost            = %d\n"
2420                  "cache line size                 = %d\n"
2421                  "l1 cache size                   = %d\n"
2422                  "l2 cache size                   = %d\n"
2423                  "simultaneous prefetches         = %d\n"
2424                  "\n",
2425                  rs6000_cost->mulsi,
2426                  rs6000_cost->mulsi_const,
2427                  rs6000_cost->mulsi_const9,
2428                  rs6000_cost->muldi,
2429                  rs6000_cost->divsi,
2430                  rs6000_cost->divdi,
2431                  rs6000_cost->fp,
2432                  rs6000_cost->dmul,
2433                  rs6000_cost->sdiv,
2434                  rs6000_cost->ddiv,
2435                  rs6000_cost->cache_line_size,
2436                  rs6000_cost->l1_cache_size,
2437                  rs6000_cost->l2_cache_size,
2438                  rs6000_cost->simultaneous_prefetches);
2439     }
2440 }
2441
2442 #if TARGET_MACHO
2443 /* The Darwin version of SUBTARGET_OVERRIDE_OPTIONS.  */
2444
2445 static void
2446 darwin_rs6000_override_options (void)
2447 {
2448   /* The Darwin ABI always includes AltiVec, can't be (validly) turned
2449      off.  */
2450   rs6000_altivec_abi = 1;
2451   TARGET_ALTIVEC_VRSAVE = 1;
2452
2453   if (DEFAULT_ABI == ABI_DARWIN
2454       && TARGET_64BIT)
2455       darwin_one_byte_bool = 1;
2456
2457   if (TARGET_64BIT && ! TARGET_POWERPC64)
2458     {
2459       target_flags |= MASK_POWERPC64;
2460       warning (0, "-m64 requires PowerPC64 architecture, enabling");
2461     }
2462   if (flag_mkernel)
2463     {
2464       rs6000_default_long_calls = 1;
2465       target_flags |= MASK_SOFT_FLOAT;
2466     }
2467
2468   /* Make -m64 imply -maltivec.  Darwin's 64-bit ABI includes
2469      Altivec.  */
2470   if (!flag_mkernel && !flag_apple_kext
2471       && TARGET_64BIT
2472       && ! (target_flags_explicit & MASK_ALTIVEC))
2473     target_flags |= MASK_ALTIVEC;
2474
2475   /* Unless the user (not the configurer) has explicitly overridden
2476      it with -mcpu=G3 or -mno-altivec, then 10.5+ targets default to
2477      G4 unless targetting the kernel.  */
2478   if (!flag_mkernel
2479       && !flag_apple_kext
2480       && strverscmp (darwin_macosx_version_min, "10.5") >= 0
2481       && ! (target_flags_explicit & MASK_ALTIVEC)
2482       && ! global_options_set.x_rs6000_cpu_index)
2483     {
2484       target_flags |= MASK_ALTIVEC;
2485     }
2486 }
2487 #endif
2488
2489 /* If not otherwise specified by a target, make 'long double' equivalent to
2490    'double'.  */
2491
2492 #ifndef RS6000_DEFAULT_LONG_DOUBLE_SIZE
2493 #define RS6000_DEFAULT_LONG_DOUBLE_SIZE 64
2494 #endif
2495
2496 /* Override command line options.  Mostly we process the processor type and
2497    sometimes adjust other TARGET_ options.  */
2498
2499 static bool
2500 rs6000_option_override_internal (bool global_init_p)
2501 {
2502   bool ret = true;
2503   const char *default_cpu = OPTION_TARGET_CPU_DEFAULT;
2504   int set_masks;
2505   int cpu_index;
2506   int tune_index;
2507   struct cl_target_option *main_target_opt
2508     = ((global_init_p || target_option_default_node == NULL)
2509        ? NULL : TREE_TARGET_OPTION (target_option_default_node));
2510
2511   /* On 64-bit Darwin, power alignment is ABI-incompatible with some C
2512      library functions, so warn about it. The flag may be useful for
2513      performance studies from time to time though, so don't disable it
2514      entirely.  */
2515   if (global_options_set.x_rs6000_alignment_flags
2516       && rs6000_alignment_flags == MASK_ALIGN_POWER
2517       && DEFAULT_ABI == ABI_DARWIN
2518       && TARGET_64BIT)
2519     warning (0, "-malign-power is not supported for 64-bit Darwin;"
2520              " it is incompatible with the installed C and C++ libraries");
2521
2522   if (global_options_set.x_rs6000_spe_abi
2523       && rs6000_spe_abi
2524       && !TARGET_SPE_ABI)
2525     error ("not configured for SPE ABI");
2526
2527   /* Numerous experiment shows that IRA based loop pressure
2528      calculation works better for RTL loop invariant motion on targets
2529      with enough (>= 32) registers.  It is an expensive optimization.
2530      So it is on only for peak performance.  */
2531   if (optimize >= 3 && global_init_p)
2532     flag_ira_loop_pressure = 1;
2533
2534   /* Set the pointer size.  */
2535   if (TARGET_64BIT)
2536     {
2537       rs6000_pmode = (int)DImode;
2538       rs6000_pointer_size = 64;
2539     }
2540   else
2541     {
2542       rs6000_pmode = (int)SImode;
2543       rs6000_pointer_size = 32;
2544     }
2545
2546   set_masks = POWER_MASKS | POWERPC_MASKS | MASK_SOFT_FLOAT;
2547 #ifdef OS_MISSING_POWERPC64
2548   if (OS_MISSING_POWERPC64)
2549     set_masks &= ~MASK_POWERPC64;
2550 #endif
2551 #ifdef OS_MISSING_ALTIVEC
2552   if (OS_MISSING_ALTIVEC)
2553     set_masks &= ~MASK_ALTIVEC;
2554 #endif
2555
2556   /* Don't override by the processor default if given explicitly.  */
2557   set_masks &= ~target_flags_explicit;
2558
2559   /* Identify the processor type.  */
2560   if (!default_cpu)
2561     {
2562       if (TARGET_POWERPC64)
2563         default_cpu = "powerpc64";
2564       else if (TARGET_POWERPC)
2565         default_cpu = "powerpc";
2566     }
2567
2568   /* Process the -mcpu=<xxx> and -mtune=<xxx> argument.  If the user changed
2569      the cpu in a target attribute or pragma, but did not specify a tuning
2570      option, use the cpu for the tuning option rather than the option specified
2571      with -mtune on the command line.  */
2572   if (rs6000_cpu_index > 0)
2573     cpu_index = rs6000_cpu_index;
2574   else if (main_target_opt != NULL && main_target_opt->x_rs6000_cpu_index > 0)
2575     rs6000_cpu_index = cpu_index = main_target_opt->x_rs6000_cpu_index;
2576   else
2577     rs6000_cpu_index = cpu_index = rs6000_cpu_name_lookup (default_cpu);
2578
2579   if (rs6000_tune_index > 0)
2580     tune_index = rs6000_tune_index;
2581   else
2582     rs6000_tune_index = tune_index = cpu_index;
2583
2584   if (cpu_index >= 0)
2585     {
2586       target_flags &= ~set_masks;
2587       target_flags |= (processor_target_table[cpu_index].target_enable
2588                        & set_masks);
2589     }
2590
2591   rs6000_cpu = ((tune_index >= 0)
2592                 ? processor_target_table[tune_index].processor
2593                 : (TARGET_POWERPC64
2594                    ? PROCESSOR_DEFAULT64
2595                    : PROCESSOR_DEFAULT));
2596
2597   if (rs6000_cpu == PROCESSOR_PPCE300C2 || rs6000_cpu == PROCESSOR_PPCE300C3
2598       || rs6000_cpu == PROCESSOR_PPCE500MC || rs6000_cpu == PROCESSOR_PPCE500MC64)
2599     {
2600       if (TARGET_ALTIVEC)
2601         error ("AltiVec not supported in this target");
2602       if (TARGET_SPE)
2603         error ("SPE not supported in this target");
2604     }
2605
2606   /* Disable Cell microcode if we are optimizing for the Cell
2607      and not optimizing for size.  */
2608   if (rs6000_gen_cell_microcode == -1)
2609     rs6000_gen_cell_microcode = !(rs6000_cpu == PROCESSOR_CELL
2610                                   && !optimize_size);
2611
2612   /* If we are optimizing big endian systems for space and it's OK to
2613      use instructions that would be microcoded on the Cell, use the
2614      load/store multiple and string instructions.  */
2615   if (BYTES_BIG_ENDIAN && optimize_size && rs6000_gen_cell_microcode)
2616     target_flags |= ~target_flags_explicit & (MASK_MULTIPLE | MASK_STRING);
2617
2618   /* Don't allow -mmultiple or -mstring on little endian systems
2619      unless the cpu is a 750, because the hardware doesn't support the
2620      instructions used in little endian mode, and causes an alignment
2621      trap.  The 750 does not cause an alignment trap (except when the
2622      target is unaligned).  */
2623
2624   if (!BYTES_BIG_ENDIAN && rs6000_cpu != PROCESSOR_PPC750)
2625     {
2626       if (TARGET_MULTIPLE)
2627         {
2628           target_flags &= ~MASK_MULTIPLE;
2629           if ((target_flags_explicit & MASK_MULTIPLE) != 0)
2630             warning (0, "-mmultiple is not supported on little endian systems");
2631         }
2632
2633       if (TARGET_STRING)
2634         {
2635           target_flags &= ~MASK_STRING;
2636           if ((target_flags_explicit & MASK_STRING) != 0)
2637             warning (0, "-mstring is not supported on little endian systems");
2638         }
2639     }
2640
2641   /* Add some warnings for VSX.  */
2642   if (TARGET_VSX)
2643     {
2644       const char *msg = NULL;
2645       if (!TARGET_HARD_FLOAT || !TARGET_FPRS
2646           || !TARGET_SINGLE_FLOAT || !TARGET_DOUBLE_FLOAT)
2647         {
2648           if (target_flags_explicit & MASK_VSX)
2649             msg = N_("-mvsx requires hardware floating point");
2650           else
2651             target_flags &= ~ MASK_VSX;
2652         }
2653       else if (TARGET_PAIRED_FLOAT)
2654         msg = N_("-mvsx and -mpaired are incompatible");
2655       /* The hardware will allow VSX and little endian, but until we make sure
2656          things like vector select, etc. work don't allow VSX on little endian
2657          systems at this point.  */
2658       else if (!BYTES_BIG_ENDIAN)
2659         msg = N_("-mvsx used with little endian code");
2660       else if (TARGET_AVOID_XFORM > 0)
2661         msg = N_("-mvsx needs indexed addressing");
2662       else if (!TARGET_ALTIVEC && (target_flags_explicit & MASK_ALTIVEC))
2663         {
2664           if (target_flags_explicit & MASK_VSX)
2665             msg = N_("-mvsx and -mno-altivec are incompatible");
2666           else
2667             msg = N_("-mno-altivec disables vsx");
2668         }
2669
2670       if (msg)
2671         {
2672           warning (0, msg);
2673           target_flags &= ~ MASK_VSX;
2674           target_flags_explicit |= MASK_VSX;
2675         }
2676     }
2677
2678   /* For the newer switches (vsx, dfp, etc.) set some of the older options,
2679      unless the user explicitly used the -mno-<option> to disable the code.  */
2680   if (TARGET_VSX)
2681     target_flags |= (ISA_2_6_MASKS_SERVER & ~target_flags_explicit);
2682   else if (TARGET_POPCNTD)
2683     target_flags |= (ISA_2_6_MASKS_EMBEDDED & ~target_flags_explicit);
2684   else if (TARGET_DFP)
2685     target_flags |= (ISA_2_5_MASKS_SERVER & ~target_flags_explicit);
2686   else if (TARGET_CMPB)
2687     target_flags |= (ISA_2_5_MASKS_EMBEDDED & ~target_flags_explicit);
2688   else if (TARGET_FPRND)
2689     target_flags |= (ISA_2_4_MASKS & ~target_flags_explicit);
2690   else if (TARGET_POPCNTB)
2691     target_flags |= (ISA_2_2_MASKS & ~target_flags_explicit);
2692   else if (TARGET_ALTIVEC)
2693     target_flags |= (MASK_PPC_GFXOPT & ~target_flags_explicit);
2694
2695   /* E500mc does "better" if we inline more aggressively.  Respect the
2696      user's opinion, though.  */
2697   if (rs6000_block_move_inline_limit == 0
2698       && (rs6000_cpu == PROCESSOR_PPCE500MC
2699           || rs6000_cpu == PROCESSOR_PPCE500MC64))
2700     rs6000_block_move_inline_limit = 128;
2701
2702   /* store_one_arg depends on expand_block_move to handle at least the
2703      size of reg_parm_stack_space.  */
2704   if (rs6000_block_move_inline_limit < (TARGET_POWERPC64 ? 64 : 32))
2705     rs6000_block_move_inline_limit = (TARGET_POWERPC64 ? 64 : 32);
2706
2707   if (global_init_p)
2708     {
2709       /* If the appropriate debug option is enabled, replace the target hooks
2710          with debug versions that call the real version and then prints
2711          debugging information.  */
2712       if (TARGET_DEBUG_COST)
2713         {
2714           targetm.rtx_costs = rs6000_debug_rtx_costs;
2715           targetm.address_cost = rs6000_debug_address_cost;
2716           targetm.sched.adjust_cost = rs6000_debug_adjust_cost;
2717         }
2718
2719       if (TARGET_DEBUG_ADDR)
2720         {
2721           targetm.legitimate_address_p = rs6000_debug_legitimate_address_p;
2722           targetm.legitimize_address = rs6000_debug_legitimize_address;
2723           rs6000_secondary_reload_class_ptr
2724             = rs6000_debug_secondary_reload_class;
2725           rs6000_secondary_memory_needed_ptr
2726             = rs6000_debug_secondary_memory_needed;
2727           rs6000_cannot_change_mode_class_ptr
2728             = rs6000_debug_cannot_change_mode_class;
2729           rs6000_preferred_reload_class_ptr
2730             = rs6000_debug_preferred_reload_class;
2731           rs6000_legitimize_reload_address_ptr
2732             = rs6000_debug_legitimize_reload_address;
2733           rs6000_mode_dependent_address_ptr
2734             = rs6000_debug_mode_dependent_address;
2735         }
2736
2737       if (rs6000_veclibabi_name)
2738         {
2739           if (strcmp (rs6000_veclibabi_name, "mass") == 0)
2740             rs6000_veclib_handler = rs6000_builtin_vectorized_libmass;
2741           else
2742             {
2743               error ("unknown vectorization library ABI type (%s) for "
2744                      "-mveclibabi= switch", rs6000_veclibabi_name);
2745               ret = false;
2746             }
2747         }
2748     }
2749
2750   if (!global_options_set.x_rs6000_long_double_type_size)
2751     {
2752       if (main_target_opt != NULL
2753           && (main_target_opt->x_rs6000_long_double_type_size
2754               != RS6000_DEFAULT_LONG_DOUBLE_SIZE))
2755         error ("target attribute or pragma changes long double size");
2756       else
2757         rs6000_long_double_type_size = RS6000_DEFAULT_LONG_DOUBLE_SIZE;
2758     }
2759
2760 #ifndef POWERPC_LINUX
2761   if (!global_options_set.x_rs6000_ieeequad)
2762     rs6000_ieeequad = 1;
2763 #endif
2764
2765   /* Disable VSX and Altivec silently if the user switched cpus to power7 in a
2766      target attribute or pragma which automatically enables both options,
2767      unless the altivec ABI was set.  This is set by default for 64-bit, but
2768      not for 32-bit.  */
2769   if (main_target_opt != NULL && !main_target_opt->x_rs6000_altivec_abi)
2770     target_flags &= ~((MASK_VSX | MASK_ALTIVEC) & ~target_flags_explicit);
2771
2772   /* Enable Altivec ABI for AIX -maltivec.  */
2773   if (TARGET_XCOFF && (TARGET_ALTIVEC || TARGET_VSX))
2774     {
2775       if (main_target_opt != NULL && !main_target_opt->x_rs6000_altivec_abi)
2776         error ("target attribute or pragma changes AltiVec ABI");
2777       else
2778         rs6000_altivec_abi = 1;
2779     }
2780
2781   /* The AltiVec ABI is the default for PowerPC-64 GNU/Linux.  For
2782      PowerPC-32 GNU/Linux, -maltivec implies the AltiVec ABI.  It can
2783      be explicitly overridden in either case.  */
2784   if (TARGET_ELF)
2785     {
2786       if (!global_options_set.x_rs6000_altivec_abi
2787           && (TARGET_64BIT || TARGET_ALTIVEC || TARGET_VSX))
2788         {
2789           if (main_target_opt != NULL &&
2790               !main_target_opt->x_rs6000_altivec_abi)
2791             error ("target attribute or pragma changes AltiVec ABI");
2792           else
2793             rs6000_altivec_abi = 1;
2794         }
2795
2796       /* Enable VRSAVE for AltiVec ABI, unless explicitly overridden.  */
2797       if (!global_options_set.x_TARGET_ALTIVEC_VRSAVE)
2798         TARGET_ALTIVEC_VRSAVE = rs6000_altivec_abi;
2799     }
2800
2801   /* Set the Darwin64 ABI as default for 64-bit Darwin.
2802      So far, the only darwin64 targets are also MACH-O.  */
2803   if (TARGET_MACHO
2804       && DEFAULT_ABI == ABI_DARWIN
2805       && TARGET_64BIT)
2806     {
2807       if (main_target_opt != NULL && !main_target_opt->x_rs6000_darwin64_abi)
2808         error ("target attribute or pragma changes darwin64 ABI");
2809       else
2810         {
2811           rs6000_darwin64_abi = 1;
2812           /* Default to natural alignment, for better performance.  */
2813           rs6000_alignment_flags = MASK_ALIGN_NATURAL;
2814         }
2815     }
2816
2817   /* Place FP constants in the constant pool instead of TOC
2818      if section anchors enabled.  */
2819   if (flag_section_anchors)
2820     TARGET_NO_FP_IN_TOC = 1;
2821
2822 #ifdef SUBTARGET_OVERRIDE_OPTIONS
2823   SUBTARGET_OVERRIDE_OPTIONS;
2824 #endif
2825 #ifdef SUBSUBTARGET_OVERRIDE_OPTIONS
2826   SUBSUBTARGET_OVERRIDE_OPTIONS;
2827 #endif
2828 #ifdef SUB3TARGET_OVERRIDE_OPTIONS
2829   SUB3TARGET_OVERRIDE_OPTIONS;
2830 #endif
2831
2832   if (TARGET_E500 || rs6000_cpu == PROCESSOR_PPCE500MC
2833       || rs6000_cpu == PROCESSOR_PPCE500MC64)
2834     {
2835       /* The e500 and e500mc do not have string instructions, and we set
2836          MASK_STRING above when optimizing for size.  */
2837       if ((target_flags & MASK_STRING) != 0)
2838         target_flags = target_flags & ~MASK_STRING;
2839     }
2840   else if (global_options_set.x_rs6000_cpu_index)
2841     {
2842       /* For the powerpc-eabispe configuration, we set all these by
2843          default, so let's unset them if we manually set another
2844          CPU that is not the E500.  */
2845       if (main_target_opt != NULL
2846           && ((main_target_opt->x_rs6000_spe_abi != rs6000_spe_abi)
2847               || (main_target_opt->x_rs6000_spe != rs6000_spe)
2848               || (main_target_opt->x_rs6000_float_gprs != rs6000_float_gprs)))
2849         error ("target attribute or pragma changes SPE ABI");
2850       else
2851         {
2852           if (!global_options_set.x_rs6000_spe_abi)
2853             rs6000_spe_abi = 0;
2854           if (!global_options_set.x_rs6000_spe)
2855             rs6000_spe = 0;
2856           if (!global_options_set.x_rs6000_float_gprs)
2857             rs6000_float_gprs = 0;
2858         }
2859       if (!(target_flags_explicit & MASK_ISEL))
2860         target_flags &= ~MASK_ISEL;
2861     }
2862
2863   /* Detect invalid option combinations with E500.  */
2864   CHECK_E500_OPTIONS;
2865
2866   rs6000_always_hint = (rs6000_cpu != PROCESSOR_POWER4
2867                         && rs6000_cpu != PROCESSOR_POWER5
2868                         && rs6000_cpu != PROCESSOR_POWER6
2869                         && rs6000_cpu != PROCESSOR_POWER7
2870                         && rs6000_cpu != PROCESSOR_PPCA2
2871                         && rs6000_cpu != PROCESSOR_CELL);
2872   rs6000_sched_groups = (rs6000_cpu == PROCESSOR_POWER4
2873                          || rs6000_cpu == PROCESSOR_POWER5
2874                          || rs6000_cpu == PROCESSOR_POWER7);
2875   rs6000_align_branch_targets = (rs6000_cpu == PROCESSOR_POWER4
2876                                  || rs6000_cpu == PROCESSOR_POWER5
2877                                  || rs6000_cpu == PROCESSOR_POWER6
2878                                  || rs6000_cpu == PROCESSOR_POWER7
2879                                  || rs6000_cpu == PROCESSOR_PPCE500MC
2880                                  || rs6000_cpu == PROCESSOR_PPCE500MC64);
2881
2882   /* Allow debug switches to override the above settings.  These are set to -1
2883      in rs6000.opt to indicate the user hasn't directly set the switch.  */
2884   if (TARGET_ALWAYS_HINT >= 0)
2885     rs6000_always_hint = TARGET_ALWAYS_HINT;
2886
2887   if (TARGET_SCHED_GROUPS >= 0)
2888     rs6000_sched_groups = TARGET_SCHED_GROUPS;
2889
2890   if (TARGET_ALIGN_BRANCH_TARGETS >= 0)
2891     rs6000_align_branch_targets = TARGET_ALIGN_BRANCH_TARGETS;
2892
2893   rs6000_sched_restricted_insns_priority
2894     = (rs6000_sched_groups ? 1 : 0);
2895
2896   /* Handle -msched-costly-dep option.  */
2897   rs6000_sched_costly_dep
2898     = (rs6000_sched_groups ? store_to_load_dep_costly : no_dep_costly);
2899
2900   if (rs6000_sched_costly_dep_str)
2901     {
2902       if (! strcmp (rs6000_sched_costly_dep_str, "no"))
2903         rs6000_sched_costly_dep = no_dep_costly;
2904       else if (! strcmp (rs6000_sched_costly_dep_str, "all"))
2905         rs6000_sched_costly_dep = all_deps_costly;
2906       else if (! strcmp (rs6000_sched_costly_dep_str, "true_store_to_load"))
2907         rs6000_sched_costly_dep = true_store_to_load_dep_costly;
2908       else if (! strcmp (rs6000_sched_costly_dep_str, "store_to_load"))
2909         rs6000_sched_costly_dep = store_to_load_dep_costly;
2910       else
2911         rs6000_sched_costly_dep = ((enum rs6000_dependence_cost)
2912                                    atoi (rs6000_sched_costly_dep_str));
2913     }
2914
2915   /* Handle -minsert-sched-nops option.  */
2916   rs6000_sched_insert_nops
2917     = (rs6000_sched_groups ? sched_finish_regroup_exact : sched_finish_none);
2918
2919   if (rs6000_sched_insert_nops_str)
2920     {
2921       if (! strcmp (rs6000_sched_insert_nops_str, "no"))
2922         rs6000_sched_insert_nops = sched_finish_none;
2923       else if (! strcmp (rs6000_sched_insert_nops_str, "pad"))
2924         rs6000_sched_insert_nops = sched_finish_pad_groups;
2925       else if (! strcmp (rs6000_sched_insert_nops_str, "regroup_exact"))
2926         rs6000_sched_insert_nops = sched_finish_regroup_exact;
2927       else
2928         rs6000_sched_insert_nops = ((enum rs6000_nop_insertion)
2929                                     atoi (rs6000_sched_insert_nops_str));
2930     }
2931
2932   if (global_init_p)
2933     {
2934 #ifdef TARGET_REGNAMES
2935       /* If the user desires alternate register names, copy in the
2936          alternate names now.  */
2937       if (TARGET_REGNAMES)
2938         memcpy (rs6000_reg_names, alt_reg_names, sizeof (rs6000_reg_names));
2939 #endif
2940
2941       /* Set aix_struct_return last, after the ABI is determined.
2942          If -maix-struct-return or -msvr4-struct-return was explicitly
2943          used, don't override with the ABI default.  */
2944       if (!global_options_set.x_aix_struct_return)
2945         aix_struct_return = (DEFAULT_ABI != ABI_V4 || DRAFT_V4_STRUCT_RET);
2946
2947 #if 0
2948       /* IBM XL compiler defaults to unsigned bitfields.  */
2949       if (TARGET_XL_COMPAT)
2950         flag_signed_bitfields = 0;
2951 #endif
2952
2953       if (TARGET_LONG_DOUBLE_128 && !TARGET_IEEEQUAD)
2954         REAL_MODE_FORMAT (TFmode) = &ibm_extended_format;
2955
2956       if (TARGET_TOC)
2957         ASM_GENERATE_INTERNAL_LABEL (toc_label_name, "LCTOC", 1);
2958
2959       /* We can only guarantee the availability of DI pseudo-ops when
2960          assembling for 64-bit targets.  */
2961       if (!TARGET_64BIT)
2962         {
2963           targetm.asm_out.aligned_op.di = NULL;
2964           targetm.asm_out.unaligned_op.di = NULL;
2965         }
2966
2967
2968       /* Set branch target alignment, if not optimizing for size.  */
2969       if (!optimize_size)
2970         {
2971           /* Cell wants to be aligned 8byte for dual issue.  Titan wants to be
2972              aligned 8byte to avoid misprediction by the branch predictor.  */
2973           if (rs6000_cpu == PROCESSOR_TITAN
2974               || rs6000_cpu == PROCESSOR_CELL)
2975             {
2976               if (align_functions <= 0)
2977                 align_functions = 8;
2978               if (align_jumps <= 0)
2979                 align_jumps = 8;
2980               if (align_loops <= 0)
2981                 align_loops = 8;
2982             }
2983           if (rs6000_align_branch_targets)
2984             {
2985               if (align_functions <= 0)
2986                 align_functions = 16;
2987               if (align_jumps <= 0)
2988                 align_jumps = 16;
2989               if (align_loops <= 0)
2990                 {
2991                   can_override_loop_align = 1;
2992                   align_loops = 16;
2993                 }
2994             }
2995           if (align_jumps_max_skip <= 0)
2996             align_jumps_max_skip = 15;
2997           if (align_loops_max_skip <= 0)
2998             align_loops_max_skip = 15;
2999         }
3000
3001       /* Arrange to save and restore machine status around nested functions.  */
3002       init_machine_status = rs6000_init_machine_status;
3003
3004       /* We should always be splitting complex arguments, but we can't break
3005          Linux and Darwin ABIs at the moment.  For now, only AIX is fixed.  */
3006       if (DEFAULT_ABI != ABI_AIX)
3007         targetm.calls.split_complex_arg = NULL;
3008     }
3009
3010   /* Initialize rs6000_cost with the appropriate target costs.  */
3011   if (optimize_size)
3012     rs6000_cost = TARGET_POWERPC64 ? &size64_cost : &size32_cost;
3013   else
3014     switch (rs6000_cpu)
3015       {
3016       case PROCESSOR_RIOS1:
3017         rs6000_cost = &rios1_cost;
3018         break;
3019
3020       case PROCESSOR_RIOS2:
3021         rs6000_cost = &rios2_cost;
3022         break;
3023
3024       case PROCESSOR_RS64A:
3025         rs6000_cost = &rs64a_cost;
3026         break;
3027
3028       case PROCESSOR_MPCCORE:
3029         rs6000_cost = &mpccore_cost;
3030         break;
3031
3032       case PROCESSOR_PPC403:
3033         rs6000_cost = &ppc403_cost;
3034         break;
3035
3036       case PROCESSOR_PPC405:
3037         rs6000_cost = &ppc405_cost;
3038         break;
3039
3040       case PROCESSOR_PPC440:
3041         rs6000_cost = &ppc440_cost;
3042         break;
3043
3044       case PROCESSOR_PPC476:
3045         rs6000_cost = &ppc476_cost;
3046         break;
3047
3048       case PROCESSOR_PPC601:
3049         rs6000_cost = &ppc601_cost;
3050         break;
3051
3052       case PROCESSOR_PPC603:
3053         rs6000_cost = &ppc603_cost;
3054         break;
3055
3056       case PROCESSOR_PPC604:
3057         rs6000_cost = &ppc604_cost;
3058         break;
3059
3060       case PROCESSOR_PPC604e:
3061         rs6000_cost = &ppc604e_cost;
3062         break;
3063
3064       case PROCESSOR_PPC620:
3065         rs6000_cost = &ppc620_cost;
3066         break;
3067
3068       case PROCESSOR_PPC630:
3069         rs6000_cost = &ppc630_cost;
3070         break;
3071
3072       case PROCESSOR_CELL:
3073         rs6000_cost = &ppccell_cost;
3074         break;
3075
3076       case PROCESSOR_PPC750:
3077       case PROCESSOR_PPC7400:
3078         rs6000_cost = &ppc750_cost;
3079         break;
3080
3081       case PROCESSOR_PPC7450:
3082         rs6000_cost = &ppc7450_cost;
3083         break;
3084
3085       case PROCESSOR_PPC8540:
3086         rs6000_cost = &ppc8540_cost;
3087         break;
3088
3089       case PROCESSOR_PPCE300C2:
3090       case PROCESSOR_PPCE300C3:
3091         rs6000_cost = &ppce300c2c3_cost;
3092         break;
3093
3094       case PROCESSOR_PPCE500MC:
3095         rs6000_cost = &ppce500mc_cost;
3096         break;
3097
3098       case PROCESSOR_PPCE500MC64:
3099         rs6000_cost = &ppce500mc64_cost;
3100         break;
3101
3102       case PROCESSOR_TITAN:
3103         rs6000_cost = &titan_cost;
3104         break;
3105
3106       case PROCESSOR_POWER4:
3107       case PROCESSOR_POWER5:
3108         rs6000_cost = &power4_cost;
3109         break;
3110
3111       case PROCESSOR_POWER6:
3112         rs6000_cost = &power6_cost;
3113         break;
3114
3115       case PROCESSOR_POWER7:
3116         rs6000_cost = &power7_cost;
3117         break;
3118
3119       case PROCESSOR_PPCA2:
3120         rs6000_cost = &ppca2_cost;
3121         break;
3122
3123       default:
3124         gcc_unreachable ();
3125       }
3126
3127   if (global_init_p)
3128     {
3129       maybe_set_param_value (PARAM_SIMULTANEOUS_PREFETCHES,
3130                              rs6000_cost->simultaneous_prefetches,
3131                              global_options.x_param_values,
3132                              global_options_set.x_param_values);
3133       maybe_set_param_value (PARAM_L1_CACHE_SIZE, rs6000_cost->l1_cache_size,
3134                              global_options.x_param_values,
3135                              global_options_set.x_param_values);
3136       maybe_set_param_value (PARAM_L1_CACHE_LINE_SIZE,
3137                              rs6000_cost->cache_line_size,
3138                              global_options.x_param_values,
3139                              global_options_set.x_param_values);
3140       maybe_set_param_value (PARAM_L2_CACHE_SIZE, rs6000_cost->l2_cache_size,
3141                              global_options.x_param_values,
3142                              global_options_set.x_param_values);
3143
3144       /* If using typedef char *va_list, signal that
3145          __builtin_va_start (&ap, 0) can be optimized to
3146          ap = __builtin_next_arg (0).  */
3147       if (DEFAULT_ABI != ABI_V4)
3148         targetm.expand_builtin_va_start = NULL;
3149     }
3150
3151   /* Set up single/double float flags.
3152      If TARGET_HARD_FLOAT is set, but neither single or double is set,
3153      then set both flags. */
3154   if (TARGET_HARD_FLOAT && TARGET_FPRS
3155       && rs6000_single_float == 0 && rs6000_double_float == 0)
3156     rs6000_single_float = rs6000_double_float = 1;
3157
3158   /* Reset single and double FP flags if target is E500. */
3159   if (TARGET_E500)
3160   {
3161     rs6000_single_float = rs6000_double_float = 0;
3162     if (TARGET_E500_SINGLE)
3163       rs6000_single_float = 1;
3164     if (TARGET_E500_DOUBLE)
3165       rs6000_single_float = rs6000_double_float = 1;
3166   }
3167
3168   if (main_target_opt)
3169     {
3170       if (main_target_opt->x_rs6000_single_float != rs6000_single_float)
3171         error ("target attribute or pragma changes single precision floating "
3172                "point");
3173       if (main_target_opt->x_rs6000_double_float != rs6000_double_float)
3174         error ("target attribute or pragma changes double precision floating "
3175                "point");
3176     }
3177
3178   /* If not explicitly specified via option, decide whether to generate indexed
3179      load/store instructions.  */
3180   if (TARGET_AVOID_XFORM == -1)
3181     /* Avoid indexed addressing when targeting Power6 in order to avoid the
3182      DERAT mispredict penalty.  However the LVE and STVE altivec instructions
3183      need indexed accesses and the type used is the scalar type of the element
3184      being loaded or stored.  */
3185     TARGET_AVOID_XFORM = (rs6000_cpu == PROCESSOR_POWER6 && TARGET_CMPB
3186                           && !TARGET_ALTIVEC);
3187
3188   /* Set the -mrecip options.  */
3189   if (rs6000_recip_name)
3190     {
3191       char *p = ASTRDUP (rs6000_recip_name);
3192       char *q;
3193       unsigned int mask, i;
3194       bool invert;
3195
3196       while ((q = strtok (p, ",")) != NULL)
3197         {
3198           p = NULL;
3199           if (*q == '!')
3200             {
3201               invert = true;
3202               q++;
3203             }
3204           else
3205             invert = false;
3206
3207           if (!strcmp (q, "default"))
3208             mask = ((TARGET_RECIP_PRECISION)
3209                     ? RECIP_HIGH_PRECISION : RECIP_LOW_PRECISION);
3210           else
3211             {
3212               for (i = 0; i < ARRAY_SIZE (recip_options); i++)
3213                 if (!strcmp (q, recip_options[i].string))
3214                   {
3215                     mask = recip_options[i].mask;
3216                     break;
3217                   }
3218
3219               if (i == ARRAY_SIZE (recip_options))
3220                 {
3221                   error ("unknown option for -mrecip=%s", q);
3222                   invert = false;
3223                   mask = 0;
3224                   ret = false;
3225                 }
3226             }
3227
3228           if (invert)
3229             rs6000_recip_control &= ~mask;
3230           else
3231             rs6000_recip_control |= mask;
3232         }
3233     }
3234
3235   rs6000_init_hard_regno_mode_ok (global_init_p);
3236
3237   /* Save the initial options in case the user does function specific options */
3238   if (global_init_p)
3239     target_option_default_node = target_option_current_node
3240       = build_target_option_node ();
3241
3242   /* If not explicitly specified via option, decide whether to generate the
3243      extra blr's required to preserve the link stack on some cpus (eg, 476).  */
3244   if (TARGET_LINK_STACK == -1)
3245     SET_TARGET_LINK_STACK (rs6000_cpu == PROCESSOR_PPC476 && flag_pic);
3246
3247   return ret;
3248 }
3249
3250 /* Implement TARGET_OPTION_OVERRIDE.  On the RS/6000 this is used to
3251    define the target cpu type.  */
3252
3253 static void
3254 rs6000_option_override (void)
3255 {
3256   (void) rs6000_option_override_internal (true);
3257 }
3258
3259 \f
3260 /* Implement targetm.vectorize.builtin_mask_for_load.  */
3261 static tree
3262 rs6000_builtin_mask_for_load (void)
3263 {
3264   if (TARGET_ALTIVEC || TARGET_VSX)
3265     return altivec_builtin_mask_for_load;
3266   else
3267     return 0;
3268 }
3269
3270 /* Implement LOOP_ALIGN. */
3271 int
3272 rs6000_loop_align (rtx label)
3273 {
3274   basic_block bb;
3275   int ninsns;
3276
3277   /* Don't override loop alignment if -falign-loops was specified. */
3278   if (!can_override_loop_align)
3279     return align_loops_log;
3280
3281   bb = BLOCK_FOR_INSN (label);
3282   ninsns = num_loop_insns(bb->loop_father);
3283
3284   /* Align small loops to 32 bytes to fit in an icache sector, otherwise return default. */
3285   if (ninsns > 4 && ninsns <= 8
3286       && (rs6000_cpu == PROCESSOR_POWER4
3287           || rs6000_cpu == PROCESSOR_POWER5
3288           || rs6000_cpu == PROCESSOR_POWER6
3289           || rs6000_cpu == PROCESSOR_POWER7))
3290     return 5;
3291   else
3292     return align_loops_log;
3293 }
3294
3295 /* Implement TARGET_LOOP_ALIGN_MAX_SKIP. */
3296 static int
3297 rs6000_loop_align_max_skip (rtx label)
3298 {
3299   return (1 << rs6000_loop_align (label)) - 1;
3300 }
3301
3302 /* Implement targetm.vectorize.builtin_conversion.
3303    Returns a decl of a function that implements conversion of an integer vector
3304    into a floating-point vector, or vice-versa.  DEST_TYPE is the
3305    destination type and SRC_TYPE the source type of the conversion.
3306    Return NULL_TREE if it is not available.  */
3307 static tree
3308 rs6000_builtin_conversion (unsigned int tcode, tree dest_type, tree src_type)
3309 {
3310   enum tree_code code = (enum tree_code) tcode;
3311
3312   switch (code)
3313     {
3314     case FIX_TRUNC_EXPR:
3315       switch (TYPE_MODE (dest_type))
3316         {
3317         case V2DImode:
3318           if (!VECTOR_UNIT_VSX_P (V2DFmode))
3319             return NULL_TREE;
3320
3321           return TYPE_UNSIGNED (dest_type)
3322             ? rs6000_builtin_decls[VSX_BUILTIN_XVCVDPUXDS_UNS]
3323             : rs6000_builtin_decls[VSX_BUILTIN_XVCVDPSXDS];
3324
3325         case V4SImode:
3326           if (VECTOR_UNIT_NONE_P (V4SImode) || VECTOR_UNIT_NONE_P (V4SFmode))
3327             return NULL_TREE;
3328
3329           return TYPE_UNSIGNED (dest_type)
3330             ? rs6000_builtin_decls[VECTOR_BUILTIN_FIXUNS_V4SF_V4SI]
3331             : rs6000_builtin_decls[VECTOR_BUILTIN_FIX_V4SF_V4SI];
3332
3333         default:
3334           return NULL_TREE;
3335         }
3336
3337     case FLOAT_EXPR:
3338       switch (TYPE_MODE (src_type))
3339         {
3340         case V2DImode:
3341           if (!VECTOR_UNIT_VSX_P (V2DFmode))
3342             return NULL_TREE;
3343
3344           return TYPE_UNSIGNED (src_type)
3345             ? rs6000_builtin_decls[VSX_BUILTIN_XVCVUXDDP]
3346             : rs6000_builtin_decls[VSX_BUILTIN_XVCVSXDDP];
3347
3348         case V4SImode:
3349           if (VECTOR_UNIT_NONE_P (V4SImode) || VECTOR_UNIT_NONE_P (V4SFmode))
3350             return NULL_TREE;
3351
3352           return TYPE_UNSIGNED (src_type)
3353             ? rs6000_builtin_decls[VECTOR_BUILTIN_UNSFLOAT_V4SI_V4SF]
3354             : rs6000_builtin_decls[VECTOR_BUILTIN_FLOAT_V4SI_V4SF];
3355
3356         default:
3357           return NULL_TREE;
3358         }
3359
3360     default:
3361       return NULL_TREE;
3362     }
3363 }
3364
3365 /* Implement targetm.vectorize.builtin_mul_widen_even.  */
3366 static tree
3367 rs6000_builtin_mul_widen_even (tree type)
3368 {
3369   if (!TARGET_ALTIVEC)
3370     return NULL_TREE;
3371
3372   switch (TYPE_MODE (type))
3373     {
3374     case V8HImode:
3375       return TYPE_UNSIGNED (type)
3376             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUH_UNS]
3377             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESH];
3378
3379     case V16QImode:
3380       return TYPE_UNSIGNED (type)
3381             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULEUB_UNS]
3382             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULESB];
3383     default:
3384       return NULL_TREE;
3385     }
3386 }
3387
3388 /* Implement targetm.vectorize.builtin_mul_widen_odd.  */
3389 static tree
3390 rs6000_builtin_mul_widen_odd (tree type)
3391 {
3392   if (!TARGET_ALTIVEC)
3393     return NULL_TREE;
3394
3395   switch (TYPE_MODE (type))
3396     {
3397     case V8HImode:
3398       return TYPE_UNSIGNED (type)
3399             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUH_UNS]
3400             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSH];
3401
3402     case V16QImode:
3403       return TYPE_UNSIGNED (type)
3404             ? rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOUB_UNS]
3405             : rs6000_builtin_decls[ALTIVEC_BUILTIN_VMULOSB];
3406     default:
3407       return NULL_TREE;
3408     }
3409 }
3410
3411
3412 /* Return true iff, data reference of TYPE can reach vector alignment (16)
3413    after applying N number of iterations.  This routine does not determine
3414    how may iterations are required to reach desired alignment.  */
3415
3416 static bool
3417 rs6000_vector_alignment_reachable (const_tree type ATTRIBUTE_UNUSED, bool is_packed)
3418 {
3419   if (is_packed)
3420     return false;
3421
3422   if (TARGET_32BIT)
3423     {
3424       if (rs6000_alignment_flags == MASK_ALIGN_NATURAL)
3425         return true;
3426
3427       if (rs6000_alignment_flags ==  MASK_ALIGN_POWER)
3428         return true;
3429
3430       return false;
3431     }
3432   else
3433     {
3434       if (TARGET_MACHO)
3435         return false;
3436
3437       /* Assuming that all other types are naturally aligned. CHECKME!  */
3438       return true;
3439     }
3440 }
3441
3442 /* Return true if the vector misalignment factor is supported by the
3443    target.  */
3444 bool
3445 rs6000_builtin_support_vector_misalignment (enum machine_mode mode,
3446                                             const_tree type,
3447                                             int misalignment,
3448                                             bool is_packed)
3449 {
3450   if (TARGET_VSX)
3451     {
3452       /* Return if movmisalign pattern is not supported for this mode.  */
3453       if (optab_handler (movmisalign_optab, mode) == CODE_FOR_nothing)
3454         return false;
3455
3456       if (misalignment == -1)
3457         {
3458           /* Misalignment factor is unknown at compile time but we know
3459              it's word aligned.  */
3460           if (rs6000_vector_alignment_reachable (type, is_packed))
3461             {
3462               int element_size = TREE_INT_CST_LOW (TYPE_SIZE (type));
3463
3464               if (element_size == 64 || element_size == 32)
3465                return true;
3466             }
3467
3468           return false;
3469         }
3470
3471       /* VSX supports word-aligned vector.  */
3472       if (misalignment % 4 == 0)
3473         return true;
3474     }
3475   return false;
3476 }
3477
3478 /* Implement targetm.vectorize.builtin_vectorization_cost.  */
3479 static int
3480 rs6000_builtin_vectorization_cost (enum vect_cost_for_stmt type_of_cost,
3481                                    tree vectype, int misalign)
3482 {
3483   unsigned elements;
3484
3485   switch (type_of_cost)
3486     {
3487       case scalar_stmt:
3488       case scalar_load:
3489       case scalar_store:
3490       case vector_stmt:
3491       case vector_load:
3492       case vector_store:
3493       case vec_to_scalar:
3494       case scalar_to_vec:
3495       case cond_branch_not_taken:
3496       case vec_perm:
3497         return 1;
3498
3499       case cond_branch_taken:
3500         return 3;
3501
3502       case unaligned_load:
3503         if (TARGET_VSX && TARGET_ALLOW_MOVMISALIGN)
3504           {
3505             elements = TYPE_VECTOR_SUBPARTS (vectype);
3506             if (elements == 2)
3507               /* Double word aligned.  */
3508               return 2;
3509
3510             if (elements == 4)
3511               {
3512                 switch (misalign)
3513                   {
3514                     case 8:
3515                       /* Double word aligned.  */
3516                       return 2;
3517
3518                     case -1:
3519                       /* Unknown misalignment.  */
3520                     case 4:
3521                     case 12:
3522                       /* Word aligned.  */
3523                       return 22;
3524
3525                     default:
3526                       gcc_unreachable ();
3527                   }
3528               }
3529           }
3530
3531         if (TARGET_ALTIVEC)
3532           /* Misaligned loads are not supported.  */
3533           gcc_unreachable ();
3534
3535         return 2;
3536
3537       case unaligned_store:
3538         if (TARGET_VSX && TARGET_ALLOW_MOVMISALIGN)
3539           {
3540             elements = TYPE_VECTOR_SUBPARTS (vectype);
3541             if (elements == 2)
3542               /* Double word aligned.  */
3543               return 2;
3544
3545             if (elements == 4)
3546               {
3547                 switch (misalign)
3548                   {
3549                     case 8:
3550                       /* Double word aligned.  */
3551                       return 2;
3552
3553                     case -1:
3554                       /* Unknown misalignment.  */
3555                     case 4:
3556                     case 12:
3557                       /* Word aligned.  */
3558                       return 23;
3559
3560                     default:
3561                       gcc_unreachable ();
3562                   }
3563               }
3564           }
3565
3566         if (TARGET_ALTIVEC)
3567           /* Misaligned stores are not supported.  */
3568           gcc_unreachable ();
3569
3570         return 2;
3571
3572       default:
3573         gcc_unreachable ();
3574     }
3575 }
3576
3577 /* Implement targetm.vectorize.preferred_simd_mode.  */
3578
3579 static enum machine_mode
3580 rs6000_preferred_simd_mode (enum machine_mode mode)
3581 {
3582   if (TARGET_VSX)
3583     switch (mode)
3584       {
3585       case DFmode:
3586         return V2DFmode;
3587       default:;
3588       }
3589   if (TARGET_ALTIVEC || TARGET_VSX)
3590     switch (mode)
3591       {
3592       case SFmode:
3593         return V4SFmode;
3594       case DImode:
3595         return V2DImode;
3596       case SImode:
3597         return V4SImode;
3598       case HImode:
3599         return V8HImode;
3600       case QImode:
3601         return V16QImode;
3602       default:;
3603       }
3604   if (TARGET_SPE)
3605     switch (mode)
3606       {
3607       case SFmode:
3608         return V2SFmode;
3609       case SImode:
3610         return V2SImode;
3611       default:;
3612       }
3613   if (TARGET_PAIRED_FLOAT
3614       && mode == SFmode)
3615     return V2SFmode;
3616   return word_mode;
3617 }
3618
3619 /* Handler for the Mathematical Acceleration Subsystem (mass) interface to a
3620    library with vectorized intrinsics.  */
3621
3622 static tree
3623 rs6000_builtin_vectorized_libmass (tree fndecl, tree type_out, tree type_in)
3624 {
3625   char name[32];
3626   const char *suffix = NULL;
3627   tree fntype, new_fndecl, bdecl = NULL_TREE;
3628   int n_args = 1;
3629   const char *bname;
3630   enum machine_mode el_mode, in_mode;
3631   int n, in_n;
3632
3633   /* Libmass is suitable for unsafe math only as it does not correctly support
3634      parts of IEEE with the required precision such as denormals.  Only support
3635      it if we have VSX to use the simd d2 or f4 functions.
3636      XXX: Add variable length support.  */
3637   if (!flag_unsafe_math_optimizations || !TARGET_VSX)
3638     return NULL_TREE;
3639
3640   el_mode = TYPE_MODE (TREE_TYPE (type_out));
3641   n = TYPE_VECTOR_SUBPARTS (type_out);
3642   in_mode = TYPE_MODE (TREE_TYPE (type_in));
3643   in_n = TYPE_VECTOR_SUBPARTS (type_in);
3644   if (el_mode != in_mode
3645       || n != in_n)
3646     return NULL_TREE;
3647
3648   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
3649     {
3650       enum built_in_function fn = DECL_FUNCTION_CODE (fndecl);
3651       switch (fn)
3652         {
3653         case BUILT_IN_ATAN2:
3654         case BUILT_IN_HYPOT:
3655         case BUILT_IN_POW:
3656           n_args = 2;
3657           /* fall through */
3658
3659         case BUILT_IN_ACOS:
3660         case BUILT_IN_ACOSH:
3661         case BUILT_IN_ASIN:
3662         case BUILT_IN_ASINH:
3663         case BUILT_IN_ATAN:
3664         case BUILT_IN_ATANH:
3665         case BUILT_IN_CBRT:
3666         case BUILT_IN_COS:
3667         case BUILT_IN_COSH:
3668         case BUILT_IN_ERF:
3669         case BUILT_IN_ERFC:
3670         case BUILT_IN_EXP2:
3671         case BUILT_IN_EXP:
3672         case BUILT_IN_EXPM1:
3673         case BUILT_IN_LGAMMA:
3674         case BUILT_IN_LOG10:
3675         case BUILT_IN_LOG1P:
3676         case BUILT_IN_LOG2:
3677         case BUILT_IN_LOG:
3678         case BUILT_IN_SIN:
3679         case BUILT_IN_SINH:
3680         case BUILT_IN_SQRT:
3681         case BUILT_IN_TAN:
3682         case BUILT_IN_TANH:
3683           bdecl = builtin_decl_implicit (fn);
3684           suffix = "d2";                                /* pow -> powd2 */
3685           if (el_mode != DFmode
3686               || n != 2)
3687             return NULL_TREE;
3688           break;
3689
3690         case BUILT_IN_ATAN2F:
3691         case BUILT_IN_HYPOTF:
3692         case BUILT_IN_POWF:
3693           n_args = 2;
3694           /* fall through */
3695
3696         case BUILT_IN_ACOSF:
3697         case BUILT_IN_ACOSHF:
3698         case BUILT_IN_ASINF:
3699         case BUILT_IN_ASINHF:
3700         case BUILT_IN_ATANF:
3701         case BUILT_IN_ATANHF:
3702         case BUILT_IN_CBRTF:
3703         case BUILT_IN_COSF:
3704         case BUILT_IN_COSHF:
3705         case BUILT_IN_ERFF:
3706         case BUILT_IN_ERFCF:
3707         case BUILT_IN_EXP2F:
3708         case BUILT_IN_EXPF:
3709         case BUILT_IN_EXPM1F:
3710         case BUILT_IN_LGAMMAF:
3711         case BUILT_IN_LOG10F:
3712         case BUILT_IN_LOG1PF:
3713         case BUILT_IN_LOG2F:
3714         case BUILT_IN_LOGF:
3715         case BUILT_IN_SINF:
3716         case BUILT_IN_SINHF:
3717         case BUILT_IN_SQRTF:
3718         case BUILT_IN_TANF:
3719         case BUILT_IN_TANHF:
3720           bdecl = builtin_decl_implicit (fn);
3721           suffix = "4";                                 /* powf -> powf4 */
3722           if (el_mode != SFmode
3723               || n != 4)
3724             return NULL_TREE;
3725           break;
3726
3727         default:
3728           return NULL_TREE;
3729         }
3730     }
3731   else
3732     return NULL_TREE;
3733
3734   gcc_assert (suffix != NULL);
3735   bname = IDENTIFIER_POINTER (DECL_NAME (bdecl));
3736   strcpy (name, bname + sizeof ("__builtin_") - 1);
3737   strcat (name, suffix);
3738
3739   if (n_args == 1)
3740     fntype = build_function_type_list (type_out, type_in, NULL);
3741   else if (n_args == 2)
3742     fntype = build_function_type_list (type_out, type_in, type_in, NULL);
3743   else
3744     gcc_unreachable ();
3745
3746   /* Build a function declaration for the vectorized function.  */
3747   new_fndecl = build_decl (BUILTINS_LOCATION,
3748                            FUNCTION_DECL, get_identifier (name), fntype);
3749   TREE_PUBLIC (new_fndecl) = 1;
3750   DECL_EXTERNAL (new_fndecl) = 1;
3751   DECL_IS_NOVOPS (new_fndecl) = 1;
3752   TREE_READONLY (new_fndecl) = 1;
3753
3754   return new_fndecl;
3755 }
3756
3757 /* Returns a function decl for a vectorized version of the builtin function
3758    with builtin function code FN and the result vector type TYPE, or NULL_TREE
3759    if it is not available.  */
3760
3761 static tree
3762 rs6000_builtin_vectorized_function (tree fndecl, tree type_out,
3763                                     tree type_in)
3764 {
3765   enum machine_mode in_mode, out_mode;
3766   int in_n, out_n;
3767
3768   if (TREE_CODE (type_out) != VECTOR_TYPE
3769       || TREE_CODE (type_in) != VECTOR_TYPE
3770       || !TARGET_VECTORIZE_BUILTINS)
3771     return NULL_TREE;
3772
3773   out_mode = TYPE_MODE (TREE_TYPE (type_out));
3774   out_n = TYPE_VECTOR_SUBPARTS (type_out);
3775   in_mode = TYPE_MODE (TREE_TYPE (type_in));
3776   in_n = TYPE_VECTOR_SUBPARTS (type_in);
3777
3778   if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_NORMAL)
3779     {
3780       enum built_in_function fn = DECL_FUNCTION_CODE (fndecl);
3781       switch (fn)
3782         {
3783         case BUILT_IN_COPYSIGN:
3784           if (VECTOR_UNIT_VSX_P (V2DFmode)
3785               && out_mode == DFmode && out_n == 2
3786               && in_mode == DFmode && in_n == 2)
3787             return rs6000_builtin_decls[VSX_BUILTIN_CPSGNDP];
3788           break;
3789         case BUILT_IN_COPYSIGNF:
3790           if (out_mode != SFmode || out_n != 4
3791               || in_mode != SFmode || in_n != 4)
3792             break;
3793           if (VECTOR_UNIT_VSX_P (V4SFmode))
3794             return rs6000_builtin_decls[VSX_BUILTIN_CPSGNSP];
3795           if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3796             return rs6000_builtin_decls[ALTIVEC_BUILTIN_COPYSIGN_V4SF];
3797           break;
3798         case BUILT_IN_SQRT:
3799           if (VECTOR_UNIT_VSX_P (V2DFmode)
3800               && out_mode == DFmode && out_n == 2
3801               && in_mode == DFmode && in_n == 2)
3802             return rs6000_builtin_decls[VSX_BUILTIN_XVSQRTDP];
3803           break;
3804         case BUILT_IN_SQRTF:
3805           if (VECTOR_UNIT_VSX_P (V4SFmode)
3806               && out_mode == SFmode && out_n == 4
3807               && in_mode == SFmode && in_n == 4)
3808             return rs6000_builtin_decls[VSX_BUILTIN_XVSQRTSP];
3809           break;
3810         case BUILT_IN_CEIL:
3811           if (VECTOR_UNIT_VSX_P (V2DFmode)
3812               && out_mode == DFmode && out_n == 2
3813               && in_mode == DFmode && in_n == 2)
3814             return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIP];
3815           break;
3816         case BUILT_IN_CEILF:
3817           if (out_mode != SFmode || out_n != 4
3818               || in_mode != SFmode || in_n != 4)
3819             break;
3820           if (VECTOR_UNIT_VSX_P (V4SFmode))
3821             return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIP];
3822           if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3823             return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIP];
3824           break;
3825         case BUILT_IN_FLOOR:
3826           if (VECTOR_UNIT_VSX_P (V2DFmode)
3827               && out_mode == DFmode && out_n == 2
3828               && in_mode == DFmode && in_n == 2)
3829             return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIM];
3830           break;
3831         case BUILT_IN_FLOORF:
3832           if (out_mode != SFmode || out_n != 4
3833               || in_mode != SFmode || in_n != 4)
3834             break;
3835           if (VECTOR_UNIT_VSX_P (V4SFmode))
3836             return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIM];
3837           if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3838             return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIM];
3839           break;
3840         case BUILT_IN_FMA:
3841           if (VECTOR_UNIT_VSX_P (V2DFmode)
3842               && out_mode == DFmode && out_n == 2
3843               && in_mode == DFmode && in_n == 2)
3844             return rs6000_builtin_decls[VSX_BUILTIN_XVMADDDP];
3845           break;
3846         case BUILT_IN_FMAF:
3847           if (VECTOR_UNIT_VSX_P (V4SFmode)
3848               && out_mode == SFmode && out_n == 4
3849               && in_mode == SFmode && in_n == 4)
3850             return rs6000_builtin_decls[VSX_BUILTIN_XVMADDSP];
3851           else if (VECTOR_UNIT_ALTIVEC_P (V4SFmode)
3852               && out_mode == SFmode && out_n == 4
3853               && in_mode == SFmode && in_n == 4)
3854             return rs6000_builtin_decls[ALTIVEC_BUILTIN_VMADDFP];
3855           break;
3856         case BUILT_IN_TRUNC:
3857           if (VECTOR_UNIT_VSX_P (V2DFmode)
3858               && out_mode == DFmode && out_n == 2
3859               && in_mode == DFmode && in_n == 2)
3860             return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIZ];
3861           break;
3862         case BUILT_IN_TRUNCF:
3863           if (out_mode != SFmode || out_n != 4
3864               || in_mode != SFmode || in_n != 4)
3865             break;
3866           if (VECTOR_UNIT_VSX_P (V4SFmode))
3867             return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIZ];
3868           if (VECTOR_UNIT_ALTIVEC_P (V4SFmode))
3869             return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRFIZ];
3870           break;
3871         case BUILT_IN_NEARBYINT:
3872           if (VECTOR_UNIT_VSX_P (V2DFmode)
3873               && flag_unsafe_math_optimizations
3874               && out_mode == DFmode && out_n == 2
3875               && in_mode == DFmode && in_n == 2)
3876             return rs6000_builtin_decls[VSX_BUILTIN_XVRDPI];
3877           break;
3878         case BUILT_IN_NEARBYINTF:
3879           if (VECTOR_UNIT_VSX_P (V4SFmode)
3880               && flag_unsafe_math_optimizations
3881               && out_mode == SFmode && out_n == 4
3882               && in_mode == SFmode && in_n == 4)
3883             return rs6000_builtin_decls[VSX_BUILTIN_XVRSPI];
3884           break;
3885         case BUILT_IN_RINT:
3886           if (VECTOR_UNIT_VSX_P (V2DFmode)
3887               && !flag_trapping_math
3888               && out_mode == DFmode && out_n == 2
3889               && in_mode == DFmode && in_n == 2)
3890             return rs6000_builtin_decls[VSX_BUILTIN_XVRDPIC];
3891           break;
3892         case BUILT_IN_RINTF:
3893           if (VECTOR_UNIT_VSX_P (V4SFmode)
3894               && !flag_trapping_math
3895               && out_mode == SFmode && out_n == 4
3896               && in_mode == SFmode && in_n == 4)
3897             return rs6000_builtin_decls[VSX_BUILTIN_XVRSPIC];
3898           break;
3899         default:
3900           break;
3901         }
3902     }
3903
3904   else if (DECL_BUILT_IN_CLASS (fndecl) == BUILT_IN_MD)
3905     {
3906       enum rs6000_builtins fn
3907         = (enum rs6000_builtins)DECL_FUNCTION_CODE (fndecl);
3908       switch (fn)
3909         {
3910         case RS6000_BUILTIN_RSQRTF:
3911           if (VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode)
3912               && out_mode == SFmode && out_n == 4
3913               && in_mode == SFmode && in_n == 4)
3914             return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRSQRTFP];
3915           break;
3916         case RS6000_BUILTIN_RSQRT:
3917           if (VECTOR_UNIT_VSX_P (V2DFmode)
3918               && out_mode == DFmode && out_n == 2
3919               && in_mode == DFmode && in_n == 2)
3920             return rs6000_builtin_decls[VSX_BUILTIN_VEC_RSQRT_V2DF];
3921           break;
3922         case RS6000_BUILTIN_RECIPF:
3923           if (VECTOR_UNIT_ALTIVEC_OR_VSX_P (V4SFmode)
3924               && out_mode == SFmode && out_n == 4
3925               && in_mode == SFmode && in_n == 4)
3926             return rs6000_builtin_decls[ALTIVEC_BUILTIN_VRECIPFP];
3927           break;
3928         case RS6000_BUILTIN_RECIP:
3929           if (VECTOR_UNIT_VSX_P (V2DFmode)
3930               && out_mode == DFmode && out_n == 2
3931               && in_mode == DFmode && in_n == 2)
3932             return rs6000_builtin_decls[VSX_BUILTIN_RECIP_V2DF];
3933           break;
3934         default:
3935           break;
3936         }
3937     }
3938
3939   /* Generate calls to libmass if appropriate.  */
3940   if (rs6000_veclib_handler)
3941     return rs6000_veclib_handler (fndecl, type_out, type_in);
3942
3943   return NULL_TREE;
3944 }
3945 \f
3946 /* Default CPU string for rs6000*_file_start functions.  */
3947 static const char *rs6000_default_cpu;
3948
3949 /* Do anything needed at the start of the asm file.  */
3950
3951 static void
3952 rs6000_file_start (void)
3953 {
3954   char buffer[80];
3955   const char *start = buffer;
3956   FILE *file = asm_out_file;
3957
3958   rs6000_default_cpu = TARGET_CPU_DEFAULT;
3959
3960   default_file_start ();
3961
3962 #ifdef TARGET_BI_ARCH
3963   if ((TARGET_DEFAULT ^ target_flags) & MASK_64BIT)
3964     rs6000_default_cpu = 0;
3965 #endif
3966
3967   if (flag_verbose_asm)
3968     {
3969       sprintf (buffer, "\n%s rs6000/powerpc options:", ASM_COMMENT_START);
3970
3971       if (rs6000_default_cpu != 0 && rs6000_default_cpu[0] != '\0')
3972         {
3973           fprintf (file, "%s --with-cpu=%s", start, rs6000_default_cpu);
3974           start = "";
3975         }
3976
3977       if (global_options_set.x_rs6000_cpu_index)
3978         {
3979           fprintf (file, "%s -mcpu=%s", start,
3980                    processor_target_table[rs6000_cpu_index].name);
3981           start = "";
3982         }
3983
3984       if (global_options_set.x_rs6000_tune_index)
3985         {
3986           fprintf (file, "%s -mtune=%s", start,
3987                    processor_target_table[rs6000_tune_index].name);
3988           start = "";
3989         }
3990
3991       if (PPC405_ERRATUM77)
3992         {
3993           fprintf (file, "%s PPC405CR_ERRATUM77", start);
3994           start = "";
3995         }
3996
3997 #ifdef USING_ELFOS_H
3998       switch (rs6000_sdata)
3999         {
4000         case SDATA_NONE: fprintf (file, "%s -msdata=none", start); start = ""; break;
4001         case SDATA_DATA: fprintf (file, "%s -msdata=data", start); start = ""; break;
4002         case SDATA_SYSV: fprintf (file, "%s -msdata=sysv", start); start = ""; break;
4003         case SDATA_EABI: fprintf (file, "%s -msdata=eabi", start); start = ""; break;
4004         }
4005
4006       if (rs6000_sdata && g_switch_value)
4007         {
4008           fprintf (file, "%s -G %d", start,
4009                    g_switch_value);
4010           start = "";
4011         }
4012 #endif
4013
4014       if (*start == '\0')
4015         putc ('\n', file);
4016     }
4017
4018   if (DEFAULT_ABI == ABI_AIX || (TARGET_ELF && flag_pic == 2))
4019     {
4020       switch_to_section (toc_section);
4021       switch_to_section (text_section);
4022     }
4023 }
4024
4025 \f
4026 /* Return nonzero if this function is known to have a null epilogue.  */
4027
4028 int
4029 direct_return (void)
4030 {
4031   if (reload_completed)
4032     {
4033       rs6000_stack_t *info = rs6000_stack_info ();
4034
4035       if (info->first_gp_reg_save == 32
4036           && info->first_fp_reg_save == 64
4037           && info->first_altivec_reg_save == LAST_ALTIVEC_REGNO + 1
4038           && ! info->lr_save_p
4039           && ! info->cr_save_p
4040           && info->vrsave_mask == 0
4041           && ! info->push_p)
4042         return 1;
4043     }
4044
4045   return 0;
4046 }
4047
4048 /* Return the number of instructions it takes to form a constant in an
4049    integer register.  */
4050
4051 int
4052 num_insns_constant_wide (HOST_WIDE_INT value)
4053 {
4054   /* signed constant loadable with {cal|addi} */
4055   if ((unsigned HOST_WIDE_INT) (value + 0x8000) < 0x10000)
4056     return 1;
4057
4058   /* constant loadable with {cau|addis} */
4059   else if ((value & 0xffff) == 0
4060            && (value >> 31 == -1 || value >> 31 == 0))
4061     return 1;
4062
4063 #if HOST_BITS_PER_WIDE_INT == 64
4064   else if (TARGET_POWERPC64)
4065     {
4066       HOST_WIDE_INT low  = ((value & 0xffffffff) ^ 0x80000000) - 0x80000000;
4067       HOST_WIDE_INT high = value >> 31;
4068
4069       if (high == 0 || high == -1)
4070         return 2;
4071
4072       high >>= 1;
4073
4074       if (low == 0)
4075         return num_insns_constant_wide (high) + 1;
4076       else if (high == 0)
4077         return num_insns_constant_wide (low) + 1;
4078       else
4079         return (num_insns_constant_wide (high)
4080                 + num_insns_constant_wide (low) + 1);
4081     }
4082 #endif
4083
4084   else
4085     return 2;
4086 }
4087
4088 int
4089 num_insns_constant (rtx op, enum machine_mode mode)
4090 {
4091   HOST_WIDE_INT low, high;
4092
4093   switch (GET_CODE (op))
4094     {
4095     case CONST_INT:
4096 #if HOST_BITS_PER_WIDE_INT == 64
4097       if ((INTVAL (op) >> 31) != 0 && (INTVAL (op) >> 31) != -1
4098           && mask64_operand (op, mode))
4099         return 2;
4100       else
4101 #endif
4102         return num_insns_constant_wide (INTVAL (op));
4103
4104       case CONST_DOUBLE:
4105         if (mode == SFmode || mode == SDmode)
4106           {
4107             long l;
4108             REAL_VALUE_TYPE rv;
4109
4110             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
4111             if (DECIMAL_FLOAT_MODE_P (mode))
4112               REAL_VALUE_TO_TARGET_DECIMAL32 (rv, l);
4113             else
4114               REAL_VALUE_TO_TARGET_SINGLE (rv, l);
4115             return num_insns_constant_wide ((HOST_WIDE_INT) l);
4116           }
4117
4118         if (mode == VOIDmode || mode == DImode)
4119           {
4120             high = CONST_DOUBLE_HIGH (op);
4121             low  = CONST_DOUBLE_LOW (op);
4122           }
4123         else
4124           {
4125             long l[2];
4126             REAL_VALUE_TYPE rv;
4127
4128             REAL_VALUE_FROM_CONST_DOUBLE (rv, op);
4129             if (DECIMAL_FLOAT_MODE_P (mode))
4130               REAL_VALUE_TO_TARGET_DECIMAL64 (rv, l);
4131             else
4132               REAL_VALUE_TO_TARGET_DOUBLE (rv, l);
4133             high = l[WORDS_BIG_ENDIAN == 0];
4134             low  = l[WORDS_BIG_ENDIAN != 0];
4135           }
4136
4137         if (TARGET_32BIT)
4138           return (num_insns_constant_wide (low)
4139                   + num_insns_constant_wide (high));
4140         else
4141           {
4142             if ((high == 0 && low >= 0)
4143                 || (high == -1 && low < 0))
4144               return num_insns_constant_wide (low);
4145
4146             else if (mask64_operand (op, mode))
4147               return 2;
4148
4149             else if (low == 0)
4150               return num_insns_constant_wide (high) + 1;
4151
4152             else
4153               return (num_insns_constant_wide (high)
4154                       + num_insns_constant_wide (low) + 1);
4155           }
4156
4157     default:
4158       gcc_unreachable ();
4159     }
4160 }
4161
4162 /* Interpret element ELT of the CONST_VECTOR OP as an integer value.
4163    If the mode of OP is MODE_VECTOR_INT, this simply returns the
4164    corresponding element of the vector, but for V4SFmode and V2SFmode,
4165    the corresponding "float" is interpreted as an SImode integer.  */
4166
4167 HOST_WIDE_INT
4168 const_vector_elt_as_int (rtx op, unsigned int elt)
4169 {
4170   rtx tmp;
4171
4172   /* We can't handle V2DImode and V2DFmode vector constants here yet.  */
4173   gcc_assert (GET_MODE (op) != V2DImode
4174               && GET_MODE (op) != V2DFmode);
4175
4176   tmp = CONST_VECTOR_ELT (op, elt);
4177   if (GET_MODE (op) == V4SFmode
4178       || GET_MODE (op) == V2SFmode)
4179     tmp = gen_lowpart (SImode, tmp);
4180   return INTVAL (tmp);
4181 }
4182
4183 /* Return true if OP can be synthesized with a particular vspltisb, vspltish
4184    or vspltisw instruction.  OP is a CONST_VECTOR.  Which instruction is used
4185    depends on STEP and COPIES, one of which will be 1.  If COPIES > 1,
4186    all items are set to the same value and contain COPIES replicas of the
4187    vsplt's operand; if STEP > 1, one in STEP elements is set to the vsplt's
4188    operand and the others are set to the value of the operand's msb.  */
4189
4190 static bool
4191 vspltis_constant (rtx op, unsigned step, unsigned copies)
4192 {
4193   enum machine_mode mode = GET_MODE (op);
4194   enum machine_mode inner = GET_MODE_INNER (mode);
4195
4196   unsigned i;
4197   unsigned nunits;
4198   unsigned bitsize;
4199   unsigned mask;
4200
4201   HOST_WIDE_INT val;
4202   HOST_WIDE_INT splat_val;
4203   HOST_WIDE_INT msb_val;
4204
4205   if (mode == V2DImode || mode == V2DFmode)
4206     return false;
4207
4208   nunits = GET_MODE_NUNITS (mode);
4209   bitsize = GET_MODE_BITSIZE (inner);
4210   mask = GET_MODE_MASK (inner);
4211
4212   val = const_vector_elt_as_int (op, nunits - 1);
4213   splat_val = val;
4214   msb_val = val > 0 ? 0 : -1;
4215
4216   /* Construct the value to be splatted, if possible.  If not, return 0.  */
4217   for (i = 2; i <= copies; i *= 2)
4218     {
4219       HOST_WIDE_INT small_val;
4220       bitsize /= 2;
4221       small_val = splat_val >> bitsize;
4222       mask >>= bitsize;
4223       if (splat_val != ((small_val << bitsize) | (small_val & mask)))
4224         return false;
4225       splat_val = small_val;
4226     }
4227
4228   /* Check if SPLAT_VAL can really be the operand of a vspltis[bhw].  */
4229   if (EASY_VECTOR_15 (splat_val))
4230     ;
4231
4232   /* Also check if we can splat, and then add the result to itself.  Do so if
4233      the value is positive, of if the splat instruction is using OP's mode;
4234      for splat_val < 0, the splat and the add should use the same mode.  */
4235   else if (EASY_VECTOR_15_ADD_SELF (splat_val)
4236            && (splat_val >= 0 || (step == 1 && copies == 1)))
4237     ;
4238
4239   /* Also check if are loading up the most significant bit which can be done by
4240      loading up -1 and shifting the value left by -1.  */
4241   else if (EASY_VECTOR_MSB (splat_val, inner))
4242     ;
4243
4244   else
4245     return false;
4246
4247   /* Check if VAL is present in every STEP-th element, and the
4248      other elements are filled with its most significant bit.  */
4249   for (i = 0; i < nunits - 1; ++i)
4250     {
4251       HOST_WIDE_INT desired_val;
4252       if (((i + 1) & (step - 1)) == 0)
4253         desired_val = val;
4254       else
4255         desired_val = msb_val;
4256
4257       if (desired_val != const_vector_elt_as_int (op, i))
4258         return false;
4259     }
4260
4261   return true;
4262 }
4263
4264
4265 /* Return true if OP is of the given MODE and can be synthesized
4266    with a vspltisb, vspltish or vspltisw.  */
4267
4268 bool
4269 easy_altivec_constant (rtx op, enum machine_mode mode)
4270 {
4271   unsigned step, copies;
4272
4273   if (mode == VOIDmode)
4274     mode = GET_MODE (op);
4275   else if (mode != GET_MODE (op))
4276     return false;
4277
4278   /* V2DI/V2DF was added with VSX.  Only allow 0 and all 1's as easy
4279      constants.  */
4280   if (mode == V2DFmode)
4281     return zero_constant (op, mode);
4282
4283   if (mode == V2DImode)
4284     {
4285       /* In case the compiler is built 32-bit, CONST_DOUBLE constants are not
4286          easy.  */
4287       if (GET_CODE (CONST_VECTOR_ELT (op, 0)) != CONST_INT
4288           || GET_CODE (CONST_VECTOR_ELT (op, 1)) != CONST_INT)
4289         return false;
4290
4291       if (zero_constant (op, mode))
4292         return true;
4293
4294       if (INTVAL (CONST_VECTOR_ELT (op, 0)) == -1
4295           && INTVAL (CONST_VECTOR_ELT (op, 1)) == -1)
4296         return true;
4297
4298       return false;
4299     }
4300
4301   /* Start with a vspltisw.  */
4302   step = GET_MODE_NUNITS (mode) / 4;
4303   copies = 1;
4304
4305   if (vspltis_constant (op, step, copies))
4306     return true;
4307
4308   /* Then try with a vspltish.  */
4309   if (step == 1)
4310     copies <<= 1;
4311   else
4312     step >>= 1;
4313
4314   if (vspltis_constant (op, step, copies))
4315     return true;
4316
4317   /* And finally a vspltisb.  */
4318   if (step == 1)
4319     copies <<= 1;
4320   else
4321     step >>= 1;
4322
4323   if (vspltis_constant (op, step, copies))
4324     return true;
4325
4326   return false;
4327 }
4328
4329 /* Generate a VEC_DUPLICATE representing a vspltis[bhw] instruction whose
4330    result is OP.  Abort if it is not possible.  */
4331
4332 rtx
4333 gen_easy_altivec_constant (rtx op)
4334 {
4335   enum machine_mode mode = GET_MODE (op);
4336   int nunits = GET_MODE_NUNITS (mode);
4337   rtx last = CONST_VECTOR_ELT (op, nunits - 1);
4338   unsigned step = nunits / 4;
4339   unsigned copies = 1;
4340
4341   /* Start with a vspltisw.  */
4342   if (vspltis_constant (op, step, copies))
4343     return gen_rtx_VEC_DUPLICATE (V4SImode, gen_lowpart (SImode, last));
4344
4345   /* Then try with a vspltish.  */
4346   if (step == 1)
4347     copies <<= 1;
4348   else
4349     step >>= 1;
4350
4351   if (vspltis_constant (op, step, copies))
4352     return gen_rtx_VEC_DUPLICATE (V8HImode, gen_lowpart (HImode, last));
4353
4354   /* And finally a vspltisb.  */
4355   if (step == 1)
4356     copies <<= 1;
4357   else
4358     step >>= 1;
4359
4360   if (vspltis_constant (op, step, copies))
4361     return gen_rtx_VEC_DUPLICATE (V16QImode, gen_lowpart (QImode, last));
4362
4363   gcc_unreachable ();
4364 }
4365
4366 const char *
4367 output_vec_const_move (rtx *operands)
4368 {
4369   int cst, cst2;
4370   enum machine_mode mode;
4371   rtx dest, vec;
4372
4373   dest = operands[0];
4374   vec = operands[1];
4375   mode = GET_MODE (dest);
4376
4377   if (TARGET_VSX)
4378     {
4379       if (zero_constant (vec, mode))
4380         return "xxlxor %x0,%x0,%x0";
4381
4382       if (mode == V2DImode
4383           && INTVAL (CONST_VECTOR_ELT (vec, 0)) == -1
4384           && INTVAL (CONST_VECTOR_ELT (vec, 1)) == -1)
4385         return "vspltisw %0,-1";
4386     }
4387
4388   if (TARGET_ALTIVEC)
4389     {
4390       rtx splat_vec;
4391       if (zero_constant (vec, mode))
4392         return "vxor %0,%0,%0";
4393
4394       splat_vec = gen_easy_altivec_constant (vec);
4395       gcc_assert (GET_CODE (splat_vec) == VEC_DUPLICATE);
4396       operands[1] = XEXP (splat_vec, 0);
4397       if (!EASY_VECTOR_15 (INTVAL (operands[1])))
4398         return "#";
4399
4400       switch (GET_MODE (splat_vec))
4401         {
4402         case V4SImode:
4403           return "vspltisw %0,%1";
4404
4405         case V8HImode:
4406           return "vspltish %0,%1";
4407
4408         case V16QImode:
4409           return "vspltisb %0,%1";
4410
4411         default:
4412           gcc_unreachable ();
4413         }
4414     }
4415
4416   gcc_assert (TARGET_SPE);
4417
4418   /* Vector constant 0 is handled as a splitter of V2SI, and in the
4419      pattern of V1DI, V4HI, and V2SF.
4420
4421      FIXME: We should probably return # and add post reload
4422      splitters for these, but this way is so easy ;-).  */
4423   cst = INTVAL (CONST_VECTOR_ELT (vec, 0));
4424   cst2 = INTVAL (CONST_VECTOR_ELT (vec, 1));
4425   operands[1] = CONST_VECTOR_ELT (vec, 0);
4426   operands[2] = CONST_VECTOR_ELT (vec, 1);
4427   if (cst == cst2)
4428     return "li %0,%1\n\tevmergelo %0,%0,%0";
4429   else
4430     return "li %0,%1\n\tevmergelo %0,%0,%0\n\tli %0,%2";
4431 }
4432
4433 /* Initialize TARGET of vector PAIRED to VALS.  */
4434
4435 void
4436 paired_expand_vector_init (rtx target, rtx vals)
4437 {
4438   enum machine_mode mode = GET_MODE (target);
4439   int n_elts = GET_MODE_NUNITS (mode);
4440   int n_var = 0;
4441   rtx x, new_rtx, tmp, constant_op, op1, op2;
4442   int i;
4443
4444   for (i = 0; i < n_elts; ++i)
4445     {
4446       x = XVECEXP (vals, 0, i);
4447       if (!(CONST_INT_P (x)
4448             || GET_CODE (x) == CONST_DOUBLE
4449             || GET_CODE (x) == CONST_FIXED))
4450         ++n_var;
4451     }
4452   if (n_var == 0)
4453     {
4454       /* Load from constant pool.  */
4455       emit_move_insn (target, gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0)));
4456       return;
4457     }
4458
4459   if (n_var == 2)
4460     {
4461       /* The vector is initialized only with non-constants.  */
4462       new_rtx = gen_rtx_VEC_CONCAT (V2SFmode, XVECEXP (vals, 0, 0),
4463                                 XVECEXP (vals, 0, 1));
4464
4465       emit_move_insn (target, new_rtx);
4466       return;
4467     }
4468
4469   /* One field is non-constant and the other one is a constant.  Load the
4470      constant from the constant pool and use ps_merge instruction to
4471      construct the whole vector.  */
4472   op1 = XVECEXP (vals, 0, 0);
4473   op2 = XVECEXP (vals, 0, 1);
4474
4475   constant_op = (CONSTANT_P (op1)) ? op1 : op2;
4476
4477   tmp = gen_reg_rtx (GET_MODE (constant_op));
4478   emit_move_insn (tmp, constant_op);
4479
4480   if (CONSTANT_P (op1))
4481     new_rtx = gen_rtx_VEC_CONCAT (V2SFmode, tmp, op2);
4482   else
4483     new_rtx = gen_rtx_VEC_CONCAT (V2SFmode, op1, tmp);
4484
4485   emit_move_insn (target, new_rtx);
4486 }
4487
4488 void
4489 paired_expand_vector_move (rtx operands[])
4490 {
4491   rtx op0 = operands[0], op1 = operands[1];
4492
4493   emit_move_insn (op0, op1);
4494 }
4495
4496 /* Emit vector compare for code RCODE.  DEST is destination, OP1 and
4497    OP2 are two VEC_COND_EXPR operands, CC_OP0 and CC_OP1 are the two
4498    operands for the relation operation COND.  This is a recursive
4499    function.  */
4500
4501 static void
4502 paired_emit_vector_compare (enum rtx_code rcode,
4503                             rtx dest, rtx op0, rtx op1,
4504                             rtx cc_op0, rtx cc_op1)
4505 {
4506   rtx tmp = gen_reg_rtx (V2SFmode);
4507   rtx tmp1, max, min;
4508
4509   gcc_assert (TARGET_PAIRED_FLOAT);
4510   gcc_assert (GET_MODE (op0) == GET_MODE (op1));
4511
4512   switch (rcode)
4513     {
4514     case LT:
4515     case LTU:
4516       paired_emit_vector_compare (GE, dest, op1, op0, cc_op0, cc_op1);
4517       return;
4518     case GE:
4519     case GEU:
4520       emit_insn (gen_subv2sf3 (tmp, cc_op0, cc_op1));
4521       emit_insn (gen_selv2sf4 (dest, tmp, op0, op1, CONST0_RTX (SFmode)));
4522       return;
4523     case LE:
4524     case LEU:
4525       paired_emit_vector_compare (GE, dest, op0, op1, cc_op1, cc_op0);
4526       return;
4527     case GT:
4528       paired_emit_vector_compare (LE, dest, op1, op0, cc_op0, cc_op1);
4529       return;
4530     case EQ:
4531       tmp1 = gen_reg_rtx (V2SFmode);
4532       max = gen_reg_rtx (V2SFmode);
4533       min = gen_reg_rtx (V2SFmode);
4534       gen_reg_rtx (V2SFmode);
4535
4536       emit_insn (gen_subv2sf3 (tmp, cc_op0, cc_op1));
4537       emit_insn (gen_selv2sf4
4538                  (max, tmp, cc_op0, cc_op1, CONST0_RTX (SFmode)));
4539       emit_insn (gen_subv2sf3 (tmp, cc_op1, cc_op0));
4540       emit_insn (gen_selv2sf4
4541                  (min, tmp, cc_op0, cc_op1, CONST0_RTX (SFmode)));
4542       emit_insn (gen_subv2sf3 (tmp1, min, max));
4543       emit_insn (gen_selv2sf4 (dest, tmp1, op0, op1, CONST0_RTX (SFmode)));
4544       return;
4545     case NE:
4546       paired_emit_vector_compare (EQ, dest, op1, op0, cc_op0, cc_op1);
4547       return;
4548     case UNLE:
4549       paired_emit_vector_compare (LE, dest, op1, op0, cc_op0, cc_op1);
4550       return;
4551     case UNLT:
4552       paired_emit_vector_compare (LT, dest, op1, op0, cc_op0, cc_op1);
4553       return;
4554     case UNGE:
4555       paired_emit_vector_compare (GE, dest, op1, op0, cc_op0, cc_op1);
4556       return;
4557     case UNGT:
4558       paired_emit_vector_compare (GT, dest, op1, op0, cc_op0, cc_op1);
4559       return;
4560     default:
4561       gcc_unreachable ();
4562     }
4563
4564   return;
4565 }
4566
4567 /* Emit vector conditional expression.
4568    DEST is destination. OP1 and OP2 are two VEC_COND_EXPR operands.
4569    CC_OP0 and CC_OP1 are the two operands for the relation operation COND.  */
4570
4571 int
4572 paired_emit_vector_cond_expr (rtx dest, rtx op1, rtx op2,
4573                               rtx cond, rtx cc_op0, rtx cc_op1)
4574 {
4575   enum rtx_code rcode = GET_CODE (cond);
4576
4577   if (!TARGET_PAIRED_FLOAT)
4578     return 0;
4579
4580   paired_emit_vector_compare (rcode, dest, op1, op2, cc_op0, cc_op1);
4581
4582   return 1;
4583 }
4584
4585 /* Initialize vector TARGET to VALS.  */
4586
4587 void
4588 rs6000_expand_vector_init (rtx target, rtx vals)
4589 {
4590   enum machine_mode mode = GET_MODE (target);
4591   enum machine_mode inner_mode = GET_MODE_INNER (mode);
4592   int n_elts = GET_MODE_NUNITS (mode);
4593   int n_var = 0, one_var = -1;
4594   bool all_same = true, all_const_zero = true;
4595   rtx x, mem;
4596   int i;
4597
4598   for (i = 0; i < n_elts; ++i)
4599     {
4600       x = XVECEXP (vals, 0, i);
4601       if (!(CONST_INT_P (x)
4602             || GET_CODE (x) == CONST_DOUBLE
4603             || GET_CODE (x) == CONST_FIXED))
4604         ++n_var, one_var = i;
4605       else if (x != CONST0_RTX (inner_mode))
4606         all_const_zero = false;
4607
4608       if (i > 0 && !rtx_equal_p (x, XVECEXP (vals, 0, 0)))
4609         all_same = false;
4610     }
4611
4612   if (n_var == 0)
4613     {
4614       rtx const_vec = gen_rtx_CONST_VECTOR (mode, XVEC (vals, 0));
4615       bool int_vector_p = (GET_MODE_CLASS (mode) == MODE_VECTOR_INT);
4616       if ((int_vector_p || TARGET_VSX) && all_const_zero)
4617         {
4618           /* Zero register.  */
4619           emit_insn (gen_rtx_SET (VOIDmode, target,
4620                                   gen_rtx_XOR (mode, target, target)));
4621           return;
4622         }
4623       else if (int_vector_p && easy_vector_constant (const_vec, mode))
4624         {
4625           /* Splat immediate.  */
4626           emit_insn (gen_rtx_SET (VOIDmode, target, const_vec));
4627           return;
4628         }
4629       else
4630         {
4631           /* Load from constant pool.  */
4632           emit_move_insn (target, const_vec);
4633           return;
4634         }
4635     }
4636
4637   /* Double word values on VSX can use xxpermdi or lxvdsx.  */
4638   if (VECTOR_MEM_VSX_P (mode) && (mode == V2DFmode || mode == V2DImode))
4639     {
4640       if (all_same)
4641         {
4642           rtx element = XVECEXP (vals, 0, 0);
4643           if (mode == V2DFmode)
4644             emit_insn (gen_vsx_splat_v2df (target, element));
4645           else
4646             emit_insn (gen_vsx_splat_v2di (target, element));
4647         }
4648       else
4649         {
4650           if (mode == V2DFmode)
4651             {
4652               rtx op0 = copy_to_mode_reg (DFmode, XVECEXP (vals, 0, 0));
4653               rtx op1 = copy_to_mode_reg (DFmode, XVECEXP (vals, 0, 1));
4654               emit_insn (gen_vsx_concat_v2df (target, op0, op1));
4655             }
4656           else
4657             {
4658               rtx op0 = copy_to_mode_reg (DImode, XVECEXP (vals, 0, 0));
4659               rtx op1 = copy_to_mode_reg (DImode, XVECEXP (vals, 0, 1));
4660               emit_insn (gen_vsx_concat_v2di (target, op0, op1));
4661             }
4662         }
4663       return;
4664     }
4665
4666   /* With single precision floating point on VSX, know that internally single
4667      precision is actually represented as a double, and either make 2 V2DF
4668      vectors, and convert these vectors to single precision, or do one
4669      conversion, and splat the result to the other elements.  */
4670   if (mode == V4SFmode && VECTOR_MEM_VSX_P (mode))
4671     {
4672       if (all_same)
4673         {
4674           rtx freg = gen_reg_rtx (V4SFmode);
4675           rtx sreg = copy_to_reg (XVECEXP (vals, 0, 0));
4676
4677           emit_insn (gen_vsx_xscvdpsp_scalar (freg, sreg));
4678           emit_insn (gen_vsx_xxspltw_v4sf (target, freg, const0_rtx));
4679         }
4680       else
4681         {
4682           rtx dbl_even = gen_reg_rtx (V2DFmode);
4683           rtx dbl_odd  = gen_reg_rtx (V2DFmode);
4684           rtx flt_even = gen_reg_rtx (V4SFmode);
4685           rtx flt_odd  = gen_reg_rtx (V4SFmode);
4686
4687           emit_insn (gen_vsx_concat_v2sf (dbl_even,
4688                                           copy_to_reg (XVECEXP (vals, 0, 0)),
4689                                           copy_to_reg (XVECEXP (vals, 0, 1))));
4690           emit_insn (gen_vsx_concat_v2sf (dbl_odd,
4691                                           copy_to_reg (XVECEXP (vals, 0, 2)),
4692                                           copy_to_reg (XVECEXP (vals, 0, 3))));
4693           emit_insn (gen_vsx_xvcvdpsp (flt_even, dbl_even));
4694           emit_insn (gen_vsx_xvcvdpsp (flt_odd, dbl_odd));
4695           emit_insn (gen_vec_extract_evenv4sf (target, flt_even, flt_odd));
4696         }
4697       return;
4698     }
4699
4700   /* Store value to stack temp.  Load vector element.  Splat.  However, splat
4701      of 64-bit items is not supported on Altivec.  */
4702   if (all_same && GET_MODE_SIZE (inner_mode) <= 4)
4703     {
4704       mem = assign_stack_temp (mode, GET_MODE_SIZE (inner_mode), 0);
4705       emit_move_insn (adjust_address_nv (mem, inner_mode, 0),
4706                       XVECEXP (vals, 0, 0));
4707       x = gen_rtx_UNSPEC (VOIDmode,
4708                           gen_rtvec (1, const0_rtx), UNSPEC_LVE);
4709       emit_insn (gen_rtx_PARALLEL (VOIDmode,
4710                                    gen_rtvec (2,
4711                                               gen_rtx_SET (VOIDmode,
4712                                                            target, mem),
4713                                               x)));
4714       x = gen_rtx_VEC_SELECT (inner_mode, target,
4715                               gen_rtx_PARALLEL (VOIDmode,
4716                                                 gen_rtvec (1, const0_rtx)));
4717       emit_insn (gen_rtx_SET (VOIDmode, target,
4718                               gen_rtx_VEC_DUPLICATE (mode, x)));
4719       return;
4720     }
4721
4722   /* One field is non-constant.  Load constant then overwrite
4723      varying field.  */
4724   if (n_var == 1)
4725     {
4726       rtx copy = copy_rtx (vals);
4727
4728       /* Load constant part of vector, substitute neighboring value for
4729          varying element.  */
4730       XVECEXP (copy, 0, one_var) = XVECEXP (vals, 0, (one_var + 1) % n_elts);
4731       rs6000_expand_vector_init (target, copy);
4732
4733       /* Insert variable.  */
4734       rs6000_expand_vector_set (target, XVECEXP (vals, 0, one_var), one_var);
4735       return;
4736     }
4737
4738   /* Construct the vector in memory one field at a time
4739      and load the whole vector.  */
4740   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
4741   for (i = 0; i < n_elts; i++)
4742     emit_move_insn (adjust_address_nv (mem, inner_mode,
4743                                     i * GET_MODE_SIZE (inner_mode)),
4744                     XVECEXP (vals, 0, i));
4745   emit_move_insn (target, mem);
4746 }
4747
4748 /* Set field ELT of TARGET to VAL.  */
4749
4750 void
4751 rs6000_expand_vector_set (rtx target, rtx val, int elt)
4752 {
4753   enum machine_mode mode = GET_MODE (target);
4754   enum machine_mode inner_mode = GET_MODE_INNER (mode);
4755   rtx reg = gen_reg_rtx (mode);
4756   rtx mask, mem, x;
4757   int width = GET_MODE_SIZE (inner_mode);
4758   int i;
4759
4760   if (VECTOR_MEM_VSX_P (mode) && (mode == V2DFmode || mode == V2DImode))
4761     {
4762       rtx (*set_func) (rtx, rtx, rtx, rtx)
4763         = ((mode == V2DFmode) ? gen_vsx_set_v2df : gen_vsx_set_v2di);
4764       emit_insn (set_func (target, target, val, GEN_INT (elt)));
4765       return;
4766     }
4767
4768   /* Load single variable value.  */
4769   mem = assign_stack_temp (mode, GET_MODE_SIZE (inner_mode), 0);
4770   emit_move_insn (adjust_address_nv (mem, inner_mode, 0), val);
4771   x = gen_rtx_UNSPEC (VOIDmode,
4772                       gen_rtvec (1, const0_rtx), UNSPEC_LVE);
4773   emit_insn (gen_rtx_PARALLEL (VOIDmode,
4774                                gen_rtvec (2,
4775                                           gen_rtx_SET (VOIDmode,
4776                                                        reg, mem),
4777                                           x)));
4778
4779   /* Linear sequence.  */
4780   mask = gen_rtx_PARALLEL (V16QImode, rtvec_alloc (16));
4781   for (i = 0; i < 16; ++i)
4782     XVECEXP (mask, 0, i) = GEN_INT (i);
4783
4784   /* Set permute mask to insert element into target.  */
4785   for (i = 0; i < width; ++i)
4786     XVECEXP (mask, 0, elt*width + i)
4787       = GEN_INT (i + 0x10);
4788   x = gen_rtx_CONST_VECTOR (V16QImode, XVEC (mask, 0));
4789   x = gen_rtx_UNSPEC (mode,
4790                       gen_rtvec (3, target, reg,
4791                                  force_reg (V16QImode, x)),
4792                       UNSPEC_VPERM);
4793   emit_insn (gen_rtx_SET (VOIDmode, target, x));
4794 }
4795
4796 /* Extract field ELT from VEC into TARGET.  */
4797
4798 void
4799 rs6000_expand_vector_extract (rtx target, rtx vec, int elt)
4800 {
4801   enum machine_mode mode = GET_MODE (vec);
4802   enum machine_mode inner_mode = GET_MODE_INNER (mode);
4803   rtx mem;
4804
4805   if (VECTOR_MEM_VSX_P (mode))
4806     {
4807       switch (mode)
4808         {
4809         default:
4810           break;
4811         case V2DFmode:
4812           emit_insn (gen_vsx_extract_v2df (target, vec, GEN_INT (elt)));
4813           return;
4814         case V2DImode:
4815           emit_insn (gen_vsx_extract_v2di (target, vec, GEN_INT (elt)));
4816           return;
4817         case V4SFmode:
4818           emit_insn (gen_vsx_extract_v4sf (target, vec, GEN_INT (elt)));
4819           return;
4820         }
4821     }
4822
4823   /* Allocate mode-sized buffer.  */
4824   mem = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
4825
4826   emit_move_insn (mem, vec);
4827
4828   /* Add offset to field within buffer matching vector element.  */
4829   mem = adjust_address_nv (mem, inner_mode, elt * GET_MODE_SIZE (inner_mode));
4830
4831   emit_move_insn (target, adjust_address_nv (mem, inner_mode, 0));
4832 }
4833
4834 /* Generates shifts and masks for a pair of rldicl or rldicr insns to
4835    implement ANDing by the mask IN.  */
4836 void
4837 build_mask64_2_operands (rtx in, rtx *out)
4838 {
4839 #if HOST_BITS_PER_WIDE_INT >= 64
4840   unsigned HOST_WIDE_INT c, lsb, m1, m2;
4841   int shift;
4842
4843   gcc_assert (GET_CODE (in) == CONST_INT);
4844
4845   c = INTVAL (in);
4846   if (c & 1)
4847     {
4848       /* Assume c initially something like 0x00fff000000fffff.  The idea
4849          is to rotate the word so that the middle ^^^^^^ group of zeros
4850          is at the MS end and can be cleared with an rldicl mask.  We then
4851          rotate back and clear off the MS    ^^ group of zeros with a
4852          second rldicl.  */
4853       c = ~c;                   /*   c == 0xff000ffffff00000 */
4854       lsb = c & -c;             /* lsb == 0x0000000000100000 */
4855       m1 = -lsb;                /*  m1 == 0xfffffffffff00000 */
4856       c = ~c;                   /*   c == 0x00fff000000fffff */
4857       c &= -lsb;                /*   c == 0x00fff00000000000 */
4858       lsb = c & -c;             /* lsb == 0x0000100000000000 */
4859       c = ~c;                   /*   c == 0xff000fffffffffff */
4860       c &= -lsb;                /*   c == 0xff00000000000000 */
4861       shift = 0;
4862       while ((lsb >>= 1) != 0)
4863         shift++;                /* shift == 44 on exit from loop */
4864       m1 <<= 64 - shift;        /*  m1 == 0xffffff0000000000 */
4865       m1 = ~m1;                 /*  m1 == 0x000000ffffffffff */
4866       m2 = ~c;                  /*  m2 == 0x00ffffffffffffff */
4867     }
4868   else
4869     {
4870       /* Assume c initially something like 0xff000f0000000000.  The idea
4871          is to rotate the word so that the     ^^^  middle group of zeros
4872          is at the LS end and can be cleared with an rldicr mask.  We then
4873          rotate back and clear off the LS group of ^^^^^^^^^^ zeros with
4874          a second rldicr.  */
4875       lsb = c & -c;             /* lsb == 0x0000010000000000 */
4876       m2 = -lsb;                /*  m2 == 0xffffff0000000000 */
4877       c = ~c;                   /*   c == 0x00fff0ffffffffff */
4878       c &= -lsb;                /*   c == 0x00fff00000000000 */
4879       lsb = c & -c;             /* lsb == 0x0000100000000000 */
4880       c = ~c;                   /*   c == 0xff000fffffffffff */
4881       c &= -lsb;                /*   c == 0xff00000000000000 */
4882       shift = 0;
4883       while ((lsb >>= 1) != 0)
4884         shift++;                /* shift == 44 on exit from loop */
4885       m1 = ~c;                  /*  m1 == 0x00ffffffffffffff */
4886       m1 >>= shift;             /*  m1 == 0x0000000000000fff */
4887       m1 = ~m1;                 /*  m1 == 0xfffffffffffff000 */
4888     }
4889
4890   /* Note that when we only have two 0->1 and 1->0 transitions, one of the
4891      masks will be all 1's.  We are guaranteed more than one transition.  */
4892   out[0] = GEN_INT (64 - shift);
4893   out[1] = GEN_INT (m1);
4894   out[2] = GEN_INT (shift);
4895   out[3] = GEN_INT (m2);
4896 #else
4897   (void)in;
4898   (void)out;
4899   gcc_unreachable ();
4900 #endif
4901 }
4902
4903 /* Return TRUE if OP is an invalid SUBREG operation on the e500.  */
4904
4905 bool
4906 invalid_e500_subreg (rtx op, enum machine_mode mode)
4907 {
4908   if (TARGET_E500_DOUBLE)
4909     {
4910       /* Reject (subreg:SI (reg:DF)); likewise with subreg:DI or
4911          subreg:TI and reg:TF.  Decimal float modes are like integer
4912          modes (only low part of each register used) for this
4913          purpose.  */
4914       if (GET_CODE (op) == SUBREG
4915           && (mode == SImode || mode == DImode || mode == TImode
4916               || mode == DDmode || mode == TDmode)
4917           && REG_P (SUBREG_REG (op))
4918           && (GET_MODE (SUBREG_REG (op)) == DFmode
4919               || GET_MODE (SUBREG_REG (op)) == TFmode))
4920         return true;
4921
4922       /* Reject (subreg:DF (reg:DI)); likewise with subreg:TF and
4923          reg:TI.  */
4924       if (GET_CODE (op) == SUBREG
4925           && (mode == DFmode || mode == TFmode)
4926           && REG_P (SUBREG_REG (op))
4927           && (GET_MODE (SUBREG_REG (op)) == DImode
4928               || GET_MODE (SUBREG_REG (op)) == TImode
4929               || GET_MODE (SUBREG_REG (op)) == DDmode
4930               || GET_MODE (SUBREG_REG (op)) == TDmode))
4931         return true;
4932     }
4933
4934   if (TARGET_SPE
4935       && GET_CODE (op) == SUBREG
4936       && mode == SImode
4937       && REG_P (SUBREG_REG (op))
4938       && SPE_VECTOR_MODE (GET_MODE (SUBREG_REG (op))))
4939     return true;
4940
4941   return false;
4942 }
4943
4944 /* AIX increases natural record alignment to doubleword if the first
4945    field is an FP double while the FP fields remain word aligned.  */
4946
4947 unsigned int
4948 rs6000_special_round_type_align (tree type, unsigned int computed,
4949                                  unsigned int specified)
4950 {
4951   unsigned int align = MAX (computed, specified);
4952   tree field = TYPE_FIELDS (type);
4953
4954   /* Skip all non field decls */
4955   while (field != NULL && TREE_CODE (field) != FIELD_DECL)
4956     field = DECL_CHAIN (field);
4957
4958   if (field != NULL && field != type)
4959     {
4960       type = TREE_TYPE (field);
4961       while (TREE_CODE (type) == ARRAY_TYPE)
4962         type = TREE_TYPE (type);
4963
4964       if (type != error_mark_node && TYPE_MODE (type) == DFmode)
4965         align = MAX (align, 64);
4966     }
4967
4968   return align;
4969 }
4970
4971 /* Darwin increases record alignment to the natural alignment of
4972    the first field.  */
4973
4974 unsigned int
4975 darwin_rs6000_special_round_type_align (tree type, unsigned int computed,
4976                                         unsigned int specified)
4977 {
4978   unsigned int align = MAX (computed, specified);
4979
4980   if (TYPE_PACKED (type))
4981     return align;
4982
4983   /* Find the first field, looking down into aggregates.  */
4984   do {
4985     tree field = TYPE_FIELDS (type);
4986     /* Skip all non field decls */
4987     while (field != NULL && TREE_CODE (field) != FIELD_DECL)
4988       field = DECL_CHAIN (field);
4989     if (! field)
4990       break;
4991     /* A packed field does not contribute any extra alignment.  */
4992     if (DECL_PACKED (field))
4993       return align;
4994     type = TREE_TYPE (field);
4995     while (TREE_CODE (type) == ARRAY_TYPE)
4996       type = TREE_TYPE (type);
4997   } while (AGGREGATE_TYPE_P (type));
4998
4999   if (! AGGREGATE_TYPE_P (type) && type != error_mark_node)
5000     align = MAX (align, TYPE_ALIGN (type));
5001
5002   return align;
5003 }
5004
5005 /* Return 1 for an operand in small memory on V.4/eabi.  */
5006
5007 int
5008 small_data_operand (rtx op ATTRIBUTE_UNUSED,
5009                     enum machine_mode mode ATTRIBUTE_UNUSED)
5010 {
5011 #if TARGET_ELF
5012   rtx sym_ref;
5013
5014   if (rs6000_sdata == SDATA_NONE || rs6000_sdata == SDATA_DATA)
5015     return 0;
5016
5017   if (DEFAULT_ABI != ABI_V4)
5018     return 0;
5019
5020   /* Vector and float memory instructions have a limited offset on the
5021      SPE, so using a vector or float variable directly as an operand is
5022      not useful.  */
5023   if (TARGET_SPE
5024       && (SPE_VECTOR_MODE (mode) || FLOAT_MODE_P (mode)))
5025     return 0;
5026
5027   if (GET_CODE (op) == SYMBOL_REF)
5028     sym_ref = op;
5029
5030   else if (GET_CODE (op) != CONST
5031            || GET_CODE (XEXP (op, 0)) != PLUS
5032            || GET_CODE (XEXP (XEXP (op, 0), 0)) != SYMBOL_REF
5033            || GET_CODE (XEXP (XEXP (op, 0), 1)) != CONST_INT)
5034     return 0;
5035
5036   else
5037     {
5038       rtx sum = XEXP (op, 0);
5039       HOST_WIDE_INT summand;
5040
5041       /* We have to be careful here, because it is the referenced address
5042          that must be 32k from _SDA_BASE_, not just the symbol.  */
5043       summand = INTVAL (XEXP (sum, 1));
5044       if (summand < 0 || summand > g_switch_value)
5045         return 0;
5046
5047       sym_ref = XEXP (sum, 0);
5048     }
5049
5050   return SYMBOL_REF_SMALL_P (sym_ref);
5051 #else
5052   return 0;
5053 #endif
5054 }
5055
5056 /* Return true if either operand is a general purpose register.  */
5057
5058 bool
5059 gpr_or_gpr_p (rtx op0, rtx op1)
5060 {
5061   return ((REG_P (op0) && INT_REGNO_P (REGNO (op0)))
5062           || (REG_P (op1) && INT_REGNO_P (REGNO (op1))));
5063 }
5064
5065 \f
5066 /* Subroutines of rs6000_legitimize_address and rs6000_legitimate_address_p.  */
5067
5068 static bool
5069 reg_offset_addressing_ok_p (enum machine_mode mode)
5070 {
5071   switch (mode)
5072     {
5073     case V16QImode:
5074     case V8HImode:
5075     case V4SFmode:
5076     case V4SImode:
5077     case V2DFmode:
5078     case V2DImode:
5079       /* AltiVec/VSX vector modes.  Only reg+reg addressing is valid.  */
5080       if (VECTOR_MEM_ALTIVEC_OR_VSX_P (mode))
5081         return false;
5082       break;
5083
5084     case V4HImode:
5085     case V2SImode:
5086     case V1DImode:
5087     case V2SFmode:
5088        /* Paired vector modes.  Only reg+reg addressing is valid.  */
5089       if (TARGET_PAIRED_FLOAT)
5090         return false;
5091       break;
5092
5093     default:
5094       break;
5095     }
5096
5097   return true;
5098 }
5099
5100 static bool
5101 virtual_stack_registers_memory_p (rtx op)
5102 {
5103   int regnum;
5104
5105   if (GET_CODE (op) == REG)
5106     regnum = REGNO (op);
5107
5108   else if (GET_CODE (op) == PLUS
5109            && GET_CODE (XEXP (op, 0)) == REG
5110            && GET_CODE (XEXP (op, 1)) == CONST_INT)
5111     regnum = REGNO (XEXP (op, 0));
5112
5113   else
5114     return false;
5115
5116   return (regnum >= FIRST_VIRTUAL_REGISTER
5117           && regnum <= LAST_VIRTUAL_POINTER_REGISTER);
5118 }
5119
5120 /* Return true if memory accesses to OP are known to never straddle
5121    a 32k boundary.  */
5122
5123 static bool
5124 offsettable_ok_by_alignment (rtx op, HOST_WIDE_INT offset,
5125                              enum machine_mode mode)
5126 {
5127   tree decl, type;
5128   unsigned HOST_WIDE_INT dsize, dalign;
5129
5130   if (GET_CODE (op) != SYMBOL_REF)
5131     return false;
5132
5133   decl = SYMBOL_REF_DECL (op);
5134   if (!decl)
5135     {
5136       if (GET_MODE_SIZE (mode) == 0)
5137         return false;
5138
5139       /* -fsection-anchors loses the original SYMBOL_REF_DECL when
5140          replacing memory addresses with an anchor plus offset.  We
5141          could find the decl by rummaging around in the block->objects
5142          VEC for the given offset but that seems like too much work.  */
5143       dalign = 1;
5144       if (SYMBOL_REF_HAS_BLOCK_INFO_P (op)
5145           && SYMBOL_REF_ANCHOR_P (op)
5146           && SYMBOL_REF_BLOCK (op) != NULL)
5147         {
5148           struct object_block *block = SYMBOL_REF_BLOCK (op);
5149           HOST_WIDE_INT lsb, mask;
5150
5151           /* Given the alignment of the block..  */
5152           dalign = block->alignment;
5153           mask = dalign / BITS_PER_UNIT - 1;
5154
5155           /* ..and the combined offset of the anchor and any offset
5156              to this block object..  */
5157           offset += SYMBOL_REF_BLOCK_OFFSET (op);
5158           lsb = offset & -offset;
5159
5160           /* ..find how many bits of the alignment we know for the
5161              object.  */
5162           mask &= lsb - 1;
5163           dalign = mask + 1;
5164         }
5165       return dalign >= GET_MODE_SIZE (mode);
5166     }
5167
5168   if (DECL_P (decl))
5169     {
5170       if (TREE_CODE (decl) == FUNCTION_DECL)
5171         return true;
5172
5173       if (!DECL_SIZE_UNIT (decl))
5174         return false;
5175
5176       if (!host_integerp (DECL_SIZE_UNIT (decl), 1))
5177         return false;
5178
5179       dsize = tree_low_cst (DECL_SIZE_UNIT (decl), 1);
5180       if (dsize > 32768)
5181         return false;
5182
5183       dalign = DECL_ALIGN_UNIT (decl);
5184       return dalign >= dsize;
5185     }
5186
5187   type = TREE_TYPE (decl);
5188
5189   if (TREE_CODE (decl) == STRING_CST)
5190     dsize = TREE_STRING_LENGTH (decl);
5191   else if (TYPE_SIZE_UNIT (type)
5192            && host_integerp (TYPE_SIZE_UNIT (type), 1))
5193     dsize = tree_low_cst (TYPE_SIZE_UNIT (type), 1);
5194   else
5195     return false;
5196   if (dsize > 32768)
5197     return false;
5198
5199   dalign = TYPE_ALIGN (type);
5200   if (CONSTANT_CLASS_P (decl))
5201     dalign = CONSTANT_ALIGNMENT (decl, dalign);
5202   else
5203     dalign = DATA_ALIGNMENT (decl, dalign);
5204   dalign /= BITS_PER_UNIT;
5205   return dalign >= dsize;
5206 }
5207
5208 static bool
5209 constant_pool_expr_p (rtx op)
5210 {
5211   rtx base, offset;
5212
5213   split_const (op, &base, &offset);
5214   return (GET_CODE (base) == SYMBOL_REF
5215           && CONSTANT_POOL_ADDRESS_P (base)
5216           && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (base), Pmode));
5217 }
5218
5219 static rtx tocrel_base, tocrel_offset;
5220
5221 bool
5222 toc_relative_expr_p (rtx op)
5223 {
5224   if (GET_CODE (op) != CONST)
5225     return false;
5226
5227   split_const (op, &tocrel_base, &tocrel_offset);
5228   return (GET_CODE (tocrel_base) == UNSPEC
5229           && XINT (tocrel_base, 1) == UNSPEC_TOCREL);
5230 }
5231
5232 /* Return true if X is a constant pool address, and also for cmodel=medium
5233    if X is a toc-relative address known to be offsettable within MODE.  */
5234
5235 bool
5236 legitimate_constant_pool_address_p (const_rtx x, enum machine_mode mode,
5237                                     bool strict)
5238 {
5239   return (TARGET_TOC
5240           && (GET_CODE (x) == PLUS || GET_CODE (x) == LO_SUM)
5241           && GET_CODE (XEXP (x, 0)) == REG
5242           && (REGNO (XEXP (x, 0)) == TOC_REGISTER
5243               || ((TARGET_MINIMAL_TOC
5244                    || TARGET_CMODEL != CMODEL_SMALL)
5245                   && INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict)))
5246           && toc_relative_expr_p (XEXP (x, 1))
5247           && (TARGET_CMODEL != CMODEL_MEDIUM
5248               || constant_pool_expr_p (XVECEXP (tocrel_base, 0, 0))
5249               || mode == QImode
5250               || offsettable_ok_by_alignment (XVECEXP (tocrel_base, 0, 0),
5251                                               INTVAL (tocrel_offset), mode)));
5252 }
5253
5254 static bool
5255 legitimate_small_data_p (enum machine_mode mode, rtx x)
5256 {
5257   return (DEFAULT_ABI == ABI_V4
5258           && !flag_pic && !TARGET_TOC
5259           && (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == CONST)
5260           && small_data_operand (x, mode));
5261 }
5262
5263 /* SPE offset addressing is limited to 5-bits worth of double words.  */
5264 #define SPE_CONST_OFFSET_OK(x) (((x) & ~0xf8) == 0)
5265
5266 bool
5267 rs6000_legitimate_offset_address_p (enum machine_mode mode, rtx x, int strict)
5268 {
5269   unsigned HOST_WIDE_INT offset, extra;
5270
5271   if (GET_CODE (x) != PLUS)
5272     return false;
5273   if (GET_CODE (XEXP (x, 0)) != REG)
5274     return false;
5275   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
5276     return false;
5277   if (!reg_offset_addressing_ok_p (mode))
5278     return virtual_stack_registers_memory_p (x);
5279   if (legitimate_constant_pool_address_p (x, mode, strict))
5280     return true;
5281   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
5282     return false;
5283
5284   offset = INTVAL (XEXP (x, 1));
5285   extra = 0;
5286   switch (mode)
5287     {
5288     case V4HImode:
5289     case V2SImode:
5290     case V1DImode:
5291     case V2SFmode:
5292       /* SPE vector modes.  */
5293       return SPE_CONST_OFFSET_OK (offset);
5294
5295     case DFmode:
5296       if (TARGET_E500_DOUBLE)
5297         return SPE_CONST_OFFSET_OK (offset);
5298
5299       /* If we are using VSX scalar loads, restrict ourselves to reg+reg
5300          addressing.  */
5301       if (VECTOR_MEM_VSX_P (DFmode))
5302         return false;
5303
5304     case DDmode:
5305     case DImode:
5306       /* On e500v2, we may have:
5307
5308            (subreg:DF (mem:DI (plus (reg) (const_int))) 0).
5309
5310          Which gets addressed with evldd instructions.  */
5311       if (TARGET_E500_DOUBLE)
5312         return SPE_CONST_OFFSET_OK (offset);
5313
5314       if (mode == DFmode || mode == DDmode || !TARGET_POWERPC64)
5315         extra = 4;
5316       else if (offset & 3)
5317         return false;
5318       break;
5319
5320     case TFmode:
5321       if (TARGET_E500_DOUBLE)
5322         return (SPE_CONST_OFFSET_OK (offset)
5323                 && SPE_CONST_OFFSET_OK (offset + 8));
5324
5325     case TDmode:
5326     case TImode:
5327       if (mode == TFmode || mode == TDmode || !TARGET_POWERPC64)
5328         extra = 12;
5329       else if (offset & 3)
5330         return false;
5331       else
5332         extra = 8;
5333       break;
5334
5335     default:
5336       break;
5337     }
5338
5339   offset += 0x8000;
5340   return offset < 0x10000 - extra;
5341 }
5342
5343 bool
5344 legitimate_indexed_address_p (rtx x, int strict)
5345 {
5346   rtx op0, op1;
5347
5348   if (GET_CODE (x) != PLUS)
5349     return false;
5350
5351   op0 = XEXP (x, 0);
5352   op1 = XEXP (x, 1);
5353
5354   /* Recognize the rtl generated by reload which we know will later be
5355      replaced with proper base and index regs.  */
5356   if (!strict
5357       && reload_in_progress
5358       && (REG_P (op0) || GET_CODE (op0) == PLUS)
5359       && REG_P (op1))
5360     return true;
5361
5362   return (REG_P (op0) && REG_P (op1)
5363           && ((INT_REG_OK_FOR_BASE_P (op0, strict)
5364                && INT_REG_OK_FOR_INDEX_P (op1, strict))
5365               || (INT_REG_OK_FOR_BASE_P (op1, strict)
5366                   && INT_REG_OK_FOR_INDEX_P (op0, strict))));
5367 }
5368
5369 bool
5370 avoiding_indexed_address_p (enum machine_mode mode)
5371 {
5372   /* Avoid indexed addressing for modes that have non-indexed
5373      load/store instruction forms.  */
5374   return (TARGET_AVOID_XFORM && VECTOR_MEM_NONE_P (mode));
5375 }
5376
5377 inline bool
5378 legitimate_indirect_address_p (rtx x, int strict)
5379 {
5380   return GET_CODE (x) == REG && INT_REG_OK_FOR_BASE_P (x, strict);
5381 }
5382
5383 bool
5384 macho_lo_sum_memory_operand (rtx x, enum machine_mode mode)
5385 {
5386   if (!TARGET_MACHO || !flag_pic
5387       || mode != SImode || GET_CODE (x) != MEM)
5388     return false;
5389   x = XEXP (x, 0);
5390
5391   if (GET_CODE (x) != LO_SUM)
5392     return false;
5393   if (GET_CODE (XEXP (x, 0)) != REG)
5394     return false;
5395   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 0))
5396     return false;
5397   x = XEXP (x, 1);
5398
5399   return CONSTANT_P (x);
5400 }
5401
5402 static bool
5403 legitimate_lo_sum_address_p (enum machine_mode mode, rtx x, int strict)
5404 {
5405   if (GET_CODE (x) != LO_SUM)
5406     return false;
5407   if (GET_CODE (XEXP (x, 0)) != REG)
5408     return false;
5409   if (!INT_REG_OK_FOR_BASE_P (XEXP (x, 0), strict))
5410     return false;
5411   /* Restrict addressing for DI because of our SUBREG hackery.  */
5412   if (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
5413                              || mode == DDmode || mode == TDmode
5414                              || mode == DImode))
5415     return false;
5416   x = XEXP (x, 1);
5417
5418   if (TARGET_ELF || TARGET_MACHO)
5419     {
5420       if (DEFAULT_ABI != ABI_AIX && DEFAULT_ABI != ABI_DARWIN && flag_pic)
5421         return false;
5422       if (TARGET_TOC)
5423         return false;
5424       if (GET_MODE_NUNITS (mode) != 1)
5425         return false;
5426       if (GET_MODE_BITSIZE (mode) > 64
5427           || (GET_MODE_BITSIZE (mode) > 32 && !TARGET_POWERPC64
5428               && !(TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
5429                    && (mode == DFmode || mode == DDmode))))
5430         return false;
5431
5432       return CONSTANT_P (x);
5433     }
5434
5435   return false;
5436 }
5437
5438
5439 /* Try machine-dependent ways of modifying an illegitimate address
5440    to be legitimate.  If we find one, return the new, valid address.
5441    This is used from only one place: `memory_address' in explow.c.
5442
5443    OLDX is the address as it was before break_out_memory_refs was
5444    called.  In some cases it is useful to look at this to decide what
5445    needs to be done.
5446
5447    It is always safe for this function to do nothing.  It exists to
5448    recognize opportunities to optimize the output.
5449
5450    On RS/6000, first check for the sum of a register with a constant
5451    integer that is out of range.  If so, generate code to add the
5452    constant with the low-order 16 bits masked to the register and force
5453    this result into another register (this can be done with `cau').
5454    Then generate an address of REG+(CONST&0xffff), allowing for the
5455    possibility of bit 16 being a one.
5456
5457    Then check for the sum of a register and something not constant, try to
5458    load the other things into a register and return the sum.  */
5459
5460 static rtx
5461 rs6000_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
5462                            enum machine_mode mode)
5463 {
5464   unsigned int extra = 0;
5465
5466   if (!reg_offset_addressing_ok_p (mode))
5467     {
5468       if (virtual_stack_registers_memory_p (x))
5469         return x;
5470
5471       /* In theory we should not be seeing addresses of the form reg+0,
5472          but just in case it is generated, optimize it away.  */
5473       if (GET_CODE (x) == PLUS && XEXP (x, 1) == const0_rtx)
5474         return force_reg (Pmode, XEXP (x, 0));
5475
5476       /* Make sure both operands are registers.  */
5477       else if (GET_CODE (x) == PLUS)
5478         return gen_rtx_PLUS (Pmode,
5479                              force_reg (Pmode, XEXP (x, 0)),
5480                              force_reg (Pmode, XEXP (x, 1)));
5481       else
5482         return force_reg (Pmode, x);
5483     }
5484   if (GET_CODE (x) == SYMBOL_REF)
5485     {
5486       enum tls_model model = SYMBOL_REF_TLS_MODEL (x);
5487       if (model != 0)
5488         return rs6000_legitimize_tls_address (x, model);
5489     }
5490
5491   switch (mode)
5492     {
5493     case DFmode:
5494     case DDmode:
5495       extra = 4;
5496       break;
5497     case DImode:
5498       if (!TARGET_POWERPC64)
5499         extra = 4;
5500       break;
5501     case TFmode:
5502     case TDmode:
5503       extra = 12;
5504       break;
5505     case TImode:
5506       extra = TARGET_POWERPC64 ? 8 : 12;
5507       break;
5508     default:
5509       break;
5510     }
5511
5512   if (GET_CODE (x) == PLUS
5513       && GET_CODE (XEXP (x, 0)) == REG
5514       && GET_CODE (XEXP (x, 1)) == CONST_INT
5515       && ((unsigned HOST_WIDE_INT) (INTVAL (XEXP (x, 1)) + 0x8000)
5516           >= 0x10000 - extra)
5517       && !((TARGET_POWERPC64
5518             && (mode == DImode || mode == TImode)
5519             && (INTVAL (XEXP (x, 1)) & 3) != 0)
5520            || SPE_VECTOR_MODE (mode)
5521            || (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
5522                                       || mode == DImode || mode == DDmode
5523                                       || mode == TDmode))))
5524     {
5525       HOST_WIDE_INT high_int, low_int;
5526       rtx sum;
5527       low_int = ((INTVAL (XEXP (x, 1)) & 0xffff) ^ 0x8000) - 0x8000;
5528       if (low_int >= 0x8000 - extra)
5529         low_int = 0;
5530       high_int = INTVAL (XEXP (x, 1)) - low_int;
5531       sum = force_operand (gen_rtx_PLUS (Pmode, XEXP (x, 0),
5532                                          GEN_INT (high_int)), 0);
5533       return plus_constant (sum, low_int);
5534     }
5535   else if (GET_CODE (x) == PLUS
5536            && GET_CODE (XEXP (x, 0)) == REG
5537            && GET_CODE (XEXP (x, 1)) != CONST_INT
5538            && GET_MODE_NUNITS (mode) == 1
5539            && ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
5540                || TARGET_POWERPC64
5541                || ((mode != DImode && mode != DFmode && mode != DDmode)
5542                    || (TARGET_E500_DOUBLE && mode != DDmode)))
5543            && (TARGET_POWERPC64 || mode != DImode)
5544            && !avoiding_indexed_address_p (mode)
5545            && mode != TImode
5546            && mode != TFmode
5547            && mode != TDmode)
5548     {
5549       return gen_rtx_PLUS (Pmode, XEXP (x, 0),
5550                            force_reg (Pmode, force_operand (XEXP (x, 1), 0)));
5551     }
5552   else if (SPE_VECTOR_MODE (mode)
5553            || (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
5554                                       || mode == DDmode || mode == TDmode
5555                                       || mode == DImode)))
5556     {
5557       if (mode == DImode)
5558         return x;
5559       /* We accept [reg + reg] and [reg + OFFSET].  */
5560
5561       if (GET_CODE (x) == PLUS)
5562        {
5563          rtx op1 = XEXP (x, 0);
5564          rtx op2 = XEXP (x, 1);
5565          rtx y;
5566
5567          op1 = force_reg (Pmode, op1);
5568
5569          if (GET_CODE (op2) != REG
5570              && (GET_CODE (op2) != CONST_INT
5571                  || !SPE_CONST_OFFSET_OK (INTVAL (op2))
5572                  || (GET_MODE_SIZE (mode) > 8
5573                      && !SPE_CONST_OFFSET_OK (INTVAL (op2) + 8))))
5574            op2 = force_reg (Pmode, op2);
5575
5576          /* We can't always do [reg + reg] for these, because [reg +
5577             reg + offset] is not a legitimate addressing mode.  */
5578          y = gen_rtx_PLUS (Pmode, op1, op2);
5579
5580          if ((GET_MODE_SIZE (mode) > 8 || mode == DDmode) && REG_P (op2))
5581            return force_reg (Pmode, y);
5582          else
5583            return y;
5584        }
5585
5586       return force_reg (Pmode, x);
5587     }
5588   else if (TARGET_ELF
5589            && TARGET_32BIT
5590            && TARGET_NO_TOC
5591            && ! flag_pic
5592            && GET_CODE (x) != CONST_INT
5593            && GET_CODE (x) != CONST_DOUBLE
5594            && CONSTANT_P (x)
5595            && GET_MODE_NUNITS (mode) == 1
5596            && (GET_MODE_BITSIZE (mode) <= 32
5597                || ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
5598                    && (mode == DFmode || mode == DDmode))))
5599     {
5600       rtx reg = gen_reg_rtx (Pmode);
5601       emit_insn (gen_elf_high (reg, x));
5602       return gen_rtx_LO_SUM (Pmode, reg, x);
5603     }
5604   else if (TARGET_MACHO && TARGET_32BIT && TARGET_NO_TOC
5605            && ! flag_pic
5606 #if TARGET_MACHO
5607            && ! MACHO_DYNAMIC_NO_PIC_P
5608 #endif
5609            && GET_CODE (x) != CONST_INT
5610            && GET_CODE (x) != CONST_DOUBLE
5611            && CONSTANT_P (x)
5612            && GET_MODE_NUNITS (mode) == 1
5613            && ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
5614                || (mode != DFmode && mode != DDmode))
5615            && mode != DImode
5616            && mode != TImode)
5617     {
5618       rtx reg = gen_reg_rtx (Pmode);
5619       emit_insn (gen_macho_high (reg, x));
5620       return gen_rtx_LO_SUM (Pmode, reg, x);
5621     }
5622   else if (TARGET_TOC
5623            && GET_CODE (x) == SYMBOL_REF
5624            && constant_pool_expr_p (x)
5625            && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), Pmode))
5626     {
5627       rtx reg = TARGET_CMODEL != CMODEL_SMALL ? gen_reg_rtx (Pmode) : NULL_RTX;
5628       return create_TOC_reference (x, reg);
5629     }
5630   else
5631     return x;
5632 }
5633
5634 /* Debug version of rs6000_legitimize_address.  */
5635 static rtx
5636 rs6000_debug_legitimize_address (rtx x, rtx oldx, enum machine_mode mode)
5637 {
5638   rtx ret;
5639   rtx insns;
5640
5641   start_sequence ();
5642   ret = rs6000_legitimize_address (x, oldx, mode);
5643   insns = get_insns ();
5644   end_sequence ();
5645
5646   if (ret != x)
5647     {
5648       fprintf (stderr,
5649                "\nrs6000_legitimize_address: mode %s, old code %s, "
5650                "new code %s, modified\n",
5651                GET_MODE_NAME (mode), GET_RTX_NAME (GET_CODE (x)),
5652                GET_RTX_NAME (GET_CODE (ret)));
5653
5654       fprintf (stderr, "Original address:\n");
5655       debug_rtx (x);
5656
5657       fprintf (stderr, "oldx:\n");
5658       debug_rtx (oldx);
5659
5660       fprintf (stderr, "New address:\n");
5661       debug_rtx (ret);
5662
5663       if (insns)
5664         {
5665           fprintf (stderr, "Insns added:\n");
5666           debug_rtx_list (insns, 20);
5667         }
5668     }
5669   else
5670     {
5671       fprintf (stderr,
5672                "\nrs6000_legitimize_address: mode %s, code %s, no change:\n",
5673                GET_MODE_NAME (mode), GET_RTX_NAME (GET_CODE (x)));
5674
5675       debug_rtx (x);
5676     }
5677
5678   if (insns)
5679     emit_insn (insns);
5680
5681   return ret;
5682 }
5683
5684 /* This is called from dwarf2out.c via TARGET_ASM_OUTPUT_DWARF_DTPREL.
5685    We need to emit DTP-relative relocations.  */
5686
5687 static void
5688 rs6000_output_dwarf_dtprel (FILE *file, int size, rtx x)
5689 {
5690   switch (size)
5691     {
5692     case 4:
5693       fputs ("\t.long\t", file);
5694       break;
5695     case 8:
5696       fputs (DOUBLE_INT_ASM_OP, file);
5697       break;
5698     default:
5699       gcc_unreachable ();
5700     }
5701   output_addr_const (file, x);
5702   fputs ("@dtprel+0x8000", file);
5703 }
5704
5705 /* In the name of slightly smaller debug output, and to cater to
5706    general assembler lossage, recognize various UNSPEC sequences
5707    and turn them back into a direct symbol reference.  */
5708
5709 static rtx
5710 rs6000_delegitimize_address (rtx orig_x)
5711 {
5712   rtx x, y;
5713
5714   orig_x = delegitimize_mem_from_attrs (orig_x);
5715   x = orig_x;
5716   if (MEM_P (x))
5717     x = XEXP (x, 0);
5718
5719   if (GET_CODE (x) == (TARGET_CMODEL != CMODEL_SMALL ? LO_SUM : PLUS)
5720       && GET_CODE (XEXP (x, 1)) == CONST)
5721     {
5722       rtx offset = NULL_RTX;
5723
5724       y = XEXP (XEXP (x, 1), 0);
5725       if (GET_CODE (y) == PLUS
5726           && GET_MODE (y) == Pmode
5727           && CONST_INT_P (XEXP (y, 1)))
5728         {
5729           offset = XEXP (y, 1);
5730           y = XEXP (y, 0);
5731         }
5732       if (GET_CODE (y) == UNSPEC
5733           && XINT (y, 1) == UNSPEC_TOCREL
5734           && ((GET_CODE (XEXP (x, 0)) == REG
5735                && (REGNO (XEXP (x, 0)) == TOC_REGISTER
5736                    || TARGET_MINIMAL_TOC
5737                    || TARGET_CMODEL != CMODEL_SMALL))
5738               || (TARGET_CMODEL != CMODEL_SMALL
5739                   && GET_CODE (XEXP (x, 0)) == CONST
5740                   && GET_CODE (XEXP (XEXP (x, 0), 0)) == PLUS
5741                   && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 0)) == REG
5742                   && REGNO (XEXP (XEXP (XEXP (x, 0), 0), 0)) == TOC_REGISTER
5743                   && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == HIGH
5744                   && rtx_equal_p (XEXP (x, 1),
5745                                   XEXP (XEXP (XEXP (XEXP (x, 0), 0), 1), 0)))))
5746         {
5747           y = XVECEXP (y, 0, 0);
5748           if (offset != NULL_RTX)
5749             y = gen_rtx_PLUS (Pmode, y, offset);
5750           if (!MEM_P (orig_x))
5751             return y;
5752           else
5753             return replace_equiv_address_nv (orig_x, y);
5754         }
5755     }
5756
5757   if (TARGET_MACHO
5758       && GET_CODE (orig_x) == LO_SUM
5759       && GET_CODE (XEXP (orig_x, 1)) == CONST)
5760     {
5761       y = XEXP (XEXP (orig_x, 1), 0);
5762       if (GET_CODE (y) == UNSPEC
5763           && XINT (y, 1) == UNSPEC_MACHOPIC_OFFSET)
5764         return XVECEXP (y, 0, 0);
5765     }
5766
5767   return orig_x;
5768 }
5769
5770 /* Construct the SYMBOL_REF for the tls_get_addr function.  */
5771
5772 static GTY(()) rtx rs6000_tls_symbol;
5773 static rtx
5774 rs6000_tls_get_addr (void)
5775 {
5776   if (!rs6000_tls_symbol)
5777     rs6000_tls_symbol = init_one_libfunc ("__tls_get_addr");
5778
5779   return rs6000_tls_symbol;
5780 }
5781
5782 /* Construct the SYMBOL_REF for TLS GOT references.  */
5783
5784 static GTY(()) rtx rs6000_got_symbol;
5785 static rtx
5786 rs6000_got_sym (void)
5787 {
5788   if (!rs6000_got_symbol)
5789     {
5790       rs6000_got_symbol = gen_rtx_SYMBOL_REF (Pmode, "_GLOBAL_OFFSET_TABLE_");
5791       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_LOCAL;
5792       SYMBOL_REF_FLAGS (rs6000_got_symbol) |= SYMBOL_FLAG_EXTERNAL;
5793     }
5794
5795   return rs6000_got_symbol;
5796 }
5797
5798 /* ADDR contains a thread-local SYMBOL_REF.  Generate code to compute
5799    this (thread-local) address.  */
5800
5801 static rtx
5802 rs6000_legitimize_tls_address (rtx addr, enum tls_model model)
5803 {
5804   rtx dest, insn;
5805
5806   dest = gen_reg_rtx (Pmode);
5807   if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 16)
5808     {
5809       rtx tlsreg;
5810
5811       if (TARGET_64BIT)
5812         {
5813           tlsreg = gen_rtx_REG (Pmode, 13);
5814           insn = gen_tls_tprel_64 (dest, tlsreg, addr);
5815         }
5816       else
5817         {
5818           tlsreg = gen_rtx_REG (Pmode, 2);
5819           insn = gen_tls_tprel_32 (dest, tlsreg, addr);
5820         }
5821       emit_insn (insn);
5822     }
5823   else if (model == TLS_MODEL_LOCAL_EXEC && rs6000_tls_size == 32)
5824     {
5825       rtx tlsreg, tmp;
5826
5827       tmp = gen_reg_rtx (Pmode);
5828       if (TARGET_64BIT)
5829         {
5830           tlsreg = gen_rtx_REG (Pmode, 13);
5831           insn = gen_tls_tprel_ha_64 (tmp, tlsreg, addr);
5832         }
5833       else
5834         {
5835           tlsreg = gen_rtx_REG (Pmode, 2);
5836           insn = gen_tls_tprel_ha_32 (tmp, tlsreg, addr);
5837         }
5838       emit_insn (insn);
5839       if (TARGET_64BIT)
5840         insn = gen_tls_tprel_lo_64 (dest, tmp, addr);
5841       else
5842         insn = gen_tls_tprel_lo_32 (dest, tmp, addr);
5843       emit_insn (insn);
5844     }
5845   else
5846     {
5847       rtx r3, got, tga, tmp1, tmp2, call_insn;
5848
5849       /* We currently use relocations like @got@tlsgd for tls, which
5850          means the linker will handle allocation of tls entries, placing
5851          them in the .got section.  So use a pointer to the .got section,
5852          not one to secondary TOC sections used by 64-bit -mminimal-toc,
5853          or to secondary GOT sections used by 32-bit -fPIC.  */
5854       if (TARGET_64BIT)
5855         got = gen_rtx_REG (Pmode, 2);
5856       else
5857         {
5858           if (flag_pic == 1)
5859             got = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
5860           else
5861             {
5862               rtx gsym = rs6000_got_sym ();
5863               got = gen_reg_rtx (Pmode);
5864               if (flag_pic == 0)
5865                 rs6000_emit_move (got, gsym, Pmode);
5866               else
5867                 {
5868                   rtx mem, lab, last;
5869
5870                   tmp1 = gen_reg_rtx (Pmode);
5871                   tmp2 = gen_reg_rtx (Pmode);
5872                   mem = gen_const_mem (Pmode, tmp1);
5873                   lab = gen_label_rtx ();
5874                   emit_insn (gen_load_toc_v4_PIC_1b (gsym, lab));
5875                   emit_move_insn (tmp1, gen_rtx_REG (Pmode, LR_REGNO));
5876                   if (TARGET_LINK_STACK)
5877                     emit_insn (gen_addsi3 (tmp1, tmp1, GEN_INT (4)));
5878                   emit_move_insn (tmp2, mem);
5879                   last = emit_insn (gen_addsi3 (got, tmp1, tmp2));
5880                   set_unique_reg_note (last, REG_EQUAL, gsym);
5881                 }
5882             }
5883         }
5884
5885       if (model == TLS_MODEL_GLOBAL_DYNAMIC)
5886         {
5887           tga = rs6000_tls_get_addr ();
5888           emit_library_call_value (tga, dest, LCT_CONST, Pmode,
5889                                    1, const0_rtx, Pmode);
5890
5891           r3 = gen_rtx_REG (Pmode, 3);
5892           if (DEFAULT_ABI == ABI_AIX && TARGET_64BIT)
5893             insn = gen_tls_gd_aix64 (r3, got, addr, tga, const0_rtx);
5894           else if (DEFAULT_ABI == ABI_AIX && !TARGET_64BIT)
5895             insn = gen_tls_gd_aix32 (r3, got, addr, tga, const0_rtx);
5896           else if (DEFAULT_ABI == ABI_V4)
5897             insn = gen_tls_gd_sysvsi (r3, got, addr, tga, const0_rtx);
5898           else
5899             gcc_unreachable ();
5900           call_insn = last_call_insn ();
5901           PATTERN (call_insn) = insn;
5902           if (DEFAULT_ABI == ABI_V4 && TARGET_SECURE_PLT && flag_pic)
5903             use_reg (&CALL_INSN_FUNCTION_USAGE (call_insn),
5904                      pic_offset_table_rtx);
5905         }
5906       else if (model == TLS_MODEL_LOCAL_DYNAMIC)
5907         {
5908           tga = rs6000_tls_get_addr ();
5909           tmp1 = gen_reg_rtx (Pmode);
5910           emit_library_call_value (tga, tmp1, LCT_CONST, Pmode,
5911                                    1, const0_rtx, Pmode);
5912
5913           r3 = gen_rtx_REG (Pmode, 3);
5914           if (DEFAULT_ABI == ABI_AIX && TARGET_64BIT)
5915             insn = gen_tls_ld_aix64 (r3, got, tga, const0_rtx);
5916           else if (DEFAULT_ABI == ABI_AIX && !TARGET_64BIT)
5917             insn = gen_tls_ld_aix32 (r3, got, tga, const0_rtx);
5918           else if (DEFAULT_ABI == ABI_V4)
5919             insn = gen_tls_ld_sysvsi (r3, got, tga, const0_rtx);
5920           else
5921             gcc_unreachable ();
5922           call_insn = last_call_insn ();
5923           PATTERN (call_insn) = insn;
5924           if (DEFAULT_ABI == ABI_V4 && TARGET_SECURE_PLT && flag_pic)
5925             use_reg (&CALL_INSN_FUNCTION_USAGE (call_insn),
5926                      pic_offset_table_rtx);
5927
5928           if (rs6000_tls_size == 16)
5929             {
5930               if (TARGET_64BIT)
5931                 insn = gen_tls_dtprel_64 (dest, tmp1, addr);
5932               else
5933                 insn = gen_tls_dtprel_32 (dest, tmp1, addr);
5934             }
5935           else if (rs6000_tls_size == 32)
5936             {
5937               tmp2 = gen_reg_rtx (Pmode);
5938               if (TARGET_64BIT)
5939                 insn = gen_tls_dtprel_ha_64 (tmp2, tmp1, addr);
5940               else
5941                 insn = gen_tls_dtprel_ha_32 (tmp2, tmp1, addr);
5942               emit_insn (insn);
5943               if (TARGET_64BIT)
5944                 insn = gen_tls_dtprel_lo_64 (dest, tmp2, addr);
5945               else
5946                 insn = gen_tls_dtprel_lo_32 (dest, tmp2, addr);
5947             }
5948           else
5949             {
5950               tmp2 = gen_reg_rtx (Pmode);
5951               if (TARGET_64BIT)
5952                 insn = gen_tls_got_dtprel_64 (tmp2, got, addr);
5953               else
5954                 insn = gen_tls_got_dtprel_32 (tmp2, got, addr);
5955               emit_insn (insn);
5956               insn = gen_rtx_SET (Pmode, dest,
5957                                   gen_rtx_PLUS (Pmode, tmp2, tmp1));
5958             }
5959           emit_insn (insn);
5960         }
5961       else
5962         {
5963           /* IE, or 64-bit offset LE.  */
5964           tmp2 = gen_reg_rtx (Pmode);
5965           if (TARGET_64BIT)
5966             insn = gen_tls_got_tprel_64 (tmp2, got, addr);
5967           else
5968             insn = gen_tls_got_tprel_32 (tmp2, got, addr);
5969           emit_insn (insn);
5970           if (TARGET_64BIT)
5971             insn = gen_tls_tls_64 (dest, tmp2, addr);
5972           else
5973             insn = gen_tls_tls_32 (dest, tmp2, addr);
5974           emit_insn (insn);
5975         }
5976     }
5977
5978   return dest;
5979 }
5980
5981 /* Return 1 if X contains a thread-local symbol.  */
5982
5983 static bool
5984 rs6000_tls_referenced_p (rtx x)
5985 {
5986   if (! TARGET_HAVE_TLS)
5987     return false;
5988
5989   return for_each_rtx (&x, &rs6000_tls_symbol_ref_1, 0);
5990 }
5991
5992 /* Implement TARGET_CANNOT_FORCE_CONST_MEM.  */
5993
5994 static bool
5995 rs6000_cannot_force_const_mem (enum machine_mode mode ATTRIBUTE_UNUSED, rtx x)
5996 {
5997   if (GET_CODE (x) == CONST
5998       && GET_CODE (XEXP (x, 0)) == PLUS
5999       && GET_CODE (XEXP (XEXP (x, 0), 1)) == HIGH)
6000     return true;
6001
6002   return rs6000_tls_referenced_p (x);
6003 }
6004
6005 /* Return 1 if *X is a thread-local symbol.  This is the same as
6006    rs6000_tls_symbol_ref except for the type of the unused argument.  */
6007
6008 static int
6009 rs6000_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
6010 {
6011   return RS6000_SYMBOL_REF_TLS_P (*x);
6012 }
6013
6014 /* Our implementation of LEGITIMIZE_RELOAD_ADDRESS.  Returns a value to
6015    replace the input X, or the original X if no replacement is called for.
6016    The output parameter *WIN is 1 if the calling macro should goto WIN,
6017    0 if it should not.
6018
6019    For RS/6000, we wish to handle large displacements off a base
6020    register by splitting the addend across an addiu/addis and the mem insn.
6021    This cuts number of extra insns needed from 3 to 1.
6022
6023    On Darwin, we use this to generate code for floating point constants.
6024    A movsf_low is generated so we wind up with 2 instructions rather than 3.
6025    The Darwin code is inside #if TARGET_MACHO because only then are the
6026    machopic_* functions defined.  */
6027 static rtx
6028 rs6000_legitimize_reload_address (rtx x, enum machine_mode mode,
6029                                   int opnum, int type,
6030                                   int ind_levels ATTRIBUTE_UNUSED, int *win)
6031 {
6032   bool reg_offset_p = reg_offset_addressing_ok_p (mode);
6033
6034   /* Nasty hack for vsx_splat_V2DF/V2DI load from mem, which takes a
6035      DFmode/DImode MEM.  */
6036   if (reg_offset_p
6037       && opnum == 1
6038       && ((mode == DFmode && recog_data.operand_mode[0] == V2DFmode)
6039           || (mode == DImode && recog_data.operand_mode[0] == V2DImode)))
6040     reg_offset_p = false;
6041
6042   /* We must recognize output that we have already generated ourselves.  */
6043   if (GET_CODE (x) == PLUS
6044       && GET_CODE (XEXP (x, 0)) == PLUS
6045       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
6046       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6047       && GET_CODE (XEXP (x, 1)) == CONST_INT)
6048     {
6049       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
6050                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
6051                    opnum, (enum reload_type)type);
6052       *win = 1;
6053       return x;
6054     }
6055
6056   /* Likewise for (lo_sum (high ...) ...) output we have generated.  */
6057   if (GET_CODE (x) == LO_SUM
6058       && GET_CODE (XEXP (x, 0)) == HIGH)
6059     {
6060       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
6061                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
6062                    opnum, (enum reload_type)type);
6063       *win = 1;
6064       return x;
6065     }
6066
6067 #if TARGET_MACHO
6068   if (DEFAULT_ABI == ABI_DARWIN && flag_pic
6069       && GET_CODE (x) == LO_SUM
6070       && GET_CODE (XEXP (x, 0)) == PLUS
6071       && XEXP (XEXP (x, 0), 0) == pic_offset_table_rtx
6072       && GET_CODE (XEXP (XEXP (x, 0), 1)) == HIGH
6073       && XEXP (XEXP (XEXP (x, 0), 1), 0) == XEXP (x, 1)
6074       && machopic_operand_p (XEXP (x, 1)))
6075     {
6076       /* Result of previous invocation of this function on Darwin
6077          floating point constant.  */
6078       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
6079                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
6080                    opnum, (enum reload_type)type);
6081       *win = 1;
6082       return x;
6083     }
6084 #endif
6085
6086   if (TARGET_CMODEL != CMODEL_SMALL
6087       && GET_CODE (x) == LO_SUM
6088       && GET_CODE (XEXP (x, 0)) == PLUS
6089       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
6090       && REGNO (XEXP (XEXP (x, 0), 0)) == TOC_REGISTER
6091       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST
6092       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 1), 0)) == HIGH
6093       && GET_CODE (XEXP (x, 1)) == CONST
6094       && GET_CODE (XEXP (XEXP (x, 1), 0)) == UNSPEC
6095       && XINT (XEXP (XEXP (x, 1), 0), 1) == UNSPEC_TOCREL
6096       && rtx_equal_p (XEXP (XEXP (XEXP (XEXP (x, 0), 1), 0), 0), XEXP (x, 1)))
6097     {
6098       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
6099                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
6100                    opnum, (enum reload_type) type);
6101       *win = 1;
6102       return x;
6103     }
6104
6105   /* Force ld/std non-word aligned offset into base register by wrapping
6106      in offset 0.  */
6107   if (GET_CODE (x) == PLUS
6108       && GET_CODE (XEXP (x, 0)) == REG
6109       && REGNO (XEXP (x, 0)) < 32
6110       && INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 1)
6111       && GET_CODE (XEXP (x, 1)) == CONST_INT
6112       && reg_offset_p
6113       && (INTVAL (XEXP (x, 1)) & 3) != 0
6114       && VECTOR_MEM_NONE_P (mode)
6115       && GET_MODE_SIZE (mode) >= UNITS_PER_WORD
6116       && TARGET_POWERPC64)
6117     {
6118       x = gen_rtx_PLUS (GET_MODE (x), x, GEN_INT (0));
6119       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
6120                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
6121                    opnum, (enum reload_type) type);
6122       *win = 1;
6123       return x;
6124     }
6125
6126   if (GET_CODE (x) == PLUS
6127       && GET_CODE (XEXP (x, 0)) == REG
6128       && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
6129       && INT_REG_OK_FOR_BASE_P (XEXP (x, 0), 1)
6130       && GET_CODE (XEXP (x, 1)) == CONST_INT
6131       && reg_offset_p
6132       && !SPE_VECTOR_MODE (mode)
6133       && !(TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
6134                                   || mode == DDmode || mode == TDmode
6135                                   || mode == DImode))
6136       && VECTOR_MEM_NONE_P (mode))
6137     {
6138       HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
6139       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
6140       HOST_WIDE_INT high
6141         = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;
6142
6143       /* Check for 32-bit overflow.  */
6144       if (high + low != val)
6145         {
6146           *win = 0;
6147           return x;
6148         }
6149
6150       /* Reload the high part into a base reg; leave the low part
6151          in the mem directly.  */
6152
6153       x = gen_rtx_PLUS (GET_MODE (x),
6154                         gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0),
6155                                       GEN_INT (high)),
6156                         GEN_INT (low));
6157
6158       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
6159                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
6160                    opnum, (enum reload_type)type);
6161       *win = 1;
6162       return x;
6163     }
6164
6165   if (GET_CODE (x) == SYMBOL_REF
6166       && reg_offset_p
6167       && VECTOR_MEM_NONE_P (mode)
6168       && !SPE_VECTOR_MODE (mode)
6169 #if TARGET_MACHO
6170       && DEFAULT_ABI == ABI_DARWIN
6171       && (flag_pic || MACHO_DYNAMIC_NO_PIC_P)
6172       && machopic_symbol_defined_p (x)
6173 #else
6174       && DEFAULT_ABI == ABI_V4
6175       && !flag_pic
6176 #endif
6177       /* Don't do this for TFmode or TDmode, since the result isn't offsettable.
6178          The same goes for DImode without 64-bit gprs and DFmode and DDmode
6179          without fprs.  */
6180       && mode != TFmode
6181       && mode != TDmode
6182       && (mode != DImode || TARGET_POWERPC64)
6183       && ((mode != DFmode && mode != DDmode) || TARGET_POWERPC64
6184           || (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)))
6185     {
6186 #if TARGET_MACHO
6187       if (flag_pic)
6188         {
6189           rtx offset = machopic_gen_offset (x);
6190           x = gen_rtx_LO_SUM (GET_MODE (x),
6191                 gen_rtx_PLUS (Pmode, pic_offset_table_rtx,
6192                   gen_rtx_HIGH (Pmode, offset)), offset);
6193         }
6194       else
6195 #endif
6196         x = gen_rtx_LO_SUM (GET_MODE (x),
6197               gen_rtx_HIGH (Pmode, x), x);
6198
6199       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
6200                    BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
6201                    opnum, (enum reload_type)type);
6202       *win = 1;
6203       return x;
6204     }
6205
6206   /* Reload an offset address wrapped by an AND that represents the
6207      masking of the lower bits.  Strip the outer AND and let reload
6208      convert the offset address into an indirect address.  For VSX,
6209      force reload to create the address with an AND in a separate
6210      register, because we can't guarantee an altivec register will
6211      be used.  */
6212   if (VECTOR_MEM_ALTIVEC_P (mode)
6213       && GET_CODE (x) == AND
6214       && GET_CODE (XEXP (x, 0)) == PLUS
6215       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
6216       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
6217       && GET_CODE (XEXP (x, 1)) == CONST_INT
6218       && INTVAL (XEXP (x, 1)) == -16)
6219     {
6220       x = XEXP (x, 0);
6221       *win = 1;
6222       return x;
6223     }
6224
6225   if (TARGET_TOC
6226       && reg_offset_p
6227       && GET_CODE (x) == SYMBOL_REF
6228       && constant_pool_expr_p (x)
6229       && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (x), mode))
6230     {
6231       x = create_TOC_reference (x, NULL_RTX);
6232       if (TARGET_CMODEL != CMODEL_SMALL)
6233         push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
6234                      BASE_REG_CLASS, Pmode, VOIDmode, 0, 0,
6235                      opnum, (enum reload_type) type);
6236       *win = 1;
6237       return x;
6238     }
6239   *win = 0;
6240   return x;
6241 }
6242
6243 /* Debug version of rs6000_legitimize_reload_address.  */
6244 static rtx
6245 rs6000_debug_legitimize_reload_address (rtx x, enum machine_mode mode,
6246                                         int opnum, int type,
6247                                         int ind_levels, int *win)
6248 {
6249   rtx ret = rs6000_legitimize_reload_address (x, mode, opnum, type,
6250                                               ind_levels, win);
6251   fprintf (stderr,
6252            "\nrs6000_legitimize_reload_address: mode = %s, opnum = %d, "
6253            "type = %d, ind_levels = %d, win = %d, original addr:\n",
6254            GET_MODE_NAME (mode), opnum, type, ind_levels, *win);
6255   debug_rtx (x);
6256
6257   if (x == ret)
6258     fprintf (stderr, "Same address returned\n");
6259   else if (!ret)
6260     fprintf (stderr, "NULL returned\n");
6261   else
6262     {
6263       fprintf (stderr, "New address:\n");
6264       debug_rtx (ret);
6265     }
6266
6267   return ret;
6268 }
6269
6270 /* TARGET_LEGITIMATE_ADDRESS_P recognizes an RTL expression
6271    that is a valid memory address for an instruction.
6272    The MODE argument is the machine mode for the MEM expression
6273    that wants to use this address.
6274
6275    On the RS/6000, there are four valid address: a SYMBOL_REF that
6276    refers to a constant pool entry of an address (or the sum of it
6277    plus a constant), a short (16-bit signed) constant plus a register,
6278    the sum of two registers, or a register indirect, possibly with an
6279    auto-increment.  For DFmode, DDmode and DImode with a constant plus
6280    register, we must ensure that both words are addressable or PowerPC64
6281    with offset word aligned.
6282
6283    For modes spanning multiple registers (DFmode and DDmode in 32-bit GPRs,
6284    32-bit DImode, TImode, TFmode, TDmode), indexed addressing cannot be used
6285    because adjacent memory cells are accessed by adding word-sized offsets
6286    during assembly output.  */
6287 bool
6288 rs6000_legitimate_address_p (enum machine_mode mode, rtx x, bool reg_ok_strict)
6289 {
6290   bool reg_offset_p = reg_offset_addressing_ok_p (mode);
6291
6292   /* If this is an unaligned stvx/ldvx type address, discard the outer AND.  */
6293   if (VECTOR_MEM_ALTIVEC_P (mode)
6294       && GET_CODE (x) == AND
6295       && GET_CODE (XEXP (x, 1)) == CONST_INT
6296       && INTVAL (XEXP (x, 1)) == -16)
6297     x = XEXP (x, 0);
6298
6299   if (RS6000_SYMBOL_REF_TLS_P (x))
6300     return 0;
6301   if (legitimate_indirect_address_p (x, reg_ok_strict))
6302     return 1;
6303   if ((GET_CODE (x) == PRE_INC || GET_CODE (x) == PRE_DEC)
6304       && !VECTOR_MEM_ALTIVEC_OR_VSX_P (mode)
6305       && !SPE_VECTOR_MODE (mode)
6306       && mode != TFmode
6307       && mode != TDmode
6308       /* Restrict addressing for DI because of our SUBREG hackery.  */
6309       && !(TARGET_E500_DOUBLE
6310            && (mode == DFmode || mode == DDmode || mode == DImode))
6311       && TARGET_UPDATE
6312       && legitimate_indirect_address_p (XEXP (x, 0), reg_ok_strict))
6313     return 1;
6314   if (virtual_stack_registers_memory_p (x))
6315     return 1;
6316   if (reg_offset_p && legitimate_small_data_p (mode, x))
6317     return 1;
6318   if (reg_offset_p
6319       && legitimate_constant_pool_address_p (x, mode, reg_ok_strict))
6320     return 1;
6321   /* If not REG_OK_STRICT (before reload) let pass any stack offset.  */
6322   if (! reg_ok_strict
6323       && reg_offset_p
6324       && GET_CODE (x) == PLUS
6325       && GET_CODE (XEXP (x, 0)) == REG
6326       && (XEXP (x, 0) == virtual_stack_vars_rtx
6327           || XEXP (x, 0) == arg_pointer_rtx)
6328       && GET_CODE (XEXP (x, 1)) == CONST_INT)
6329     return 1;
6330   if (rs6000_legitimate_offset_address_p (mode, x, reg_ok_strict))
6331     return 1;
6332   if (mode != TImode
6333       && mode != TFmode
6334       && mode != TDmode
6335       && ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
6336           || TARGET_POWERPC64
6337           || (mode != DFmode && mode != DDmode)
6338           || (TARGET_E500_DOUBLE && mode != DDmode))
6339       && (TARGET_POWERPC64 || mode != DImode)
6340       && !avoiding_indexed_address_p (mode)
6341       && legitimate_indexed_address_p (x, reg_ok_strict))
6342     return 1;
6343   if (GET_CODE (x) == PRE_MODIFY
6344       && mode != TImode
6345       && mode != TFmode
6346       && mode != TDmode
6347       && ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT)
6348           || TARGET_POWERPC64
6349           || ((mode != DFmode && mode != DDmode) || TARGET_E500_DOUBLE))
6350       && (TARGET_POWERPC64 || mode != DImode)
6351       && !VECTOR_MEM_ALTIVEC_OR_VSX_P (mode)
6352       && !SPE_VECTOR_MODE (mode)
6353       /* Restrict addressing for DI because of our SUBREG hackery.  */
6354       && !(TARGET_E500_DOUBLE
6355            && (mode == DFmode || mode == DDmode || mode == DImode))
6356       && TARGET_UPDATE
6357       && legitimate_indirect_address_p (XEXP (x, 0), reg_ok_strict)
6358       && (rs6000_legitimate_offset_address_p (mode, XEXP (x, 1), reg_ok_strict)
6359           || (!avoiding_indexed_address_p (mode)
6360               && legitimate_indexed_address_p (XEXP (x, 1), reg_ok_strict)))
6361       && rtx_equal_p (XEXP (XEXP (x, 1), 0), XEXP (x, 0)))
6362     return 1;
6363   if (reg_offset_p && legitimate_lo_sum_address_p (mode, x, reg_ok_strict))
6364     return 1;
6365   return 0;
6366 }
6367
6368 /* Debug version of rs6000_legitimate_address_p.  */
6369 static bool
6370 rs6000_debug_legitimate_address_p (enum machine_mode mode, rtx x,
6371                                    bool reg_ok_strict)
6372 {
6373   bool ret = rs6000_legitimate_address_p (mode, x, reg_ok_strict);
6374   fprintf (stderr,
6375            "\nrs6000_legitimate_address_p: return = %s, mode = %s, "
6376            "strict = %d, code = %s\n",
6377            ret ? "true" : "false",
6378            GET_MODE_NAME (mode),
6379            reg_ok_strict,
6380            GET_RTX_NAME (GET_CODE (x)));
6381   debug_rtx (x);
6382
6383   return ret;
6384 }
6385
6386 /* Implement TARGET_MODE_DEPENDENT_ADDRESS_P.  */
6387
6388 static bool
6389 rs6000_mode_dependent_address_p (const_rtx addr)
6390 {
6391   return rs6000_mode_dependent_address_ptr (addr);
6392 }
6393
6394 /* Go to LABEL if ADDR (a legitimate address expression)
6395    has an effect that depends on the machine mode it is used for.
6396
6397    On the RS/6000 this is true of all integral offsets (since AltiVec
6398    and VSX modes don't allow them) or is a pre-increment or decrement.
6399
6400    ??? Except that due to conceptual problems in offsettable_address_p
6401    we can't really report the problems of integral offsets.  So leave
6402    this assuming that the adjustable offset must be valid for the
6403    sub-words of a TFmode operand, which is what we had before.  */
6404
6405 static bool
6406 rs6000_mode_dependent_address (const_rtx addr)
6407 {
6408   switch (GET_CODE (addr))
6409     {
6410     case PLUS:
6411       /* Any offset from virtual_stack_vars_rtx and arg_pointer_rtx
6412          is considered a legitimate address before reload, so there
6413          are no offset restrictions in that case.  Note that this
6414          condition is safe in strict mode because any address involving
6415          virtual_stack_vars_rtx or arg_pointer_rtx would already have
6416          been rejected as illegitimate.  */
6417       if (XEXP (addr, 0) != virtual_stack_vars_rtx
6418           && XEXP (addr, 0) != arg_pointer_rtx
6419           && GET_CODE (XEXP (addr, 1)) == CONST_INT)
6420         {
6421           unsigned HOST_WIDE_INT val = INTVAL (XEXP (addr, 1));
6422           return val + 12 + 0x8000 >= 0x10000;
6423         }
6424       break;
6425
6426     case LO_SUM:
6427       /* Anything in the constant pool is sufficiently aligned that
6428          all bytes have the same high part address.  */
6429       return !legitimate_constant_pool_address_p (addr, QImode, false);
6430
6431     /* Auto-increment cases are now treated generically in recog.c.  */
6432     case PRE_MODIFY:
6433       return TARGET_UPDATE;
6434
6435     /* AND is only allowed in Altivec loads.  */
6436     case AND:
6437       return true;
6438
6439     default:
6440       break;
6441     }
6442
6443   return false;
6444 }
6445
6446 /* Debug version of rs6000_mode_dependent_address.  */
6447 static bool
6448 rs6000_debug_mode_dependent_address (const_rtx addr)
6449 {
6450   bool ret = rs6000_mode_dependent_address (addr);
6451
6452   fprintf (stderr, "\nrs6000_mode_dependent_address: ret = %s\n",
6453            ret ? "true" : "false");
6454   debug_rtx (addr);
6455
6456   return ret;
6457 }
6458
6459 /* Implement FIND_BASE_TERM.  */
6460
6461 rtx
6462 rs6000_find_base_term (rtx op)
6463 {
6464   rtx base, offset;
6465
6466   split_const (op, &base, &offset);
6467   if (GET_CODE (base) == UNSPEC)
6468     switch (XINT (base, 1))
6469       {
6470       case UNSPEC_TOCREL:
6471       case UNSPEC_MACHOPIC_OFFSET:
6472         /* OP represents SYM [+ OFFSET] - ANCHOR.  SYM is the base term
6473            for aliasing purposes.  */
6474         return XVECEXP (base, 0, 0);
6475       }
6476
6477   return op;
6478 }
6479
6480 /* More elaborate version of recog's offsettable_memref_p predicate
6481    that works around the ??? note of rs6000_mode_dependent_address.
6482    In particular it accepts
6483
6484      (mem:DI (plus:SI (reg/f:SI 31 31) (const_int 32760 [0x7ff8])))
6485
6486    in 32-bit mode, that the recog predicate rejects.  */
6487
6488 bool
6489 rs6000_offsettable_memref_p (rtx op)
6490 {
6491   if (!MEM_P (op))
6492     return false;
6493
6494   /* First mimic offsettable_memref_p.  */
6495   if (offsettable_address_p (1, GET_MODE (op), XEXP (op, 0)))
6496     return true;
6497
6498   /* offsettable_address_p invokes rs6000_mode_dependent_address, but
6499      the latter predicate knows nothing about the mode of the memory
6500      reference and, therefore, assumes that it is the largest supported
6501      mode (TFmode).  As a consequence, legitimate offsettable memory
6502      references are rejected.  rs6000_legitimate_offset_address_p contains
6503      the correct logic for the PLUS case of rs6000_mode_dependent_address.  */
6504   return rs6000_legitimate_offset_address_p (GET_MODE (op), XEXP (op, 0), 1);
6505 }
6506
6507 /* Change register usage conditional on target flags.  */
6508 static void
6509 rs6000_conditional_register_usage (void)
6510 {
6511   int i;
6512
6513   if (TARGET_DEBUG_TARGET)
6514     fprintf (stderr, "rs6000_conditional_register_usage called\n");
6515
6516   /* Set MQ register fixed (already call_used) if not POWER
6517      architecture (RIOS1, RIOS2, RSC, and PPC601) so that it will not
6518      be allocated.  */
6519   if (! TARGET_POWER)
6520     fixed_regs[64] = 1;
6521
6522   /* 64-bit AIX and Linux reserve GPR13 for thread-private data.  */
6523   if (TARGET_64BIT)
6524     fixed_regs[13] = call_used_regs[13]
6525       = call_really_used_regs[13] = 1;
6526
6527   /* Conditionally disable FPRs.  */
6528   if (TARGET_SOFT_FLOAT || !TARGET_FPRS)
6529     for (i = 32; i < 64; i++)
6530       fixed_regs[i] = call_used_regs[i]
6531         = call_really_used_regs[i] = 1;
6532
6533   /* The TOC register is not killed across calls in a way that is
6534      visible to the compiler.  */
6535   if (DEFAULT_ABI == ABI_AIX)
6536     call_really_used_regs[2] = 0;
6537
6538   if (DEFAULT_ABI == ABI_V4
6539       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
6540       && flag_pic == 2)
6541     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
6542
6543   if (DEFAULT_ABI == ABI_V4
6544       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM
6545       && flag_pic == 1)
6546     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
6547       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
6548       = call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
6549
6550   if (DEFAULT_ABI == ABI_DARWIN
6551       && PIC_OFFSET_TABLE_REGNUM != INVALID_REGNUM)
6552       fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
6553       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
6554       = call_really_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
6555
6556   if (TARGET_TOC && TARGET_MINIMAL_TOC)
6557     fixed_regs[RS6000_PIC_OFFSET_TABLE_REGNUM]
6558       = call_used_regs[RS6000_PIC_OFFSET_TABLE_REGNUM] = 1;
6559
6560   if (TARGET_SPE)
6561     {
6562       global_regs[SPEFSCR_REGNO] = 1;
6563       /* We used to use r14 as FIXED_SCRATCH to address SPE 64-bit
6564          registers in prologues and epilogues.  We no longer use r14
6565          for FIXED_SCRATCH, but we're keeping r14 out of the allocation
6566          pool for link-compatibility with older versions of GCC.  Once
6567          "old" code has died out, we can return r14 to the allocation
6568          pool.  */
6569       fixed_regs[14]
6570         = call_used_regs[14]
6571         = call_really_used_regs[14] = 1;
6572     }
6573
6574   if (!TARGET_ALTIVEC && !TARGET_VSX)
6575     {
6576       for (i = FIRST_ALTIVEC_REGNO; i <= LAST_ALTIVEC_REGNO; ++i)
6577         fixed_regs[i] = call_used_regs[i] = call_really_used_regs[i] = 1;
6578       call_really_used_regs[VRSAVE_REGNO] = 1;
6579     }
6580
6581   if (TARGET_ALTIVEC || TARGET_VSX)
6582     global_regs[VSCR_REGNO] = 1;
6583
6584   if (TARGET_ALTIVEC_ABI)
6585     {
6586       for (i = FIRST_ALTIVEC_REGNO; i < FIRST_ALTIVEC_REGNO + 20; ++i)
6587         call_used_regs[i] = call_really_used_regs[i] = 1;
6588
6589       /* AIX reserves VR20:31 in non-extended ABI mode.  */
6590       if (TARGET_XCOFF)
6591         for (i = FIRST_ALTIVEC_REGNO + 20; i < FIRST_ALTIVEC_REGNO + 32; ++i)
6592           fixed_regs[i] = call_used_regs[i] = call_really_used_regs[i] = 1;
6593     }
6594 }
6595 \f
6596 /* Try to output insns to set TARGET equal to the constant C if it can
6597    be done in less than N insns.  Do all computations in MODE.
6598    Returns the place where the output has been placed if it can be
6599    done and the insns have been emitted.  If it would take more than N
6600    insns, zero is returned and no insns and emitted.  */
6601
6602 rtx
6603 rs6000_emit_set_const (rtx dest, enum machine_mode mode,
6604                        rtx source, int n ATTRIBUTE_UNUSED)
6605 {
6606   rtx result, insn, set;
6607   HOST_WIDE_INT c0, c1;
6608
6609   switch (mode)
6610     {
6611       case  QImode:
6612     case HImode:
6613       if (dest == NULL)
6614         dest = gen_reg_rtx (mode);
6615       emit_insn (gen_rtx_SET (VOIDmode, dest, source));
6616       return dest;
6617
6618     case SImode:
6619       result = !can_create_pseudo_p () ? dest : gen_reg_rtx (SImode);
6620
6621       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (result),
6622                               GEN_INT (INTVAL (source)
6623                                        & (~ (HOST_WIDE_INT) 0xffff))));
6624       emit_insn (gen_rtx_SET (VOIDmode, dest,
6625                               gen_rtx_IOR (SImode, copy_rtx (result),
6626                                            GEN_INT (INTVAL (source) & 0xffff))));
6627       result = dest;
6628       break;
6629
6630     case DImode:
6631       switch (GET_CODE (source))
6632         {
6633         case CONST_INT:
6634           c0 = INTVAL (source);
6635           c1 = -(c0 < 0);
6636           break;
6637
6638         case CONST_DOUBLE:
6639 #if HOST_BITS_PER_WIDE_INT >= 64
6640           c0 = CONST_DOUBLE_LOW (source);
6641           c1 = -(c0 < 0);
6642 #else
6643           c0 = CONST_DOUBLE_LOW (source);
6644           c1 = CONST_DOUBLE_HIGH (source);
6645 #endif
6646           break;
6647
6648         default:
6649           gcc_unreachable ();
6650         }
6651
6652       result = rs6000_emit_set_long_const (dest, c0, c1);
6653       break;
6654
6655     default:
6656       gcc_unreachable ();
6657     }
6658
6659   insn = get_last_insn ();
6660   set = single_set (insn);
6661   if (! CONSTANT_P (SET_SRC (set)))
6662     set_unique_reg_note (insn, REG_EQUAL, source);
6663
6664   return result;
6665 }
6666
6667 /* Having failed to find a 3 insn sequence in rs6000_emit_set_const,
6668    fall back to a straight forward decomposition.  We do this to avoid
6669    exponential run times encountered when looking for longer sequences
6670    with rs6000_emit_set_const.  */
6671 static rtx
6672 rs6000_emit_set_long_const (rtx dest, HOST_WIDE_INT c1, HOST_WIDE_INT c2)
6673 {
6674   if (!TARGET_POWERPC64)
6675     {
6676       rtx operand1, operand2;
6677
6678       operand1 = operand_subword_force (dest, WORDS_BIG_ENDIAN == 0,
6679                                         DImode);
6680       operand2 = operand_subword_force (copy_rtx (dest), WORDS_BIG_ENDIAN != 0,
6681                                         DImode);
6682       emit_move_insn (operand1, GEN_INT (c1));
6683       emit_move_insn (operand2, GEN_INT (c2));
6684     }
6685   else
6686     {
6687       HOST_WIDE_INT ud1, ud2, ud3, ud4;
6688
6689       ud1 = c1 & 0xffff;
6690       ud2 = (c1 & 0xffff0000) >> 16;
6691 #if HOST_BITS_PER_WIDE_INT >= 64
6692       c2 = c1 >> 32;
6693 #endif
6694       ud3 = c2 & 0xffff;
6695       ud4 = (c2 & 0xffff0000) >> 16;
6696
6697       if ((ud4 == 0xffff && ud3 == 0xffff && ud2 == 0xffff && (ud1 & 0x8000))
6698           || (ud4 == 0 && ud3 == 0 && ud2 == 0 && ! (ud1 & 0x8000)))
6699         {
6700           if (ud1 & 0x8000)
6701             emit_move_insn (dest, GEN_INT (((ud1 ^ 0x8000) -  0x8000)));
6702           else
6703             emit_move_insn (dest, GEN_INT (ud1));
6704         }
6705
6706       else if ((ud4 == 0xffff && ud3 == 0xffff && (ud2 & 0x8000))
6707                || (ud4 == 0 && ud3 == 0 && ! (ud2 & 0x8000)))
6708         {
6709           if (ud2 & 0x8000)
6710             emit_move_insn (dest, GEN_INT (((ud2 << 16) ^ 0x80000000)
6711                                            - 0x80000000));
6712           else
6713             emit_move_insn (dest, GEN_INT (ud2 << 16));
6714           if (ud1 != 0)
6715             emit_move_insn (copy_rtx (dest),
6716                             gen_rtx_IOR (DImode, copy_rtx (dest),
6717                                          GEN_INT (ud1)));
6718         }
6719       else if (ud3 == 0 && ud4 == 0)
6720         {
6721           gcc_assert (ud2 & 0x8000);
6722           emit_move_insn (dest, GEN_INT (((ud2 << 16) ^ 0x80000000)
6723                                          - 0x80000000));
6724           if (ud1 != 0)
6725             emit_move_insn (copy_rtx (dest),
6726                             gen_rtx_IOR (DImode, copy_rtx (dest),
6727                                          GEN_INT (ud1)));
6728           emit_move_insn (copy_rtx (dest),
6729                           gen_rtx_ZERO_EXTEND (DImode,
6730                                                gen_lowpart (SImode,
6731                                                             copy_rtx (dest))));
6732         }
6733       else if ((ud4 == 0xffff && (ud3 & 0x8000))
6734                || (ud4 == 0 && ! (ud3 & 0x8000)))
6735         {
6736           if (ud3 & 0x8000)
6737             emit_move_insn (dest, GEN_INT (((ud3 << 16) ^ 0x80000000)
6738                                            - 0x80000000));
6739           else
6740             emit_move_insn (dest, GEN_INT (ud3 << 16));
6741
6742           if (ud2 != 0)
6743             emit_move_insn (copy_rtx (dest),
6744                             gen_rtx_IOR (DImode, copy_rtx (dest),
6745                                          GEN_INT (ud2)));
6746           emit_move_insn (copy_rtx (dest),
6747                           gen_rtx_ASHIFT (DImode, copy_rtx (dest),
6748                                           GEN_INT (16)));
6749           if (ud1 != 0)
6750             emit_move_insn (copy_rtx (dest),
6751                             gen_rtx_IOR (DImode, copy_rtx (dest),
6752                                          GEN_INT (ud1)));
6753         }
6754       else
6755         {
6756           if (ud4 & 0x8000)
6757             emit_move_insn (dest, GEN_INT (((ud4 << 16) ^ 0x80000000)
6758                                            - 0x80000000));
6759           else
6760             emit_move_insn (dest, GEN_INT (ud4 << 16));
6761
6762           if (ud3 != 0)
6763             emit_move_insn (copy_rtx (dest),
6764                             gen_rtx_IOR (DImode, copy_rtx (dest),
6765                                          GEN_INT (ud3)));
6766
6767           emit_move_insn (copy_rtx (dest),
6768                           gen_rtx_ASHIFT (DImode, copy_rtx (dest),
6769                                           GEN_INT (32)));
6770           if (ud2 != 0)
6771             emit_move_insn (copy_rtx (dest),
6772                             gen_rtx_IOR (DImode, copy_rtx (dest),
6773                                          GEN_INT (ud2 << 16)));
6774           if (ud1 != 0)
6775             emit_move_insn (copy_rtx (dest),
6776                             gen_rtx_IOR (DImode, copy_rtx (dest), GEN_INT (ud1)));
6777         }
6778     }
6779   return dest;
6780 }
6781
6782 /* Helper for the following.  Get rid of [r+r] memory refs
6783    in cases where it won't work (TImode, TFmode, TDmode).  */
6784
6785 static void
6786 rs6000_eliminate_indexed_memrefs (rtx operands[2])
6787 {
6788   if (reload_in_progress)
6789     return;
6790
6791   if (GET_CODE (operands[0]) == MEM
6792       && GET_CODE (XEXP (operands[0], 0)) != REG
6793       && ! legitimate_constant_pool_address_p (XEXP (operands[0], 0),
6794                                                GET_MODE (operands[0]), false))
6795     operands[0]
6796       = replace_equiv_address (operands[0],
6797                                copy_addr_to_reg (XEXP (operands[0], 0)));
6798
6799   if (GET_CODE (operands[1]) == MEM
6800       && GET_CODE (XEXP (operands[1], 0)) != REG
6801       && ! legitimate_constant_pool_address_p (XEXP (operands[1], 0),
6802                                                GET_MODE (operands[1]), false))
6803     operands[1]
6804       = replace_equiv_address (operands[1],
6805                                copy_addr_to_reg (XEXP (operands[1], 0)));
6806 }
6807
6808 /* Emit a move from SOURCE to DEST in mode MODE.  */
6809 void
6810 rs6000_emit_move (rtx dest, rtx source, enum machine_mode mode)
6811 {
6812   rtx operands[2];
6813   operands[0] = dest;
6814   operands[1] = source;
6815
6816   if (TARGET_DEBUG_ADDR)
6817     {
6818       fprintf (stderr,
6819                "\nrs6000_emit_move: mode = %s, reload_in_progress = %d, "
6820                "reload_completed = %d, can_create_pseudos = %d.\ndest:\n",
6821                GET_MODE_NAME (mode),
6822                reload_in_progress,
6823                reload_completed,
6824                can_create_pseudo_p ());
6825       debug_rtx (dest);
6826       fprintf (stderr, "source:\n");
6827       debug_rtx (source);
6828     }
6829
6830   /* Sanity checks.  Check that we get CONST_DOUBLE only when we should.  */
6831   if (GET_CODE (operands[1]) == CONST_DOUBLE
6832       && ! FLOAT_MODE_P (mode)
6833       && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT)
6834     {
6835       /* FIXME.  This should never happen.  */
6836       /* Since it seems that it does, do the safe thing and convert
6837          to a CONST_INT.  */
6838       operands[1] = gen_int_mode (CONST_DOUBLE_LOW (operands[1]), mode);
6839     }
6840   gcc_assert (GET_CODE (operands[1]) != CONST_DOUBLE
6841               || FLOAT_MODE_P (mode)
6842               || ((CONST_DOUBLE_HIGH (operands[1]) != 0
6843                    || CONST_DOUBLE_LOW (operands[1]) < 0)
6844                   && (CONST_DOUBLE_HIGH (operands[1]) != -1
6845                       || CONST_DOUBLE_LOW (operands[1]) >= 0)));
6846
6847   /* Check if GCC is setting up a block move that will end up using FP
6848      registers as temporaries.  We must make sure this is acceptable.  */
6849   if (GET_CODE (operands[0]) == MEM
6850       && GET_CODE (operands[1]) == MEM
6851       && mode == DImode
6852       && (SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[0]))
6853           || SLOW_UNALIGNED_ACCESS (DImode, MEM_ALIGN (operands[1])))
6854       && ! (SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[0]) > 32
6855                                             ? 32 : MEM_ALIGN (operands[0])))
6856             || SLOW_UNALIGNED_ACCESS (SImode, (MEM_ALIGN (operands[1]) > 32
6857                                                ? 32
6858                                                : MEM_ALIGN (operands[1]))))
6859       && ! MEM_VOLATILE_P (operands [0])
6860       && ! MEM_VOLATILE_P (operands [1]))
6861     {
6862       emit_move_insn (adjust_address (operands[0], SImode, 0),
6863                       adjust_address (operands[1], SImode, 0));
6864       emit_move_insn (adjust_address (copy_rtx (operands[0]), SImode, 4),
6865                       adjust_address (copy_rtx (operands[1]), SImode, 4));
6866       return;
6867     }
6868
6869   if (can_create_pseudo_p () && GET_CODE (operands[0]) == MEM
6870       && !gpc_reg_operand (operands[1], mode))
6871     operands[1] = force_reg (mode, operands[1]);
6872
6873   if (mode == SFmode && ! TARGET_POWERPC
6874       && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT
6875       && GET_CODE (operands[0]) == MEM)
6876     {
6877       int regnum;
6878
6879       if (reload_in_progress || reload_completed)
6880         regnum = true_regnum (operands[1]);
6881       else if (GET_CODE (operands[1]) == REG)
6882         regnum = REGNO (operands[1]);
6883       else
6884         regnum = -1;
6885
6886       /* If operands[1] is a register, on POWER it may have
6887          double-precision data in it, so truncate it to single
6888          precision.  */
6889       if (FP_REGNO_P (regnum) || regnum >= FIRST_PSEUDO_REGISTER)
6890         {
6891           rtx newreg;
6892           newreg = (!can_create_pseudo_p () ? copy_rtx (operands[1])
6893                     : gen_reg_rtx (mode));
6894           emit_insn (gen_aux_truncdfsf2 (newreg, operands[1]));
6895           operands[1] = newreg;
6896         }
6897     }
6898
6899   /* Recognize the case where operand[1] is a reference to thread-local
6900      data and load its address to a register.  */
6901   if (rs6000_tls_referenced_p (operands[1]))
6902     {
6903       enum tls_model model;
6904       rtx tmp = operands[1];
6905       rtx addend = NULL;
6906
6907       if (GET_CODE (tmp) == CONST && GET_CODE (XEXP (tmp, 0)) == PLUS)
6908         {
6909           addend = XEXP (XEXP (tmp, 0), 1);
6910           tmp = XEXP (XEXP (tmp, 0), 0);
6911         }
6912
6913       gcc_assert (GET_CODE (tmp) == SYMBOL_REF);
6914       model = SYMBOL_REF_TLS_MODEL (tmp);
6915       gcc_assert (model != 0);
6916
6917       tmp = rs6000_legitimize_tls_address (tmp, model);
6918       if (addend)
6919         {
6920           tmp = gen_rtx_PLUS (mode, tmp, addend);
6921           tmp = force_operand (tmp, operands[0]);
6922         }
6923       operands[1] = tmp;
6924     }
6925
6926   /* Handle the case where reload calls us with an invalid address.  */
6927   if (reload_in_progress && mode == Pmode
6928       && (! general_operand (operands[1], mode)
6929           || ! nonimmediate_operand (operands[0], mode)))
6930     goto emit_set;
6931
6932   /* 128-bit constant floating-point values on Darwin should really be
6933      loaded as two parts.  */
6934   if (!TARGET_IEEEQUAD && TARGET_LONG_DOUBLE_128
6935       && mode == TFmode && GET_CODE (operands[1]) == CONST_DOUBLE)
6936     {
6937       /* DImode is used, not DFmode, because simplify_gen_subreg doesn't
6938          know how to get a DFmode SUBREG of a TFmode.  */
6939       enum machine_mode imode = (TARGET_E500_DOUBLE ? DFmode : DImode);
6940       rs6000_emit_move (simplify_gen_subreg (imode, operands[0], mode, 0),
6941                         simplify_gen_subreg (imode, operands[1], mode, 0),
6942                         imode);
6943       rs6000_emit_move (simplify_gen_subreg (imode, operands[0], mode,
6944                                              GET_MODE_SIZE (imode)),
6945                         simplify_gen_subreg (imode, operands[1], mode,
6946                                              GET_MODE_SIZE (imode)),
6947                         imode);
6948       return;
6949     }
6950
6951   if (reload_in_progress && cfun->machine->sdmode_stack_slot != NULL_RTX)
6952     cfun->machine->sdmode_stack_slot =
6953       eliminate_regs (cfun->machine->sdmode_stack_slot, VOIDmode, NULL_RTX);
6954
6955   if (reload_in_progress
6956       && mode == SDmode
6957       && MEM_P (operands[0])
6958       && rtx_equal_p (operands[0], cfun->machine->sdmode_stack_slot)
6959       && REG_P (operands[1]))
6960     {
6961       if (FP_REGNO_P (REGNO (operands[1])))
6962         {
6963           rtx mem = adjust_address_nv (operands[0], DDmode, 0);
6964           mem = eliminate_regs (mem, VOIDmode, NULL_RTX);
6965           emit_insn (gen_movsd_store (mem, operands[1]));
6966         }
6967       else if (INT_REGNO_P (REGNO (operands[1])))
6968         {
6969           rtx mem = adjust_address_nv (operands[0], mode, 4);
6970           mem = eliminate_regs (mem, VOIDmode, NULL_RTX);
6971           emit_insn (gen_movsd_hardfloat (mem, operands[1]));
6972         }
6973       else
6974         gcc_unreachable();
6975       return;
6976     }
6977   if (reload_in_progress
6978       && mode == SDmode
6979       && REG_P (operands[0])
6980       && MEM_P (operands[1])
6981       && rtx_equal_p (operands[1], cfun->machine->sdmode_stack_slot))
6982     {
6983       if (FP_REGNO_P (REGNO (operands[0])))
6984         {
6985           rtx mem = adjust_address_nv (operands[1], DDmode, 0);
6986           mem = eliminate_regs (mem, VOIDmode, NULL_RTX);
6987           emit_insn (gen_movsd_load (operands[0], mem));
6988         }
6989       else if (INT_REGNO_P (REGNO (operands[0])))
6990         {
6991           rtx mem = adjust_address_nv (operands[1], mode, 4);
6992           mem = eliminate_regs (mem, VOIDmode, NULL_RTX);
6993           emit_insn (gen_movsd_hardfloat (operands[0], mem));
6994         }
6995       else
6996         gcc_unreachable();
6997       return;
6998     }
6999
7000   /* FIXME:  In the long term, this switch statement should go away
7001      and be replaced by a sequence of tests based on things like
7002      mode == Pmode.  */
7003   switch (mode)
7004     {
7005     case HImode:
7006     case QImode:
7007       if (CONSTANT_P (operands[1])
7008           && GET_CODE (operands[1]) != CONST_INT)
7009         operands[1] = force_const_mem (mode, operands[1]);
7010       break;
7011
7012     case TFmode:
7013     case TDmode:
7014       rs6000_eliminate_indexed_memrefs (operands);
7015       /* fall through */
7016
7017     case DFmode:
7018     case DDmode:
7019     case SFmode:
7020     case SDmode:
7021       if (CONSTANT_P (operands[1])
7022           && ! easy_fp_constant (operands[1], mode))
7023         operands[1] = force_const_mem (mode, operands[1]);
7024       break;
7025
7026     case V16QImode:
7027     case V8HImode:
7028     case V4SFmode:
7029     case V4SImode:
7030     case V4HImode:
7031     case V2SFmode:
7032     case V2SImode:
7033     case V1DImode:
7034     case V2DFmode:
7035     case V2DImode:
7036       if (CONSTANT_P (operands[1])
7037           && !easy_vector_constant (operands[1], mode))
7038         operands[1] = force_const_mem (mode, operands[1]);
7039       break;
7040
7041     case SImode:
7042     case DImode:
7043       /* Use default pattern for address of ELF small data */
7044       if (TARGET_ELF
7045           && mode == Pmode
7046           && DEFAULT_ABI == ABI_V4
7047           && (GET_CODE (operands[1]) == SYMBOL_REF
7048               || GET_CODE (operands[1]) == CONST)
7049           && small_data_operand (operands[1], mode))
7050         {
7051           emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
7052           return;
7053         }
7054
7055       if (DEFAULT_ABI == ABI_V4
7056           && mode == Pmode && mode == SImode
7057           && flag_pic == 1 && got_operand (operands[1], mode))
7058         {
7059           emit_insn (gen_movsi_got (operands[0], operands[1]));
7060           return;
7061         }
7062
7063       if ((TARGET_ELF || DEFAULT_ABI == ABI_DARWIN)
7064           && TARGET_NO_TOC
7065           && ! flag_pic
7066           && mode == Pmode
7067           && CONSTANT_P (operands[1])
7068           && GET_CODE (operands[1]) != HIGH
7069           && GET_CODE (operands[1]) != CONST_INT)
7070         {
7071           rtx target = (!can_create_pseudo_p ()
7072                         ? operands[0]
7073                         : gen_reg_rtx (mode));
7074
7075           /* If this is a function address on -mcall-aixdesc,
7076              convert it to the address of the descriptor.  */
7077           if (DEFAULT_ABI == ABI_AIX
7078               && GET_CODE (operands[1]) == SYMBOL_REF
7079               && XSTR (operands[1], 0)[0] == '.')
7080             {
7081               const char *name = XSTR (operands[1], 0);
7082               rtx new_ref;
7083               while (*name == '.')
7084                 name++;
7085               new_ref = gen_rtx_SYMBOL_REF (Pmode, name);
7086               CONSTANT_POOL_ADDRESS_P (new_ref)
7087                 = CONSTANT_POOL_ADDRESS_P (operands[1]);
7088               SYMBOL_REF_FLAGS (new_ref) = SYMBOL_REF_FLAGS (operands[1]);
7089               SYMBOL_REF_USED (new_ref) = SYMBOL_REF_USED (operands[1]);
7090               SYMBOL_REF_DATA (new_ref) = SYMBOL_REF_DATA (operands[1]);
7091               operands[1] = new_ref;
7092             }
7093
7094           if (DEFAULT_ABI == ABI_DARWIN)
7095             {
7096 #if TARGET_MACHO
7097               if (MACHO_DYNAMIC_NO_PIC_P)
7098                 {
7099                   /* Take care of any required data indirection.  */
7100                   operands[1] = rs6000_machopic_legitimize_pic_address (
7101                                   operands[1], mode, operands[0]);
7102                   if (operands[0] != operands[1])
7103                     emit_insn (gen_rtx_SET (VOIDmode,
7104                                             operands[0], operands[1]));
7105                   return;
7106                 }
7107 #endif
7108               emit_insn (gen_macho_high (target, operands[1]));
7109               emit_insn (gen_macho_low (operands[0], target, operands[1]));
7110               return;
7111             }
7112
7113           emit_insn (gen_elf_high (target, operands[1]));
7114           emit_insn (gen_elf_low (operands[0], target, operands[1]));
7115           return;
7116         }
7117
7118       /* If this is a SYMBOL_REF that refers to a constant pool entry,
7119          and we have put it in the TOC, we just need to make a TOC-relative
7120          reference to it.  */
7121       if ((TARGET_TOC
7122            && GET_CODE (operands[1]) == SYMBOL_REF
7123            && constant_pool_expr_p (operands[1])
7124            && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (get_pool_constant (operands[1]),
7125                                                get_pool_mode (operands[1])))
7126           || (TARGET_CMODEL == CMODEL_MEDIUM
7127               && GET_CODE (operands[1]) == SYMBOL_REF
7128               && !CONSTANT_POOL_ADDRESS_P (operands[1])
7129               && SYMBOL_REF_LOCAL_P (operands[1])))
7130         {
7131           rtx reg = NULL_RTX;
7132           if (TARGET_CMODEL != CMODEL_SMALL)
7133             {
7134               if (can_create_pseudo_p ())
7135                 reg = gen_reg_rtx (Pmode);
7136               else
7137                 reg = operands[0];
7138             }
7139           operands[1] = create_TOC_reference (operands[1], reg);
7140         }
7141       else if (mode == Pmode
7142                && CONSTANT_P (operands[1])
7143                && GET_CODE (operands[1]) != HIGH
7144                && !(TARGET_CMODEL != CMODEL_SMALL
7145                     && GET_CODE (operands[1]) == CONST
7146                     && GET_CODE (XEXP (operands[1], 0)) == PLUS
7147                     && GET_CODE (XEXP (XEXP (operands[1], 0), 1)) == HIGH)
7148                && ((GET_CODE (operands[1]) != CONST_INT
7149                     && ! easy_fp_constant (operands[1], mode))
7150                    || (GET_CODE (operands[1]) == CONST_INT
7151                        && (num_insns_constant (operands[1], mode)
7152                            > (TARGET_CMODEL != CMODEL_SMALL ? 3 : 2)))
7153                    || (GET_CODE (operands[0]) == REG
7154                        && FP_REGNO_P (REGNO (operands[0]))))
7155                && ! legitimate_constant_pool_address_p (operands[1], mode,
7156                                                         false)
7157                && ! toc_relative_expr_p (operands[1])
7158                && (TARGET_CMODEL == CMODEL_SMALL
7159                    || can_create_pseudo_p ()
7160                    || (REG_P (operands[0])
7161                        && INT_REG_OK_FOR_BASE_P (operands[0], true))))
7162         {
7163
7164 #if TARGET_MACHO
7165           /* Darwin uses a special PIC legitimizer.  */
7166           if (DEFAULT_ABI == ABI_DARWIN && MACHOPIC_INDIRECT)
7167             {
7168               operands[1] =
7169                 rs6000_machopic_legitimize_pic_address (operands[1], mode,
7170                                                         operands[0]);
7171               if (operands[0] != operands[1])
7172                 emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
7173               return;
7174             }
7175 #endif
7176
7177           /* If we are to limit the number of things we put in the TOC and
7178              this is a symbol plus a constant we can add in one insn,
7179              just put the symbol in the TOC and add the constant.  Don't do
7180              this if reload is in progress.  */
7181           if (GET_CODE (operands[1]) == CONST
7182               && TARGET_NO_SUM_IN_TOC && ! reload_in_progress
7183               && GET_CODE (XEXP (operands[1], 0)) == PLUS
7184               && add_operand (XEXP (XEXP (operands[1], 0), 1), mode)
7185               && (GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == LABEL_REF
7186                   || GET_CODE (XEXP (XEXP (operands[1], 0), 0)) == SYMBOL_REF)
7187               && ! side_effects_p (operands[0]))
7188             {
7189               rtx sym =
7190                 force_const_mem (mode, XEXP (XEXP (operands[1], 0), 0));
7191               rtx other = XEXP (XEXP (operands[1], 0), 1);
7192
7193               sym = force_reg (mode, sym);
7194               emit_insn (gen_add3_insn (operands[0], sym, other));
7195               return;
7196             }
7197
7198           operands[1] = force_const_mem (mode, operands[1]);
7199
7200           if (TARGET_TOC
7201               && GET_CODE (XEXP (operands[1], 0)) == SYMBOL_REF
7202               && constant_pool_expr_p (XEXP (operands[1], 0))
7203               && ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (
7204                         get_pool_constant (XEXP (operands[1], 0)),
7205                         get_pool_mode (XEXP (operands[1], 0))))
7206             {
7207               rtx tocref;
7208               rtx reg = NULL_RTX;
7209               if (TARGET_CMODEL != CMODEL_SMALL)
7210                 {
7211                   if (can_create_pseudo_p ())
7212                     reg = gen_reg_rtx (Pmode);
7213                   else
7214                     reg = operands[0];
7215                 }
7216               tocref = create_TOC_reference (XEXP (operands[1], 0), reg);
7217               operands[1] = gen_const_mem (mode, tocref);
7218               set_mem_alias_set (operands[1], get_TOC_alias_set ());
7219             }
7220         }
7221       break;
7222
7223     case TImode:
7224       rs6000_eliminate_indexed_memrefs (operands);
7225
7226       if (TARGET_POWER)
7227         {
7228           emit_insn (gen_rtx_PARALLEL (VOIDmode,
7229                        gen_rtvec (2,
7230                                   gen_rtx_SET (VOIDmode,
7231                                                operands[0], operands[1]),
7232                                   gen_rtx_CLOBBER (VOIDmode,
7233                                                    gen_rtx_SCRATCH (SImode)))));
7234           return;
7235         }
7236       break;
7237
7238     default:
7239       fatal_insn ("bad move", gen_rtx_SET (VOIDmode, dest, source));
7240     }
7241
7242   /* Above, we may have called force_const_mem which may have returned
7243      an invalid address.  If we can, fix this up; otherwise, reload will
7244      have to deal with it.  */
7245   if (GET_CODE (operands[1]) == MEM && ! reload_in_progress)
7246     operands[1] = validize_mem (operands[1]);
7247
7248  emit_set:
7249   emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[1]));
7250 }
7251 \f
7252 /* Nonzero if we can use a floating-point register to pass this arg.  */
7253 #define USE_FP_FOR_ARG_P(CUM,MODE,TYPE)         \
7254   (SCALAR_FLOAT_MODE_P (MODE)                   \
7255    && (CUM)->fregno <= FP_ARG_MAX_REG           \
7256    && TARGET_HARD_FLOAT && TARGET_FPRS)
7257
7258 /* Nonzero if we can use an AltiVec register to pass this arg.  */
7259 #define USE_ALTIVEC_FOR_ARG_P(CUM,MODE,TYPE,NAMED)              \
7260   (ALTIVEC_OR_VSX_VECTOR_MODE (MODE)                            \
7261    && (CUM)->vregno <= ALTIVEC_ARG_MAX_REG                      \
7262    && TARGET_ALTIVEC_ABI                                        \
7263    && (NAMED))
7264
7265 /* Return a nonzero value to say to return the function value in
7266    memory, just as large structures are always returned.  TYPE will be
7267    the data type of the value, and FNTYPE will be the type of the
7268    function doing the returning, or @code{NULL} for libcalls.
7269
7270    The AIX ABI for the RS/6000 specifies that all structures are
7271    returned in memory.  The Darwin ABI does the same.
7272
7273    For the Darwin 64 Bit ABI, a function result can be returned in
7274    registers or in memory, depending on the size of the return data
7275    type.  If it is returned in registers, the value occupies the same
7276    registers as it would if it were the first and only function
7277    argument.  Otherwise, the function places its result in memory at
7278    the location pointed to by GPR3.
7279
7280    The SVR4 ABI specifies that structures <= 8 bytes are returned in r3/r4,
7281    but a draft put them in memory, and GCC used to implement the draft
7282    instead of the final standard.  Therefore, aix_struct_return
7283    controls this instead of DEFAULT_ABI; V.4 targets needing backward
7284    compatibility can change DRAFT_V4_STRUCT_RET to override the
7285    default, and -m switches get the final word.  See
7286    rs6000_option_override_internal for more details.
7287
7288    The PPC32 SVR4 ABI uses IEEE double extended for long double, if 128-bit
7289    long double support is enabled.  These values are returned in memory.
7290
7291    int_size_in_bytes returns -1 for variable size objects, which go in
7292    memory always.  The cast to unsigned makes -1 > 8.  */
7293
7294 static bool
7295 rs6000_return_in_memory (const_tree type, const_tree fntype ATTRIBUTE_UNUSED)
7296 {
7297   /* For the Darwin64 ABI, test if we can fit the return value in regs.  */
7298   if (TARGET_MACHO
7299       && rs6000_darwin64_abi
7300       && TREE_CODE (type) == RECORD_TYPE
7301       && int_size_in_bytes (type) > 0)
7302     {
7303       CUMULATIVE_ARGS valcum;
7304       rtx valret;
7305
7306       valcum.words = 0;
7307       valcum.fregno = FP_ARG_MIN_REG;
7308       valcum.vregno = ALTIVEC_ARG_MIN_REG;
7309       /* Do a trial code generation as if this were going to be passed
7310          as an argument; if any part goes in memory, we return NULL.  */
7311       valret = rs6000_darwin64_record_arg (&valcum, type, true, true);
7312       if (valret)
7313         return false;
7314       /* Otherwise fall through to more conventional ABI rules.  */
7315     }
7316
7317   if (AGGREGATE_TYPE_P (type)
7318       && (aix_struct_return
7319           || (unsigned HOST_WIDE_INT) int_size_in_bytes (type) > 8))
7320     return true;
7321
7322   /* Allow -maltivec -mabi=no-altivec without warning.  Altivec vector
7323      modes only exist for GCC vector types if -maltivec.  */
7324   if (TARGET_32BIT && !TARGET_ALTIVEC_ABI
7325       && ALTIVEC_VECTOR_MODE (TYPE_MODE (type)))
7326     return false;
7327
7328   /* Return synthetic vectors in memory.  */
7329   if (TREE_CODE (type) == VECTOR_TYPE
7330       && int_size_in_bytes (type) > (TARGET_ALTIVEC_ABI ? 16 : 8))
7331     {
7332       static bool warned_for_return_big_vectors = false;
7333       if (!warned_for_return_big_vectors)
7334         {
7335           warning (0, "GCC vector returned by reference: "
7336                    "non-standard ABI extension with no compatibility guarantee");
7337           warned_for_return_big_vectors = true;
7338         }
7339       return true;
7340     }
7341
7342   if (DEFAULT_ABI == ABI_V4 && TARGET_IEEEQUAD && TYPE_MODE (type) == TFmode)
7343     return true;
7344
7345   return false;
7346 }
7347
7348 #ifdef HAVE_AS_GNU_ATTRIBUTE
7349 /* Return TRUE if a call to function FNDECL may be one that
7350    potentially affects the function calling ABI of the object file.  */
7351
7352 static bool
7353 call_ABI_of_interest (tree fndecl)
7354 {
7355   if (cgraph_state == CGRAPH_STATE_EXPANSION)
7356     {
7357       struct cgraph_node *c_node;
7358
7359       /* Libcalls are always interesting.  */
7360       if (fndecl == NULL_TREE)
7361         return true;
7362
7363       /* Any call to an external function is interesting.  */
7364       if (DECL_EXTERNAL (fndecl))
7365         return true;
7366
7367       /* Interesting functions that we are emitting in this object file.  */
7368       c_node = cgraph_get_node (fndecl);
7369       c_node = cgraph_function_or_thunk_node (c_node, NULL);
7370       return !cgraph_only_called_directly_p (c_node);
7371     }
7372   return false;
7373 }
7374 #endif
7375
7376 /* Initialize a variable CUM of type CUMULATIVE_ARGS
7377    for a call to a function whose data type is FNTYPE.
7378    For a library call, FNTYPE is 0 and RETURN_MODE the return value mode.
7379
7380    For incoming args we set the number of arguments in the prototype large
7381    so we never return a PARALLEL.  */
7382
7383 void
7384 init_cumulative_args (CUMULATIVE_ARGS *cum, tree fntype,
7385                       rtx libname ATTRIBUTE_UNUSED, int incoming,
7386                       int libcall, int n_named_args,
7387                       tree fndecl ATTRIBUTE_UNUSED,
7388                       enum machine_mode return_mode ATTRIBUTE_UNUSED)
7389 {
7390   static CUMULATIVE_ARGS zero_cumulative;
7391
7392   *cum = zero_cumulative;
7393   cum->words = 0;
7394   cum->fregno = FP_ARG_MIN_REG;
7395   cum->vregno = ALTIVEC_ARG_MIN_REG;
7396   cum->prototype = (fntype && prototype_p (fntype));
7397   cum->call_cookie = ((DEFAULT_ABI == ABI_V4 && libcall)
7398                       ? CALL_LIBCALL : CALL_NORMAL);
7399   cum->sysv_gregno = GP_ARG_MIN_REG;
7400   cum->stdarg = stdarg_p (fntype);
7401
7402   cum->nargs_prototype = 0;
7403   if (incoming || cum->prototype)
7404     cum->nargs_prototype = n_named_args;
7405
7406   /* Check for a longcall attribute.  */
7407   if ((!fntype && rs6000_default_long_calls)
7408       || (fntype
7409           && lookup_attribute ("longcall", TYPE_ATTRIBUTES (fntype))
7410           && !lookup_attribute ("shortcall", TYPE_ATTRIBUTES (fntype))))
7411     cum->call_cookie |= CALL_LONG;
7412
7413   if (TARGET_DEBUG_ARG)
7414     {
7415       fprintf (stderr, "\ninit_cumulative_args:");
7416       if (fntype)
7417         {
7418           tree ret_type = TREE_TYPE (fntype);
7419           fprintf (stderr, " ret code = %s,",
7420                    tree_code_name[ (int)TREE_CODE (ret_type) ]);
7421         }
7422
7423       if (cum->call_cookie & CALL_LONG)
7424         fprintf (stderr, " longcall,");
7425
7426       fprintf (stderr, " proto = %d, nargs = %d\n",
7427                cum->prototype, cum->nargs_prototype);
7428     }
7429
7430 #ifdef HAVE_AS_GNU_ATTRIBUTE
7431   if (DEFAULT_ABI == ABI_V4)
7432     {
7433       cum->escapes = call_ABI_of_interest (fndecl);
7434       if (cum->escapes)
7435         {
7436           tree return_type;
7437
7438           if (fntype)
7439             {
7440               return_type = TREE_TYPE (fntype);
7441               return_mode = TYPE_MODE (return_type);
7442             }
7443           else
7444             return_type = lang_hooks.types.type_for_mode (return_mode, 0);
7445
7446           if (return_type != NULL)
7447             {
7448               if (TREE_CODE (return_type) == RECORD_TYPE
7449                   && TYPE_TRANSPARENT_AGGR (return_type))
7450                 {
7451                   return_type = TREE_TYPE (first_field (return_type));
7452                   return_mode = TYPE_MODE (return_type);
7453                 }
7454               if (AGGREGATE_TYPE_P (return_type)
7455                   && ((unsigned HOST_WIDE_INT) int_size_in_bytes (return_type)
7456                       <= 8))
7457                 rs6000_returns_struct = true;
7458             }
7459           if (SCALAR_FLOAT_MODE_P (return_mode))
7460             rs6000_passes_float = true;
7461           else if (ALTIVEC_OR_VSX_VECTOR_MODE (return_mode)
7462                    || SPE_VECTOR_MODE (return_mode))
7463             rs6000_passes_vector = true;
7464         }
7465     }
7466 #endif
7467
7468   if (fntype
7469       && !TARGET_ALTIVEC
7470       && TARGET_ALTIVEC_ABI
7471       && ALTIVEC_VECTOR_MODE (TYPE_MODE (TREE_TYPE (fntype))))
7472     {
7473       error ("cannot return value in vector register because"
7474              " altivec instructions are disabled, use -maltivec"
7475              " to enable them");
7476     }
7477 }
7478 \f
7479 /* Return true if TYPE must be passed on the stack and not in registers.  */
7480
7481 static bool
7482 rs6000_must_pass_in_stack (enum machine_mode mode, const_tree type)
7483 {
7484   if (DEFAULT_ABI == ABI_AIX || TARGET_64BIT)
7485     return must_pass_in_stack_var_size (mode, type);
7486   else
7487     return must_pass_in_stack_var_size_or_pad (mode, type);
7488 }
7489
7490 /* If defined, a C expression which determines whether, and in which
7491    direction, to pad out an argument with extra space.  The value
7492    should be of type `enum direction': either `upward' to pad above
7493    the argument, `downward' to pad below, or `none' to inhibit
7494    padding.
7495
7496    For the AIX ABI structs are always stored left shifted in their
7497    argument slot.  */
7498
7499 enum direction
7500 function_arg_padding (enum machine_mode mode, const_tree type)
7501 {
7502 #ifndef AGGREGATE_PADDING_FIXED
7503 #define AGGREGATE_PADDING_FIXED 0
7504 #endif
7505 #ifndef AGGREGATES_PAD_UPWARD_ALWAYS
7506 #define AGGREGATES_PAD_UPWARD_ALWAYS 0
7507 #endif
7508
7509   if (!AGGREGATE_PADDING_FIXED)
7510     {
7511       /* GCC used to pass structures of the same size as integer types as
7512          if they were in fact integers, ignoring FUNCTION_ARG_PADDING.
7513          i.e. Structures of size 1 or 2 (or 4 when TARGET_64BIT) were
7514          passed padded downward, except that -mstrict-align further
7515          muddied the water in that multi-component structures of 2 and 4
7516          bytes in size were passed padded upward.
7517
7518          The following arranges for best compatibility with previous
7519          versions of gcc, but removes the -mstrict-align dependency.  */
7520       if (BYTES_BIG_ENDIAN)
7521         {
7522           HOST_WIDE_INT size = 0;
7523
7524           if (mode == BLKmode)
7525             {
7526               if (type && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST)
7527                 size = int_size_in_bytes (type);
7528             }
7529           else
7530             size = GET_MODE_SIZE (mode);
7531
7532           if (size == 1 || size == 2 || size == 4)
7533             return downward;
7534         }
7535       return upward;
7536     }
7537
7538   if (AGGREGATES_PAD_UPWARD_ALWAYS)
7539     {
7540       if (type != 0 && AGGREGATE_TYPE_P (type))
7541         return upward;
7542     }
7543
7544   /* Fall back to the default.  */
7545   return DEFAULT_FUNCTION_ARG_PADDING (mode, type);
7546 }
7547
7548 /* If defined, a C expression that gives the alignment boundary, in bits,
7549    of an argument with the specified mode and type.  If it is not defined,
7550    PARM_BOUNDARY is used for all arguments.
7551
7552    V.4 wants long longs and doubles to be double word aligned.  Just
7553    testing the mode size is a boneheaded way to do this as it means
7554    that other types such as complex int are also double word aligned.
7555    However, we're stuck with this because changing the ABI might break
7556    existing library interfaces.
7557
7558    Doubleword align SPE vectors.
7559    Quadword align Altivec/VSX vectors.
7560    Quadword align large synthetic vector types.   */
7561
7562 static unsigned int
7563 rs6000_function_arg_boundary (enum machine_mode mode, const_tree type)
7564 {
7565   if (DEFAULT_ABI == ABI_V4
7566       && (GET_MODE_SIZE (mode) == 8
7567           || (TARGET_HARD_FLOAT
7568               && TARGET_FPRS
7569               && (mode == TFmode || mode == TDmode))))
7570     return 64;
7571   else if (SPE_VECTOR_MODE (mode)
7572            || (type && TREE_CODE (type) == VECTOR_TYPE
7573                && int_size_in_bytes (type) >= 8
7574                && int_size_in_bytes (type) < 16))
7575     return 64;
7576   else if (ALTIVEC_OR_VSX_VECTOR_MODE (mode)
7577            || (type && TREE_CODE (type) == VECTOR_TYPE
7578                && int_size_in_bytes (type) >= 16))
7579     return 128;
7580   else if (TARGET_MACHO
7581            && rs6000_darwin64_abi
7582            && mode == BLKmode
7583            && type && TYPE_ALIGN (type) > 64)
7584     return 128;
7585   else
7586     return PARM_BOUNDARY;
7587 }
7588
7589 /* For a function parm of MODE and TYPE, return the starting word in
7590    the parameter area.  NWORDS of the parameter area are already used.  */
7591
7592 static unsigned int
7593 rs6000_parm_start (enum machine_mode mode, const_tree type,
7594                    unsigned int nwords)
7595 {
7596   unsigned int align;
7597   unsigned int parm_offset;
7598
7599   align = rs6000_function_arg_boundary (mode, type) / PARM_BOUNDARY - 1;
7600   parm_offset = DEFAULT_ABI == ABI_V4 ? 2 : 6;
7601   return nwords + (-(parm_offset + nwords) & align);
7602 }
7603
7604 /* Compute the size (in words) of a function argument.  */
7605
7606 static unsigned long
7607 rs6000_arg_size (enum machine_mode mode, const_tree type)
7608 {
7609   unsigned long size;
7610
7611   if (mode != BLKmode)
7612     size = GET_MODE_SIZE (mode);
7613   else
7614     size = int_size_in_bytes (type);
7615
7616   if (TARGET_32BIT)
7617     return (size + 3) >> 2;
7618   else
7619     return (size + 7) >> 3;
7620 }
7621 \f
7622 /* Use this to flush pending int fields.  */
7623
7624 static void
7625 rs6000_darwin64_record_arg_advance_flush (CUMULATIVE_ARGS *cum,
7626                                           HOST_WIDE_INT bitpos, int final)
7627 {
7628   unsigned int startbit, endbit;
7629   int intregs, intoffset;
7630   enum machine_mode mode;
7631
7632   /* Handle the situations where a float is taking up the first half
7633      of the GPR, and the other half is empty (typically due to
7634      alignment restrictions). We can detect this by a 8-byte-aligned
7635      int field, or by seeing that this is the final flush for this
7636      argument. Count the word and continue on.  */
7637   if (cum->floats_in_gpr == 1
7638       && (cum->intoffset % 64 == 0
7639           || (cum->intoffset == -1 && final)))
7640     {
7641       cum->words++;
7642       cum->floats_in_gpr = 0;
7643     }
7644
7645   if (cum->intoffset == -1)
7646     return;
7647
7648   intoffset = cum->intoffset;
7649   cum->intoffset = -1;
7650   cum->floats_in_gpr = 0;
7651
7652   if (intoffset % BITS_PER_WORD != 0)
7653     {
7654       mode = mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
7655                             MODE_INT, 0);
7656       if (mode == BLKmode)
7657         {
7658           /* We couldn't find an appropriate mode, which happens,
7659              e.g., in packed structs when there are 3 bytes to load.
7660              Back intoffset back to the beginning of the word in this
7661              case.  */
7662           intoffset = intoffset & -BITS_PER_WORD;
7663         }
7664     }
7665
7666   startbit = intoffset & -BITS_PER_WORD;
7667   endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
7668   intregs = (endbit - startbit) / BITS_PER_WORD;
7669   cum->words += intregs;
7670   /* words should be unsigned. */
7671   if ((unsigned)cum->words < (endbit/BITS_PER_WORD))
7672     {
7673       int pad = (endbit/BITS_PER_WORD) - cum->words;
7674       cum->words += pad;
7675     }
7676 }
7677
7678 /* The darwin64 ABI calls for us to recurse down through structs,
7679    looking for elements passed in registers.  Unfortunately, we have
7680    to track int register count here also because of misalignments
7681    in powerpc alignment mode.  */
7682
7683 static void
7684 rs6000_darwin64_record_arg_advance_recurse (CUMULATIVE_ARGS *cum,
7685                                             const_tree type,
7686                                             HOST_WIDE_INT startbitpos)
7687 {
7688   tree f;
7689
7690   for (f = TYPE_FIELDS (type); f ; f = DECL_CHAIN (f))
7691     if (TREE_CODE (f) == FIELD_DECL)
7692       {
7693         HOST_WIDE_INT bitpos = startbitpos;
7694         tree ftype = TREE_TYPE (f);
7695         enum machine_mode mode;
7696         if (ftype == error_mark_node)
7697           continue;
7698         mode = TYPE_MODE (ftype);
7699
7700         if (DECL_SIZE (f) != 0
7701             && host_integerp (bit_position (f), 1))
7702           bitpos += int_bit_position (f);
7703
7704         /* ??? FIXME: else assume zero offset.  */
7705
7706         if (TREE_CODE (ftype) == RECORD_TYPE)
7707           rs6000_darwin64_record_arg_advance_recurse (cum, ftype, bitpos);
7708         else if (USE_FP_FOR_ARG_P (cum, mode, ftype))
7709           {
7710             unsigned n_fpregs = (GET_MODE_SIZE (mode) + 7) >> 3;
7711             rs6000_darwin64_record_arg_advance_flush (cum, bitpos, 0);
7712             cum->fregno += n_fpregs;
7713             /* Single-precision floats present a special problem for
7714                us, because they are smaller than an 8-byte GPR, and so
7715                the structure-packing rules combined with the standard
7716                varargs behavior mean that we want to pack float/float
7717                and float/int combinations into a single register's
7718                space. This is complicated by the arg advance flushing,
7719                which works on arbitrarily large groups of int-type
7720                fields.  */
7721             if (mode == SFmode)
7722               {
7723                 if (cum->floats_in_gpr == 1)
7724                   {
7725                     /* Two floats in a word; count the word and reset
7726                        the float count.  */
7727                     cum->words++;
7728                     cum->floats_in_gpr = 0;
7729                   }
7730                 else if (bitpos % 64 == 0)
7731                   {
7732                     /* A float at the beginning of an 8-byte word;
7733                        count it and put off adjusting cum->words until
7734                        we see if a arg advance flush is going to do it
7735                        for us.  */
7736                     cum->floats_in_gpr++;
7737                   }
7738                 else
7739                   {
7740                     /* The float is at the end of a word, preceded
7741                        by integer fields, so the arg advance flush
7742                        just above has already set cum->words and
7743                        everything is taken care of.  */
7744                   }
7745               }
7746             else
7747               cum->words += n_fpregs;
7748           }
7749         else if (USE_ALTIVEC_FOR_ARG_P (cum, mode, type, 1))
7750           {
7751             rs6000_darwin64_record_arg_advance_flush (cum, bitpos, 0);
7752             cum->vregno++;
7753             cum->words += 2;
7754           }
7755         else if (cum->intoffset == -1)
7756           cum->intoffset = bitpos;
7757       }
7758 }
7759
7760 /* Check for an item that needs to be considered specially under the darwin 64
7761    bit ABI.  These are record types where the mode is BLK or the structure is
7762    8 bytes in size.  */
7763 static int
7764 rs6000_darwin64_struct_check_p (enum machine_mode mode, const_tree type)
7765 {
7766   return rs6000_darwin64_abi
7767          && ((mode == BLKmode
7768               && TREE_CODE (type) == RECORD_TYPE
7769               && int_size_in_bytes (type) > 0)
7770           || (type && TREE_CODE (type) == RECORD_TYPE
7771               && int_size_in_bytes (type) == 8)) ? 1 : 0;
7772 }
7773
7774 /* Update the data in CUM to advance over an argument
7775    of mode MODE and data type TYPE.
7776    (TYPE is null for libcalls where that information may not be available.)
7777
7778    Note that for args passed by reference, function_arg will be called
7779    with MODE and TYPE set to that of the pointer to the arg, not the arg
7780    itself.  */
7781
7782 static void
7783 rs6000_function_arg_advance_1 (CUMULATIVE_ARGS *cum, enum machine_mode mode,
7784                                const_tree type, bool named, int depth)
7785 {
7786   /* Only tick off an argument if we're not recursing.  */
7787   if (depth == 0)
7788     cum->nargs_prototype--;
7789
7790 #ifdef HAVE_AS_GNU_ATTRIBUTE
7791   if (DEFAULT_ABI == ABI_V4
7792       && cum->escapes)
7793     {
7794       if (SCALAR_FLOAT_MODE_P (mode))
7795         rs6000_passes_float = true;
7796       else if (named && ALTIVEC_OR_VSX_VECTOR_MODE (mode))
7797         rs6000_passes_vector = true;
7798       else if (SPE_VECTOR_MODE (mode)
7799                && !cum->stdarg
7800                && cum->sysv_gregno <= GP_ARG_MAX_REG)
7801         rs6000_passes_vector = true;
7802     }
7803 #endif
7804
7805   if (TARGET_ALTIVEC_ABI
7806       && (ALTIVEC_OR_VSX_VECTOR_MODE (mode)
7807           || (type && TREE_CODE (type) == VECTOR_TYPE
7808               && int_size_in_bytes (type) == 16)))
7809     {
7810       bool stack = false;
7811
7812       if (USE_ALTIVEC_FOR_ARG_P (cum, mode, type, named))
7813         {
7814           cum->vregno++;
7815           if (!TARGET_ALTIVEC)
7816             error ("cannot pass argument in vector register because"
7817                    " altivec instructions are disabled, use -maltivec"
7818                    " to enable them");
7819
7820           /* PowerPC64 Linux and AIX allocate GPRs for a vector argument
7821              even if it is going to be passed in a vector register.
7822              Darwin does the same for variable-argument functions.  */
7823           if ((DEFAULT_ABI == ABI_AIX && TARGET_64BIT)
7824               || (cum->stdarg && DEFAULT_ABI != ABI_V4))
7825             stack = true;
7826         }
7827       else
7828         stack = true;
7829
7830       if (stack)
7831         {
7832           int align;
7833
7834           /* Vector parameters must be 16-byte aligned.  This places
7835              them at 2 mod 4 in terms of words in 32-bit mode, since
7836              the parameter save area starts at offset 24 from the
7837              stack.  In 64-bit mode, they just have to start on an
7838              even word, since the parameter save area is 16-byte
7839              aligned.  Space for GPRs is reserved even if the argument
7840              will be passed in memory.  */
7841           if (TARGET_32BIT)
7842             align = (2 - cum->words) & 3;
7843           else
7844             align = cum->words & 1;
7845           cum->words += align + rs6000_arg_size (mode, type);
7846
7847           if (TARGET_DEBUG_ARG)
7848             {
7849               fprintf (stderr, "function_adv: words = %2d, align=%d, ",
7850                        cum->words, align);
7851               fprintf (stderr, "nargs = %4d, proto = %d, mode = %4s\n",
7852                        cum->nargs_prototype, cum->prototype,
7853                        GET_MODE_NAME (mode));
7854             }
7855         }
7856     }
7857   else if (TARGET_SPE_ABI && TARGET_SPE && SPE_VECTOR_MODE (mode)
7858            && !cum->stdarg
7859            && cum->sysv_gregno <= GP_ARG_MAX_REG)
7860     cum->sysv_gregno++;
7861
7862   else if (TARGET_MACHO && rs6000_darwin64_struct_check_p (mode, type))
7863     {
7864       int size = int_size_in_bytes (type);
7865       /* Variable sized types have size == -1 and are
7866          treated as if consisting entirely of ints.
7867          Pad to 16 byte boundary if needed.  */
7868       if (TYPE_ALIGN (type) >= 2 * BITS_PER_WORD
7869           && (cum->words % 2) != 0)
7870         cum->words++;
7871       /* For varargs, we can just go up by the size of the struct. */
7872       if (!named)
7873         cum->words += (size + 7) / 8;
7874       else
7875         {
7876           /* It is tempting to say int register count just goes up by
7877              sizeof(type)/8, but this is wrong in a case such as
7878              { int; double; int; } [powerpc alignment].  We have to
7879              grovel through the fields for these too.  */
7880           cum->intoffset = 0;
7881           cum->floats_in_gpr = 0;
7882           rs6000_darwin64_record_arg_advance_recurse (cum, type, 0);
7883           rs6000_darwin64_record_arg_advance_flush (cum,
7884                                                     size * BITS_PER_UNIT, 1);
7885         }
7886           if (TARGET_DEBUG_ARG)
7887             {
7888               fprintf (stderr, "function_adv: words = %2d, align=%d, size=%d",
7889                        cum->words, TYPE_ALIGN (type), size);
7890               fprintf (stderr,
7891                    "nargs = %4d, proto = %d, mode = %4s (darwin64 abi)\n",
7892                        cum->nargs_prototype, cum->prototype,
7893                        GET_MODE_NAME (mode));
7894             }
7895     }
7896   else if (DEFAULT_ABI == ABI_V4)
7897     {
7898       if (TARGET_HARD_FLOAT && TARGET_FPRS
7899           && ((TARGET_SINGLE_FLOAT && mode == SFmode)
7900               || (TARGET_DOUBLE_FLOAT && mode == DFmode)
7901               || (mode == TFmode && !TARGET_IEEEQUAD)
7902               || mode == SDmode || mode == DDmode || mode == TDmode))
7903         {
7904           /* _Decimal128 must use an even/odd register pair.  This assumes
7905              that the register number is odd when fregno is odd.  */
7906           if (mode == TDmode && (cum->fregno % 2) == 1)
7907             cum->fregno++;
7908
7909           if (cum->fregno + (mode == TFmode || mode == TDmode ? 1 : 0)
7910               <= FP_ARG_V4_MAX_REG)
7911             cum->fregno += (GET_MODE_SIZE (mode) + 7) >> 3;
7912           else
7913             {
7914               cum->fregno = FP_ARG_V4_MAX_REG + 1;
7915               if (mode == DFmode || mode == TFmode
7916                   || mode == DDmode || mode == TDmode)
7917                 cum->words += cum->words & 1;
7918               cum->words += rs6000_arg_size (mode, type);
7919             }
7920         }
7921       else
7922         {
7923           int n_words = rs6000_arg_size (mode, type);
7924           int gregno = cum->sysv_gregno;
7925
7926           /* Long long and SPE vectors are put in (r3,r4), (r5,r6),
7927              (r7,r8) or (r9,r10).  As does any other 2 word item such
7928              as complex int due to a historical mistake.  */
7929           if (n_words == 2)
7930             gregno += (1 - gregno) & 1;
7931
7932           /* Multi-reg args are not split between registers and stack.  */
7933           if (gregno + n_words - 1 > GP_ARG_MAX_REG)
7934             {
7935               /* Long long and SPE vectors are aligned on the stack.
7936                  So are other 2 word items such as complex int due to
7937                  a historical mistake.  */
7938               if (n_words == 2)
7939                 cum->words += cum->words & 1;
7940               cum->words += n_words;
7941             }
7942
7943           /* Note: continuing to accumulate gregno past when we've started
7944              spilling to the stack indicates the fact that we've started
7945              spilling to the stack to expand_builtin_saveregs.  */
7946           cum->sysv_gregno = gregno + n_words;
7947         }
7948
7949       if (TARGET_DEBUG_ARG)
7950         {
7951           fprintf (stderr, "function_adv: words = %2d, fregno = %2d, ",
7952                    cum->words, cum->fregno);
7953           fprintf (stderr, "gregno = %2d, nargs = %4d, proto = %d, ",
7954                    cum->sysv_gregno, cum->nargs_prototype, cum->prototype);
7955           fprintf (stderr, "mode = %4s, named = %d\n",
7956                    GET_MODE_NAME (mode), named);
7957         }
7958     }
7959   else
7960     {
7961       int n_words = rs6000_arg_size (mode, type);
7962       int start_words = cum->words;
7963       int align_words = rs6000_parm_start (mode, type, start_words);
7964
7965       cum->words = align_words + n_words;
7966
7967       if (SCALAR_FLOAT_MODE_P (mode)
7968           && TARGET_HARD_FLOAT && TARGET_FPRS)
7969         {
7970           /* _Decimal128 must be passed in an even/odd float register pair.
7971              This assumes that the register number is odd when fregno is
7972              odd.  */
7973           if (mode == TDmode && (cum->fregno % 2) == 1)
7974             cum->fregno++;
7975           cum->fregno += (GET_MODE_SIZE (mode) + 7) >> 3;
7976         }
7977
7978       if (TARGET_DEBUG_ARG)
7979         {
7980           fprintf (stderr, "function_adv: words = %2d, fregno = %2d, ",
7981                    cum->words, cum->fregno);
7982           fprintf (stderr, "nargs = %4d, proto = %d, mode = %4s, ",
7983                    cum->nargs_prototype, cum->prototype, GET_MODE_NAME (mode));
7984           fprintf (stderr, "named = %d, align = %d, depth = %d\n",
7985                    named, align_words - start_words, depth);
7986         }
7987     }
7988 }
7989
7990 static void
7991 rs6000_function_arg_advance (cumulative_args_t cum, enum machine_mode mode,
7992                              const_tree type, bool named)
7993 {
7994   rs6000_function_arg_advance_1 (get_cumulative_args (cum), mode, type, named,
7995                                  0);
7996 }
7997
7998 static rtx
7999 spe_build_register_parallel (enum machine_mode mode, int gregno)
8000 {
8001   rtx r1, r3, r5, r7;
8002
8003   switch (mode)
8004     {
8005     case DFmode:
8006       r1 = gen_rtx_REG (DImode, gregno);
8007       r1 = gen_rtx_EXPR_LIST (VOIDmode, r1, const0_rtx);
8008       return gen_rtx_PARALLEL (mode, gen_rtvec (1, r1));
8009
8010     case DCmode:
8011     case TFmode:
8012       r1 = gen_rtx_REG (DImode, gregno);
8013       r1 = gen_rtx_EXPR_LIST (VOIDmode, r1, const0_rtx);
8014       r3 = gen_rtx_REG (DImode, gregno + 2);
8015       r3 = gen_rtx_EXPR_LIST (VOIDmode, r3, GEN_INT (8));
8016       return gen_rtx_PARALLEL (mode, gen_rtvec (2, r1, r3));
8017
8018     case TCmode:
8019       r1 = gen_rtx_REG (DImode, gregno);
8020       r1 = gen_rtx_EXPR_LIST (VOIDmode, r1, const0_rtx);
8021       r3 = gen_rtx_REG (DImode, gregno + 2);
8022       r3 = gen_rtx_EXPR_LIST (VOIDmode, r3, GEN_INT (8));
8023       r5 = gen_rtx_REG (DImode, gregno + 4);
8024       r5 = gen_rtx_EXPR_LIST (VOIDmode, r5, GEN_INT (16));
8025       r7 = gen_rtx_REG (DImode, gregno + 6);
8026       r7 = gen_rtx_EXPR_LIST (VOIDmode, r7, GEN_INT (24));
8027       return gen_rtx_PARALLEL (mode, gen_rtvec (4, r1, r3, r5, r7));
8028
8029     default:
8030       gcc_unreachable ();
8031     }
8032 }
8033
8034 /* Determine where to put a SIMD argument on the SPE.  */
8035 static rtx
8036 rs6000_spe_function_arg (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
8037                          const_tree type)
8038 {
8039   int gregno = cum->sysv_gregno;
8040
8041   /* On E500 v2, double arithmetic is done on the full 64-bit GPR, but
8042      are passed and returned in a pair of GPRs for ABI compatibility.  */
8043   if (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode
8044                              || mode == DCmode || mode == TCmode))
8045     {
8046       int n_words = rs6000_arg_size (mode, type);
8047
8048       /* Doubles go in an odd/even register pair (r5/r6, etc).  */
8049       if (mode == DFmode)
8050         gregno += (1 - gregno) & 1;
8051
8052       /* Multi-reg args are not split between registers and stack.  */
8053       if (gregno + n_words - 1 > GP_ARG_MAX_REG)
8054         return NULL_RTX;
8055
8056       return spe_build_register_parallel (mode, gregno);
8057     }
8058   if (cum->stdarg)
8059     {
8060       int n_words = rs6000_arg_size (mode, type);
8061
8062       /* SPE vectors are put in odd registers.  */
8063       if (n_words == 2 && (gregno & 1) == 0)
8064         gregno += 1;
8065
8066       if (gregno + n_words - 1 <= GP_ARG_MAX_REG)
8067         {
8068           rtx r1, r2;
8069           enum machine_mode m = SImode;
8070
8071           r1 = gen_rtx_REG (m, gregno);
8072           r1 = gen_rtx_EXPR_LIST (m, r1, const0_rtx);
8073           r2 = gen_rtx_REG (m, gregno + 1);
8074           r2 = gen_rtx_EXPR_LIST (m, r2, GEN_INT (4));
8075           return gen_rtx_PARALLEL (mode, gen_rtvec (2, r1, r2));
8076         }
8077       else
8078         return NULL_RTX;
8079     }
8080   else
8081     {
8082       if (gregno <= GP_ARG_MAX_REG)
8083         return gen_rtx_REG (mode, gregno);
8084       else
8085         return NULL_RTX;
8086     }
8087 }
8088
8089 /* A subroutine of rs6000_darwin64_record_arg.  Assign the bits of the
8090    structure between cum->intoffset and bitpos to integer registers.  */
8091
8092 static void
8093 rs6000_darwin64_record_arg_flush (CUMULATIVE_ARGS *cum,
8094                                   HOST_WIDE_INT bitpos, rtx rvec[], int *k)
8095 {
8096   enum machine_mode mode;
8097   unsigned int regno;
8098   unsigned int startbit, endbit;
8099   int this_regno, intregs, intoffset;
8100   rtx reg;
8101
8102   if (cum->intoffset == -1)
8103     return;
8104
8105   intoffset = cum->intoffset;
8106   cum->intoffset = -1;
8107
8108   /* If this is the trailing part of a word, try to only load that
8109      much into the register.  Otherwise load the whole register.  Note
8110      that in the latter case we may pick up unwanted bits.  It's not a
8111      problem at the moment but may wish to revisit.  */
8112
8113   if (intoffset % BITS_PER_WORD != 0)
8114     {
8115       mode = mode_for_size (BITS_PER_WORD - intoffset % BITS_PER_WORD,
8116                           MODE_INT, 0);
8117       if (mode == BLKmode)
8118         {
8119           /* We couldn't find an appropriate mode, which happens,
8120              e.g., in packed structs when there are 3 bytes to load.
8121              Back intoffset back to the beginning of the word in this
8122              case.  */
8123          intoffset = intoffset & -BITS_PER_WORD;
8124          mode = word_mode;
8125         }
8126     }
8127   else
8128     mode = word_mode;
8129
8130   startbit = intoffset & -BITS_PER_WORD;
8131   endbit = (bitpos + BITS_PER_WORD - 1) & -BITS_PER_WORD;
8132   intregs = (endbit - startbit) / BITS_PER_WORD;
8133   this_regno = cum->words + intoffset / BITS_PER_WORD;
8134
8135   if (intregs > 0 && intregs > GP_ARG_NUM_REG - this_regno)
8136     cum->use_stack = 1;
8137
8138   intregs = MIN (intregs, GP_ARG_NUM_REG - this_regno);
8139   if (intregs <= 0)
8140     return;
8141
8142   intoffset /= BITS_PER_UNIT;
8143   do
8144     {
8145       regno = GP_ARG_MIN_REG + this_regno;
8146       reg = gen_rtx_REG (mode, regno);
8147       rvec[(*k)++] =
8148         gen_rtx_EXPR_LIST (VOIDmode, reg, GEN_INT (intoffset));
8149
8150       this_regno += 1;
8151       intoffset = (intoffset | (UNITS_PER_WORD-1)) + 1;
8152       mode = word_mode;
8153       intregs -= 1;
8154     }
8155   while (intregs > 0);
8156 }
8157
8158 /* Recursive workhorse for the following.  */
8159
8160 static void
8161 rs6000_darwin64_record_arg_recurse (CUMULATIVE_ARGS *cum, const_tree type,
8162                                     HOST_WIDE_INT startbitpos, rtx rvec[],
8163                                     int *k)
8164 {
8165   tree f;
8166
8167   for (f = TYPE_FIELDS (type); f ; f = DECL_CHAIN (f))
8168     if (TREE_CODE (f) == FIELD_DECL)
8169       {
8170         HOST_WIDE_INT bitpos = startbitpos;
8171         tree ftype = TREE_TYPE (f);
8172         enum machine_mode mode;
8173         if (ftype == error_mark_node)
8174           continue;
8175         mode = TYPE_MODE (ftype);
8176
8177         if (DECL_SIZE (f) != 0
8178             && host_integerp (bit_position (f), 1))
8179           bitpos += int_bit_position (f);
8180
8181         /* ??? FIXME: else assume zero offset.  */
8182
8183         if (TREE_CODE (ftype) == RECORD_TYPE)
8184           rs6000_darwin64_record_arg_recurse (cum, ftype, bitpos, rvec, k);
8185         else if (cum->named && USE_FP_FOR_ARG_P (cum, mode, ftype))
8186           {
8187             unsigned n_fpreg = (GET_MODE_SIZE (mode) + 7) >> 3;
8188 #if 0
8189             switch (mode)
8190               {
8191               case SCmode: mode = SFmode; break;
8192               case DCmode: mode = DFmode; break;
8193               case TCmode: mode = TFmode; break;
8194               default: break;
8195               }
8196 #endif
8197             rs6000_darwin64_record_arg_flush (cum, bitpos, rvec, k);
8198             if (cum->fregno + n_fpreg > FP_ARG_MAX_REG + 1)
8199               {
8200                 gcc_assert (cum->fregno == FP_ARG_MAX_REG
8201                             && (mode == TFmode || mode == TDmode));
8202                 /* Long double or _Decimal128 split over regs and memory.  */
8203                 mode = DECIMAL_FLOAT_MODE_P (mode) ? DDmode : DFmode;
8204                 cum->use_stack=1;
8205               }
8206             rvec[(*k)++]
8207               = gen_rtx_EXPR_LIST (VOIDmode,
8208                                    gen_rtx_REG (mode, cum->fregno++),
8209                                    GEN_INT (bitpos / BITS_PER_UNIT));
8210             if (mode == TFmode || mode == TDmode)
8211               cum->fregno++;
8212           }
8213         else if (cum->named && USE_ALTIVEC_FOR_ARG_P (cum, mode, ftype, 1))
8214           {
8215             rs6000_darwin64_record_arg_flush (cum, bitpos, rvec, k);
8216             rvec[(*k)++]
8217               = gen_rtx_EXPR_LIST (VOIDmode,
8218                                    gen_rtx_REG (mode, cum->vregno++),
8219                                    GEN_INT (bitpos / BITS_PER_UNIT));
8220           }
8221         else if (cum->intoffset == -1)
8222           cum->intoffset = bitpos;
8223       }
8224 }
8225
8226 /* For the darwin64 ABI, we want to construct a PARALLEL consisting of
8227    the register(s) to be used for each field and subfield of a struct
8228    being passed by value, along with the offset of where the
8229    register's value may be found in the block.  FP fields go in FP
8230    register, vector fields go in vector registers, and everything
8231    else goes in int registers, packed as in memory.
8232
8233    This code is also used for function return values.  RETVAL indicates
8234    whether this is the case.
8235
8236    Much of this is taken from the SPARC V9 port, which has a similar
8237    calling convention.  */
8238
8239 static rtx
8240 rs6000_darwin64_record_arg (CUMULATIVE_ARGS *orig_cum, const_tree type,
8241                             bool named, bool retval)
8242 {
8243   rtx rvec[FIRST_PSEUDO_REGISTER];
8244   int k = 1, kbase = 1;
8245   HOST_WIDE_INT typesize = int_size_in_bytes (type);
8246   /* This is a copy; modifications are not visible to our caller.  */
8247   CUMULATIVE_ARGS copy_cum = *orig_cum;
8248   CUMULATIVE_ARGS *cum = &copy_cum;
8249
8250   /* Pad to 16 byte boundary if needed.  */
8251   if (!retval && TYPE_ALIGN (type) >= 2 * BITS_PER_WORD
8252       && (cum->words % 2) != 0)
8253     cum->words++;
8254
8255   cum->intoffset = 0;
8256   cum->use_stack = 0;
8257   cum->named = named;
8258
8259   /* Put entries into rvec[] for individual FP and vector fields, and
8260      for the chunks of memory that go in int regs.  Note we start at
8261      element 1; 0 is reserved for an indication of using memory, and
8262      may or may not be filled in below. */
8263   rs6000_darwin64_record_arg_recurse (cum, type, /* startbit pos= */ 0, rvec, &k);
8264   rs6000_darwin64_record_arg_flush (cum, typesize * BITS_PER_UNIT, rvec, &k);
8265
8266   /* If any part of the struct went on the stack put all of it there.
8267      This hack is because the generic code for
8268      FUNCTION_ARG_PARTIAL_NREGS cannot handle cases where the register
8269      parts of the struct are not at the beginning.  */
8270   if (cum->use_stack)
8271     {
8272       if (retval)
8273         return NULL_RTX;    /* doesn't go in registers at all */
8274       kbase = 0;
8275       rvec[0] = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
8276     }
8277   if (k > 1 || cum->use_stack)
8278     return gen_rtx_PARALLEL (BLKmode, gen_rtvec_v (k - kbase, &rvec[kbase]));
8279   else
8280     return NULL_RTX;
8281 }
8282
8283 /* Determine where to place an argument in 64-bit mode with 32-bit ABI.  */
8284
8285 static rtx
8286 rs6000_mixed_function_arg (enum machine_mode mode, const_tree type,
8287                            int align_words)
8288 {
8289   int n_units;
8290   int i, k;
8291   rtx rvec[GP_ARG_NUM_REG + 1];
8292
8293   if (align_words >= GP_ARG_NUM_REG)
8294     return NULL_RTX;
8295
8296   n_units = rs6000_arg_size (mode, type);
8297
8298   /* Optimize the simple case where the arg fits in one gpr, except in
8299      the case of BLKmode due to assign_parms assuming that registers are
8300      BITS_PER_WORD wide.  */
8301   if (n_units == 0
8302       || (n_units == 1 && mode != BLKmode))
8303     return gen_rtx_REG (mode, GP_ARG_MIN_REG + align_words);
8304
8305   k = 0;
8306   if (align_words + n_units > GP_ARG_NUM_REG)
8307     /* Not all of the arg fits in gprs.  Say that it goes in memory too,
8308        using a magic NULL_RTX component.
8309        This is not strictly correct.  Only some of the arg belongs in
8310        memory, not all of it.  However, the normal scheme using
8311        function_arg_partial_nregs can result in unusual subregs, eg.
8312        (subreg:SI (reg:DF) 4), which are not handled well.  The code to
8313        store the whole arg to memory is often more efficient than code
8314        to store pieces, and we know that space is available in the right
8315        place for the whole arg.  */
8316     rvec[k++] = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
8317
8318   i = 0;
8319   do
8320     {
8321       rtx r = gen_rtx_REG (SImode, GP_ARG_MIN_REG + align_words);
8322       rtx off = GEN_INT (i++ * 4);
8323       rvec[k++] = gen_rtx_EXPR_LIST (VOIDmode, r, off);
8324     }
8325   while (++align_words < GP_ARG_NUM_REG && --n_units != 0);
8326
8327   return gen_rtx_PARALLEL (mode, gen_rtvec_v (k, rvec));
8328 }
8329
8330 /* Determine where to put an argument to a function.
8331    Value is zero to push the argument on the stack,
8332    or a hard register in which to store the argument.
8333
8334    MODE is the argument's machine mode.
8335    TYPE is the data type of the argument (as a tree).
8336     This is null for libcalls where that information may
8337     not be available.
8338    CUM is a variable of type CUMULATIVE_ARGS which gives info about
8339     the preceding args and about the function being called.  It is
8340     not modified in this routine.
8341    NAMED is nonzero if this argument is a named parameter
8342     (otherwise it is an extra parameter matching an ellipsis).
8343
8344    On RS/6000 the first eight words of non-FP are normally in registers
8345    and the rest are pushed.  Under AIX, the first 13 FP args are in registers.
8346    Under V.4, the first 8 FP args are in registers.
8347
8348    If this is floating-point and no prototype is specified, we use
8349    both an FP and integer register (or possibly FP reg and stack).  Library
8350    functions (when CALL_LIBCALL is set) always have the proper types for args,
8351    so we can pass the FP value just in one register.  emit_library_function
8352    doesn't support PARALLEL anyway.
8353
8354    Note that for args passed by reference, function_arg will be called
8355    with MODE and TYPE set to that of the pointer to the arg, not the arg
8356    itself.  */
8357
8358 static rtx
8359 rs6000_function_arg (cumulative_args_t cum_v, enum machine_mode mode,
8360                      const_tree type, bool named)
8361 {
8362   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
8363   enum rs6000_abi abi = DEFAULT_ABI;
8364
8365   /* Return a marker to indicate whether CR1 needs to set or clear the
8366      bit that V.4 uses to say fp args were passed in registers.
8367      Assume that we don't need the marker for software floating point,
8368      or compiler generated library calls.  */
8369   if (mode == VOIDmode)
8370     {
8371       if (abi == ABI_V4
8372           && (cum->call_cookie & CALL_LIBCALL) == 0
8373           && (cum->stdarg
8374               || (cum->nargs_prototype < 0
8375                   && (cum->prototype || TARGET_NO_PROTOTYPE))))
8376         {
8377           /* For the SPE, we need to crxor CR6 always.  */
8378           if (TARGET_SPE_ABI)
8379             return GEN_INT (cum->call_cookie | CALL_V4_SET_FP_ARGS);
8380           else if (TARGET_HARD_FLOAT && TARGET_FPRS)
8381             return GEN_INT (cum->call_cookie
8382                             | ((cum->fregno == FP_ARG_MIN_REG)
8383                                ? CALL_V4_SET_FP_ARGS
8384                                : CALL_V4_CLEAR_FP_ARGS));
8385         }
8386
8387       return GEN_INT (cum->call_cookie & ~CALL_LIBCALL);
8388     }
8389
8390   if (TARGET_MACHO && rs6000_darwin64_struct_check_p (mode, type))
8391     {
8392       rtx rslt = rs6000_darwin64_record_arg (cum, type, named, /*retval= */false);
8393       if (rslt != NULL_RTX)
8394         return rslt;
8395       /* Else fall through to usual handling.  */
8396     }
8397
8398   if (USE_ALTIVEC_FOR_ARG_P (cum, mode, type, named))
8399     if (TARGET_64BIT && ! cum->prototype)
8400       {
8401         /* Vector parameters get passed in vector register
8402            and also in GPRs or memory, in absence of prototype.  */
8403         int align_words;
8404         rtx slot;
8405         align_words = (cum->words + 1) & ~1;
8406
8407         if (align_words >= GP_ARG_NUM_REG)
8408           {
8409             slot = NULL_RTX;
8410           }
8411         else
8412           {
8413             slot = gen_rtx_REG (mode, GP_ARG_MIN_REG + align_words);
8414           }
8415         return gen_rtx_PARALLEL (mode,
8416                  gen_rtvec (2,
8417                             gen_rtx_EXPR_LIST (VOIDmode,
8418                                                slot, const0_rtx),
8419                             gen_rtx_EXPR_LIST (VOIDmode,
8420                                                gen_rtx_REG (mode, cum->vregno),
8421                                                const0_rtx)));
8422       }
8423     else
8424       return gen_rtx_REG (mode, cum->vregno);
8425   else if (TARGET_ALTIVEC_ABI
8426            && (ALTIVEC_OR_VSX_VECTOR_MODE (mode)
8427                || (type && TREE_CODE (type) == VECTOR_TYPE
8428                    && int_size_in_bytes (type) == 16)))
8429     {
8430       if (named || abi == ABI_V4)
8431         return NULL_RTX;
8432       else
8433         {
8434           /* Vector parameters to varargs functions under AIX or Darwin
8435              get passed in memory and possibly also in GPRs.  */
8436           int align, align_words, n_words;
8437           enum machine_mode part_mode;
8438
8439           /* Vector parameters must be 16-byte aligned.  This places them at
8440              2 mod 4 in terms of words in 32-bit mode, since the parameter
8441              save area starts at offset 24 from the stack.  In 64-bit mode,
8442              they just have to start on an even word, since the parameter
8443              save area is 16-byte aligned.  */
8444           if (TARGET_32BIT)
8445             align = (2 - cum->words) & 3;
8446           else
8447             align = cum->words & 1;
8448           align_words = cum->words + align;
8449
8450           /* Out of registers?  Memory, then.  */
8451           if (align_words >= GP_ARG_NUM_REG)
8452             return NULL_RTX;
8453
8454           if (TARGET_32BIT && TARGET_POWERPC64)
8455             return rs6000_mixed_function_arg (mode, type, align_words);
8456
8457           /* The vector value goes in GPRs.  Only the part of the
8458              value in GPRs is reported here.  */
8459           part_mode = mode;
8460           n_words = rs6000_arg_size (mode, type);
8461           if (align_words + n_words > GP_ARG_NUM_REG)
8462             /* Fortunately, there are only two possibilities, the value
8463                is either wholly in GPRs or half in GPRs and half not.  */
8464             part_mode = DImode;
8465
8466           return gen_rtx_REG (part_mode, GP_ARG_MIN_REG + align_words);
8467         }
8468     }
8469   else if (TARGET_SPE_ABI && TARGET_SPE
8470            && (SPE_VECTOR_MODE (mode)
8471                || (TARGET_E500_DOUBLE && (mode == DFmode
8472                                           || mode == DCmode
8473                                           || mode == TFmode
8474                                           || mode == TCmode))))
8475     return rs6000_spe_function_arg (cum, mode, type);
8476
8477   else if (abi == ABI_V4)
8478     {
8479       if (TARGET_HARD_FLOAT && TARGET_FPRS
8480           && ((TARGET_SINGLE_FLOAT && mode == SFmode)
8481               || (TARGET_DOUBLE_FLOAT && mode == DFmode)
8482               || (mode == TFmode && !TARGET_IEEEQUAD)
8483               || mode == SDmode || mode == DDmode || mode == TDmode))
8484         {
8485           /* _Decimal128 must use an even/odd register pair.  This assumes
8486              that the register number is odd when fregno is odd.  */
8487           if (mode == TDmode && (cum->fregno % 2) == 1)
8488             cum->fregno++;
8489
8490           if (cum->fregno + (mode == TFmode || mode == TDmode ? 1 : 0)
8491               <= FP_ARG_V4_MAX_REG)
8492             return gen_rtx_REG (mode, cum->fregno);
8493           else
8494             return NULL_RTX;
8495         }
8496       else
8497         {
8498           int n_words = rs6000_arg_size (mode, type);
8499           int gregno = cum->sysv_gregno;
8500
8501           /* Long long and SPE vectors are put in (r3,r4), (r5,r6),
8502              (r7,r8) or (r9,r10).  As does any other 2 word item such
8503              as complex int due to a historical mistake.  */
8504           if (n_words == 2)
8505             gregno += (1 - gregno) & 1;
8506
8507           /* Multi-reg args are not split between registers and stack.  */
8508           if (gregno + n_words - 1 > GP_ARG_MAX_REG)
8509             return NULL_RTX;
8510
8511           if (TARGET_32BIT && TARGET_POWERPC64)
8512             return rs6000_mixed_function_arg (mode, type,
8513                                               gregno - GP_ARG_MIN_REG);
8514           return gen_rtx_REG (mode, gregno);
8515         }
8516     }
8517   else
8518     {
8519       int align_words = rs6000_parm_start (mode, type, cum->words);
8520
8521       /* _Decimal128 must be passed in an even/odd float register pair.
8522          This assumes that the register number is odd when fregno is odd.  */
8523       if (mode == TDmode && (cum->fregno % 2) == 1)
8524         cum->fregno++;
8525
8526       if (USE_FP_FOR_ARG_P (cum, mode, type))
8527         {
8528           rtx rvec[GP_ARG_NUM_REG + 1];
8529           rtx r;
8530           int k;
8531           bool needs_psave;
8532           enum machine_mode fmode = mode;
8533           unsigned long n_fpreg = (GET_MODE_SIZE (mode) + 7) >> 3;
8534
8535           if (cum->fregno + n_fpreg > FP_ARG_MAX_REG + 1)
8536             {
8537               /* Currently, we only ever need one reg here because complex
8538                  doubles are split.  */
8539               gcc_assert (cum->fregno == FP_ARG_MAX_REG
8540                           && (fmode == TFmode || fmode == TDmode));
8541
8542               /* Long double or _Decimal128 split over regs and memory.  */
8543               fmode = DECIMAL_FLOAT_MODE_P (fmode) ? DDmode : DFmode;
8544             }
8545
8546           /* Do we also need to pass this arg in the parameter save
8547              area?  */
8548           needs_psave = (type
8549                          && (cum->nargs_prototype <= 0
8550                              || (DEFAULT_ABI == ABI_AIX
8551                                  && TARGET_XL_COMPAT
8552                                  && align_words >= GP_ARG_NUM_REG)));
8553
8554           if (!needs_psave && mode == fmode)
8555             return gen_rtx_REG (fmode, cum->fregno);
8556
8557           k = 0;
8558           if (needs_psave)
8559             {
8560               /* Describe the part that goes in gprs or the stack.
8561                  This piece must come first, before the fprs.  */
8562               if (align_words < GP_ARG_NUM_REG)
8563                 {
8564                   unsigned long n_words = rs6000_arg_size (mode, type);
8565
8566                   if (align_words + n_words > GP_ARG_NUM_REG
8567                       || (TARGET_32BIT && TARGET_POWERPC64))
8568                     {
8569                       /* If this is partially on the stack, then we only
8570                          include the portion actually in registers here.  */
8571                       enum machine_mode rmode = TARGET_32BIT ? SImode : DImode;
8572                       rtx off;
8573                       int i = 0;
8574                       if (align_words + n_words > GP_ARG_NUM_REG)
8575                         /* Not all of the arg fits in gprs.  Say that it
8576                            goes in memory too, using a magic NULL_RTX
8577                            component.  Also see comment in
8578                            rs6000_mixed_function_arg for why the normal
8579                            function_arg_partial_nregs scheme doesn't work
8580                            in this case. */
8581                         rvec[k++] = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX,
8582                                                        const0_rtx);
8583                       do
8584                         {
8585                           r = gen_rtx_REG (rmode,
8586                                            GP_ARG_MIN_REG + align_words);
8587                           off = GEN_INT (i++ * GET_MODE_SIZE (rmode));
8588                           rvec[k++] = gen_rtx_EXPR_LIST (VOIDmode, r, off);
8589                         }
8590                       while (++align_words < GP_ARG_NUM_REG && --n_words != 0);
8591                     }
8592                   else
8593                     {
8594                       /* The whole arg fits in gprs.  */
8595                       r = gen_rtx_REG (mode, GP_ARG_MIN_REG + align_words);
8596                       rvec[k++] = gen_rtx_EXPR_LIST (VOIDmode, r, const0_rtx);
8597                     }
8598                 }
8599               else
8600                 /* It's entirely in memory.  */
8601                 rvec[k++] = gen_rtx_EXPR_LIST (VOIDmode, NULL_RTX, const0_rtx);
8602             }
8603
8604           /* Describe where this piece goes in the fprs.  */
8605           r = gen_rtx_REG (fmode, cum->fregno);
8606           rvec[k++] = gen_rtx_EXPR_LIST (VOIDmode, r, const0_rtx);
8607
8608           return gen_rtx_PARALLEL (mode, gen_rtvec_v (k, rvec));
8609         }
8610       else if (align_words < GP_ARG_NUM_REG)
8611         {
8612           if (TARGET_32BIT && TARGET_POWERPC64)
8613             return rs6000_mixed_function_arg (mode, type, align_words);
8614
8615           if (mode == BLKmode)
8616             mode = Pmode;
8617
8618           return gen_rtx_REG (mode, GP_ARG_MIN_REG + align_words);
8619         }
8620       else
8621         return NULL_RTX;
8622     }
8623 }
8624 \f
8625 /* For an arg passed partly in registers and partly in memory, this is
8626    the number of bytes passed in registers.  For args passed entirely in
8627    registers or entirely in memory, zero.  When an arg is described by a
8628    PARALLEL, perhaps using more than one register type, this function
8629    returns the number of bytes used by the first element of the PARALLEL.  */
8630
8631 static int
8632 rs6000_arg_partial_bytes (cumulative_args_t cum_v, enum machine_mode mode,
8633                           tree type, bool named)
8634 {
8635   CUMULATIVE_ARGS *cum = get_cumulative_args (cum_v);
8636   int ret = 0;
8637   int align_words;
8638
8639   if (DEFAULT_ABI == ABI_V4)
8640     return 0;
8641
8642   if (USE_ALTIVEC_FOR_ARG_P (cum, mode, type, named)
8643       && cum->nargs_prototype >= 0)
8644     return 0;
8645
8646   /* In this complicated case we just disable the partial_nregs code.  */
8647   if (TARGET_MACHO && rs6000_darwin64_struct_check_p (mode, type))
8648     return 0;
8649
8650   align_words = rs6000_parm_start (mode, type, cum->words);
8651
8652   if (USE_FP_FOR_ARG_P (cum, mode, type))
8653     {
8654       /* If we are passing this arg in the fixed parameter save area
8655          (gprs or memory) as well as fprs, then this function should
8656          return the number of partial bytes passed in the parameter
8657          save area rather than partial bytes passed in fprs.  */
8658       if (type
8659           && (cum->nargs_prototype <= 0
8660               || (DEFAULT_ABI == ABI_AIX
8661                   && TARGET_XL_COMPAT
8662                   && align_words >= GP_ARG_NUM_REG)))
8663         return 0;
8664       else if (cum->fregno + ((GET_MODE_SIZE (mode) + 7) >> 3)
8665                > FP_ARG_MAX_REG + 1)
8666         ret = (FP_ARG_MAX_REG + 1 - cum->fregno) * 8;
8667       else if (cum->nargs_prototype >= 0)
8668         return 0;
8669     }
8670
8671   if (align_words < GP_ARG_NUM_REG
8672       && GP_ARG_NUM_REG < align_words + rs6000_arg_size (mode, type))
8673     ret = (GP_ARG_NUM_REG - align_words) * (TARGET_32BIT ? 4 : 8);
8674
8675   if (ret != 0 && TARGET_DEBUG_ARG)
8676     fprintf (stderr, "rs6000_arg_partial_bytes: %d\n", ret);
8677
8678   return ret;
8679 }
8680 \f
8681 /* A C expression that indicates when an argument must be passed by
8682    reference.  If nonzero for an argument, a copy of that argument is
8683    made in memory and a pointer to the argument is passed instead of
8684    the argument itself.  The pointer is passed in whatever way is
8685    appropriate for passing a pointer to that type.
8686
8687    Under V.4, aggregates and long double are passed by reference.
8688
8689    As an extension to all 32-bit ABIs, AltiVec vectors are passed by
8690    reference unless the AltiVec vector extension ABI is in force.
8691
8692    As an extension to all ABIs, variable sized types are passed by
8693    reference.  */
8694
8695 static bool
8696 rs6000_pass_by_reference (cumulative_args_t cum ATTRIBUTE_UNUSED,
8697                           enum machine_mode mode, const_tree type,
8698                           bool named ATTRIBUTE_UNUSED)
8699 {
8700   if (DEFAULT_ABI == ABI_V4 && TARGET_IEEEQUAD && mode == TFmode)
8701     {
8702       if (TARGET_DEBUG_ARG)
8703         fprintf (stderr, "function_arg_pass_by_reference: V4 long double\n");
8704       return 1;
8705     }
8706
8707   if (!type)
8708     return 0;
8709
8710   if (DEFAULT_ABI == ABI_V4 && AGGREGATE_TYPE_P (type))
8711     {
8712       if (TARGET_DEBUG_ARG)
8713         fprintf (stderr, "function_arg_pass_by_reference: V4 aggregate\n");
8714       return 1;
8715     }
8716
8717   if (int_size_in_bytes (type) < 0)
8718     {
8719       if (TARGET_DEBUG_ARG)
8720         fprintf (stderr, "function_arg_pass_by_reference: variable size\n");
8721       return 1;
8722     }
8723
8724   /* Allow -maltivec -mabi=no-altivec without warning.  Altivec vector
8725      modes only exist for GCC vector types if -maltivec.  */
8726   if (TARGET_32BIT && !TARGET_ALTIVEC_ABI && ALTIVEC_VECTOR_MODE (mode))
8727     {
8728       if (TARGET_DEBUG_ARG)
8729         fprintf (stderr, "function_arg_pass_by_reference: AltiVec\n");
8730       return 1;
8731     }
8732
8733   /* Pass synthetic vectors in memory.  */
8734   if (TREE_CODE (type) == VECTOR_TYPE
8735       && int_size_in_bytes (type) > (TARGET_ALTIVEC_ABI ? 16 : 8))
8736     {
8737       static bool warned_for_pass_big_vectors = false;
8738       if (TARGET_DEBUG_ARG)
8739         fprintf (stderr, "function_arg_pass_by_reference: synthetic vector\n");
8740       if (!warned_for_pass_big_vectors)
8741         {
8742           warning (0, "GCC vector passed by reference: "
8743                    "non-standard ABI extension with no compatibility guarantee");
8744           warned_for_pass_big_vectors = true;
8745         }
8746       return 1;
8747     }
8748
8749   return 0;
8750 }
8751
8752 static void
8753 rs6000_move_block_from_reg (int regno, rtx x, int nregs)
8754 {
8755   int i;
8756   enum machine_mode reg_mode = TARGET_32BIT ? SImode : DImode;
8757
8758   if (nregs == 0)
8759     return;
8760
8761   for (i = 0; i < nregs; i++)
8762     {
8763       rtx tem = adjust_address_nv (x, reg_mode, i * GET_MODE_SIZE (reg_mode));
8764       if (reload_completed)
8765         {
8766           if (! strict_memory_address_p (reg_mode, XEXP (tem, 0)))
8767             tem = NULL_RTX;
8768           else
8769             tem = simplify_gen_subreg (reg_mode, x, BLKmode,
8770                                        i * GET_MODE_SIZE (reg_mode));
8771         }
8772       else
8773         tem = replace_equiv_address (tem, XEXP (tem, 0));
8774
8775       gcc_assert (tem);
8776
8777       emit_move_insn (tem, gen_rtx_REG (reg_mode, regno + i));
8778     }
8779 }
8780 \f
8781 /* Perform any needed actions needed for a function that is receiving a
8782    variable number of arguments.
8783
8784    CUM is as above.
8785
8786    MODE and TYPE are the mode and type of the current parameter.
8787
8788    PRETEND_SIZE is a variable that should be set to the amount of stack
8789    that must be pushed by the prolog to pretend that our caller pushed
8790    it.
8791
8792    Normally, this macro will push all remaining incoming registers on the
8793    stack and set PRETEND_SIZE to the length of the registers pushed.  */
8794
8795 static void
8796 setup_incoming_varargs (cumulative_args_t cum, enum machine_mode mode,
8797                         tree type, int *pretend_size ATTRIBUTE_UNUSED,
8798                         int no_rtl)
8799 {
8800   CUMULATIVE_ARGS next_cum;
8801   int reg_size = TARGET_32BIT ? 4 : 8;
8802   rtx save_area = NULL_RTX, mem;
8803   int first_reg_offset;
8804   alias_set_type set;
8805
8806   /* Skip the last named argument.  */
8807   next_cum = *get_cumulative_args (cum);
8808   rs6000_function_arg_advance_1 (&next_cum, mode, type, true, 0);
8809
8810   if (DEFAULT_ABI == ABI_V4)
8811     {
8812       first_reg_offset = next_cum.sysv_gregno - GP_ARG_MIN_REG;
8813
8814       if (! no_rtl)
8815         {
8816           int gpr_reg_num = 0, gpr_size = 0, fpr_size = 0;
8817           HOST_WIDE_INT offset = 0;
8818
8819           /* Try to optimize the size of the varargs save area.
8820              The ABI requires that ap.reg_save_area is doubleword
8821              aligned, but we don't need to allocate space for all
8822              the bytes, only those to which we actually will save
8823              anything.  */
8824           if (cfun->va_list_gpr_size && first_reg_offset < GP_ARG_NUM_REG)
8825             gpr_reg_num = GP_ARG_NUM_REG - first_reg_offset;
8826           if (TARGET_HARD_FLOAT && TARGET_FPRS
8827               && next_cum.fregno <= FP_ARG_V4_MAX_REG
8828               && cfun->va_list_fpr_size)
8829             {
8830               if (gpr_reg_num)
8831                 fpr_size = (next_cum.fregno - FP_ARG_MIN_REG)
8832                            * UNITS_PER_FP_WORD;
8833               if (cfun->va_list_fpr_size
8834                   < FP_ARG_V4_MAX_REG + 1 - next_cum.fregno)
8835                 fpr_size += cfun->va_list_fpr_size * UNITS_PER_FP_WORD;
8836               else
8837                 fpr_size += (FP_ARG_V4_MAX_REG + 1 - next_cum.fregno)
8838                             * UNITS_PER_FP_WORD;
8839             }
8840           if (gpr_reg_num)
8841             {
8842               offset = -((first_reg_offset * reg_size) & ~7);
8843               if (!fpr_size && gpr_reg_num > cfun->va_list_gpr_size)
8844                 {
8845                   gpr_reg_num = cfun->va_list_gpr_size;
8846                   if (reg_size == 4 && (first_reg_offset & 1))
8847                     gpr_reg_num++;
8848                 }
8849               gpr_size = (gpr_reg_num * reg_size + 7) & ~7;
8850             }
8851           else if (fpr_size)
8852             offset = - (int) (next_cum.fregno - FP_ARG_MIN_REG)
8853                        * UNITS_PER_FP_WORD
8854                      - (int) (GP_ARG_NUM_REG * reg_size);
8855
8856           if (gpr_size + fpr_size)
8857             {
8858               rtx reg_save_area
8859                 = assign_stack_local (BLKmode, gpr_size + fpr_size, 64);
8860               gcc_assert (GET_CODE (reg_save_area) == MEM);
8861               reg_save_area = XEXP (reg_save_area, 0);
8862               if (GET_CODE (reg_save_area) == PLUS)
8863                 {
8864                   gcc_assert (XEXP (reg_save_area, 0)
8865                               == virtual_stack_vars_rtx);
8866                   gcc_assert (GET_CODE (XEXP (reg_save_area, 1)) == CONST_INT);
8867                   offset += INTVAL (XEXP (reg_save_area, 1));
8868                 }
8869               else
8870                 gcc_assert (reg_save_area == virtual_stack_vars_rtx);
8871             }
8872
8873           cfun->machine->varargs_save_offset = offset;
8874           save_area = plus_constant (virtual_stack_vars_rtx, offset);
8875         }
8876     }
8877   else
8878     {
8879       first_reg_offset = next_cum.words;
8880       save_area = virtual_incoming_args_rtx;
8881
8882       if (targetm.calls.must_pass_in_stack (mode, type))
8883         first_reg_offset += rs6000_arg_size (TYPE_MODE (type), type);
8884     }
8885
8886   set = get_varargs_alias_set ();
8887   if (! no_rtl && first_reg_offset < GP_ARG_NUM_REG
8888       && cfun->va_list_gpr_size)
8889     {
8890       int nregs = GP_ARG_NUM_REG - first_reg_offset;
8891
8892       if (va_list_gpr_counter_field)
8893         {
8894           /* V4 va_list_gpr_size counts number of registers needed.  */
8895           if (nregs > cfun->va_list_gpr_size)
8896             nregs = cfun->va_list_gpr_size;
8897         }
8898       else
8899         {
8900           /* char * va_list instead counts number of bytes needed.  */
8901           if (nregs > cfun->va_list_gpr_size / reg_size)
8902             nregs = cfun->va_list_gpr_size / reg_size;
8903         }
8904
8905       mem = gen_rtx_MEM (BLKmode,
8906                          plus_constant (save_area,
8907                                         first_reg_offset * reg_size));
8908       MEM_NOTRAP_P (mem) = 1;
8909       set_mem_alias_set (mem, set);
8910       set_mem_align (mem, BITS_PER_WORD);
8911
8912       rs6000_move_block_from_reg (GP_ARG_MIN_REG + first_reg_offset, mem,
8913                                   nregs);
8914     }
8915
8916   /* Save FP registers if needed.  */
8917   if (DEFAULT_ABI == ABI_V4
8918       && TARGET_HARD_FLOAT && TARGET_FPRS
8919       && ! no_rtl
8920       && next_cum.fregno <= FP_ARG_V4_MAX_REG
8921       && cfun->va_list_fpr_size)
8922     {
8923       int fregno = next_cum.fregno, nregs;
8924       rtx cr1 = gen_rtx_REG (CCmode, CR1_REGNO);
8925       rtx lab = gen_label_rtx ();
8926       int off = (GP_ARG_NUM_REG * reg_size) + ((fregno - FP_ARG_MIN_REG)
8927                                                * UNITS_PER_FP_WORD);
8928
8929       emit_jump_insn
8930         (gen_rtx_SET (VOIDmode,
8931                       pc_rtx,
8932                       gen_rtx_IF_THEN_ELSE (VOIDmode,
8933                                             gen_rtx_NE (VOIDmode, cr1,
8934                                                         const0_rtx),
8935                                             gen_rtx_LABEL_REF (VOIDmode, lab),
8936                                             pc_rtx)));
8937
8938       for (nregs = 0;
8939            fregno <= FP_ARG_V4_MAX_REG && nregs < cfun->va_list_fpr_size;
8940            fregno++, off += UNITS_PER_FP_WORD, nregs++)
8941         {
8942           mem = gen_rtx_MEM ((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
8943                               ? DFmode : SFmode,
8944                              plus_constant (save_area, off));
8945           MEM_NOTRAP_P (mem) = 1;
8946           set_mem_alias_set (mem, set);
8947           set_mem_align (mem, GET_MODE_ALIGNMENT (
8948                          (TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
8949                           ? DFmode : SFmode));
8950           emit_move_insn (mem, gen_rtx_REG (
8951                           (TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
8952                            ? DFmode : SFmode, fregno));
8953         }
8954
8955       emit_label (lab);
8956     }
8957 }
8958
8959 /* Create the va_list data type.  */
8960
8961 static tree
8962 rs6000_build_builtin_va_list (void)
8963 {
8964   tree f_gpr, f_fpr, f_res, f_ovf, f_sav, record, type_decl;
8965
8966   /* For AIX, prefer 'char *' because that's what the system
8967      header files like.  */
8968   if (DEFAULT_ABI != ABI_V4)
8969     return build_pointer_type (char_type_node);
8970
8971   record = (*lang_hooks.types.make_type) (RECORD_TYPE);
8972   type_decl = build_decl (BUILTINS_LOCATION, TYPE_DECL,
8973                           get_identifier ("__va_list_tag"), record);
8974
8975   f_gpr = build_decl (BUILTINS_LOCATION, FIELD_DECL, get_identifier ("gpr"),
8976                       unsigned_char_type_node);
8977   f_fpr = build_decl (BUILTINS_LOCATION, FIELD_DECL, get_identifier ("fpr"),
8978                       unsigned_char_type_node);
8979   /* Give the two bytes of padding a name, so that -Wpadded won't warn on
8980      every user file.  */
8981   f_res = build_decl (BUILTINS_LOCATION, FIELD_DECL,
8982                       get_identifier ("reserved"), short_unsigned_type_node);
8983   f_ovf = build_decl (BUILTINS_LOCATION, FIELD_DECL,
8984                       get_identifier ("overflow_arg_area"),
8985                       ptr_type_node);
8986   f_sav = build_decl (BUILTINS_LOCATION, FIELD_DECL,
8987                       get_identifier ("reg_save_area"),
8988                       ptr_type_node);
8989
8990   va_list_gpr_counter_field = f_gpr;
8991   va_list_fpr_counter_field = f_fpr;
8992
8993   DECL_FIELD_CONTEXT (f_gpr) = record;
8994   DECL_FIELD_CONTEXT (f_fpr) = record;
8995   DECL_FIELD_CONTEXT (f_res) = record;
8996   DECL_FIELD_CONTEXT (f_ovf) = record;
8997   DECL_FIELD_CONTEXT (f_sav) = record;
8998
8999   TYPE_STUB_DECL (record) = type_decl;
9000   TYPE_NAME (record) = type_decl;
9001   TYPE_FIELDS (record) = f_gpr;
9002   DECL_CHAIN (f_gpr) = f_fpr;
9003   DECL_CHAIN (f_fpr) = f_res;
9004   DECL_CHAIN (f_res) = f_ovf;
9005   DECL_CHAIN (f_ovf) = f_sav;
9006
9007   layout_type (record);
9008
9009   /* The correct type is an array type of one element.  */
9010   return build_array_type (record, build_index_type (size_zero_node));
9011 }
9012
9013 /* Implement va_start.  */
9014
9015 static void
9016 rs6000_va_start (tree valist, rtx nextarg)
9017 {
9018   HOST_WIDE_INT words, n_gpr, n_fpr;
9019   tree f_gpr, f_fpr, f_res, f_ovf, f_sav;
9020   tree gpr, fpr, ovf, sav, t;
9021
9022   /* Only SVR4 needs something special.  */
9023   if (DEFAULT_ABI != ABI_V4)
9024     {
9025       std_expand_builtin_va_start (valist, nextarg);
9026       return;
9027     }
9028
9029   f_gpr = TYPE_FIELDS (TREE_TYPE (va_list_type_node));
9030   f_fpr = DECL_CHAIN (f_gpr);
9031   f_res = DECL_CHAIN (f_fpr);
9032   f_ovf = DECL_CHAIN (f_res);
9033   f_sav = DECL_CHAIN (f_ovf);
9034
9035   valist = build_simple_mem_ref (valist);
9036   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), valist, f_gpr, NULL_TREE);
9037   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), unshare_expr (valist),
9038                 f_fpr, NULL_TREE);
9039   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), unshare_expr (valist),
9040                 f_ovf, NULL_TREE);
9041   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), unshare_expr (valist),
9042                 f_sav, NULL_TREE);
9043
9044   /* Count number of gp and fp argument registers used.  */
9045   words = crtl->args.info.words;
9046   n_gpr = MIN (crtl->args.info.sysv_gregno - GP_ARG_MIN_REG,
9047                GP_ARG_NUM_REG);
9048   n_fpr = MIN (crtl->args.info.fregno - FP_ARG_MIN_REG,
9049                FP_ARG_NUM_REG);
9050
9051   if (TARGET_DEBUG_ARG)
9052     fprintf (stderr, "va_start: words = "HOST_WIDE_INT_PRINT_DEC", n_gpr = "
9053              HOST_WIDE_INT_PRINT_DEC", n_fpr = "HOST_WIDE_INT_PRINT_DEC"\n",
9054              words, n_gpr, n_fpr);
9055
9056   if (cfun->va_list_gpr_size)
9057     {
9058       t = build2 (MODIFY_EXPR, TREE_TYPE (gpr), gpr,
9059                   build_int_cst (NULL_TREE, n_gpr));
9060       TREE_SIDE_EFFECTS (t) = 1;
9061       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
9062     }
9063
9064   if (cfun->va_list_fpr_size)
9065     {
9066       t = build2 (MODIFY_EXPR, TREE_TYPE (fpr), fpr,
9067                   build_int_cst (NULL_TREE, n_fpr));
9068       TREE_SIDE_EFFECTS (t) = 1;
9069       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
9070
9071 #ifdef HAVE_AS_GNU_ATTRIBUTE
9072       if (call_ABI_of_interest (cfun->decl))
9073         rs6000_passes_float = true;
9074 #endif
9075     }
9076
9077   /* Find the overflow area.  */
9078   t = make_tree (TREE_TYPE (ovf), virtual_incoming_args_rtx);
9079   if (words != 0)
9080     t = fold_build_pointer_plus_hwi (t, words * UNITS_PER_WORD);
9081   t = build2 (MODIFY_EXPR, TREE_TYPE (ovf), ovf, t);
9082   TREE_SIDE_EFFECTS (t) = 1;
9083   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
9084
9085   /* If there were no va_arg invocations, don't set up the register
9086      save area.  */
9087   if (!cfun->va_list_gpr_size
9088       && !cfun->va_list_fpr_size
9089       && n_gpr < GP_ARG_NUM_REG
9090       && n_fpr < FP_ARG_V4_MAX_REG)
9091     return;
9092
9093   /* Find the register save area.  */
9094   t = make_tree (TREE_TYPE (sav), virtual_stack_vars_rtx);
9095   if (cfun->machine->varargs_save_offset)
9096     t = fold_build_pointer_plus_hwi (t, cfun->machine->varargs_save_offset);
9097   t = build2 (MODIFY_EXPR, TREE_TYPE (sav), sav, t);
9098   TREE_SIDE_EFFECTS (t) = 1;
9099   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
9100 }
9101
9102 /* Implement va_arg.  */
9103
9104 tree
9105 rs6000_gimplify_va_arg (tree valist, tree type, gimple_seq *pre_p,
9106                         gimple_seq *post_p)
9107 {
9108   tree f_gpr, f_fpr, f_res, f_ovf, f_sav;
9109   tree gpr, fpr, ovf, sav, reg, t, u;
9110   int size, rsize, n_reg, sav_ofs, sav_scale;
9111   tree lab_false, lab_over, addr;
9112   int align;
9113   tree ptrtype = build_pointer_type_for_mode (type, ptr_mode, true);
9114   int regalign = 0;
9115   gimple stmt;
9116
9117   if (pass_by_reference (NULL, TYPE_MODE (type), type, false))
9118     {
9119       t = rs6000_gimplify_va_arg (valist, ptrtype, pre_p, post_p);
9120       return build_va_arg_indirect_ref (t);
9121     }
9122
9123   /* We need to deal with the fact that the darwin ppc64 ABI is defined by an
9124      earlier version of gcc, with the property that it always applied alignment
9125      adjustments to the va-args (even for zero-sized types).  The cheapest way
9126      to deal with this is to replicate the effect of the part of
9127      std_gimplify_va_arg_expr that carries out the align adjust, for the case
9128      of relevance.
9129      We don't need to check for pass-by-reference because of the test above.
9130      We can return a simplifed answer, since we know there's no offset to add.  */
9131
9132   if (TARGET_MACHO
9133       && rs6000_darwin64_abi
9134       && integer_zerop (TYPE_SIZE (type)))
9135     {
9136       unsigned HOST_WIDE_INT align, boundary;
9137       tree valist_tmp = get_initialized_tmp_var (valist, pre_p, NULL);
9138       align = PARM_BOUNDARY / BITS_PER_UNIT;
9139       boundary = rs6000_function_arg_boundary (TYPE_MODE (type), type);
9140       if (boundary > MAX_SUPPORTED_STACK_ALIGNMENT)
9141         boundary = MAX_SUPPORTED_STACK_ALIGNMENT;
9142       boundary /= BITS_PER_UNIT;
9143       if (boundary > align)
9144         {
9145           tree t ;
9146           /* This updates arg ptr by the amount that would be necessary
9147              to align the zero-sized (but not zero-alignment) item.  */
9148           t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
9149                       fold_build_pointer_plus_hwi (valist_tmp, boundary - 1));
9150           gimplify_and_add (t, pre_p);
9151
9152           t = fold_convert (sizetype, valist_tmp);
9153           t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist_tmp,
9154                   fold_convert (TREE_TYPE (valist),
9155                                 fold_build2 (BIT_AND_EXPR, sizetype, t,
9156                                              size_int (-boundary))));
9157           t = build2 (MODIFY_EXPR, TREE_TYPE (valist), valist, t);
9158           gimplify_and_add (t, pre_p);
9159         }
9160       /* Since it is zero-sized there's no increment for the item itself. */
9161       valist_tmp = fold_convert (build_pointer_type (type), valist_tmp);
9162       return build_va_arg_indirect_ref (valist_tmp);
9163     }
9164
9165   if (DEFAULT_ABI != ABI_V4)
9166     {
9167       if (targetm.calls.split_complex_arg && TREE_CODE (type) == COMPLEX_TYPE)
9168         {
9169           tree elem_type = TREE_TYPE (type);
9170           enum machine_mode elem_mode = TYPE_MODE (elem_type);
9171           int elem_size = GET_MODE_SIZE (elem_mode);
9172
9173           if (elem_size < UNITS_PER_WORD)
9174             {
9175               tree real_part, imag_part;
9176               gimple_seq post = NULL;
9177
9178               real_part = rs6000_gimplify_va_arg (valist, elem_type, pre_p,
9179                                                   &post);
9180               /* Copy the value into a temporary, lest the formal temporary
9181                  be reused out from under us.  */
9182               real_part = get_initialized_tmp_var (real_part, pre_p, &post);
9183               gimple_seq_add_seq (pre_p, post);
9184
9185               imag_part = rs6000_gimplify_va_arg (valist, elem_type, pre_p,
9186                                                   post_p);
9187
9188               return build2 (COMPLEX_EXPR, type, real_part, imag_part);
9189             }
9190         }
9191
9192       return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
9193     }
9194
9195   f_gpr = TYPE_FIELDS (TREE_TYPE (va_list_type_node));
9196   f_fpr = DECL_CHAIN (f_gpr);
9197   f_res = DECL_CHAIN (f_fpr);
9198   f_ovf = DECL_CHAIN (f_res);
9199   f_sav = DECL_CHAIN (f_ovf);
9200
9201   valist = build_va_arg_indirect_ref (valist);
9202   gpr = build3 (COMPONENT_REF, TREE_TYPE (f_gpr), valist, f_gpr, NULL_TREE);
9203   fpr = build3 (COMPONENT_REF, TREE_TYPE (f_fpr), unshare_expr (valist),
9204                 f_fpr, NULL_TREE);
9205   ovf = build3 (COMPONENT_REF, TREE_TYPE (f_ovf), unshare_expr (valist),
9206                 f_ovf, NULL_TREE);
9207   sav = build3 (COMPONENT_REF, TREE_TYPE (f_sav), unshare_expr (valist),
9208                 f_sav, NULL_TREE);
9209
9210   size = int_size_in_bytes (type);
9211   rsize = (size + 3) / 4;
9212   align = 1;
9213
9214   if (TARGET_HARD_FLOAT && TARGET_FPRS
9215       && ((TARGET_SINGLE_FLOAT && TYPE_MODE (type) == SFmode)
9216           || (TARGET_DOUBLE_FLOAT
9217               && (TYPE_MODE (type) == DFmode
9218                   || TYPE_MODE (type) == TFmode
9219                   || TYPE_MODE (type) == SDmode
9220                   || TYPE_MODE (type) == DDmode
9221                   || TYPE_MODE (type) == TDmode))))
9222     {
9223       /* FP args go in FP registers, if present.  */
9224       reg = fpr;
9225       n_reg = (size + 7) / 8;
9226       sav_ofs = ((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT) ? 8 : 4) * 4;
9227       sav_scale = ((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT) ? 8 : 4);
9228       if (TYPE_MODE (type) != SFmode && TYPE_MODE (type) != SDmode)
9229         align = 8;
9230     }
9231   else
9232     {
9233       /* Otherwise into GP registers.  */
9234       reg = gpr;
9235       n_reg = rsize;
9236       sav_ofs = 0;
9237       sav_scale = 4;
9238       if (n_reg == 2)
9239         align = 8;
9240     }
9241
9242   /* Pull the value out of the saved registers....  */
9243
9244   lab_over = NULL;
9245   addr = create_tmp_var (ptr_type_node, "addr");
9246
9247   /*  AltiVec vectors never go in registers when -mabi=altivec.  */
9248   if (TARGET_ALTIVEC_ABI && ALTIVEC_VECTOR_MODE (TYPE_MODE (type)))
9249     align = 16;
9250   else
9251     {
9252       lab_false = create_artificial_label (input_location);
9253       lab_over = create_artificial_label (input_location);
9254
9255       /* Long long and SPE vectors are aligned in the registers.
9256          As are any other 2 gpr item such as complex int due to a
9257          historical mistake.  */
9258       u = reg;
9259       if (n_reg == 2 && reg == gpr)
9260         {
9261           regalign = 1;
9262           u = build2 (BIT_AND_EXPR, TREE_TYPE (reg), unshare_expr (reg),
9263                      build_int_cst (TREE_TYPE (reg), n_reg - 1));
9264           u = build2 (POSTINCREMENT_EXPR, TREE_TYPE (reg),
9265                       unshare_expr (reg), u);
9266         }
9267       /* _Decimal128 is passed in even/odd fpr pairs; the stored
9268          reg number is 0 for f1, so we want to make it odd.  */
9269       else if (reg == fpr && TYPE_MODE (type) == TDmode)
9270         {
9271           t = build2 (BIT_IOR_EXPR, TREE_TYPE (reg), unshare_expr (reg),
9272                       build_int_cst (TREE_TYPE (reg), 1));
9273           u = build2 (MODIFY_EXPR, void_type_node, unshare_expr (reg), t);
9274         }
9275
9276       t = fold_convert (TREE_TYPE (reg), size_int (8 - n_reg + 1));
9277       t = build2 (GE_EXPR, boolean_type_node, u, t);
9278       u = build1 (GOTO_EXPR, void_type_node, lab_false);
9279       t = build3 (COND_EXPR, void_type_node, t, u, NULL_TREE);
9280       gimplify_and_add (t, pre_p);
9281
9282       t = sav;
9283       if (sav_ofs)
9284         t = fold_build_pointer_plus_hwi (sav, sav_ofs);
9285
9286       u = build2 (POSTINCREMENT_EXPR, TREE_TYPE (reg), unshare_expr (reg),
9287                   build_int_cst (TREE_TYPE (reg), n_reg));
9288       u = fold_convert (sizetype, u);
9289       u = build2 (MULT_EXPR, sizetype, u, size_int (sav_scale));
9290       t = fold_build_pointer_plus (t, u);
9291
9292       /* _Decimal32 varargs are located in the second word of the 64-bit
9293          FP register for 32-bit binaries.  */
9294       if (!TARGET_POWERPC64
9295           && TARGET_HARD_FLOAT && TARGET_FPRS
9296           && TYPE_MODE (type) == SDmode)
9297         t = fold_build_pointer_plus_hwi (t, size);
9298
9299       gimplify_assign (addr, t, pre_p);
9300
9301       gimple_seq_add_stmt (pre_p, gimple_build_goto (lab_over));
9302
9303       stmt = gimple_build_label (lab_false);
9304       gimple_seq_add_stmt (pre_p, stmt);
9305
9306       if ((n_reg == 2 && !regalign) || n_reg > 2)
9307         {
9308           /* Ensure that we don't find any more args in regs.
9309              Alignment has taken care of for special cases.  */
9310           gimplify_assign (reg, build_int_cst (TREE_TYPE (reg), 8), pre_p);
9311         }
9312     }
9313
9314   /* ... otherwise out of the overflow area.  */
9315
9316   /* Care for on-stack alignment if needed.  */
9317   t = ovf;
9318   if (align != 1)
9319     {
9320       t = fold_build_pointer_plus_hwi (t, align - 1);
9321       t = build2 (BIT_AND_EXPR, TREE_TYPE (t), t,
9322                   build_int_cst (TREE_TYPE (t), -align));
9323     }
9324   gimplify_expr (&t, pre_p, NULL, is_gimple_val, fb_rvalue);
9325
9326   gimplify_assign (unshare_expr (addr), t, pre_p);
9327
9328   t = fold_build_pointer_plus_hwi (t, size);
9329   gimplify_assign (unshare_expr (ovf), t, pre_p);
9330
9331   if (lab_over)
9332     {
9333       stmt = gimple_build_label (lab_over);
9334       gimple_seq_add_stmt (pre_p, stmt);
9335     }
9336
9337   if (STRICT_ALIGNMENT
9338       && (TYPE_ALIGN (type)
9339           > (unsigned) BITS_PER_UNIT * (align < 4 ? 4 : align)))
9340     {
9341       /* The value (of type complex double, for example) may not be
9342          aligned in memory in the saved registers, so copy via a
9343          temporary.  (This is the same code as used for SPARC.)  */
9344       tree tmp = create_tmp_var (type, "va_arg_tmp");
9345       tree dest_addr = build_fold_addr_expr (tmp);
9346
9347       tree copy = build_call_expr (builtin_decl_implicit (BUILT_IN_MEMCPY),
9348                                    3, dest_addr, addr, size_int (rsize * 4));
9349
9350       gimplify_and_add (copy, pre_p);
9351       addr = dest_addr;
9352     }
9353
9354   addr = fold_convert (ptrtype, addr);
9355   return build_va_arg_indirect_ref (addr);
9356 }
9357
9358 /* Builtins.  */
9359
9360 static void
9361 def_builtin (int mask, const char *name, tree type, int code)
9362 {
9363   if ((mask & target_flags) || TARGET_PAIRED_FLOAT)
9364     {
9365       tree t;
9366       if (rs6000_builtin_decls[code])
9367         fatal_error ("internal error: builtin function to %s already processed",
9368                      name);
9369
9370       rs6000_builtin_decls[code] = t =
9371         add_builtin_function (name, type, code, BUILT_IN_MD,
9372                               NULL, NULL_TREE);
9373
9374       gcc_assert (code >= 0 && code < (int)RS6000_BUILTIN_COUNT);
9375       switch (builtin_classify[code])
9376         {
9377         default:
9378           gcc_unreachable ();
9379
9380           /* assume builtin can do anything.  */
9381         case RS6000_BTC_MISC:
9382           break;
9383
9384           /* const function, function only depends on the inputs.  */
9385         case RS6000_BTC_CONST:
9386           TREE_READONLY (t) = 1;
9387           TREE_NOTHROW (t) = 1;
9388           break;
9389
9390           /* pure function, function can read global memory.  */
9391         case RS6000_BTC_PURE:
9392           DECL_PURE_P (t) = 1;
9393           TREE_NOTHROW (t) = 1;
9394           break;
9395
9396           /* Function is a math function.  If rounding mode is on, then treat
9397              the function as not reading global memory, but it can have
9398              arbitrary side effects.  If it is off, then assume the function is
9399              a const function.  This mimics the ATTR_MATHFN_FPROUNDING
9400              attribute in builtin-attribute.def that is used for the math
9401              functions. */
9402         case RS6000_BTC_FP_PURE:
9403           TREE_NOTHROW (t) = 1;
9404           if (flag_rounding_math)
9405             {
9406               DECL_PURE_P (t) = 1;
9407               DECL_IS_NOVOPS (t) = 1;
9408             }
9409           else
9410             TREE_READONLY (t) = 1;
9411           break;
9412         }
9413     }
9414 }
9415
9416 /* Simple ternary operations: VECd = foo (VECa, VECb, VECc).  */
9417
9418 static const struct builtin_description bdesc_3arg[] =
9419 {
9420   { MASK_ALTIVEC, CODE_FOR_fmav4sf4, "__builtin_altivec_vmaddfp", ALTIVEC_BUILTIN_VMADDFP },
9421   { MASK_ALTIVEC, CODE_FOR_altivec_vmhaddshs, "__builtin_altivec_vmhaddshs", ALTIVEC_BUILTIN_VMHADDSHS },
9422   { MASK_ALTIVEC, CODE_FOR_altivec_vmhraddshs, "__builtin_altivec_vmhraddshs", ALTIVEC_BUILTIN_VMHRADDSHS },
9423   { MASK_ALTIVEC, CODE_FOR_altivec_vmladduhm, "__builtin_altivec_vmladduhm", ALTIVEC_BUILTIN_VMLADDUHM},
9424   { MASK_ALTIVEC, CODE_FOR_altivec_vmsumubm, "__builtin_altivec_vmsumubm", ALTIVEC_BUILTIN_VMSUMUBM },
9425   { MASK_ALTIVEC, CODE_FOR_altivec_vmsummbm, "__builtin_altivec_vmsummbm", ALTIVEC_BUILTIN_VMSUMMBM },
9426   { MASK_ALTIVEC, CODE_FOR_altivec_vmsumuhm, "__builtin_altivec_vmsumuhm", ALTIVEC_BUILTIN_VMSUMUHM },
9427   { MASK_ALTIVEC, CODE_FOR_altivec_vmsumshm, "__builtin_altivec_vmsumshm", ALTIVEC_BUILTIN_VMSUMSHM },
9428   { MASK_ALTIVEC, CODE_FOR_altivec_vmsumuhs, "__builtin_altivec_vmsumuhs", ALTIVEC_BUILTIN_VMSUMUHS },
9429   { MASK_ALTIVEC, CODE_FOR_altivec_vmsumshs, "__builtin_altivec_vmsumshs", ALTIVEC_BUILTIN_VMSUMSHS },
9430   { MASK_ALTIVEC, CODE_FOR_nfmsv4sf4, "__builtin_altivec_vnmsubfp", ALTIVEC_BUILTIN_VNMSUBFP },
9431   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v2df, "__builtin_altivec_vperm_2df", ALTIVEC_BUILTIN_VPERM_2DF },
9432   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v2di, "__builtin_altivec_vperm_2di", ALTIVEC_BUILTIN_VPERM_2DI },
9433   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v4sf, "__builtin_altivec_vperm_4sf", ALTIVEC_BUILTIN_VPERM_4SF },
9434   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v4si, "__builtin_altivec_vperm_4si", ALTIVEC_BUILTIN_VPERM_4SI },
9435   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v8hi, "__builtin_altivec_vperm_8hi", ALTIVEC_BUILTIN_VPERM_8HI },
9436   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v16qi_uns, "__builtin_altivec_vperm_16qi", ALTIVEC_BUILTIN_VPERM_16QI },
9437   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v2di_uns, "__builtin_altivec_vperm_2di_uns", ALTIVEC_BUILTIN_VPERM_2DI_UNS },
9438   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v4si_uns, "__builtin_altivec_vperm_4si_uns", ALTIVEC_BUILTIN_VPERM_4SI_UNS },
9439   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v8hi_uns, "__builtin_altivec_vperm_8hi_uns", ALTIVEC_BUILTIN_VPERM_8HI_UNS },
9440   { MASK_ALTIVEC, CODE_FOR_altivec_vperm_v16qi_uns, "__builtin_altivec_vperm_16qi_uns", ALTIVEC_BUILTIN_VPERM_16QI_UNS },
9441   { MASK_ALTIVEC, CODE_FOR_vector_select_v4sf, "__builtin_altivec_vsel_4sf", ALTIVEC_BUILTIN_VSEL_4SF },
9442   { MASK_ALTIVEC, CODE_FOR_vector_select_v4si, "__builtin_altivec_vsel_4si", ALTIVEC_BUILTIN_VSEL_4SI },
9443   { MASK_ALTIVEC, CODE_FOR_vector_select_v8hi, "__builtin_altivec_vsel_8hi", ALTIVEC_BUILTIN_VSEL_8HI },
9444   { MASK_ALTIVEC, CODE_FOR_vector_select_v16qi, "__builtin_altivec_vsel_16qi", ALTIVEC_BUILTIN_VSEL_16QI },
9445   { MASK_ALTIVEC, CODE_FOR_vector_select_v2df, "__builtin_altivec_vsel_2df", ALTIVEC_BUILTIN_VSEL_2DF },
9446   { MASK_ALTIVEC, CODE_FOR_vector_select_v2di, "__builtin_altivec_vsel_2di", ALTIVEC_BUILTIN_VSEL_2DI },
9447   { MASK_ALTIVEC, CODE_FOR_vector_select_v4si_uns, "__builtin_altivec_vsel_4si_uns", ALTIVEC_BUILTIN_VSEL_4SI_UNS },
9448   { MASK_ALTIVEC, CODE_FOR_vector_select_v8hi_uns, "__builtin_altivec_vsel_8hi_uns", ALTIVEC_BUILTIN_VSEL_8HI_UNS },
9449   { MASK_ALTIVEC, CODE_FOR_vector_select_v16qi_uns, "__builtin_altivec_vsel_16qi_uns", ALTIVEC_BUILTIN_VSEL_16QI_UNS },
9450   { MASK_ALTIVEC, CODE_FOR_vector_select_v2di_uns, "__builtin_altivec_vsel_2di_uns", ALTIVEC_BUILTIN_VSEL_2DI_UNS },
9451   { MASK_ALTIVEC, CODE_FOR_altivec_vsldoi_v16qi, "__builtin_altivec_vsldoi_16qi", ALTIVEC_BUILTIN_VSLDOI_16QI },
9452   { MASK_ALTIVEC, CODE_FOR_altivec_vsldoi_v8hi, "__builtin_altivec_vsldoi_8hi", ALTIVEC_BUILTIN_VSLDOI_8HI },
9453   { MASK_ALTIVEC, CODE_FOR_altivec_vsldoi_v4si, "__builtin_altivec_vsldoi_4si", ALTIVEC_BUILTIN_VSLDOI_4SI },
9454   { MASK_ALTIVEC, CODE_FOR_altivec_vsldoi_v4sf, "__builtin_altivec_vsldoi_4sf", ALTIVEC_BUILTIN_VSLDOI_4SF },
9455
9456   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_madd", ALTIVEC_BUILTIN_VEC_MADD },
9457   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_madds", ALTIVEC_BUILTIN_VEC_MADDS },
9458   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_mladd", ALTIVEC_BUILTIN_VEC_MLADD },
9459   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_mradds", ALTIVEC_BUILTIN_VEC_MRADDS },
9460   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_msum", ALTIVEC_BUILTIN_VEC_MSUM },
9461   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmsumshm", ALTIVEC_BUILTIN_VEC_VMSUMSHM },
9462   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmsumuhm", ALTIVEC_BUILTIN_VEC_VMSUMUHM },
9463   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmsummbm", ALTIVEC_BUILTIN_VEC_VMSUMMBM },
9464   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmsumubm", ALTIVEC_BUILTIN_VEC_VMSUMUBM },
9465   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_msums", ALTIVEC_BUILTIN_VEC_MSUMS },
9466   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmsumshs", ALTIVEC_BUILTIN_VEC_VMSUMSHS },
9467   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmsumuhs", ALTIVEC_BUILTIN_VEC_VMSUMUHS },
9468   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_nmsub", ALTIVEC_BUILTIN_VEC_NMSUB },
9469   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_perm", ALTIVEC_BUILTIN_VEC_PERM },
9470   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sel", ALTIVEC_BUILTIN_VEC_SEL },
9471
9472   { MASK_VSX, CODE_FOR_fmav2df4, "__builtin_vsx_xvmadddp", VSX_BUILTIN_XVMADDDP },
9473   { MASK_VSX, CODE_FOR_fmsv2df4, "__builtin_vsx_xvmsubdp", VSX_BUILTIN_XVMSUBDP },
9474   { MASK_VSX, CODE_FOR_nfmav2df4, "__builtin_vsx_xvnmadddp", VSX_BUILTIN_XVNMADDDP },
9475   { MASK_VSX, CODE_FOR_nfmsv2df4, "__builtin_vsx_xvnmsubdp", VSX_BUILTIN_XVNMSUBDP },
9476
9477   { MASK_VSX, CODE_FOR_fmav4sf4, "__builtin_vsx_xvmaddsp", VSX_BUILTIN_XVMADDSP },
9478   { MASK_VSX, CODE_FOR_fmsv4sf4, "__builtin_vsx_xvmsubsp", VSX_BUILTIN_XVMSUBSP },
9479   { MASK_VSX, CODE_FOR_nfmav4sf4, "__builtin_vsx_xvnmaddsp", VSX_BUILTIN_XVNMADDSP },
9480   { MASK_VSX, CODE_FOR_nfmsv4sf4, "__builtin_vsx_xvnmsubsp", VSX_BUILTIN_XVNMSUBSP },
9481
9482   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_msub", VSX_BUILTIN_VEC_MSUB },
9483   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_nmadd", VSX_BUILTIN_VEC_NMADD },
9484
9485   { MASK_VSX, CODE_FOR_vector_select_v2di, "__builtin_vsx_xxsel_2di", VSX_BUILTIN_XXSEL_2DI },
9486   { MASK_VSX, CODE_FOR_vector_select_v2df, "__builtin_vsx_xxsel_2df", VSX_BUILTIN_XXSEL_2DF },
9487   { MASK_VSX, CODE_FOR_vector_select_v4sf, "__builtin_vsx_xxsel_4sf", VSX_BUILTIN_XXSEL_4SF },
9488   { MASK_VSX, CODE_FOR_vector_select_v4si, "__builtin_vsx_xxsel_4si", VSX_BUILTIN_XXSEL_4SI },
9489   { MASK_VSX, CODE_FOR_vector_select_v8hi, "__builtin_vsx_xxsel_8hi", VSX_BUILTIN_XXSEL_8HI },
9490   { MASK_VSX, CODE_FOR_vector_select_v16qi, "__builtin_vsx_xxsel_16qi", VSX_BUILTIN_XXSEL_16QI },
9491   { MASK_VSX, CODE_FOR_vector_select_v2di_uns, "__builtin_vsx_xxsel_2di_uns", VSX_BUILTIN_XXSEL_2DI_UNS },
9492   { MASK_VSX, CODE_FOR_vector_select_v4si_uns, "__builtin_vsx_xxsel_4si_uns", VSX_BUILTIN_XXSEL_4SI_UNS },
9493   { MASK_VSX, CODE_FOR_vector_select_v8hi_uns, "__builtin_vsx_xxsel_8hi_uns", VSX_BUILTIN_XXSEL_8HI_UNS },
9494   { MASK_VSX, CODE_FOR_vector_select_v16qi_uns, "__builtin_vsx_xxsel_16qi_uns", VSX_BUILTIN_XXSEL_16QI_UNS },
9495
9496   { MASK_VSX, CODE_FOR_altivec_vperm_v2di, "__builtin_vsx_vperm_2di", VSX_BUILTIN_VPERM_2DI },
9497   { MASK_VSX, CODE_FOR_altivec_vperm_v2df, "__builtin_vsx_vperm_2df", VSX_BUILTIN_VPERM_2DF },
9498   { MASK_VSX, CODE_FOR_altivec_vperm_v4sf, "__builtin_vsx_vperm_4sf", VSX_BUILTIN_VPERM_4SF },
9499   { MASK_VSX, CODE_FOR_altivec_vperm_v4si, "__builtin_vsx_vperm_4si", VSX_BUILTIN_VPERM_4SI },
9500   { MASK_VSX, CODE_FOR_altivec_vperm_v8hi, "__builtin_vsx_vperm_8hi", VSX_BUILTIN_VPERM_8HI },
9501   { MASK_VSX, CODE_FOR_altivec_vperm_v16qi, "__builtin_vsx_vperm_16qi", VSX_BUILTIN_VPERM_16QI },
9502   { MASK_VSX, CODE_FOR_altivec_vperm_v2di_uns, "__builtin_vsx_vperm_2di_uns", VSX_BUILTIN_VPERM_2DI_UNS },
9503   { MASK_VSX, CODE_FOR_altivec_vperm_v4si_uns, "__builtin_vsx_vperm_4si_uns", VSX_BUILTIN_VPERM_4SI_UNS },
9504   { MASK_VSX, CODE_FOR_altivec_vperm_v8hi_uns, "__builtin_vsx_vperm_8hi_uns", VSX_BUILTIN_VPERM_8HI_UNS },
9505   { MASK_VSX, CODE_FOR_altivec_vperm_v16qi_uns, "__builtin_vsx_vperm_16qi_uns", VSX_BUILTIN_VPERM_16QI_UNS },
9506
9507   { MASK_VSX, CODE_FOR_vsx_xxpermdi_v2df, "__builtin_vsx_xxpermdi_2df", VSX_BUILTIN_XXPERMDI_2DF },
9508   { MASK_VSX, CODE_FOR_vsx_xxpermdi_v2di, "__builtin_vsx_xxpermdi_2di", VSX_BUILTIN_XXPERMDI_2DI },
9509   { MASK_VSX, CODE_FOR_vsx_xxpermdi_v4sf, "__builtin_vsx_xxpermdi_4sf", VSX_BUILTIN_XXPERMDI_4SF },
9510   { MASK_VSX, CODE_FOR_vsx_xxpermdi_v4si, "__builtin_vsx_xxpermdi_4si", VSX_BUILTIN_XXPERMDI_4SI },
9511   { MASK_VSX, CODE_FOR_vsx_xxpermdi_v8hi, "__builtin_vsx_xxpermdi_8hi", VSX_BUILTIN_XXPERMDI_8HI },
9512   { MASK_VSX, CODE_FOR_vsx_xxpermdi_v16qi, "__builtin_vsx_xxpermdi_16qi", VSX_BUILTIN_XXPERMDI_16QI },
9513   { MASK_VSX, CODE_FOR_nothing, "__builtin_vsx_xxpermdi", VSX_BUILTIN_VEC_XXPERMDI },
9514   { MASK_VSX, CODE_FOR_vsx_set_v2df, "__builtin_vsx_set_2df", VSX_BUILTIN_SET_2DF },
9515   { MASK_VSX, CODE_FOR_vsx_set_v2di, "__builtin_vsx_set_2di", VSX_BUILTIN_SET_2DI },
9516
9517   { MASK_VSX, CODE_FOR_vsx_xxsldwi_v2di, "__builtin_vsx_xxsldwi_2di", VSX_BUILTIN_XXSLDWI_2DI },
9518   { MASK_VSX, CODE_FOR_vsx_xxsldwi_v2df, "__builtin_vsx_xxsldwi_2df", VSX_BUILTIN_XXSLDWI_2DF },
9519   { MASK_VSX, CODE_FOR_vsx_xxsldwi_v4sf, "__builtin_vsx_xxsldwi_4sf", VSX_BUILTIN_XXSLDWI_4SF },
9520   { MASK_VSX, CODE_FOR_vsx_xxsldwi_v4si, "__builtin_vsx_xxsldwi_4si", VSX_BUILTIN_XXSLDWI_4SI },
9521   { MASK_VSX, CODE_FOR_vsx_xxsldwi_v8hi, "__builtin_vsx_xxsldwi_8hi", VSX_BUILTIN_XXSLDWI_8HI },
9522   { MASK_VSX, CODE_FOR_vsx_xxsldwi_v16qi, "__builtin_vsx_xxsldwi_16qi", VSX_BUILTIN_XXSLDWI_16QI },
9523   { MASK_VSX, CODE_FOR_nothing, "__builtin_vsx_xxsldwi", VSX_BUILTIN_VEC_XXSLDWI },
9524
9525   { 0, CODE_FOR_fmsv2sf4, "__builtin_paired_msub", PAIRED_BUILTIN_MSUB },
9526   { 0, CODE_FOR_fmav2sf4, "__builtin_paired_madd", PAIRED_BUILTIN_MADD },
9527   { 0, CODE_FOR_paired_madds0, "__builtin_paired_madds0", PAIRED_BUILTIN_MADDS0 },
9528   { 0, CODE_FOR_paired_madds1, "__builtin_paired_madds1", PAIRED_BUILTIN_MADDS1 },
9529   { 0, CODE_FOR_nfmsv2sf4, "__builtin_paired_nmsub", PAIRED_BUILTIN_NMSUB },
9530   { 0, CODE_FOR_nfmav2sf4, "__builtin_paired_nmadd", PAIRED_BUILTIN_NMADD },
9531   { 0, CODE_FOR_paired_sum0, "__builtin_paired_sum0", PAIRED_BUILTIN_SUM0 },
9532   { 0, CODE_FOR_paired_sum1, "__builtin_paired_sum1", PAIRED_BUILTIN_SUM1 },
9533   { 0, CODE_FOR_selv2sf4, "__builtin_paired_selv2sf4", PAIRED_BUILTIN_SELV2SF4 },
9534 };
9535
9536 /* DST operations: void foo (void *, const int, const char).  */
9537
9538 static const struct builtin_description bdesc_dst[] =
9539 {
9540   { MASK_ALTIVEC, CODE_FOR_altivec_dst, "__builtin_altivec_dst", ALTIVEC_BUILTIN_DST },
9541   { MASK_ALTIVEC, CODE_FOR_altivec_dstt, "__builtin_altivec_dstt", ALTIVEC_BUILTIN_DSTT },
9542   { MASK_ALTIVEC, CODE_FOR_altivec_dstst, "__builtin_altivec_dstst", ALTIVEC_BUILTIN_DSTST },
9543   { MASK_ALTIVEC, CODE_FOR_altivec_dststt, "__builtin_altivec_dststt", ALTIVEC_BUILTIN_DSTSTT },
9544
9545   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_dst", ALTIVEC_BUILTIN_VEC_DST },
9546   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_dstt", ALTIVEC_BUILTIN_VEC_DSTT },
9547   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_dstst", ALTIVEC_BUILTIN_VEC_DSTST },
9548   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_dststt", ALTIVEC_BUILTIN_VEC_DSTSTT }
9549 };
9550
9551 /* Simple binary operations: VECc = foo (VECa, VECb).  */
9552
9553 static struct builtin_description bdesc_2arg[] =
9554 {
9555   { MASK_ALTIVEC, CODE_FOR_addv16qi3, "__builtin_altivec_vaddubm", ALTIVEC_BUILTIN_VADDUBM },
9556   { MASK_ALTIVEC, CODE_FOR_addv8hi3, "__builtin_altivec_vadduhm", ALTIVEC_BUILTIN_VADDUHM },
9557   { MASK_ALTIVEC, CODE_FOR_addv4si3, "__builtin_altivec_vadduwm", ALTIVEC_BUILTIN_VADDUWM },
9558   { MASK_ALTIVEC, CODE_FOR_addv4sf3, "__builtin_altivec_vaddfp", ALTIVEC_BUILTIN_VADDFP },
9559   { MASK_ALTIVEC, CODE_FOR_altivec_vaddcuw, "__builtin_altivec_vaddcuw", ALTIVEC_BUILTIN_VADDCUW },
9560   { MASK_ALTIVEC, CODE_FOR_altivec_vaddubs, "__builtin_altivec_vaddubs", ALTIVEC_BUILTIN_VADDUBS },
9561   { MASK_ALTIVEC, CODE_FOR_altivec_vaddsbs, "__builtin_altivec_vaddsbs", ALTIVEC_BUILTIN_VADDSBS },
9562   { MASK_ALTIVEC, CODE_FOR_altivec_vadduhs, "__builtin_altivec_vadduhs", ALTIVEC_BUILTIN_VADDUHS },
9563   { MASK_ALTIVEC, CODE_FOR_altivec_vaddshs, "__builtin_altivec_vaddshs", ALTIVEC_BUILTIN_VADDSHS },
9564   { MASK_ALTIVEC, CODE_FOR_altivec_vadduws, "__builtin_altivec_vadduws", ALTIVEC_BUILTIN_VADDUWS },
9565   { MASK_ALTIVEC, CODE_FOR_altivec_vaddsws, "__builtin_altivec_vaddsws", ALTIVEC_BUILTIN_VADDSWS },
9566   { MASK_ALTIVEC, CODE_FOR_andv4si3, "__builtin_altivec_vand", ALTIVEC_BUILTIN_VAND },
9567   { MASK_ALTIVEC, CODE_FOR_andcv4si3, "__builtin_altivec_vandc", ALTIVEC_BUILTIN_VANDC },
9568   { MASK_ALTIVEC, CODE_FOR_altivec_vavgub, "__builtin_altivec_vavgub", ALTIVEC_BUILTIN_VAVGUB },
9569   { MASK_ALTIVEC, CODE_FOR_altivec_vavgsb, "__builtin_altivec_vavgsb", ALTIVEC_BUILTIN_VAVGSB },
9570   { MASK_ALTIVEC, CODE_FOR_altivec_vavguh, "__builtin_altivec_vavguh", ALTIVEC_BUILTIN_VAVGUH },
9571   { MASK_ALTIVEC, CODE_FOR_altivec_vavgsh, "__builtin_altivec_vavgsh", ALTIVEC_BUILTIN_VAVGSH },
9572   { MASK_ALTIVEC, CODE_FOR_altivec_vavguw, "__builtin_altivec_vavguw", ALTIVEC_BUILTIN_VAVGUW },
9573   { MASK_ALTIVEC, CODE_FOR_altivec_vavgsw, "__builtin_altivec_vavgsw", ALTIVEC_BUILTIN_VAVGSW },
9574   { MASK_ALTIVEC, CODE_FOR_altivec_vcfux, "__builtin_altivec_vcfux", ALTIVEC_BUILTIN_VCFUX },
9575   { MASK_ALTIVEC, CODE_FOR_altivec_vcfsx, "__builtin_altivec_vcfsx", ALTIVEC_BUILTIN_VCFSX },
9576   { MASK_ALTIVEC, CODE_FOR_altivec_vcmpbfp, "__builtin_altivec_vcmpbfp", ALTIVEC_BUILTIN_VCMPBFP },
9577   { MASK_ALTIVEC, CODE_FOR_vector_eqv16qi, "__builtin_altivec_vcmpequb", ALTIVEC_BUILTIN_VCMPEQUB },
9578   { MASK_ALTIVEC, CODE_FOR_vector_eqv8hi, "__builtin_altivec_vcmpequh", ALTIVEC_BUILTIN_VCMPEQUH },
9579   { MASK_ALTIVEC, CODE_FOR_vector_eqv4si, "__builtin_altivec_vcmpequw", ALTIVEC_BUILTIN_VCMPEQUW },
9580   { MASK_ALTIVEC, CODE_FOR_vector_eqv4sf, "__builtin_altivec_vcmpeqfp", ALTIVEC_BUILTIN_VCMPEQFP },
9581   { MASK_ALTIVEC, CODE_FOR_vector_gev4sf, "__builtin_altivec_vcmpgefp", ALTIVEC_BUILTIN_VCMPGEFP },
9582   { MASK_ALTIVEC, CODE_FOR_vector_gtuv16qi, "__builtin_altivec_vcmpgtub", ALTIVEC_BUILTIN_VCMPGTUB },
9583   { MASK_ALTIVEC, CODE_FOR_vector_gtv16qi, "__builtin_altivec_vcmpgtsb", ALTIVEC_BUILTIN_VCMPGTSB },
9584   { MASK_ALTIVEC, CODE_FOR_vector_gtuv8hi, "__builtin_altivec_vcmpgtuh", ALTIVEC_BUILTIN_VCMPGTUH },
9585   { MASK_ALTIVEC, CODE_FOR_vector_gtv8hi, "__builtin_altivec_vcmpgtsh", ALTIVEC_BUILTIN_VCMPGTSH },
9586   { MASK_ALTIVEC, CODE_FOR_vector_gtuv4si, "__builtin_altivec_vcmpgtuw", ALTIVEC_BUILTIN_VCMPGTUW },
9587   { MASK_ALTIVEC, CODE_FOR_vector_gtv4si, "__builtin_altivec_vcmpgtsw", ALTIVEC_BUILTIN_VCMPGTSW },
9588   { MASK_ALTIVEC, CODE_FOR_vector_gtv4sf, "__builtin_altivec_vcmpgtfp", ALTIVEC_BUILTIN_VCMPGTFP },
9589   { MASK_ALTIVEC, CODE_FOR_altivec_vctsxs, "__builtin_altivec_vctsxs", ALTIVEC_BUILTIN_VCTSXS },
9590   { MASK_ALTIVEC, CODE_FOR_altivec_vctuxs, "__builtin_altivec_vctuxs", ALTIVEC_BUILTIN_VCTUXS },
9591   { MASK_ALTIVEC, CODE_FOR_umaxv16qi3, "__builtin_altivec_vmaxub", ALTIVEC_BUILTIN_VMAXUB },
9592   { MASK_ALTIVEC, CODE_FOR_smaxv16qi3, "__builtin_altivec_vmaxsb", ALTIVEC_BUILTIN_VMAXSB },
9593   { MASK_ALTIVEC, CODE_FOR_umaxv8hi3, "__builtin_altivec_vmaxuh", ALTIVEC_BUILTIN_VMAXUH },
9594   { MASK_ALTIVEC, CODE_FOR_smaxv8hi3, "__builtin_altivec_vmaxsh", ALTIVEC_BUILTIN_VMAXSH },
9595   { MASK_ALTIVEC, CODE_FOR_umaxv4si3, "__builtin_altivec_vmaxuw", ALTIVEC_BUILTIN_VMAXUW },
9596   { MASK_ALTIVEC, CODE_FOR_smaxv4si3, "__builtin_altivec_vmaxsw", ALTIVEC_BUILTIN_VMAXSW },
9597   { MASK_ALTIVEC, CODE_FOR_smaxv4sf3, "__builtin_altivec_vmaxfp", ALTIVEC_BUILTIN_VMAXFP },
9598   { MASK_ALTIVEC, CODE_FOR_altivec_vmrghb, "__builtin_altivec_vmrghb", ALTIVEC_BUILTIN_VMRGHB },
9599   { MASK_ALTIVEC, CODE_FOR_altivec_vmrghh, "__builtin_altivec_vmrghh", ALTIVEC_BUILTIN_VMRGHH },
9600   { MASK_ALTIVEC, CODE_FOR_altivec_vmrghw, "__builtin_altivec_vmrghw", ALTIVEC_BUILTIN_VMRGHW },
9601   { MASK_ALTIVEC, CODE_FOR_altivec_vmrglb, "__builtin_altivec_vmrglb", ALTIVEC_BUILTIN_VMRGLB },
9602   { MASK_ALTIVEC, CODE_FOR_altivec_vmrglh, "__builtin_altivec_vmrglh", ALTIVEC_BUILTIN_VMRGLH },
9603   { MASK_ALTIVEC, CODE_FOR_altivec_vmrglw, "__builtin_altivec_vmrglw", ALTIVEC_BUILTIN_VMRGLW },
9604   { MASK_ALTIVEC, CODE_FOR_uminv16qi3, "__builtin_altivec_vminub", ALTIVEC_BUILTIN_VMINUB },
9605   { MASK_ALTIVEC, CODE_FOR_sminv16qi3, "__builtin_altivec_vminsb", ALTIVEC_BUILTIN_VMINSB },
9606   { MASK_ALTIVEC, CODE_FOR_uminv8hi3, "__builtin_altivec_vminuh", ALTIVEC_BUILTIN_VMINUH },
9607   { MASK_ALTIVEC, CODE_FOR_sminv8hi3, "__builtin_altivec_vminsh", ALTIVEC_BUILTIN_VMINSH },
9608   { MASK_ALTIVEC, CODE_FOR_uminv4si3, "__builtin_altivec_vminuw", ALTIVEC_BUILTIN_VMINUW },
9609   { MASK_ALTIVEC, CODE_FOR_sminv4si3, "__builtin_altivec_vminsw", ALTIVEC_BUILTIN_VMINSW },
9610   { MASK_ALTIVEC, CODE_FOR_sminv4sf3, "__builtin_altivec_vminfp", ALTIVEC_BUILTIN_VMINFP },
9611   { MASK_ALTIVEC, CODE_FOR_altivec_vmuleub, "__builtin_altivec_vmuleub", ALTIVEC_BUILTIN_VMULEUB },
9612   { MASK_ALTIVEC, CODE_FOR_altivec_vmuleub, "__builtin_altivec_vmuleub_uns", ALTIVEC_BUILTIN_VMULEUB_UNS },
9613   { MASK_ALTIVEC, CODE_FOR_altivec_vmulesb, "__builtin_altivec_vmulesb", ALTIVEC_BUILTIN_VMULESB },
9614   { MASK_ALTIVEC, CODE_FOR_altivec_vmuleuh, "__builtin_altivec_vmuleuh", ALTIVEC_BUILTIN_VMULEUH },
9615   { MASK_ALTIVEC, CODE_FOR_altivec_vmuleuh, "__builtin_altivec_vmuleuh_uns", ALTIVEC_BUILTIN_VMULEUH_UNS },
9616   { MASK_ALTIVEC, CODE_FOR_altivec_vmulesh, "__builtin_altivec_vmulesh", ALTIVEC_BUILTIN_VMULESH },
9617   { MASK_ALTIVEC, CODE_FOR_altivec_vmuloub, "__builtin_altivec_vmuloub", ALTIVEC_BUILTIN_VMULOUB },
9618   { MASK_ALTIVEC, CODE_FOR_altivec_vmuloub, "__builtin_altivec_vmuloub_uns", ALTIVEC_BUILTIN_VMULOUB_UNS },
9619   { MASK_ALTIVEC, CODE_FOR_altivec_vmulosb, "__builtin_altivec_vmulosb", ALTIVEC_BUILTIN_VMULOSB },
9620   { MASK_ALTIVEC, CODE_FOR_altivec_vmulouh, "__builtin_altivec_vmulouh", ALTIVEC_BUILTIN_VMULOUH },
9621   { MASK_ALTIVEC, CODE_FOR_altivec_vmulouh, "__builtin_altivec_vmulouh_uns", ALTIVEC_BUILTIN_VMULOUH_UNS },
9622   { MASK_ALTIVEC, CODE_FOR_altivec_vmulosh, "__builtin_altivec_vmulosh", ALTIVEC_BUILTIN_VMULOSH },
9623   { MASK_ALTIVEC, CODE_FOR_norv4si3, "__builtin_altivec_vnor", ALTIVEC_BUILTIN_VNOR },
9624   { MASK_ALTIVEC, CODE_FOR_iorv4si3, "__builtin_altivec_vor", ALTIVEC_BUILTIN_VOR },
9625   { MASK_ALTIVEC, CODE_FOR_altivec_vpkuhum, "__builtin_altivec_vpkuhum", ALTIVEC_BUILTIN_VPKUHUM },
9626   { MASK_ALTIVEC, CODE_FOR_altivec_vpkuwum, "__builtin_altivec_vpkuwum", ALTIVEC_BUILTIN_VPKUWUM },
9627   { MASK_ALTIVEC, CODE_FOR_altivec_vpkpx, "__builtin_altivec_vpkpx", ALTIVEC_BUILTIN_VPKPX },
9628   { MASK_ALTIVEC, CODE_FOR_altivec_vpkshss, "__builtin_altivec_vpkshss", ALTIVEC_BUILTIN_VPKSHSS },
9629   { MASK_ALTIVEC, CODE_FOR_altivec_vpkswss, "__builtin_altivec_vpkswss", ALTIVEC_BUILTIN_VPKSWSS },
9630   { MASK_ALTIVEC, CODE_FOR_altivec_vpkuhus, "__builtin_altivec_vpkuhus", ALTIVEC_BUILTIN_VPKUHUS },
9631   { MASK_ALTIVEC, CODE_FOR_altivec_vpkshus, "__builtin_altivec_vpkshus", ALTIVEC_BUILTIN_VPKSHUS },
9632   { MASK_ALTIVEC, CODE_FOR_altivec_vpkuwus, "__builtin_altivec_vpkuwus", ALTIVEC_BUILTIN_VPKUWUS },
9633   { MASK_ALTIVEC, CODE_FOR_altivec_vpkswus, "__builtin_altivec_vpkswus", ALTIVEC_BUILTIN_VPKSWUS },
9634   { MASK_ALTIVEC, CODE_FOR_recipv4sf3, "__builtin_altivec_vrecipdivfp", ALTIVEC_BUILTIN_VRECIPFP },
9635   { MASK_ALTIVEC, CODE_FOR_vrotlv16qi3, "__builtin_altivec_vrlb", ALTIVEC_BUILTIN_VRLB },
9636   { MASK_ALTIVEC, CODE_FOR_vrotlv8hi3, "__builtin_altivec_vrlh", ALTIVEC_BUILTIN_VRLH },
9637   { MASK_ALTIVEC, CODE_FOR_vrotlv4si3, "__builtin_altivec_vrlw", ALTIVEC_BUILTIN_VRLW },
9638   { MASK_ALTIVEC, CODE_FOR_vashlv16qi3, "__builtin_altivec_vslb", ALTIVEC_BUILTIN_VSLB },
9639   { MASK_ALTIVEC, CODE_FOR_vashlv8hi3, "__builtin_altivec_vslh", ALTIVEC_BUILTIN_VSLH },
9640   { MASK_ALTIVEC, CODE_FOR_vashlv4si3, "__builtin_altivec_vslw", ALTIVEC_BUILTIN_VSLW },
9641   { MASK_ALTIVEC, CODE_FOR_altivec_vsl, "__builtin_altivec_vsl", ALTIVEC_BUILTIN_VSL },
9642   { MASK_ALTIVEC, CODE_FOR_altivec_vslo, "__builtin_altivec_vslo", ALTIVEC_BUILTIN_VSLO },
9643   { MASK_ALTIVEC, CODE_FOR_altivec_vspltb, "__builtin_altivec_vspltb", ALTIVEC_BUILTIN_VSPLTB },
9644   { MASK_ALTIVEC, CODE_FOR_altivec_vsplth, "__builtin_altivec_vsplth", ALTIVEC_BUILTIN_VSPLTH },
9645   { MASK_ALTIVEC, CODE_FOR_altivec_vspltw, "__builtin_altivec_vspltw", ALTIVEC_BUILTIN_VSPLTW },
9646   { MASK_ALTIVEC, CODE_FOR_vlshrv16qi3, "__builtin_altivec_vsrb", ALTIVEC_BUILTIN_VSRB },
9647   { MASK_ALTIVEC, CODE_FOR_vlshrv8hi3, "__builtin_altivec_vsrh", ALTIVEC_BUILTIN_VSRH },
9648   { MASK_ALTIVEC, CODE_FOR_vlshrv4si3, "__builtin_altivec_vsrw", ALTIVEC_BUILTIN_VSRW },
9649   { MASK_ALTIVEC, CODE_FOR_vashrv16qi3, "__builtin_altivec_vsrab", ALTIVEC_BUILTIN_VSRAB },
9650   { MASK_ALTIVEC, CODE_FOR_vashrv8hi3, "__builtin_altivec_vsrah", ALTIVEC_BUILTIN_VSRAH },
9651   { MASK_ALTIVEC, CODE_FOR_vashrv4si3, "__builtin_altivec_vsraw", ALTIVEC_BUILTIN_VSRAW },
9652   { MASK_ALTIVEC, CODE_FOR_altivec_vsr, "__builtin_altivec_vsr", ALTIVEC_BUILTIN_VSR },
9653   { MASK_ALTIVEC, CODE_FOR_altivec_vsro, "__builtin_altivec_vsro", ALTIVEC_BUILTIN_VSRO },
9654   { MASK_ALTIVEC, CODE_FOR_subv16qi3, "__builtin_altivec_vsububm", ALTIVEC_BUILTIN_VSUBUBM },
9655   { MASK_ALTIVEC, CODE_FOR_subv8hi3, "__builtin_altivec_vsubuhm", ALTIVEC_BUILTIN_VSUBUHM },
9656   { MASK_ALTIVEC, CODE_FOR_subv4si3, "__builtin_altivec_vsubuwm", ALTIVEC_BUILTIN_VSUBUWM },
9657   { MASK_ALTIVEC, CODE_FOR_subv4sf3, "__builtin_altivec_vsubfp", ALTIVEC_BUILTIN_VSUBFP },
9658   { MASK_ALTIVEC, CODE_FOR_altivec_vsubcuw, "__builtin_altivec_vsubcuw", ALTIVEC_BUILTIN_VSUBCUW },
9659   { MASK_ALTIVEC, CODE_FOR_altivec_vsububs, "__builtin_altivec_vsububs", ALTIVEC_BUILTIN_VSUBUBS },
9660   { MASK_ALTIVEC, CODE_FOR_altivec_vsubsbs, "__builtin_altivec_vsubsbs", ALTIVEC_BUILTIN_VSUBSBS },
9661   { MASK_ALTIVEC, CODE_FOR_altivec_vsubuhs, "__builtin_altivec_vsubuhs", ALTIVEC_BUILTIN_VSUBUHS },
9662   { MASK_ALTIVEC, CODE_FOR_altivec_vsubshs, "__builtin_altivec_vsubshs", ALTIVEC_BUILTIN_VSUBSHS },
9663   { MASK_ALTIVEC, CODE_FOR_altivec_vsubuws, "__builtin_altivec_vsubuws", ALTIVEC_BUILTIN_VSUBUWS },
9664   { MASK_ALTIVEC, CODE_FOR_altivec_vsubsws, "__builtin_altivec_vsubsws", ALTIVEC_BUILTIN_VSUBSWS },
9665   { MASK_ALTIVEC, CODE_FOR_altivec_vsum4ubs, "__builtin_altivec_vsum4ubs", ALTIVEC_BUILTIN_VSUM4UBS },
9666   { MASK_ALTIVEC, CODE_FOR_altivec_vsum4sbs, "__builtin_altivec_vsum4sbs", ALTIVEC_BUILTIN_VSUM4SBS },
9667   { MASK_ALTIVEC, CODE_FOR_altivec_vsum4shs, "__builtin_altivec_vsum4shs", ALTIVEC_BUILTIN_VSUM4SHS },
9668   { MASK_ALTIVEC, CODE_FOR_altivec_vsum2sws, "__builtin_altivec_vsum2sws", ALTIVEC_BUILTIN_VSUM2SWS },
9669   { MASK_ALTIVEC, CODE_FOR_altivec_vsumsws, "__builtin_altivec_vsumsws", ALTIVEC_BUILTIN_VSUMSWS },
9670   { MASK_ALTIVEC, CODE_FOR_xorv4si3, "__builtin_altivec_vxor", ALTIVEC_BUILTIN_VXOR },
9671   { MASK_ALTIVEC, CODE_FOR_vector_copysignv4sf3, "__builtin_altivec_copysignfp", ALTIVEC_BUILTIN_COPYSIGN_V4SF },
9672
9673   { MASK_VSX, CODE_FOR_addv2df3, "__builtin_vsx_xvadddp", VSX_BUILTIN_XVADDDP },
9674   { MASK_VSX, CODE_FOR_subv2df3, "__builtin_vsx_xvsubdp", VSX_BUILTIN_XVSUBDP },
9675   { MASK_VSX, CODE_FOR_mulv2df3, "__builtin_vsx_xvmuldp", VSX_BUILTIN_XVMULDP },
9676   { MASK_VSX, CODE_FOR_divv2df3, "__builtin_vsx_xvdivdp", VSX_BUILTIN_XVDIVDP },
9677   { MASK_VSX, CODE_FOR_recipv2df3, "__builtin_vsx_xvrecipdivdp", VSX_BUILTIN_RECIP_V2DF },
9678   { MASK_VSX, CODE_FOR_sminv2df3, "__builtin_vsx_xvmindp", VSX_BUILTIN_XVMINDP },
9679   { MASK_VSX, CODE_FOR_smaxv2df3, "__builtin_vsx_xvmaxdp", VSX_BUILTIN_XVMAXDP },
9680   { MASK_VSX, CODE_FOR_vsx_tdivv2df3_fe, "__builtin_vsx_xvtdivdp_fe", VSX_BUILTIN_XVTDIVDP_FE },
9681   { MASK_VSX, CODE_FOR_vsx_tdivv2df3_fg, "__builtin_vsx_xvtdivdp_fg", VSX_BUILTIN_XVTDIVDP_FG },
9682   { MASK_VSX, CODE_FOR_vector_eqv2df, "__builtin_vsx_xvcmpeqdp", VSX_BUILTIN_XVCMPEQDP },
9683   { MASK_VSX, CODE_FOR_vector_gtv2df, "__builtin_vsx_xvcmpgtdp", VSX_BUILTIN_XVCMPGTDP },
9684   { MASK_VSX, CODE_FOR_vector_gev2df, "__builtin_vsx_xvcmpgedp", VSX_BUILTIN_XVCMPGEDP },
9685
9686   { MASK_VSX, CODE_FOR_addv4sf3, "__builtin_vsx_xvaddsp", VSX_BUILTIN_XVADDSP },
9687   { MASK_VSX, CODE_FOR_subv4sf3, "__builtin_vsx_xvsubsp", VSX_BUILTIN_XVSUBSP },
9688   { MASK_VSX, CODE_FOR_mulv4sf3, "__builtin_vsx_xvmulsp", VSX_BUILTIN_XVMULSP },
9689   { MASK_VSX, CODE_FOR_divv4sf3, "__builtin_vsx_xvdivsp", VSX_BUILTIN_XVDIVSP },
9690   { MASK_VSX, CODE_FOR_recipv4sf3, "__builtin_vsx_xvrecipdivsp", VSX_BUILTIN_RECIP_V4SF },
9691   { MASK_VSX, CODE_FOR_sminv4sf3, "__builtin_vsx_xvminsp", VSX_BUILTIN_XVMINSP },
9692   { MASK_VSX, CODE_FOR_smaxv4sf3, "__builtin_vsx_xvmaxsp", VSX_BUILTIN_XVMAXSP },
9693   { MASK_VSX, CODE_FOR_vsx_tdivv4sf3_fe, "__builtin_vsx_xvtdivsp_fe", VSX_BUILTIN_XVTDIVSP_FE },
9694   { MASK_VSX, CODE_FOR_vsx_tdivv4sf3_fg, "__builtin_vsx_xvtdivsp_fg", VSX_BUILTIN_XVTDIVSP_FG },
9695   { MASK_VSX, CODE_FOR_vector_eqv4sf, "__builtin_vsx_xvcmpeqsp", VSX_BUILTIN_XVCMPEQSP },
9696   { MASK_VSX, CODE_FOR_vector_gtv4sf, "__builtin_vsx_xvcmpgtsp", VSX_BUILTIN_XVCMPGTSP },
9697   { MASK_VSX, CODE_FOR_vector_gev4sf, "__builtin_vsx_xvcmpgesp", VSX_BUILTIN_XVCMPGESP },
9698
9699   { MASK_VSX, CODE_FOR_smindf3, "__builtin_vsx_xsmindp", VSX_BUILTIN_XSMINDP },
9700   { MASK_VSX, CODE_FOR_smaxdf3, "__builtin_vsx_xsmaxdp", VSX_BUILTIN_XSMAXDP },
9701   { MASK_VSX, CODE_FOR_vsx_tdivdf3_fe, "__builtin_vsx_xstdivdp_fe", VSX_BUILTIN_XSTDIVDP_FE },
9702   { MASK_VSX, CODE_FOR_vsx_tdivdf3_fg, "__builtin_vsx_xstdivdp_fg", VSX_BUILTIN_XSTDIVDP_FG },
9703   { MASK_VSX, CODE_FOR_vector_copysignv2df3, "__builtin_vsx_cpsgndp", VSX_BUILTIN_CPSGNDP },
9704   { MASK_VSX, CODE_FOR_vector_copysignv4sf3, "__builtin_vsx_cpsgnsp", VSX_BUILTIN_CPSGNSP },
9705
9706   { MASK_VSX, CODE_FOR_vsx_concat_v2df, "__builtin_vsx_concat_2df", VSX_BUILTIN_CONCAT_2DF },
9707   { MASK_VSX, CODE_FOR_vsx_concat_v2di, "__builtin_vsx_concat_2di", VSX_BUILTIN_CONCAT_2DI },
9708   { MASK_VSX, CODE_FOR_vsx_splat_v2df, "__builtin_vsx_splat_2df", VSX_BUILTIN_SPLAT_2DF },
9709   { MASK_VSX, CODE_FOR_vsx_splat_v2di, "__builtin_vsx_splat_2di", VSX_BUILTIN_SPLAT_2DI },
9710   { MASK_VSX, CODE_FOR_vsx_xxmrghw_v4sf, "__builtin_vsx_xxmrghw", VSX_BUILTIN_XXMRGHW_4SF },
9711   { MASK_VSX, CODE_FOR_vsx_xxmrghw_v4si, "__builtin_vsx_xxmrghw_4si", VSX_BUILTIN_XXMRGHW_4SI },
9712   { MASK_VSX, CODE_FOR_vsx_xxmrglw_v4sf, "__builtin_vsx_xxmrglw", VSX_BUILTIN_XXMRGLW_4SF },
9713   { MASK_VSX, CODE_FOR_vsx_xxmrglw_v4si, "__builtin_vsx_xxmrglw_4si", VSX_BUILTIN_XXMRGLW_4SI },
9714   { MASK_VSX, CODE_FOR_vec_interleave_lowv2df, "__builtin_vsx_mergel_2df", VSX_BUILTIN_VEC_MERGEL_V2DF },
9715   { MASK_VSX, CODE_FOR_vec_interleave_lowv2di, "__builtin_vsx_mergel_2di", VSX_BUILTIN_VEC_MERGEL_V2DI },
9716   { MASK_VSX, CODE_FOR_vec_interleave_highv2df, "__builtin_vsx_mergeh_2df", VSX_BUILTIN_VEC_MERGEH_V2DF },
9717   { MASK_VSX, CODE_FOR_vec_interleave_highv2di, "__builtin_vsx_mergeh_2di", VSX_BUILTIN_VEC_MERGEH_V2DI },
9718
9719   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_add", ALTIVEC_BUILTIN_VEC_ADD },
9720   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_vaddfp", ALTIVEC_BUILTIN_VEC_VADDFP },
9721   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vadduwm", ALTIVEC_BUILTIN_VEC_VADDUWM },
9722   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vadduhm", ALTIVEC_BUILTIN_VEC_VADDUHM },
9723   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vaddubm", ALTIVEC_BUILTIN_VEC_VADDUBM },
9724   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_addc", ALTIVEC_BUILTIN_VEC_ADDC },
9725   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_adds", ALTIVEC_BUILTIN_VEC_ADDS },
9726   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vaddsws", ALTIVEC_BUILTIN_VEC_VADDSWS },
9727   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vadduws", ALTIVEC_BUILTIN_VEC_VADDUWS },
9728   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vaddshs", ALTIVEC_BUILTIN_VEC_VADDSHS },
9729   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vadduhs", ALTIVEC_BUILTIN_VEC_VADDUHS },
9730   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vaddsbs", ALTIVEC_BUILTIN_VEC_VADDSBS },
9731   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vaddubs", ALTIVEC_BUILTIN_VEC_VADDUBS },
9732   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_and", ALTIVEC_BUILTIN_VEC_AND },
9733   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_andc", ALTIVEC_BUILTIN_VEC_ANDC },
9734   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_avg", ALTIVEC_BUILTIN_VEC_AVG },
9735   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vavgsw", ALTIVEC_BUILTIN_VEC_VAVGSW },
9736   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vavguw", ALTIVEC_BUILTIN_VEC_VAVGUW },
9737   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vavgsh", ALTIVEC_BUILTIN_VEC_VAVGSH },
9738   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vavguh", ALTIVEC_BUILTIN_VEC_VAVGUH },
9739   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vavgsb", ALTIVEC_BUILTIN_VEC_VAVGSB },
9740   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vavgub", ALTIVEC_BUILTIN_VEC_VAVGUB },
9741   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_cmpb", ALTIVEC_BUILTIN_VEC_CMPB },
9742   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_cmpeq", ALTIVEC_BUILTIN_VEC_CMPEQ },
9743   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpeqfp", ALTIVEC_BUILTIN_VEC_VCMPEQFP },
9744   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpequw", ALTIVEC_BUILTIN_VEC_VCMPEQUW },
9745   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpequh", ALTIVEC_BUILTIN_VEC_VCMPEQUH },
9746   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpequb", ALTIVEC_BUILTIN_VEC_VCMPEQUB },
9747   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_cmpge", ALTIVEC_BUILTIN_VEC_CMPGE },
9748   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_cmpgt", ALTIVEC_BUILTIN_VEC_CMPGT },
9749   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpgtfp", ALTIVEC_BUILTIN_VEC_VCMPGTFP },
9750   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpgtsw", ALTIVEC_BUILTIN_VEC_VCMPGTSW },
9751   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpgtuw", ALTIVEC_BUILTIN_VEC_VCMPGTUW },
9752   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpgtsh", ALTIVEC_BUILTIN_VEC_VCMPGTSH },
9753   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpgtuh", ALTIVEC_BUILTIN_VEC_VCMPGTUH },
9754   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpgtsb", ALTIVEC_BUILTIN_VEC_VCMPGTSB },
9755   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vcmpgtub", ALTIVEC_BUILTIN_VEC_VCMPGTUB },
9756   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_cmple", ALTIVEC_BUILTIN_VEC_CMPLE },
9757   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_cmplt", ALTIVEC_BUILTIN_VEC_CMPLT },
9758   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_copysign", ALTIVEC_BUILTIN_VEC_COPYSIGN },
9759   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_max", ALTIVEC_BUILTIN_VEC_MAX },
9760   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_vmaxfp", ALTIVEC_BUILTIN_VEC_VMAXFP },
9761   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmaxsw", ALTIVEC_BUILTIN_VEC_VMAXSW },
9762   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmaxuw", ALTIVEC_BUILTIN_VEC_VMAXUW },
9763   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmaxsh", ALTIVEC_BUILTIN_VEC_VMAXSH },
9764   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmaxuh", ALTIVEC_BUILTIN_VEC_VMAXUH },
9765   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmaxsb", ALTIVEC_BUILTIN_VEC_VMAXSB },
9766   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmaxub", ALTIVEC_BUILTIN_VEC_VMAXUB },
9767   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_mergeh", ALTIVEC_BUILTIN_VEC_MERGEH },
9768   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmrghw", ALTIVEC_BUILTIN_VEC_VMRGHW },
9769   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmrghh", ALTIVEC_BUILTIN_VEC_VMRGHH },
9770   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmrghb", ALTIVEC_BUILTIN_VEC_VMRGHB },
9771   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_mergel", ALTIVEC_BUILTIN_VEC_MERGEL },
9772   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmrglw", ALTIVEC_BUILTIN_VEC_VMRGLW },
9773   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmrglh", ALTIVEC_BUILTIN_VEC_VMRGLH },
9774   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmrglb", ALTIVEC_BUILTIN_VEC_VMRGLB },
9775   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_min", ALTIVEC_BUILTIN_VEC_MIN },
9776   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_vminfp", ALTIVEC_BUILTIN_VEC_VMINFP },
9777   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vminsw", ALTIVEC_BUILTIN_VEC_VMINSW },
9778   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vminuw", ALTIVEC_BUILTIN_VEC_VMINUW },
9779   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vminsh", ALTIVEC_BUILTIN_VEC_VMINSH },
9780   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vminuh", ALTIVEC_BUILTIN_VEC_VMINUH },
9781   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vminsb", ALTIVEC_BUILTIN_VEC_VMINSB },
9782   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vminub", ALTIVEC_BUILTIN_VEC_VMINUB },
9783   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_mule", ALTIVEC_BUILTIN_VEC_MULE },
9784   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmuleub", ALTIVEC_BUILTIN_VEC_VMULEUB },
9785   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmulesb", ALTIVEC_BUILTIN_VEC_VMULESB },
9786   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmuleuh", ALTIVEC_BUILTIN_VEC_VMULEUH },
9787   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmulesh", ALTIVEC_BUILTIN_VEC_VMULESH },
9788   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_mulo", ALTIVEC_BUILTIN_VEC_MULO },
9789   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmulosh", ALTIVEC_BUILTIN_VEC_VMULOSH },
9790   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmulouh", ALTIVEC_BUILTIN_VEC_VMULOUH },
9791   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmulosb", ALTIVEC_BUILTIN_VEC_VMULOSB },
9792   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vmuloub", ALTIVEC_BUILTIN_VEC_VMULOUB },
9793   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_nor", ALTIVEC_BUILTIN_VEC_NOR },
9794   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_or", ALTIVEC_BUILTIN_VEC_OR },
9795   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_pack", ALTIVEC_BUILTIN_VEC_PACK },
9796   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vpkuwum", ALTIVEC_BUILTIN_VEC_VPKUWUM },
9797   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vpkuhum", ALTIVEC_BUILTIN_VEC_VPKUHUM },
9798   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_packpx", ALTIVEC_BUILTIN_VEC_PACKPX },
9799   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_packs", ALTIVEC_BUILTIN_VEC_PACKS },
9800   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vpkswss", ALTIVEC_BUILTIN_VEC_VPKSWSS },
9801   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vpkuwus", ALTIVEC_BUILTIN_VEC_VPKUWUS },
9802   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vpkshss", ALTIVEC_BUILTIN_VEC_VPKSHSS },
9803   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vpkuhus", ALTIVEC_BUILTIN_VEC_VPKUHUS },
9804   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_packsu", ALTIVEC_BUILTIN_VEC_PACKSU },
9805   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vpkswus", ALTIVEC_BUILTIN_VEC_VPKSWUS },
9806   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vpkshus", ALTIVEC_BUILTIN_VEC_VPKSHUS },
9807   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_recipdiv", ALTIVEC_BUILTIN_VEC_RECIP },
9808   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_rl", ALTIVEC_BUILTIN_VEC_RL },
9809   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vrlw", ALTIVEC_BUILTIN_VEC_VRLW },
9810   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vrlh", ALTIVEC_BUILTIN_VEC_VRLH },
9811   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vrlb", ALTIVEC_BUILTIN_VEC_VRLB },
9812   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sl", ALTIVEC_BUILTIN_VEC_SL },
9813   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vslw", ALTIVEC_BUILTIN_VEC_VSLW },
9814   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vslh", ALTIVEC_BUILTIN_VEC_VSLH },
9815   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vslb", ALTIVEC_BUILTIN_VEC_VSLB },
9816   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sll", ALTIVEC_BUILTIN_VEC_SLL },
9817   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_slo", ALTIVEC_BUILTIN_VEC_SLO },
9818   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sr", ALTIVEC_BUILTIN_VEC_SR },
9819   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsrw", ALTIVEC_BUILTIN_VEC_VSRW },
9820   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsrh", ALTIVEC_BUILTIN_VEC_VSRH },
9821   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsrb", ALTIVEC_BUILTIN_VEC_VSRB },
9822   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sra", ALTIVEC_BUILTIN_VEC_SRA },
9823   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsraw", ALTIVEC_BUILTIN_VEC_VSRAW },
9824   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsrah", ALTIVEC_BUILTIN_VEC_VSRAH },
9825   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsrab", ALTIVEC_BUILTIN_VEC_VSRAB },
9826   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_srl", ALTIVEC_BUILTIN_VEC_SRL },
9827   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sro", ALTIVEC_BUILTIN_VEC_SRO },
9828   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_sub", ALTIVEC_BUILTIN_VEC_SUB },
9829   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_vsubfp", ALTIVEC_BUILTIN_VEC_VSUBFP },
9830   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsubuwm", ALTIVEC_BUILTIN_VEC_VSUBUWM },
9831   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsubuhm", ALTIVEC_BUILTIN_VEC_VSUBUHM },
9832   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsububm", ALTIVEC_BUILTIN_VEC_VSUBUBM },
9833   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_subc", ALTIVEC_BUILTIN_VEC_SUBC },
9834   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_subs", ALTIVEC_BUILTIN_VEC_SUBS },
9835   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsubsws", ALTIVEC_BUILTIN_VEC_VSUBSWS },
9836   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsubuws", ALTIVEC_BUILTIN_VEC_VSUBUWS },
9837   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsubshs", ALTIVEC_BUILTIN_VEC_VSUBSHS },
9838   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsubuhs", ALTIVEC_BUILTIN_VEC_VSUBUHS },
9839   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsubsbs", ALTIVEC_BUILTIN_VEC_VSUBSBS },
9840   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsububs", ALTIVEC_BUILTIN_VEC_VSUBUBS },
9841   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sum4s", ALTIVEC_BUILTIN_VEC_SUM4S },
9842   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsum4shs", ALTIVEC_BUILTIN_VEC_VSUM4SHS },
9843   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsum4sbs", ALTIVEC_BUILTIN_VEC_VSUM4SBS },
9844   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vsum4ubs", ALTIVEC_BUILTIN_VEC_VSUM4UBS },
9845   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sum2s", ALTIVEC_BUILTIN_VEC_SUM2S },
9846   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_sums", ALTIVEC_BUILTIN_VEC_SUMS },
9847   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_xor", ALTIVEC_BUILTIN_VEC_XOR },
9848
9849   { MASK_VSX, CODE_FOR_nothing, "__builtin_vec_mul", VSX_BUILTIN_VEC_MUL },
9850   { MASK_VSX, CODE_FOR_nothing, "__builtin_vec_div", VSX_BUILTIN_VEC_DIV },
9851
9852   { 0, CODE_FOR_paired_divv2sf3, "__builtin_paired_divv2sf3", PAIRED_BUILTIN_DIVV2SF3 },
9853   { 0, CODE_FOR_paired_addv2sf3, "__builtin_paired_addv2sf3", PAIRED_BUILTIN_ADDV2SF3 },
9854   { 0, CODE_FOR_paired_subv2sf3, "__builtin_paired_subv2sf3", PAIRED_BUILTIN_SUBV2SF3 },
9855   { 0, CODE_FOR_paired_mulv2sf3, "__builtin_paired_mulv2sf3", PAIRED_BUILTIN_MULV2SF3 },
9856   { 0, CODE_FOR_paired_muls0, "__builtin_paired_muls0", PAIRED_BUILTIN_MULS0 },
9857   { 0, CODE_FOR_paired_muls1, "__builtin_paired_muls1", PAIRED_BUILTIN_MULS1 },
9858   { 0, CODE_FOR_paired_merge00, "__builtin_paired_merge00", PAIRED_BUILTIN_MERGE00 },
9859   { 0, CODE_FOR_paired_merge01, "__builtin_paired_merge01", PAIRED_BUILTIN_MERGE01 },
9860   { 0, CODE_FOR_paired_merge10, "__builtin_paired_merge10", PAIRED_BUILTIN_MERGE10 },
9861   { 0, CODE_FOR_paired_merge11, "__builtin_paired_merge11", PAIRED_BUILTIN_MERGE11 },
9862
9863   /* Place holder, leave as first spe builtin.  */
9864   { 0, CODE_FOR_addv2si3, "__builtin_spe_evaddw", SPE_BUILTIN_EVADDW },
9865   { 0, CODE_FOR_andv2si3, "__builtin_spe_evand", SPE_BUILTIN_EVAND },
9866   { 0, CODE_FOR_spe_evandc, "__builtin_spe_evandc", SPE_BUILTIN_EVANDC },
9867   { 0, CODE_FOR_divv2si3, "__builtin_spe_evdivws", SPE_BUILTIN_EVDIVWS },
9868   { 0, CODE_FOR_spe_evdivwu, "__builtin_spe_evdivwu", SPE_BUILTIN_EVDIVWU },
9869   { 0, CODE_FOR_spe_eveqv, "__builtin_spe_eveqv", SPE_BUILTIN_EVEQV },
9870   { 0, CODE_FOR_spe_evfsadd, "__builtin_spe_evfsadd", SPE_BUILTIN_EVFSADD },
9871   { 0, CODE_FOR_spe_evfsdiv, "__builtin_spe_evfsdiv", SPE_BUILTIN_EVFSDIV },
9872   { 0, CODE_FOR_spe_evfsmul, "__builtin_spe_evfsmul", SPE_BUILTIN_EVFSMUL },
9873   { 0, CODE_FOR_spe_evfssub, "__builtin_spe_evfssub", SPE_BUILTIN_EVFSSUB },
9874   { 0, CODE_FOR_spe_evmergehi, "__builtin_spe_evmergehi", SPE_BUILTIN_EVMERGEHI },
9875   { 0, CODE_FOR_spe_evmergehilo, "__builtin_spe_evmergehilo", SPE_BUILTIN_EVMERGEHILO },
9876   { 0, CODE_FOR_spe_evmergelo, "__builtin_spe_evmergelo", SPE_BUILTIN_EVMERGELO },
9877   { 0, CODE_FOR_spe_evmergelohi, "__builtin_spe_evmergelohi", SPE_BUILTIN_EVMERGELOHI },
9878   { 0, CODE_FOR_spe_evmhegsmfaa, "__builtin_spe_evmhegsmfaa", SPE_BUILTIN_EVMHEGSMFAA },
9879   { 0, CODE_FOR_spe_evmhegsmfan, "__builtin_spe_evmhegsmfan", SPE_BUILTIN_EVMHEGSMFAN },
9880   { 0, CODE_FOR_spe_evmhegsmiaa, "__builtin_spe_evmhegsmiaa", SPE_BUILTIN_EVMHEGSMIAA },
9881   { 0, CODE_FOR_spe_evmhegsmian, "__builtin_spe_evmhegsmian", SPE_BUILTIN_EVMHEGSMIAN },
9882   { 0, CODE_FOR_spe_evmhegumiaa, "__builtin_spe_evmhegumiaa", SPE_BUILTIN_EVMHEGUMIAA },
9883   { 0, CODE_FOR_spe_evmhegumian, "__builtin_spe_evmhegumian", SPE_BUILTIN_EVMHEGUMIAN },
9884   { 0, CODE_FOR_spe_evmhesmf, "__builtin_spe_evmhesmf", SPE_BUILTIN_EVMHESMF },
9885   { 0, CODE_FOR_spe_evmhesmfa, "__builtin_spe_evmhesmfa", SPE_BUILTIN_EVMHESMFA },
9886   { 0, CODE_FOR_spe_evmhesmfaaw, "__builtin_spe_evmhesmfaaw", SPE_BUILTIN_EVMHESMFAAW },
9887   { 0, CODE_FOR_spe_evmhesmfanw, "__builtin_spe_evmhesmfanw", SPE_BUILTIN_EVMHESMFANW },
9888   { 0, CODE_FOR_spe_evmhesmi, "__builtin_spe_evmhesmi", SPE_BUILTIN_EVMHESMI },
9889   { 0, CODE_FOR_spe_evmhesmia, "__builtin_spe_evmhesmia", SPE_BUILTIN_EVMHESMIA },
9890   { 0, CODE_FOR_spe_evmhesmiaaw, "__builtin_spe_evmhesmiaaw", SPE_BUILTIN_EVMHESMIAAW },
9891   { 0, CODE_FOR_spe_evmhesmianw, "__builtin_spe_evmhesmianw", SPE_BUILTIN_EVMHESMIANW },
9892   { 0, CODE_FOR_spe_evmhessf, "__builtin_spe_evmhessf", SPE_BUILTIN_EVMHESSF },
9893   { 0, CODE_FOR_spe_evmhessfa, "__builtin_spe_evmhessfa", SPE_BUILTIN_EVMHESSFA },
9894   { 0, CODE_FOR_spe_evmhessfaaw, "__builtin_spe_evmhessfaaw", SPE_BUILTIN_EVMHESSFAAW },
9895   { 0, CODE_FOR_spe_evmhessfanw, "__builtin_spe_evmhessfanw", SPE_BUILTIN_EVMHESSFANW },
9896   { 0, CODE_FOR_spe_evmhessiaaw, "__builtin_spe_evmhessiaaw", SPE_BUILTIN_EVMHESSIAAW },
9897   { 0, CODE_FOR_spe_evmhessianw, "__builtin_spe_evmhessianw", SPE_BUILTIN_EVMHESSIANW },
9898   { 0, CODE_FOR_spe_evmheumi, "__builtin_spe_evmheumi", SPE_BUILTIN_EVMHEUMI },
9899   { 0, CODE_FOR_spe_evmheumia, "__builtin_spe_evmheumia", SPE_BUILTIN_EVMHEUMIA },
9900   { 0, CODE_FOR_spe_evmheumiaaw, "__builtin_spe_evmheumiaaw", SPE_BUILTIN_EVMHEUMIAAW },
9901   { 0, CODE_FOR_spe_evmheumianw, "__builtin_spe_evmheumianw", SPE_BUILTIN_EVMHEUMIANW },
9902   { 0, CODE_FOR_spe_evmheusiaaw, "__builtin_spe_evmheusiaaw", SPE_BUILTIN_EVMHEUSIAAW },
9903   { 0, CODE_FOR_spe_evmheusianw, "__builtin_spe_evmheusianw", SPE_BUILTIN_EVMHEUSIANW },
9904   { 0, CODE_FOR_spe_evmhogsmfaa, "__builtin_spe_evmhogsmfaa", SPE_BUILTIN_EVMHOGSMFAA },
9905   { 0, CODE_FOR_spe_evmhogsmfan, "__builtin_spe_evmhogsmfan", SPE_BUILTIN_EVMHOGSMFAN },
9906   { 0, CODE_FOR_spe_evmhogsmiaa, "__builtin_spe_evmhogsmiaa", SPE_BUILTIN_EVMHOGSMIAA },
9907   { 0, CODE_FOR_spe_evmhogsmian, "__builtin_spe_evmhogsmian", SPE_BUILTIN_EVMHOGSMIAN },
9908   { 0, CODE_FOR_spe_evmhogumiaa, "__builtin_spe_evmhogumiaa", SPE_BUILTIN_EVMHOGUMIAA },
9909   { 0, CODE_FOR_spe_evmhogumian, "__builtin_spe_evmhogumian", SPE_BUILTIN_EVMHOGUMIAN },
9910   { 0, CODE_FOR_spe_evmhosmf, "__builtin_spe_evmhosmf", SPE_BUILTIN_EVMHOSMF },
9911   { 0, CODE_FOR_spe_evmhosmfa, "__builtin_spe_evmhosmfa", SPE_BUILTIN_EVMHOSMFA },
9912   { 0, CODE_FOR_spe_evmhosmfaaw, "__builtin_spe_evmhosmfaaw", SPE_BUILTIN_EVMHOSMFAAW },
9913   { 0, CODE_FOR_spe_evmhosmfanw, "__builtin_spe_evmhosmfanw", SPE_BUILTIN_EVMHOSMFANW },
9914   { 0, CODE_FOR_spe_evmhosmi, "__builtin_spe_evmhosmi", SPE_BUILTIN_EVMHOSMI },
9915   { 0, CODE_FOR_spe_evmhosmia, "__builtin_spe_evmhosmia", SPE_BUILTIN_EVMHOSMIA },
9916   { 0, CODE_FOR_spe_evmhosmiaaw, "__builtin_spe_evmhosmiaaw", SPE_BUILTIN_EVMHOSMIAAW },
9917   { 0, CODE_FOR_spe_evmhosmianw, "__builtin_spe_evmhosmianw", SPE_BUILTIN_EVMHOSMIANW },
9918   { 0, CODE_FOR_spe_evmhossf, "__builtin_spe_evmhossf", SPE_BUILTIN_EVMHOSSF },
9919   { 0, CODE_FOR_spe_evmhossfa, "__builtin_spe_evmhossfa", SPE_BUILTIN_EVMHOSSFA },
9920   { 0, CODE_FOR_spe_evmhossfaaw, "__builtin_spe_evmhossfaaw", SPE_BUILTIN_EVMHOSSFAAW },
9921   { 0, CODE_FOR_spe_evmhossfanw, "__builtin_spe_evmhossfanw", SPE_BUILTIN_EVMHOSSFANW },
9922   { 0, CODE_FOR_spe_evmhossiaaw, "__builtin_spe_evmhossiaaw", SPE_BUILTIN_EVMHOSSIAAW },
9923   { 0, CODE_FOR_spe_evmhossianw, "__builtin_spe_evmhossianw", SPE_BUILTIN_EVMHOSSIANW },
9924   { 0, CODE_FOR_spe_evmhoumi, "__builtin_spe_evmhoumi", SPE_BUILTIN_EVMHOUMI },
9925   { 0, CODE_FOR_spe_evmhoumia, "__builtin_spe_evmhoumia", SPE_BUILTIN_EVMHOUMIA },
9926   { 0, CODE_FOR_spe_evmhoumiaaw, "__builtin_spe_evmhoumiaaw", SPE_BUILTIN_EVMHOUMIAAW },
9927   { 0, CODE_FOR_spe_evmhoumianw, "__builtin_spe_evmhoumianw", SPE_BUILTIN_EVMHOUMIANW },
9928   { 0, CODE_FOR_spe_evmhousiaaw, "__builtin_spe_evmhousiaaw", SPE_BUILTIN_EVMHOUSIAAW },
9929   { 0, CODE_FOR_spe_evmhousianw, "__builtin_spe_evmhousianw", SPE_BUILTIN_EVMHOUSIANW },
9930   { 0, CODE_FOR_spe_evmwhsmf, "__builtin_spe_evmwhsmf", SPE_BUILTIN_EVMWHSMF },
9931   { 0, CODE_FOR_spe_evmwhsmfa, "__builtin_spe_evmwhsmfa", SPE_BUILTIN_EVMWHSMFA },
9932   { 0, CODE_FOR_spe_evmwhsmi, "__builtin_spe_evmwhsmi", SPE_BUILTIN_EVMWHSMI },
9933   { 0, CODE_FOR_spe_evmwhsmia, "__builtin_spe_evmwhsmia", SPE_BUILTIN_EVMWHSMIA },
9934   { 0, CODE_FOR_spe_evmwhssf, "__builtin_spe_evmwhssf", SPE_BUILTIN_EVMWHSSF },
9935   { 0, CODE_FOR_spe_evmwhssfa, "__builtin_spe_evmwhssfa", SPE_BUILTIN_EVMWHSSFA },
9936   { 0, CODE_FOR_spe_evmwhumi, "__builtin_spe_evmwhumi", SPE_BUILTIN_EVMWHUMI },
9937   { 0, CODE_FOR_spe_evmwhumia, "__builtin_spe_evmwhumia", SPE_BUILTIN_EVMWHUMIA },
9938   { 0, CODE_FOR_spe_evmwlsmiaaw, "__builtin_spe_evmwlsmiaaw", SPE_BUILTIN_EVMWLSMIAAW },
9939   { 0, CODE_FOR_spe_evmwlsmianw, "__builtin_spe_evmwlsmianw", SPE_BUILTIN_EVMWLSMIANW },
9940   { 0, CODE_FOR_spe_evmwlssiaaw, "__builtin_spe_evmwlssiaaw", SPE_BUILTIN_EVMWLSSIAAW },
9941   { 0, CODE_FOR_spe_evmwlssianw, "__builtin_spe_evmwlssianw", SPE_BUILTIN_EVMWLSSIANW },
9942   { 0, CODE_FOR_spe_evmwlumi, "__builtin_spe_evmwlumi", SPE_BUILTIN_EVMWLUMI },
9943   { 0, CODE_FOR_spe_evmwlumia, "__builtin_spe_evmwlumia", SPE_BUILTIN_EVMWLUMIA },
9944   { 0, CODE_FOR_spe_evmwlumiaaw, "__builtin_spe_evmwlumiaaw", SPE_BUILTIN_EVMWLUMIAAW },
9945   { 0, CODE_FOR_spe_evmwlumianw, "__builtin_spe_evmwlumianw", SPE_BUILTIN_EVMWLUMIANW },
9946   { 0, CODE_FOR_spe_evmwlusiaaw, "__builtin_spe_evmwlusiaaw", SPE_BUILTIN_EVMWLUSIAAW },
9947   { 0, CODE_FOR_spe_evmwlusianw, "__builtin_spe_evmwlusianw", SPE_BUILTIN_EVMWLUSIANW },
9948   { 0, CODE_FOR_spe_evmwsmf, "__builtin_spe_evmwsmf", SPE_BUILTIN_EVMWSMF },
9949   { 0, CODE_FOR_spe_evmwsmfa, "__builtin_spe_evmwsmfa", SPE_BUILTIN_EVMWSMFA },
9950   { 0, CODE_FOR_spe_evmwsmfaa, "__builtin_spe_evmwsmfaa", SPE_BUILTIN_EVMWSMFAA },
9951   { 0, CODE_FOR_spe_evmwsmfan, "__builtin_spe_evmwsmfan", SPE_BUILTIN_EVMWSMFAN },
9952   { 0, CODE_FOR_spe_evmwsmi, "__builtin_spe_evmwsmi", SPE_BUILTIN_EVMWSMI },
9953   { 0, CODE_FOR_spe_evmwsmia, "__builtin_spe_evmwsmia", SPE_BUILTIN_EVMWSMIA },
9954   { 0, CODE_FOR_spe_evmwsmiaa, "__builtin_spe_evmwsmiaa", SPE_BUILTIN_EVMWSMIAA },
9955   { 0, CODE_FOR_spe_evmwsmian, "__builtin_spe_evmwsmian", SPE_BUILTIN_EVMWSMIAN },
9956   { 0, CODE_FOR_spe_evmwssf, "__builtin_spe_evmwssf", SPE_BUILTIN_EVMWSSF },
9957   { 0, CODE_FOR_spe_evmwssfa, "__builtin_spe_evmwssfa", SPE_BUILTIN_EVMWSSFA },
9958   { 0, CODE_FOR_spe_evmwssfaa, "__builtin_spe_evmwssfaa", SPE_BUILTIN_EVMWSSFAA },
9959   { 0, CODE_FOR_spe_evmwssfan, "__builtin_spe_evmwssfan", SPE_BUILTIN_EVMWSSFAN },
9960   { 0, CODE_FOR_spe_evmwumi, "__builtin_spe_evmwumi", SPE_BUILTIN_EVMWUMI },
9961   { 0, CODE_FOR_spe_evmwumia, "__builtin_spe_evmwumia", SPE_BUILTIN_EVMWUMIA },
9962   { 0, CODE_FOR_spe_evmwumiaa, "__builtin_spe_evmwumiaa", SPE_BUILTIN_EVMWUMIAA },
9963   { 0, CODE_FOR_spe_evmwumian, "__builtin_spe_evmwumian", SPE_BUILTIN_EVMWUMIAN },
9964   { 0, CODE_FOR_spe_evnand, "__builtin_spe_evnand", SPE_BUILTIN_EVNAND },
9965   { 0, CODE_FOR_spe_evnor, "__builtin_spe_evnor", SPE_BUILTIN_EVNOR },
9966   { 0, CODE_FOR_spe_evor, "__builtin_spe_evor", SPE_BUILTIN_EVOR },
9967   { 0, CODE_FOR_spe_evorc, "__builtin_spe_evorc", SPE_BUILTIN_EVORC },
9968   { 0, CODE_FOR_spe_evrlw, "__builtin_spe_evrlw", SPE_BUILTIN_EVRLW },
9969   { 0, CODE_FOR_spe_evslw, "__builtin_spe_evslw", SPE_BUILTIN_EVSLW },
9970   { 0, CODE_FOR_spe_evsrws, "__builtin_spe_evsrws", SPE_BUILTIN_EVSRWS },
9971   { 0, CODE_FOR_spe_evsrwu, "__builtin_spe_evsrwu", SPE_BUILTIN_EVSRWU },
9972   { 0, CODE_FOR_subv2si3, "__builtin_spe_evsubfw", SPE_BUILTIN_EVSUBFW },
9973
9974   /* SPE binary operations expecting a 5-bit unsigned literal.  */
9975   { 0, CODE_FOR_spe_evaddiw, "__builtin_spe_evaddiw", SPE_BUILTIN_EVADDIW },
9976
9977   { 0, CODE_FOR_spe_evrlwi, "__builtin_spe_evrlwi", SPE_BUILTIN_EVRLWI },
9978   { 0, CODE_FOR_spe_evslwi, "__builtin_spe_evslwi", SPE_BUILTIN_EVSLWI },
9979   { 0, CODE_FOR_spe_evsrwis, "__builtin_spe_evsrwis", SPE_BUILTIN_EVSRWIS },
9980   { 0, CODE_FOR_spe_evsrwiu, "__builtin_spe_evsrwiu", SPE_BUILTIN_EVSRWIU },
9981   { 0, CODE_FOR_spe_evsubifw, "__builtin_spe_evsubifw", SPE_BUILTIN_EVSUBIFW },
9982   { 0, CODE_FOR_spe_evmwhssfaa, "__builtin_spe_evmwhssfaa", SPE_BUILTIN_EVMWHSSFAA },
9983   { 0, CODE_FOR_spe_evmwhssmaa, "__builtin_spe_evmwhssmaa", SPE_BUILTIN_EVMWHSSMAA },
9984   { 0, CODE_FOR_spe_evmwhsmfaa, "__builtin_spe_evmwhsmfaa", SPE_BUILTIN_EVMWHSMFAA },
9985   { 0, CODE_FOR_spe_evmwhsmiaa, "__builtin_spe_evmwhsmiaa", SPE_BUILTIN_EVMWHSMIAA },
9986   { 0, CODE_FOR_spe_evmwhusiaa, "__builtin_spe_evmwhusiaa", SPE_BUILTIN_EVMWHUSIAA },
9987   { 0, CODE_FOR_spe_evmwhumiaa, "__builtin_spe_evmwhumiaa", SPE_BUILTIN_EVMWHUMIAA },
9988   { 0, CODE_FOR_spe_evmwhssfan, "__builtin_spe_evmwhssfan", SPE_BUILTIN_EVMWHSSFAN },
9989   { 0, CODE_FOR_spe_evmwhssian, "__builtin_spe_evmwhssian", SPE_BUILTIN_EVMWHSSIAN },
9990   { 0, CODE_FOR_spe_evmwhsmfan, "__builtin_spe_evmwhsmfan", SPE_BUILTIN_EVMWHSMFAN },
9991   { 0, CODE_FOR_spe_evmwhsmian, "__builtin_spe_evmwhsmian", SPE_BUILTIN_EVMWHSMIAN },
9992   { 0, CODE_FOR_spe_evmwhusian, "__builtin_spe_evmwhusian", SPE_BUILTIN_EVMWHUSIAN },
9993   { 0, CODE_FOR_spe_evmwhumian, "__builtin_spe_evmwhumian", SPE_BUILTIN_EVMWHUMIAN },
9994   { 0, CODE_FOR_spe_evmwhgssfaa, "__builtin_spe_evmwhgssfaa", SPE_BUILTIN_EVMWHGSSFAA },
9995   { 0, CODE_FOR_spe_evmwhgsmfaa, "__builtin_spe_evmwhgsmfaa", SPE_BUILTIN_EVMWHGSMFAA },
9996   { 0, CODE_FOR_spe_evmwhgsmiaa, "__builtin_spe_evmwhgsmiaa", SPE_BUILTIN_EVMWHGSMIAA },
9997   { 0, CODE_FOR_spe_evmwhgumiaa, "__builtin_spe_evmwhgumiaa", SPE_BUILTIN_EVMWHGUMIAA },
9998   { 0, CODE_FOR_spe_evmwhgssfan, "__builtin_spe_evmwhgssfan", SPE_BUILTIN_EVMWHGSSFAN },
9999   { 0, CODE_FOR_spe_evmwhgsmfan, "__builtin_spe_evmwhgsmfan", SPE_BUILTIN_EVMWHGSMFAN },
10000   { 0, CODE_FOR_spe_evmwhgsmian, "__builtin_spe_evmwhgsmian", SPE_BUILTIN_EVMWHGSMIAN },
10001   { 0, CODE_FOR_spe_evmwhgumian, "__builtin_spe_evmwhgumian", SPE_BUILTIN_EVMWHGUMIAN },
10002   { 0, CODE_FOR_spe_brinc, "__builtin_spe_brinc", SPE_BUILTIN_BRINC },
10003
10004   /* Place-holder.  Leave as last binary SPE builtin.  */
10005   { 0, CODE_FOR_xorv2si3, "__builtin_spe_evxor", SPE_BUILTIN_EVXOR }
10006 };
10007
10008 /* AltiVec predicates.  */
10009
10010 struct builtin_description_predicates
10011 {
10012   const unsigned int mask;
10013   const enum insn_code icode;
10014   const char *const name;
10015   const enum rs6000_builtins code;
10016 };
10017
10018 static const struct builtin_description_predicates bdesc_altivec_preds[] =
10019 {
10020   { MASK_ALTIVEC, CODE_FOR_altivec_vcmpbfp_p, "__builtin_altivec_vcmpbfp_p",
10021     ALTIVEC_BUILTIN_VCMPBFP_P },
10022   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_vector_eq_v4sf_p,
10023     "__builtin_altivec_vcmpeqfp_p", ALTIVEC_BUILTIN_VCMPEQFP_P },
10024   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_vector_ge_v4sf_p,
10025     "__builtin_altivec_vcmpgefp_p", ALTIVEC_BUILTIN_VCMPGEFP_P },
10026   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_vector_gt_v4sf_p,
10027     "__builtin_altivec_vcmpgtfp_p", ALTIVEC_BUILTIN_VCMPGTFP_P },
10028   { MASK_ALTIVEC, CODE_FOR_vector_eq_v4si_p, "__builtin_altivec_vcmpequw_p",
10029     ALTIVEC_BUILTIN_VCMPEQUW_P },
10030   { MASK_ALTIVEC, CODE_FOR_vector_gt_v4si_p, "__builtin_altivec_vcmpgtsw_p",
10031     ALTIVEC_BUILTIN_VCMPGTSW_P },
10032   { MASK_ALTIVEC, CODE_FOR_vector_gtu_v4si_p, "__builtin_altivec_vcmpgtuw_p",
10033     ALTIVEC_BUILTIN_VCMPGTUW_P },
10034   { MASK_ALTIVEC, CODE_FOR_vector_eq_v8hi_p, "__builtin_altivec_vcmpequh_p",
10035     ALTIVEC_BUILTIN_VCMPEQUH_P },
10036   { MASK_ALTIVEC, CODE_FOR_vector_gt_v8hi_p, "__builtin_altivec_vcmpgtsh_p",
10037     ALTIVEC_BUILTIN_VCMPGTSH_P },
10038   { MASK_ALTIVEC, CODE_FOR_vector_gtu_v8hi_p, "__builtin_altivec_vcmpgtuh_p",
10039     ALTIVEC_BUILTIN_VCMPGTUH_P },
10040   { MASK_ALTIVEC, CODE_FOR_vector_eq_v16qi_p, "__builtin_altivec_vcmpequb_p",
10041     ALTIVEC_BUILTIN_VCMPEQUB_P },
10042   { MASK_ALTIVEC, CODE_FOR_vector_gt_v16qi_p, "__builtin_altivec_vcmpgtsb_p",
10043     ALTIVEC_BUILTIN_VCMPGTSB_P },
10044   { MASK_ALTIVEC, CODE_FOR_vector_gtu_v16qi_p, "__builtin_altivec_vcmpgtub_p",
10045     ALTIVEC_BUILTIN_VCMPGTUB_P },
10046
10047   { MASK_VSX, CODE_FOR_vector_eq_v4sf_p, "__builtin_vsx_xvcmpeqsp_p",
10048     VSX_BUILTIN_XVCMPEQSP_P },
10049   { MASK_VSX, CODE_FOR_vector_ge_v4sf_p, "__builtin_vsx_xvcmpgesp_p",
10050     VSX_BUILTIN_XVCMPGESP_P },
10051   { MASK_VSX, CODE_FOR_vector_gt_v4sf_p, "__builtin_vsx_xvcmpgtsp_p",
10052     VSX_BUILTIN_XVCMPGTSP_P },
10053   { MASK_VSX, CODE_FOR_vector_eq_v2df_p, "__builtin_vsx_xvcmpeqdp_p",
10054     VSX_BUILTIN_XVCMPEQDP_P },
10055   { MASK_VSX, CODE_FOR_vector_ge_v2df_p, "__builtin_vsx_xvcmpgedp_p",
10056     VSX_BUILTIN_XVCMPGEDP_P },
10057   { MASK_VSX, CODE_FOR_vector_gt_v2df_p, "__builtin_vsx_xvcmpgtdp_p",
10058     VSX_BUILTIN_XVCMPGTDP_P },
10059
10060   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_vcmpeq_p",
10061     ALTIVEC_BUILTIN_VCMPEQ_P },
10062   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_vcmpgt_p",
10063     ALTIVEC_BUILTIN_VCMPGT_P },
10064   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_nothing, "__builtin_vec_vcmpge_p",
10065     ALTIVEC_BUILTIN_VCMPGE_P }
10066 };
10067
10068 /* SPE predicates.  */
10069 static struct builtin_description bdesc_spe_predicates[] =
10070 {
10071   /* Place-holder.  Leave as first.  */
10072   { 0, CODE_FOR_spe_evcmpeq, "__builtin_spe_evcmpeq", SPE_BUILTIN_EVCMPEQ },
10073   { 0, CODE_FOR_spe_evcmpgts, "__builtin_spe_evcmpgts", SPE_BUILTIN_EVCMPGTS },
10074   { 0, CODE_FOR_spe_evcmpgtu, "__builtin_spe_evcmpgtu", SPE_BUILTIN_EVCMPGTU },
10075   { 0, CODE_FOR_spe_evcmplts, "__builtin_spe_evcmplts", SPE_BUILTIN_EVCMPLTS },
10076   { 0, CODE_FOR_spe_evcmpltu, "__builtin_spe_evcmpltu", SPE_BUILTIN_EVCMPLTU },
10077   { 0, CODE_FOR_spe_evfscmpeq, "__builtin_spe_evfscmpeq", SPE_BUILTIN_EVFSCMPEQ },
10078   { 0, CODE_FOR_spe_evfscmpgt, "__builtin_spe_evfscmpgt", SPE_BUILTIN_EVFSCMPGT },
10079   { 0, CODE_FOR_spe_evfscmplt, "__builtin_spe_evfscmplt", SPE_BUILTIN_EVFSCMPLT },
10080   { 0, CODE_FOR_spe_evfststeq, "__builtin_spe_evfststeq", SPE_BUILTIN_EVFSTSTEQ },
10081   { 0, CODE_FOR_spe_evfststgt, "__builtin_spe_evfststgt", SPE_BUILTIN_EVFSTSTGT },
10082   /* Place-holder.  Leave as last.  */
10083   { 0, CODE_FOR_spe_evfststlt, "__builtin_spe_evfststlt", SPE_BUILTIN_EVFSTSTLT },
10084 };
10085
10086 /* SPE evsel predicates.  */
10087 static struct builtin_description bdesc_spe_evsel[] =
10088 {
10089   /* Place-holder.  Leave as first.  */
10090   { 0, CODE_FOR_spe_evcmpgts, "__builtin_spe_evsel_gts", SPE_BUILTIN_EVSEL_CMPGTS },
10091   { 0, CODE_FOR_spe_evcmpgtu, "__builtin_spe_evsel_gtu", SPE_BUILTIN_EVSEL_CMPGTU },
10092   { 0, CODE_FOR_spe_evcmplts, "__builtin_spe_evsel_lts", SPE_BUILTIN_EVSEL_CMPLTS },
10093   { 0, CODE_FOR_spe_evcmpltu, "__builtin_spe_evsel_ltu", SPE_BUILTIN_EVSEL_CMPLTU },
10094   { 0, CODE_FOR_spe_evcmpeq, "__builtin_spe_evsel_eq", SPE_BUILTIN_EVSEL_CMPEQ },
10095   { 0, CODE_FOR_spe_evfscmpgt, "__builtin_spe_evsel_fsgt", SPE_BUILTIN_EVSEL_FSCMPGT },
10096   { 0, CODE_FOR_spe_evfscmplt, "__builtin_spe_evsel_fslt", SPE_BUILTIN_EVSEL_FSCMPLT },
10097   { 0, CODE_FOR_spe_evfscmpeq, "__builtin_spe_evsel_fseq", SPE_BUILTIN_EVSEL_FSCMPEQ },
10098   { 0, CODE_FOR_spe_evfststgt, "__builtin_spe_evsel_fststgt", SPE_BUILTIN_EVSEL_FSTSTGT },
10099   { 0, CODE_FOR_spe_evfststlt, "__builtin_spe_evsel_fststlt", SPE_BUILTIN_EVSEL_FSTSTLT },
10100   /* Place-holder.  Leave as last.  */
10101   { 0, CODE_FOR_spe_evfststeq, "__builtin_spe_evsel_fststeq", SPE_BUILTIN_EVSEL_FSTSTEQ },
10102 };
10103
10104 /* PAIRED predicates.  */
10105 static const struct builtin_description bdesc_paired_preds[] =
10106 {
10107   /* Place-holder.  Leave as first.  */
10108   { 0, CODE_FOR_paired_cmpu0, "__builtin_paired_cmpu0", PAIRED_BUILTIN_CMPU0 },
10109   /* Place-holder.  Leave as last.  */
10110   { 0, CODE_FOR_paired_cmpu1, "__builtin_paired_cmpu1", PAIRED_BUILTIN_CMPU1 },
10111 };
10112
10113 /* ABS* operations.  */
10114
10115 static const struct builtin_description bdesc_abs[] =
10116 {
10117   { MASK_ALTIVEC, CODE_FOR_absv4si2, "__builtin_altivec_abs_v4si", ALTIVEC_BUILTIN_ABS_V4SI },
10118   { MASK_ALTIVEC, CODE_FOR_absv8hi2, "__builtin_altivec_abs_v8hi", ALTIVEC_BUILTIN_ABS_V8HI },
10119   { MASK_ALTIVEC, CODE_FOR_absv4sf2, "__builtin_altivec_abs_v4sf", ALTIVEC_BUILTIN_ABS_V4SF },
10120   { MASK_ALTIVEC, CODE_FOR_absv16qi2, "__builtin_altivec_abs_v16qi", ALTIVEC_BUILTIN_ABS_V16QI },
10121   { MASK_ALTIVEC, CODE_FOR_altivec_abss_v4si, "__builtin_altivec_abss_v4si", ALTIVEC_BUILTIN_ABSS_V4SI },
10122   { MASK_ALTIVEC, CODE_FOR_altivec_abss_v8hi, "__builtin_altivec_abss_v8hi", ALTIVEC_BUILTIN_ABSS_V8HI },
10123   { MASK_ALTIVEC, CODE_FOR_altivec_abss_v16qi, "__builtin_altivec_abss_v16qi", ALTIVEC_BUILTIN_ABSS_V16QI },
10124   { MASK_VSX, CODE_FOR_absv2df2, "__builtin_vsx_xvabsdp", VSX_BUILTIN_XVABSDP },
10125   { MASK_VSX, CODE_FOR_vsx_nabsv2df2, "__builtin_vsx_xvnabsdp", VSX_BUILTIN_XVNABSDP },
10126   { MASK_VSX, CODE_FOR_absv4sf2, "__builtin_vsx_xvabssp", VSX_BUILTIN_XVABSSP },
10127   { MASK_VSX, CODE_FOR_vsx_nabsv4sf2, "__builtin_vsx_xvnabssp", VSX_BUILTIN_XVNABSSP },
10128 };
10129
10130 /* Simple unary operations: VECb = foo (unsigned literal) or VECb =
10131    foo (VECa).  */
10132
10133 static struct builtin_description bdesc_1arg[] =
10134 {
10135   { MASK_ALTIVEC, CODE_FOR_altivec_vexptefp, "__builtin_altivec_vexptefp", ALTIVEC_BUILTIN_VEXPTEFP },
10136   { MASK_ALTIVEC, CODE_FOR_altivec_vlogefp, "__builtin_altivec_vlogefp", ALTIVEC_BUILTIN_VLOGEFP },
10137   { MASK_ALTIVEC, CODE_FOR_rev4sf2, "__builtin_altivec_vrefp", ALTIVEC_BUILTIN_VREFP },
10138   { MASK_ALTIVEC, CODE_FOR_vector_floorv4sf2, "__builtin_altivec_vrfim", ALTIVEC_BUILTIN_VRFIM },
10139   { MASK_ALTIVEC, CODE_FOR_altivec_vrfin, "__builtin_altivec_vrfin", ALTIVEC_BUILTIN_VRFIN },
10140   { MASK_ALTIVEC, CODE_FOR_vector_ceilv4sf2, "__builtin_altivec_vrfip", ALTIVEC_BUILTIN_VRFIP },
10141   { MASK_ALTIVEC, CODE_FOR_vector_btruncv4sf2, "__builtin_altivec_vrfiz", ALTIVEC_BUILTIN_VRFIZ },
10142   { MASK_ALTIVEC, CODE_FOR_rsqrtv4sf2, "__builtin_altivec_vrsqrtfp", ALTIVEC_BUILTIN_VRSQRTFP },
10143   { MASK_ALTIVEC, CODE_FOR_rsqrtev4sf2, "__builtin_altivec_vrsqrtefp", ALTIVEC_BUILTIN_VRSQRTEFP },
10144   { MASK_ALTIVEC, CODE_FOR_altivec_vspltisb, "__builtin_altivec_vspltisb", ALTIVEC_BUILTIN_VSPLTISB },
10145   { MASK_ALTIVEC, CODE_FOR_altivec_vspltish, "__builtin_altivec_vspltish", ALTIVEC_BUILTIN_VSPLTISH },
10146   { MASK_ALTIVEC, CODE_FOR_altivec_vspltisw, "__builtin_altivec_vspltisw", ALTIVEC_BUILTIN_VSPLTISW },
10147   { MASK_ALTIVEC, CODE_FOR_altivec_vupkhsb, "__builtin_altivec_vupkhsb", ALTIVEC_BUILTIN_VUPKHSB },
10148   { MASK_ALTIVEC, CODE_FOR_altivec_vupkhpx, "__builtin_altivec_vupkhpx", ALTIVEC_BUILTIN_VUPKHPX },
10149   { MASK_ALTIVEC, CODE_FOR_altivec_vupkhsh, "__builtin_altivec_vupkhsh", ALTIVEC_BUILTIN_VUPKHSH },
10150   { MASK_ALTIVEC, CODE_FOR_altivec_vupklsb, "__builtin_altivec_vupklsb", ALTIVEC_BUILTIN_VUPKLSB },
10151   { MASK_ALTIVEC, CODE_FOR_altivec_vupklpx, "__builtin_altivec_vupklpx", ALTIVEC_BUILTIN_VUPKLPX },
10152   { MASK_ALTIVEC, CODE_FOR_altivec_vupklsh, "__builtin_altivec_vupklsh", ALTIVEC_BUILTIN_VUPKLSH },
10153
10154   { MASK_VSX, CODE_FOR_negv2df2, "__builtin_vsx_xvnegdp", VSX_BUILTIN_XVNEGDP },
10155   { MASK_VSX, CODE_FOR_sqrtv2df2, "__builtin_vsx_xvsqrtdp", VSX_BUILTIN_XVSQRTDP },
10156   { MASK_VSX, CODE_FOR_rsqrtv2df2, "__builtin_vsx_xvrsqrtdp", VSX_BUILTIN_VEC_RSQRT_V2DF },
10157   { MASK_VSX, CODE_FOR_rsqrtev2df2, "__builtin_vsx_xvrsqrtedp", VSX_BUILTIN_XVRSQRTEDP },
10158   { MASK_VSX, CODE_FOR_vsx_tsqrtv2df2_fe, "__builtin_vsx_xvtsqrtdp_fe", VSX_BUILTIN_XVTSQRTDP_FE },
10159   { MASK_VSX, CODE_FOR_vsx_tsqrtv2df2_fg, "__builtin_vsx_xvtsqrtdp_fg", VSX_BUILTIN_XVTSQRTDP_FG },
10160   { MASK_VSX, CODE_FOR_vsx_frev2df2, "__builtin_vsx_xvredp", VSX_BUILTIN_XVREDP },
10161
10162   { MASK_VSX, CODE_FOR_negv4sf2, "__builtin_vsx_xvnegsp", VSX_BUILTIN_XVNEGSP },
10163   { MASK_VSX, CODE_FOR_sqrtv4sf2, "__builtin_vsx_xvsqrtsp", VSX_BUILTIN_XVSQRTSP },
10164   { MASK_VSX, CODE_FOR_rsqrtv4sf2, "__builtin_vsx_xvrsqrtsp", VSX_BUILTIN_VEC_RSQRT_V4SF },
10165   { MASK_VSX, CODE_FOR_rsqrtev4sf2, "__builtin_vsx_xvrsqrtesp", VSX_BUILTIN_XVRSQRTESP },
10166   { MASK_VSX, CODE_FOR_vsx_tsqrtv4sf2_fe, "__builtin_vsx_xvtsqrtsp_fe", VSX_BUILTIN_XVTSQRTSP_FE },
10167   { MASK_VSX, CODE_FOR_vsx_tsqrtv4sf2_fg, "__builtin_vsx_xvtsqrtsp_fg", VSX_BUILTIN_XVTSQRTSP_FG },
10168   { MASK_VSX, CODE_FOR_vsx_frev4sf2, "__builtin_vsx_xvresp", VSX_BUILTIN_XVRESP },
10169
10170   { MASK_VSX, CODE_FOR_vsx_xscvdpsp, "__builtin_vsx_xscvdpsp", VSX_BUILTIN_XSCVDPSP },
10171   { MASK_VSX, CODE_FOR_vsx_xscvdpsp, "__builtin_vsx_xscvspdp", VSX_BUILTIN_XSCVSPDP },
10172   { MASK_VSX, CODE_FOR_vsx_xvcvdpsp, "__builtin_vsx_xvcvdpsp", VSX_BUILTIN_XVCVDPSP },
10173   { MASK_VSX, CODE_FOR_vsx_xvcvspdp, "__builtin_vsx_xvcvspdp", VSX_BUILTIN_XVCVSPDP },
10174   { MASK_VSX, CODE_FOR_vsx_tsqrtdf2_fe, "__builtin_vsx_xstsqrtdp_fe", VSX_BUILTIN_XSTSQRTDP_FE },
10175   { MASK_VSX, CODE_FOR_vsx_tsqrtdf2_fg, "__builtin_vsx_xstsqrtdp_fg", VSX_BUILTIN_XSTSQRTDP_FG },
10176
10177   { MASK_VSX, CODE_FOR_vsx_fix_truncv2dfv2di2, "__builtin_vsx_xvcvdpsxds", VSX_BUILTIN_XVCVDPSXDS },
10178   { MASK_VSX, CODE_FOR_vsx_fixuns_truncv2dfv2di2, "__builtin_vsx_xvcvdpuxds", VSX_BUILTIN_XVCVDPUXDS },
10179   { MASK_VSX, CODE_FOR_vsx_fixuns_truncv2dfv2di2, "__builtin_vsx_xvcvdpuxds_uns", VSX_BUILTIN_XVCVDPUXDS_UNS },
10180   { MASK_VSX, CODE_FOR_vsx_floatv2div2df2, "__builtin_vsx_xvcvsxddp", VSX_BUILTIN_XVCVSXDDP },
10181   { MASK_VSX, CODE_FOR_vsx_floatunsv2div2df2, "__builtin_vsx_xvcvuxddp", VSX_BUILTIN_XVCVUXDDP },
10182   { MASK_VSX, CODE_FOR_vsx_floatunsv2div2df2, "__builtin_vsx_xvcvuxddp_uns", VSX_BUILTIN_XVCVUXDDP_UNS },
10183
10184   { MASK_VSX, CODE_FOR_vsx_fix_truncv4sfv4si2, "__builtin_vsx_xvcvspsxws", VSX_BUILTIN_XVCVSPSXWS },
10185   { MASK_VSX, CODE_FOR_vsx_fixuns_truncv4sfv4si2, "__builtin_vsx_xvcvspuxws", VSX_BUILTIN_XVCVSPUXWS },
10186   { MASK_VSX, CODE_FOR_vsx_floatv4siv4sf2, "__builtin_vsx_xvcvsxwsp", VSX_BUILTIN_XVCVSXWSP },
10187   { MASK_VSX, CODE_FOR_vsx_floatunsv4siv4sf2, "__builtin_vsx_xvcvuxwsp", VSX_BUILTIN_XVCVUXWSP },
10188
10189   { MASK_VSX, CODE_FOR_vsx_xvcvdpsxws, "__builtin_vsx_xvcvdpsxws", VSX_BUILTIN_XVCVDPSXWS },
10190   { MASK_VSX, CODE_FOR_vsx_xvcvdpuxws, "__builtin_vsx_xvcvdpuxws", VSX_BUILTIN_XVCVDPUXWS },
10191   { MASK_VSX, CODE_FOR_vsx_xvcvsxwdp, "__builtin_vsx_xvcvsxwdp", VSX_BUILTIN_XVCVSXWDP },
10192   { MASK_VSX, CODE_FOR_vsx_xvcvuxwdp, "__builtin_vsx_xvcvuxwdp", VSX_BUILTIN_XVCVUXWDP },
10193   { MASK_VSX, CODE_FOR_vsx_xvrdpi, "__builtin_vsx_xvrdpi", VSX_BUILTIN_XVRDPI },
10194   { MASK_VSX, CODE_FOR_vsx_xvrdpic, "__builtin_vsx_xvrdpic", VSX_BUILTIN_XVRDPIC },
10195   { MASK_VSX, CODE_FOR_vsx_floorv2df2, "__builtin_vsx_xvrdpim", VSX_BUILTIN_XVRDPIM },
10196   { MASK_VSX, CODE_FOR_vsx_ceilv2df2, "__builtin_vsx_xvrdpip", VSX_BUILTIN_XVRDPIP },
10197   { MASK_VSX, CODE_FOR_vsx_btruncv2df2, "__builtin_vsx_xvrdpiz", VSX_BUILTIN_XVRDPIZ },
10198
10199   { MASK_VSX, CODE_FOR_vsx_xvcvspsxds, "__builtin_vsx_xvcvspsxds", VSX_BUILTIN_XVCVSPSXDS },
10200   { MASK_VSX, CODE_FOR_vsx_xvcvspuxds, "__builtin_vsx_xvcvspuxds", VSX_BUILTIN_XVCVSPUXDS },
10201   { MASK_VSX, CODE_FOR_vsx_xvcvsxdsp, "__builtin_vsx_xvcvsxdsp", VSX_BUILTIN_XVCVSXDSP },
10202   { MASK_VSX, CODE_FOR_vsx_xvcvuxdsp, "__builtin_vsx_xvcvuxdsp", VSX_BUILTIN_XVCVUXDSP },
10203   { MASK_VSX, CODE_FOR_vsx_xvrspi, "__builtin_vsx_xvrspi", VSX_BUILTIN_XVRSPI },
10204   { MASK_VSX, CODE_FOR_vsx_xvrspic, "__builtin_vsx_xvrspic", VSX_BUILTIN_XVRSPIC },
10205   { MASK_VSX, CODE_FOR_vsx_floorv4sf2, "__builtin_vsx_xvrspim", VSX_BUILTIN_XVRSPIM },
10206   { MASK_VSX, CODE_FOR_vsx_ceilv4sf2, "__builtin_vsx_xvrspip", VSX_BUILTIN_XVRSPIP },
10207   { MASK_VSX, CODE_FOR_vsx_btruncv4sf2, "__builtin_vsx_xvrspiz", VSX_BUILTIN_XVRSPIZ },
10208
10209   { MASK_VSX, CODE_FOR_vsx_xsrdpi, "__builtin_vsx_xsrdpi", VSX_BUILTIN_XSRDPI },
10210   { MASK_VSX, CODE_FOR_vsx_xsrdpic, "__builtin_vsx_xsrdpic", VSX_BUILTIN_XSRDPIC },
10211   { MASK_VSX, CODE_FOR_vsx_floordf2, "__builtin_vsx_xsrdpim", VSX_BUILTIN_XSRDPIM },
10212   { MASK_VSX, CODE_FOR_vsx_ceildf2, "__builtin_vsx_xsrdpip", VSX_BUILTIN_XSRDPIP },
10213   { MASK_VSX, CODE_FOR_vsx_btruncdf2, "__builtin_vsx_xsrdpiz", VSX_BUILTIN_XSRDPIZ },
10214
10215   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_abs", ALTIVEC_BUILTIN_VEC_ABS },
10216   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_abss", ALTIVEC_BUILTIN_VEC_ABSS },
10217   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_ceil", ALTIVEC_BUILTIN_VEC_CEIL },
10218   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_expte", ALTIVEC_BUILTIN_VEC_EXPTE },
10219   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_floor", ALTIVEC_BUILTIN_VEC_FLOOR },
10220   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_loge", ALTIVEC_BUILTIN_VEC_LOGE },
10221   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_mtvscr", ALTIVEC_BUILTIN_VEC_MTVSCR },
10222   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_re", ALTIVEC_BUILTIN_VEC_RE },
10223   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_round", ALTIVEC_BUILTIN_VEC_ROUND },
10224   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_rsqrt", ALTIVEC_BUILTIN_VEC_RSQRT },
10225   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_rsqrte", ALTIVEC_BUILTIN_VEC_RSQRTE },
10226   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_trunc", ALTIVEC_BUILTIN_VEC_TRUNC },
10227   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_unpackh", ALTIVEC_BUILTIN_VEC_UNPACKH },
10228   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vupkhsh", ALTIVEC_BUILTIN_VEC_VUPKHSH },
10229   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vupkhpx", ALTIVEC_BUILTIN_VEC_VUPKHPX },
10230   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vupkhsb", ALTIVEC_BUILTIN_VEC_VUPKHSB },
10231   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_unpackl", ALTIVEC_BUILTIN_VEC_UNPACKL },
10232   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vupklpx", ALTIVEC_BUILTIN_VEC_VUPKLPX },
10233   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vupklsh", ALTIVEC_BUILTIN_VEC_VUPKLSH },
10234   { MASK_ALTIVEC, CODE_FOR_nothing, "__builtin_vec_vupklsb", ALTIVEC_BUILTIN_VEC_VUPKLSB },
10235
10236   { MASK_VSX, CODE_FOR_nothing, "__builtin_vec_nearbyint", ALTIVEC_BUILTIN_VEC_NEARBYINT },
10237   { MASK_VSX, CODE_FOR_nothing, "__builtin_vec_rint", ALTIVEC_BUILTIN_VEC_RINT },
10238   { MASK_VSX, CODE_FOR_nothing, "__builtin_vec_sqrt", ALTIVEC_BUILTIN_VEC_SQRT },
10239
10240   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_floatv4siv4sf2, "__builtin_vec_float_sisf", VECTOR_BUILTIN_FLOAT_V4SI_V4SF },
10241   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_unsigned_floatv4siv4sf2, "__builtin_vec_uns_float_sisf", VECTOR_BUILTIN_UNSFLOAT_V4SI_V4SF },
10242   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_fix_truncv4sfv4si2, "__builtin_vec_fix_sfsi", VECTOR_BUILTIN_FIX_V4SF_V4SI },
10243   { MASK_ALTIVEC|MASK_VSX, CODE_FOR_fixuns_truncv4sfv4si2, "__builtin_vec_fixuns_sfsi", VECTOR_BUILTIN_FIXUNS_V4SF_V4SI },
10244
10245   /* The SPE unary builtins must start with SPE_BUILTIN_EVABS and
10246      end with SPE_BUILTIN_EVSUBFUSIAAW.  */
10247   { 0, CODE_FOR_absv2si2, "__builtin_spe_evabs", SPE_BUILTIN_EVABS },
10248   { 0, CODE_FOR_spe_evaddsmiaaw, "__builtin_spe_evaddsmiaaw", SPE_BUILTIN_EVADDSMIAAW },
10249   { 0, CODE_FOR_spe_evaddssiaaw, "__builtin_spe_evaddssiaaw", SPE_BUILTIN_EVADDSSIAAW },
10250   { 0, CODE_FOR_spe_evaddumiaaw, "__builtin_spe_evaddumiaaw", SPE_BUILTIN_EVADDUMIAAW },
10251   { 0, CODE_FOR_spe_evaddusiaaw, "__builtin_spe_evaddusiaaw", SPE_BUILTIN_EVADDUSIAAW },
10252   { 0, CODE_FOR_spe_evcntlsw, "__builtin_spe_evcntlsw", SPE_BUILTIN_EVCNTLSW },
10253   { 0, CODE_FOR_spe_evcntlzw, "__builtin_spe_evcntlzw", SPE_BUILTIN_EVCNTLZW },
10254   { 0, CODE_FOR_spe_evextsb, "__builtin_spe_evextsb", SPE_BUILTIN_EVEXTSB },
10255   { 0, CODE_FOR_spe_evextsh, "__builtin_spe_evextsh", SPE_BUILTIN_EVEXTSH },
10256   { 0, CODE_FOR_spe_evfsabs, "__builtin_spe_evfsabs", SPE_BUILTIN_EVFSABS },
10257   { 0, CODE_FOR_spe_evfscfsf, "__builtin_spe_evfscfsf", SPE_BUILTIN_EVFSCFSF },
10258   { 0, CODE_FOR_spe_evfscfsi, "__builtin_spe_evfscfsi", SPE_BUILTIN_EVFSCFSI },
10259   { 0, CODE_FOR_spe_evfscfuf, "__builtin_spe_evfscfuf", SPE_BUILTIN_EVFSCFUF },
10260   { 0, CODE_FOR_spe_evfscfui, "__builtin_spe_evfscfui", SPE_BUILTIN_EVFSCFUI },
10261   { 0, CODE_FOR_spe_evfsctsf, "__builtin_spe_evfsctsf", SPE_BUILTIN_EVFSCTSF },
10262   { 0, CODE_FOR_spe_evfsctsi, "__builtin_spe_evfsctsi", SPE_BUILTIN_EVFSCTSI },
10263   { 0, CODE_FOR_spe_evfsctsiz, "__builtin_spe_evfsctsiz", SPE_BUILTIN_EVFSCTSIZ },
10264   { 0, CODE_FOR_spe_evfsctuf, "__builtin_spe_evfsctuf", SPE_BUILTIN_EVFSCTUF },
10265   { 0, CODE_FOR_spe_evfsctui, "__builtin_spe_evfsctui", SPE_BUILTIN_EVFSCTUI },
10266   { 0, CODE_FOR_spe_evfsctuiz, "__builtin_spe_evfsctuiz", SPE_BUILTIN_EVFSCTUIZ },
10267   { 0, CODE_FOR_spe_evfsnabs, "__builtin_spe_evfsnabs", SPE_BUILTIN_EVFSNABS },
10268   { 0, CODE_FOR_spe_evfsneg, "__builtin_spe_evfsneg", SPE_BUILTIN_EVFSNEG },
10269   { 0, CODE_FOR_spe_evmra, "__builtin_spe_evmra", SPE_BUILTIN_EVMRA },
10270   { 0, CODE_FOR_negv2si2, "__builtin_spe_evneg", SPE_BUILTIN_EVNEG },
10271   { 0, CODE_FOR_spe_evrndw, "__builtin_spe_evrndw", SPE_BUILTIN_EVRNDW },
10272   { 0, CODE_FOR_spe_evsubfsmiaaw, "__builtin_spe_evsubfsmiaaw", SPE_BUILTIN_EVSUBFSMIAAW },
10273   { 0, CODE_FOR_spe_evsubfssiaaw, "__builtin_spe_evsubfssiaaw", SPE_BUILTIN_EVSUBFSSIAAW },
10274   { 0, CODE_FOR_spe_evsubfumiaaw, "__builtin_spe_evsubfumiaaw", SPE_BUILTIN_EVSUBFUMIAAW },
10275
10276   /* Place-holder.  Leave as last unary SPE builtin.  */
10277   { 0, CODE_FOR_spe_evsubfusiaaw, "__builtin_spe_evsubfusiaaw", SPE_BUILTIN_EVSUBFUSIAAW },
10278
10279   { 0, CODE_FOR_paired_absv2sf2, "__builtin_paired_absv2sf2", PAIRED_BUILTIN_ABSV2SF2 },
10280   { 0, CODE_FOR_nabsv2sf2, "__builtin_paired_nabsv2sf2", PAIRED_BUILTIN_NABSV2SF2 },
10281   { 0, CODE_FOR_paired_negv2sf2, "__builtin_paired_negv2sf2", PAIRED_BUILTIN_NEGV2SF2 },
10282   { 0, CODE_FOR_sqrtv2sf2, "__builtin_paired_sqrtv2sf2", PAIRED_BUILTIN_SQRTV2SF2 },
10283   { 0, CODE_FOR_resv2sf2, "__builtin_paired_resv2sf2", PAIRED_BUILTIN_RESV2SF2 }
10284 };
10285
10286 static rtx
10287 rs6000_expand_unop_builtin (enum insn_code icode, tree exp, rtx target)
10288 {
10289   rtx pat;
10290   tree arg0 = CALL_EXPR_ARG (exp, 0);
10291   rtx op0 = expand_normal (arg0);
10292   enum machine_mode tmode = insn_data[icode].operand[0].mode;
10293   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
10294
10295   if (icode == CODE_FOR_nothing)
10296     /* Builtin not supported on this processor.  */
10297     return 0;
10298
10299   /* If we got invalid arguments bail out before generating bad rtl.  */
10300   if (arg0 == error_mark_node)
10301     return const0_rtx;
10302
10303   if (icode == CODE_FOR_altivec_vspltisb
10304       || icode == CODE_FOR_altivec_vspltish
10305       || icode == CODE_FOR_altivec_vspltisw
10306       || icode == CODE_FOR_spe_evsplatfi
10307       || icode == CODE_FOR_spe_evsplati)
10308     {
10309       /* Only allow 5-bit *signed* literals.  */
10310       if (GET_CODE (op0) != CONST_INT
10311           || INTVAL (op0) > 15
10312           || INTVAL (op0) < -16)
10313         {
10314           error ("argument 1 must be a 5-bit signed literal");
10315           return const0_rtx;
10316         }
10317     }
10318
10319   if (target == 0
10320       || GET_MODE (target) != tmode
10321       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10322     target = gen_reg_rtx (tmode);
10323
10324   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
10325     op0 = copy_to_mode_reg (mode0, op0);
10326
10327   pat = GEN_FCN (icode) (target, op0);
10328   if (! pat)
10329     return 0;
10330   emit_insn (pat);
10331
10332   return target;
10333 }
10334
10335 static rtx
10336 altivec_expand_abs_builtin (enum insn_code icode, tree exp, rtx target)
10337 {
10338   rtx pat, scratch1, scratch2;
10339   tree arg0 = CALL_EXPR_ARG (exp, 0);
10340   rtx op0 = expand_normal (arg0);
10341   enum machine_mode tmode = insn_data[icode].operand[0].mode;
10342   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
10343
10344   /* If we have invalid arguments, bail out before generating bad rtl.  */
10345   if (arg0 == error_mark_node)
10346     return const0_rtx;
10347
10348   if (target == 0
10349       || GET_MODE (target) != tmode
10350       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10351     target = gen_reg_rtx (tmode);
10352
10353   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
10354     op0 = copy_to_mode_reg (mode0, op0);
10355
10356   scratch1 = gen_reg_rtx (mode0);
10357   scratch2 = gen_reg_rtx (mode0);
10358
10359   pat = GEN_FCN (icode) (target, op0, scratch1, scratch2);
10360   if (! pat)
10361     return 0;
10362   emit_insn (pat);
10363
10364   return target;
10365 }
10366
10367 static rtx
10368 rs6000_expand_binop_builtin (enum insn_code icode, tree exp, rtx target)
10369 {
10370   rtx pat;
10371   tree arg0 = CALL_EXPR_ARG (exp, 0);
10372   tree arg1 = CALL_EXPR_ARG (exp, 1);
10373   rtx op0 = expand_normal (arg0);
10374   rtx op1 = expand_normal (arg1);
10375   enum machine_mode tmode = insn_data[icode].operand[0].mode;
10376   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
10377   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
10378
10379   if (icode == CODE_FOR_nothing)
10380     /* Builtin not supported on this processor.  */
10381     return 0;
10382
10383   /* If we got invalid arguments bail out before generating bad rtl.  */
10384   if (arg0 == error_mark_node || arg1 == error_mark_node)
10385     return const0_rtx;
10386
10387   if (icode == CODE_FOR_altivec_vcfux
10388       || icode == CODE_FOR_altivec_vcfsx
10389       || icode == CODE_FOR_altivec_vctsxs
10390       || icode == CODE_FOR_altivec_vctuxs
10391       || icode == CODE_FOR_altivec_vspltb
10392       || icode == CODE_FOR_altivec_vsplth
10393       || icode == CODE_FOR_altivec_vspltw
10394       || icode == CODE_FOR_spe_evaddiw
10395       || icode == CODE_FOR_spe_evldd
10396       || icode == CODE_FOR_spe_evldh
10397       || icode == CODE_FOR_spe_evldw
10398       || icode == CODE_FOR_spe_evlhhesplat
10399       || icode == CODE_FOR_spe_evlhhossplat
10400       || icode == CODE_FOR_spe_evlhhousplat
10401       || icode == CODE_FOR_spe_evlwhe
10402       || icode == CODE_FOR_spe_evlwhos
10403       || icode == CODE_FOR_spe_evlwhou
10404       || icode == CODE_FOR_spe_evlwhsplat
10405       || icode == CODE_FOR_spe_evlwwsplat
10406       || icode == CODE_FOR_spe_evrlwi
10407       || icode == CODE_FOR_spe_evslwi
10408       || icode == CODE_FOR_spe_evsrwis
10409       || icode == CODE_FOR_spe_evsubifw
10410       || icode == CODE_FOR_spe_evsrwiu)
10411     {
10412       /* Only allow 5-bit unsigned literals.  */
10413       STRIP_NOPS (arg1);
10414       if (TREE_CODE (arg1) != INTEGER_CST
10415           || TREE_INT_CST_LOW (arg1) & ~0x1f)
10416         {
10417           error ("argument 2 must be a 5-bit unsigned literal");
10418           return const0_rtx;
10419         }
10420     }
10421
10422   if (target == 0
10423       || GET_MODE (target) != tmode
10424       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10425     target = gen_reg_rtx (tmode);
10426
10427   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
10428     op0 = copy_to_mode_reg (mode0, op0);
10429   if (! (*insn_data[icode].operand[2].predicate) (op1, mode1))
10430     op1 = copy_to_mode_reg (mode1, op1);
10431
10432   pat = GEN_FCN (icode) (target, op0, op1);
10433   if (! pat)
10434     return 0;
10435   emit_insn (pat);
10436
10437   return target;
10438 }
10439
10440 static rtx
10441 altivec_expand_predicate_builtin (enum insn_code icode, tree exp, rtx target)
10442 {
10443   rtx pat, scratch;
10444   tree cr6_form = CALL_EXPR_ARG (exp, 0);
10445   tree arg0 = CALL_EXPR_ARG (exp, 1);
10446   tree arg1 = CALL_EXPR_ARG (exp, 2);
10447   rtx op0 = expand_normal (arg0);
10448   rtx op1 = expand_normal (arg1);
10449   enum machine_mode tmode = SImode;
10450   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
10451   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
10452   int cr6_form_int;
10453
10454   if (TREE_CODE (cr6_form) != INTEGER_CST)
10455     {
10456       error ("argument 1 of __builtin_altivec_predicate must be a constant");
10457       return const0_rtx;
10458     }
10459   else
10460     cr6_form_int = TREE_INT_CST_LOW (cr6_form);
10461
10462   gcc_assert (mode0 == mode1);
10463
10464   /* If we have invalid arguments, bail out before generating bad rtl.  */
10465   if (arg0 == error_mark_node || arg1 == error_mark_node)
10466     return const0_rtx;
10467
10468   if (target == 0
10469       || GET_MODE (target) != tmode
10470       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10471     target = gen_reg_rtx (tmode);
10472
10473   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
10474     op0 = copy_to_mode_reg (mode0, op0);
10475   if (! (*insn_data[icode].operand[2].predicate) (op1, mode1))
10476     op1 = copy_to_mode_reg (mode1, op1);
10477
10478   scratch = gen_reg_rtx (mode0);
10479
10480   pat = GEN_FCN (icode) (scratch, op0, op1);
10481   if (! pat)
10482     return 0;
10483   emit_insn (pat);
10484
10485   /* The vec_any* and vec_all* predicates use the same opcodes for two
10486      different operations, but the bits in CR6 will be different
10487      depending on what information we want.  So we have to play tricks
10488      with CR6 to get the right bits out.
10489
10490      If you think this is disgusting, look at the specs for the
10491      AltiVec predicates.  */
10492
10493   switch (cr6_form_int)
10494     {
10495     case 0:
10496       emit_insn (gen_cr6_test_for_zero (target));
10497       break;
10498     case 1:
10499       emit_insn (gen_cr6_test_for_zero_reverse (target));
10500       break;
10501     case 2:
10502       emit_insn (gen_cr6_test_for_lt (target));
10503       break;
10504     case 3:
10505       emit_insn (gen_cr6_test_for_lt_reverse (target));
10506       break;
10507     default:
10508       error ("argument 1 of __builtin_altivec_predicate is out of range");
10509       break;
10510     }
10511
10512   return target;
10513 }
10514
10515 static rtx
10516 paired_expand_lv_builtin (enum insn_code icode, tree exp, rtx target)
10517 {
10518   rtx pat, addr;
10519   tree arg0 = CALL_EXPR_ARG (exp, 0);
10520   tree arg1 = CALL_EXPR_ARG (exp, 1);
10521   enum machine_mode tmode = insn_data[icode].operand[0].mode;
10522   enum machine_mode mode0 = Pmode;
10523   enum machine_mode mode1 = Pmode;
10524   rtx op0 = expand_normal (arg0);
10525   rtx op1 = expand_normal (arg1);
10526
10527   if (icode == CODE_FOR_nothing)
10528     /* Builtin not supported on this processor.  */
10529     return 0;
10530
10531   /* If we got invalid arguments bail out before generating bad rtl.  */
10532   if (arg0 == error_mark_node || arg1 == error_mark_node)
10533     return const0_rtx;
10534
10535   if (target == 0
10536       || GET_MODE (target) != tmode
10537       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10538     target = gen_reg_rtx (tmode);
10539
10540   op1 = copy_to_mode_reg (mode1, op1);
10541
10542   if (op0 == const0_rtx)
10543     {
10544       addr = gen_rtx_MEM (tmode, op1);
10545     }
10546   else
10547     {
10548       op0 = copy_to_mode_reg (mode0, op0);
10549       addr = gen_rtx_MEM (tmode, gen_rtx_PLUS (Pmode, op0, op1));
10550     }
10551
10552   pat = GEN_FCN (icode) (target, addr);
10553
10554   if (! pat)
10555     return 0;
10556   emit_insn (pat);
10557
10558   return target;
10559 }
10560
10561 static rtx
10562 altivec_expand_lv_builtin (enum insn_code icode, tree exp, rtx target, bool blk)
10563 {
10564   rtx pat, addr;
10565   tree arg0 = CALL_EXPR_ARG (exp, 0);
10566   tree arg1 = CALL_EXPR_ARG (exp, 1);
10567   enum machine_mode tmode = insn_data[icode].operand[0].mode;
10568   enum machine_mode mode0 = Pmode;
10569   enum machine_mode mode1 = Pmode;
10570   rtx op0 = expand_normal (arg0);
10571   rtx op1 = expand_normal (arg1);
10572
10573   if (icode == CODE_FOR_nothing)
10574     /* Builtin not supported on this processor.  */
10575     return 0;
10576
10577   /* If we got invalid arguments bail out before generating bad rtl.  */
10578   if (arg0 == error_mark_node || arg1 == error_mark_node)
10579     return const0_rtx;
10580
10581   if (target == 0
10582       || GET_MODE (target) != tmode
10583       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10584     target = gen_reg_rtx (tmode);
10585
10586   op1 = copy_to_mode_reg (mode1, op1);
10587
10588   if (op0 == const0_rtx)
10589     {
10590       addr = gen_rtx_MEM (blk ? BLKmode : tmode, op1);
10591     }
10592   else
10593     {
10594       op0 = copy_to_mode_reg (mode0, op0);
10595       addr = gen_rtx_MEM (blk ? BLKmode : tmode, gen_rtx_PLUS (Pmode, op0, op1));
10596     }
10597
10598   pat = GEN_FCN (icode) (target, addr);
10599
10600   if (! pat)
10601     return 0;
10602   emit_insn (pat);
10603
10604   return target;
10605 }
10606
10607 static rtx
10608 spe_expand_stv_builtin (enum insn_code icode, tree exp)
10609 {
10610   tree arg0 = CALL_EXPR_ARG (exp, 0);
10611   tree arg1 = CALL_EXPR_ARG (exp, 1);
10612   tree arg2 = CALL_EXPR_ARG (exp, 2);
10613   rtx op0 = expand_normal (arg0);
10614   rtx op1 = expand_normal (arg1);
10615   rtx op2 = expand_normal (arg2);
10616   rtx pat;
10617   enum machine_mode mode0 = insn_data[icode].operand[0].mode;
10618   enum machine_mode mode1 = insn_data[icode].operand[1].mode;
10619   enum machine_mode mode2 = insn_data[icode].operand[2].mode;
10620
10621   /* Invalid arguments.  Bail before doing anything stoopid!  */
10622   if (arg0 == error_mark_node
10623       || arg1 == error_mark_node
10624       || arg2 == error_mark_node)
10625     return const0_rtx;
10626
10627   if (! (*insn_data[icode].operand[2].predicate) (op0, mode2))
10628     op0 = copy_to_mode_reg (mode2, op0);
10629   if (! (*insn_data[icode].operand[0].predicate) (op1, mode0))
10630     op1 = copy_to_mode_reg (mode0, op1);
10631   if (! (*insn_data[icode].operand[1].predicate) (op2, mode1))
10632     op2 = copy_to_mode_reg (mode1, op2);
10633
10634   pat = GEN_FCN (icode) (op1, op2, op0);
10635   if (pat)
10636     emit_insn (pat);
10637   return NULL_RTX;
10638 }
10639
10640 static rtx
10641 paired_expand_stv_builtin (enum insn_code icode, tree exp)
10642 {
10643   tree arg0 = CALL_EXPR_ARG (exp, 0);
10644   tree arg1 = CALL_EXPR_ARG (exp, 1);
10645   tree arg2 = CALL_EXPR_ARG (exp, 2);
10646   rtx op0 = expand_normal (arg0);
10647   rtx op1 = expand_normal (arg1);
10648   rtx op2 = expand_normal (arg2);
10649   rtx pat, addr;
10650   enum machine_mode tmode = insn_data[icode].operand[0].mode;
10651   enum machine_mode mode1 = Pmode;
10652   enum machine_mode mode2 = Pmode;
10653
10654   /* Invalid arguments.  Bail before doing anything stoopid!  */
10655   if (arg0 == error_mark_node
10656       || arg1 == error_mark_node
10657       || arg2 == error_mark_node)
10658     return const0_rtx;
10659
10660   if (! (*insn_data[icode].operand[1].predicate) (op0, tmode))
10661     op0 = copy_to_mode_reg (tmode, op0);
10662
10663   op2 = copy_to_mode_reg (mode2, op2);
10664
10665   if (op1 == const0_rtx)
10666     {
10667       addr = gen_rtx_MEM (tmode, op2);
10668     }
10669   else
10670     {
10671       op1 = copy_to_mode_reg (mode1, op1);
10672       addr = gen_rtx_MEM (tmode, gen_rtx_PLUS (Pmode, op1, op2));
10673     }
10674
10675   pat = GEN_FCN (icode) (addr, op0);
10676   if (pat)
10677     emit_insn (pat);
10678   return NULL_RTX;
10679 }
10680
10681 static rtx
10682 altivec_expand_stv_builtin (enum insn_code icode, tree exp)
10683 {
10684   tree arg0 = CALL_EXPR_ARG (exp, 0);
10685   tree arg1 = CALL_EXPR_ARG (exp, 1);
10686   tree arg2 = CALL_EXPR_ARG (exp, 2);
10687   rtx op0 = expand_normal (arg0);
10688   rtx op1 = expand_normal (arg1);
10689   rtx op2 = expand_normal (arg2);
10690   rtx pat, addr;
10691   enum machine_mode tmode = insn_data[icode].operand[0].mode;
10692   enum machine_mode smode = insn_data[icode].operand[1].mode;
10693   enum machine_mode mode1 = Pmode;
10694   enum machine_mode mode2 = Pmode;
10695
10696   /* Invalid arguments.  Bail before doing anything stoopid!  */
10697   if (arg0 == error_mark_node
10698       || arg1 == error_mark_node
10699       || arg2 == error_mark_node)
10700     return const0_rtx;
10701
10702   if (! (*insn_data[icode].operand[1].predicate) (op0, smode))
10703     op0 = copy_to_mode_reg (smode, op0);
10704
10705   op2 = copy_to_mode_reg (mode2, op2);
10706
10707   if (op1 == const0_rtx)
10708     {
10709       addr = gen_rtx_MEM (tmode, op2);
10710     }
10711   else
10712     {
10713       op1 = copy_to_mode_reg (mode1, op1);
10714       addr = gen_rtx_MEM (tmode, gen_rtx_PLUS (Pmode, op1, op2));
10715     }
10716
10717   pat = GEN_FCN (icode) (addr, op0);
10718   if (pat)
10719     emit_insn (pat);
10720   return NULL_RTX;
10721 }
10722
10723 static rtx
10724 rs6000_expand_ternop_builtin (enum insn_code icode, tree exp, rtx target)
10725 {
10726   rtx pat;
10727   tree arg0 = CALL_EXPR_ARG (exp, 0);
10728   tree arg1 = CALL_EXPR_ARG (exp, 1);
10729   tree arg2 = CALL_EXPR_ARG (exp, 2);
10730   rtx op0 = expand_normal (arg0);
10731   rtx op1 = expand_normal (arg1);
10732   rtx op2 = expand_normal (arg2);
10733   enum machine_mode tmode = insn_data[icode].operand[0].mode;
10734   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
10735   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
10736   enum machine_mode mode2 = insn_data[icode].operand[3].mode;
10737
10738   if (icode == CODE_FOR_nothing)
10739     /* Builtin not supported on this processor.  */
10740     return 0;
10741
10742   /* If we got invalid arguments bail out before generating bad rtl.  */
10743   if (arg0 == error_mark_node
10744       || arg1 == error_mark_node
10745       || arg2 == error_mark_node)
10746     return const0_rtx;
10747
10748   /* Check and prepare argument depending on the instruction code.
10749
10750      Note that a switch statement instead of the sequence of tests
10751      would be incorrect as many of the CODE_FOR values could be
10752      CODE_FOR_nothing and that would yield multiple alternatives
10753      with identical values.  We'd never reach here at runtime in
10754      this case.  */
10755   if (icode == CODE_FOR_altivec_vsldoi_v4sf
10756       || icode == CODE_FOR_altivec_vsldoi_v4si
10757       || icode == CODE_FOR_altivec_vsldoi_v8hi
10758       || icode == CODE_FOR_altivec_vsldoi_v16qi)
10759     {
10760       /* Only allow 4-bit unsigned literals.  */
10761       STRIP_NOPS (arg2);
10762       if (TREE_CODE (arg2) != INTEGER_CST
10763           || TREE_INT_CST_LOW (arg2) & ~0xf)
10764         {
10765           error ("argument 3 must be a 4-bit unsigned literal");
10766           return const0_rtx;
10767         }
10768     }
10769   else if (icode == CODE_FOR_vsx_xxpermdi_v2df
10770            || icode == CODE_FOR_vsx_xxpermdi_v2di
10771            || icode == CODE_FOR_vsx_xxsldwi_v16qi
10772            || icode == CODE_FOR_vsx_xxsldwi_v8hi
10773            || icode == CODE_FOR_vsx_xxsldwi_v4si
10774            || icode == CODE_FOR_vsx_xxsldwi_v4sf
10775            || icode == CODE_FOR_vsx_xxsldwi_v2di
10776            || icode == CODE_FOR_vsx_xxsldwi_v2df)
10777     {
10778       /* Only allow 2-bit unsigned literals.  */
10779       STRIP_NOPS (arg2);
10780       if (TREE_CODE (arg2) != INTEGER_CST
10781           || TREE_INT_CST_LOW (arg2) & ~0x3)
10782         {
10783           error ("argument 3 must be a 2-bit unsigned literal");
10784           return const0_rtx;
10785         }
10786     }
10787   else if (icode == CODE_FOR_vsx_set_v2df
10788            || icode == CODE_FOR_vsx_set_v2di)
10789     {
10790       /* Only allow 1-bit unsigned literals.  */
10791       STRIP_NOPS (arg2);
10792       if (TREE_CODE (arg2) != INTEGER_CST
10793           || TREE_INT_CST_LOW (arg2) & ~0x1)
10794         {
10795           error ("argument 3 must be a 1-bit unsigned literal");
10796           return const0_rtx;
10797         }
10798     }
10799
10800   if (target == 0
10801       || GET_MODE (target) != tmode
10802       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10803     target = gen_reg_rtx (tmode);
10804
10805   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
10806     op0 = copy_to_mode_reg (mode0, op0);
10807   if (! (*insn_data[icode].operand[2].predicate) (op1, mode1))
10808     op1 = copy_to_mode_reg (mode1, op1);
10809   if (! (*insn_data[icode].operand[3].predicate) (op2, mode2))
10810     op2 = copy_to_mode_reg (mode2, op2);
10811
10812   if (TARGET_PAIRED_FLOAT && icode == CODE_FOR_selv2sf4)
10813     pat = GEN_FCN (icode) (target, op0, op1, op2, CONST0_RTX (SFmode));
10814   else
10815     pat = GEN_FCN (icode) (target, op0, op1, op2);
10816   if (! pat)
10817     return 0;
10818   emit_insn (pat);
10819
10820   return target;
10821 }
10822
10823 /* Expand the lvx builtins.  */
10824 static rtx
10825 altivec_expand_ld_builtin (tree exp, rtx target, bool *expandedp)
10826 {
10827   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
10828   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
10829   tree arg0;
10830   enum machine_mode tmode, mode0;
10831   rtx pat, op0;
10832   enum insn_code icode;
10833
10834   switch (fcode)
10835     {
10836     case ALTIVEC_BUILTIN_LD_INTERNAL_16qi:
10837       icode = CODE_FOR_vector_altivec_load_v16qi;
10838       break;
10839     case ALTIVEC_BUILTIN_LD_INTERNAL_8hi:
10840       icode = CODE_FOR_vector_altivec_load_v8hi;
10841       break;
10842     case ALTIVEC_BUILTIN_LD_INTERNAL_4si:
10843       icode = CODE_FOR_vector_altivec_load_v4si;
10844       break;
10845     case ALTIVEC_BUILTIN_LD_INTERNAL_4sf:
10846       icode = CODE_FOR_vector_altivec_load_v4sf;
10847       break;
10848     case ALTIVEC_BUILTIN_LD_INTERNAL_2df:
10849       icode = CODE_FOR_vector_altivec_load_v2df;
10850       break;
10851     case ALTIVEC_BUILTIN_LD_INTERNAL_2di:
10852       icode = CODE_FOR_vector_altivec_load_v2di;
10853       break;
10854     default:
10855       *expandedp = false;
10856       return NULL_RTX;
10857     }
10858
10859   *expandedp = true;
10860
10861   arg0 = CALL_EXPR_ARG (exp, 0);
10862   op0 = expand_normal (arg0);
10863   tmode = insn_data[icode].operand[0].mode;
10864   mode0 = insn_data[icode].operand[1].mode;
10865
10866   if (target == 0
10867       || GET_MODE (target) != tmode
10868       || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10869     target = gen_reg_rtx (tmode);
10870
10871   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
10872     op0 = gen_rtx_MEM (mode0, copy_to_mode_reg (Pmode, op0));
10873
10874   pat = GEN_FCN (icode) (target, op0);
10875   if (! pat)
10876     return 0;
10877   emit_insn (pat);
10878   return target;
10879 }
10880
10881 /* Expand the stvx builtins.  */
10882 static rtx
10883 altivec_expand_st_builtin (tree exp, rtx target ATTRIBUTE_UNUSED,
10884                            bool *expandedp)
10885 {
10886   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
10887   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
10888   tree arg0, arg1;
10889   enum machine_mode mode0, mode1;
10890   rtx pat, op0, op1;
10891   enum insn_code icode;
10892
10893   switch (fcode)
10894     {
10895     case ALTIVEC_BUILTIN_ST_INTERNAL_16qi:
10896       icode = CODE_FOR_vector_altivec_store_v16qi;
10897       break;
10898     case ALTIVEC_BUILTIN_ST_INTERNAL_8hi:
10899       icode = CODE_FOR_vector_altivec_store_v8hi;
10900       break;
10901     case ALTIVEC_BUILTIN_ST_INTERNAL_4si:
10902       icode = CODE_FOR_vector_altivec_store_v4si;
10903       break;
10904     case ALTIVEC_BUILTIN_ST_INTERNAL_4sf:
10905       icode = CODE_FOR_vector_altivec_store_v4sf;
10906       break;
10907     case ALTIVEC_BUILTIN_ST_INTERNAL_2df:
10908       icode = CODE_FOR_vector_altivec_store_v2df;
10909       break;
10910     case ALTIVEC_BUILTIN_ST_INTERNAL_2di:
10911       icode = CODE_FOR_vector_altivec_store_v2di;
10912       break;
10913     default:
10914       *expandedp = false;
10915       return NULL_RTX;
10916     }
10917
10918   arg0 = CALL_EXPR_ARG (exp, 0);
10919   arg1 = CALL_EXPR_ARG (exp, 1);
10920   op0 = expand_normal (arg0);
10921   op1 = expand_normal (arg1);
10922   mode0 = insn_data[icode].operand[0].mode;
10923   mode1 = insn_data[icode].operand[1].mode;
10924
10925   if (! (*insn_data[icode].operand[0].predicate) (op0, mode0))
10926     op0 = gen_rtx_MEM (mode0, copy_to_mode_reg (Pmode, op0));
10927   if (! (*insn_data[icode].operand[1].predicate) (op1, mode1))
10928     op1 = copy_to_mode_reg (mode1, op1);
10929
10930   pat = GEN_FCN (icode) (op0, op1);
10931   if (pat)
10932     emit_insn (pat);
10933
10934   *expandedp = true;
10935   return NULL_RTX;
10936 }
10937
10938 /* Expand the dst builtins.  */
10939 static rtx
10940 altivec_expand_dst_builtin (tree exp, rtx target ATTRIBUTE_UNUSED,
10941                             bool *expandedp)
10942 {
10943   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
10944   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
10945   tree arg0, arg1, arg2;
10946   enum machine_mode mode0, mode1;
10947   rtx pat, op0, op1, op2;
10948   const struct builtin_description *d;
10949   size_t i;
10950
10951   *expandedp = false;
10952
10953   /* Handle DST variants.  */
10954   d = bdesc_dst;
10955   for (i = 0; i < ARRAY_SIZE (bdesc_dst); i++, d++)
10956     if (d->code == fcode)
10957       {
10958         arg0 = CALL_EXPR_ARG (exp, 0);
10959         arg1 = CALL_EXPR_ARG (exp, 1);
10960         arg2 = CALL_EXPR_ARG (exp, 2);
10961         op0 = expand_normal (arg0);
10962         op1 = expand_normal (arg1);
10963         op2 = expand_normal (arg2);
10964         mode0 = insn_data[d->icode].operand[0].mode;
10965         mode1 = insn_data[d->icode].operand[1].mode;
10966
10967         /* Invalid arguments, bail out before generating bad rtl.  */
10968         if (arg0 == error_mark_node
10969             || arg1 == error_mark_node
10970             || arg2 == error_mark_node)
10971           return const0_rtx;
10972
10973         *expandedp = true;
10974         STRIP_NOPS (arg2);
10975         if (TREE_CODE (arg2) != INTEGER_CST
10976             || TREE_INT_CST_LOW (arg2) & ~0x3)
10977           {
10978             error ("argument to %qs must be a 2-bit unsigned literal", d->name);
10979             return const0_rtx;
10980           }
10981
10982         if (! (*insn_data[d->icode].operand[0].predicate) (op0, mode0))
10983           op0 = copy_to_mode_reg (Pmode, op0);
10984         if (! (*insn_data[d->icode].operand[1].predicate) (op1, mode1))
10985           op1 = copy_to_mode_reg (mode1, op1);
10986
10987         pat = GEN_FCN (d->icode) (op0, op1, op2);
10988         if (pat != 0)
10989           emit_insn (pat);
10990
10991         return NULL_RTX;
10992       }
10993
10994   return NULL_RTX;
10995 }
10996
10997 /* Expand vec_init builtin.  */
10998 static rtx
10999 altivec_expand_vec_init_builtin (tree type, tree exp, rtx target)
11000 {
11001   enum machine_mode tmode = TYPE_MODE (type);
11002   enum machine_mode inner_mode = GET_MODE_INNER (tmode);
11003   int i, n_elt = GET_MODE_NUNITS (tmode);
11004   rtvec v = rtvec_alloc (n_elt);
11005
11006   gcc_assert (VECTOR_MODE_P (tmode));
11007   gcc_assert (n_elt == call_expr_nargs (exp));
11008
11009   for (i = 0; i < n_elt; ++i)
11010     {
11011       rtx x = expand_normal (CALL_EXPR_ARG (exp, i));
11012       RTVEC_ELT (v, i) = gen_lowpart (inner_mode, x);
11013     }
11014
11015   if (!target || !register_operand (target, tmode))
11016     target = gen_reg_rtx (tmode);
11017
11018   rs6000_expand_vector_init (target, gen_rtx_PARALLEL (tmode, v));
11019   return target;
11020 }
11021
11022 /* Return the integer constant in ARG.  Constrain it to be in the range
11023    of the subparts of VEC_TYPE; issue an error if not.  */
11024
11025 static int
11026 get_element_number (tree vec_type, tree arg)
11027 {
11028   unsigned HOST_WIDE_INT elt, max = TYPE_VECTOR_SUBPARTS (vec_type) - 1;
11029
11030   if (!host_integerp (arg, 1)
11031       || (elt = tree_low_cst (arg, 1), elt > max))
11032     {
11033       error ("selector must be an integer constant in the range 0..%wi", max);
11034       return 0;
11035     }
11036
11037   return elt;
11038 }
11039
11040 /* Expand vec_set builtin.  */
11041 static rtx
11042 altivec_expand_vec_set_builtin (tree exp)
11043 {
11044   enum machine_mode tmode, mode1;
11045   tree arg0, arg1, arg2;
11046   int elt;
11047   rtx op0, op1;
11048
11049   arg0 = CALL_EXPR_ARG (exp, 0);
11050   arg1 = CALL_EXPR_ARG (exp, 1);
11051   arg2 = CALL_EXPR_ARG (exp, 2);
11052
11053   tmode = TYPE_MODE (TREE_TYPE (arg0));
11054   mode1 = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
11055   gcc_assert (VECTOR_MODE_P (tmode));
11056
11057   op0 = expand_expr (arg0, NULL_RTX, tmode, EXPAND_NORMAL);
11058   op1 = expand_expr (arg1, NULL_RTX, mode1, EXPAND_NORMAL);
11059   elt = get_element_number (TREE_TYPE (arg0), arg2);
11060
11061   if (GET_MODE (op1) != mode1 && GET_MODE (op1) != VOIDmode)
11062     op1 = convert_modes (mode1, GET_MODE (op1), op1, true);
11063
11064   op0 = force_reg (tmode, op0);
11065   op1 = force_reg (mode1, op1);
11066
11067   rs6000_expand_vector_set (op0, op1, elt);
11068
11069   return op0;
11070 }
11071
11072 /* Expand vec_ext builtin.  */
11073 static rtx
11074 altivec_expand_vec_ext_builtin (tree exp, rtx target)
11075 {
11076   enum machine_mode tmode, mode0;
11077   tree arg0, arg1;
11078   int elt;
11079   rtx op0;
11080
11081   arg0 = CALL_EXPR_ARG (exp, 0);
11082   arg1 = CALL_EXPR_ARG (exp, 1);
11083
11084   op0 = expand_normal (arg0);
11085   elt = get_element_number (TREE_TYPE (arg0), arg1);
11086
11087   tmode = TYPE_MODE (TREE_TYPE (TREE_TYPE (arg0)));
11088   mode0 = TYPE_MODE (TREE_TYPE (arg0));
11089   gcc_assert (VECTOR_MODE_P (mode0));
11090
11091   op0 = force_reg (mode0, op0);
11092
11093   if (optimize || !target || !register_operand (target, tmode))
11094     target = gen_reg_rtx (tmode);
11095
11096   rs6000_expand_vector_extract (target, op0, elt);
11097
11098   return target;
11099 }
11100
11101 /* Expand the builtin in EXP and store the result in TARGET.  Store
11102    true in *EXPANDEDP if we found a builtin to expand.  */
11103 static rtx
11104 altivec_expand_builtin (tree exp, rtx target, bool *expandedp)
11105 {
11106   const struct builtin_description *d;
11107   const struct builtin_description_predicates *dp;
11108   size_t i;
11109   enum insn_code icode;
11110   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
11111   tree arg0;
11112   rtx op0, pat;
11113   enum machine_mode tmode, mode0;
11114   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
11115
11116   if ((fcode >= ALTIVEC_BUILTIN_OVERLOADED_FIRST
11117        && fcode <= ALTIVEC_BUILTIN_OVERLOADED_LAST)
11118       || (fcode >= VSX_BUILTIN_OVERLOADED_FIRST
11119           && fcode <= VSX_BUILTIN_OVERLOADED_LAST))
11120     {
11121       *expandedp = true;
11122       error ("unresolved overload for Altivec builtin %qF", fndecl);
11123       return const0_rtx;
11124     }
11125
11126   target = altivec_expand_ld_builtin (exp, target, expandedp);
11127   if (*expandedp)
11128     return target;
11129
11130   target = altivec_expand_st_builtin (exp, target, expandedp);
11131   if (*expandedp)
11132     return target;
11133
11134   target = altivec_expand_dst_builtin (exp, target, expandedp);
11135   if (*expandedp)
11136     return target;
11137
11138   *expandedp = true;
11139
11140   switch (fcode)
11141     {
11142     case ALTIVEC_BUILTIN_STVX:
11143       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvx_v4si, exp);
11144     case ALTIVEC_BUILTIN_STVEBX:
11145       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvebx, exp);
11146     case ALTIVEC_BUILTIN_STVEHX:
11147       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvehx, exp);
11148     case ALTIVEC_BUILTIN_STVEWX:
11149       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvewx, exp);
11150     case ALTIVEC_BUILTIN_STVXL:
11151       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvxl, exp);
11152
11153     case ALTIVEC_BUILTIN_STVLX:
11154       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvlx, exp);
11155     case ALTIVEC_BUILTIN_STVLXL:
11156       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvlxl, exp);
11157     case ALTIVEC_BUILTIN_STVRX:
11158       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvrx, exp);
11159     case ALTIVEC_BUILTIN_STVRXL:
11160       return altivec_expand_stv_builtin (CODE_FOR_altivec_stvrxl, exp);
11161
11162     case VSX_BUILTIN_STXVD2X_V2DF:
11163       return altivec_expand_stv_builtin (CODE_FOR_vsx_store_v2df, exp);
11164     case VSX_BUILTIN_STXVD2X_V2DI:
11165       return altivec_expand_stv_builtin (CODE_FOR_vsx_store_v2di, exp);
11166     case VSX_BUILTIN_STXVW4X_V4SF:
11167       return altivec_expand_stv_builtin (CODE_FOR_vsx_store_v4sf, exp);
11168     case VSX_BUILTIN_STXVW4X_V4SI:
11169       return altivec_expand_stv_builtin (CODE_FOR_vsx_store_v4si, exp);
11170     case VSX_BUILTIN_STXVW4X_V8HI:
11171       return altivec_expand_stv_builtin (CODE_FOR_vsx_store_v8hi, exp);
11172     case VSX_BUILTIN_STXVW4X_V16QI:
11173       return altivec_expand_stv_builtin (CODE_FOR_vsx_store_v16qi, exp);
11174
11175     case ALTIVEC_BUILTIN_MFVSCR:
11176       icode = CODE_FOR_altivec_mfvscr;
11177       tmode = insn_data[icode].operand[0].mode;
11178
11179       if (target == 0
11180           || GET_MODE (target) != tmode
11181           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
11182         target = gen_reg_rtx (tmode);
11183
11184       pat = GEN_FCN (icode) (target);
11185       if (! pat)
11186         return 0;
11187       emit_insn (pat);
11188       return target;
11189
11190     case ALTIVEC_BUILTIN_MTVSCR:
11191       icode = CODE_FOR_altivec_mtvscr;
11192       arg0 = CALL_EXPR_ARG (exp, 0);
11193       op0 = expand_normal (arg0);
11194       mode0 = insn_data[icode].operand[0].mode;
11195
11196       /* If we got invalid arguments bail out before generating bad rtl.  */
11197       if (arg0 == error_mark_node)
11198         return const0_rtx;
11199
11200       if (! (*insn_data[icode].operand[0].predicate) (op0, mode0))
11201         op0 = copy_to_mode_reg (mode0, op0);
11202
11203       pat = GEN_FCN (icode) (op0);
11204       if (pat)
11205         emit_insn (pat);
11206       return NULL_RTX;
11207
11208     case ALTIVEC_BUILTIN_DSSALL:
11209       emit_insn (gen_altivec_dssall ());
11210       return NULL_RTX;
11211
11212     case ALTIVEC_BUILTIN_DSS:
11213       icode = CODE_FOR_altivec_dss;
11214       arg0 = CALL_EXPR_ARG (exp, 0);
11215       STRIP_NOPS (arg0);
11216       op0 = expand_normal (arg0);
11217       mode0 = insn_data[icode].operand[0].mode;
11218
11219       /* If we got invalid arguments bail out before generating bad rtl.  */
11220       if (arg0 == error_mark_node)
11221         return const0_rtx;
11222
11223       if (TREE_CODE (arg0) != INTEGER_CST
11224           || TREE_INT_CST_LOW (arg0) & ~0x3)
11225         {
11226           error ("argument to dss must be a 2-bit unsigned literal");
11227           return const0_rtx;
11228         }
11229
11230       if (! (*insn_data[icode].operand[0].predicate) (op0, mode0))
11231         op0 = copy_to_mode_reg (mode0, op0);
11232
11233       emit_insn (gen_altivec_dss (op0));
11234       return NULL_RTX;
11235
11236     case ALTIVEC_BUILTIN_VEC_INIT_V4SI:
11237     case ALTIVEC_BUILTIN_VEC_INIT_V8HI:
11238     case ALTIVEC_BUILTIN_VEC_INIT_V16QI:
11239     case ALTIVEC_BUILTIN_VEC_INIT_V4SF:
11240     case VSX_BUILTIN_VEC_INIT_V2DF:
11241     case VSX_BUILTIN_VEC_INIT_V2DI:
11242       return altivec_expand_vec_init_builtin (TREE_TYPE (exp), exp, target);
11243
11244     case ALTIVEC_BUILTIN_VEC_SET_V4SI:
11245     case ALTIVEC_BUILTIN_VEC_SET_V8HI:
11246     case ALTIVEC_BUILTIN_VEC_SET_V16QI:
11247     case ALTIVEC_BUILTIN_VEC_SET_V4SF:
11248     case VSX_BUILTIN_VEC_SET_V2DF:
11249     case VSX_BUILTIN_VEC_SET_V2DI:
11250       return altivec_expand_vec_set_builtin (exp);
11251
11252     case ALTIVEC_BUILTIN_VEC_EXT_V4SI:
11253     case ALTIVEC_BUILTIN_VEC_EXT_V8HI:
11254     case ALTIVEC_BUILTIN_VEC_EXT_V16QI:
11255     case ALTIVEC_BUILTIN_VEC_EXT_V4SF:
11256     case VSX_BUILTIN_VEC_EXT_V2DF:
11257     case VSX_BUILTIN_VEC_EXT_V2DI:
11258       return altivec_expand_vec_ext_builtin (exp, target);
11259
11260     default:
11261       break;
11262       /* Fall through.  */
11263     }
11264
11265   /* Expand abs* operations.  */
11266   d = bdesc_abs;
11267   for (i = 0; i < ARRAY_SIZE (bdesc_abs); i++, d++)
11268     if (d->code == fcode)
11269       return altivec_expand_abs_builtin (d->icode, exp, target);
11270
11271   /* Expand the AltiVec predicates.  */
11272   dp = bdesc_altivec_preds;
11273   for (i = 0; i < ARRAY_SIZE (bdesc_altivec_preds); i++, dp++)
11274     if (dp->code == fcode)
11275       return altivec_expand_predicate_builtin (dp->icode, exp, target);
11276
11277   /* LV* are funky.  We initialized them differently.  */
11278   switch (fcode)
11279     {
11280     case ALTIVEC_BUILTIN_LVSL:
11281       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvsl,
11282                                         exp, target, false);
11283     case ALTIVEC_BUILTIN_LVSR:
11284       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvsr,
11285                                         exp, target, false);
11286     case ALTIVEC_BUILTIN_LVEBX:
11287       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvebx,
11288                                         exp, target, false);
11289     case ALTIVEC_BUILTIN_LVEHX:
11290       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvehx,
11291                                         exp, target, false);
11292     case ALTIVEC_BUILTIN_LVEWX:
11293       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvewx,
11294                                         exp, target, false);
11295     case ALTIVEC_BUILTIN_LVXL:
11296       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvxl,
11297                                         exp, target, false);
11298     case ALTIVEC_BUILTIN_LVX:
11299       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvx_v4si,
11300                                         exp, target, false);
11301     case ALTIVEC_BUILTIN_LVLX:
11302       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvlx,
11303                                         exp, target, true);
11304     case ALTIVEC_BUILTIN_LVLXL:
11305       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvlxl,
11306                                         exp, target, true);
11307     case ALTIVEC_BUILTIN_LVRX:
11308       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvrx,
11309                                         exp, target, true);
11310     case ALTIVEC_BUILTIN_LVRXL:
11311       return altivec_expand_lv_builtin (CODE_FOR_altivec_lvrxl,
11312                                         exp, target, true);
11313     case VSX_BUILTIN_LXVD2X_V2DF:
11314       return altivec_expand_lv_builtin (CODE_FOR_vsx_load_v2df,
11315                                         exp, target, false);
11316     case VSX_BUILTIN_LXVD2X_V2DI:
11317       return altivec_expand_lv_builtin (CODE_FOR_vsx_load_v2di,
11318                                         exp, target, false);
11319     case VSX_BUILTIN_LXVW4X_V4SF:
11320       return altivec_expand_lv_builtin (CODE_FOR_vsx_load_v4sf,
11321                                         exp, target, false);
11322     case VSX_BUILTIN_LXVW4X_V4SI:
11323       return altivec_expand_lv_builtin (CODE_FOR_vsx_load_v4si,
11324                                         exp, target, false);
11325     case VSX_BUILTIN_LXVW4X_V8HI:
11326       return altivec_expand_lv_builtin (CODE_FOR_vsx_load_v8hi,
11327                                         exp, target, false);
11328     case VSX_BUILTIN_LXVW4X_V16QI:
11329       return altivec_expand_lv_builtin (CODE_FOR_vsx_load_v16qi,
11330                                         exp, target, false);
11331       break;
11332     default:
11333       break;
11334       /* Fall through.  */
11335     }
11336
11337   *expandedp = false;
11338   return NULL_RTX;
11339 }
11340
11341 /* Expand the builtin in EXP and store the result in TARGET.  Store
11342    true in *EXPANDEDP if we found a builtin to expand.  */
11343 static rtx
11344 paired_expand_builtin (tree exp, rtx target, bool * expandedp)
11345 {
11346   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
11347   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
11348   const struct builtin_description *d;
11349   size_t i;
11350
11351   *expandedp = true;
11352
11353   switch (fcode)
11354     {
11355     case PAIRED_BUILTIN_STX:
11356       return paired_expand_stv_builtin (CODE_FOR_paired_stx, exp);
11357     case PAIRED_BUILTIN_LX:
11358       return paired_expand_lv_builtin (CODE_FOR_paired_lx, exp, target);
11359     default:
11360       break;
11361       /* Fall through.  */
11362     }
11363
11364   /* Expand the paired predicates.  */
11365   d = bdesc_paired_preds;
11366   for (i = 0; i < ARRAY_SIZE (bdesc_paired_preds); i++, d++)
11367     if (d->code == fcode)
11368       return paired_expand_predicate_builtin (d->icode, exp, target);
11369
11370   *expandedp = false;
11371   return NULL_RTX;
11372 }
11373
11374 /* Binops that need to be initialized manually, but can be expanded
11375    automagically by rs6000_expand_binop_builtin.  */
11376 static struct builtin_description bdesc_2arg_spe[] =
11377 {
11378   { 0, CODE_FOR_spe_evlddx, "__builtin_spe_evlddx", SPE_BUILTIN_EVLDDX },
11379   { 0, CODE_FOR_spe_evldwx, "__builtin_spe_evldwx", SPE_BUILTIN_EVLDWX },
11380   { 0, CODE_FOR_spe_evldhx, "__builtin_spe_evldhx", SPE_BUILTIN_EVLDHX },
11381   { 0, CODE_FOR_spe_evlwhex, "__builtin_spe_evlwhex", SPE_BUILTIN_EVLWHEX },
11382   { 0, CODE_FOR_spe_evlwhoux, "__builtin_spe_evlwhoux", SPE_BUILTIN_EVLWHOUX },
11383   { 0, CODE_FOR_spe_evlwhosx, "__builtin_spe_evlwhosx", SPE_BUILTIN_EVLWHOSX },
11384   { 0, CODE_FOR_spe_evlwwsplatx, "__builtin_spe_evlwwsplatx", SPE_BUILTIN_EVLWWSPLATX },
11385   { 0, CODE_FOR_spe_evlwhsplatx, "__builtin_spe_evlwhsplatx", SPE_BUILTIN_EVLWHSPLATX },
11386   { 0, CODE_FOR_spe_evlhhesplatx, "__builtin_spe_evlhhesplatx", SPE_BUILTIN_EVLHHESPLATX },
11387   { 0, CODE_FOR_spe_evlhhousplatx, "__builtin_spe_evlhhousplatx", SPE_BUILTIN_EVLHHOUSPLATX },
11388   { 0, CODE_FOR_spe_evlhhossplatx, "__builtin_spe_evlhhossplatx", SPE_BUILTIN_EVLHHOSSPLATX },
11389   { 0, CODE_FOR_spe_evldd, "__builtin_spe_evldd", SPE_BUILTIN_EVLDD },
11390   { 0, CODE_FOR_spe_evldw, "__builtin_spe_evldw", SPE_BUILTIN_EVLDW },
11391   { 0, CODE_FOR_spe_evldh, "__builtin_spe_evldh", SPE_BUILTIN_EVLDH },
11392   { 0, CODE_FOR_spe_evlwhe, "__builtin_spe_evlwhe", SPE_BUILTIN_EVLWHE },
11393   { 0, CODE_FOR_spe_evlwhou, "__builtin_spe_evlwhou", SPE_BUILTIN_EVLWHOU },
11394   { 0, CODE_FOR_spe_evlwhos, "__builtin_spe_evlwhos", SPE_BUILTIN_EVLWHOS },
11395   { 0, CODE_FOR_spe_evlwwsplat, "__builtin_spe_evlwwsplat", SPE_BUILTIN_EVLWWSPLAT },
11396   { 0, CODE_FOR_spe_evlwhsplat, "__builtin_spe_evlwhsplat", SPE_BUILTIN_EVLWHSPLAT },
11397   { 0, CODE_FOR_spe_evlhhesplat, "__builtin_spe_evlhhesplat", SPE_BUILTIN_EVLHHESPLAT },
11398   { 0, CODE_FOR_spe_evlhhousplat, "__builtin_spe_evlhhousplat", SPE_BUILTIN_EVLHHOUSPLAT },
11399   { 0, CODE_FOR_spe_evlhhossplat, "__builtin_spe_evlhhossplat", SPE_BUILTIN_EVLHHOSSPLAT }
11400 };
11401
11402 /* Expand the builtin in EXP and store the result in TARGET.  Store
11403    true in *EXPANDEDP if we found a builtin to expand.
11404
11405    This expands the SPE builtins that are not simple unary and binary
11406    operations.  */
11407 static rtx
11408 spe_expand_builtin (tree exp, rtx target, bool *expandedp)
11409 {
11410   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
11411   tree arg1, arg0;
11412   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
11413   enum insn_code icode;
11414   enum machine_mode tmode, mode0;
11415   rtx pat, op0;
11416   struct builtin_description *d;
11417   size_t i;
11418
11419   *expandedp = true;
11420
11421   /* Syntax check for a 5-bit unsigned immediate.  */
11422   switch (fcode)
11423     {
11424     case SPE_BUILTIN_EVSTDD:
11425     case SPE_BUILTIN_EVSTDH:
11426     case SPE_BUILTIN_EVSTDW:
11427     case SPE_BUILTIN_EVSTWHE:
11428     case SPE_BUILTIN_EVSTWHO:
11429     case SPE_BUILTIN_EVSTWWE:
11430     case SPE_BUILTIN_EVSTWWO:
11431       arg1 = CALL_EXPR_ARG (exp, 2);
11432       if (TREE_CODE (arg1) != INTEGER_CST
11433           || TREE_INT_CST_LOW (arg1) & ~0x1f)
11434         {
11435           error ("argument 2 must be a 5-bit unsigned literal");
11436           return const0_rtx;
11437         }
11438       break;
11439     default:
11440       break;
11441     }
11442
11443   /* The evsplat*i instructions are not quite generic.  */
11444   switch (fcode)
11445     {
11446     case SPE_BUILTIN_EVSPLATFI:
11447       return rs6000_expand_unop_builtin (CODE_FOR_spe_evsplatfi,
11448                                          exp, target);
11449     case SPE_BUILTIN_EVSPLATI:
11450       return rs6000_expand_unop_builtin (CODE_FOR_spe_evsplati,
11451                                          exp, target);
11452     default:
11453       break;
11454     }
11455
11456   d = (struct builtin_description *) bdesc_2arg_spe;
11457   for (i = 0; i < ARRAY_SIZE (bdesc_2arg_spe); ++i, ++d)
11458     if (d->code == fcode)
11459       return rs6000_expand_binop_builtin (d->icode, exp, target);
11460
11461   d = (struct builtin_description *) bdesc_spe_predicates;
11462   for (i = 0; i < ARRAY_SIZE (bdesc_spe_predicates); ++i, ++d)
11463     if (d->code == fcode)
11464       return spe_expand_predicate_builtin (d->icode, exp, target);
11465
11466   d = (struct builtin_description *) bdesc_spe_evsel;
11467   for (i = 0; i < ARRAY_SIZE (bdesc_spe_evsel); ++i, ++d)
11468     if (d->code == fcode)
11469       return spe_expand_evsel_builtin (d->icode, exp, target);
11470
11471   switch (fcode)
11472     {
11473     case SPE_BUILTIN_EVSTDDX:
11474       return spe_expand_stv_builtin (CODE_FOR_spe_evstddx, exp);
11475     case SPE_BUILTIN_EVSTDHX:
11476       return spe_expand_stv_builtin (CODE_FOR_spe_evstdhx, exp);
11477     case SPE_BUILTIN_EVSTDWX:
11478       return spe_expand_stv_builtin (CODE_FOR_spe_evstdwx, exp);
11479     case SPE_BUILTIN_EVSTWHEX:
11480       return spe_expand_stv_builtin (CODE_FOR_spe_evstwhex, exp);
11481     case SPE_BUILTIN_EVSTWHOX:
11482       return spe_expand_stv_builtin (CODE_FOR_spe_evstwhox, exp);
11483     case SPE_BUILTIN_EVSTWWEX:
11484       return spe_expand_stv_builtin (CODE_FOR_spe_evstwwex, exp);
11485     case SPE_BUILTIN_EVSTWWOX:
11486       return spe_expand_stv_builtin (CODE_FOR_spe_evstwwox, exp);
11487     case SPE_BUILTIN_EVSTDD:
11488       return spe_expand_stv_builtin (CODE_FOR_spe_evstdd, exp);
11489     case SPE_BUILTIN_EVSTDH:
11490       return spe_expand_stv_builtin (CODE_FOR_spe_evstdh, exp);
11491     case SPE_BUILTIN_EVSTDW:
11492       return spe_expand_stv_builtin (CODE_FOR_spe_evstdw, exp);
11493     case SPE_BUILTIN_EVSTWHE:
11494       return spe_expand_stv_builtin (CODE_FOR_spe_evstwhe, exp);
11495     case SPE_BUILTIN_EVSTWHO:
11496       return spe_expand_stv_builtin (CODE_FOR_spe_evstwho, exp);
11497     case SPE_BUILTIN_EVSTWWE:
11498       return spe_expand_stv_builtin (CODE_FOR_spe_evstwwe, exp);
11499     case SPE_BUILTIN_EVSTWWO:
11500       return spe_expand_stv_builtin (CODE_FOR_spe_evstwwo, exp);
11501     case SPE_BUILTIN_MFSPEFSCR:
11502       icode = CODE_FOR_spe_mfspefscr;
11503       tmode = insn_data[icode].operand[0].mode;
11504
11505       if (target == 0
11506           || GET_MODE (target) != tmode
11507           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
11508         target = gen_reg_rtx (tmode);
11509
11510       pat = GEN_FCN (icode) (target);
11511       if (! pat)
11512         return 0;
11513       emit_insn (pat);
11514       return target;
11515     case SPE_BUILTIN_MTSPEFSCR:
11516       icode = CODE_FOR_spe_mtspefscr;
11517       arg0 = CALL_EXPR_ARG (exp, 0);
11518       op0 = expand_normal (arg0);
11519       mode0 = insn_data[icode].operand[0].mode;
11520
11521       if (arg0 == error_mark_node)
11522         return const0_rtx;
11523
11524       if (! (*insn_data[icode].operand[0].predicate) (op0, mode0))
11525         op0 = copy_to_mode_reg (mode0, op0);
11526
11527       pat = GEN_FCN (icode) (op0);
11528       if (pat)
11529         emit_insn (pat);
11530       return NULL_RTX;
11531     default:
11532       break;
11533     }
11534
11535   *expandedp = false;
11536   return NULL_RTX;
11537 }
11538
11539 static rtx
11540 paired_expand_predicate_builtin (enum insn_code icode, tree exp, rtx target)
11541 {
11542   rtx pat, scratch, tmp;
11543   tree form = CALL_EXPR_ARG (exp, 0);
11544   tree arg0 = CALL_EXPR_ARG (exp, 1);
11545   tree arg1 = CALL_EXPR_ARG (exp, 2);
11546   rtx op0 = expand_normal (arg0);
11547   rtx op1 = expand_normal (arg1);
11548   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
11549   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
11550   int form_int;
11551   enum rtx_code code;
11552
11553   if (TREE_CODE (form) != INTEGER_CST)
11554     {
11555       error ("argument 1 of __builtin_paired_predicate must be a constant");
11556       return const0_rtx;
11557     }
11558   else
11559     form_int = TREE_INT_CST_LOW (form);
11560
11561   gcc_assert (mode0 == mode1);
11562
11563   if (arg0 == error_mark_node || arg1 == error_mark_node)
11564     return const0_rtx;
11565
11566   if (target == 0
11567       || GET_MODE (target) != SImode
11568       || !(*insn_data[icode].operand[0].predicate) (target, SImode))
11569     target = gen_reg_rtx (SImode);
11570   if (!(*insn_data[icode].operand[1].predicate) (op0, mode0))
11571     op0 = copy_to_mode_reg (mode0, op0);
11572   if (!(*insn_data[icode].operand[2].predicate) (op1, mode1))
11573     op1 = copy_to_mode_reg (mode1, op1);
11574
11575   scratch = gen_reg_rtx (CCFPmode);
11576
11577   pat = GEN_FCN (icode) (scratch, op0, op1);
11578   if (!pat)
11579     return const0_rtx;
11580
11581   emit_insn (pat);
11582
11583   switch (form_int)
11584     {
11585       /* LT bit.  */
11586     case 0:
11587       code = LT;
11588       break;
11589       /* GT bit.  */
11590     case 1:
11591       code = GT;
11592       break;
11593       /* EQ bit.  */
11594     case 2:
11595       code = EQ;
11596       break;
11597       /* UN bit.  */
11598     case 3:
11599       emit_insn (gen_move_from_CR_ov_bit (target, scratch));
11600       return target;
11601     default:
11602       error ("argument 1 of __builtin_paired_predicate is out of range");
11603       return const0_rtx;
11604     }
11605
11606   tmp = gen_rtx_fmt_ee (code, SImode, scratch, const0_rtx);
11607   emit_move_insn (target, tmp);
11608   return target;
11609 }
11610
11611 static rtx
11612 spe_expand_predicate_builtin (enum insn_code icode, tree exp, rtx target)
11613 {
11614   rtx pat, scratch, tmp;
11615   tree form = CALL_EXPR_ARG (exp, 0);
11616   tree arg0 = CALL_EXPR_ARG (exp, 1);
11617   tree arg1 = CALL_EXPR_ARG (exp, 2);
11618   rtx op0 = expand_normal (arg0);
11619   rtx op1 = expand_normal (arg1);
11620   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
11621   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
11622   int form_int;
11623   enum rtx_code code;
11624
11625   if (TREE_CODE (form) != INTEGER_CST)
11626     {
11627       error ("argument 1 of __builtin_spe_predicate must be a constant");
11628       return const0_rtx;
11629     }
11630   else
11631     form_int = TREE_INT_CST_LOW (form);
11632
11633   gcc_assert (mode0 == mode1);
11634
11635   if (arg0 == error_mark_node || arg1 == error_mark_node)
11636     return const0_rtx;
11637
11638   if (target == 0
11639       || GET_MODE (target) != SImode
11640       || ! (*insn_data[icode].operand[0].predicate) (target, SImode))
11641     target = gen_reg_rtx (SImode);
11642
11643   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
11644     op0 = copy_to_mode_reg (mode0, op0);
11645   if (! (*insn_data[icode].operand[2].predicate) (op1, mode1))
11646     op1 = copy_to_mode_reg (mode1, op1);
11647
11648   scratch = gen_reg_rtx (CCmode);
11649
11650   pat = GEN_FCN (icode) (scratch, op0, op1);
11651   if (! pat)
11652     return const0_rtx;
11653   emit_insn (pat);
11654
11655   /* There are 4 variants for each predicate: _any_, _all_, _upper_,
11656      _lower_.  We use one compare, but look in different bits of the
11657      CR for each variant.
11658
11659      There are 2 elements in each SPE simd type (upper/lower).  The CR
11660      bits are set as follows:
11661
11662      BIT0  | BIT 1  | BIT 2   | BIT 3
11663      U     |   L    | (U | L) | (U & L)
11664
11665      So, for an "all" relationship, BIT 3 would be set.
11666      For an "any" relationship, BIT 2 would be set.  Etc.
11667
11668      Following traditional nomenclature, these bits map to:
11669
11670      BIT0  | BIT 1  | BIT 2   | BIT 3
11671      LT    | GT     | EQ      | OV
11672
11673      Later, we will generate rtl to look in the LT/EQ/EQ/OV bits.
11674   */
11675
11676   switch (form_int)
11677     {
11678       /* All variant.  OV bit.  */
11679     case 0:
11680       /* We need to get to the OV bit, which is the ORDERED bit.  We
11681          could generate (ordered:SI (reg:CC xx) (const_int 0)), but
11682          that's ugly and will make validate_condition_mode die.
11683          So let's just use another pattern.  */
11684       emit_insn (gen_move_from_CR_ov_bit (target, scratch));
11685       return target;
11686       /* Any variant.  EQ bit.  */
11687     case 1:
11688       code = EQ;
11689       break;
11690       /* Upper variant.  LT bit.  */
11691     case 2:
11692       code = LT;
11693       break;
11694       /* Lower variant.  GT bit.  */
11695     case 3:
11696       code = GT;
11697       break;
11698     default:
11699       error ("argument 1 of __builtin_spe_predicate is out of range");
11700       return const0_rtx;
11701     }
11702
11703   tmp = gen_rtx_fmt_ee (code, SImode, scratch, const0_rtx);
11704   emit_move_insn (target, tmp);
11705
11706   return target;
11707 }
11708
11709 /* The evsel builtins look like this:
11710
11711      e = __builtin_spe_evsel_OP (a, b, c, d);
11712
11713    and work like this:
11714
11715      e[upper] = a[upper] *OP* b[upper] ? c[upper] : d[upper];
11716      e[lower] = a[lower] *OP* b[lower] ? c[lower] : d[lower];
11717 */
11718
11719 static rtx
11720 spe_expand_evsel_builtin (enum insn_code icode, tree exp, rtx target)
11721 {
11722   rtx pat, scratch;
11723   tree arg0 = CALL_EXPR_ARG (exp, 0);
11724   tree arg1 = CALL_EXPR_ARG (exp, 1);
11725   tree arg2 = CALL_EXPR_ARG (exp, 2);
11726   tree arg3 = CALL_EXPR_ARG (exp, 3);
11727   rtx op0 = expand_normal (arg0);
11728   rtx op1 = expand_normal (arg1);
11729   rtx op2 = expand_normal (arg2);
11730   rtx op3 = expand_normal (arg3);
11731   enum machine_mode mode0 = insn_data[icode].operand[1].mode;
11732   enum machine_mode mode1 = insn_data[icode].operand[2].mode;
11733
11734   gcc_assert (mode0 == mode1);
11735
11736   if (arg0 == error_mark_node || arg1 == error_mark_node
11737       || arg2 == error_mark_node || arg3 == error_mark_node)
11738     return const0_rtx;
11739
11740   if (target == 0
11741       || GET_MODE (target) != mode0
11742       || ! (*insn_data[icode].operand[0].predicate) (target, mode0))
11743     target = gen_reg_rtx (mode0);
11744
11745   if (! (*insn_data[icode].operand[1].predicate) (op0, mode0))
11746     op0 = copy_to_mode_reg (mode0, op0);
11747   if (! (*insn_data[icode].operand[1].predicate) (op1, mode1))
11748     op1 = copy_to_mode_reg (mode0, op1);
11749   if (! (*insn_data[icode].operand[1].predicate) (op2, mode1))
11750     op2 = copy_to_mode_reg (mode0, op2);
11751   if (! (*insn_data[icode].operand[1].predicate) (op3, mode1))
11752     op3 = copy_to_mode_reg (mode0, op3);
11753
11754   /* Generate the compare.  */
11755   scratch = gen_reg_rtx (CCmode);
11756   pat = GEN_FCN (icode) (scratch, op0, op1);
11757   if (! pat)
11758     return const0_rtx;
11759   emit_insn (pat);
11760
11761   if (mode0 == V2SImode)
11762     emit_insn (gen_spe_evsel (target, op2, op3, scratch));
11763   else
11764     emit_insn (gen_spe_evsel_fs (target, op2, op3, scratch));
11765
11766   return target;
11767 }
11768
11769 /* Expand an expression EXP that calls a built-in function,
11770    with result going to TARGET if that's convenient
11771    (and in mode MODE if that's convenient).
11772    SUBTARGET may be used as the target for computing one of EXP's operands.
11773    IGNORE is nonzero if the value is to be ignored.  */
11774
11775 static rtx
11776 rs6000_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
11777                        enum machine_mode mode ATTRIBUTE_UNUSED,
11778                        int ignore ATTRIBUTE_UNUSED)
11779 {
11780   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
11781   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
11782   const struct builtin_description *d;
11783   size_t i;
11784   rtx ret;
11785   bool success;
11786
11787   switch (fcode)
11788     {
11789     case RS6000_BUILTIN_RECIP:
11790       return rs6000_expand_binop_builtin (CODE_FOR_recipdf3, exp, target);
11791
11792     case RS6000_BUILTIN_RECIPF:
11793       return rs6000_expand_binop_builtin (CODE_FOR_recipsf3, exp, target);
11794
11795     case RS6000_BUILTIN_RSQRTF:
11796       return rs6000_expand_unop_builtin (CODE_FOR_rsqrtsf2, exp, target);
11797
11798     case RS6000_BUILTIN_RSQRT:
11799       return rs6000_expand_unop_builtin (CODE_FOR_rsqrtdf2, exp, target);
11800
11801     case RS6000_BUILTIN_BSWAP_HI:
11802       return rs6000_expand_unop_builtin (CODE_FOR_bswaphi2, exp, target);
11803
11804     case POWER7_BUILTIN_BPERMD:
11805       return rs6000_expand_binop_builtin (((TARGET_64BIT)
11806                                            ? CODE_FOR_bpermd_di
11807                                            : CODE_FOR_bpermd_si), exp, target);
11808
11809     case ALTIVEC_BUILTIN_MASK_FOR_LOAD:
11810     case ALTIVEC_BUILTIN_MASK_FOR_STORE:
11811       {
11812         int icode = (int) CODE_FOR_altivec_lvsr;
11813         enum machine_mode tmode = insn_data[icode].operand[0].mode;
11814         enum machine_mode mode = insn_data[icode].operand[1].mode;
11815         tree arg;
11816         rtx op, addr, pat;
11817
11818         gcc_assert (TARGET_ALTIVEC);
11819
11820         arg = CALL_EXPR_ARG (exp, 0);
11821         gcc_assert (POINTER_TYPE_P (TREE_TYPE (arg)));
11822         op = expand_expr (arg, NULL_RTX, Pmode, EXPAND_NORMAL);
11823         addr = memory_address (mode, op);
11824         if (fcode == ALTIVEC_BUILTIN_MASK_FOR_STORE)
11825           op = addr;
11826         else
11827           {
11828             /* For the load case need to negate the address.  */
11829             op = gen_reg_rtx (GET_MODE (addr));
11830             emit_insn (gen_rtx_SET (VOIDmode, op,
11831                                     gen_rtx_NEG (GET_MODE (addr), addr)));
11832           }
11833         op = gen_rtx_MEM (mode, op);
11834
11835         if (target == 0
11836             || GET_MODE (target) != tmode
11837             || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
11838           target = gen_reg_rtx (tmode);
11839
11840         /*pat = gen_altivec_lvsr (target, op);*/
11841         pat = GEN_FCN (icode) (target, op);
11842         if (!pat)
11843           return 0;
11844         emit_insn (pat);
11845
11846         return target;
11847       }
11848
11849     case ALTIVEC_BUILTIN_VCFUX:
11850     case ALTIVEC_BUILTIN_VCFSX:
11851     case ALTIVEC_BUILTIN_VCTUXS:
11852     case ALTIVEC_BUILTIN_VCTSXS:
11853   /* FIXME: There's got to be a nicer way to handle this case than
11854      constructing a new CALL_EXPR.  */
11855       if (call_expr_nargs (exp) == 1)
11856         {
11857           exp = build_call_nary (TREE_TYPE (exp), CALL_EXPR_FN (exp),
11858                                  2, CALL_EXPR_ARG (exp, 0), integer_zero_node);
11859         }
11860       break;
11861
11862     default:
11863       break;
11864     }
11865
11866   if (TARGET_ALTIVEC)
11867     {
11868       ret = altivec_expand_builtin (exp, target, &success);
11869
11870       if (success)
11871         return ret;
11872     }
11873   if (TARGET_SPE)
11874     {
11875       ret = spe_expand_builtin (exp, target, &success);
11876
11877       if (success)
11878         return ret;
11879     }
11880   if (TARGET_PAIRED_FLOAT)
11881     {
11882       ret = paired_expand_builtin (exp, target, &success);
11883
11884       if (success)
11885         return ret;
11886     }
11887
11888   gcc_assert (TARGET_ALTIVEC || TARGET_VSX || TARGET_SPE || TARGET_PAIRED_FLOAT);
11889
11890   /* Handle simple unary operations.  */
11891   d = (struct builtin_description *) bdesc_1arg;
11892   for (i = 0; i < ARRAY_SIZE (bdesc_1arg); i++, d++)
11893     if (d->code == fcode)
11894       return rs6000_expand_unop_builtin (d->icode, exp, target);
11895
11896   /* Handle simple binary operations.  */
11897   d = (struct builtin_description *) bdesc_2arg;
11898   for (i = 0; i < ARRAY_SIZE (bdesc_2arg); i++, d++)
11899     if (d->code == fcode)
11900       return rs6000_expand_binop_builtin (d->icode, exp, target);
11901
11902   /* Handle simple ternary operations.  */
11903   d = bdesc_3arg;
11904   for (i = 0; i < ARRAY_SIZE  (bdesc_3arg); i++, d++)
11905     if (d->code == fcode)
11906       return rs6000_expand_ternop_builtin (d->icode, exp, target);
11907
11908   gcc_unreachable ();
11909 }
11910
11911 static void
11912 rs6000_init_builtins (void)
11913 {
11914   tree tdecl;
11915   tree ftype;
11916
11917   V2SI_type_node = build_vector_type (intSI_type_node, 2);
11918   V2SF_type_node = build_vector_type (float_type_node, 2);
11919   V2DI_type_node = build_vector_type (intDI_type_node, 2);
11920   V2DF_type_node = build_vector_type (double_type_node, 2);
11921   V4HI_type_node = build_vector_type (intHI_type_node, 4);
11922   V4SI_type_node = build_vector_type (intSI_type_node, 4);
11923   V4SF_type_node = build_vector_type (float_type_node, 4);
11924   V8HI_type_node = build_vector_type (intHI_type_node, 8);
11925   V16QI_type_node = build_vector_type (intQI_type_node, 16);
11926
11927   unsigned_V16QI_type_node = build_vector_type (unsigned_intQI_type_node, 16);
11928   unsigned_V8HI_type_node = build_vector_type (unsigned_intHI_type_node, 8);
11929   unsigned_V4SI_type_node = build_vector_type (unsigned_intSI_type_node, 4);
11930   unsigned_V2DI_type_node = build_vector_type (unsigned_intDI_type_node, 2);
11931
11932   opaque_V2SF_type_node = build_opaque_vector_type (float_type_node, 2);
11933   opaque_V2SI_type_node = build_opaque_vector_type (intSI_type_node, 2);
11934   opaque_p_V2SI_type_node = build_pointer_type (opaque_V2SI_type_node);
11935   opaque_V4SI_type_node = build_opaque_vector_type (intSI_type_node, 4);
11936
11937   /* The 'vector bool ...' types must be kept distinct from 'vector unsigned ...'
11938      types, especially in C++ land.  Similarly, 'vector pixel' is distinct from
11939      'vector unsigned short'.  */
11940
11941   bool_char_type_node = build_distinct_type_copy (unsigned_intQI_type_node);
11942   bool_short_type_node = build_distinct_type_copy (unsigned_intHI_type_node);
11943   bool_int_type_node = build_distinct_type_copy (unsigned_intSI_type_node);
11944   bool_long_type_node = build_distinct_type_copy (unsigned_intDI_type_node);
11945   pixel_type_node = build_distinct_type_copy (unsigned_intHI_type_node);
11946
11947   long_integer_type_internal_node = long_integer_type_node;
11948   long_unsigned_type_internal_node = long_unsigned_type_node;
11949   long_long_integer_type_internal_node = long_long_integer_type_node;
11950   long_long_unsigned_type_internal_node = long_long_unsigned_type_node;
11951   intQI_type_internal_node = intQI_type_node;
11952   uintQI_type_internal_node = unsigned_intQI_type_node;
11953   intHI_type_internal_node = intHI_type_node;
11954   uintHI_type_internal_node = unsigned_intHI_type_node;
11955   intSI_type_internal_node = intSI_type_node;
11956   uintSI_type_internal_node = unsigned_intSI_type_node;
11957   intDI_type_internal_node = intDI_type_node;
11958   uintDI_type_internal_node = unsigned_intDI_type_node;
11959   float_type_internal_node = float_type_node;
11960   double_type_internal_node = double_type_node;
11961   void_type_internal_node = void_type_node;
11962
11963   /* Initialize the modes for builtin_function_type, mapping a machine mode to
11964      tree type node.  */
11965   builtin_mode_to_type[QImode][0] = integer_type_node;
11966   builtin_mode_to_type[HImode][0] = integer_type_node;
11967   builtin_mode_to_type[SImode][0] = intSI_type_node;
11968   builtin_mode_to_type[SImode][1] = unsigned_intSI_type_node;
11969   builtin_mode_to_type[DImode][0] = intDI_type_node;
11970   builtin_mode_to_type[DImode][1] = unsigned_intDI_type_node;
11971   builtin_mode_to_type[SFmode][0] = float_type_node;
11972   builtin_mode_to_type[DFmode][0] = double_type_node;
11973   builtin_mode_to_type[V2SImode][0] = V2SI_type_node;
11974   builtin_mode_to_type[V2SFmode][0] = V2SF_type_node;
11975   builtin_mode_to_type[V2DImode][0] = V2DI_type_node;
11976   builtin_mode_to_type[V2DImode][1] = unsigned_V2DI_type_node;
11977   builtin_mode_to_type[V2DFmode][0] = V2DF_type_node;
11978   builtin_mode_to_type[V4HImode][0] = V4HI_type_node;
11979   builtin_mode_to_type[V4SImode][0] = V4SI_type_node;
11980   builtin_mode_to_type[V4SImode][1] = unsigned_V4SI_type_node;
11981   builtin_mode_to_type[V4SFmode][0] = V4SF_type_node;
11982   builtin_mode_to_type[V8HImode][0] = V8HI_type_node;
11983   builtin_mode_to_type[V8HImode][1] = unsigned_V8HI_type_node;
11984   builtin_mode_to_type[V16QImode][0] = V16QI_type_node;
11985   builtin_mode_to_type[V16QImode][1] = unsigned_V16QI_type_node;
11986
11987   tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL,
11988                       get_identifier ("__bool char"),
11989                       bool_char_type_node);
11990   TYPE_NAME (bool_char_type_node) = tdecl;
11991   (*lang_hooks.decls.pushdecl) (tdecl);
11992   tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL,
11993                       get_identifier ("__bool short"),
11994                       bool_short_type_node);
11995   TYPE_NAME (bool_short_type_node) = tdecl;
11996   (*lang_hooks.decls.pushdecl) (tdecl);
11997   tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL,
11998                       get_identifier ("__bool int"),
11999                       bool_int_type_node);
12000   TYPE_NAME (bool_int_type_node) = tdecl;
12001   (*lang_hooks.decls.pushdecl) (tdecl);
12002   tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL, get_identifier ("__pixel"),
12003                       pixel_type_node);
12004   TYPE_NAME (pixel_type_node) = tdecl;
12005   (*lang_hooks.decls.pushdecl) (tdecl);
12006
12007   bool_V16QI_type_node = build_vector_type (bool_char_type_node, 16);
12008   bool_V8HI_type_node = build_vector_type (bool_short_type_node, 8);
12009   bool_V4SI_type_node = build_vector_type (bool_int_type_node, 4);
12010   bool_V2DI_type_node = build_vector_type (bool_long_type_node, 2);
12011   pixel_V8HI_type_node = build_vector_type (pixel_type_node, 8);
12012
12013   tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL,
12014                       get_identifier ("__vector unsigned char"),
12015                       unsigned_V16QI_type_node);
12016   TYPE_NAME (unsigned_V16QI_type_node) = tdecl;
12017   (*lang_hooks.decls.pushdecl) (tdecl);
12018   tdecl = build_decl (BUILTINS_LOCATION,
12019                       TYPE_DECL, get_identifier ("__vector signed char"),
12020                       V16QI_type_node);
12021   TYPE_NAME (V16QI_type_node) = tdecl;
12022   (*lang_hooks.decls.pushdecl) (tdecl);
12023   tdecl = build_decl (BUILTINS_LOCATION,
12024                       TYPE_DECL, get_identifier ("__vector __bool char"),
12025                       bool_V16QI_type_node);
12026   TYPE_NAME ( bool_V16QI_type_node) = tdecl;
12027   (*lang_hooks.decls.pushdecl) (tdecl);
12028
12029   tdecl = build_decl (BUILTINS_LOCATION,
12030                       TYPE_DECL, get_identifier ("__vector unsigned short"),
12031                       unsigned_V8HI_type_node);
12032   TYPE_NAME (unsigned_V8HI_type_node) = tdecl;
12033   (*lang_hooks.decls.pushdecl) (tdecl);
12034   tdecl = build_decl (BUILTINS_LOCATION,
12035                       TYPE_DECL, get_identifier ("__vector signed short"),
12036                       V8HI_type_node);
12037   TYPE_NAME (V8HI_type_node) = tdecl;
12038   (*lang_hooks.decls.pushdecl) (tdecl);
12039   tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL,
12040                       get_identifier ("__vector __bool short"),
12041                       bool_V8HI_type_node);
12042   TYPE_NAME (bool_V8HI_type_node) = tdecl;
12043   (*lang_hooks.decls.pushdecl) (tdecl);
12044
12045   tdecl = build_decl (BUILTINS_LOCATION, TYPE_DECL,
12046                       get_identifier ("__vector unsigned int"),
12047                       unsigned_V4SI_type_node);
12048   TYPE_NAME (unsigned_V4SI_type_node) = tdecl;
12049   (*lang_hooks.decls.pushdecl) (tdecl);
12050   tdecl = build_decl (BUILTINS_LOCATION,
12051                       TYPE_DECL, get_identifier ("__vector signed int"),
12052                       V4SI_type_node);
12053   TYPE_NAME (V4SI_type_node) = tdecl;
12054   (*lang_hooks.decls.pushdecl) (tdecl);
12055   tdecl = build_decl (BUILTINS_LOCATION,
12056                       TYPE_DECL, get_identifier ("__vector __bool int"),
12057                       bool_V4SI_type_node);
12058   TYPE_NAME (bool_V4SI_type_node) = tdecl;
12059   (*lang_hooks.decls.pushdecl) (tdecl);
12060
12061   tdecl = build_decl (BUILTINS_LOCATION,
12062                       TYPE_DECL, get_identifier ("__vector float"),
12063                       V4SF_type_node);
12064   TYPE_NAME (V4SF_type_node) = tdecl;
12065   (*lang_hooks.decls.pushdecl) (tdecl);
12066   tdecl = build_decl (BUILTINS_LOCATION,
12067                       TYPE_DECL, get_identifier ("__vector __pixel"),
12068                       pixel_V8HI_type_node);
12069   TYPE_NAME (pixel_V8HI_type_node) = tdecl;
12070   (*lang_hooks.decls.pushdecl) (tdecl);
12071
12072   if (TARGET_VSX)
12073     {
12074       tdecl = build_decl (BUILTINS_LOCATION,
12075                           TYPE_DECL, get_identifier ("__vector double"),
12076                           V2DF_type_node);
12077       TYPE_NAME (V2DF_type_node) = tdecl;
12078       (*lang_hooks.decls.pushdecl) (tdecl);
12079
12080       tdecl = build_decl (BUILTINS_LOCATION,
12081                           TYPE_DECL, get_identifier ("__vector long"),
12082                           V2DI_type_node);
12083       TYPE_NAME (V2DI_type_node) = tdecl;
12084       (*lang_hooks.decls.pushdecl) (tdecl);
12085
12086       tdecl = build_decl (BUILTINS_LOCATION,
12087                           TYPE_DECL, get_identifier ("__vector unsigned long"),
12088                           unsigned_V2DI_type_node);
12089       TYPE_NAME (unsigned_V2DI_type_node) = tdecl;
12090       (*lang_hooks.decls.pushdecl) (tdecl);
12091
12092       tdecl = build_decl (BUILTINS_LOCATION,
12093                           TYPE_DECL, get_identifier ("__vector __bool long"),
12094                           bool_V2DI_type_node);
12095       TYPE_NAME (bool_V2DI_type_node) = tdecl;
12096       (*lang_hooks.decls.pushdecl) (tdecl);
12097     }
12098
12099   if (TARGET_PAIRED_FLOAT)
12100     paired_init_builtins ();
12101   if (TARGET_SPE)
12102     spe_init_builtins ();
12103   if (TARGET_ALTIVEC)
12104     altivec_init_builtins ();
12105   if (TARGET_ALTIVEC || TARGET_SPE || TARGET_PAIRED_FLOAT || TARGET_VSX)
12106     rs6000_common_init_builtins ();
12107   if (TARGET_FRE)
12108     {
12109       ftype = builtin_function_type (DFmode, DFmode, DFmode, VOIDmode,
12110                                      RS6000_BUILTIN_RECIP,
12111                                      "__builtin_recipdiv");
12112       def_builtin (MASK_POPCNTB, "__builtin_recipdiv", ftype,
12113                    RS6000_BUILTIN_RECIP);
12114     }
12115   if (TARGET_FRES)
12116     {
12117       ftype = builtin_function_type (SFmode, SFmode, SFmode, VOIDmode,
12118                                      RS6000_BUILTIN_RECIPF,
12119                                      "__builtin_recipdivf");
12120       def_builtin (MASK_PPC_GFXOPT, "__builtin_recipdivf", ftype,
12121                    RS6000_BUILTIN_RECIPF);
12122     }
12123   if (TARGET_FRSQRTE)
12124     {
12125       ftype = builtin_function_type (DFmode, DFmode, VOIDmode, VOIDmode,
12126                                      RS6000_BUILTIN_RSQRT,
12127                                      "__builtin_rsqrt");
12128       def_builtin (MASK_PPC_GFXOPT, "__builtin_rsqrt", ftype,
12129                    RS6000_BUILTIN_RSQRT);
12130     }
12131   if (TARGET_FRSQRTES)
12132     {
12133       ftype = builtin_function_type (SFmode, SFmode, VOIDmode, VOIDmode,
12134                                      RS6000_BUILTIN_RSQRTF,
12135                                      "__builtin_rsqrtf");
12136       def_builtin (MASK_PPC_GFXOPT, "__builtin_rsqrtf", ftype,
12137                    RS6000_BUILTIN_RSQRTF);
12138     }
12139   if (TARGET_POPCNTD)
12140     {
12141       enum machine_mode mode = (TARGET_64BIT) ? DImode : SImode;
12142       tree ftype = builtin_function_type (mode, mode, mode, VOIDmode,
12143                                           POWER7_BUILTIN_BPERMD,
12144                                           "__builtin_bpermd");
12145       def_builtin (MASK_POPCNTD, "__builtin_bpermd", ftype,
12146                    POWER7_BUILTIN_BPERMD);
12147     }
12148   if (TARGET_POWERPC)
12149     {
12150       /* Don't use builtin_function_type here, as it maps HI/QI to SI.  */
12151       tree ftype = build_function_type_list (unsigned_intHI_type_node,
12152                                              unsigned_intHI_type_node,
12153                                              NULL_TREE);
12154       def_builtin (MASK_POWERPC, "__builtin_bswap16", ftype,
12155                    RS6000_BUILTIN_BSWAP_HI);
12156     }
12157
12158 #if TARGET_XCOFF
12159   /* AIX libm provides clog as __clog.  */
12160   if ((tdecl = builtin_decl_explicit (BUILT_IN_CLOG)) != NULL_TREE)
12161     set_user_assembler_name (tdecl, "__clog");
12162 #endif
12163
12164 #ifdef SUBTARGET_INIT_BUILTINS
12165   SUBTARGET_INIT_BUILTINS;
12166 #endif
12167 }
12168
12169 /* Returns the rs6000 builtin decl for CODE.  */
12170
12171 static tree
12172 rs6000_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
12173 {
12174   if (code >= RS6000_BUILTIN_COUNT)
12175     return error_mark_node;
12176
12177   return rs6000_builtin_decls[code];
12178 }
12179
12180 /* Search through a set of builtins and enable the mask bits.
12181    DESC is an array of builtins.
12182    SIZE is the total number of builtins.
12183    START is the builtin enum at which to start.
12184    END is the builtin enum at which to end.  */
12185 static void
12186 enable_mask_for_builtins (struct builtin_description *desc, int size,
12187                           enum rs6000_builtins start,
12188                           enum rs6000_builtins end)
12189 {
12190   int i;
12191
12192   for (i = 0; i < size; ++i)
12193     if (desc[i].code == start)
12194       break;
12195
12196   if (i == size)
12197     return;
12198
12199   for (; i < size; ++i)
12200     {
12201       /* Flip all the bits on.  */
12202       desc[i].mask = target_flags;
12203       if (desc[i].code == end)
12204         break;
12205     }
12206 }
12207
12208 static void
12209 spe_init_builtins (void)
12210 {
12211   tree puint_type_node = build_pointer_type (unsigned_type_node);
12212   tree pushort_type_node = build_pointer_type (short_unsigned_type_node);
12213   struct builtin_description *d;
12214   size_t i;
12215
12216   tree v2si_ftype_4_v2si
12217     = build_function_type_list (opaque_V2SI_type_node,
12218                                 opaque_V2SI_type_node,
12219                                 opaque_V2SI_type_node,
12220                                 opaque_V2SI_type_node,
12221                                 opaque_V2SI_type_node,
12222                                 NULL_TREE);
12223
12224   tree v2sf_ftype_4_v2sf
12225     = build_function_type_list (opaque_V2SF_type_node,
12226                                 opaque_V2SF_type_node,
12227                                 opaque_V2SF_type_node,
12228                                 opaque_V2SF_type_node,
12229                                 opaque_V2SF_type_node,
12230                                 NULL_TREE);
12231
12232   tree int_ftype_int_v2si_v2si
12233     = build_function_type_list (integer_type_node,
12234                                 integer_type_node,
12235                                 opaque_V2SI_type_node,
12236                                 opaque_V2SI_type_node,
12237                                 NULL_TREE);
12238
12239   tree int_ftype_int_v2sf_v2sf
12240     = build_function_type_list (integer_type_node,
12241                                 integer_type_node,
12242                                 opaque_V2SF_type_node,
12243                                 opaque_V2SF_type_node,
12244                                 NULL_TREE);
12245
12246   tree void_ftype_v2si_puint_int
12247     = build_function_type_list (void_type_node,
12248                                 opaque_V2SI_type_node,
12249                                 puint_type_node,
12250                                 integer_type_node,
12251                                 NULL_TREE);
12252
12253   tree void_ftype_v2si_puint_char
12254     = build_function_type_list (void_type_node,
12255                                 opaque_V2SI_type_node,
12256                                 puint_type_node,
12257                                 char_type_node,
12258                                 NULL_TREE);
12259
12260   tree void_ftype_v2si_pv2si_int
12261     = build_function_type_list (void_type_node,
12262                                 opaque_V2SI_type_node,
12263                                 opaque_p_V2SI_type_node,
12264                                 integer_type_node,
12265                                 NULL_TREE);
12266
12267   tree void_ftype_v2si_pv2si_char
12268     = build_function_type_list (void_type_node,
12269                                 opaque_V2SI_type_node,
12270                                 opaque_p_V2SI_type_node,
12271                                 char_type_node,
12272                                 NULL_TREE);
12273
12274   tree void_ftype_int
12275     = build_function_type_list (void_type_node, integer_type_node, NULL_TREE);
12276
12277   tree int_ftype_void
12278     = build_function_type_list (integer_type_node, NULL_TREE);
12279
12280   tree v2si_ftype_pv2si_int
12281     = build_function_type_list (opaque_V2SI_type_node,
12282                                 opaque_p_V2SI_type_node,
12283                                 integer_type_node,
12284                                 NULL_TREE);
12285
12286   tree v2si_ftype_puint_int
12287     = build_function_type_list (opaque_V2SI_type_node,
12288                                 puint_type_node,
12289                                 integer_type_node,
12290                                 NULL_TREE);
12291
12292   tree v2si_ftype_pushort_int
12293     = build_function_type_list (opaque_V2SI_type_node,
12294                                 pushort_type_node,
12295                                 integer_type_node,
12296                                 NULL_TREE);
12297
12298   tree v2si_ftype_signed_char
12299     = build_function_type_list (opaque_V2SI_type_node,
12300                                 signed_char_type_node,
12301                                 NULL_TREE);
12302
12303   /* The initialization of the simple binary and unary builtins is
12304      done in rs6000_common_init_builtins, but we have to enable the
12305      mask bits here manually because we have run out of `target_flags'
12306      bits.  We really need to redesign this mask business.  */
12307
12308   enable_mask_for_builtins ((struct builtin_description *) bdesc_2arg,
12309                             ARRAY_SIZE (bdesc_2arg),
12310                             SPE_BUILTIN_EVADDW,
12311                             SPE_BUILTIN_EVXOR);
12312   enable_mask_for_builtins ((struct builtin_description *) bdesc_1arg,
12313                             ARRAY_SIZE (bdesc_1arg),
12314                             SPE_BUILTIN_EVABS,
12315                             SPE_BUILTIN_EVSUBFUSIAAW);
12316   enable_mask_for_builtins ((struct builtin_description *) bdesc_spe_predicates,
12317                             ARRAY_SIZE (bdesc_spe_predicates),
12318                             SPE_BUILTIN_EVCMPEQ,
12319                             SPE_BUILTIN_EVFSTSTLT);
12320   enable_mask_for_builtins ((struct builtin_description *) bdesc_spe_evsel,
12321                             ARRAY_SIZE (bdesc_spe_evsel),
12322                             SPE_BUILTIN_EVSEL_CMPGTS,
12323                             SPE_BUILTIN_EVSEL_FSTSTEQ);
12324
12325   (*lang_hooks.decls.pushdecl)
12326     (build_decl (BUILTINS_LOCATION, TYPE_DECL,
12327                  get_identifier ("__ev64_opaque__"),
12328                  opaque_V2SI_type_node));
12329
12330   /* Initialize irregular SPE builtins.  */
12331
12332   def_builtin (target_flags, "__builtin_spe_mtspefscr", void_ftype_int, SPE_BUILTIN_MTSPEFSCR);
12333   def_builtin (target_flags, "__builtin_spe_mfspefscr", int_ftype_void, SPE_BUILTIN_MFSPEFSCR);
12334   def_builtin (target_flags, "__builtin_spe_evstddx", void_ftype_v2si_pv2si_int, SPE_BUILTIN_EVSTDDX);
12335   def_builtin (target_flags, "__builtin_spe_evstdhx", void_ftype_v2si_pv2si_int, SPE_BUILTIN_EVSTDHX);
12336   def_builtin (target_flags, "__builtin_spe_evstdwx", void_ftype_v2si_pv2si_int, SPE_BUILTIN_EVSTDWX);
12337   def_builtin (target_flags, "__builtin_spe_evstwhex", void_ftype_v2si_puint_int, SPE_BUILTIN_EVSTWHEX);
12338   def_builtin (target_flags, "__builtin_spe_evstwhox", void_ftype_v2si_puint_int, SPE_BUILTIN_EVSTWHOX);
12339   def_builtin (target_flags, "__builtin_spe_evstwwex", void_ftype_v2si_puint_int, SPE_BUILTIN_EVSTWWEX);
12340   def_builtin (target_flags, "__builtin_spe_evstwwox", void_ftype_v2si_puint_int, SPE_BUILTIN_EVSTWWOX);
12341   def_builtin (target_flags, "__builtin_spe_evstdd", void_ftype_v2si_pv2si_char, SPE_BUILTIN_EVSTDD);
12342   def_builtin (target_flags, "__builtin_spe_evstdh", void_ftype_v2si_pv2si_char, SPE_BUILTIN_EVSTDH);
12343   def_builtin (target_flags, "__builtin_spe_evstdw", void_ftype_v2si_pv2si_char, SPE_BUILTIN_EVSTDW);
12344   def_builtin (target_flags, "__builtin_spe_evstwhe", void_ftype_v2si_puint_char, SPE_BUILTIN_EVSTWHE);
12345   def_builtin (target_flags, "__builtin_spe_evstwho", void_ftype_v2si_puint_char, SPE_BUILTIN_EVSTWHO);
12346   def_builtin (target_flags, "__builtin_spe_evstwwe", void_ftype_v2si_puint_char, SPE_BUILTIN_EVSTWWE);
12347   def_builtin (target_flags, "__builtin_spe_evstwwo", void_ftype_v2si_puint_char, SPE_BUILTIN_EVSTWWO);
12348   def_builtin (target_flags, "__builtin_spe_evsplatfi", v2si_ftype_signed_char, SPE_BUILTIN_EVSPLATFI);
12349   def_builtin (target_flags, "__builtin_spe_evsplati", v2si_ftype_signed_char, SPE_BUILTIN_EVSPLATI);
12350
12351   /* Loads.  */
12352   def_builtin (target_flags, "__builtin_spe_evlddx", v2si_ftype_pv2si_int, SPE_BUILTIN_EVLDDX);
12353   def_builtin (target_flags, "__builtin_spe_evldwx", v2si_ftype_pv2si_int, SPE_BUILTIN_EVLDWX);
12354   def_builtin (target_flags, "__builtin_spe_evldhx", v2si_ftype_pv2si_int, SPE_BUILTIN_EVLDHX);
12355   def_builtin (target_flags, "__builtin_spe_evlwhex", v2si_ftype_puint_int, SPE_BUILTIN_EVLWHEX);
12356   def_builtin (target_flags, "__builtin_spe_evlwhoux", v2si_ftype_puint_int, SPE_BUILTIN_EVLWHOUX);
12357   def_builtin (target_flags, "__builtin_spe_evlwhosx", v2si_ftype_puint_int, SPE_BUILTIN_EVLWHOSX);
12358   def_builtin (target_flags, "__builtin_spe_evlwwsplatx", v2si_ftype_puint_int, SPE_BUILTIN_EVLWWSPLATX);
12359   def_builtin (target_flags, "__builtin_spe_evlwhsplatx", v2si_ftype_puint_int, SPE_BUILTIN_EVLWHSPLATX);
12360   def_builtin (target_flags, "__builtin_spe_evlhhesplatx", v2si_ftype_pushort_int, SPE_BUILTIN_EVLHHESPLATX);
12361   def_builtin (target_flags, "__builtin_spe_evlhhousplatx", v2si_ftype_pushort_int, SPE_BUILTIN_EVLHHOUSPLATX);
12362   def_builtin (target_flags, "__builtin_spe_evlhhossplatx", v2si_ftype_pushort_int, SPE_BUILTIN_EVLHHOSSPLATX);
12363   def_builtin (target_flags, "__builtin_spe_evldd", v2si_ftype_pv2si_int, SPE_BUILTIN_EVLDD);
12364   def_builtin (target_flags, "__builtin_spe_evldw", v2si_ftype_pv2si_int, SPE_BUILTIN_EVLDW);
12365   def_builtin (target_flags, "__builtin_spe_evldh", v2si_ftype_pv2si_int, SPE_BUILTIN_EVLDH);
12366   def_builtin (target_flags, "__builtin_spe_evlhhesplat", v2si_ftype_pushort_int, SPE_BUILTIN_EVLHHESPLAT);
12367   def_builtin (target_flags, "__builtin_spe_evlhhossplat", v2si_ftype_pushort_int, SPE_BUILTIN_EVLHHOSSPLAT);
12368   def_builtin (target_flags, "__builtin_spe_evlhhousplat", v2si_ftype_pushort_int, SPE_BUILTIN_EVLHHOUSPLAT);
12369   def_builtin (target_flags, "__builtin_spe_evlwhe", v2si_ftype_puint_int, SPE_BUILTIN_EVLWHE);
12370   def_builtin (target_flags, "__builtin_spe_evlwhos", v2si_ftype_puint_int, SPE_BUILTIN_EVLWHOS);
12371   def_builtin (target_flags, "__builtin_spe_evlwhou", v2si_ftype_puint_int, SPE_BUILTIN_EVLWHOU);
12372   def_builtin (target_flags, "__builtin_spe_evlwhsplat", v2si_ftype_puint_int, SPE_BUILTIN_EVLWHSPLAT);
12373   def_builtin (target_flags, "__builtin_spe_evlwwsplat", v2si_ftype_puint_int, SPE_BUILTIN_EVLWWSPLAT);
12374
12375   /* Predicates.  */
12376   d = (struct builtin_description *) bdesc_spe_predicates;
12377   for (i = 0; i < ARRAY_SIZE (bdesc_spe_predicates); ++i, d++)
12378     {
12379       tree type;
12380
12381       switch (insn_data[d->icode].operand[1].mode)
12382         {
12383         case V2SImode:
12384           type = int_ftype_int_v2si_v2si;
12385           break;
12386         case V2SFmode:
12387           type = int_ftype_int_v2sf_v2sf;
12388           break;
12389         default:
12390           gcc_unreachable ();
12391         }
12392
12393       def_builtin (d->mask, d->name, type, d->code);
12394     }
12395
12396   /* Evsel predicates.  */
12397   d = (struct builtin_description *) bdesc_spe_evsel;
12398   for (i = 0; i < ARRAY_SIZE (bdesc_spe_evsel); ++i, d++)
12399     {
12400       tree type;
12401
12402       switch (insn_data[d->icode].operand[1].mode)
12403         {
12404         case V2SImode:
12405           type = v2si_ftype_4_v2si;
12406           break;
12407         case V2SFmode:
12408           type = v2sf_ftype_4_v2sf;
12409           break;
12410         default:
12411           gcc_unreachable ();
12412         }
12413
12414       def_builtin (d->mask, d->name, type, d->code);
12415     }
12416 }
12417
12418 static void
12419 paired_init_builtins (void)
12420 {
12421   const struct builtin_description *d;
12422   size_t i;
12423
12424    tree int_ftype_int_v2sf_v2sf
12425     = build_function_type_list (integer_type_node,
12426                                 integer_type_node,
12427                                 V2SF_type_node,
12428                                 V2SF_type_node,
12429                                 NULL_TREE);
12430   tree pcfloat_type_node =
12431     build_pointer_type (build_qualified_type
12432                         (float_type_node, TYPE_QUAL_CONST));
12433
12434   tree v2sf_ftype_long_pcfloat = build_function_type_list (V2SF_type_node,
12435                                                            long_integer_type_node,
12436                                                            pcfloat_type_node,
12437                                                            NULL_TREE);
12438   tree void_ftype_v2sf_long_pcfloat =
12439     build_function_type_list (void_type_node,
12440                               V2SF_type_node,
12441                               long_integer_type_node,
12442                               pcfloat_type_node,
12443                               NULL_TREE);
12444
12445
12446   def_builtin (0, "__builtin_paired_lx", v2sf_ftype_long_pcfloat,
12447                PAIRED_BUILTIN_LX);
12448
12449
12450   def_builtin (0, "__builtin_paired_stx", void_ftype_v2sf_long_pcfloat,
12451                PAIRED_BUILTIN_STX);
12452
12453   /* Predicates.  */
12454   d = bdesc_paired_preds;
12455   for (i = 0; i < ARRAY_SIZE (bdesc_paired_preds); ++i, d++)
12456     {
12457       tree type;
12458
12459       switch (insn_data[d->icode].operand[1].mode)
12460         {
12461         case V2SFmode:
12462           type = int_ftype_int_v2sf_v2sf;
12463           break;
12464         default:
12465           gcc_unreachable ();
12466         }
12467
12468       def_builtin (d->mask, d->name, type, d->code);
12469     }
12470 }
12471
12472 static void
12473 altivec_init_builtins (void)
12474 {
12475   const struct builtin_description *d;
12476   const struct builtin_description_predicates *dp;
12477   size_t i;
12478   tree ftype;
12479
12480   tree pvoid_type_node = build_pointer_type (void_type_node);
12481
12482   tree pcvoid_type_node
12483     = build_pointer_type (build_qualified_type (void_type_node,
12484                                                 TYPE_QUAL_CONST));
12485
12486   tree int_ftype_opaque
12487     = build_function_type_list (integer_type_node,
12488                                 opaque_V4SI_type_node, NULL_TREE);
12489   tree opaque_ftype_opaque
12490     = build_function_type_list (integer_type_node, NULL_TREE);
12491   tree opaque_ftype_opaque_int
12492     = build_function_type_list (opaque_V4SI_type_node,
12493                                 opaque_V4SI_type_node, integer_type_node, NULL_TREE);
12494   tree opaque_ftype_opaque_opaque_int
12495     = build_function_type_list (opaque_V4SI_type_node,
12496                                 opaque_V4SI_type_node, opaque_V4SI_type_node,
12497                                 integer_type_node, NULL_TREE);
12498   tree int_ftype_int_opaque_opaque
12499     = build_function_type_list (integer_type_node,
12500                                 integer_type_node, opaque_V4SI_type_node,
12501                                 opaque_V4SI_type_node, NULL_TREE);
12502   tree int_ftype_int_v4si_v4si
12503     = build_function_type_list (integer_type_node,
12504                                 integer_type_node, V4SI_type_node,
12505                                 V4SI_type_node, NULL_TREE);
12506   tree void_ftype_v4si
12507     = build_function_type_list (void_type_node, V4SI_type_node, NULL_TREE);
12508   tree v8hi_ftype_void
12509     = build_function_type_list (V8HI_type_node, NULL_TREE);
12510   tree void_ftype_void
12511     = build_function_type_list (void_type_node, NULL_TREE);
12512   tree void_ftype_int
12513     = build_function_type_list (void_type_node, integer_type_node, NULL_TREE);
12514
12515   tree opaque_ftype_long_pcvoid
12516     = build_function_type_list (opaque_V4SI_type_node,
12517                                 long_integer_type_node, pcvoid_type_node,
12518                                 NULL_TREE);
12519   tree v16qi_ftype_long_pcvoid
12520     = build_function_type_list (V16QI_type_node,
12521                                 long_integer_type_node, pcvoid_type_node,
12522                                 NULL_TREE);
12523   tree v8hi_ftype_long_pcvoid
12524     = build_function_type_list (V8HI_type_node,
12525                                 long_integer_type_node, pcvoid_type_node,
12526                                 NULL_TREE);
12527   tree v4si_ftype_long_pcvoid
12528     = build_function_type_list (V4SI_type_node,
12529                                 long_integer_type_node, pcvoid_type_node,
12530                                 NULL_TREE);
12531   tree v4sf_ftype_long_pcvoid
12532     = build_function_type_list (V4SF_type_node,
12533                                 long_integer_type_node, pcvoid_type_node,
12534                                 NULL_TREE);
12535   tree v2df_ftype_long_pcvoid
12536     = build_function_type_list (V2DF_type_node,
12537                                 long_integer_type_node, pcvoid_type_node,
12538                                 NULL_TREE);
12539   tree v2di_ftype_long_pcvoid
12540     = build_function_type_list (V2DI_type_node,
12541                                 long_integer_type_node, pcvoid_type_node,
12542                                 NULL_TREE);
12543
12544   tree void_ftype_opaque_long_pvoid
12545     = build_function_type_list (void_type_node,
12546                                 opaque_V4SI_type_node, long_integer_type_node,
12547                                 pvoid_type_node, NULL_TREE);
12548   tree void_ftype_v4si_long_pvoid
12549     = build_function_type_list (void_type_node,
12550                                 V4SI_type_node, long_integer_type_node,
12551                                 pvoid_type_node, NULL_TREE);
12552   tree void_ftype_v16qi_long_pvoid
12553     = build_function_type_list (void_type_node,
12554                                 V16QI_type_node, long_integer_type_node,
12555                                 pvoid_type_node, NULL_TREE);
12556   tree void_ftype_v8hi_long_pvoid
12557     = build_function_type_list (void_type_node,
12558                                 V8HI_type_node, long_integer_type_node,
12559                                 pvoid_type_node, NULL_TREE);
12560   tree void_ftype_v4sf_long_pvoid
12561     = build_function_type_list (void_type_node,
12562                                 V4SF_type_node, long_integer_type_node,
12563                                 pvoid_type_node, NULL_TREE);
12564   tree void_ftype_v2df_long_pvoid
12565     = build_function_type_list (void_type_node,
12566                                 V2DF_type_node, long_integer_type_node,
12567                                 pvoid_type_node, NULL_TREE);
12568   tree void_ftype_v2di_long_pvoid
12569     = build_function_type_list (void_type_node,
12570                                 V2DI_type_node, long_integer_type_node,
12571                                 pvoid_type_node, NULL_TREE);
12572   tree int_ftype_int_v8hi_v8hi
12573     = build_function_type_list (integer_type_node,
12574                                 integer_type_node, V8HI_type_node,
12575                                 V8HI_type_node, NULL_TREE);
12576   tree int_ftype_int_v16qi_v16qi
12577     = build_function_type_list (integer_type_node,
12578                                 integer_type_node, V16QI_type_node,
12579                                 V16QI_type_node, NULL_TREE);
12580   tree int_ftype_int_v4sf_v4sf
12581     = build_function_type_list (integer_type_node,
12582                                 integer_type_node, V4SF_type_node,
12583                                 V4SF_type_node, NULL_TREE);
12584   tree int_ftype_int_v2df_v2df
12585     = build_function_type_list (integer_type_node,
12586                                 integer_type_node, V2DF_type_node,
12587                                 V2DF_type_node, NULL_TREE);
12588   tree v4si_ftype_v4si
12589     = build_function_type_list (V4SI_type_node, V4SI_type_node, NULL_TREE);
12590   tree v8hi_ftype_v8hi
12591     = build_function_type_list (V8HI_type_node, V8HI_type_node, NULL_TREE);
12592   tree v16qi_ftype_v16qi
12593     = build_function_type_list (V16QI_type_node, V16QI_type_node, NULL_TREE);
12594   tree v4sf_ftype_v4sf
12595     = build_function_type_list (V4SF_type_node, V4SF_type_node, NULL_TREE);
12596   tree v2df_ftype_v2df
12597     = build_function_type_list (V2DF_type_node, V2DF_type_node, NULL_TREE);
12598   tree void_ftype_pcvoid_int_int
12599     = build_function_type_list (void_type_node,
12600                                 pcvoid_type_node, integer_type_node,
12601                                 integer_type_node, NULL_TREE);
12602
12603   def_builtin (MASK_ALTIVEC, "__builtin_altivec_mtvscr", void_ftype_v4si, ALTIVEC_BUILTIN_MTVSCR);
12604   def_builtin (MASK_ALTIVEC, "__builtin_altivec_mfvscr", v8hi_ftype_void, ALTIVEC_BUILTIN_MFVSCR);
12605   def_builtin (MASK_ALTIVEC, "__builtin_altivec_dssall", void_ftype_void, ALTIVEC_BUILTIN_DSSALL);
12606   def_builtin (MASK_ALTIVEC, "__builtin_altivec_dss", void_ftype_int, ALTIVEC_BUILTIN_DSS);
12607   def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvsl", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVSL);
12608   def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvsr", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVSR);
12609   def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvebx", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVEBX);
12610   def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvehx", v8hi_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVEHX);
12611   def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvewx", v4si_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVEWX);
12612   def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvxl", v4si_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVXL);
12613   def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvx", v4si_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVX);
12614   def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvx", void_ftype_v4si_long_pvoid, ALTIVEC_BUILTIN_STVX);
12615   def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvewx", void_ftype_v4si_long_pvoid, ALTIVEC_BUILTIN_STVEWX);
12616   def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvxl", void_ftype_v4si_long_pvoid, ALTIVEC_BUILTIN_STVXL);
12617   def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvebx", void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_STVEBX);
12618   def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvehx", void_ftype_v8hi_long_pvoid, ALTIVEC_BUILTIN_STVEHX);
12619   def_builtin (MASK_ALTIVEC, "__builtin_vec_ld", opaque_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LD);
12620   def_builtin (MASK_ALTIVEC, "__builtin_vec_lde", opaque_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LDE);
12621   def_builtin (MASK_ALTIVEC, "__builtin_vec_ldl", opaque_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LDL);
12622   def_builtin (MASK_ALTIVEC, "__builtin_vec_lvsl", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVSL);
12623   def_builtin (MASK_ALTIVEC, "__builtin_vec_lvsr", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVSR);
12624   def_builtin (MASK_ALTIVEC, "__builtin_vec_lvebx", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVEBX);
12625   def_builtin (MASK_ALTIVEC, "__builtin_vec_lvehx", v8hi_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVEHX);
12626   def_builtin (MASK_ALTIVEC, "__builtin_vec_lvewx", v4si_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVEWX);
12627   def_builtin (MASK_ALTIVEC, "__builtin_vec_st", void_ftype_opaque_long_pvoid, ALTIVEC_BUILTIN_VEC_ST);
12628   def_builtin (MASK_ALTIVEC, "__builtin_vec_ste", void_ftype_opaque_long_pvoid, ALTIVEC_BUILTIN_VEC_STE);
12629   def_builtin (MASK_ALTIVEC, "__builtin_vec_stl", void_ftype_opaque_long_pvoid, ALTIVEC_BUILTIN_VEC_STL);
12630   def_builtin (MASK_ALTIVEC, "__builtin_vec_stvewx", void_ftype_opaque_long_pvoid, ALTIVEC_BUILTIN_VEC_STVEWX);
12631   def_builtin (MASK_ALTIVEC, "__builtin_vec_stvebx", void_ftype_opaque_long_pvoid, ALTIVEC_BUILTIN_VEC_STVEBX);
12632   def_builtin (MASK_ALTIVEC, "__builtin_vec_stvehx", void_ftype_opaque_long_pvoid, ALTIVEC_BUILTIN_VEC_STVEHX);
12633
12634   def_builtin (MASK_VSX, "__builtin_vsx_lxvd2x_v2df", v2df_ftype_long_pcvoid,
12635                VSX_BUILTIN_LXVD2X_V2DF);
12636   def_builtin (MASK_VSX, "__builtin_vsx_lxvd2x_v2di", v2di_ftype_long_pcvoid,
12637                VSX_BUILTIN_LXVD2X_V2DI);
12638   def_builtin (MASK_VSX, "__builtin_vsx_lxvw4x_v4sf", v4sf_ftype_long_pcvoid,
12639                VSX_BUILTIN_LXVW4X_V4SF);
12640   def_builtin (MASK_VSX, "__builtin_vsx_lxvw4x_v4si", v4si_ftype_long_pcvoid,
12641                VSX_BUILTIN_LXVW4X_V4SI);
12642   def_builtin (MASK_VSX, "__builtin_vsx_lxvw4x_v8hi",
12643                v8hi_ftype_long_pcvoid, VSX_BUILTIN_LXVW4X_V8HI);
12644   def_builtin (MASK_VSX, "__builtin_vsx_lxvw4x_v16qi",
12645                v16qi_ftype_long_pcvoid, VSX_BUILTIN_LXVW4X_V16QI);
12646   def_builtin (MASK_VSX, "__builtin_vsx_stxvd2x_v2df",
12647                void_ftype_v2df_long_pvoid, VSX_BUILTIN_STXVD2X_V2DF);
12648   def_builtin (MASK_VSX, "__builtin_vsx_stxvd2x_v2di",
12649                void_ftype_v2di_long_pvoid, VSX_BUILTIN_STXVD2X_V2DI);
12650   def_builtin (MASK_VSX, "__builtin_vsx_stxvw4x_v4sf",
12651                void_ftype_v4sf_long_pvoid, VSX_BUILTIN_STXVW4X_V4SF);
12652   def_builtin (MASK_VSX, "__builtin_vsx_stxvw4x_v4si",
12653                void_ftype_v4si_long_pvoid, VSX_BUILTIN_STXVW4X_V4SI);
12654   def_builtin (MASK_VSX, "__builtin_vsx_stxvw4x_v8hi",
12655                void_ftype_v8hi_long_pvoid, VSX_BUILTIN_STXVW4X_V8HI);
12656   def_builtin (MASK_VSX, "__builtin_vsx_stxvw4x_v16qi",
12657                void_ftype_v16qi_long_pvoid, VSX_BUILTIN_STXVW4X_V16QI);
12658   def_builtin (MASK_VSX, "__builtin_vec_vsx_ld", opaque_ftype_long_pcvoid,
12659                VSX_BUILTIN_VEC_LD);
12660   def_builtin (MASK_VSX, "__builtin_vec_vsx_st", void_ftype_opaque_long_pvoid,
12661                VSX_BUILTIN_VEC_ST);
12662
12663   if (rs6000_cpu == PROCESSOR_CELL)
12664     {
12665       def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvlx",  v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVLX);
12666       def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvlxl", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVLXL);
12667       def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvrx",  v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVRX);
12668       def_builtin (MASK_ALTIVEC, "__builtin_altivec_lvrxl", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_LVRXL);
12669
12670       def_builtin (MASK_ALTIVEC, "__builtin_vec_lvlx",  v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVLX);
12671       def_builtin (MASK_ALTIVEC, "__builtin_vec_lvlxl", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVLXL);
12672       def_builtin (MASK_ALTIVEC, "__builtin_vec_lvrx",  v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVRX);
12673       def_builtin (MASK_ALTIVEC, "__builtin_vec_lvrxl", v16qi_ftype_long_pcvoid, ALTIVEC_BUILTIN_VEC_LVRXL);
12674
12675       def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvlx",  void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_STVLX);
12676       def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvlxl", void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_STVLXL);
12677       def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvrx",  void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_STVRX);
12678       def_builtin (MASK_ALTIVEC, "__builtin_altivec_stvrxl", void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_STVRXL);
12679
12680       def_builtin (MASK_ALTIVEC, "__builtin_vec_stvlx",  void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_VEC_STVLX);
12681       def_builtin (MASK_ALTIVEC, "__builtin_vec_stvlxl", void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_VEC_STVLXL);
12682       def_builtin (MASK_ALTIVEC, "__builtin_vec_stvrx",  void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_VEC_STVRX);
12683       def_builtin (MASK_ALTIVEC, "__builtin_vec_stvrxl", void_ftype_v16qi_long_pvoid, ALTIVEC_BUILTIN_VEC_STVRXL);
12684     }
12685   def_builtin (MASK_ALTIVEC, "__builtin_vec_step", int_ftype_opaque, ALTIVEC_BUILTIN_VEC_STEP);
12686   def_builtin (MASK_ALTIVEC, "__builtin_vec_splats", opaque_ftype_opaque, ALTIVEC_BUILTIN_VEC_SPLATS);
12687   def_builtin (MASK_ALTIVEC, "__builtin_vec_promote", opaque_ftype_opaque, ALTIVEC_BUILTIN_VEC_PROMOTE);
12688
12689   def_builtin (MASK_ALTIVEC, "__builtin_vec_sld", opaque_ftype_opaque_opaque_int, ALTIVEC_BUILTIN_VEC_SLD);
12690   def_builtin (MASK_ALTIVEC, "__builtin_vec_splat", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_SPLAT);
12691   def_builtin (MASK_ALTIVEC, "__builtin_vec_extract", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_EXTRACT);
12692   def_builtin (MASK_ALTIVEC, "__builtin_vec_insert", opaque_ftype_opaque_opaque_int, ALTIVEC_BUILTIN_VEC_INSERT);
12693   def_builtin (MASK_ALTIVEC, "__builtin_vec_vspltw", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_VSPLTW);
12694   def_builtin (MASK_ALTIVEC, "__builtin_vec_vsplth", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_VSPLTH);
12695   def_builtin (MASK_ALTIVEC, "__builtin_vec_vspltb", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_VSPLTB);
12696   def_builtin (MASK_ALTIVEC, "__builtin_vec_ctf", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_CTF);
12697   def_builtin (MASK_ALTIVEC, "__builtin_vec_vcfsx", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_VCFSX);
12698   def_builtin (MASK_ALTIVEC, "__builtin_vec_vcfux", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_VCFUX);
12699   def_builtin (MASK_ALTIVEC, "__builtin_vec_cts", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_CTS);
12700   def_builtin (MASK_ALTIVEC, "__builtin_vec_ctu", opaque_ftype_opaque_int, ALTIVEC_BUILTIN_VEC_CTU);
12701
12702   /* Add the DST variants.  */
12703   d = bdesc_dst;
12704   for (i = 0; i < ARRAY_SIZE (bdesc_dst); i++, d++)
12705     def_builtin (d->mask, d->name, void_ftype_pcvoid_int_int, d->code);
12706
12707   /* Initialize the predicates.  */
12708   dp = bdesc_altivec_preds;
12709   for (i = 0; i < ARRAY_SIZE (bdesc_altivec_preds); i++, dp++)
12710     {
12711       enum machine_mode mode1;
12712       tree type;
12713       bool is_overloaded = ((dp->code >= ALTIVEC_BUILTIN_OVERLOADED_FIRST
12714                              && dp->code <= ALTIVEC_BUILTIN_OVERLOADED_LAST)
12715                             || (dp->code >= VSX_BUILTIN_OVERLOADED_FIRST
12716                                 && dp->code <= VSX_BUILTIN_OVERLOADED_LAST));
12717
12718       if (is_overloaded)
12719         mode1 = VOIDmode;
12720       else
12721         mode1 = insn_data[dp->icode].operand[1].mode;
12722
12723       switch (mode1)
12724         {
12725         case VOIDmode:
12726           type = int_ftype_int_opaque_opaque;
12727           break;
12728         case V4SImode:
12729           type = int_ftype_int_v4si_v4si;
12730           break;
12731         case V8HImode:
12732           type = int_ftype_int_v8hi_v8hi;
12733           break;
12734         case V16QImode:
12735           type = int_ftype_int_v16qi_v16qi;
12736           break;
12737         case V4SFmode:
12738           type = int_ftype_int_v4sf_v4sf;
12739           break;
12740         case V2DFmode:
12741           type = int_ftype_int_v2df_v2df;
12742           break;
12743         default:
12744           gcc_unreachable ();
12745         }
12746
12747       def_builtin (dp->mask, dp->name, type, dp->code);
12748     }
12749
12750   /* Initialize the abs* operators.  */
12751   d = bdesc_abs;
12752   for (i = 0; i < ARRAY_SIZE (bdesc_abs); i++, d++)
12753     {
12754       enum machine_mode mode0;
12755       tree type;
12756
12757       mode0 = insn_data[d->icode].operand[0].mode;
12758
12759       switch (mode0)
12760         {
12761         case V4SImode:
12762           type = v4si_ftype_v4si;
12763           break;
12764         case V8HImode:
12765           type = v8hi_ftype_v8hi;
12766           break;
12767         case V16QImode:
12768           type = v16qi_ftype_v16qi;
12769           break;
12770         case V4SFmode:
12771           type = v4sf_ftype_v4sf;
12772           break;
12773         case V2DFmode:
12774           type = v2df_ftype_v2df;
12775           break;
12776         default:
12777           gcc_unreachable ();
12778         }
12779
12780       def_builtin (d->mask, d->name, type, d->code);
12781     }
12782
12783   if (TARGET_ALTIVEC)
12784     {
12785       tree decl;
12786
12787       /* Initialize target builtin that implements
12788          targetm.vectorize.builtin_mask_for_load.  */
12789
12790       decl = add_builtin_function ("__builtin_altivec_mask_for_load",
12791                                    v16qi_ftype_long_pcvoid,
12792                                    ALTIVEC_BUILTIN_MASK_FOR_LOAD,
12793                                    BUILT_IN_MD, NULL, NULL_TREE);
12794       TREE_READONLY (decl) = 1;
12795       /* Record the decl. Will be used by rs6000_builtin_mask_for_load.  */
12796       altivec_builtin_mask_for_load = decl;
12797     }
12798
12799   /* Access to the vec_init patterns.  */
12800   ftype = build_function_type_list (V4SI_type_node, integer_type_node,
12801                                     integer_type_node, integer_type_node,
12802                                     integer_type_node, NULL_TREE);
12803   def_builtin (MASK_ALTIVEC, "__builtin_vec_init_v4si", ftype,
12804                ALTIVEC_BUILTIN_VEC_INIT_V4SI);
12805
12806   ftype = build_function_type_list (V8HI_type_node, short_integer_type_node,
12807                                     short_integer_type_node,
12808                                     short_integer_type_node,
12809                                     short_integer_type_node,
12810                                     short_integer_type_node,
12811                                     short_integer_type_node,
12812                                     short_integer_type_node,
12813                                     short_integer_type_node, NULL_TREE);
12814   def_builtin (MASK_ALTIVEC, "__builtin_vec_init_v8hi", ftype,
12815                ALTIVEC_BUILTIN_VEC_INIT_V8HI);
12816
12817   ftype = build_function_type_list (V16QI_type_node, char_type_node,
12818                                     char_type_node, char_type_node,
12819                                     char_type_node, char_type_node,
12820                                     char_type_node, char_type_node,
12821                                     char_type_node, char_type_node,
12822                                     char_type_node, char_type_node,
12823                                     char_type_node, char_type_node,
12824                                     char_type_node, char_type_node,
12825                                     char_type_node, NULL_TREE);
12826   def_builtin (MASK_ALTIVEC, "__builtin_vec_init_v16qi", ftype,
12827                ALTIVEC_BUILTIN_VEC_INIT_V16QI);
12828
12829   ftype = build_function_type_list (V4SF_type_node, float_type_node,
12830                                     float_type_node, float_type_node,
12831                                     float_type_node, NULL_TREE);
12832   def_builtin (MASK_ALTIVEC, "__builtin_vec_init_v4sf", ftype,
12833                ALTIVEC_BUILTIN_VEC_INIT_V4SF);
12834
12835   if (TARGET_VSX)
12836     {
12837       ftype = build_function_type_list (V2DF_type_node, double_type_node,
12838                                         double_type_node, NULL_TREE);
12839       def_builtin (MASK_VSX, "__builtin_vec_init_v2df", ftype,
12840                    VSX_BUILTIN_VEC_INIT_V2DF);
12841
12842       ftype = build_function_type_list (V2DI_type_node, intDI_type_node,
12843                                         intDI_type_node, NULL_TREE);
12844       def_builtin (MASK_VSX, "__builtin_vec_init_v2di", ftype,
12845                    VSX_BUILTIN_VEC_INIT_V2DI);
12846     }
12847
12848   /* Access to the vec_set patterns.  */
12849   ftype = build_function_type_list (V4SI_type_node, V4SI_type_node,
12850                                     intSI_type_node,
12851                                     integer_type_node, NULL_TREE);
12852   def_builtin (MASK_ALTIVEC, "__builtin_vec_set_v4si", ftype,
12853                ALTIVEC_BUILTIN_VEC_SET_V4SI);
12854
12855   ftype = build_function_type_list (V8HI_type_node, V8HI_type_node,
12856                                     intHI_type_node,
12857                                     integer_type_node, NULL_TREE);
12858   def_builtin (MASK_ALTIVEC, "__builtin_vec_set_v8hi", ftype,
12859                ALTIVEC_BUILTIN_VEC_SET_V8HI);
12860
12861   ftype = build_function_type_list (V16QI_type_node, V16QI_type_node,
12862                                     intQI_type_node,
12863                                     integer_type_node, NULL_TREE);
12864   def_builtin (MASK_ALTIVEC, "__builtin_vec_set_v16qi", ftype,
12865                ALTIVEC_BUILTIN_VEC_SET_V16QI);
12866
12867   ftype = build_function_type_list (V4SF_type_node, V4SF_type_node,
12868                                     float_type_node,
12869                                     integer_type_node, NULL_TREE);
12870   def_builtin (MASK_ALTIVEC|MASK_VSX, "__builtin_vec_set_v4sf", ftype,
12871                ALTIVEC_BUILTIN_VEC_SET_V4SF);
12872
12873   if (TARGET_VSX)
12874     {
12875       ftype = build_function_type_list (V2DF_type_node, V2DF_type_node,
12876                                         double_type_node,
12877                                         integer_type_node, NULL_TREE);
12878       def_builtin (MASK_VSX, "__builtin_vec_set_v2df", ftype,
12879                    VSX_BUILTIN_VEC_SET_V2DF);
12880
12881       ftype = build_function_type_list (V2DI_type_node, V2DI_type_node,
12882                                         intDI_type_node,
12883                                         integer_type_node, NULL_TREE);
12884       def_builtin (MASK_VSX, "__builtin_vec_set_v2di", ftype,
12885                    VSX_BUILTIN_VEC_SET_V2DI);
12886     }
12887
12888   /* Access to the vec_extract patterns.  */
12889   ftype = build_function_type_list (intSI_type_node, V4SI_type_node,
12890                                     integer_type_node, NULL_TREE);
12891   def_builtin (MASK_ALTIVEC, "__builtin_vec_ext_v4si", ftype,
12892                ALTIVEC_BUILTIN_VEC_EXT_V4SI);
12893
12894   ftype = build_function_type_list (intHI_type_node, V8HI_type_node,
12895                                     integer_type_node, NULL_TREE);
12896   def_builtin (MASK_ALTIVEC, "__builtin_vec_ext_v8hi", ftype,
12897                ALTIVEC_BUILTIN_VEC_EXT_V8HI);
12898
12899   ftype = build_function_type_list (intQI_type_node, V16QI_type_node,
12900                                     integer_type_node, NULL_TREE);
12901   def_builtin (MASK_ALTIVEC, "__builtin_vec_ext_v16qi", ftype,
12902                ALTIVEC_BUILTIN_VEC_EXT_V16QI);
12903
12904   ftype = build_function_type_list (float_type_node, V4SF_type_node,
12905                                     integer_type_node, NULL_TREE);
12906   def_builtin (MASK_ALTIVEC|MASK_VSX, "__builtin_vec_ext_v4sf", ftype,
12907                ALTIVEC_BUILTIN_VEC_EXT_V4SF);
12908
12909   if (TARGET_VSX)
12910     {
12911       ftype = build_function_type_list (double_type_node, V2DF_type_node,
12912                                         integer_type_node, NULL_TREE);
12913       def_builtin (MASK_VSX, "__builtin_vec_ext_v2df", ftype,
12914                    VSX_BUILTIN_VEC_EXT_V2DF);
12915
12916       ftype = build_function_type_list (intDI_type_node, V2DI_type_node,
12917                                         integer_type_node, NULL_TREE);
12918       def_builtin (MASK_VSX, "__builtin_vec_ext_v2di", ftype,
12919                    VSX_BUILTIN_VEC_EXT_V2DI);
12920     }
12921 }
12922
12923 /* Hash function for builtin functions with up to 3 arguments and a return
12924    type.  */
12925 static unsigned
12926 builtin_hash_function (const void *hash_entry)
12927 {
12928   unsigned ret = 0;
12929   int i;
12930   const struct builtin_hash_struct *bh =
12931     (const struct builtin_hash_struct *) hash_entry;
12932
12933   for (i = 0; i < 4; i++)
12934     {
12935       ret = (ret * (unsigned)MAX_MACHINE_MODE) + ((unsigned)bh->mode[i]);
12936       ret = (ret * 2) + bh->uns_p[i];
12937     }
12938
12939   return ret;
12940 }
12941
12942 /* Compare builtin hash entries H1 and H2 for equivalence.  */
12943 static int
12944 builtin_hash_eq (const void *h1, const void *h2)
12945 {
12946   const struct builtin_hash_struct *p1 = (const struct builtin_hash_struct *) h1;
12947   const struct builtin_hash_struct *p2 = (const struct builtin_hash_struct *) h2;
12948
12949   return ((p1->mode[0] == p2->mode[0])
12950           && (p1->mode[1] == p2->mode[1])
12951           && (p1->mode[2] == p2->mode[2])
12952           && (p1->mode[3] == p2->mode[3])
12953           && (p1->uns_p[0] == p2->uns_p[0])
12954           && (p1->uns_p[1] == p2->uns_p[1])
12955           && (p1->uns_p[2] == p2->uns_p[2])
12956           && (p1->uns_p[3] == p2->uns_p[3]));
12957 }
12958
12959 /* Map types for builtin functions with an explicit return type and up to 3
12960    arguments.  Functions with fewer than 3 arguments use VOIDmode as the type
12961    of the argument.  */
12962 static tree
12963 builtin_function_type (enum machine_mode mode_ret, enum machine_mode mode_arg0,
12964                        enum machine_mode mode_arg1, enum machine_mode mode_arg2,
12965                        enum rs6000_builtins builtin, const char *name)
12966 {
12967   struct builtin_hash_struct h;
12968   struct builtin_hash_struct *h2;
12969   void **found;
12970   int num_args = 3;
12971   int i;
12972   tree ret_type = NULL_TREE;
12973   tree arg_type[3] = { NULL_TREE, NULL_TREE, NULL_TREE };
12974
12975   /* Create builtin_hash_table.  */
12976   if (builtin_hash_table == NULL)
12977     builtin_hash_table = htab_create_ggc (1500, builtin_hash_function,
12978                                           builtin_hash_eq, NULL);
12979
12980   h.type = NULL_TREE;
12981   h.mode[0] = mode_ret;
12982   h.mode[1] = mode_arg0;
12983   h.mode[2] = mode_arg1;
12984   h.mode[3] = mode_arg2;
12985   h.uns_p[0] = 0;
12986   h.uns_p[1] = 0;
12987   h.uns_p[2] = 0;
12988   h.uns_p[3] = 0;
12989
12990   /* If the builtin is a type that produces unsigned results or takes unsigned
12991      arguments, and it is returned as a decl for the vectorizer (such as
12992      widening multiplies, permute), make sure the arguments and return value
12993      are type correct.  */
12994   switch (builtin)
12995     {
12996       /* unsigned 2 argument functions.  */
12997     case ALTIVEC_BUILTIN_VMULEUB_UNS:
12998     case ALTIVEC_BUILTIN_VMULEUH_UNS:
12999     case ALTIVEC_BUILTIN_VMULOUB_UNS:
13000     case ALTIVEC_BUILTIN_VMULOUH_UNS:
13001       h.uns_p[0] = 1;
13002       h.uns_p[1] = 1;
13003       h.uns_p[2] = 1;
13004       break;
13005
13006       /* unsigned 3 argument functions.  */
13007     case ALTIVEC_BUILTIN_VPERM_16QI_UNS:
13008     case ALTIVEC_BUILTIN_VPERM_8HI_UNS:
13009     case ALTIVEC_BUILTIN_VPERM_4SI_UNS:
13010     case ALTIVEC_BUILTIN_VPERM_2DI_UNS:
13011     case ALTIVEC_BUILTIN_VSEL_16QI_UNS:
13012     case ALTIVEC_BUILTIN_VSEL_8HI_UNS:
13013     case ALTIVEC_BUILTIN_VSEL_4SI_UNS:
13014     case ALTIVEC_BUILTIN_VSEL_2DI_UNS:
13015     case VSX_BUILTIN_VPERM_16QI_UNS:
13016     case VSX_BUILTIN_VPERM_8HI_UNS:
13017     case VSX_BUILTIN_VPERM_4SI_UNS:
13018     case VSX_BUILTIN_VPERM_2DI_UNS:
13019     case VSX_BUILTIN_XXSEL_16QI_UNS:
13020     case VSX_BUILTIN_XXSEL_8HI_UNS:
13021     case VSX_BUILTIN_XXSEL_4SI_UNS:
13022     case VSX_BUILTIN_XXSEL_2DI_UNS:
13023       h.uns_p[0] = 1;
13024       h.uns_p[1] = 1;
13025       h.uns_p[2] = 1;
13026       h.uns_p[3] = 1;
13027       break;
13028
13029       /* signed permute functions with unsigned char mask.  */
13030     case ALTIVEC_BUILTIN_VPERM_16QI:
13031     case ALTIVEC_BUILTIN_VPERM_8HI:
13032     case ALTIVEC_BUILTIN_VPERM_4SI:
13033     case ALTIVEC_BUILTIN_VPERM_4SF:
13034     case ALTIVEC_BUILTIN_VPERM_2DI:
13035     case ALTIVEC_BUILTIN_VPERM_2DF:
13036     case VSX_BUILTIN_VPERM_16QI:
13037     case VSX_BUILTIN_VPERM_8HI:
13038     case VSX_BUILTIN_VPERM_4SI:
13039     case VSX_BUILTIN_VPERM_4SF:
13040     case VSX_BUILTIN_VPERM_2DI:
13041     case VSX_BUILTIN_VPERM_2DF:
13042       h.uns_p[3] = 1;
13043       break;
13044
13045       /* unsigned args, signed return.  */
13046     case VSX_BUILTIN_XVCVUXDDP_UNS:
13047     case VECTOR_BUILTIN_UNSFLOAT_V4SI_V4SF:
13048       h.uns_p[1] = 1;
13049       break;
13050
13051       /* signed args, unsigned return.  */
13052     case VSX_BUILTIN_XVCVDPUXDS_UNS:
13053     case VECTOR_BUILTIN_FIXUNS_V4SF_V4SI:
13054       h.uns_p[0] = 1;
13055       break;
13056
13057     default:
13058       break;
13059     }
13060
13061   /* Figure out how many args are present.  */
13062   while (num_args > 0 && h.mode[num_args] == VOIDmode)
13063     num_args--;
13064
13065   if (num_args == 0)
13066     fatal_error ("internal error: builtin function %s had no type", name);
13067
13068   ret_type = builtin_mode_to_type[h.mode[0]][h.uns_p[0]];
13069   if (!ret_type && h.uns_p[0])
13070     ret_type = builtin_mode_to_type[h.mode[0]][0];
13071
13072   if (!ret_type)
13073     fatal_error ("internal error: builtin function %s had an unexpected "
13074                  "return type %s", name, GET_MODE_NAME (h.mode[0]));
13075
13076   for (i = 0; i < (int) ARRAY_SIZE (arg_type); i++)
13077     arg_type[i] = NULL_TREE;
13078
13079   for (i = 0; i < num_args; i++)
13080     {
13081       int m = (int) h.mode[i+1];
13082       int uns_p = h.uns_p[i+1];
13083
13084       arg_type[i] = builtin_mode_to_type[m][uns_p];
13085       if (!arg_type[i] && uns_p)
13086         arg_type[i] = builtin_mode_to_type[m][0];
13087
13088       if (!arg_type[i])
13089         fatal_error ("internal error: builtin function %s, argument %d "
13090                      "had unexpected argument type %s", name, i,
13091                      GET_MODE_NAME (m));
13092     }
13093
13094   found = htab_find_slot (builtin_hash_table, &h, INSERT);
13095   if (*found == NULL)
13096     {
13097       h2 = ggc_alloc_builtin_hash_struct ();
13098       *h2 = h;
13099       *found = (void *)h2;
13100
13101       h2->type = build_function_type_list (ret_type, arg_type[0], arg_type[1],
13102                                            arg_type[2], NULL_TREE);
13103     }
13104
13105   return ((struct builtin_hash_struct *)(*found))->type;
13106 }
13107
13108 static void
13109 rs6000_common_init_builtins (void)
13110 {
13111   const struct builtin_description *d;
13112   size_t i;
13113
13114   tree opaque_ftype_opaque = NULL_TREE;
13115   tree opaque_ftype_opaque_opaque = NULL_TREE;
13116   tree opaque_ftype_opaque_opaque_opaque = NULL_TREE;
13117   tree v2si_ftype_qi = NULL_TREE;
13118   tree v2si_ftype_v2si_qi = NULL_TREE;
13119   tree v2si_ftype_int_qi = NULL_TREE;
13120
13121   if (!TARGET_PAIRED_FLOAT)
13122     {
13123       builtin_mode_to_type[V2SImode][0] = opaque_V2SI_type_node;
13124       builtin_mode_to_type[V2SFmode][0] = opaque_V2SF_type_node;
13125     }
13126
13127   /* Add the ternary operators.  */
13128   d = bdesc_3arg;
13129   for (i = 0; i < ARRAY_SIZE (bdesc_3arg); i++, d++)
13130     {
13131       tree type;
13132       int mask = d->mask;
13133
13134       if ((mask != 0 && (mask & target_flags) == 0)
13135           || (mask == 0 && !TARGET_PAIRED_FLOAT))
13136         continue;
13137
13138       if ((d->code >= ALTIVEC_BUILTIN_OVERLOADED_FIRST
13139            && d->code <= ALTIVEC_BUILTIN_OVERLOADED_LAST)
13140           || (d->code >= VSX_BUILTIN_OVERLOADED_FIRST
13141               && d->code <= VSX_BUILTIN_OVERLOADED_LAST))
13142         {
13143           if (! (type = opaque_ftype_opaque_opaque_opaque))
13144             type = opaque_ftype_opaque_opaque_opaque
13145               = build_function_type_list (opaque_V4SI_type_node,
13146                                           opaque_V4SI_type_node,
13147                                           opaque_V4SI_type_node,
13148                                           opaque_V4SI_type_node,
13149                                           NULL_TREE);
13150         }
13151       else
13152         {
13153           enum insn_code icode = d->icode;
13154           if (d->name == 0 || icode == CODE_FOR_nothing)
13155             continue;
13156
13157           type = builtin_function_type (insn_data[icode].operand[0].mode,
13158                                         insn_data[icode].operand[1].mode,
13159                                         insn_data[icode].operand[2].mode,
13160                                         insn_data[icode].operand[3].mode,
13161                                         d->code, d->name);
13162         }
13163
13164       def_builtin (d->mask, d->name, type, d->code);
13165     }
13166
13167   /* Add the binary operators.  */
13168   d = bdesc_2arg;
13169   for (i = 0; i < ARRAY_SIZE (bdesc_2arg); i++, d++)
13170     {
13171       enum machine_mode mode0, mode1, mode2;
13172       tree type;
13173       int mask = d->mask;
13174
13175       if ((mask != 0 && (mask & target_flags) == 0)
13176           || (mask == 0 && !TARGET_PAIRED_FLOAT))
13177         continue;
13178
13179       if ((d->code >= ALTIVEC_BUILTIN_OVERLOADED_FIRST
13180            && d->code <= ALTIVEC_BUILTIN_OVERLOADED_LAST)
13181           || (d->code >= VSX_BUILTIN_OVERLOADED_FIRST
13182               && d->code <= VSX_BUILTIN_OVERLOADED_LAST))
13183         {
13184           if (! (type = opaque_ftype_opaque_opaque))
13185             type = opaque_ftype_opaque_opaque
13186               = build_function_type_list (opaque_V4SI_type_node,
13187                                           opaque_V4SI_type_node,
13188                                           opaque_V4SI_type_node,
13189                                           NULL_TREE);
13190         }
13191       else
13192         {
13193           enum insn_code icode = d->icode;
13194           if (d->name == 0 || icode == CODE_FOR_nothing)
13195             continue;
13196
13197           mode0 = insn_data[icode].operand[0].mode;
13198           mode1 = insn_data[icode].operand[1].mode;
13199           mode2 = insn_data[icode].operand[2].mode;
13200
13201           if (mode0 == V2SImode && mode1 == V2SImode && mode2 == QImode)
13202             {
13203               if (! (type = v2si_ftype_v2si_qi))
13204                 type = v2si_ftype_v2si_qi
13205                   = build_function_type_list (opaque_V2SI_type_node,
13206                                               opaque_V2SI_type_node,
13207                                               char_type_node,
13208                                               NULL_TREE);
13209             }
13210
13211           else if (mode0 == V2SImode && GET_MODE_CLASS (mode1) == MODE_INT
13212                    && mode2 == QImode)
13213             {
13214               if (! (type = v2si_ftype_int_qi))
13215                 type = v2si_ftype_int_qi
13216                   = build_function_type_list (opaque_V2SI_type_node,
13217                                               integer_type_node,
13218                                               char_type_node,
13219                                               NULL_TREE);
13220             }
13221
13222           else
13223             type = builtin_function_type (mode0, mode1, mode2, VOIDmode,
13224                                           d->code, d->name);
13225         }
13226
13227       def_builtin (d->mask, d->name, type, d->code);
13228     }
13229
13230   /* Add the simple unary operators.  */
13231   d = (struct builtin_description *) bdesc_1arg;
13232   for (i = 0; i < ARRAY_SIZE (bdesc_1arg); i++, d++)
13233     {
13234       enum machine_mode mode0, mode1;
13235       tree type;
13236       int mask = d->mask;
13237
13238       if ((mask != 0 && (mask & target_flags) == 0)
13239           || (mask == 0 && !TARGET_PAIRED_FLOAT))
13240         continue;
13241
13242       if ((d->code >= ALTIVEC_BUILTIN_OVERLOADED_FIRST
13243            && d->code <= ALTIVEC_BUILTIN_OVERLOADED_LAST)
13244           || (d->code >= VSX_BUILTIN_OVERLOADED_FIRST
13245               && d->code <= VSX_BUILTIN_OVERLOADED_LAST))
13246         {
13247           if (! (type = opaque_ftype_opaque))
13248             type = opaque_ftype_opaque
13249               = build_function_type_list (opaque_V4SI_type_node,
13250                                           opaque_V4SI_type_node,
13251                                           NULL_TREE);
13252         }
13253       else
13254         {
13255           enum insn_code icode = d->icode;
13256           if (d->name == 0 || icode == CODE_FOR_nothing)
13257             continue;
13258
13259           mode0 = insn_data[icode].operand[0].mode;
13260           mode1 = insn_data[icode].operand[1].mode;
13261
13262           if (mode0 == V2SImode && mode1 == QImode)
13263             {
13264               if (! (type = v2si_ftype_qi))
13265                 type = v2si_ftype_qi
13266                   = build_function_type_list (opaque_V2SI_type_node,
13267                                               char_type_node,
13268                                               NULL_TREE);
13269             }
13270
13271           else
13272             type = builtin_function_type (mode0, mode1, VOIDmode, VOIDmode,
13273                                           d->code, d->name);
13274         }
13275
13276       def_builtin (d->mask, d->name, type, d->code);
13277     }
13278 }
13279
13280 static void
13281 rs6000_init_libfuncs (void)
13282 {
13283   if (DEFAULT_ABI != ABI_V4 && TARGET_XCOFF
13284       && !TARGET_POWER2 && !TARGET_POWERPC)
13285     {
13286       /* AIX library routines for float->int conversion.  */
13287       set_conv_libfunc (sfix_optab, SImode, DFmode, "__itrunc");
13288       set_conv_libfunc (ufix_optab, SImode, DFmode, "__uitrunc");
13289       set_conv_libfunc (sfix_optab, SImode, TFmode, "_qitrunc");
13290       set_conv_libfunc (ufix_optab, SImode, TFmode, "_quitrunc");
13291     }
13292
13293   if (!TARGET_IEEEQUAD)
13294       /* AIX/Darwin/64-bit Linux quad floating point routines.  */
13295     if (!TARGET_XL_COMPAT)
13296       {
13297         set_optab_libfunc (add_optab, TFmode, "__gcc_qadd");
13298         set_optab_libfunc (sub_optab, TFmode, "__gcc_qsub");
13299         set_optab_libfunc (smul_optab, TFmode, "__gcc_qmul");
13300         set_optab_libfunc (sdiv_optab, TFmode, "__gcc_qdiv");
13301
13302         if (!(TARGET_HARD_FLOAT && (TARGET_FPRS || TARGET_E500_DOUBLE)))
13303           {
13304             set_optab_libfunc (neg_optab, TFmode, "__gcc_qneg");
13305             set_optab_libfunc (eq_optab, TFmode, "__gcc_qeq");
13306             set_optab_libfunc (ne_optab, TFmode, "__gcc_qne");
13307             set_optab_libfunc (gt_optab, TFmode, "__gcc_qgt");
13308             set_optab_libfunc (ge_optab, TFmode, "__gcc_qge");
13309             set_optab_libfunc (lt_optab, TFmode, "__gcc_qlt");
13310             set_optab_libfunc (le_optab, TFmode, "__gcc_qle");
13311
13312             set_conv_libfunc (sext_optab, TFmode, SFmode, "__gcc_stoq");
13313             set_conv_libfunc (sext_optab, TFmode, DFmode, "__gcc_dtoq");
13314             set_conv_libfunc (trunc_optab, SFmode, TFmode, "__gcc_qtos");
13315             set_conv_libfunc (trunc_optab, DFmode, TFmode, "__gcc_qtod");
13316             set_conv_libfunc (sfix_optab, SImode, TFmode, "__gcc_qtoi");
13317             set_conv_libfunc (ufix_optab, SImode, TFmode, "__gcc_qtou");
13318             set_conv_libfunc (sfloat_optab, TFmode, SImode, "__gcc_itoq");
13319             set_conv_libfunc (ufloat_optab, TFmode, SImode, "__gcc_utoq");
13320           }
13321
13322         if (!(TARGET_HARD_FLOAT && TARGET_FPRS))
13323           set_optab_libfunc (unord_optab, TFmode, "__gcc_qunord");
13324       }
13325     else
13326       {
13327         set_optab_libfunc (add_optab, TFmode, "_xlqadd");
13328         set_optab_libfunc (sub_optab, TFmode, "_xlqsub");
13329         set_optab_libfunc (smul_optab, TFmode, "_xlqmul");
13330         set_optab_libfunc (sdiv_optab, TFmode, "_xlqdiv");
13331       }
13332   else
13333     {
13334       /* 32-bit SVR4 quad floating point routines.  */
13335
13336       set_optab_libfunc (add_optab, TFmode, "_q_add");
13337       set_optab_libfunc (sub_optab, TFmode, "_q_sub");
13338       set_optab_libfunc (neg_optab, TFmode, "_q_neg");
13339       set_optab_libfunc (smul_optab, TFmode, "_q_mul");
13340       set_optab_libfunc (sdiv_optab, TFmode, "_q_div");
13341       if (TARGET_PPC_GPOPT || TARGET_POWER2)
13342         set_optab_libfunc (sqrt_optab, TFmode, "_q_sqrt");
13343
13344       set_optab_libfunc (eq_optab, TFmode, "_q_feq");
13345       set_optab_libfunc (ne_optab, TFmode, "_q_fne");
13346       set_optab_libfunc (gt_optab, TFmode, "_q_fgt");
13347       set_optab_libfunc (ge_optab, TFmode, "_q_fge");
13348       set_optab_libfunc (lt_optab, TFmode, "_q_flt");
13349       set_optab_libfunc (le_optab, TFmode, "_q_fle");
13350
13351       set_conv_libfunc (sext_optab, TFmode, SFmode, "_q_stoq");
13352       set_conv_libfunc (sext_optab, TFmode, DFmode, "_q_dtoq");
13353       set_conv_libfunc (trunc_optab, SFmode, TFmode, "_q_qtos");
13354       set_conv_libfunc (trunc_optab, DFmode, TFmode, "_q_qtod");
13355       set_conv_libfunc (sfix_optab, SImode, TFmode, "_q_qtoi");
13356       set_conv_libfunc (ufix_optab, SImode, TFmode, "_q_qtou");
13357       set_conv_libfunc (sfloat_optab, TFmode, SImode, "_q_itoq");
13358       set_conv_libfunc (ufloat_optab, TFmode, SImode, "_q_utoq");
13359     }
13360 }
13361
13362 \f
13363 /* Expand a block clear operation, and return 1 if successful.  Return 0
13364    if we should let the compiler generate normal code.
13365
13366    operands[0] is the destination
13367    operands[1] is the length
13368    operands[3] is the alignment */
13369
13370 int
13371 expand_block_clear (rtx operands[])
13372 {
13373   rtx orig_dest = operands[0];
13374   rtx bytes_rtx = operands[1];
13375   rtx align_rtx = operands[3];
13376   bool constp   = (GET_CODE (bytes_rtx) == CONST_INT);
13377   HOST_WIDE_INT align;
13378   HOST_WIDE_INT bytes;
13379   int offset;
13380   int clear_bytes;
13381   int clear_step;
13382
13383   /* If this is not a fixed size move, just call memcpy */
13384   if (! constp)
13385     return 0;
13386
13387   /* This must be a fixed size alignment  */
13388   gcc_assert (GET_CODE (align_rtx) == CONST_INT);
13389   align = INTVAL (align_rtx) * BITS_PER_UNIT;
13390
13391   /* Anything to clear? */
13392   bytes = INTVAL (bytes_rtx);
13393   if (bytes <= 0)
13394     return 1;
13395
13396   /* Use the builtin memset after a point, to avoid huge code bloat.
13397      When optimize_size, avoid any significant code bloat; calling
13398      memset is about 4 instructions, so allow for one instruction to
13399      load zero and three to do clearing.  */
13400   if (TARGET_ALTIVEC && align >= 128)
13401     clear_step = 16;
13402   else if (TARGET_POWERPC64 && align >= 32)
13403     clear_step = 8;
13404   else if (TARGET_SPE && align >= 64)
13405     clear_step = 8;
13406   else
13407     clear_step = 4;
13408
13409   if (optimize_size && bytes > 3 * clear_step)
13410     return 0;
13411   if (! optimize_size && bytes > 8 * clear_step)
13412     return 0;
13413
13414   for (offset = 0; bytes > 0; offset += clear_bytes, bytes -= clear_bytes)
13415     {
13416       enum machine_mode mode = BLKmode;
13417       rtx dest;
13418
13419       if (bytes >= 16 && TARGET_ALTIVEC && align >= 128)
13420         {
13421           clear_bytes = 16;
13422           mode = V4SImode;
13423         }
13424       else if (bytes >= 8 && TARGET_SPE && align >= 64)
13425         {
13426           clear_bytes = 8;
13427           mode = V2SImode;
13428         }
13429       else if (bytes >= 8 && TARGET_POWERPC64
13430                /* 64-bit loads and stores require word-aligned
13431                   displacements.  */
13432                && (align >= 64 || (!STRICT_ALIGNMENT && align >= 32)))
13433         {
13434           clear_bytes = 8;
13435           mode = DImode;
13436         }
13437       else if (bytes >= 4 && (align >= 32 || !STRICT_ALIGNMENT))
13438         {                       /* move 4 bytes */
13439           clear_bytes = 4;
13440           mode = SImode;
13441         }
13442       else if (bytes >= 2 && (align >= 16 || !STRICT_ALIGNMENT))
13443         {                       /* move 2 bytes */
13444           clear_bytes = 2;
13445           mode = HImode;
13446         }
13447       else /* move 1 byte at a time */
13448         {
13449           clear_bytes = 1;
13450           mode = QImode;
13451         }
13452
13453       dest = adjust_address (orig_dest, mode, offset);
13454
13455       emit_move_insn (dest, CONST0_RTX (mode));
13456     }
13457
13458   return 1;
13459 }
13460
13461 \f
13462 /* Expand a block move operation, and return 1 if successful.  Return 0
13463    if we should let the compiler generate normal code.
13464
13465    operands[0] is the destination
13466    operands[1] is the source
13467    operands[2] is the length
13468    operands[3] is the alignment */
13469
13470 #define MAX_MOVE_REG 4
13471
13472 int
13473 expand_block_move (rtx operands[])
13474 {
13475   rtx orig_dest = operands[0];
13476   rtx orig_src  = operands[1];
13477   rtx bytes_rtx = operands[2];
13478   rtx align_rtx = operands[3];
13479   int constp    = (GET_CODE (bytes_rtx) == CONST_INT);
13480   int align;
13481   int bytes;
13482   int offset;
13483   int move_bytes;
13484   rtx stores[MAX_MOVE_REG];
13485   int num_reg = 0;
13486
13487   /* If this is not a fixed size move, just call memcpy */
13488   if (! constp)
13489     return 0;
13490
13491   /* This must be a fixed size alignment */
13492   gcc_assert (GET_CODE (align_rtx) == CONST_INT);
13493   align = INTVAL (align_rtx) * BITS_PER_UNIT;
13494
13495   /* Anything to move? */
13496   bytes = INTVAL (bytes_rtx);
13497   if (bytes <= 0)
13498     return 1;
13499
13500   if (bytes > rs6000_block_move_inline_limit)
13501     return 0;
13502
13503   for (offset = 0; bytes > 0; offset += move_bytes, bytes -= move_bytes)
13504     {
13505       union {
13506         rtx (*movmemsi) (rtx, rtx, rtx, rtx);
13507         rtx (*mov) (rtx, rtx);
13508       } gen_func;
13509       enum machine_mode mode = BLKmode;
13510       rtx src, dest;
13511
13512       /* Altivec first, since it will be faster than a string move
13513          when it applies, and usually not significantly larger.  */
13514       if (TARGET_ALTIVEC && bytes >= 16 && align >= 128)
13515         {
13516           move_bytes = 16;
13517           mode = V4SImode;
13518           gen_func.mov = gen_movv4si;
13519         }
13520       else if (TARGET_SPE && bytes >= 8 && align >= 64)
13521         {
13522           move_bytes = 8;
13523           mode = V2SImode;
13524           gen_func.mov = gen_movv2si;
13525         }
13526       else if (TARGET_STRING
13527           && bytes > 24         /* move up to 32 bytes at a time */
13528           && ! fixed_regs[5]
13529           && ! fixed_regs[6]
13530           && ! fixed_regs[7]
13531           && ! fixed_regs[8]
13532           && ! fixed_regs[9]
13533           && ! fixed_regs[10]
13534           && ! fixed_regs[11]
13535           && ! fixed_regs[12])
13536         {
13537           move_bytes = (bytes > 32) ? 32 : bytes;
13538           gen_func.movmemsi = gen_movmemsi_8reg;
13539         }
13540       else if (TARGET_STRING
13541                && bytes > 16    /* move up to 24 bytes at a time */
13542                && ! fixed_regs[5]
13543                && ! fixed_regs[6]
13544                && ! fixed_regs[7]
13545                && ! fixed_regs[8]
13546                && ! fixed_regs[9]
13547                && ! fixed_regs[10])
13548         {
13549           move_bytes = (bytes > 24) ? 24 : bytes;
13550           gen_func.movmemsi = gen_movmemsi_6reg;
13551         }
13552       else if (TARGET_STRING
13553                && bytes > 8     /* move up to 16 bytes at a time */
13554                && ! fixed_regs[5]
13555                && ! fixed_regs[6]
13556                && ! fixed_regs[7]
13557                && ! fixed_regs[8])
13558         {
13559           move_bytes = (bytes > 16) ? 16 : bytes;
13560           gen_func.movmemsi = gen_movmemsi_4reg;
13561         }
13562       else if (bytes >= 8 && TARGET_POWERPC64
13563                /* 64-bit loads and stores require word-aligned
13564                   displacements.  */
13565                && (align >= 64 || (!STRICT_ALIGNMENT && align >= 32)))
13566         {
13567           move_bytes = 8;
13568           mode = DImode;
13569           gen_func.mov = gen_movdi;
13570         }
13571       else if (TARGET_STRING && bytes > 4 && !TARGET_POWERPC64)
13572         {                       /* move up to 8 bytes at a time */
13573           move_bytes = (bytes > 8) ? 8 : bytes;
13574           gen_func.movmemsi = gen_movmemsi_2reg;
13575         }
13576       else if (bytes >= 4 && (align >= 32 || !STRICT_ALIGNMENT))
13577         {                       /* move 4 bytes */
13578           move_bytes = 4;
13579           mode = SImode;
13580           gen_func.mov = gen_movsi;
13581         }
13582       else if (bytes >= 2 && (align >= 16 || !STRICT_ALIGNMENT))
13583         {                       /* move 2 bytes */
13584           move_bytes = 2;
13585           mode = HImode;
13586           gen_func.mov = gen_movhi;
13587         }
13588       else if (TARGET_STRING && bytes > 1)
13589         {                       /* move up to 4 bytes at a time */
13590           move_bytes = (bytes > 4) ? 4 : bytes;
13591           gen_func.movmemsi = gen_movmemsi_1reg;
13592         }
13593       else /* move 1 byte at a time */
13594         {
13595           move_bytes = 1;
13596           mode = QImode;
13597           gen_func.mov = gen_movqi;
13598         }
13599
13600       src = adjust_address (orig_src, mode, offset);
13601       dest = adjust_address (orig_dest, mode, offset);
13602
13603       if (mode != BLKmode)
13604         {
13605           rtx tmp_reg = gen_reg_rtx (mode);
13606
13607           emit_insn ((*gen_func.mov) (tmp_reg, src));
13608           stores[num_reg++] = (*gen_func.mov) (dest, tmp_reg);
13609         }
13610
13611       if (mode == BLKmode || num_reg >= MAX_MOVE_REG || bytes == move_bytes)
13612         {
13613           int i;
13614           for (i = 0; i < num_reg; i++)
13615             emit_insn (stores[i]);
13616           num_reg = 0;
13617         }
13618
13619       if (mode == BLKmode)
13620         {
13621           /* Move the address into scratch registers.  The movmemsi
13622              patterns require zero offset.  */
13623           if (!REG_P (XEXP (src, 0)))
13624             {
13625               rtx src_reg = copy_addr_to_reg (XEXP (src, 0));
13626               src = replace_equiv_address (src, src_reg);
13627             }
13628           set_mem_size (src, move_bytes);
13629
13630           if (!REG_P (XEXP (dest, 0)))
13631             {
13632               rtx dest_reg = copy_addr_to_reg (XEXP (dest, 0));
13633               dest = replace_equiv_address (dest, dest_reg);
13634             }
13635           set_mem_size (dest, move_bytes);
13636
13637           emit_insn ((*gen_func.movmemsi) (dest, src,
13638                                            GEN_INT (move_bytes & 31),
13639                                            align_rtx));
13640         }
13641     }
13642
13643   return 1;
13644 }
13645
13646 \f
13647 /* Return a string to perform a load_multiple operation.
13648    operands[0] is the vector.
13649    operands[1] is the source address.
13650    operands[2] is the first destination register.  */
13651
13652 const char *
13653 rs6000_output_load_multiple (rtx operands[3])
13654 {
13655   /* We have to handle the case where the pseudo used to contain the address
13656      is assigned to one of the output registers.  */
13657   int i, j;
13658   int words = XVECLEN (operands[0], 0);
13659   rtx xop[10];
13660
13661   if (XVECLEN (operands[0], 0) == 1)
13662     return "{l|lwz} %2,0(%1)";
13663
13664   for (i = 0; i < words; i++)
13665     if (refers_to_regno_p (REGNO (operands[2]) + i,
13666                            REGNO (operands[2]) + i + 1, operands[1], 0))
13667       {
13668         if (i == words-1)
13669           {
13670             xop[0] = GEN_INT (4 * (words-1));
13671             xop[1] = operands[1];
13672             xop[2] = operands[2];
13673             output_asm_insn ("{lsi|lswi} %2,%1,%0\n\t{l|lwz} %1,%0(%1)", xop);
13674             return "";
13675           }
13676         else if (i == 0)
13677           {
13678             xop[0] = GEN_INT (4 * (words-1));
13679             xop[1] = operands[1];
13680             xop[2] = gen_rtx_REG (SImode, REGNO (operands[2]) + 1);
13681             output_asm_insn ("{cal %1,4(%1)|addi %1,%1,4}\n\t{lsi|lswi} %2,%1,%0\n\t{l|lwz} %1,-4(%1)", xop);
13682             return "";
13683           }
13684         else
13685           {
13686             for (j = 0; j < words; j++)
13687               if (j != i)
13688                 {
13689                   xop[0] = GEN_INT (j * 4);
13690                   xop[1] = operands[1];
13691                   xop[2] = gen_rtx_REG (SImode, REGNO (operands[2]) + j);
13692                   output_asm_insn ("{l|lwz} %2,%0(%1)", xop);
13693                 }
13694             xop[0] = GEN_INT (i * 4);
13695             xop[1] = operands[1];
13696             output_asm_insn ("{l|lwz} %1,%0(%1)", xop);
13697             return "";
13698           }
13699       }
13700
13701   return "{lsi|lswi} %2,%1,%N0";
13702 }
13703
13704 \f
13705 /* A validation routine: say whether CODE, a condition code, and MODE
13706    match.  The other alternatives either don't make sense or should
13707    never be generated.  */
13708
13709 void
13710 validate_condition_mode (enum rtx_code code, enum machine_mode mode)
13711 {
13712   gcc_assert ((GET_RTX_CLASS (code) == RTX_COMPARE
13713                || GET_RTX_CLASS (code) == RTX_COMM_COMPARE)
13714               && GET_MODE_CLASS (mode) == MODE_CC);
13715
13716   /* These don't make sense.  */
13717   gcc_assert ((code != GT && code != LT && code != GE && code != LE)
13718               || mode != CCUNSmode);
13719
13720   gcc_assert ((code != GTU && code != LTU && code != GEU && code != LEU)
13721               || mode == CCUNSmode);
13722
13723   gcc_assert (mode == CCFPmode
13724               || (code != ORDERED && code != UNORDERED
13725                   && code != UNEQ && code != LTGT
13726                   && code != UNGT && code != UNLT
13727                   && code != UNGE && code != UNLE));
13728
13729   /* These should never be generated except for
13730      flag_finite_math_only.  */
13731   gcc_assert (mode != CCFPmode
13732               || flag_finite_math_only
13733               || (code != LE && code != GE
13734                   && code != UNEQ && code != LTGT
13735                   && code != UNGT && code != UNLT));
13736
13737   /* These are invalid; the information is not there.  */
13738   gcc_assert (mode != CCEQmode || code == EQ || code == NE);
13739 }
13740
13741 \f
13742 /* Return 1 if ANDOP is a mask that has no bits on that are not in the
13743    mask required to convert the result of a rotate insn into a shift
13744    left insn of SHIFTOP bits.  Both are known to be SImode CONST_INT.  */
13745
13746 int
13747 includes_lshift_p (rtx shiftop, rtx andop)
13748 {
13749   unsigned HOST_WIDE_INT shift_mask = ~(unsigned HOST_WIDE_INT) 0;
13750
13751   shift_mask <<= INTVAL (shiftop);
13752
13753   return (INTVAL (andop) & 0xffffffff & ~shift_mask) == 0;
13754 }
13755
13756 /* Similar, but for right shift.  */
13757
13758 int
13759 includes_rshift_p (rtx shiftop, rtx andop)
13760 {
13761   unsigned HOST_WIDE_INT shift_mask = ~(unsigned HOST_WIDE_INT) 0;
13762
13763   shift_mask >>= INTVAL (shiftop);
13764
13765   return (INTVAL (andop) & 0xffffffff & ~shift_mask) == 0;
13766 }
13767
13768 /* Return 1 if ANDOP is a mask suitable for use with an rldic insn
13769    to perform a left shift.  It must have exactly SHIFTOP least
13770    significant 0's, then one or more 1's, then zero or more 0's.  */
13771
13772 int
13773 includes_rldic_lshift_p (rtx shiftop, rtx andop)
13774 {
13775   if (GET_CODE (andop) == CONST_INT)
13776     {
13777       HOST_WIDE_INT c, lsb, shift_mask;
13778
13779       c = INTVAL (andop);
13780       if (c == 0 || c == ~0)
13781         return 0;
13782
13783       shift_mask = ~0;
13784       shift_mask <<= INTVAL (shiftop);
13785
13786       /* Find the least significant one bit.  */
13787       lsb = c & -c;
13788
13789       /* It must coincide with the LSB of the shift mask.  */
13790       if (-lsb != shift_mask)
13791         return 0;
13792
13793       /* Invert to look for the next transition (if any).  */
13794       c = ~c;
13795
13796       /* Remove the low group of ones (originally low group of zeros).  */
13797       c &= -lsb;
13798
13799       /* Again find the lsb, and check we have all 1's above.  */
13800       lsb = c & -c;
13801       return c == -lsb;
13802     }
13803   else if (GET_CODE (andop) == CONST_DOUBLE
13804            && (GET_MODE (andop) == VOIDmode || GET_MODE (andop) == DImode))
13805     {
13806       HOST_WIDE_INT low, high, lsb;
13807       HOST_WIDE_INT shift_mask_low, shift_mask_high;
13808
13809       low = CONST_DOUBLE_LOW (andop);
13810       if (HOST_BITS_PER_WIDE_INT < 64)
13811         high = CONST_DOUBLE_HIGH (andop);
13812
13813       if ((low == 0 && (HOST_BITS_PER_WIDE_INT >= 64 || high == 0))
13814           || (low == ~0 && (HOST_BITS_PER_WIDE_INT >= 64 || high == ~0)))
13815         return 0;
13816
13817       if (HOST_BITS_PER_WIDE_INT < 64 && low == 0)
13818         {
13819           shift_mask_high = ~0;
13820           if (INTVAL (shiftop) > 32)
13821             shift_mask_high <<= INTVAL (shiftop) - 32;
13822
13823           lsb = high & -high;
13824
13825           if (-lsb != shift_mask_high || INTVAL (shiftop) < 32)
13826             return 0;
13827
13828           high = ~high;
13829           high &= -lsb;
13830
13831           lsb = high & -high;
13832           return high == -lsb;
13833         }
13834
13835       shift_mask_low = ~0;
13836       shift_mask_low <<= INTVAL (shiftop);
13837
13838       lsb = low & -low;
13839
13840       if (-lsb != shift_mask_low)
13841         return 0;
13842
13843       if (HOST_BITS_PER_WIDE_INT < 64)
13844         high = ~high;
13845       low = ~low;
13846       low &= -lsb;
13847
13848       if (HOST_BITS_PER_WIDE_INT < 64 && low == 0)
13849         {
13850           lsb = high & -high;
13851           return high == -lsb;
13852         }
13853
13854       lsb = low & -low;
13855       return low == -lsb && (HOST_BITS_PER_WIDE_INT >= 64 || high == ~0);
13856     }
13857   else
13858     return 0;
13859 }
13860
13861 /* Return 1 if ANDOP is a mask suitable for use with an rldicr insn
13862    to perform a left shift.  It must have SHIFTOP or more least
13863    significant 0's, with the remainder of the word 1's.  */
13864
13865 int
13866 includes_rldicr_lshift_p (rtx shiftop, rtx andop)
13867 {
13868   if (GET_CODE (andop) == CONST_INT)
13869     {
13870       HOST_WIDE_INT c, lsb, shift_mask;
13871
13872       shift_mask = ~0;
13873       shift_mask <<= INTVAL (shiftop);
13874       c = INTVAL (andop);
13875
13876       /* Find the least significant one bit.  */
13877       lsb = c & -c;
13878
13879       /* It must be covered by the shift mask.
13880          This test also rejects c == 0.  */
13881       if ((lsb & shift_mask) == 0)
13882         return 0;
13883
13884       /* Check we have all 1's above the transition, and reject all 1's.  */
13885       return c == -lsb && lsb != 1;
13886     }
13887   else if (GET_CODE (andop) == CONST_DOUBLE
13888            && (GET_MODE (andop) == VOIDmode || GET_MODE (andop) == DImode))
13889     {
13890       HOST_WIDE_INT low, lsb, shift_mask_low;
13891
13892       low = CONST_DOUBLE_LOW (andop);
13893
13894       if (HOST_BITS_PER_WIDE_INT < 64)
13895         {
13896           HOST_WIDE_INT high, shift_mask_high;
13897
13898           high = CONST_DOUBLE_HIGH (andop);
13899
13900           if (low == 0)
13901             {
13902               shift_mask_high = ~0;
13903               if (INTVAL (shiftop) > 32)
13904                 shift_mask_high <<= INTVAL (shiftop) - 32;
13905
13906               lsb = high & -high;
13907
13908               if ((lsb & shift_mask_high) == 0)
13909                 return 0;
13910
13911               return high == -lsb;
13912             }
13913           if (high != ~0)
13914             return 0;
13915         }
13916
13917       shift_mask_low = ~0;
13918       shift_mask_low <<= INTVAL (shiftop);
13919
13920       lsb = low & -low;
13921
13922       if ((lsb & shift_mask_low) == 0)
13923         return 0;
13924
13925       return low == -lsb && lsb != 1;
13926     }
13927   else
13928     return 0;
13929 }
13930
13931 /* Return 1 if operands will generate a valid arguments to rlwimi
13932 instruction for insert with right shift in 64-bit mode.  The mask may
13933 not start on the first bit or stop on the last bit because wrap-around
13934 effects of instruction do not correspond to semantics of RTL insn.  */
13935
13936 int
13937 insvdi_rshift_rlwimi_p (rtx sizeop, rtx startop, rtx shiftop)
13938 {
13939   if (INTVAL (startop) > 32
13940       && INTVAL (startop) < 64
13941       && INTVAL (sizeop) > 1
13942       && INTVAL (sizeop) + INTVAL (startop) < 64
13943       && INTVAL (shiftop) > 0
13944       && INTVAL (sizeop) + INTVAL (shiftop) < 32
13945       && (64 - (INTVAL (shiftop) & 63)) >= INTVAL (sizeop))
13946     return 1;
13947
13948   return 0;
13949 }
13950
13951 /* Return 1 if REGNO (reg1) == REGNO (reg2) - 1 making them candidates
13952    for lfq and stfq insns iff the registers are hard registers.   */
13953
13954 int
13955 registers_ok_for_quad_peep (rtx reg1, rtx reg2)
13956 {
13957   /* We might have been passed a SUBREG.  */
13958   if (GET_CODE (reg1) != REG || GET_CODE (reg2) != REG)
13959     return 0;
13960
13961   /* We might have been passed non floating point registers.  */
13962   if (!FP_REGNO_P (REGNO (reg1))
13963       || !FP_REGNO_P (REGNO (reg2)))
13964     return 0;
13965
13966   return (REGNO (reg1) == REGNO (reg2) - 1);
13967 }
13968
13969 /* Return 1 if addr1 and addr2 are suitable for lfq or stfq insn.
13970    addr1 and addr2 must be in consecutive memory locations
13971    (addr2 == addr1 + 8).  */
13972
13973 int
13974 mems_ok_for_quad_peep (rtx mem1, rtx mem2)
13975 {
13976   rtx addr1, addr2;
13977   unsigned int reg1, reg2;
13978   int offset1, offset2;
13979
13980   /* The mems cannot be volatile.  */
13981   if (MEM_VOLATILE_P (mem1) || MEM_VOLATILE_P (mem2))
13982     return 0;
13983
13984   addr1 = XEXP (mem1, 0);
13985   addr2 = XEXP (mem2, 0);
13986
13987   /* Extract an offset (if used) from the first addr.  */
13988   if (GET_CODE (addr1) == PLUS)
13989     {
13990       /* If not a REG, return zero.  */
13991       if (GET_CODE (XEXP (addr1, 0)) != REG)
13992         return 0;
13993       else
13994         {
13995           reg1 = REGNO (XEXP (addr1, 0));
13996           /* The offset must be constant!  */
13997           if (GET_CODE (XEXP (addr1, 1)) != CONST_INT)
13998             return 0;
13999           offset1 = INTVAL (XEXP (addr1, 1));
14000         }
14001     }
14002   else if (GET_CODE (addr1) != REG)
14003     return 0;
14004   else
14005     {
14006       reg1 = REGNO (addr1);
14007       /* This was a simple (mem (reg)) expression.  Offset is 0.  */
14008       offset1 = 0;
14009     }
14010
14011   /* And now for the second addr.  */
14012   if (GET_CODE (addr2) == PLUS)
14013     {
14014       /* If not a REG, return zero.  */
14015       if (GET_CODE (XEXP (addr2, 0)) != REG)
14016         return 0;
14017       else
14018         {
14019           reg2 = REGNO (XEXP (addr2, 0));
14020           /* The offset must be constant. */
14021           if (GET_CODE (XEXP (addr2, 1)) != CONST_INT)
14022             return 0;
14023           offset2 = INTVAL (XEXP (addr2, 1));
14024         }
14025     }
14026   else if (GET_CODE (addr2) != REG)
14027     return 0;
14028   else
14029     {
14030       reg2 = REGNO (addr2);
14031       /* This was a simple (mem (reg)) expression.  Offset is 0.  */
14032       offset2 = 0;
14033     }
14034
14035   /* Both of these must have the same base register.  */
14036   if (reg1 != reg2)
14037     return 0;
14038
14039   /* The offset for the second addr must be 8 more than the first addr.  */
14040   if (offset2 != offset1 + 8)
14041     return 0;
14042
14043   /* All the tests passed.  addr1 and addr2 are valid for lfq or stfq
14044      instructions.  */
14045   return 1;
14046 }
14047 \f
14048
14049 rtx
14050 rs6000_secondary_memory_needed_rtx (enum machine_mode mode)
14051 {
14052   static bool eliminated = false;
14053   rtx ret;
14054
14055   if (mode != SDmode)
14056     ret = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
14057   else
14058     {
14059       rtx mem = cfun->machine->sdmode_stack_slot;
14060       gcc_assert (mem != NULL_RTX);
14061
14062       if (!eliminated)
14063         {
14064           mem = eliminate_regs (mem, VOIDmode, NULL_RTX);
14065           cfun->machine->sdmode_stack_slot = mem;
14066           eliminated = true;
14067         }
14068       ret = mem;
14069     }
14070
14071   if (TARGET_DEBUG_ADDR)
14072     {
14073       fprintf (stderr, "\nrs6000_secondary_memory_needed_rtx, mode %s, rtx:\n",
14074                GET_MODE_NAME (mode));
14075       if (!ret)
14076         fprintf (stderr, "\tNULL_RTX\n");
14077       else
14078         debug_rtx (ret);
14079     }
14080
14081   return ret;
14082 }
14083
14084 static tree
14085 rs6000_check_sdmode (tree *tp, int *walk_subtrees, void *data ATTRIBUTE_UNUSED)
14086 {
14087   /* Don't walk into types.  */
14088   if (*tp == NULL_TREE || *tp == error_mark_node || TYPE_P (*tp))
14089     {
14090       *walk_subtrees = 0;
14091       return NULL_TREE;
14092     }
14093
14094   switch (TREE_CODE (*tp))
14095     {
14096     case VAR_DECL:
14097     case PARM_DECL:
14098     case FIELD_DECL:
14099     case RESULT_DECL:
14100     case SSA_NAME:
14101     case REAL_CST:
14102     case MEM_REF:
14103     case VIEW_CONVERT_EXPR:
14104       if (TYPE_MODE (TREE_TYPE (*tp)) == SDmode)
14105         return *tp;
14106       break;
14107     default:
14108       break;
14109     }
14110
14111   return NULL_TREE;
14112 }
14113
14114 enum reload_reg_type {
14115   GPR_REGISTER_TYPE,
14116   VECTOR_REGISTER_TYPE,
14117   OTHER_REGISTER_TYPE
14118 };
14119
14120 static enum reload_reg_type
14121 rs6000_reload_register_type (enum reg_class rclass)
14122 {
14123   switch (rclass)
14124     {
14125     case GENERAL_REGS:
14126     case BASE_REGS:
14127       return GPR_REGISTER_TYPE;
14128
14129     case FLOAT_REGS:
14130     case ALTIVEC_REGS:
14131     case VSX_REGS:
14132       return VECTOR_REGISTER_TYPE;
14133
14134     default:
14135       return OTHER_REGISTER_TYPE;
14136     }
14137 }
14138
14139 /* Inform reload about cases where moving X with a mode MODE to a register in
14140    RCLASS requires an extra scratch or immediate register.  Return the class
14141    needed for the immediate register.
14142
14143    For VSX and Altivec, we may need a register to convert sp+offset into
14144    reg+sp.
14145
14146    For misaligned 64-bit gpr loads and stores we need a register to
14147    convert an offset address to indirect.  */
14148
14149 static reg_class_t
14150 rs6000_secondary_reload (bool in_p,
14151                          rtx x,
14152                          reg_class_t rclass_i,
14153                          enum machine_mode mode,
14154                          secondary_reload_info *sri)
14155 {
14156   enum reg_class rclass = (enum reg_class) rclass_i;
14157   reg_class_t ret = ALL_REGS;
14158   enum insn_code icode;
14159   bool default_p = false;
14160
14161   sri->icode = CODE_FOR_nothing;
14162
14163   /* Convert vector loads and stores into gprs to use an additional base
14164      register.  */
14165   icode = rs6000_vector_reload[mode][in_p != false];
14166   if (icode != CODE_FOR_nothing)
14167     {
14168       ret = NO_REGS;
14169       sri->icode = CODE_FOR_nothing;
14170       sri->extra_cost = 0;
14171
14172       if (GET_CODE (x) == MEM)
14173         {
14174           rtx addr = XEXP (x, 0);
14175
14176           /* Loads to and stores from gprs can do reg+offset, and wouldn't need
14177              an extra register in that case, but it would need an extra
14178              register if the addressing is reg+reg or (reg+reg)&(-16).  */
14179           if (rclass == GENERAL_REGS || rclass == BASE_REGS)
14180             {
14181               if (!legitimate_indirect_address_p (addr, false)
14182                   && !rs6000_legitimate_offset_address_p (TImode, addr, false))
14183                 {
14184                   sri->icode = icode;
14185                   /* account for splitting the loads, and converting the
14186                      address from reg+reg to reg.  */
14187                   sri->extra_cost = (((TARGET_64BIT) ? 3 : 5)
14188                                      + ((GET_CODE (addr) == AND) ? 1 : 0));
14189                 }
14190             }
14191           /* Loads to and stores from vector registers can only do reg+reg
14192              addressing.  Altivec registers can also do (reg+reg)&(-16).  */
14193           else if (rclass == VSX_REGS || rclass == ALTIVEC_REGS
14194                    || rclass == FLOAT_REGS || rclass == NO_REGS)
14195             {
14196               if (!VECTOR_MEM_ALTIVEC_P (mode)
14197                   && GET_CODE (addr) == AND
14198                   && GET_CODE (XEXP (addr, 1)) == CONST_INT
14199                   && INTVAL (XEXP (addr, 1)) == -16
14200                   && (legitimate_indirect_address_p (XEXP (addr, 0), false)
14201                       || legitimate_indexed_address_p (XEXP (addr, 0), false)))
14202                 {
14203                   sri->icode = icode;
14204                   sri->extra_cost = ((GET_CODE (XEXP (addr, 0)) == PLUS)
14205                                      ? 2 : 1);
14206                 }
14207               else if (!legitimate_indirect_address_p (addr, false)
14208                        && (rclass == NO_REGS
14209                            || !legitimate_indexed_address_p (addr, false)))
14210                 {
14211                   sri->icode = icode;
14212                   sri->extra_cost = 1;
14213                 }
14214               else
14215                 icode = CODE_FOR_nothing;
14216             }
14217           /* Any other loads, including to pseudo registers which haven't been
14218              assigned to a register yet, default to require a scratch
14219              register.  */
14220           else
14221             {
14222               sri->icode = icode;
14223               sri->extra_cost = 2;
14224             }
14225         }
14226       else if (REG_P (x))
14227         {
14228           int regno = true_regnum (x);
14229
14230           icode = CODE_FOR_nothing;
14231           if (regno < 0 || regno >= FIRST_PSEUDO_REGISTER)
14232             default_p = true;
14233           else
14234             {
14235               enum reg_class xclass = REGNO_REG_CLASS (regno);
14236               enum reload_reg_type rtype1 = rs6000_reload_register_type (rclass);
14237               enum reload_reg_type rtype2 = rs6000_reload_register_type (xclass);
14238
14239               /* If memory is needed, use default_secondary_reload to create the
14240                  stack slot.  */
14241               if (rtype1 != rtype2 || rtype1 == OTHER_REGISTER_TYPE)
14242                 default_p = true;
14243               else
14244                 ret = NO_REGS;
14245             }
14246         }
14247       else
14248         default_p = true;
14249     }
14250   else if (TARGET_POWERPC64
14251            && rs6000_reload_register_type (rclass) == GPR_REGISTER_TYPE
14252            && MEM_P (x)
14253            && GET_MODE_SIZE (GET_MODE (x)) >= UNITS_PER_WORD)
14254     {
14255       rtx addr = XEXP (x, 0);
14256
14257       if (GET_CODE (addr) == PRE_MODIFY)
14258         addr = XEXP (addr, 1);
14259       else if (GET_CODE (addr) == LO_SUM
14260                && GET_CODE (XEXP (addr, 0)) == REG
14261                && GET_CODE (XEXP (addr, 1)) == CONST)
14262         addr = XEXP (XEXP (addr, 1), 0);
14263
14264       if (GET_CODE (addr) == PLUS
14265           && GET_CODE (XEXP (addr, 1)) == CONST_INT
14266           && (INTVAL (XEXP (addr, 1)) & 3) != 0)
14267         {
14268           if (in_p)
14269             sri->icode = CODE_FOR_reload_di_load;
14270           else
14271             sri->icode = CODE_FOR_reload_di_store;
14272           sri->extra_cost = 2;
14273           ret = NO_REGS;
14274         }
14275       else
14276         default_p = true;
14277     }
14278   else
14279     default_p = true;
14280
14281   if (default_p)
14282     ret = default_secondary_reload (in_p, x, rclass, mode, sri);
14283
14284   gcc_assert (ret != ALL_REGS);
14285
14286   if (TARGET_DEBUG_ADDR)
14287     {
14288       fprintf (stderr,
14289                "\nrs6000_secondary_reload, return %s, in_p = %s, rclass = %s, "
14290                "mode = %s",
14291                reg_class_names[ret],
14292                in_p ? "true" : "false",
14293                reg_class_names[rclass],
14294                GET_MODE_NAME (mode));
14295
14296       if (default_p)
14297         fprintf (stderr, ", default secondary reload");
14298
14299       if (sri->icode != CODE_FOR_nothing)
14300         fprintf (stderr, ", reload func = %s, extra cost = %d\n",
14301                  insn_data[sri->icode].name, sri->extra_cost);
14302       else
14303         fprintf (stderr, "\n");
14304
14305       debug_rtx (x);
14306     }
14307
14308   return ret;
14309 }
14310
14311 /* Fixup reload addresses for Altivec or VSX loads/stores to change SP+offset
14312    to SP+reg addressing.  */
14313
14314 void
14315 rs6000_secondary_reload_inner (rtx reg, rtx mem, rtx scratch, bool store_p)
14316 {
14317   int regno = true_regnum (reg);
14318   enum machine_mode mode = GET_MODE (reg);
14319   enum reg_class rclass;
14320   rtx addr;
14321   rtx and_op2 = NULL_RTX;
14322   rtx addr_op1;
14323   rtx addr_op2;
14324   rtx scratch_or_premodify = scratch;
14325   rtx and_rtx;
14326   rtx cc_clobber;
14327
14328   if (TARGET_DEBUG_ADDR)
14329     {
14330       fprintf (stderr, "\nrs6000_secondary_reload_inner, type = %s\n",
14331                store_p ? "store" : "load");
14332       fprintf (stderr, "reg:\n");
14333       debug_rtx (reg);
14334       fprintf (stderr, "mem:\n");
14335       debug_rtx (mem);
14336       fprintf (stderr, "scratch:\n");
14337       debug_rtx (scratch);
14338     }
14339
14340   gcc_assert (regno >= 0 && regno < FIRST_PSEUDO_REGISTER);
14341   gcc_assert (GET_CODE (mem) == MEM);
14342   rclass = REGNO_REG_CLASS (regno);
14343   addr = XEXP (mem, 0);
14344
14345   switch (rclass)
14346     {
14347       /* GPRs can handle reg + small constant, all other addresses need to use
14348          the scratch register.  */
14349     case GENERAL_REGS:
14350     case BASE_REGS:
14351       if (GET_CODE (addr) == AND)
14352         {
14353           and_op2 = XEXP (addr, 1);
14354           addr = XEXP (addr, 0);
14355         }
14356
14357       if (GET_CODE (addr) == PRE_MODIFY)
14358         {
14359           scratch_or_premodify = XEXP (addr, 0);
14360           gcc_assert (REG_P (scratch_or_premodify));
14361           gcc_assert (GET_CODE (XEXP (addr, 1)) == PLUS);
14362           addr = XEXP (addr, 1);
14363         }
14364
14365       if (GET_CODE (addr) == PLUS
14366           && (!rs6000_legitimate_offset_address_p (TImode, addr, false)
14367               || and_op2 != NULL_RTX))
14368         {
14369           addr_op1 = XEXP (addr, 0);
14370           addr_op2 = XEXP (addr, 1);
14371           gcc_assert (legitimate_indirect_address_p (addr_op1, false));
14372
14373           if (!REG_P (addr_op2)
14374               && (GET_CODE (addr_op2) != CONST_INT
14375                   || !satisfies_constraint_I (addr_op2)))
14376             {
14377               if (TARGET_DEBUG_ADDR)
14378                 {
14379                   fprintf (stderr,
14380                            "\nMove plus addr to register %s, mode = %s: ",
14381                            rs6000_reg_names[REGNO (scratch)],
14382                            GET_MODE_NAME (mode));
14383                   debug_rtx (addr_op2);
14384                 }
14385               rs6000_emit_move (scratch, addr_op2, Pmode);
14386               addr_op2 = scratch;
14387             }
14388
14389           emit_insn (gen_rtx_SET (VOIDmode,
14390                                   scratch_or_premodify,
14391                                   gen_rtx_PLUS (Pmode,
14392                                                 addr_op1,
14393                                                 addr_op2)));
14394
14395           addr = scratch_or_premodify;
14396           scratch_or_premodify = scratch;
14397         }
14398       else if (!legitimate_indirect_address_p (addr, false)
14399                && !rs6000_legitimate_offset_address_p (TImode, addr, false))
14400         {
14401           if (TARGET_DEBUG_ADDR)
14402             {
14403               fprintf (stderr, "\nMove addr to register %s, mode = %s: ",
14404                        rs6000_reg_names[REGNO (scratch_or_premodify)],
14405                        GET_MODE_NAME (mode));
14406               debug_rtx (addr);
14407             }
14408           rs6000_emit_move (scratch_or_premodify, addr, Pmode);
14409           addr = scratch_or_premodify;
14410           scratch_or_premodify = scratch;
14411         }
14412       break;
14413
14414       /* Float/Altivec registers can only handle reg+reg addressing.  Move
14415          other addresses into a scratch register.  */
14416     case FLOAT_REGS:
14417     case VSX_REGS:
14418     case ALTIVEC_REGS:
14419
14420       /* With float regs, we need to handle the AND ourselves, since we can't
14421          use the Altivec instruction with an implicit AND -16.  Allow scalar
14422          loads to float registers to use reg+offset even if VSX.  */
14423       if (GET_CODE (addr) == AND
14424           && (rclass != ALTIVEC_REGS || GET_MODE_SIZE (mode) != 16
14425               || GET_CODE (XEXP (addr, 1)) != CONST_INT
14426               || INTVAL (XEXP (addr, 1)) != -16
14427               || !VECTOR_MEM_ALTIVEC_P (mode)))
14428         {
14429           and_op2 = XEXP (addr, 1);
14430           addr = XEXP (addr, 0);
14431         }
14432
14433       /* If we aren't using a VSX load, save the PRE_MODIFY register and use it
14434          as the address later.  */
14435       if (GET_CODE (addr) == PRE_MODIFY
14436           && (!VECTOR_MEM_VSX_P (mode)
14437               || and_op2 != NULL_RTX
14438               || !legitimate_indexed_address_p (XEXP (addr, 1), false)))
14439         {
14440           scratch_or_premodify = XEXP (addr, 0);
14441           gcc_assert (legitimate_indirect_address_p (scratch_or_premodify,
14442                                                      false));
14443           gcc_assert (GET_CODE (XEXP (addr, 1)) == PLUS);
14444           addr = XEXP (addr, 1);
14445         }
14446
14447       if (legitimate_indirect_address_p (addr, false)   /* reg */
14448           || legitimate_indexed_address_p (addr, false) /* reg+reg */
14449           || GET_CODE (addr) == PRE_MODIFY              /* VSX pre-modify */
14450           || (GET_CODE (addr) == AND                    /* Altivec memory */
14451               && GET_CODE (XEXP (addr, 1)) == CONST_INT
14452               && INTVAL (XEXP (addr, 1)) == -16
14453               && VECTOR_MEM_ALTIVEC_P (mode))
14454           || (rclass == FLOAT_REGS                      /* legacy float mem */
14455               && GET_MODE_SIZE (mode) == 8
14456               && and_op2 == NULL_RTX
14457               && scratch_or_premodify == scratch
14458               && rs6000_legitimate_offset_address_p (mode, addr, false)))
14459         ;
14460
14461       else if (GET_CODE (addr) == PLUS)
14462         {
14463           addr_op1 = XEXP (addr, 0);
14464           addr_op2 = XEXP (addr, 1);
14465           gcc_assert (REG_P (addr_op1));
14466
14467           if (TARGET_DEBUG_ADDR)
14468             {
14469               fprintf (stderr, "\nMove plus addr to register %s, mode = %s: ",
14470                        rs6000_reg_names[REGNO (scratch)], GET_MODE_NAME (mode));
14471               debug_rtx (addr_op2);
14472             }
14473           rs6000_emit_move (scratch, addr_op2, Pmode);
14474           emit_insn (gen_rtx_SET (VOIDmode,
14475                                   scratch_or_premodify,
14476                                   gen_rtx_PLUS (Pmode,
14477                                                 addr_op1,
14478                                                 scratch)));
14479           addr = scratch_or_premodify;
14480           scratch_or_premodify = scratch;
14481         }
14482
14483       else if (GET_CODE (addr) == SYMBOL_REF || GET_CODE (addr) == CONST
14484                || GET_CODE (addr) == CONST_INT || REG_P (addr))
14485         {
14486           if (TARGET_DEBUG_ADDR)
14487             {
14488               fprintf (stderr, "\nMove addr to register %s, mode = %s: ",
14489                        rs6000_reg_names[REGNO (scratch_or_premodify)],
14490                        GET_MODE_NAME (mode));
14491               debug_rtx (addr);
14492             }
14493
14494           rs6000_emit_move (scratch_or_premodify, addr, Pmode);
14495           addr = scratch_or_premodify;
14496           scratch_or_premodify = scratch;
14497         }
14498
14499       else
14500         gcc_unreachable ();
14501
14502       break;
14503
14504     default:
14505       gcc_unreachable ();
14506     }
14507
14508   /* If the original address involved a pre-modify that we couldn't use the VSX
14509      memory instruction with update, and we haven't taken care of already,
14510      store the address in the pre-modify register and use that as the
14511      address.  */
14512   if (scratch_or_premodify != scratch && scratch_or_premodify != addr)
14513     {
14514       emit_insn (gen_rtx_SET (VOIDmode, scratch_or_premodify, addr));
14515       addr = scratch_or_premodify;
14516     }
14517
14518   /* If the original address involved an AND -16 and we couldn't use an ALTIVEC
14519      memory instruction, recreate the AND now, including the clobber which is
14520      generated by the general ANDSI3/ANDDI3 patterns for the
14521      andi. instruction.  */
14522   if (and_op2 != NULL_RTX)
14523     {
14524       if (! legitimate_indirect_address_p (addr, false))
14525         {
14526           emit_insn (gen_rtx_SET (VOIDmode, scratch, addr));
14527           addr = scratch;
14528         }
14529
14530       if (TARGET_DEBUG_ADDR)
14531         {
14532           fprintf (stderr, "\nAnd addr to register %s, mode = %s: ",
14533                    rs6000_reg_names[REGNO (scratch)], GET_MODE_NAME (mode));
14534           debug_rtx (and_op2);
14535         }
14536
14537       and_rtx = gen_rtx_SET (VOIDmode,
14538                              scratch,
14539                              gen_rtx_AND (Pmode,
14540                                           addr,
14541                                           and_op2));
14542
14543       cc_clobber = gen_rtx_CLOBBER (CCmode, gen_rtx_SCRATCH (CCmode));
14544       emit_insn (gen_rtx_PARALLEL (VOIDmode,
14545                                    gen_rtvec (2, and_rtx, cc_clobber)));
14546       addr = scratch;
14547     }
14548
14549   /* Adjust the address if it changed.  */
14550   if (addr != XEXP (mem, 0))
14551     {
14552       mem = change_address (mem, mode, addr);
14553       if (TARGET_DEBUG_ADDR)
14554         fprintf (stderr, "\nrs6000_secondary_reload_inner, mem adjusted.\n");
14555     }
14556
14557   /* Now create the move.  */
14558   if (store_p)
14559     emit_insn (gen_rtx_SET (VOIDmode, mem, reg));
14560   else
14561     emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
14562
14563   return;
14564 }
14565
14566 /* Convert reloads involving 64-bit gprs and misaligned offset
14567    addressing to use indirect addressing.  */
14568
14569 void
14570 rs6000_secondary_reload_ppc64 (rtx reg, rtx mem, rtx scratch, bool store_p)
14571 {
14572   int regno = true_regnum (reg);
14573   enum reg_class rclass;
14574   rtx addr;
14575   rtx scratch_or_premodify = scratch;
14576
14577   if (TARGET_DEBUG_ADDR)
14578     {
14579       fprintf (stderr, "\nrs6000_secondary_reload_ppc64, type = %s\n",
14580                store_p ? "store" : "load");
14581       fprintf (stderr, "reg:\n");
14582       debug_rtx (reg);
14583       fprintf (stderr, "mem:\n");
14584       debug_rtx (mem);
14585       fprintf (stderr, "scratch:\n");
14586       debug_rtx (scratch);
14587     }
14588
14589   gcc_assert (regno >= 0 && regno < FIRST_PSEUDO_REGISTER);
14590   gcc_assert (GET_CODE (mem) == MEM);
14591   rclass = REGNO_REG_CLASS (regno);
14592   gcc_assert (rclass == GENERAL_REGS || rclass == BASE_REGS);
14593   addr = XEXP (mem, 0);
14594
14595   if (GET_CODE (addr) == PRE_MODIFY)
14596     {
14597       scratch_or_premodify = XEXP (addr, 0);
14598       gcc_assert (REG_P (scratch_or_premodify));
14599       addr = XEXP (addr, 1);
14600     }
14601   gcc_assert (GET_CODE (addr) == PLUS || GET_CODE (addr) == LO_SUM);
14602
14603   rs6000_emit_move (scratch_or_premodify, addr, Pmode);
14604
14605   mem = replace_equiv_address_nv (mem, scratch_or_premodify);
14606
14607   /* Now create the move.  */
14608   if (store_p)
14609     emit_insn (gen_rtx_SET (VOIDmode, mem, reg));
14610   else
14611     emit_insn (gen_rtx_SET (VOIDmode, reg, mem));
14612
14613   return;
14614 }
14615
14616 /* Allocate a 64-bit stack slot to be used for copying SDmode
14617    values through if this function has any SDmode references.  */
14618
14619 static void
14620 rs6000_alloc_sdmode_stack_slot (void)
14621 {
14622   tree t;
14623   basic_block bb;
14624   gimple_stmt_iterator gsi;
14625
14626   gcc_assert (cfun->machine->sdmode_stack_slot == NULL_RTX);
14627
14628   FOR_EACH_BB (bb)
14629     for (gsi = gsi_start_bb (bb); !gsi_end_p (gsi); gsi_next (&gsi))
14630       {
14631         tree ret = walk_gimple_op (gsi_stmt (gsi), rs6000_check_sdmode, NULL);
14632         if (ret)
14633           {
14634             rtx stack = assign_stack_local (DDmode, GET_MODE_SIZE (DDmode), 0);
14635             cfun->machine->sdmode_stack_slot = adjust_address_nv (stack,
14636                                                                   SDmode, 0);
14637             return;
14638           }
14639       }
14640
14641   /* Check for any SDmode parameters of the function.  */
14642   for (t = DECL_ARGUMENTS (cfun->decl); t; t = DECL_CHAIN (t))
14643     {
14644       if (TREE_TYPE (t) == error_mark_node)
14645         continue;
14646
14647       if (TYPE_MODE (TREE_TYPE (t)) == SDmode
14648           || TYPE_MODE (DECL_ARG_TYPE (t)) == SDmode)
14649         {
14650           rtx stack = assign_stack_local (DDmode, GET_MODE_SIZE (DDmode), 0);
14651           cfun->machine->sdmode_stack_slot = adjust_address_nv (stack,
14652                                                                 SDmode, 0);
14653           return;
14654         }
14655     }
14656 }
14657
14658 static void
14659 rs6000_instantiate_decls (void)
14660 {
14661   if (cfun->machine->sdmode_stack_slot != NULL_RTX)
14662     instantiate_decl_rtl (cfun->machine->sdmode_stack_slot);
14663 }
14664
14665 /* Given an rtx X being reloaded into a reg required to be
14666    in class CLASS, return the class of reg to actually use.
14667    In general this is just CLASS; but on some machines
14668    in some cases it is preferable to use a more restrictive class.
14669
14670    On the RS/6000, we have to return NO_REGS when we want to reload a
14671    floating-point CONST_DOUBLE to force it to be copied to memory.
14672
14673    We also don't want to reload integer values into floating-point
14674    registers if we can at all help it.  In fact, this can
14675    cause reload to die, if it tries to generate a reload of CTR
14676    into a FP register and discovers it doesn't have the memory location
14677    required.
14678
14679    ??? Would it be a good idea to have reload do the converse, that is
14680    try to reload floating modes into FP registers if possible?
14681  */
14682
14683 static enum reg_class
14684 rs6000_preferred_reload_class (rtx x, enum reg_class rclass)
14685 {
14686   enum machine_mode mode = GET_MODE (x);
14687
14688   if (VECTOR_UNIT_VSX_P (mode)
14689       && x == CONST0_RTX (mode) && VSX_REG_CLASS_P (rclass))
14690     return rclass;
14691
14692   if (VECTOR_UNIT_ALTIVEC_OR_VSX_P (mode)
14693       && (rclass == ALTIVEC_REGS || rclass == VSX_REGS)
14694       && easy_vector_constant (x, mode))
14695     return ALTIVEC_REGS;
14696
14697   if (CONSTANT_P (x) && reg_classes_intersect_p (rclass, FLOAT_REGS))
14698     return NO_REGS;
14699
14700   if (GET_MODE_CLASS (mode) == MODE_INT && rclass == NON_SPECIAL_REGS)
14701     return GENERAL_REGS;
14702
14703   /* For VSX, prefer the traditional registers for 64-bit values because we can
14704      use the non-VSX loads.  Prefer the Altivec registers if Altivec is
14705      handling the vector operations (i.e. V16QI, V8HI, and V4SI), or if we
14706      prefer Altivec loads..  */
14707   if (rclass == VSX_REGS)
14708     {
14709       if (GET_MODE_SIZE (mode) <= 8)
14710         return FLOAT_REGS;
14711
14712       if (VECTOR_UNIT_ALTIVEC_P (mode) || VECTOR_MEM_ALTIVEC_P (mode))
14713         return ALTIVEC_REGS;
14714
14715       return rclass;
14716     }
14717
14718   return rclass;
14719 }
14720
14721 /* Debug version of rs6000_preferred_reload_class.  */
14722 static enum reg_class
14723 rs6000_debug_preferred_reload_class (rtx x, enum reg_class rclass)
14724 {
14725   enum reg_class ret = rs6000_preferred_reload_class (x, rclass);
14726
14727   fprintf (stderr,
14728            "\nrs6000_preferred_reload_class, return %s, rclass = %s, "
14729            "mode = %s, x:\n",
14730            reg_class_names[ret], reg_class_names[rclass],
14731            GET_MODE_NAME (GET_MODE (x)));
14732   debug_rtx (x);
14733
14734   return ret;
14735 }
14736
14737 /* If we are copying between FP or AltiVec registers and anything else, we need
14738    a memory location.  The exception is when we are targeting ppc64 and the
14739    move to/from fpr to gpr instructions are available.  Also, under VSX, you
14740    can copy vector registers from the FP register set to the Altivec register
14741    set and vice versa.  */
14742
14743 static bool
14744 rs6000_secondary_memory_needed (enum reg_class class1,
14745                                 enum reg_class class2,
14746                                 enum machine_mode mode)
14747 {
14748   if (class1 == class2)
14749     return false;
14750
14751   /* Under VSX, there are 3 register classes that values could be in (VSX_REGS,
14752      ALTIVEC_REGS, and FLOAT_REGS).  We don't need to use memory to copy
14753      between these classes.  But we need memory for other things that can go in
14754      FLOAT_REGS like SFmode.  */
14755   if (TARGET_VSX
14756       && (VECTOR_MEM_VSX_P (mode) || VECTOR_UNIT_VSX_P (mode))
14757       && (class1 == VSX_REGS || class1 == ALTIVEC_REGS
14758           || class1 == FLOAT_REGS))
14759     return (class2 != VSX_REGS && class2 != ALTIVEC_REGS
14760             && class2 != FLOAT_REGS);
14761
14762   if (class1 == VSX_REGS || class2 == VSX_REGS)
14763     return true;
14764
14765   if (class1 == FLOAT_REGS
14766       && (!TARGET_MFPGPR || !TARGET_POWERPC64
14767           || ((mode != DFmode)
14768               && (mode != DDmode)
14769               && (mode != DImode))))
14770     return true;
14771
14772   if (class2 == FLOAT_REGS
14773       && (!TARGET_MFPGPR || !TARGET_POWERPC64
14774           || ((mode != DFmode)
14775               && (mode != DDmode)
14776               && (mode != DImode))))
14777     return true;
14778
14779   if (class1 == ALTIVEC_REGS || class2 == ALTIVEC_REGS)
14780     return true;
14781
14782   return false;
14783 }
14784
14785 /* Debug version of rs6000_secondary_memory_needed.  */
14786 static bool
14787 rs6000_debug_secondary_memory_needed (enum reg_class class1,
14788                                       enum reg_class class2,
14789                                       enum machine_mode mode)
14790 {
14791   bool ret = rs6000_secondary_memory_needed (class1, class2, mode);
14792
14793   fprintf (stderr,
14794            "rs6000_secondary_memory_needed, return: %s, class1 = %s, "
14795            "class2 = %s, mode = %s\n",
14796            ret ? "true" : "false", reg_class_names[class1],
14797            reg_class_names[class2], GET_MODE_NAME (mode));
14798
14799   return ret;
14800 }
14801
14802 /* Return the register class of a scratch register needed to copy IN into
14803    or out of a register in RCLASS in MODE.  If it can be done directly,
14804    NO_REGS is returned.  */
14805
14806 static enum reg_class
14807 rs6000_secondary_reload_class (enum reg_class rclass, enum machine_mode mode,
14808                                rtx in)
14809 {
14810   int regno;
14811
14812   if (TARGET_ELF || (DEFAULT_ABI == ABI_DARWIN
14813 #if TARGET_MACHO
14814                      && MACHOPIC_INDIRECT
14815 #endif
14816                      ))
14817     {
14818       /* We cannot copy a symbolic operand directly into anything
14819          other than BASE_REGS for TARGET_ELF.  So indicate that a
14820          register from BASE_REGS is needed as an intermediate
14821          register.
14822
14823          On Darwin, pic addresses require a load from memory, which
14824          needs a base register.  */
14825       if (rclass != BASE_REGS
14826           && (GET_CODE (in) == SYMBOL_REF
14827               || GET_CODE (in) == HIGH
14828               || GET_CODE (in) == LABEL_REF
14829               || GET_CODE (in) == CONST))
14830         return BASE_REGS;
14831     }
14832
14833   if (GET_CODE (in) == REG)
14834     {
14835       regno = REGNO (in);
14836       if (regno >= FIRST_PSEUDO_REGISTER)
14837         {
14838           regno = true_regnum (in);
14839           if (regno >= FIRST_PSEUDO_REGISTER)
14840             regno = -1;
14841         }
14842     }
14843   else if (GET_CODE (in) == SUBREG)
14844     {
14845       regno = true_regnum (in);
14846       if (regno >= FIRST_PSEUDO_REGISTER)
14847         regno = -1;
14848     }
14849   else
14850     regno = -1;
14851
14852   /* We can place anything into GENERAL_REGS and can put GENERAL_REGS
14853      into anything.  */
14854   if (rclass == GENERAL_REGS || rclass == BASE_REGS
14855       || (regno >= 0 && INT_REGNO_P (regno)))
14856     return NO_REGS;
14857
14858   /* Constants, memory, and FP registers can go into FP registers.  */
14859   if ((regno == -1 || FP_REGNO_P (regno))
14860       && (rclass == FLOAT_REGS || rclass == NON_SPECIAL_REGS))
14861     return (mode != SDmode) ? NO_REGS : GENERAL_REGS;
14862
14863   /* Memory, and FP/altivec registers can go into fp/altivec registers under
14864      VSX.  */
14865   if (TARGET_VSX
14866       && (regno == -1 || VSX_REGNO_P (regno))
14867       && VSX_REG_CLASS_P (rclass))
14868     return NO_REGS;
14869
14870   /* Memory, and AltiVec registers can go into AltiVec registers.  */
14871   if ((regno == -1 || ALTIVEC_REGNO_P (regno))
14872       && rclass == ALTIVEC_REGS)
14873     return NO_REGS;
14874
14875   /* We can copy among the CR registers.  */
14876   if ((rclass == CR_REGS || rclass == CR0_REGS)
14877       && regno >= 0 && CR_REGNO_P (regno))
14878     return NO_REGS;
14879
14880   /* Otherwise, we need GENERAL_REGS.  */
14881   return GENERAL_REGS;
14882 }
14883
14884 /* Debug version of rs6000_secondary_reload_class.  */
14885 static enum reg_class
14886 rs6000_debug_secondary_reload_class (enum reg_class rclass,
14887                                      enum machine_mode mode, rtx in)
14888 {
14889   enum reg_class ret = rs6000_secondary_reload_class (rclass, mode, in);
14890   fprintf (stderr,
14891            "\nrs6000_secondary_reload_class, return %s, rclass = %s, "
14892            "mode = %s, input rtx:\n",
14893            reg_class_names[ret], reg_class_names[rclass],
14894            GET_MODE_NAME (mode));
14895   debug_rtx (in);
14896
14897   return ret;
14898 }
14899
14900 /* Return nonzero if for CLASS a mode change from FROM to TO is invalid.  */
14901
14902 static bool
14903 rs6000_cannot_change_mode_class (enum machine_mode from,
14904                                  enum machine_mode to,
14905                                  enum reg_class rclass)
14906 {
14907   unsigned from_size = GET_MODE_SIZE (from);
14908   unsigned to_size = GET_MODE_SIZE (to);
14909
14910   if (from_size != to_size)
14911     {
14912       enum reg_class xclass = (TARGET_VSX) ? VSX_REGS : FLOAT_REGS;
14913       return ((from_size < 8 || to_size < 8 || TARGET_IEEEQUAD)
14914               && reg_classes_intersect_p (xclass, rclass));
14915     }
14916
14917   if (TARGET_E500_DOUBLE
14918       && ((((to) == DFmode) + ((from) == DFmode)) == 1
14919           || (((to) == TFmode) + ((from) == TFmode)) == 1
14920           || (((to) == DDmode) + ((from) == DDmode)) == 1
14921           || (((to) == TDmode) + ((from) == TDmode)) == 1
14922           || (((to) == DImode) + ((from) == DImode)) == 1))
14923     return true;
14924
14925   /* Since the VSX register set includes traditional floating point registers
14926      and altivec registers, just check for the size being different instead of
14927      trying to check whether the modes are vector modes.  Otherwise it won't
14928      allow say DF and DI to change classes.  */
14929   if (TARGET_VSX && VSX_REG_CLASS_P (rclass))
14930     return (from_size != 8 && from_size != 16);
14931
14932   if (TARGET_ALTIVEC && rclass == ALTIVEC_REGS
14933       && (ALTIVEC_VECTOR_MODE (from) + ALTIVEC_VECTOR_MODE (to)) == 1)
14934     return true;
14935
14936   if (TARGET_SPE && (SPE_VECTOR_MODE (from) + SPE_VECTOR_MODE (to)) == 1
14937       && reg_classes_intersect_p (GENERAL_REGS, rclass))
14938     return true;
14939
14940   return false;
14941 }
14942
14943 /* Debug version of rs6000_cannot_change_mode_class.  */
14944 static bool
14945 rs6000_debug_cannot_change_mode_class (enum machine_mode from,
14946                                        enum machine_mode to,
14947                                        enum reg_class rclass)
14948 {
14949   bool ret = rs6000_cannot_change_mode_class (from, to, rclass);
14950
14951   fprintf (stderr,
14952            "rs6000_cannot_change_mode_class, return %s, from = %s, "
14953            "to = %s, rclass = %s\n",
14954            ret ? "true" : "false",
14955            GET_MODE_NAME (from), GET_MODE_NAME (to),
14956            reg_class_names[rclass]);
14957
14958   return ret;
14959 }
14960 \f
14961 /* Given a comparison operation, return the bit number in CCR to test.  We
14962    know this is a valid comparison.
14963
14964    SCC_P is 1 if this is for an scc.  That means that %D will have been
14965    used instead of %C, so the bits will be in different places.
14966
14967    Return -1 if OP isn't a valid comparison for some reason.  */
14968
14969 int
14970 ccr_bit (rtx op, int scc_p)
14971 {
14972   enum rtx_code code = GET_CODE (op);
14973   enum machine_mode cc_mode;
14974   int cc_regnum;
14975   int base_bit;
14976   rtx reg;
14977
14978   if (!COMPARISON_P (op))
14979     return -1;
14980
14981   reg = XEXP (op, 0);
14982
14983   gcc_assert (GET_CODE (reg) == REG && CR_REGNO_P (REGNO (reg)));
14984
14985   cc_mode = GET_MODE (reg);
14986   cc_regnum = REGNO (reg);
14987   base_bit = 4 * (cc_regnum - CR0_REGNO);
14988
14989   validate_condition_mode (code, cc_mode);
14990
14991   /* When generating a sCOND operation, only positive conditions are
14992      allowed.  */
14993   gcc_assert (!scc_p
14994               || code == EQ || code == GT || code == LT || code == UNORDERED
14995               || code == GTU || code == LTU);
14996
14997   switch (code)
14998     {
14999     case NE:
15000       return scc_p ? base_bit + 3 : base_bit + 2;
15001     case EQ:
15002       return base_bit + 2;
15003     case GT:  case GTU:  case UNLE:
15004       return base_bit + 1;
15005     case LT:  case LTU:  case UNGE:
15006       return base_bit;
15007     case ORDERED:  case UNORDERED:
15008       return base_bit + 3;
15009
15010     case GE:  case GEU:
15011       /* If scc, we will have done a cror to put the bit in the
15012          unordered position.  So test that bit.  For integer, this is ! LT
15013          unless this is an scc insn.  */
15014       return scc_p ? base_bit + 3 : base_bit;
15015
15016     case LE:  case LEU:
15017       return scc_p ? base_bit + 3 : base_bit + 1;
15018
15019     default:
15020       gcc_unreachable ();
15021     }
15022 }
15023 \f
15024 /* Return the GOT register.  */
15025
15026 rtx
15027 rs6000_got_register (rtx value ATTRIBUTE_UNUSED)
15028 {
15029   /* The second flow pass currently (June 1999) can't update
15030      regs_ever_live without disturbing other parts of the compiler, so
15031      update it here to make the prolog/epilogue code happy.  */
15032   if (!can_create_pseudo_p ()
15033       && !df_regs_ever_live_p (RS6000_PIC_OFFSET_TABLE_REGNUM))
15034     df_set_regs_ever_live (RS6000_PIC_OFFSET_TABLE_REGNUM, true);
15035
15036   crtl->uses_pic_offset_table = 1;
15037
15038   return pic_offset_table_rtx;
15039 }
15040 \f
15041 static rs6000_stack_t stack_info;
15042
15043 /* Function to init struct machine_function.
15044    This will be called, via a pointer variable,
15045    from push_function_context.  */
15046
15047 static struct machine_function *
15048 rs6000_init_machine_status (void)
15049 {
15050   stack_info.reload_completed = 0;
15051   return ggc_alloc_cleared_machine_function ();
15052 }
15053 \f
15054 /* These macros test for integers and extract the low-order bits.  */
15055 #define INT_P(X)  \
15056 ((GET_CODE (X) == CONST_INT || GET_CODE (X) == CONST_DOUBLE)    \
15057  && GET_MODE (X) == VOIDmode)
15058
15059 #define INT_LOWPART(X) \
15060   (GET_CODE (X) == CONST_INT ? INTVAL (X) : CONST_DOUBLE_LOW (X))
15061
15062 int
15063 extract_MB (rtx op)
15064 {
15065   int i;
15066   unsigned long val = INT_LOWPART (op);
15067
15068   /* If the high bit is zero, the value is the first 1 bit we find
15069      from the left.  */
15070   if ((val & 0x80000000) == 0)
15071     {
15072       gcc_assert (val & 0xffffffff);
15073
15074       i = 1;
15075       while (((val <<= 1) & 0x80000000) == 0)
15076         ++i;
15077       return i;
15078     }
15079
15080   /* If the high bit is set and the low bit is not, or the mask is all
15081      1's, the value is zero.  */
15082   if ((val & 1) == 0 || (val & 0xffffffff) == 0xffffffff)
15083     return 0;
15084
15085   /* Otherwise we have a wrap-around mask.  Look for the first 0 bit
15086      from the right.  */
15087   i = 31;
15088   while (((val >>= 1) & 1) != 0)
15089     --i;
15090
15091   return i;
15092 }
15093
15094 int
15095 extract_ME (rtx op)
15096 {
15097   int i;
15098   unsigned long val = INT_LOWPART (op);
15099
15100   /* If the low bit is zero, the value is the first 1 bit we find from
15101      the right.  */
15102   if ((val & 1) == 0)
15103     {
15104       gcc_assert (val & 0xffffffff);
15105
15106       i = 30;
15107       while (((val >>= 1) & 1) == 0)
15108         --i;
15109
15110       return i;
15111     }
15112
15113   /* If the low bit is set and the high bit is not, or the mask is all
15114      1's, the value is 31.  */
15115   if ((val & 0x80000000) == 0 || (val & 0xffffffff) == 0xffffffff)
15116     return 31;
15117
15118   /* Otherwise we have a wrap-around mask.  Look for the first 0 bit
15119      from the left.  */
15120   i = 0;
15121   while (((val <<= 1) & 0x80000000) != 0)
15122     ++i;
15123
15124   return i;
15125 }
15126
15127 /* Locate some local-dynamic symbol still in use by this function
15128    so that we can print its name in some tls_ld pattern.  */
15129
15130 static const char *
15131 rs6000_get_some_local_dynamic_name (void)
15132 {
15133   rtx insn;
15134
15135   if (cfun->machine->some_ld_name)
15136     return cfun->machine->some_ld_name;
15137
15138   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
15139     if (INSN_P (insn)
15140         && for_each_rtx (&PATTERN (insn),
15141                          rs6000_get_some_local_dynamic_name_1, 0))
15142       return cfun->machine->some_ld_name;
15143
15144   gcc_unreachable ();
15145 }
15146
15147 /* Helper function for rs6000_get_some_local_dynamic_name.  */
15148
15149 static int
15150 rs6000_get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
15151 {
15152   rtx x = *px;
15153
15154   if (GET_CODE (x) == SYMBOL_REF)
15155     {
15156       const char *str = XSTR (x, 0);
15157       if (SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
15158         {
15159           cfun->machine->some_ld_name = str;
15160           return 1;
15161         }
15162     }
15163
15164   return 0;
15165 }
15166
15167 /* Write out a function code label.  */
15168
15169 void
15170 rs6000_output_function_entry (FILE *file, const char *fname)
15171 {
15172   if (fname[0] != '.')
15173     {
15174       switch (DEFAULT_ABI)
15175         {
15176         default:
15177           gcc_unreachable ();
15178
15179         case ABI_AIX:
15180           if (DOT_SYMBOLS)
15181             putc ('.', file);
15182           else
15183             ASM_OUTPUT_INTERNAL_LABEL_PREFIX (file, "L.");
15184           break;
15185
15186         case ABI_V4:
15187         case ABI_DARWIN:
15188           break;
15189         }
15190     }
15191
15192   RS6000_OUTPUT_BASENAME (file, fname);
15193 }
15194
15195 /* Print an operand.  Recognize special options, documented below.  */
15196
15197 #if TARGET_ELF
15198 #define SMALL_DATA_RELOC ((rs6000_sdata == SDATA_EABI) ? "sda21" : "sdarel")
15199 #define SMALL_DATA_REG ((rs6000_sdata == SDATA_EABI) ? 0 : 13)
15200 #else
15201 #define SMALL_DATA_RELOC "sda21"
15202 #define SMALL_DATA_REG 0
15203 #endif
15204
15205 void
15206 print_operand (FILE *file, rtx x, int code)
15207 {
15208   int i;
15209   HOST_WIDE_INT val;
15210   unsigned HOST_WIDE_INT uval;
15211
15212   switch (code)
15213     {
15214     case '.':
15215       /* Write out an instruction after the call which may be replaced
15216          with glue code by the loader.  This depends on the AIX version.  */
15217       asm_fprintf (file, RS6000_CALL_GLUE);
15218       return;
15219
15220       /* %a is output_address.  */
15221
15222     case 'A':
15223       /* If X is a constant integer whose low-order 5 bits are zero,
15224          write 'l'.  Otherwise, write 'r'.  This is a kludge to fix a bug
15225          in the AIX assembler where "sri" with a zero shift count
15226          writes a trash instruction.  */
15227       if (GET_CODE (x) == CONST_INT && (INTVAL (x) & 31) == 0)
15228         putc ('l', file);
15229       else
15230         putc ('r', file);
15231       return;
15232
15233     case 'b':
15234       /* If constant, low-order 16 bits of constant, unsigned.
15235          Otherwise, write normally.  */
15236       if (INT_P (x))
15237         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INT_LOWPART (x) & 0xffff);
15238       else
15239         print_operand (file, x, 0);
15240       return;
15241
15242     case 'B':
15243       /* If the low-order bit is zero, write 'r'; otherwise, write 'l'
15244          for 64-bit mask direction.  */
15245       putc (((INT_LOWPART (x) & 1) == 0 ? 'r' : 'l'), file);
15246       return;
15247
15248       /* %c is output_addr_const if a CONSTANT_ADDRESS_P, otherwise
15249          output_operand.  */
15250
15251     case 'c':
15252       /* X is a CR register.  Print the number of the GT bit of the CR.  */
15253       if (GET_CODE (x) != REG || ! CR_REGNO_P (REGNO (x)))
15254         output_operand_lossage ("invalid %%c value");
15255       else
15256         fprintf (file, "%d", 4 * (REGNO (x) - CR0_REGNO) + 1);
15257       return;
15258
15259     case 'D':
15260       /* Like 'J' but get to the GT bit only.  */
15261       gcc_assert (GET_CODE (x) == REG);
15262
15263       /* Bit 1 is GT bit.  */
15264       i = 4 * (REGNO (x) - CR0_REGNO) + 1;
15265
15266       /* Add one for shift count in rlinm for scc.  */
15267       fprintf (file, "%d", i + 1);
15268       return;
15269
15270     case 'E':
15271       /* X is a CR register.  Print the number of the EQ bit of the CR */
15272       if (GET_CODE (x) != REG || ! CR_REGNO_P (REGNO (x)))
15273         output_operand_lossage ("invalid %%E value");
15274       else
15275         fprintf (file, "%d", 4 * (REGNO (x) - CR0_REGNO) + 2);
15276       return;
15277
15278     case 'f':
15279       /* X is a CR register.  Print the shift count needed to move it
15280          to the high-order four bits.  */
15281       if (GET_CODE (x) != REG || ! CR_REGNO_P (REGNO (x)))
15282         output_operand_lossage ("invalid %%f value");
15283       else
15284         fprintf (file, "%d", 4 * (REGNO (x) - CR0_REGNO));
15285       return;
15286
15287     case 'F':
15288       /* Similar, but print the count for the rotate in the opposite
15289          direction.  */
15290       if (GET_CODE (x) != REG || ! CR_REGNO_P (REGNO (x)))
15291         output_operand_lossage ("invalid %%F value");
15292       else
15293         fprintf (file, "%d", 32 - 4 * (REGNO (x) - CR0_REGNO));
15294       return;
15295
15296     case 'G':
15297       /* X is a constant integer.  If it is negative, print "m",
15298          otherwise print "z".  This is to make an aze or ame insn.  */
15299       if (GET_CODE (x) != CONST_INT)
15300         output_operand_lossage ("invalid %%G value");
15301       else if (INTVAL (x) >= 0)
15302         putc ('z', file);
15303       else
15304         putc ('m', file);
15305       return;
15306
15307     case 'h':
15308       /* If constant, output low-order five bits.  Otherwise, write
15309          normally.  */
15310       if (INT_P (x))
15311         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INT_LOWPART (x) & 31);
15312       else
15313         print_operand (file, x, 0);
15314       return;
15315
15316     case 'H':
15317       /* If constant, output low-order six bits.  Otherwise, write
15318          normally.  */
15319       if (INT_P (x))
15320         fprintf (file, HOST_WIDE_INT_PRINT_DEC, INT_LOWPART (x) & 63);
15321       else
15322         print_operand (file, x, 0);
15323       return;
15324
15325     case 'I':
15326       /* Print `i' if this is a constant, else nothing.  */
15327       if (INT_P (x))
15328         putc ('i', file);
15329       return;
15330
15331     case 'j':
15332       /* Write the bit number in CCR for jump.  */
15333       i = ccr_bit (x, 0);
15334       if (i == -1)
15335         output_operand_lossage ("invalid %%j code");
15336       else
15337         fprintf (file, "%d", i);
15338       return;
15339
15340     case 'J':
15341       /* Similar, but add one for shift count in rlinm for scc and pass
15342          scc flag to `ccr_bit'.  */
15343       i = ccr_bit (x, 1);
15344       if (i == -1)
15345         output_operand_lossage ("invalid %%J code");
15346       else
15347         /* If we want bit 31, write a shift count of zero, not 32.  */
15348         fprintf (file, "%d", i == 31 ? 0 : i + 1);
15349       return;
15350
15351     case 'k':
15352       /* X must be a constant.  Write the 1's complement of the
15353          constant.  */
15354       if (! INT_P (x))
15355         output_operand_lossage ("invalid %%k value");
15356       else
15357         fprintf (file, HOST_WIDE_INT_PRINT_DEC, ~ INT_LOWPART (x));
15358       return;
15359
15360     case 'K':
15361       /* X must be a symbolic constant on ELF.  Write an
15362          expression suitable for an 'addi' that adds in the low 16
15363          bits of the MEM.  */
15364       if (GET_CODE (x) == CONST)
15365         {
15366           if (GET_CODE (XEXP (x, 0)) != PLUS
15367               || (GET_CODE (XEXP (XEXP (x, 0), 0)) != SYMBOL_REF
15368                   && GET_CODE (XEXP (XEXP (x, 0), 0)) != LABEL_REF)
15369               || GET_CODE (XEXP (XEXP (x, 0), 1)) != CONST_INT)
15370             output_operand_lossage ("invalid %%K value");
15371         }
15372       print_operand_address (file, x);
15373       fputs ("@l", file);
15374       return;
15375
15376       /* %l is output_asm_label.  */
15377
15378     case 'L':
15379       /* Write second word of DImode or DFmode reference.  Works on register
15380          or non-indexed memory only.  */
15381       if (GET_CODE (x) == REG)
15382         fputs (reg_names[REGNO (x) + 1], file);
15383       else if (GET_CODE (x) == MEM)
15384         {
15385           /* Handle possible auto-increment.  Since it is pre-increment and
15386              we have already done it, we can just use an offset of word.  */
15387           if (GET_CODE (XEXP (x, 0)) == PRE_INC
15388               || GET_CODE (XEXP (x, 0)) == PRE_DEC)
15389             output_address (plus_constant (XEXP (XEXP (x, 0), 0),
15390                                            UNITS_PER_WORD));
15391           else if (GET_CODE (XEXP (x, 0)) == PRE_MODIFY)
15392             output_address (plus_constant (XEXP (XEXP (x, 0), 0),
15393                                            UNITS_PER_WORD));
15394           else
15395             output_address (XEXP (adjust_address_nv (x, SImode,
15396                                                      UNITS_PER_WORD),
15397                                   0));
15398
15399           if (small_data_operand (x, GET_MODE (x)))
15400             fprintf (file, "@%s(%s)", SMALL_DATA_RELOC,
15401                      reg_names[SMALL_DATA_REG]);
15402         }
15403       return;
15404
15405     case 'm':
15406       /* MB value for a mask operand.  */
15407       if (! mask_operand (x, SImode))
15408         output_operand_lossage ("invalid %%m value");
15409
15410       fprintf (file, "%d", extract_MB (x));
15411       return;
15412
15413     case 'M':
15414       /* ME value for a mask operand.  */
15415       if (! mask_operand (x, SImode))
15416         output_operand_lossage ("invalid %%M value");
15417
15418       fprintf (file, "%d", extract_ME (x));
15419       return;
15420
15421       /* %n outputs the negative of its operand.  */
15422
15423     case 'N':
15424       /* Write the number of elements in the vector times 4.  */
15425       if (GET_CODE (x) != PARALLEL)
15426         output_operand_lossage ("invalid %%N value");
15427       else
15428         fprintf (file, "%d", XVECLEN (x, 0) * 4);
15429       return;
15430
15431     case 'O':
15432       /* Similar, but subtract 1 first.  */
15433       if (GET_CODE (x) != PARALLEL)
15434         output_operand_lossage ("invalid %%O value");
15435       else
15436         fprintf (file, "%d", (XVECLEN (x, 0) - 1) * 4);
15437       return;
15438
15439     case 'p':
15440       /* X is a CONST_INT that is a power of two.  Output the logarithm.  */
15441       if (! INT_P (x)
15442           || INT_LOWPART (x) < 0
15443           || (i = exact_log2 (INT_LOWPART (x))) < 0)
15444         output_operand_lossage ("invalid %%p value");
15445       else
15446         fprintf (file, "%d", i);
15447       return;
15448
15449     case 'P':
15450       /* The operand must be an indirect memory reference.  The result
15451          is the register name.  */
15452       if (GET_CODE (x) != MEM || GET_CODE (XEXP (x, 0)) != REG
15453           || REGNO (XEXP (x, 0)) >= 32)
15454         output_operand_lossage ("invalid %%P value");
15455       else
15456         fputs (reg_names[REGNO (XEXP (x, 0))], file);
15457       return;
15458
15459     case 'q':
15460       /* This outputs the logical code corresponding to a boolean
15461          expression.  The expression may have one or both operands
15462          negated (if one, only the first one).  For condition register
15463          logical operations, it will also treat the negated
15464          CR codes as NOTs, but not handle NOTs of them.  */
15465       {
15466         const char *const *t = 0;
15467         const char *s;
15468         enum rtx_code code = GET_CODE (x);
15469         static const char * const tbl[3][3] = {
15470           { "and", "andc", "nor" },
15471           { "or", "orc", "nand" },
15472           { "xor", "eqv", "xor" } };
15473
15474         if (code == AND)
15475           t = tbl[0];
15476         else if (code == IOR)
15477           t = tbl[1];
15478         else if (code == XOR)
15479           t = tbl[2];
15480         else
15481           output_operand_lossage ("invalid %%q value");
15482
15483         if (GET_CODE (XEXP (x, 0)) != NOT)
15484           s = t[0];
15485         else
15486           {
15487             if (GET_CODE (XEXP (x, 1)) == NOT)
15488               s = t[2];
15489             else
15490               s = t[1];
15491           }
15492
15493         fputs (s, file);
15494       }
15495       return;
15496
15497     case 'Q':
15498       if (TARGET_MFCRF)
15499         fputc (',', file);
15500         /* FALLTHRU */
15501       else
15502         return;
15503
15504     case 'R':
15505       /* X is a CR register.  Print the mask for `mtcrf'.  */
15506       if (GET_CODE (x) != REG || ! CR_REGNO_P (REGNO (x)))
15507         output_operand_lossage ("invalid %%R value");
15508       else
15509         fprintf (file, "%d", 128 >> (REGNO (x) - CR0_REGNO));
15510       return;
15511
15512     case 's':
15513       /* Low 5 bits of 32 - value */
15514       if (! INT_P (x))
15515         output_operand_lossage ("invalid %%s value");
15516       else
15517         fprintf (file, HOST_WIDE_INT_PRINT_DEC, (32 - INT_LOWPART (x)) & 31);
15518       return;
15519
15520     case 'S':
15521       /* PowerPC64 mask position.  All 0's is excluded.
15522          CONST_INT 32-bit mask is considered sign-extended so any
15523          transition must occur within the CONST_INT, not on the boundary.  */
15524       if (! mask64_operand (x, DImode))
15525         output_operand_lossage ("invalid %%S value");
15526
15527       uval = INT_LOWPART (x);
15528
15529       if (uval & 1)     /* Clear Left */
15530         {
15531 #if HOST_BITS_PER_WIDE_INT > 64
15532           uval &= ((unsigned HOST_WIDE_INT) 1 << 64) - 1;
15533 #endif
15534           i = 64;
15535         }
15536       else              /* Clear Right */
15537         {
15538           uval = ~uval;
15539 #if HOST_BITS_PER_WIDE_INT > 64
15540           uval &= ((unsigned HOST_WIDE_INT) 1 << 64) - 1;
15541 #endif
15542           i = 63;
15543         }
15544       while (uval != 0)
15545         --i, uval >>= 1;
15546       gcc_assert (i >= 0);
15547       fprintf (file, "%d", i);
15548       return;
15549
15550     case 't':
15551       /* Like 'J' but get to the OVERFLOW/UNORDERED bit.  */
15552       gcc_assert (GET_CODE (x) == REG && GET_MODE (x) == CCmode);
15553
15554       /* Bit 3 is OV bit.  */
15555       i = 4 * (REGNO (x) - CR0_REGNO) + 3;
15556
15557       /* If we want bit 31, write a shift count of zero, not 32.  */
15558       fprintf (file, "%d", i == 31 ? 0 : i + 1);
15559       return;
15560
15561     case 'T':
15562       /* Print the symbolic name of a branch target register.  */
15563       if (GET_CODE (x) != REG || (REGNO (x) != LR_REGNO
15564                                   && REGNO (x) != CTR_REGNO))
15565         output_operand_lossage ("invalid %%T value");
15566       else if (REGNO (x) == LR_REGNO)
15567         fputs (TARGET_NEW_MNEMONICS ? "lr" : "r", file);
15568       else
15569         fputs ("ctr", file);
15570       return;
15571
15572     case 'u':
15573       /* High-order 16 bits of constant for use in unsigned operand.  */
15574       if (! INT_P (x))
15575         output_operand_lossage ("invalid %%u value");
15576       else
15577         fprintf (file, HOST_WIDE_INT_PRINT_HEX,
15578                  (INT_LOWPART (x) >> 16) & 0xffff);
15579       return;
15580
15581     case 'v':
15582       /* High-order 16 bits of constant for use in signed operand.  */
15583       if (! INT_P (x))
15584         output_operand_lossage ("invalid %%v value");
15585       else
15586         fprintf (file, HOST_WIDE_INT_PRINT_HEX,
15587                  (INT_LOWPART (x) >> 16) & 0xffff);
15588       return;
15589
15590     case 'U':
15591       /* Print `u' if this has an auto-increment or auto-decrement.  */
15592       if (GET_CODE (x) == MEM
15593           && (GET_CODE (XEXP (x, 0)) == PRE_INC
15594               || GET_CODE (XEXP (x, 0)) == PRE_DEC
15595               || GET_CODE (XEXP (x, 0)) == PRE_MODIFY))
15596         putc ('u', file);
15597       return;
15598
15599     case 'V':
15600       /* Print the trap code for this operand.  */
15601       switch (GET_CODE (x))
15602         {
15603         case EQ:
15604           fputs ("eq", file);   /* 4 */
15605           break;
15606         case NE:
15607           fputs ("ne", file);   /* 24 */
15608           break;
15609         case LT:
15610           fputs ("lt", file);   /* 16 */
15611           break;
15612         case LE:
15613           fputs ("le", file);   /* 20 */
15614           break;
15615         case GT:
15616           fputs ("gt", file);   /* 8 */
15617           break;
15618         case GE:
15619           fputs ("ge", file);   /* 12 */
15620           break;
15621         case LTU:
15622           fputs ("llt", file);  /* 2 */
15623           break;
15624         case LEU:
15625           fputs ("lle", file);  /* 6 */
15626           break;
15627         case GTU:
15628           fputs ("lgt", file);  /* 1 */
15629           break;
15630         case GEU:
15631           fputs ("lge", file);  /* 5 */
15632           break;
15633         default:
15634           gcc_unreachable ();
15635         }
15636       break;
15637
15638     case 'w':
15639       /* If constant, low-order 16 bits of constant, signed.  Otherwise, write
15640          normally.  */
15641       if (INT_P (x))
15642         fprintf (file, HOST_WIDE_INT_PRINT_DEC,
15643                  ((INT_LOWPART (x) & 0xffff) ^ 0x8000) - 0x8000);
15644       else
15645         print_operand (file, x, 0);
15646       return;
15647
15648     case 'W':
15649       /* MB value for a PowerPC64 rldic operand.  */
15650       val = (GET_CODE (x) == CONST_INT
15651              ? INTVAL (x) : CONST_DOUBLE_HIGH (x));
15652
15653       if (val < 0)
15654         i = -1;
15655       else
15656         for (i = 0; i < HOST_BITS_PER_WIDE_INT; i++)
15657           if ((val <<= 1) < 0)
15658             break;
15659
15660 #if HOST_BITS_PER_WIDE_INT == 32
15661       if (GET_CODE (x) == CONST_INT && i >= 0)
15662         i += 32;  /* zero-extend high-part was all 0's */
15663       else if (GET_CODE (x) == CONST_DOUBLE && i == 32)
15664         {
15665           val = CONST_DOUBLE_LOW (x);
15666
15667           gcc_assert (val);
15668           if (val < 0)
15669             --i;
15670           else
15671             for ( ; i < 64; i++)
15672               if ((val <<= 1) < 0)
15673                 break;
15674         }
15675 #endif
15676
15677       fprintf (file, "%d", i + 1);
15678       return;
15679
15680     case 'x':
15681       /* X is a FPR or Altivec register used in a VSX context.  */
15682       if (GET_CODE (x) != REG || !VSX_REGNO_P (REGNO (x)))
15683         output_operand_lossage ("invalid %%x value");
15684       else
15685         {
15686           int reg = REGNO (x);
15687           int vsx_reg = (FP_REGNO_P (reg)
15688                          ? reg - 32
15689                          : reg - FIRST_ALTIVEC_REGNO + 32);
15690
15691 #ifdef TARGET_REGNAMES
15692           if (TARGET_REGNAMES)
15693             fprintf (file, "%%vs%d", vsx_reg);
15694           else
15695 #endif
15696             fprintf (file, "%d", vsx_reg);
15697         }
15698       return;
15699
15700     case 'X':
15701       if (GET_CODE (x) == MEM
15702           && (legitimate_indexed_address_p (XEXP (x, 0), 0)
15703               || (GET_CODE (XEXP (x, 0)) == PRE_MODIFY
15704                   && legitimate_indexed_address_p (XEXP (XEXP (x, 0), 1), 0))))
15705         putc ('x', file);
15706       return;
15707
15708     case 'Y':
15709       /* Like 'L', for third word of TImode  */
15710       if (GET_CODE (x) == REG)
15711         fputs (reg_names[REGNO (x) + 2], file);
15712       else if (GET_CODE (x) == MEM)
15713         {
15714           if (GET_CODE (XEXP (x, 0)) == PRE_INC
15715               || GET_CODE (XEXP (x, 0)) == PRE_DEC)
15716             output_address (plus_constant (XEXP (XEXP (x, 0), 0), 8));
15717           else if (GET_CODE (XEXP (x, 0)) == PRE_MODIFY)
15718             output_address (plus_constant (XEXP (XEXP (x, 0), 0), 8));
15719           else
15720             output_address (XEXP (adjust_address_nv (x, SImode, 8), 0));
15721           if (small_data_operand (x, GET_MODE (x)))
15722             fprintf (file, "@%s(%s)", SMALL_DATA_RELOC,
15723                      reg_names[SMALL_DATA_REG]);
15724         }
15725       return;
15726
15727     case 'z':
15728       /* X is a SYMBOL_REF.  Write out the name preceded by a
15729          period and without any trailing data in brackets.  Used for function
15730          names.  If we are configured for System V (or the embedded ABI) on
15731          the PowerPC, do not emit the period, since those systems do not use
15732          TOCs and the like.  */
15733       gcc_assert (GET_CODE (x) == SYMBOL_REF);
15734
15735       /* Mark the decl as referenced so that cgraph will output the
15736          function.  */
15737       if (SYMBOL_REF_DECL (x))
15738         mark_decl_referenced (SYMBOL_REF_DECL (x));
15739
15740       /* For macho, check to see if we need a stub.  */
15741       if (TARGET_MACHO)
15742         {
15743           const char *name = XSTR (x, 0);
15744 #if TARGET_MACHO
15745           if (darwin_emit_branch_islands
15746               && MACHOPIC_INDIRECT
15747               && machopic_classify_symbol (x) == MACHOPIC_UNDEFINED_FUNCTION)
15748             name = machopic_indirection_name (x, /*stub_p=*/true);
15749 #endif
15750           assemble_name (file, name);
15751         }
15752       else if (!DOT_SYMBOLS)
15753         assemble_name (file, XSTR (x, 0));
15754       else
15755         rs6000_output_function_entry (file, XSTR (x, 0));
15756       return;
15757
15758     case 'Z':
15759       /* Like 'L', for last word of TImode.  */
15760       if (GET_CODE (x) == REG)
15761         fputs (reg_names[REGNO (x) + 3], file);
15762       else if (GET_CODE (x) == MEM)
15763         {
15764           if (GET_CODE (XEXP (x, 0)) == PRE_INC
15765               || GET_CODE (XEXP (x, 0)) == PRE_DEC)
15766             output_address (plus_constant (XEXP (XEXP (x, 0), 0), 12));
15767           else if (GET_CODE (XEXP (x, 0)) == PRE_MODIFY)
15768             output_address (plus_constant (XEXP (XEXP (x, 0), 0), 12));
15769           else
15770             output_address (XEXP (adjust_address_nv (x, SImode, 12), 0));
15771           if (small_data_operand (x, GET_MODE (x)))
15772             fprintf (file, "@%s(%s)", SMALL_DATA_RELOC,
15773                      reg_names[SMALL_DATA_REG]);
15774         }
15775       return;
15776
15777       /* Print AltiVec or SPE memory operand.  */
15778     case 'y':
15779       {
15780         rtx tmp;
15781
15782         gcc_assert (GET_CODE (x) == MEM);
15783
15784         tmp = XEXP (x, 0);
15785
15786         /* Ugly hack because %y is overloaded.  */
15787         if ((TARGET_SPE || TARGET_E500_DOUBLE)
15788             && (GET_MODE_SIZE (GET_MODE (x)) == 8
15789                 || GET_MODE (x) == TFmode
15790                 || GET_MODE (x) == TImode))
15791           {
15792             /* Handle [reg].  */
15793             if (GET_CODE (tmp) == REG)
15794               {
15795                 fprintf (file, "0(%s)", reg_names[REGNO (tmp)]);
15796                 break;
15797               }
15798             /* Handle [reg+UIMM].  */
15799             else if (GET_CODE (tmp) == PLUS &&
15800                      GET_CODE (XEXP (tmp, 1)) == CONST_INT)
15801               {
15802                 int x;
15803
15804                 gcc_assert (GET_CODE (XEXP (tmp, 0)) == REG);
15805
15806                 x = INTVAL (XEXP (tmp, 1));
15807                 fprintf (file, "%d(%s)", x, reg_names[REGNO (XEXP (tmp, 0))]);
15808                 break;
15809               }
15810
15811             /* Fall through.  Must be [reg+reg].  */
15812           }
15813         if (VECTOR_MEM_ALTIVEC_P (GET_MODE (x))
15814             && GET_CODE (tmp) == AND
15815             && GET_CODE (XEXP (tmp, 1)) == CONST_INT
15816             && INTVAL (XEXP (tmp, 1)) == -16)
15817           tmp = XEXP (tmp, 0);
15818         else if (VECTOR_MEM_VSX_P (GET_MODE (x))
15819                  && GET_CODE (tmp) == PRE_MODIFY)
15820           tmp = XEXP (tmp, 1);
15821         if (GET_CODE (tmp) == REG)
15822           fprintf (file, "0,%s", reg_names[REGNO (tmp)]);
15823         else
15824           {
15825             if (!GET_CODE (tmp) == PLUS
15826                 || !REG_P (XEXP (tmp, 0))
15827                 || !REG_P (XEXP (tmp, 1)))
15828               {
15829                 output_operand_lossage ("invalid %%y value, try using the 'Z' constraint");
15830                 break;
15831               }
15832
15833             if (REGNO (XEXP (tmp, 0)) == 0)
15834               fprintf (file, "%s,%s", reg_names[ REGNO (XEXP (tmp, 1)) ],
15835                        reg_names[ REGNO (XEXP (tmp, 0)) ]);
15836             else
15837               fprintf (file, "%s,%s", reg_names[ REGNO (XEXP (tmp, 0)) ],
15838                        reg_names[ REGNO (XEXP (tmp, 1)) ]);
15839           }
15840         break;
15841       }
15842
15843     case 0:
15844       if (GET_CODE (x) == REG)
15845         fprintf (file, "%s", reg_names[REGNO (x)]);
15846       else if (GET_CODE (x) == MEM)
15847         {
15848           /* We need to handle PRE_INC and PRE_DEC here, since we need to
15849              know the width from the mode.  */
15850           if (GET_CODE (XEXP (x, 0)) == PRE_INC)
15851             fprintf (file, "%d(%s)", GET_MODE_SIZE (GET_MODE (x)),
15852                      reg_names[REGNO (XEXP (XEXP (x, 0), 0))]);
15853           else if (GET_CODE (XEXP (x, 0)) == PRE_DEC)
15854             fprintf (file, "%d(%s)", - GET_MODE_SIZE (GET_MODE (x)),
15855                      reg_names[REGNO (XEXP (XEXP (x, 0), 0))]);
15856           else if (GET_CODE (XEXP (x, 0)) == PRE_MODIFY)
15857             output_address (XEXP (XEXP (x, 0), 1));
15858           else
15859             output_address (XEXP (x, 0));
15860         }
15861       else
15862         {
15863           if (toc_relative_expr_p (x))
15864             /* This hack along with a corresponding hack in
15865                rs6000_output_addr_const_extra arranges to output addends
15866                where the assembler expects to find them.  eg.
15867                (const (plus (unspec [symbol_ref ("x") tocrel]) 4))
15868                without this hack would be output as "x@toc+4".  We
15869                want "x+4@toc".  */
15870             output_addr_const (file, tocrel_base);
15871           else
15872             output_addr_const (file, x);
15873         }
15874       return;
15875
15876     case '&':
15877       assemble_name (file, rs6000_get_some_local_dynamic_name ());
15878       return;
15879
15880     default:
15881       output_operand_lossage ("invalid %%xn code");
15882     }
15883 }
15884 \f
15885 /* Print the address of an operand.  */
15886
15887 void
15888 print_operand_address (FILE *file, rtx x)
15889 {
15890   if (GET_CODE (x) == REG)
15891     fprintf (file, "0(%s)", reg_names[ REGNO (x) ]);
15892   else if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == CONST
15893            || GET_CODE (x) == LABEL_REF)
15894     {
15895       output_addr_const (file, x);
15896       if (small_data_operand (x, GET_MODE (x)))
15897         fprintf (file, "@%s(%s)", SMALL_DATA_RELOC,
15898                  reg_names[SMALL_DATA_REG]);
15899       else
15900         gcc_assert (!TARGET_TOC);
15901     }
15902   else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == REG)
15903     {
15904       gcc_assert (REG_P (XEXP (x, 0)));
15905       if (REGNO (XEXP (x, 0)) == 0)
15906         fprintf (file, "%s,%s", reg_names[ REGNO (XEXP (x, 1)) ],
15907                  reg_names[ REGNO (XEXP (x, 0)) ]);
15908       else
15909         fprintf (file, "%s,%s", reg_names[ REGNO (XEXP (x, 0)) ],
15910                  reg_names[ REGNO (XEXP (x, 1)) ]);
15911     }
15912   else if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT)
15913     fprintf (file, HOST_WIDE_INT_PRINT_DEC "(%s)",
15914              INTVAL (XEXP (x, 1)), reg_names[ REGNO (XEXP (x, 0)) ]);
15915 #if TARGET_MACHO
15916   else if (GET_CODE (x) == LO_SUM && GET_CODE (XEXP (x, 0)) == REG
15917            && CONSTANT_P (XEXP (x, 1)))
15918     {
15919       fprintf (file, "lo16(");
15920       output_addr_const (file, XEXP (x, 1));
15921       fprintf (file, ")(%s)", reg_names[ REGNO (XEXP (x, 0)) ]);
15922     }
15923 #endif
15924   else if (legitimate_constant_pool_address_p (x, QImode, true))
15925     {
15926       /* This hack along with a corresponding hack in
15927          rs6000_output_addr_const_extra arranges to output addends
15928          where the assembler expects to find them.  eg.
15929          (lo_sum (reg 9)
15930          .       (const (plus (unspec [symbol_ref ("x") tocrel]) 8)))
15931          without this hack would be output as "x@toc+8@l(9)".  We
15932          want "x+8@toc@l(9)".  */
15933       output_addr_const (file, tocrel_base);
15934       if (GET_CODE (x) == LO_SUM)
15935         fprintf (file, "@l(%s)", reg_names[ REGNO (XEXP (x, 0)) ]);
15936       else
15937         fprintf (file, "(%s)", reg_names[REGNO (XEXP (x, 0))]);
15938     }
15939 #if TARGET_ELF
15940   else if (GET_CODE (x) == LO_SUM && GET_CODE (XEXP (x, 0)) == REG
15941            && CONSTANT_P (XEXP (x, 1)))
15942     {
15943       output_addr_const (file, XEXP (x, 1));
15944       fprintf (file, "@l(%s)", reg_names[ REGNO (XEXP (x, 0)) ]);
15945     }
15946 #endif
15947   else
15948     gcc_unreachable ();
15949 }
15950 \f
15951 /* Implement TARGET_OUTPUT_ADDR_CONST_EXTRA.  */
15952
15953 static bool
15954 rs6000_output_addr_const_extra (FILE *file, rtx x)
15955 {
15956   if (GET_CODE (x) == UNSPEC)
15957     switch (XINT (x, 1))
15958       {
15959       case UNSPEC_TOCREL:
15960         gcc_assert (GET_CODE (XVECEXP (x, 0, 0)) == SYMBOL_REF);
15961         output_addr_const (file, XVECEXP (x, 0, 0));
15962         if (x == tocrel_base && tocrel_offset != const0_rtx)
15963           {
15964             if (INTVAL (tocrel_offset) >= 0)
15965               fprintf (file, "+");
15966             output_addr_const (file, tocrel_offset);
15967           }
15968         if (!TARGET_AIX || (TARGET_ELF && TARGET_MINIMAL_TOC))
15969           {
15970             putc ('-', file);
15971             assemble_name (file, toc_label_name);
15972           }
15973         else if (TARGET_ELF)
15974           fputs ("@toc", file);
15975         return true;
15976
15977 #if TARGET_MACHO
15978       case UNSPEC_MACHOPIC_OFFSET:
15979         output_addr_const (file, XVECEXP (x, 0, 0));
15980         putc ('-', file);
15981         machopic_output_function_base_name (file);
15982         return true;
15983 #endif
15984       }
15985   return false;
15986 }
15987 \f
15988 /* Target hook for assembling integer objects.  The PowerPC version has
15989    to handle fixup entries for relocatable code if RELOCATABLE_NEEDS_FIXUP
15990    is defined.  It also needs to handle DI-mode objects on 64-bit
15991    targets.  */
15992
15993 static bool
15994 rs6000_assemble_integer (rtx x, unsigned int size, int aligned_p)
15995 {
15996 #ifdef RELOCATABLE_NEEDS_FIXUP
15997   /* Special handling for SI values.  */
15998   if (RELOCATABLE_NEEDS_FIXUP && size == 4 && aligned_p)
15999     {
16000       static int recurse = 0;
16001
16002       /* For -mrelocatable, we mark all addresses that need to be fixed up
16003          in the .fixup section.  */
16004       if (TARGET_RELOCATABLE
16005           && in_section != toc_section
16006           && in_section != text_section
16007           && !unlikely_text_section_p (in_section)
16008           && !recurse
16009           && GET_CODE (x) != CONST_INT
16010           && GET_CODE (x) != CONST_DOUBLE
16011           && CONSTANT_P (x))
16012         {
16013           char buf[256];
16014
16015           recurse = 1;
16016           ASM_GENERATE_INTERNAL_LABEL (buf, "LCP", fixuplabelno);
16017           fixuplabelno++;
16018           ASM_OUTPUT_LABEL (asm_out_file, buf);
16019           fprintf (asm_out_file, "\t.long\t(");
16020           output_addr_const (asm_out_file, x);
16021           fprintf (asm_out_file, ")@fixup\n");
16022           fprintf (asm_out_file, "\t.section\t\".fixup\",\"aw\"\n");
16023           ASM_OUTPUT_ALIGN (asm_out_file, 2);
16024           fprintf (asm_out_file, "\t.long\t");
16025           assemble_name (asm_out_file, buf);
16026           fprintf (asm_out_file, "\n\t.previous\n");
16027           recurse = 0;
16028           return true;
16029         }
16030       /* Remove initial .'s to turn a -mcall-aixdesc function
16031          address into the address of the descriptor, not the function
16032          itself.  */
16033       else if (GET_CODE (x) == SYMBOL_REF
16034                && XSTR (x, 0)[0] == '.'
16035                && DEFAULT_ABI == ABI_AIX)
16036         {
16037           const char *name = XSTR (x, 0);
16038           while (*name == '.')
16039             name++;
16040
16041           fprintf (asm_out_file, "\t.long\t%s\n", name);
16042           return true;
16043         }
16044     }
16045 #endif /* RELOCATABLE_NEEDS_FIXUP */
16046   return default_assemble_integer (x, size, aligned_p);
16047 }
16048
16049 #if defined (HAVE_GAS_HIDDEN) && !defined (TARGET_MACHO)
16050 /* Emit an assembler directive to set symbol visibility for DECL to
16051    VISIBILITY_TYPE.  */
16052
16053 static void
16054 rs6000_assemble_visibility (tree decl, int vis)
16055 {
16056   /* Functions need to have their entry point symbol visibility set as
16057      well as their descriptor symbol visibility.  */
16058   if (DEFAULT_ABI == ABI_AIX
16059       && DOT_SYMBOLS
16060       && TREE_CODE (decl) == FUNCTION_DECL)
16061     {
16062       static const char * const visibility_types[] = {
16063         NULL, "internal", "hidden", "protected"
16064       };
16065
16066       const char *name, *type;
16067
16068       name = ((* targetm.strip_name_encoding)
16069               (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl))));
16070       type = visibility_types[vis];
16071
16072       fprintf (asm_out_file, "\t.%s\t%s\n", type, name);
16073       fprintf (asm_out_file, "\t.%s\t.%s\n", type, name);
16074     }
16075   else
16076     default_assemble_visibility (decl, vis);
16077 }
16078 #endif
16079 \f
16080 enum rtx_code
16081 rs6000_reverse_condition (enum machine_mode mode, enum rtx_code code)
16082 {
16083   /* Reversal of FP compares takes care -- an ordered compare
16084      becomes an unordered compare and vice versa.  */
16085   if (mode == CCFPmode
16086       && (!flag_finite_math_only
16087           || code == UNLT || code == UNLE || code == UNGT || code == UNGE
16088           || code == UNEQ || code == LTGT))
16089     return reverse_condition_maybe_unordered (code);
16090   else
16091     return reverse_condition (code);
16092 }
16093
16094 /* Generate a compare for CODE.  Return a brand-new rtx that
16095    represents the result of the compare.  */
16096
16097 static rtx
16098 rs6000_generate_compare (rtx cmp, enum machine_mode mode)
16099 {
16100   enum machine_mode comp_mode;
16101   rtx compare_result;
16102   enum rtx_code code = GET_CODE (cmp);
16103   rtx op0 = XEXP (cmp, 0);
16104   rtx op1 = XEXP (cmp, 1);
16105
16106   if (FLOAT_MODE_P (mode))
16107     comp_mode = CCFPmode;
16108   else if (code == GTU || code == LTU
16109            || code == GEU || code == LEU)
16110     comp_mode = CCUNSmode;
16111   else if ((code == EQ || code == NE)
16112            && GET_CODE (op0) == SUBREG
16113            && GET_CODE (op1) == SUBREG
16114            && SUBREG_PROMOTED_UNSIGNED_P (op0)
16115            && SUBREG_PROMOTED_UNSIGNED_P (op1))
16116     /* These are unsigned values, perhaps there will be a later
16117        ordering compare that can be shared with this one.
16118        Unfortunately we cannot detect the signedness of the operands
16119        for non-subregs.  */
16120     comp_mode = CCUNSmode;
16121   else
16122     comp_mode = CCmode;
16123
16124   /* First, the compare.  */
16125   compare_result = gen_reg_rtx (comp_mode);
16126
16127   /* E500 FP compare instructions on the GPRs.  Yuck!  */
16128   if ((!TARGET_FPRS && TARGET_HARD_FLOAT)
16129       && FLOAT_MODE_P (mode))
16130     {
16131       rtx cmp, or_result, compare_result2;
16132       enum machine_mode op_mode = GET_MODE (op0);
16133
16134       if (op_mode == VOIDmode)
16135         op_mode = GET_MODE (op1);
16136
16137       /* The E500 FP compare instructions toggle the GT bit (CR bit 1) only.
16138          This explains the following mess.  */
16139
16140       switch (code)
16141         {
16142         case EQ: case UNEQ: case NE: case LTGT:
16143           switch (op_mode)
16144             {
16145             case SFmode:
16146               cmp = (flag_finite_math_only && !flag_trapping_math)
16147                 ? gen_tstsfeq_gpr (compare_result, op0, op1)
16148                 : gen_cmpsfeq_gpr (compare_result, op0, op1);
16149               break;
16150
16151             case DFmode:
16152               cmp = (flag_finite_math_only && !flag_trapping_math)
16153                 ? gen_tstdfeq_gpr (compare_result, op0, op1)
16154                 : gen_cmpdfeq_gpr (compare_result, op0, op1);
16155               break;
16156
16157             case TFmode:
16158               cmp = (flag_finite_math_only && !flag_trapping_math)
16159                 ? gen_tsttfeq_gpr (compare_result, op0, op1)
16160                 : gen_cmptfeq_gpr (compare_result, op0, op1);
16161               break;
16162
16163             default:
16164               gcc_unreachable ();
16165             }
16166           break;
16167
16168         case GT: case GTU: case UNGT: case UNGE: case GE: case GEU:
16169           switch (op_mode)
16170             {
16171             case SFmode:
16172               cmp = (flag_finite_math_only && !flag_trapping_math)
16173                 ? gen_tstsfgt_gpr (compare_result, op0, op1)
16174                 : gen_cmpsfgt_gpr (compare_result, op0, op1);
16175               break;
16176
16177             case DFmode:
16178               cmp = (flag_finite_math_only && !flag_trapping_math)
16179                 ? gen_tstdfgt_gpr (compare_result, op0, op1)
16180                 : gen_cmpdfgt_gpr (compare_result, op0, op1);
16181               break;
16182
16183             case TFmode:
16184               cmp = (flag_finite_math_only && !flag_trapping_math)
16185                 ? gen_tsttfgt_gpr (compare_result, op0, op1)
16186                 : gen_cmptfgt_gpr (compare_result, op0, op1);
16187               break;
16188
16189             default:
16190               gcc_unreachable ();
16191             }
16192           break;
16193
16194         case LT: case LTU: case UNLT: case UNLE: case LE: case LEU:
16195           switch (op_mode)
16196             {
16197             case SFmode:
16198               cmp = (flag_finite_math_only && !flag_trapping_math)
16199                 ? gen_tstsflt_gpr (compare_result, op0, op1)
16200                 : gen_cmpsflt_gpr (compare_result, op0, op1);
16201               break;
16202
16203             case DFmode:
16204               cmp = (flag_finite_math_only && !flag_trapping_math)
16205                 ? gen_tstdflt_gpr (compare_result, op0, op1)
16206                 : gen_cmpdflt_gpr (compare_result, op0, op1);
16207               break;
16208
16209             case TFmode:
16210               cmp = (flag_finite_math_only && !flag_trapping_math)
16211                 ? gen_tsttflt_gpr (compare_result, op0, op1)
16212                 : gen_cmptflt_gpr (compare_result, op0, op1);
16213               break;
16214
16215             default:
16216               gcc_unreachable ();
16217             }
16218           break;
16219         default:
16220           gcc_unreachable ();
16221         }
16222
16223       /* Synthesize LE and GE from LT/GT || EQ.  */
16224       if (code == LE || code == GE || code == LEU || code == GEU)
16225         {
16226           emit_insn (cmp);
16227
16228           switch (code)
16229             {
16230             case LE: code = LT; break;
16231             case GE: code = GT; break;
16232             case LEU: code = LT; break;
16233             case GEU: code = GT; break;
16234             default: gcc_unreachable ();
16235             }
16236
16237           compare_result2 = gen_reg_rtx (CCFPmode);
16238
16239           /* Do the EQ.  */
16240           switch (op_mode)
16241             {
16242             case SFmode:
16243               cmp = (flag_finite_math_only && !flag_trapping_math)
16244                 ? gen_tstsfeq_gpr (compare_result2, op0, op1)
16245                 : gen_cmpsfeq_gpr (compare_result2, op0, op1);
16246               break;
16247
16248             case DFmode:
16249               cmp = (flag_finite_math_only && !flag_trapping_math)
16250                 ? gen_tstdfeq_gpr (compare_result2, op0, op1)
16251                 : gen_cmpdfeq_gpr (compare_result2, op0, op1);
16252               break;
16253
16254             case TFmode:
16255               cmp = (flag_finite_math_only && !flag_trapping_math)
16256                 ? gen_tsttfeq_gpr (compare_result2, op0, op1)
16257                 : gen_cmptfeq_gpr (compare_result2, op0, op1);
16258               break;
16259
16260             default:
16261               gcc_unreachable ();
16262             }
16263           emit_insn (cmp);
16264
16265           /* OR them together.  */
16266           or_result = gen_reg_rtx (CCFPmode);
16267           cmp = gen_e500_cr_ior_compare (or_result, compare_result,
16268                                            compare_result2);
16269           compare_result = or_result;
16270           code = EQ;
16271         }
16272       else
16273         {
16274           if (code == NE || code == LTGT)
16275             code = NE;
16276           else
16277             code = EQ;
16278         }
16279
16280       emit_insn (cmp);
16281     }
16282   else
16283     {
16284       /* Generate XLC-compatible TFmode compare as PARALLEL with extra
16285          CLOBBERs to match cmptf_internal2 pattern.  */
16286       if (comp_mode == CCFPmode && TARGET_XL_COMPAT
16287           && GET_MODE (op0) == TFmode
16288           && !TARGET_IEEEQUAD
16289           && TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_LONG_DOUBLE_128)
16290         emit_insn (gen_rtx_PARALLEL (VOIDmode,
16291           gen_rtvec (10,
16292                      gen_rtx_SET (VOIDmode,
16293                                   compare_result,
16294                                   gen_rtx_COMPARE (comp_mode, op0, op1)),
16295                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
16296                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
16297                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
16298                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
16299                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
16300                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
16301                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
16302                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (DFmode)),
16303                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (Pmode)))));
16304       else if (GET_CODE (op1) == UNSPEC
16305                && XINT (op1, 1) == UNSPEC_SP_TEST)
16306         {
16307           rtx op1b = XVECEXP (op1, 0, 0);
16308           comp_mode = CCEQmode;
16309           compare_result = gen_reg_rtx (CCEQmode);
16310           if (TARGET_64BIT)
16311             emit_insn (gen_stack_protect_testdi (compare_result, op0, op1b));
16312           else
16313             emit_insn (gen_stack_protect_testsi (compare_result, op0, op1b));
16314         }
16315       else
16316         emit_insn (gen_rtx_SET (VOIDmode, compare_result,
16317                                 gen_rtx_COMPARE (comp_mode, op0, op1)));
16318     }
16319
16320   /* Some kinds of FP comparisons need an OR operation;
16321      under flag_finite_math_only we don't bother.  */
16322   if (FLOAT_MODE_P (mode)
16323       && !flag_finite_math_only
16324       && !(TARGET_HARD_FLOAT && !TARGET_FPRS)
16325       && (code == LE || code == GE
16326           || code == UNEQ || code == LTGT
16327           || code == UNGT || code == UNLT))
16328     {
16329       enum rtx_code or1, or2;
16330       rtx or1_rtx, or2_rtx, compare2_rtx;
16331       rtx or_result = gen_reg_rtx (CCEQmode);
16332
16333       switch (code)
16334         {
16335         case LE: or1 = LT;  or2 = EQ;  break;
16336         case GE: or1 = GT;  or2 = EQ;  break;
16337         case UNEQ: or1 = UNORDERED;  or2 = EQ;  break;
16338         case LTGT: or1 = LT;  or2 = GT;  break;
16339         case UNGT: or1 = UNORDERED;  or2 = GT;  break;
16340         case UNLT: or1 = UNORDERED;  or2 = LT;  break;
16341         default:  gcc_unreachable ();
16342         }
16343       validate_condition_mode (or1, comp_mode);
16344       validate_condition_mode (or2, comp_mode);
16345       or1_rtx = gen_rtx_fmt_ee (or1, SImode, compare_result, const0_rtx);
16346       or2_rtx = gen_rtx_fmt_ee (or2, SImode, compare_result, const0_rtx);
16347       compare2_rtx = gen_rtx_COMPARE (CCEQmode,
16348                                       gen_rtx_IOR (SImode, or1_rtx, or2_rtx),
16349                                       const_true_rtx);
16350       emit_insn (gen_rtx_SET (VOIDmode, or_result, compare2_rtx));
16351
16352       compare_result = or_result;
16353       code = EQ;
16354     }
16355
16356   validate_condition_mode (code, GET_MODE (compare_result));
16357
16358   return gen_rtx_fmt_ee (code, VOIDmode, compare_result, const0_rtx);
16359 }
16360
16361
16362 /* Emit the RTL for an sISEL pattern.  */
16363
16364 void
16365 rs6000_emit_sISEL (enum machine_mode mode ATTRIBUTE_UNUSED, rtx operands[])
16366 {
16367   rs6000_emit_int_cmove (operands[0], operands[1], const1_rtx, const0_rtx);
16368 }
16369
16370 void
16371 rs6000_emit_sCOND (enum machine_mode mode, rtx operands[])
16372 {
16373   rtx condition_rtx;
16374   enum machine_mode op_mode;
16375   enum rtx_code cond_code;
16376   rtx result = operands[0];
16377
16378   if (TARGET_ISEL && (mode == SImode || mode == DImode))
16379     {
16380       rs6000_emit_sISEL (mode, operands);
16381       return;
16382     }
16383
16384   condition_rtx = rs6000_generate_compare (operands[1], mode);
16385   cond_code = GET_CODE (condition_rtx);
16386
16387   if (FLOAT_MODE_P (mode)
16388       && !TARGET_FPRS && TARGET_HARD_FLOAT)
16389     {
16390       rtx t;
16391
16392       PUT_MODE (condition_rtx, SImode);
16393       t = XEXP (condition_rtx, 0);
16394
16395       gcc_assert (cond_code == NE || cond_code == EQ);
16396
16397       if (cond_code == NE)
16398         emit_insn (gen_e500_flip_gt_bit (t, t));
16399
16400       emit_insn (gen_move_from_CR_gt_bit (result, t));
16401       return;
16402     }
16403
16404   if (cond_code == NE
16405       || cond_code == GE || cond_code == LE
16406       || cond_code == GEU || cond_code == LEU
16407       || cond_code == ORDERED || cond_code == UNGE || cond_code == UNLE)
16408     {
16409       rtx not_result = gen_reg_rtx (CCEQmode);
16410       rtx not_op, rev_cond_rtx;
16411       enum machine_mode cc_mode;
16412
16413       cc_mode = GET_MODE (XEXP (condition_rtx, 0));
16414
16415       rev_cond_rtx = gen_rtx_fmt_ee (rs6000_reverse_condition (cc_mode, cond_code),
16416                                      SImode, XEXP (condition_rtx, 0), const0_rtx);
16417       not_op = gen_rtx_COMPARE (CCEQmode, rev_cond_rtx, const0_rtx);
16418       emit_insn (gen_rtx_SET (VOIDmode, not_result, not_op));
16419       condition_rtx = gen_rtx_EQ (VOIDmode, not_result, const0_rtx);
16420     }
16421
16422   op_mode = GET_MODE (XEXP (operands[1], 0));
16423   if (op_mode == VOIDmode)
16424     op_mode = GET_MODE (XEXP (operands[1], 1));
16425
16426   if (TARGET_POWERPC64 && (op_mode == DImode || FLOAT_MODE_P (mode)))
16427     {
16428       PUT_MODE (condition_rtx, DImode);
16429       convert_move (result, condition_rtx, 0);
16430     }
16431   else
16432     {
16433       PUT_MODE (condition_rtx, SImode);
16434       emit_insn (gen_rtx_SET (VOIDmode, result, condition_rtx));
16435     }
16436 }
16437
16438 /* Emit a branch of kind CODE to location LOC.  */
16439
16440 void
16441 rs6000_emit_cbranch (enum machine_mode mode, rtx operands[])
16442 {
16443   rtx condition_rtx, loc_ref;
16444
16445   condition_rtx = rs6000_generate_compare (operands[0], mode);
16446   loc_ref = gen_rtx_LABEL_REF (VOIDmode, operands[3]);
16447   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
16448                                gen_rtx_IF_THEN_ELSE (VOIDmode, condition_rtx,
16449                                                      loc_ref, pc_rtx)));
16450 }
16451
16452 /* Return the string to output a conditional branch to LABEL, which is
16453    the operand number of the label, or -1 if the branch is really a
16454    conditional return.
16455
16456    OP is the conditional expression.  XEXP (OP, 0) is assumed to be a
16457    condition code register and its mode specifies what kind of
16458    comparison we made.
16459
16460    REVERSED is nonzero if we should reverse the sense of the comparison.
16461
16462    INSN is the insn.  */
16463
16464 char *
16465 output_cbranch (rtx op, const char *label, int reversed, rtx insn)
16466 {
16467   static char string[64];
16468   enum rtx_code code = GET_CODE (op);
16469   rtx cc_reg = XEXP (op, 0);
16470   enum machine_mode mode = GET_MODE (cc_reg);
16471   int cc_regno = REGNO (cc_reg) - CR0_REGNO;
16472   int need_longbranch = label != NULL && get_attr_length (insn) == 8;
16473   int really_reversed = reversed ^ need_longbranch;
16474   char *s = string;
16475   const char *ccode;
16476   const char *pred;
16477   rtx note;
16478
16479   validate_condition_mode (code, mode);
16480
16481   /* Work out which way this really branches.  We could use
16482      reverse_condition_maybe_unordered here always but this
16483      makes the resulting assembler clearer.  */
16484   if (really_reversed)
16485     {
16486       /* Reversal of FP compares takes care -- an ordered compare
16487          becomes an unordered compare and vice versa.  */
16488       if (mode == CCFPmode)
16489         code = reverse_condition_maybe_unordered (code);
16490       else
16491         code = reverse_condition (code);
16492     }
16493
16494   if ((!TARGET_FPRS && TARGET_HARD_FLOAT) && mode == CCFPmode)
16495     {
16496       /* The efscmp/tst* instructions twiddle bit 2, which maps nicely
16497          to the GT bit.  */
16498       switch (code)
16499         {
16500         case EQ:
16501           /* Opposite of GT.  */
16502           code = GT;
16503           break;
16504
16505         case NE:
16506           code = UNLE;
16507           break;
16508
16509         default:
16510           gcc_unreachable ();
16511         }
16512     }
16513
16514   switch (code)
16515     {
16516       /* Not all of these are actually distinct opcodes, but
16517          we distinguish them for clarity of the resulting assembler.  */
16518     case NE: case LTGT:
16519       ccode = "ne"; break;
16520     case EQ: case UNEQ:
16521       ccode = "eq"; break;
16522     case GE: case GEU:
16523       ccode = "ge"; break;
16524     case GT: case GTU: case UNGT:
16525       ccode = "gt"; break;
16526     case LE: case LEU:
16527       ccode = "le"; break;
16528     case LT: case LTU: case UNLT:
16529       ccode = "lt"; break;
16530     case UNORDERED: ccode = "un"; break;
16531     case ORDERED: ccode = "nu"; break;
16532     case UNGE: ccode = "nl"; break;
16533     case UNLE: ccode = "ng"; break;
16534     default:
16535       gcc_unreachable ();
16536     }
16537
16538   /* Maybe we have a guess as to how likely the branch is.
16539      The old mnemonics don't have a way to specify this information.  */
16540   pred = "";
16541   note = find_reg_note (insn, REG_BR_PROB, NULL_RTX);
16542   if (note != NULL_RTX)
16543     {
16544       /* PROB is the difference from 50%.  */
16545       int prob = INTVAL (XEXP (note, 0)) - REG_BR_PROB_BASE / 2;
16546
16547       /* Only hint for highly probable/improbable branches on newer
16548          cpus as static prediction overrides processor dynamic
16549          prediction.  For older cpus we may as well always hint, but
16550          assume not taken for branches that are very close to 50% as a
16551          mispredicted taken branch is more expensive than a
16552          mispredicted not-taken branch.  */
16553       if (rs6000_always_hint
16554           || (abs (prob) > REG_BR_PROB_BASE / 100 * 48
16555               && br_prob_note_reliable_p (note)))
16556         {
16557           if (abs (prob) > REG_BR_PROB_BASE / 20
16558               && ((prob > 0) ^ need_longbranch))
16559             pred = "+";
16560           else
16561             pred = "-";
16562         }
16563     }
16564
16565   if (label == NULL)
16566     s += sprintf (s, "{b%sr|b%slr%s} ", ccode, ccode, pred);
16567   else
16568     s += sprintf (s, "{b%s|b%s%s} ", ccode, ccode, pred);
16569
16570   /* We need to escape any '%' characters in the reg_names string.
16571      Assume they'd only be the first character....  */
16572   if (reg_names[cc_regno + CR0_REGNO][0] == '%')
16573     *s++ = '%';
16574   s += sprintf (s, "%s", reg_names[cc_regno + CR0_REGNO]);
16575
16576   if (label != NULL)
16577     {
16578       /* If the branch distance was too far, we may have to use an
16579          unconditional branch to go the distance.  */
16580       if (need_longbranch)
16581         s += sprintf (s, ",$+8\n\tb %s", label);
16582       else
16583         s += sprintf (s, ",%s", label);
16584     }
16585
16586   return string;
16587 }
16588
16589 /* Return the string to flip the GT bit on a CR.  */
16590 char *
16591 output_e500_flip_gt_bit (rtx dst, rtx src)
16592 {
16593   static char string[64];
16594   int a, b;
16595
16596   gcc_assert (GET_CODE (dst) == REG && CR_REGNO_P (REGNO (dst))
16597               && GET_CODE (src) == REG && CR_REGNO_P (REGNO (src)));
16598
16599   /* GT bit.  */
16600   a = 4 * (REGNO (dst) - CR0_REGNO) + 1;
16601   b = 4 * (REGNO (src) - CR0_REGNO) + 1;
16602
16603   sprintf (string, "crnot %d,%d", a, b);
16604   return string;
16605 }
16606
16607 /* Return insn for VSX or Altivec comparisons.  */
16608
16609 static rtx
16610 rs6000_emit_vector_compare_inner (enum rtx_code code, rtx op0, rtx op1)
16611 {
16612   rtx mask;
16613   enum machine_mode mode = GET_MODE (op0);
16614
16615   switch (code)
16616     {
16617     default:
16618       break;
16619
16620     case GE:
16621       if (GET_MODE_CLASS (mode) == MODE_VECTOR_INT)
16622         return NULL_RTX;
16623
16624     case EQ:
16625     case GT:
16626     case GTU:
16627       mask = gen_reg_rtx (mode);
16628       emit_insn (gen_rtx_SET (VOIDmode,
16629                               mask,
16630                               gen_rtx_fmt_ee (code, mode, op0, op1)));
16631       return mask;
16632     }
16633
16634   return NULL_RTX;
16635 }
16636
16637 /* Emit vector compare for operands OP0 and OP1 using code RCODE.
16638    DMODE is expected destination mode. This is a recursive function.  */
16639
16640 static rtx
16641 rs6000_emit_vector_compare (enum rtx_code rcode,
16642                             rtx op0, rtx op1,
16643                             enum machine_mode dmode)
16644 {
16645   rtx mask;
16646   bool swap_operands = false;
16647   bool try_again = false;
16648
16649   gcc_assert (VECTOR_UNIT_ALTIVEC_OR_VSX_P (dmode));
16650   gcc_assert (GET_MODE (op0) == GET_MODE (op1));
16651
16652   /* See if the comparison works as is.  */
16653   mask = rs6000_emit_vector_compare_inner (rcode, op0, op1);
16654   if (mask)
16655     return mask;
16656
16657   switch (rcode)
16658     {
16659     case LT:
16660       rcode = GT;
16661       swap_operands = true;
16662       try_again = true;
16663       break;
16664     case LTU:
16665       rcode = GTU;
16666       swap_operands = true;
16667       try_again = true;
16668       break;
16669     case NE:
16670     case UNLE:
16671     case UNLT:
16672     case UNGE:
16673     case UNGT:
16674       /* Invert condition and try again.
16675          e.g., A != B becomes ~(A==B).  */
16676       {
16677         enum rtx_code rev_code;
16678         enum insn_code nor_code;
16679         rtx mask2;
16680
16681         rev_code = reverse_condition_maybe_unordered (rcode);
16682         if (rev_code == UNKNOWN)
16683           return NULL_RTX;
16684
16685         nor_code = optab_handler (one_cmpl_optab, dmode);
16686         if (nor_code == CODE_FOR_nothing)
16687           return NULL_RTX;
16688
16689         mask2 = rs6000_emit_vector_compare (rev_code, op0, op1, dmode);
16690         if (!mask2)
16691           return NULL_RTX;
16692
16693         mask = gen_reg_rtx (dmode);
16694         emit_insn (GEN_FCN (nor_code) (mask, mask2));
16695         return mask;
16696       }
16697       break;
16698     case GE:
16699     case GEU:
16700     case LE:
16701     case LEU:
16702       /* Try GT/GTU/LT/LTU OR EQ */
16703       {
16704         rtx c_rtx, eq_rtx;
16705         enum insn_code ior_code;
16706         enum rtx_code new_code;
16707
16708         switch (rcode)
16709           {
16710           case  GE:
16711             new_code = GT;
16712             break;
16713
16714           case GEU:
16715             new_code = GTU;
16716             break;
16717
16718           case LE:
16719             new_code = LT;
16720             break;
16721
16722           case LEU:
16723             new_code = LTU;
16724             break;
16725
16726           default:
16727             gcc_unreachable ();
16728           }
16729
16730         ior_code = optab_handler (ior_optab, dmode);
16731         if (ior_code == CODE_FOR_nothing)
16732           return NULL_RTX;
16733
16734         c_rtx = rs6000_emit_vector_compare (new_code, op0, op1, dmode);
16735         if (!c_rtx)
16736           return NULL_RTX;
16737
16738         eq_rtx = rs6000_emit_vector_compare (EQ, op0, op1, dmode);
16739         if (!eq_rtx)
16740           return NULL_RTX;
16741
16742         mask = gen_reg_rtx (dmode);
16743         emit_insn (GEN_FCN (ior_code) (mask, c_rtx, eq_rtx));
16744         return mask;
16745       }
16746       break;
16747     default:
16748       return NULL_RTX;
16749     }
16750
16751   if (try_again)
16752     {
16753       if (swap_operands)
16754         {
16755           rtx tmp;
16756           tmp = op0;
16757           op0 = op1;
16758           op1 = tmp;
16759         }
16760
16761       mask = rs6000_emit_vector_compare_inner (rcode, op0, op1);
16762       if (mask)
16763         return mask;
16764     }
16765
16766   /* You only get two chances.  */
16767   return NULL_RTX;
16768 }
16769
16770 /* Emit vector conditional expression.  DEST is destination. OP_TRUE and
16771    OP_FALSE are two VEC_COND_EXPR operands.  CC_OP0 and CC_OP1 are the two
16772    operands for the relation operation COND.  */
16773
16774 int
16775 rs6000_emit_vector_cond_expr (rtx dest, rtx op_true, rtx op_false,
16776                               rtx cond, rtx cc_op0, rtx cc_op1)
16777 {
16778   enum machine_mode dest_mode = GET_MODE (dest);
16779   enum machine_mode mask_mode = GET_MODE (cc_op0);
16780   enum rtx_code rcode = GET_CODE (cond);
16781   enum machine_mode cc_mode = CCmode;
16782   rtx mask;
16783   rtx cond2;
16784   rtx tmp;
16785   bool invert_move = false;
16786
16787   if (VECTOR_UNIT_NONE_P (dest_mode))
16788     return 0;
16789
16790   gcc_assert (GET_MODE_SIZE (dest_mode) == GET_MODE_SIZE (mask_mode)
16791               && GET_MODE_NUNITS (dest_mode) == GET_MODE_NUNITS (mask_mode));
16792
16793   switch (rcode)
16794     {
16795       /* Swap operands if we can, and fall back to doing the operation as
16796          specified, and doing a NOR to invert the test.  */
16797     case NE:
16798     case UNLE:
16799     case UNLT:
16800     case UNGE:
16801     case UNGT:
16802       /* Invert condition and try again.
16803          e.g., A  = (B != C) ? D : E becomes A = (B == C) ? E : D.  */
16804       invert_move = true;
16805       rcode = reverse_condition_maybe_unordered (rcode);
16806       if (rcode == UNKNOWN)
16807         return 0;
16808       break;
16809
16810       /* Mark unsigned tests with CCUNSmode.  */
16811     case GTU:
16812     case GEU:
16813     case LTU:
16814     case LEU:
16815       cc_mode = CCUNSmode;
16816       break;
16817
16818     default:
16819       break;
16820     }
16821
16822   /* Get the vector mask for the given relational operations.  */
16823   mask = rs6000_emit_vector_compare (rcode, cc_op0, cc_op1, mask_mode);
16824
16825   if (!mask)
16826     return 0;
16827
16828   if (invert_move)
16829     {
16830       tmp = op_true;
16831       op_true = op_false;
16832       op_false = tmp;
16833     }
16834
16835   cond2 = gen_rtx_fmt_ee (NE, cc_mode, gen_lowpart (dest_mode, mask),
16836                           CONST0_RTX (dest_mode));
16837   emit_insn (gen_rtx_SET (VOIDmode,
16838                           dest,
16839                           gen_rtx_IF_THEN_ELSE (dest_mode,
16840                                                 cond2,
16841                                                 op_true,
16842                                                 op_false)));
16843   return 1;
16844 }
16845
16846 /* Emit a conditional move: move TRUE_COND to DEST if OP of the
16847    operands of the last comparison is nonzero/true, FALSE_COND if it
16848    is zero/false.  Return 0 if the hardware has no such operation.  */
16849
16850 int
16851 rs6000_emit_cmove (rtx dest, rtx op, rtx true_cond, rtx false_cond)
16852 {
16853   enum rtx_code code = GET_CODE (op);
16854   rtx op0 = XEXP (op, 0);
16855   rtx op1 = XEXP (op, 1);
16856   REAL_VALUE_TYPE c1;
16857   enum machine_mode compare_mode = GET_MODE (op0);
16858   enum machine_mode result_mode = GET_MODE (dest);
16859   rtx temp;
16860   bool is_against_zero;
16861
16862   /* These modes should always match.  */
16863   if (GET_MODE (op1) != compare_mode
16864       /* In the isel case however, we can use a compare immediate, so
16865          op1 may be a small constant.  */
16866       && (!TARGET_ISEL || !short_cint_operand (op1, VOIDmode)))
16867     return 0;
16868   if (GET_MODE (true_cond) != result_mode)
16869     return 0;
16870   if (GET_MODE (false_cond) != result_mode)
16871     return 0;
16872
16873   /* First, work out if the hardware can do this at all, or
16874      if it's too slow....  */
16875   if (!FLOAT_MODE_P (compare_mode))
16876     {
16877       if (TARGET_ISEL)
16878         return rs6000_emit_int_cmove (dest, op, true_cond, false_cond);
16879       return 0;
16880     }
16881   else if (TARGET_HARD_FLOAT && !TARGET_FPRS
16882            && SCALAR_FLOAT_MODE_P (compare_mode))
16883     return 0;
16884
16885   is_against_zero = op1 == CONST0_RTX (compare_mode);
16886
16887   /* A floating-point subtract might overflow, underflow, or produce
16888      an inexact result, thus changing the floating-point flags, so it
16889      can't be generated if we care about that.  It's safe if one side
16890      of the construct is zero, since then no subtract will be
16891      generated.  */
16892   if (SCALAR_FLOAT_MODE_P (compare_mode)
16893       && flag_trapping_math && ! is_against_zero)
16894     return 0;
16895
16896   /* Eliminate half of the comparisons by switching operands, this
16897      makes the remaining code simpler.  */
16898   if (code == UNLT || code == UNGT || code == UNORDERED || code == NE
16899       || code == LTGT || code == LT || code == UNLE)
16900     {
16901       code = reverse_condition_maybe_unordered (code);
16902       temp = true_cond;
16903       true_cond = false_cond;
16904       false_cond = temp;
16905     }
16906
16907   /* UNEQ and LTGT take four instructions for a comparison with zero,
16908      it'll probably be faster to use a branch here too.  */
16909   if (code == UNEQ && HONOR_NANS (compare_mode))
16910     return 0;
16911
16912   if (GET_CODE (op1) == CONST_DOUBLE)
16913     REAL_VALUE_FROM_CONST_DOUBLE (c1, op1);
16914
16915   /* We're going to try to implement comparisons by performing
16916      a subtract, then comparing against zero.  Unfortunately,
16917      Inf - Inf is NaN which is not zero, and so if we don't
16918      know that the operand is finite and the comparison
16919      would treat EQ different to UNORDERED, we can't do it.  */
16920   if (HONOR_INFINITIES (compare_mode)
16921       && code != GT && code != UNGE
16922       && (GET_CODE (op1) != CONST_DOUBLE || real_isinf (&c1))
16923       /* Constructs of the form (a OP b ? a : b) are safe.  */
16924       && ((! rtx_equal_p (op0, false_cond) && ! rtx_equal_p (op1, false_cond))
16925           || (! rtx_equal_p (op0, true_cond)
16926               && ! rtx_equal_p (op1, true_cond))))
16927     return 0;
16928
16929   /* At this point we know we can use fsel.  */
16930
16931   /* Reduce the comparison to a comparison against zero.  */
16932   if (! is_against_zero)
16933     {
16934       temp = gen_reg_rtx (compare_mode);
16935       emit_insn (gen_rtx_SET (VOIDmode, temp,
16936                               gen_rtx_MINUS (compare_mode, op0, op1)));
16937       op0 = temp;
16938       op1 = CONST0_RTX (compare_mode);
16939     }
16940
16941   /* If we don't care about NaNs we can reduce some of the comparisons
16942      down to faster ones.  */
16943   if (! HONOR_NANS (compare_mode))
16944     switch (code)
16945       {
16946       case GT:
16947         code = LE;
16948         temp = true_cond;
16949         true_cond = false_cond;
16950         false_cond = temp;
16951         break;
16952       case UNGE:
16953         code = GE;
16954         break;
16955       case UNEQ:
16956         code = EQ;
16957         break;
16958       default:
16959         break;
16960       }
16961
16962   /* Now, reduce everything down to a GE.  */
16963   switch (code)
16964     {
16965     case GE:
16966       break;
16967
16968     case LE:
16969       temp = gen_reg_rtx (compare_mode);
16970       emit_insn (gen_rtx_SET (VOIDmode, temp, gen_rtx_NEG (compare_mode, op0)));
16971       op0 = temp;
16972       break;
16973
16974     case ORDERED:
16975       temp = gen_reg_rtx (compare_mode);
16976       emit_insn (gen_rtx_SET (VOIDmode, temp, gen_rtx_ABS (compare_mode, op0)));
16977       op0 = temp;
16978       break;
16979
16980     case EQ:
16981       temp = gen_reg_rtx (compare_mode);
16982       emit_insn (gen_rtx_SET (VOIDmode, temp,
16983                               gen_rtx_NEG (compare_mode,
16984                                            gen_rtx_ABS (compare_mode, op0))));
16985       op0 = temp;
16986       break;
16987
16988     case UNGE:
16989       /* a UNGE 0 <-> (a GE 0 || -a UNLT 0) */
16990       temp = gen_reg_rtx (result_mode);
16991       emit_insn (gen_rtx_SET (VOIDmode, temp,
16992                               gen_rtx_IF_THEN_ELSE (result_mode,
16993                                                     gen_rtx_GE (VOIDmode,
16994                                                                 op0, op1),
16995                                                     true_cond, false_cond)));
16996       false_cond = true_cond;
16997       true_cond = temp;
16998
16999       temp = gen_reg_rtx (compare_mode);
17000       emit_insn (gen_rtx_SET (VOIDmode, temp, gen_rtx_NEG (compare_mode, op0)));
17001       op0 = temp;
17002       break;
17003
17004     case GT:
17005       /* a GT 0 <-> (a GE 0 && -a UNLT 0) */
17006       temp = gen_reg_rtx (result_mode);
17007       emit_insn (gen_rtx_SET (VOIDmode, temp,
17008                               gen_rtx_IF_THEN_ELSE (result_mode,
17009                                                     gen_rtx_GE (VOIDmode,
17010                                                                 op0, op1),
17011                                                     true_cond, false_cond)));
17012       true_cond = false_cond;
17013       false_cond = temp;
17014
17015       temp = gen_reg_rtx (compare_mode);
17016       emit_insn (gen_rtx_SET (VOIDmode, temp, gen_rtx_NEG (compare_mode, op0)));
17017       op0 = temp;
17018       break;
17019
17020     default:
17021       gcc_unreachable ();
17022     }
17023
17024   emit_insn (gen_rtx_SET (VOIDmode, dest,
17025                           gen_rtx_IF_THEN_ELSE (result_mode,
17026                                                 gen_rtx_GE (VOIDmode,
17027                                                             op0, op1),
17028                                                 true_cond, false_cond)));
17029   return 1;
17030 }
17031
17032 /* Same as above, but for ints (isel).  */
17033
17034 static int
17035 rs6000_emit_int_cmove (rtx dest, rtx op, rtx true_cond, rtx false_cond)
17036 {
17037   rtx condition_rtx, cr;
17038   enum machine_mode mode = GET_MODE (dest);
17039   enum rtx_code cond_code;
17040   rtx (*isel_func) (rtx, rtx, rtx, rtx, rtx);
17041   bool signedp;
17042
17043   if (mode != SImode && (!TARGET_POWERPC64 || mode != DImode))
17044     return 0;
17045
17046   /* We still have to do the compare, because isel doesn't do a
17047      compare, it just looks at the CRx bits set by a previous compare
17048      instruction.  */
17049   condition_rtx = rs6000_generate_compare (op, mode);
17050   cond_code = GET_CODE (condition_rtx);
17051   cr = XEXP (condition_rtx, 0);
17052   signedp = GET_MODE (cr) == CCmode;
17053
17054   isel_func = (mode == SImode
17055                ? (signedp ? gen_isel_signed_si : gen_isel_unsigned_si)
17056                : (signedp ? gen_isel_signed_di : gen_isel_unsigned_di));
17057
17058   switch (cond_code)
17059     {
17060     case LT: case GT: case LTU: case GTU: case EQ:
17061       /* isel handles these directly.  */
17062       break;
17063
17064     default:
17065       /* We need to swap the sense of the comparison.  */
17066       {
17067         rtx t = true_cond;
17068         true_cond = false_cond;
17069         false_cond = t;
17070         PUT_CODE (condition_rtx, reverse_condition (cond_code));
17071       }
17072       break;
17073     }
17074
17075   false_cond = force_reg (mode, false_cond);
17076   if (true_cond != const0_rtx)
17077     true_cond = force_reg (mode, true_cond);
17078
17079   emit_insn (isel_func (dest, condition_rtx, true_cond, false_cond, cr));
17080
17081   return 1;
17082 }
17083
17084 const char *
17085 output_isel (rtx *operands)
17086 {
17087   enum rtx_code code;
17088
17089   code = GET_CODE (operands[1]);
17090
17091   if (code == GE || code == GEU || code == LE || code == LEU || code == NE)
17092     {
17093       gcc_assert (GET_CODE (operands[2]) == REG
17094                   && GET_CODE (operands[3]) == REG);
17095       PUT_CODE (operands[1], reverse_condition (code));
17096       return "isel %0,%3,%2,%j1";
17097     }
17098
17099   return "isel %0,%2,%3,%j1";
17100 }
17101
17102 void
17103 rs6000_emit_minmax (rtx dest, enum rtx_code code, rtx op0, rtx op1)
17104 {
17105   enum machine_mode mode = GET_MODE (op0);
17106   enum rtx_code c;
17107   rtx target;
17108
17109   /* VSX/altivec have direct min/max insns.  */
17110   if ((code == SMAX || code == SMIN)
17111       && (VECTOR_UNIT_ALTIVEC_OR_VSX_P (mode)
17112           || (mode == SFmode && VECTOR_UNIT_VSX_P (DFmode))))
17113     {
17114       emit_insn (gen_rtx_SET (VOIDmode,
17115                               dest,
17116                               gen_rtx_fmt_ee (code, mode, op0, op1)));
17117       return;
17118     }
17119
17120   if (code == SMAX || code == SMIN)
17121     c = GE;
17122   else
17123     c = GEU;
17124
17125   if (code == SMAX || code == UMAX)
17126     target = emit_conditional_move (dest, c, op0, op1, mode,
17127                                     op0, op1, mode, 0);
17128   else
17129     target = emit_conditional_move (dest, c, op0, op1, mode,
17130                                     op1, op0, mode, 0);
17131   gcc_assert (target);
17132   if (target != dest)
17133     emit_move_insn (dest, target);
17134 }
17135
17136 /* Emit instructions to perform a load-reserved/store-conditional operation.
17137    The operation performed is an atomic
17138    (set M (CODE:MODE M OP))
17139    If not NULL, BEFORE is atomically set to M before the operation, and
17140    AFTER is set to M after the operation (that is, (CODE:MODE M OP)).
17141    If SYNC_P then a memory barrier is emitted before the operation.
17142    Either OP or M may be wrapped in a NOT operation.  */
17143
17144 void
17145 rs6000_emit_sync (enum rtx_code code, enum machine_mode mode,
17146                   rtx m, rtx op, rtx before_param, rtx after_param,
17147                   bool sync_p)
17148 {
17149   enum machine_mode used_mode;
17150   rtx the_op, set_before, set_after, set_atomic, cc_scratch, before, after;
17151   rtx used_m;
17152   rtvec vec;
17153   HOST_WIDE_INT imask = GET_MODE_MASK (mode);
17154   rtx shift = NULL_RTX;
17155
17156   if (sync_p)
17157     emit_insn (gen_lwsync ());
17158
17159     used_m = m;
17160
17161   /* If this is smaller than SImode, we'll have to use SImode with
17162      adjustments.  */
17163   if (mode == QImode || mode == HImode)
17164     {
17165       rtx newop, oldop;
17166
17167       if (MEM_ALIGN (used_m) >= 32)
17168         {
17169           int ishift = 0;
17170           if (BYTES_BIG_ENDIAN)
17171             ishift = GET_MODE_BITSIZE (SImode) - GET_MODE_BITSIZE (mode);
17172
17173           shift = GEN_INT (ishift);
17174           used_m = change_address (used_m, SImode, 0);
17175         }
17176       else
17177         {
17178           rtx addrSI, aligned_addr;
17179           int shift_mask = mode == QImode ? 0x18 : 0x10;
17180
17181           addrSI = gen_lowpart_common (SImode,
17182                                        force_reg (Pmode, XEXP (used_m, 0)));
17183           addrSI = force_reg (SImode, addrSI);
17184           shift = gen_reg_rtx (SImode);
17185
17186           emit_insn (gen_rlwinm (shift, addrSI, GEN_INT (3),
17187                                  GEN_INT (shift_mask)));
17188           emit_insn (gen_xorsi3 (shift, shift, GEN_INT (shift_mask)));
17189
17190           aligned_addr = expand_binop (Pmode, and_optab,
17191                                        XEXP (used_m, 0),
17192                                        GEN_INT (-4), NULL_RTX,
17193                                        1, OPTAB_LIB_WIDEN);
17194           used_m = change_address (used_m, SImode, aligned_addr);
17195           set_mem_align (used_m, 32);
17196         }
17197       /* It's safe to keep the old alias set of USED_M, because
17198          the operation is atomic and only affects the original
17199          USED_M.  */
17200       m = used_m;
17201
17202       if (GET_CODE (op) == NOT)
17203         {
17204           oldop = lowpart_subreg (SImode, XEXP (op, 0), mode);
17205           oldop = gen_rtx_NOT (SImode, oldop);
17206         }
17207       else
17208         oldop = lowpart_subreg (SImode, op, mode);
17209
17210       switch (code)
17211         {
17212         case IOR:
17213         case XOR:
17214           newop = expand_binop (SImode, and_optab,
17215                                 oldop, GEN_INT (imask), NULL_RTX,
17216                                 1, OPTAB_LIB_WIDEN);
17217           emit_insn (gen_ashlsi3 (newop, newop, shift));
17218           break;
17219
17220         case NOT: /* NAND */
17221           newop = expand_binop (SImode, ior_optab,
17222                                 oldop, GEN_INT (~imask), NULL_RTX,
17223                                 1, OPTAB_LIB_WIDEN);
17224           emit_insn (gen_rotlsi3 (newop, newop, shift));
17225           break;
17226
17227         case AND:
17228           newop = expand_binop (SImode, ior_optab,
17229                                 oldop, GEN_INT (~imask), NULL_RTX,
17230                                 1, OPTAB_LIB_WIDEN);
17231           emit_insn (gen_rotlsi3 (newop, newop, shift));
17232           break;
17233
17234         case PLUS:
17235         case MINUS:
17236           {
17237             rtx mask;
17238
17239             newop = expand_binop (SImode, and_optab,
17240                                   oldop, GEN_INT (imask), NULL_RTX,
17241                                   1, OPTAB_LIB_WIDEN);
17242             emit_insn (gen_ashlsi3 (newop, newop, shift));
17243
17244             mask = gen_reg_rtx (SImode);
17245             emit_move_insn (mask, GEN_INT (imask));
17246             emit_insn (gen_ashlsi3 (mask, mask, shift));
17247
17248             if (code == PLUS)
17249               newop = gen_rtx_PLUS (SImode, m, newop);
17250             else
17251               newop = gen_rtx_MINUS (SImode, m, newop);
17252             newop = gen_rtx_AND (SImode, newop, mask);
17253             newop = gen_rtx_IOR (SImode, newop,
17254                                  gen_rtx_AND (SImode,
17255                                               gen_rtx_NOT (SImode, mask),
17256                                               m));
17257             break;
17258           }
17259
17260         default:
17261           gcc_unreachable ();
17262         }
17263
17264       op = newop;
17265       used_mode = SImode;
17266       before = gen_reg_rtx (used_mode);
17267       after = gen_reg_rtx (used_mode);
17268     }
17269   else
17270     {
17271       used_mode = mode;
17272       before = before_param;
17273       after = after_param;
17274
17275       if (before == NULL_RTX)
17276         before = gen_reg_rtx (used_mode);
17277       if (after == NULL_RTX)
17278         after = gen_reg_rtx (used_mode);
17279     }
17280
17281   if ((code == PLUS || code == MINUS)
17282       && used_mode != mode)
17283     the_op = op;  /* Computed above.  */
17284   else if (GET_CODE (op) == NOT && GET_CODE (m) != NOT)
17285     the_op = gen_rtx_fmt_ee (code, used_mode, op, m);
17286   else if (code == NOT)
17287     the_op = gen_rtx_fmt_ee (IOR, used_mode,
17288                              gen_rtx_NOT (used_mode, m),
17289                              gen_rtx_NOT (used_mode, op));
17290   else
17291     the_op = gen_rtx_fmt_ee (code, used_mode, m, op);
17292
17293   set_after = gen_rtx_SET (VOIDmode, after, the_op);
17294   set_before = gen_rtx_SET (VOIDmode, before, used_m);
17295   set_atomic = gen_rtx_SET (VOIDmode, used_m,
17296                             gen_rtx_UNSPEC (used_mode,
17297                                             gen_rtvec (1, the_op),
17298                                             UNSPEC_SYNC_OP));
17299   cc_scratch = gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (CCmode));
17300
17301   if ((code == PLUS || code == MINUS) && used_mode != mode)
17302     vec = gen_rtvec (5, set_after, set_before, set_atomic, cc_scratch,
17303                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_SCRATCH (SImode)));
17304   else
17305     vec = gen_rtvec (4, set_after, set_before, set_atomic, cc_scratch);
17306   emit_insn (gen_rtx_PARALLEL (VOIDmode, vec));
17307
17308   /* Shift and mask the return values properly.  */
17309   if (used_mode != mode && before_param)
17310     {
17311       emit_insn (gen_lshrsi3 (before, before, shift));
17312       convert_move (before_param, before, 1);
17313     }
17314
17315   if (used_mode != mode && after_param)
17316     {
17317       emit_insn (gen_lshrsi3 (after, after, shift));
17318       convert_move (after_param, after, 1);
17319     }
17320
17321   /* The previous sequence will end with a branch that's dependent on
17322      the conditional store, so placing an isync will ensure that no
17323      other instructions (especially, no load or store instructions)
17324      can start before the atomic operation completes.  */
17325   if (sync_p)
17326     emit_insn (gen_isync ());
17327 }
17328
17329 /* A subroutine of the atomic operation splitters.  Jump to LABEL if
17330    COND is true.  Mark the jump as unlikely to be taken.  */
17331
17332 static void
17333 emit_unlikely_jump (rtx cond, rtx label)
17334 {
17335   rtx very_unlikely = GEN_INT (REG_BR_PROB_BASE / 100 - 1);
17336   rtx x;
17337
17338   x = gen_rtx_IF_THEN_ELSE (VOIDmode, cond, label, pc_rtx);
17339   x = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, x));
17340   add_reg_note (x, REG_BR_PROB, very_unlikely);
17341 }
17342
17343 /* A subroutine of the atomic operation splitters.  Emit a load-locked
17344    instruction in MODE.  */
17345
17346 static void
17347 emit_load_locked (enum machine_mode mode, rtx reg, rtx mem)
17348 {
17349   rtx (*fn) (rtx, rtx) = NULL;
17350   if (mode == SImode)
17351     fn = gen_load_locked_si;
17352   else if (mode == DImode)
17353     fn = gen_load_locked_di;
17354   emit_insn (fn (reg, mem));
17355 }
17356
17357 /* A subroutine of the atomic operation splitters.  Emit a store-conditional
17358    instruction in MODE.  */
17359
17360 static void
17361 emit_store_conditional (enum machine_mode mode, rtx res, rtx mem, rtx val)
17362 {
17363   rtx (*fn) (rtx, rtx, rtx) = NULL;
17364   if (mode == SImode)
17365     fn = gen_store_conditional_si;
17366   else if (mode == DImode)
17367     fn = gen_store_conditional_di;
17368
17369   /* Emit sync before stwcx. to address PPC405 Erratum.  */
17370   if (PPC405_ERRATUM77)
17371     emit_insn (gen_memory_barrier ());
17372
17373   emit_insn (fn (res, mem, val));
17374 }
17375
17376 /* Expand an atomic fetch-and-operate pattern.  CODE is the binary operation
17377    to perform.  MEM is the memory on which to operate.  VAL is the second
17378    operand of the binary operator.  BEFORE and AFTER are optional locations to
17379    return the value of MEM either before of after the operation.  SCRATCH is
17380    a scratch register.  */
17381
17382 void
17383 rs6000_split_atomic_op (enum rtx_code code, rtx mem, rtx val,
17384                        rtx before, rtx after, rtx scratch)
17385 {
17386   enum machine_mode mode = GET_MODE (mem);
17387   rtx label, x, cond = gen_rtx_REG (CCmode, CR0_REGNO);
17388
17389   emit_insn (gen_lwsync ());
17390
17391   label = gen_label_rtx ();
17392   emit_label (label);
17393   label = gen_rtx_LABEL_REF (VOIDmode, label);
17394
17395   if (before == NULL_RTX)
17396     before = scratch;
17397   emit_load_locked (mode, before, mem);
17398
17399   if (code == NOT)
17400     x = gen_rtx_IOR (mode,
17401                      gen_rtx_NOT (mode, before),
17402                      gen_rtx_NOT (mode, val));
17403   else if (code == AND)
17404     x = gen_rtx_UNSPEC (mode, gen_rtvec (2, before, val), UNSPEC_AND);
17405   else
17406     x = gen_rtx_fmt_ee (code, mode, before, val);
17407
17408   if (after != NULL_RTX)
17409     emit_insn (gen_rtx_SET (VOIDmode, after, copy_rtx (x)));
17410   emit_insn (gen_rtx_SET (VOIDmode, scratch, x));
17411
17412   emit_store_conditional (mode, cond, mem, scratch);
17413
17414   x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
17415   emit_unlikely_jump (x, label);
17416
17417   emit_insn (gen_isync ());
17418 }
17419
17420 /* Expand an atomic compare and swap operation.  MEM is the memory on which
17421    to operate.  OLDVAL is the old value to be compared.  NEWVAL is the new
17422    value to be stored.  SCRATCH is a scratch GPR.  */
17423
17424 void
17425 rs6000_split_compare_and_swap (rtx retval, rtx mem, rtx oldval, rtx newval,
17426                                rtx scratch)
17427 {
17428   enum machine_mode mode = GET_MODE (mem);
17429   rtx label1, label2, x, cond = gen_rtx_REG (CCmode, CR0_REGNO);
17430
17431   emit_insn (gen_lwsync ());
17432
17433   label1 = gen_rtx_LABEL_REF (VOIDmode, gen_label_rtx ());
17434   label2 = gen_rtx_LABEL_REF (VOIDmode, gen_label_rtx ());
17435   emit_label (XEXP (label1, 0));
17436
17437   emit_load_locked (mode, retval, mem);
17438
17439   x = gen_rtx_COMPARE (CCmode, retval, oldval);
17440   emit_insn (gen_rtx_SET (VOIDmode, cond, x));
17441
17442   x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
17443   emit_unlikely_jump (x, label2);
17444
17445   emit_move_insn (scratch, newval);
17446   emit_store_conditional (mode, cond, mem, scratch);
17447
17448   x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
17449   emit_unlikely_jump (x, label1);
17450
17451   emit_insn (gen_isync ());
17452   emit_label (XEXP (label2, 0));
17453 }
17454
17455 /* Expand an atomic test and set operation.  MEM is the memory on which
17456    to operate.  VAL is the value set.  SCRATCH is a scratch GPR.  */
17457
17458 void
17459 rs6000_split_lock_test_and_set (rtx retval, rtx mem, rtx val, rtx scratch)
17460 {
17461   enum machine_mode mode = GET_MODE (mem);
17462   rtx label, x, cond = gen_rtx_REG (CCmode, CR0_REGNO);
17463
17464   label = gen_rtx_LABEL_REF (VOIDmode, gen_label_rtx ());
17465   emit_label (XEXP (label, 0));
17466
17467   emit_load_locked (mode, retval, mem);
17468   emit_move_insn (scratch, val);
17469   emit_store_conditional (mode, cond, mem, scratch);
17470
17471   x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
17472   emit_unlikely_jump (x, label);
17473
17474   emit_insn (gen_isync ());
17475 }
17476
17477 void
17478 rs6000_expand_compare_and_swapqhi (rtx dst, rtx mem, rtx oldval, rtx newval)
17479 {
17480   enum machine_mode mode = GET_MODE (mem);
17481   rtx addrSI, align, wdst, shift, mask;
17482   HOST_WIDE_INT shift_mask = mode == QImode ? 0x18 : 0x10;
17483   HOST_WIDE_INT imask = GET_MODE_MASK (mode);
17484
17485   /* Shift amount for subword relative to aligned word.  */
17486   addrSI = force_reg (GET_MODE (XEXP (mem, 0)), XEXP (mem, 0));
17487   addrSI = force_reg (SImode, gen_lowpart_common (SImode, addrSI));
17488   shift = gen_reg_rtx (SImode);
17489   emit_insn (gen_rlwinm (shift, addrSI, GEN_INT (3),
17490                          GEN_INT (shift_mask)));
17491   emit_insn (gen_xorsi3 (shift, shift, GEN_INT (shift_mask)));
17492
17493   /* Shift and mask old value into position within word.  */
17494   oldval = convert_modes (SImode, mode, oldval, 1);
17495   oldval = expand_binop (SImode, and_optab,
17496                          oldval, GEN_INT (imask), NULL_RTX,
17497                          1, OPTAB_LIB_WIDEN);
17498   emit_insn (gen_ashlsi3 (oldval, oldval, shift));
17499
17500   /* Shift and mask new value into position within word.  */
17501   newval = convert_modes (SImode, mode, newval, 1);
17502   newval = expand_binop (SImode, and_optab,
17503                          newval, GEN_INT (imask), NULL_RTX,
17504                          1, OPTAB_LIB_WIDEN);
17505   emit_insn (gen_ashlsi3 (newval, newval, shift));
17506
17507   /* Mask for insertion.  */
17508   mask = gen_reg_rtx (SImode);
17509   emit_move_insn (mask, GEN_INT (imask));
17510   emit_insn (gen_ashlsi3 (mask, mask, shift));
17511
17512   /* Address of aligned word containing subword.  */
17513   align = expand_binop (Pmode, and_optab, XEXP (mem, 0), GEN_INT (-4),
17514                         NULL_RTX, 1, OPTAB_LIB_WIDEN);
17515   mem = change_address (mem, SImode, align);
17516   set_mem_align (mem, 32);
17517   MEM_VOLATILE_P (mem) = 1;
17518
17519   wdst = gen_reg_rtx (SImode);
17520   emit_insn (gen_sync_compare_and_swapqhi_internal (wdst, mask,
17521                                                     oldval, newval, mem));
17522
17523   /* Shift the result back.  */
17524   emit_insn (gen_lshrsi3 (wdst, wdst, shift));
17525
17526   emit_move_insn (dst, gen_lowpart (mode, wdst));
17527 }
17528
17529 void
17530 rs6000_split_compare_and_swapqhi (rtx dest, rtx mask,
17531                                   rtx oldval, rtx newval, rtx mem,
17532                                   rtx scratch)
17533 {
17534   rtx label1, label2, x, cond = gen_rtx_REG (CCmode, CR0_REGNO);
17535
17536   emit_insn (gen_lwsync ());
17537   label1 = gen_rtx_LABEL_REF (VOIDmode, gen_label_rtx ());
17538   label2 = gen_rtx_LABEL_REF (VOIDmode, gen_label_rtx ());
17539   emit_label (XEXP (label1, 0));
17540
17541   emit_load_locked (SImode, scratch, mem);
17542
17543   /* Mask subword within loaded value for comparison with oldval.
17544      Use UNSPEC_AND to avoid clobber.*/
17545   emit_insn (gen_rtx_SET (SImode, dest,
17546                           gen_rtx_UNSPEC (SImode,
17547                                           gen_rtvec (2, scratch, mask),
17548                                           UNSPEC_AND)));
17549
17550   x = gen_rtx_COMPARE (CCmode, dest, oldval);
17551   emit_insn (gen_rtx_SET (VOIDmode, cond, x));
17552
17553   x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
17554   emit_unlikely_jump (x, label2);
17555
17556   /* Clear subword within loaded value for insertion of new value.  */
17557   emit_insn (gen_rtx_SET (SImode, scratch,
17558                           gen_rtx_AND (SImode,
17559                                        gen_rtx_NOT (SImode, mask), scratch)));
17560   emit_insn (gen_iorsi3 (scratch, scratch, newval));
17561   emit_store_conditional (SImode, cond, mem, scratch);
17562
17563   x = gen_rtx_NE (VOIDmode, cond, const0_rtx);
17564   emit_unlikely_jump (x, label1);
17565
17566   emit_insn (gen_isync ());
17567   emit_label (XEXP (label2, 0));
17568 }
17569
17570
17571   /* Emit instructions to move SRC to DST.  Called by splitters for
17572    multi-register moves.  It will emit at most one instruction for
17573    each register that is accessed; that is, it won't emit li/lis pairs
17574    (or equivalent for 64-bit code).  One of SRC or DST must be a hard
17575    register.  */
17576
17577 void
17578 rs6000_split_multireg_move (rtx dst, rtx src)
17579 {
17580   /* The register number of the first register being moved.  */
17581   int reg;
17582   /* The mode that is to be moved.  */
17583   enum machine_mode mode;
17584   /* The mode that the move is being done in, and its size.  */
17585   enum machine_mode reg_mode;
17586   int reg_mode_size;
17587   /* The number of registers that will be moved.  */
17588   int nregs;
17589
17590   reg = REG_P (dst) ? REGNO (dst) : REGNO (src);
17591   mode = GET_MODE (dst);
17592   nregs = hard_regno_nregs[reg][mode];
17593   if (FP_REGNO_P (reg))
17594     reg_mode = DECIMAL_FLOAT_MODE_P (mode) ? DDmode :
17595         ((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT) ? DFmode : SFmode);
17596   else if (ALTIVEC_REGNO_P (reg))
17597     reg_mode = V16QImode;
17598   else if (TARGET_E500_DOUBLE && mode == TFmode)
17599     reg_mode = DFmode;
17600   else
17601     reg_mode = word_mode;
17602   reg_mode_size = GET_MODE_SIZE (reg_mode);
17603
17604   gcc_assert (reg_mode_size * nregs == GET_MODE_SIZE (mode));
17605
17606   if (REG_P (src) && REG_P (dst) && (REGNO (src) < REGNO (dst)))
17607     {
17608       /* Move register range backwards, if we might have destructive
17609          overlap.  */
17610       int i;
17611       for (i = nregs - 1; i >= 0; i--)
17612         emit_insn (gen_rtx_SET (VOIDmode,
17613                                 simplify_gen_subreg (reg_mode, dst, mode,
17614                                                      i * reg_mode_size),
17615                                 simplify_gen_subreg (reg_mode, src, mode,
17616                                                      i * reg_mode_size)));
17617     }
17618   else
17619     {
17620       int i;
17621       int j = -1;
17622       bool used_update = false;
17623       rtx restore_basereg = NULL_RTX;
17624
17625       if (MEM_P (src) && INT_REGNO_P (reg))
17626         {
17627           rtx breg;
17628
17629           if (GET_CODE (XEXP (src, 0)) == PRE_INC
17630               || GET_CODE (XEXP (src, 0)) == PRE_DEC)
17631             {
17632               rtx delta_rtx;
17633               breg = XEXP (XEXP (src, 0), 0);
17634               delta_rtx = (GET_CODE (XEXP (src, 0)) == PRE_INC
17635                            ? GEN_INT (GET_MODE_SIZE (GET_MODE (src)))
17636                            : GEN_INT (-GET_MODE_SIZE (GET_MODE (src))));
17637               emit_insn (gen_add3_insn (breg, breg, delta_rtx));
17638               src = replace_equiv_address (src, breg);
17639             }
17640           else if (! rs6000_offsettable_memref_p (src))
17641             {
17642               if (GET_CODE (XEXP (src, 0)) == PRE_MODIFY)
17643                 {
17644                   rtx basereg = XEXP (XEXP (src, 0), 0);
17645                   if (TARGET_UPDATE)
17646                     {
17647                       rtx ndst = simplify_gen_subreg (reg_mode, dst, mode, 0);
17648                       emit_insn (gen_rtx_SET (VOIDmode, ndst,
17649                                  gen_rtx_MEM (reg_mode, XEXP (src, 0))));
17650                       used_update = true;
17651                     }
17652                   else
17653                     emit_insn (gen_rtx_SET (VOIDmode, basereg,
17654                                XEXP (XEXP (src, 0), 1)));
17655                   src = replace_equiv_address (src, basereg);
17656                 }
17657               else
17658                 {
17659                   rtx basereg = gen_rtx_REG (Pmode, reg);
17660                   emit_insn (gen_rtx_SET (VOIDmode, basereg, XEXP (src, 0)));
17661                   src = replace_equiv_address (src, basereg);
17662                 }
17663             }
17664
17665           breg = XEXP (src, 0);
17666           if (GET_CODE (breg) == PLUS || GET_CODE (breg) == LO_SUM)
17667             breg = XEXP (breg, 0);
17668
17669           /* If the base register we are using to address memory is
17670              also a destination reg, then change that register last.  */
17671           if (REG_P (breg)
17672               && REGNO (breg) >= REGNO (dst)
17673               && REGNO (breg) < REGNO (dst) + nregs)
17674             j = REGNO (breg) - REGNO (dst);
17675         }
17676       else if (MEM_P (dst) && INT_REGNO_P (reg))
17677         {
17678           rtx breg;
17679
17680           if (GET_CODE (XEXP (dst, 0)) == PRE_INC
17681               || GET_CODE (XEXP (dst, 0)) == PRE_DEC)
17682             {
17683               rtx delta_rtx;
17684               breg = XEXP (XEXP (dst, 0), 0);
17685               delta_rtx = (GET_CODE (XEXP (dst, 0)) == PRE_INC
17686                            ? GEN_INT (GET_MODE_SIZE (GET_MODE (dst)))
17687                            : GEN_INT (-GET_MODE_SIZE (GET_MODE (dst))));
17688
17689               /* We have to update the breg before doing the store.
17690                  Use store with update, if available.  */
17691
17692               if (TARGET_UPDATE)
17693                 {
17694                   rtx nsrc = simplify_gen_subreg (reg_mode, src, mode, 0);
17695                   emit_insn (TARGET_32BIT
17696                              ? (TARGET_POWERPC64
17697                                 ? gen_movdi_si_update (breg, breg, delta_rtx, nsrc)
17698                                 : gen_movsi_update (breg, breg, delta_rtx, nsrc))
17699                              : gen_movdi_di_update (breg, breg, delta_rtx, nsrc));
17700                   used_update = true;
17701                 }
17702               else
17703                 emit_insn (gen_add3_insn (breg, breg, delta_rtx));
17704               dst = replace_equiv_address (dst, breg);
17705             }
17706           else if (!rs6000_offsettable_memref_p (dst)
17707                    && GET_CODE (XEXP (dst, 0)) != LO_SUM)
17708             {
17709               if (GET_CODE (XEXP (dst, 0)) == PRE_MODIFY)
17710                 {
17711                   rtx basereg = XEXP (XEXP (dst, 0), 0);
17712                   if (TARGET_UPDATE)
17713                     {
17714                       rtx nsrc = simplify_gen_subreg (reg_mode, src, mode, 0);
17715                       emit_insn (gen_rtx_SET (VOIDmode,
17716                                  gen_rtx_MEM (reg_mode, XEXP (dst, 0)), nsrc));
17717                       used_update = true;
17718                     }
17719                   else
17720                     emit_insn (gen_rtx_SET (VOIDmode, basereg,
17721                                XEXP (XEXP (dst, 0), 1)));
17722                   dst = replace_equiv_address (dst, basereg);
17723                 }
17724               else
17725                 {
17726                   rtx basereg = XEXP (XEXP (dst, 0), 0);
17727                   rtx offsetreg = XEXP (XEXP (dst, 0), 1);
17728                   gcc_assert (GET_CODE (XEXP (dst, 0)) == PLUS
17729                               && REG_P (basereg)
17730                               && REG_P (offsetreg)
17731                               && REGNO (basereg) != REGNO (offsetreg));
17732                   if (REGNO (basereg) == 0)
17733                     {
17734                       rtx tmp = offsetreg;
17735                       offsetreg = basereg;
17736                       basereg = tmp;
17737                     }
17738                   emit_insn (gen_add3_insn (basereg, basereg, offsetreg));
17739                   restore_basereg = gen_sub3_insn (basereg, basereg, offsetreg);
17740                   dst = replace_equiv_address (dst, basereg);
17741                 }
17742             }
17743           else if (GET_CODE (XEXP (dst, 0)) != LO_SUM)
17744             gcc_assert (rs6000_offsettable_memref_p (dst));
17745         }
17746
17747       for (i = 0; i < nregs; i++)
17748         {
17749           /* Calculate index to next subword.  */
17750           ++j;
17751           if (j == nregs)
17752             j = 0;
17753
17754           /* If compiler already emitted move of first word by
17755              store with update, no need to do anything.  */
17756           if (j == 0 && used_update)
17757             continue;
17758
17759           emit_insn (gen_rtx_SET (VOIDmode,
17760                                   simplify_gen_subreg (reg_mode, dst, mode,
17761                                                        j * reg_mode_size),
17762                                   simplify_gen_subreg (reg_mode, src, mode,
17763                                                        j * reg_mode_size)));
17764         }
17765       if (restore_basereg != NULL_RTX)
17766         emit_insn (restore_basereg);
17767     }
17768 }
17769
17770 \f
17771 /* This page contains routines that are used to determine what the
17772    function prologue and epilogue code will do and write them out.  */
17773
17774 /* Return the first fixed-point register that is required to be
17775    saved. 32 if none.  */
17776
17777 int
17778 first_reg_to_save (void)
17779 {
17780   int first_reg;
17781
17782   /* Find lowest numbered live register.  */
17783   for (first_reg = 13; first_reg <= 31; first_reg++)
17784     if (df_regs_ever_live_p (first_reg)
17785         && (! call_used_regs[first_reg]
17786             || (first_reg == RS6000_PIC_OFFSET_TABLE_REGNUM
17787                 && ((DEFAULT_ABI == ABI_V4 && flag_pic != 0)
17788                     || (DEFAULT_ABI == ABI_DARWIN && flag_pic)
17789                     || (TARGET_TOC && TARGET_MINIMAL_TOC)))))
17790       break;
17791
17792 #if TARGET_MACHO
17793   if (flag_pic
17794       && crtl->uses_pic_offset_table
17795       && first_reg > RS6000_PIC_OFFSET_TABLE_REGNUM)
17796     return RS6000_PIC_OFFSET_TABLE_REGNUM;
17797 #endif
17798
17799   return first_reg;
17800 }
17801
17802 /* Similar, for FP regs.  */
17803
17804 int
17805 first_fp_reg_to_save (void)
17806 {
17807   int first_reg;
17808
17809   /* Find lowest numbered live register.  */
17810   for (first_reg = 14 + 32; first_reg <= 63; first_reg++)
17811     if (df_regs_ever_live_p (first_reg))
17812       break;
17813
17814   return first_reg;
17815 }
17816
17817 /* Similar, for AltiVec regs.  */
17818
17819 static int
17820 first_altivec_reg_to_save (void)
17821 {
17822   int i;
17823
17824   /* Stack frame remains as is unless we are in AltiVec ABI.  */
17825   if (! TARGET_ALTIVEC_ABI)
17826     return LAST_ALTIVEC_REGNO + 1;
17827
17828   /* On Darwin, the unwind routines are compiled without
17829      TARGET_ALTIVEC, and use save_world to save/restore the
17830      altivec registers when necessary.  */
17831   if (DEFAULT_ABI == ABI_DARWIN && crtl->calls_eh_return
17832       && ! TARGET_ALTIVEC)
17833     return FIRST_ALTIVEC_REGNO + 20;
17834
17835   /* Find lowest numbered live register.  */
17836   for (i = FIRST_ALTIVEC_REGNO + 20; i <= LAST_ALTIVEC_REGNO; ++i)
17837     if (df_regs_ever_live_p (i))
17838       break;
17839
17840   return i;
17841 }
17842
17843 /* Return a 32-bit mask of the AltiVec registers we need to set in
17844    VRSAVE.  Bit n of the return value is 1 if Vn is live.  The MSB in
17845    the 32-bit word is 0.  */
17846
17847 static unsigned int
17848 compute_vrsave_mask (void)
17849 {
17850   unsigned int i, mask = 0;
17851
17852   /* On Darwin, the unwind routines are compiled without
17853      TARGET_ALTIVEC, and use save_world to save/restore the
17854      call-saved altivec registers when necessary.  */
17855   if (DEFAULT_ABI == ABI_DARWIN && crtl->calls_eh_return
17856       && ! TARGET_ALTIVEC)
17857     mask |= 0xFFF;
17858
17859   /* First, find out if we use _any_ altivec registers.  */
17860   for (i = FIRST_ALTIVEC_REGNO; i <= LAST_ALTIVEC_REGNO; ++i)
17861     if (df_regs_ever_live_p (i))
17862       mask |= ALTIVEC_REG_BIT (i);
17863
17864   if (mask == 0)
17865     return mask;
17866
17867   /* Next, remove the argument registers from the set.  These must
17868      be in the VRSAVE mask set by the caller, so we don't need to add
17869      them in again.  More importantly, the mask we compute here is
17870      used to generate CLOBBERs in the set_vrsave insn, and we do not
17871      wish the argument registers to die.  */
17872   for (i = crtl->args.info.vregno - 1; i >= ALTIVEC_ARG_MIN_REG; --i)
17873     mask &= ~ALTIVEC_REG_BIT (i);
17874
17875   /* Similarly, remove the return value from the set.  */
17876   {
17877     bool yes = false;
17878     diddle_return_value (is_altivec_return_reg, &yes);
17879     if (yes)
17880       mask &= ~ALTIVEC_REG_BIT (ALTIVEC_ARG_RETURN);
17881   }
17882
17883   return mask;
17884 }
17885
17886 /* For a very restricted set of circumstances, we can cut down the
17887    size of prologues/epilogues by calling our own save/restore-the-world
17888    routines.  */
17889
17890 static void
17891 compute_save_world_info (rs6000_stack_t *info_ptr)
17892 {
17893   info_ptr->world_save_p = 1;
17894   info_ptr->world_save_p
17895     = (WORLD_SAVE_P (info_ptr)
17896        && DEFAULT_ABI == ABI_DARWIN
17897        && !cfun->has_nonlocal_label
17898        && info_ptr->first_fp_reg_save == FIRST_SAVED_FP_REGNO
17899        && info_ptr->first_gp_reg_save == FIRST_SAVED_GP_REGNO
17900        && info_ptr->first_altivec_reg_save == FIRST_SAVED_ALTIVEC_REGNO
17901        && info_ptr->cr_save_p);
17902
17903   /* This will not work in conjunction with sibcalls.  Make sure there
17904      are none.  (This check is expensive, but seldom executed.) */
17905   if (WORLD_SAVE_P (info_ptr))
17906     {
17907       rtx insn;
17908       for ( insn = get_last_insn_anywhere (); insn; insn = PREV_INSN (insn))
17909         if ( GET_CODE (insn) == CALL_INSN
17910              && SIBLING_CALL_P (insn))
17911           {
17912             info_ptr->world_save_p = 0;
17913             break;
17914           }
17915     }
17916
17917   if (WORLD_SAVE_P (info_ptr))
17918     {
17919       /* Even if we're not touching VRsave, make sure there's room on the
17920          stack for it, if it looks like we're calling SAVE_WORLD, which
17921          will attempt to save it. */
17922       info_ptr->vrsave_size  = 4;
17923
17924       /* If we are going to save the world, we need to save the link register too.  */
17925       info_ptr->lr_save_p = 1;
17926
17927       /* "Save" the VRsave register too if we're saving the world.  */
17928       if (info_ptr->vrsave_mask == 0)
17929         info_ptr->vrsave_mask = compute_vrsave_mask ();
17930
17931       /* Because the Darwin register save/restore routines only handle
17932          F14 .. F31 and V20 .. V31 as per the ABI, perform a consistency
17933          check.  */
17934       gcc_assert (info_ptr->first_fp_reg_save >= FIRST_SAVED_FP_REGNO
17935                   && (info_ptr->first_altivec_reg_save
17936                       >= FIRST_SAVED_ALTIVEC_REGNO));
17937     }
17938   return;
17939 }
17940
17941
17942 static void
17943 is_altivec_return_reg (rtx reg, void *xyes)
17944 {
17945   bool *yes = (bool *) xyes;
17946   if (REGNO (reg) == ALTIVEC_ARG_RETURN)
17947     *yes = true;
17948 }
17949
17950 \f
17951 /* Determine the strategy for savings/restoring registers.  */
17952
17953 enum {
17954   SAVRES_MULTIPLE = 0x1,
17955   SAVE_INLINE_FPRS = 0x2,
17956   SAVE_INLINE_GPRS = 0x4,
17957   REST_INLINE_FPRS = 0x8,
17958   REST_INLINE_GPRS = 0x10,
17959   SAVE_NOINLINE_GPRS_SAVES_LR = 0x20,
17960   SAVE_NOINLINE_FPRS_SAVES_LR = 0x40,
17961   REST_NOINLINE_FPRS_DOESNT_RESTORE_LR = 0x80
17962 };
17963
17964 static int
17965 rs6000_savres_strategy (rs6000_stack_t *info,
17966                         bool using_static_chain_p)
17967 {
17968   int strategy = 0;
17969
17970   if (TARGET_MULTIPLE
17971       && !TARGET_POWERPC64
17972       && !(TARGET_SPE_ABI && info->spe_64bit_regs_used)
17973       && info->first_gp_reg_save < 31
17974       && no_global_regs_above (info->first_gp_reg_save, /*gpr=*/true))
17975     strategy |= SAVRES_MULTIPLE;
17976
17977   if (crtl->calls_eh_return
17978       || cfun->machine->ra_need_lr
17979       || info->total_size > 32767)
17980     strategy |= (SAVE_INLINE_FPRS | REST_INLINE_FPRS
17981                  | SAVE_INLINE_GPRS | REST_INLINE_GPRS);
17982
17983   if (info->first_fp_reg_save == 64
17984       || FP_SAVE_INLINE (info->first_fp_reg_save)
17985       /* The out-of-line FP routines use double-precision stores;
17986          we can't use those routines if we don't have such stores.  */
17987       || (TARGET_HARD_FLOAT && !TARGET_DOUBLE_FLOAT)
17988       || !no_global_regs_above (info->first_fp_reg_save, /*gpr=*/false))
17989     strategy |= SAVE_INLINE_FPRS | REST_INLINE_FPRS;
17990
17991   if (info->first_gp_reg_save == 32
17992       || GP_SAVE_INLINE (info->first_gp_reg_save)
17993       || !((strategy & SAVRES_MULTIPLE)
17994            || no_global_regs_above (info->first_gp_reg_save, /*gpr=*/true)))
17995     strategy |= SAVE_INLINE_GPRS | REST_INLINE_GPRS;
17996
17997   /* Don't bother to try to save things out-of-line if r11 is occupied
17998      by the static chain.  It would require too much fiddling and the
17999      static chain is rarely used anyway.  FPRs are saved w.r.t the stack
18000      pointer on Darwin.  */
18001   if (using_static_chain_p)
18002     strategy |= (DEFAULT_ABI == ABI_DARWIN ? 0 : SAVE_INLINE_FPRS)
18003                 | SAVE_INLINE_GPRS;
18004
18005   /* If we are going to use store multiple, then don't even bother
18006      with the out-of-line routines, since the store-multiple
18007      instruction will always be smaller.  */
18008   if ((strategy & SAVRES_MULTIPLE))
18009     strategy |= SAVE_INLINE_GPRS;
18010
18011   /* The situation is more complicated with load multiple.  We'd
18012      prefer to use the out-of-line routines for restores, since the
18013      "exit" out-of-line routines can handle the restore of LR and the
18014      frame teardown.  However if doesn't make sense to use the
18015      out-of-line routine if that is the only reason we'd need to save
18016      LR, and we can't use the "exit" out-of-line gpr restore if we
18017      have saved some fprs; In those cases it is advantageous to use
18018      load multiple when available.  */
18019   if ((strategy & SAVRES_MULTIPLE)
18020       && (!info->lr_save_p
18021           || info->first_fp_reg_save != 64))
18022     strategy |= REST_INLINE_GPRS;
18023
18024   /* We can only use load multiple or the out-of-line routines to
18025      restore if we've used store multiple or out-of-line routines
18026      in the prologue, i.e. if we've saved all the registers from
18027      first_gp_reg_save.  Otherwise, we risk loading garbage.  */
18028   if ((strategy & (SAVE_INLINE_GPRS | SAVRES_MULTIPLE)) == SAVE_INLINE_GPRS)
18029     strategy |= REST_INLINE_GPRS;
18030
18031   /* Saving CR interferes with the exit routines used on the SPE, so
18032      just punt here.  */
18033   if (TARGET_SPE_ABI
18034       && info->spe_64bit_regs_used
18035       && info->cr_save_p)
18036     strategy |= REST_INLINE_GPRS;
18037
18038 #ifdef POWERPC_LINUX
18039   if (TARGET_64BIT)
18040     {
18041       if (!(strategy & SAVE_INLINE_FPRS))
18042         strategy |= SAVE_NOINLINE_FPRS_SAVES_LR;
18043       else if (!(strategy & SAVE_INLINE_GPRS)
18044                && info->first_fp_reg_save == 64)
18045         strategy |= SAVE_NOINLINE_GPRS_SAVES_LR;
18046     }
18047 #else
18048   if (TARGET_AIX && !(strategy & REST_INLINE_FPRS))
18049     strategy |= REST_NOINLINE_FPRS_DOESNT_RESTORE_LR;
18050 #endif
18051   if (TARGET_MACHO && !(strategy & SAVE_INLINE_FPRS))
18052     strategy |= SAVE_NOINLINE_FPRS_SAVES_LR;
18053
18054   return strategy;
18055 }
18056
18057 /* Calculate the stack information for the current function.  This is
18058    complicated by having two separate calling sequences, the AIX calling
18059    sequence and the V.4 calling sequence.
18060
18061    AIX (and Darwin/Mac OS X) stack frames look like:
18062                                                           32-bit  64-bit
18063         SP----> +---------------------------------------+
18064                 | back chain to caller                  | 0       0
18065                 +---------------------------------------+
18066                 | saved CR                              | 4       8 (8-11)
18067                 +---------------------------------------+
18068                 | saved LR                              | 8       16
18069                 +---------------------------------------+
18070                 | reserved for compilers                | 12      24
18071                 +---------------------------------------+
18072                 | reserved for binders                  | 16      32
18073                 +---------------------------------------+
18074                 | saved TOC pointer                     | 20      40
18075                 +---------------------------------------+
18076                 | Parameter save area (P)               | 24      48
18077                 +---------------------------------------+
18078                 | Alloca space (A)                      | 24+P    etc.
18079                 +---------------------------------------+
18080                 | Local variable space (L)              | 24+P+A
18081                 +---------------------------------------+
18082                 | Float/int conversion temporary (X)    | 24+P+A+L
18083                 +---------------------------------------+
18084                 | Save area for AltiVec registers (W)   | 24+P+A+L+X
18085                 +---------------------------------------+
18086                 | AltiVec alignment padding (Y)         | 24+P+A+L+X+W
18087                 +---------------------------------------+
18088                 | Save area for VRSAVE register (Z)     | 24+P+A+L+X+W+Y
18089                 +---------------------------------------+
18090                 | Save area for GP registers (G)        | 24+P+A+X+L+X+W+Y+Z
18091                 +---------------------------------------+
18092                 | Save area for FP registers (F)        | 24+P+A+X+L+X+W+Y+Z+G
18093                 +---------------------------------------+
18094         old SP->| back chain to caller's caller         |
18095                 +---------------------------------------+
18096
18097    The required alignment for AIX configurations is two words (i.e., 8
18098    or 16 bytes).
18099
18100
18101    V.4 stack frames look like:
18102
18103         SP----> +---------------------------------------+
18104                 | back chain to caller                  | 0
18105                 +---------------------------------------+
18106                 | caller's saved LR                     | 4
18107                 +---------------------------------------+
18108                 | Parameter save area (P)               | 8
18109                 +---------------------------------------+
18110                 | Alloca space (A)                      | 8+P
18111                 +---------------------------------------+
18112                 | Varargs save area (V)                 | 8+P+A
18113                 +---------------------------------------+
18114                 | Local variable space (L)              | 8+P+A+V
18115                 +---------------------------------------+
18116                 | Float/int conversion temporary (X)    | 8+P+A+V+L
18117                 +---------------------------------------+
18118                 | Save area for AltiVec registers (W)   | 8+P+A+V+L+X
18119                 +---------------------------------------+
18120                 | AltiVec alignment padding (Y)         | 8+P+A+V+L+X+W
18121                 +---------------------------------------+
18122                 | Save area for VRSAVE register (Z)     | 8+P+A+V+L+X+W+Y
18123                 +---------------------------------------+
18124                 | SPE: area for 64-bit GP registers     |
18125                 +---------------------------------------+
18126                 | SPE alignment padding                 |
18127                 +---------------------------------------+
18128                 | saved CR (C)                          | 8+P+A+V+L+X+W+Y+Z
18129                 +---------------------------------------+
18130                 | Save area for GP registers (G)        | 8+P+A+V+L+X+W+Y+Z+C
18131                 +---------------------------------------+
18132                 | Save area for FP registers (F)        | 8+P+A+V+L+X+W+Y+Z+C+G
18133                 +---------------------------------------+
18134         old SP->| back chain to caller's caller         |
18135                 +---------------------------------------+
18136
18137    The required alignment for V.4 is 16 bytes, or 8 bytes if -meabi is
18138    given.  (But note below and in sysv4.h that we require only 8 and
18139    may round up the size of our stack frame anyways.  The historical
18140    reason is early versions of powerpc-linux which didn't properly
18141    align the stack at program startup.  A happy side-effect is that
18142    -mno-eabi libraries can be used with -meabi programs.)
18143
18144    The EABI configuration defaults to the V.4 layout.  However,
18145    the stack alignment requirements may differ.  If -mno-eabi is not
18146    given, the required stack alignment is 8 bytes; if -mno-eabi is
18147    given, the required alignment is 16 bytes.  (But see V.4 comment
18148    above.)  */
18149
18150 #ifndef ABI_STACK_BOUNDARY
18151 #define ABI_STACK_BOUNDARY STACK_BOUNDARY
18152 #endif
18153
18154 static rs6000_stack_t *
18155 rs6000_stack_info (void)
18156 {
18157   rs6000_stack_t *info_ptr = &stack_info;
18158   int reg_size = TARGET_32BIT ? 4 : 8;
18159   int ehrd_size;
18160   int save_align;
18161   int first_gp;
18162   HOST_WIDE_INT non_fixed_size;
18163   bool using_static_chain_p;
18164
18165   if (reload_completed && info_ptr->reload_completed)
18166     return info_ptr;
18167
18168   memset (info_ptr, 0, sizeof (*info_ptr));
18169   info_ptr->reload_completed = reload_completed;
18170
18171   if (TARGET_SPE)
18172     {
18173       /* Cache value so we don't rescan instruction chain over and over.  */
18174       if (cfun->machine->insn_chain_scanned_p == 0)
18175         cfun->machine->insn_chain_scanned_p
18176           = spe_func_has_64bit_regs_p () + 1;
18177       info_ptr->spe_64bit_regs_used = cfun->machine->insn_chain_scanned_p - 1;
18178     }
18179
18180   /* Select which calling sequence.  */
18181   info_ptr->abi = DEFAULT_ABI;
18182
18183   /* Calculate which registers need to be saved & save area size.  */
18184   info_ptr->first_gp_reg_save = first_reg_to_save ();
18185   /* Assume that we will have to save RS6000_PIC_OFFSET_TABLE_REGNUM,
18186      even if it currently looks like we won't.  Reload may need it to
18187      get at a constant; if so, it will have already created a constant
18188      pool entry for it.  */
18189   if (((TARGET_TOC && TARGET_MINIMAL_TOC)
18190        || (flag_pic == 1 && DEFAULT_ABI == ABI_V4)
18191        || (flag_pic && DEFAULT_ABI == ABI_DARWIN))
18192       && crtl->uses_const_pool
18193       && info_ptr->first_gp_reg_save > RS6000_PIC_OFFSET_TABLE_REGNUM)
18194     first_gp = RS6000_PIC_OFFSET_TABLE_REGNUM;
18195   else
18196     first_gp = info_ptr->first_gp_reg_save;
18197
18198   info_ptr->gp_size = reg_size * (32 - first_gp);
18199
18200   /* For the SPE, we have an additional upper 32-bits on each GPR.
18201      Ideally we should save the entire 64-bits only when the upper
18202      half is used in SIMD instructions.  Since we only record
18203      registers live (not the size they are used in), this proves
18204      difficult because we'd have to traverse the instruction chain at
18205      the right time, taking reload into account.  This is a real pain,
18206      so we opt to save the GPRs in 64-bits always if but one register
18207      gets used in 64-bits.  Otherwise, all the registers in the frame
18208      get saved in 32-bits.
18209
18210      So... since when we save all GPRs (except the SP) in 64-bits, the
18211      traditional GP save area will be empty.  */
18212   if (TARGET_SPE_ABI && info_ptr->spe_64bit_regs_used != 0)
18213     info_ptr->gp_size = 0;
18214
18215   info_ptr->first_fp_reg_save = first_fp_reg_to_save ();
18216   info_ptr->fp_size = 8 * (64 - info_ptr->first_fp_reg_save);
18217
18218   info_ptr->first_altivec_reg_save = first_altivec_reg_to_save ();
18219   info_ptr->altivec_size = 16 * (LAST_ALTIVEC_REGNO + 1
18220                                  - info_ptr->first_altivec_reg_save);
18221
18222   /* Does this function call anything?  */
18223   info_ptr->calls_p = (! current_function_is_leaf
18224                        || cfun->machine->ra_needs_full_frame);
18225
18226   /* Determine if we need to save the condition code registers.  */
18227   if (df_regs_ever_live_p (CR2_REGNO)
18228       || df_regs_ever_live_p (CR3_REGNO)
18229       || df_regs_ever_live_p (CR4_REGNO))
18230     {
18231       info_ptr->cr_save_p = 1;
18232       if (DEFAULT_ABI == ABI_V4)
18233         info_ptr->cr_size = reg_size;
18234     }
18235
18236   /* If the current function calls __builtin_eh_return, then we need
18237      to allocate stack space for registers that will hold data for
18238      the exception handler.  */
18239   if (crtl->calls_eh_return)
18240     {
18241       unsigned int i;
18242       for (i = 0; EH_RETURN_DATA_REGNO (i) != INVALID_REGNUM; ++i)
18243         continue;
18244
18245       /* SPE saves EH registers in 64-bits.  */
18246       ehrd_size = i * (TARGET_SPE_ABI
18247                        && info_ptr->spe_64bit_regs_used != 0
18248                        ? UNITS_PER_SPE_WORD : UNITS_PER_WORD);
18249     }
18250   else
18251     ehrd_size = 0;
18252
18253   /* Determine various sizes.  */
18254   info_ptr->reg_size     = reg_size;
18255   info_ptr->fixed_size   = RS6000_SAVE_AREA;
18256   info_ptr->vars_size    = RS6000_ALIGN (get_frame_size (), 8);
18257   info_ptr->parm_size    = RS6000_ALIGN (crtl->outgoing_args_size,
18258                                          TARGET_ALTIVEC ? 16 : 8);
18259   if (FRAME_GROWS_DOWNWARD)
18260     info_ptr->vars_size
18261       += RS6000_ALIGN (info_ptr->fixed_size + info_ptr->vars_size
18262                        + info_ptr->parm_size,
18263                        ABI_STACK_BOUNDARY / BITS_PER_UNIT)
18264          - (info_ptr->fixed_size + info_ptr->vars_size
18265             + info_ptr->parm_size);
18266
18267   if (TARGET_SPE_ABI && info_ptr->spe_64bit_regs_used != 0)
18268     info_ptr->spe_gp_size = 8 * (32 - first_gp);
18269   else
18270     info_ptr->spe_gp_size = 0;
18271
18272   if (TARGET_ALTIVEC_ABI)
18273     info_ptr->vrsave_mask = compute_vrsave_mask ();
18274   else
18275     info_ptr->vrsave_mask = 0;
18276
18277   if (TARGET_ALTIVEC_VRSAVE && info_ptr->vrsave_mask)
18278     info_ptr->vrsave_size  = 4;
18279   else
18280     info_ptr->vrsave_size  = 0;
18281
18282   compute_save_world_info (info_ptr);
18283
18284   /* Calculate the offsets.  */
18285   switch (DEFAULT_ABI)
18286     {
18287     case ABI_NONE:
18288     default:
18289       gcc_unreachable ();
18290
18291     case ABI_AIX:
18292     case ABI_DARWIN:
18293       info_ptr->fp_save_offset   = - info_ptr->fp_size;
18294       info_ptr->gp_save_offset   = info_ptr->fp_save_offset - info_ptr->gp_size;
18295
18296       if (TARGET_ALTIVEC_ABI)
18297         {
18298           info_ptr->vrsave_save_offset
18299             = info_ptr->gp_save_offset - info_ptr->vrsave_size;
18300
18301           /* Align stack so vector save area is on a quadword boundary.
18302              The padding goes above the vectors.  */
18303           if (info_ptr->altivec_size != 0)
18304             info_ptr->altivec_padding_size
18305               = info_ptr->vrsave_save_offset & 0xF;
18306           else
18307             info_ptr->altivec_padding_size = 0;
18308
18309           info_ptr->altivec_save_offset
18310             = info_ptr->vrsave_save_offset
18311             - info_ptr->altivec_padding_size
18312             - info_ptr->altivec_size;
18313           gcc_assert (info_ptr->altivec_size == 0
18314                       || info_ptr->altivec_save_offset % 16 == 0);
18315
18316           /* Adjust for AltiVec case.  */
18317           info_ptr->ehrd_offset = info_ptr->altivec_save_offset - ehrd_size;
18318         }
18319       else
18320         info_ptr->ehrd_offset      = info_ptr->gp_save_offset - ehrd_size;
18321       info_ptr->cr_save_offset   = reg_size; /* first word when 64-bit.  */
18322       info_ptr->lr_save_offset   = 2*reg_size;
18323       break;
18324
18325     case ABI_V4:
18326       info_ptr->fp_save_offset   = - info_ptr->fp_size;
18327       info_ptr->gp_save_offset   = info_ptr->fp_save_offset - info_ptr->gp_size;
18328       info_ptr->cr_save_offset   = info_ptr->gp_save_offset - info_ptr->cr_size;
18329
18330       if (TARGET_SPE_ABI && info_ptr->spe_64bit_regs_used != 0)
18331         {
18332           /* Align stack so SPE GPR save area is aligned on a
18333              double-word boundary.  */
18334           if (info_ptr->spe_gp_size != 0 && info_ptr->cr_save_offset != 0)
18335             info_ptr->spe_padding_size
18336               = 8 - (-info_ptr->cr_save_offset % 8);
18337           else
18338             info_ptr->spe_padding_size = 0;
18339
18340           info_ptr->spe_gp_save_offset
18341             = info_ptr->cr_save_offset
18342             - info_ptr->spe_padding_size
18343             - info_ptr->spe_gp_size;
18344
18345           /* Adjust for SPE case.  */
18346           info_ptr->ehrd_offset = info_ptr->spe_gp_save_offset;
18347         }
18348       else if (TARGET_ALTIVEC_ABI)
18349         {
18350           info_ptr->vrsave_save_offset
18351             = info_ptr->cr_save_offset - info_ptr->vrsave_size;
18352
18353           /* Align stack so vector save area is on a quadword boundary.  */
18354           if (info_ptr->altivec_size != 0)
18355             info_ptr->altivec_padding_size
18356               = 16 - (-info_ptr->vrsave_save_offset % 16);
18357           else
18358             info_ptr->altivec_padding_size = 0;
18359
18360           info_ptr->altivec_save_offset
18361             = info_ptr->vrsave_save_offset
18362             - info_ptr->altivec_padding_size
18363             - info_ptr->altivec_size;
18364
18365           /* Adjust for AltiVec case.  */
18366           info_ptr->ehrd_offset = info_ptr->altivec_save_offset;
18367         }
18368       else
18369         info_ptr->ehrd_offset    = info_ptr->cr_save_offset;
18370       info_ptr->ehrd_offset      -= ehrd_size;
18371       info_ptr->lr_save_offset   = reg_size;
18372       break;
18373     }
18374
18375   save_align = (TARGET_ALTIVEC_ABI || DEFAULT_ABI == ABI_DARWIN) ? 16 : 8;
18376   info_ptr->save_size    = RS6000_ALIGN (info_ptr->fp_size
18377                                          + info_ptr->gp_size
18378                                          + info_ptr->altivec_size
18379                                          + info_ptr->altivec_padding_size
18380                                          + info_ptr->spe_gp_size
18381                                          + info_ptr->spe_padding_size
18382                                          + ehrd_size
18383                                          + info_ptr->cr_size
18384                                          + info_ptr->vrsave_size,
18385                                          save_align);
18386
18387   non_fixed_size         = (info_ptr->vars_size
18388                             + info_ptr->parm_size
18389                             + info_ptr->save_size);
18390
18391   info_ptr->total_size = RS6000_ALIGN (non_fixed_size + info_ptr->fixed_size,
18392                                        ABI_STACK_BOUNDARY / BITS_PER_UNIT);
18393
18394   /* Determine if we need to save the link register.  */
18395   if (info_ptr->calls_p
18396       || (DEFAULT_ABI == ABI_AIX
18397           && crtl->profile
18398           && !TARGET_PROFILE_KERNEL)
18399       || (DEFAULT_ABI == ABI_V4 && cfun->calls_alloca)
18400 #ifdef TARGET_RELOCATABLE
18401       || (TARGET_RELOCATABLE && (get_pool_size () != 0))
18402 #endif
18403       || rs6000_ra_ever_killed ())
18404     info_ptr->lr_save_p = 1;
18405
18406   using_static_chain_p = (cfun->static_chain_decl != NULL_TREE
18407                           && df_regs_ever_live_p (STATIC_CHAIN_REGNUM)
18408                           && call_used_regs[STATIC_CHAIN_REGNUM]);
18409   info_ptr->savres_strategy = rs6000_savres_strategy (info_ptr,
18410                                                       using_static_chain_p);
18411
18412   if (!(info_ptr->savres_strategy & SAVE_INLINE_GPRS)
18413       || !(info_ptr->savres_strategy & SAVE_INLINE_FPRS)
18414       || !(info_ptr->savres_strategy & REST_INLINE_GPRS)
18415       || !(info_ptr->savres_strategy & REST_INLINE_FPRS))
18416     info_ptr->lr_save_p = 1;
18417
18418   if (info_ptr->lr_save_p)
18419     df_set_regs_ever_live (LR_REGNO, true);
18420
18421   /* Determine if we need to allocate any stack frame:
18422
18423      For AIX we need to push the stack if a frame pointer is needed
18424      (because the stack might be dynamically adjusted), if we are
18425      debugging, if we make calls, or if the sum of fp_save, gp_save,
18426      and local variables are more than the space needed to save all
18427      non-volatile registers: 32-bit: 18*8 + 19*4 = 220 or 64-bit: 18*8
18428      + 18*8 = 288 (GPR13 reserved).
18429
18430      For V.4 we don't have the stack cushion that AIX uses, but assume
18431      that the debugger can handle stackless frames.  */
18432
18433   if (info_ptr->calls_p)
18434     info_ptr->push_p = 1;
18435
18436   else if (DEFAULT_ABI == ABI_V4)
18437     info_ptr->push_p = non_fixed_size != 0;
18438
18439   else if (frame_pointer_needed)
18440     info_ptr->push_p = 1;
18441
18442   else if (TARGET_XCOFF && write_symbols != NO_DEBUG)
18443     info_ptr->push_p = 1;
18444
18445   else
18446     info_ptr->push_p = non_fixed_size > (TARGET_32BIT ? 220 : 288);
18447
18448   /* Zero offsets if we're not saving those registers.  */
18449   if (info_ptr->fp_size == 0)
18450     info_ptr->fp_save_offset = 0;
18451
18452   if (info_ptr->gp_size == 0)
18453     info_ptr->gp_save_offset = 0;
18454
18455   if (! TARGET_ALTIVEC_ABI || info_ptr->altivec_size == 0)
18456     info_ptr->altivec_save_offset = 0;
18457
18458   if (! TARGET_ALTIVEC_ABI || info_ptr->vrsave_mask == 0)
18459     info_ptr->vrsave_save_offset = 0;
18460
18461   if (! TARGET_SPE_ABI
18462       || info_ptr->spe_64bit_regs_used == 0
18463       || info_ptr->spe_gp_size == 0)
18464     info_ptr->spe_gp_save_offset = 0;
18465
18466   if (! info_ptr->lr_save_p)
18467     info_ptr->lr_save_offset = 0;
18468
18469   if (! info_ptr->cr_save_p)
18470     info_ptr->cr_save_offset = 0;
18471
18472   return info_ptr;
18473 }
18474
18475 /* Return true if the current function uses any GPRs in 64-bit SIMD
18476    mode.  */
18477
18478 static bool
18479 spe_func_has_64bit_regs_p (void)
18480 {
18481   rtx insns, insn;
18482
18483   /* Functions that save and restore all the call-saved registers will
18484      need to save/restore the registers in 64-bits.  */
18485   if (crtl->calls_eh_return
18486       || cfun->calls_setjmp
18487       || crtl->has_nonlocal_goto)
18488     return true;
18489
18490   insns = get_insns ();
18491
18492   for (insn = NEXT_INSN (insns); insn != NULL_RTX; insn = NEXT_INSN (insn))
18493     {
18494       if (INSN_P (insn))
18495         {
18496           rtx i;
18497
18498           /* FIXME: This should be implemented with attributes...
18499
18500                  (set_attr "spe64" "true")....then,
18501                  if (get_spe64(insn)) return true;
18502
18503              It's the only reliable way to do the stuff below.  */
18504
18505           i = PATTERN (insn);
18506           if (GET_CODE (i) == SET)
18507             {
18508               enum machine_mode mode = GET_MODE (SET_SRC (i));
18509
18510               if (SPE_VECTOR_MODE (mode))
18511                 return true;
18512               if (TARGET_E500_DOUBLE && (mode == DFmode || mode == TFmode))
18513                 return true;
18514             }
18515         }
18516     }
18517
18518   return false;
18519 }
18520
18521 static void
18522 debug_stack_info (rs6000_stack_t *info)
18523 {
18524   const char *abi_string;
18525
18526   if (! info)
18527     info = rs6000_stack_info ();
18528
18529   fprintf (stderr, "\nStack information for function %s:\n",
18530            ((current_function_decl && DECL_NAME (current_function_decl))
18531             ? IDENTIFIER_POINTER (DECL_NAME (current_function_decl))
18532             : "<unknown>"));
18533
18534   switch (info->abi)
18535     {
18536     default:             abi_string = "Unknown";        break;
18537     case ABI_NONE:       abi_string = "NONE";           break;
18538     case ABI_AIX:        abi_string = "AIX";            break;
18539     case ABI_DARWIN:     abi_string = "Darwin";         break;
18540     case ABI_V4:         abi_string = "V.4";            break;
18541     }
18542
18543   fprintf (stderr, "\tABI                 = %5s\n", abi_string);
18544
18545   if (TARGET_ALTIVEC_ABI)
18546     fprintf (stderr, "\tALTIVEC ABI extensions enabled.\n");
18547
18548   if (TARGET_SPE_ABI)
18549     fprintf (stderr, "\tSPE ABI extensions enabled.\n");
18550
18551   if (info->first_gp_reg_save != 32)
18552     fprintf (stderr, "\tfirst_gp_reg_save   = %5d\n", info->first_gp_reg_save);
18553
18554   if (info->first_fp_reg_save != 64)
18555     fprintf (stderr, "\tfirst_fp_reg_save   = %5d\n", info->first_fp_reg_save);
18556
18557   if (info->first_altivec_reg_save <= LAST_ALTIVEC_REGNO)
18558     fprintf (stderr, "\tfirst_altivec_reg_save = %5d\n",
18559              info->first_altivec_reg_save);
18560
18561   if (info->lr_save_p)
18562     fprintf (stderr, "\tlr_save_p           = %5d\n", info->lr_save_p);
18563
18564   if (info->cr_save_p)
18565     fprintf (stderr, "\tcr_save_p           = %5d\n", info->cr_save_p);
18566
18567   if (info->vrsave_mask)
18568     fprintf (stderr, "\tvrsave_mask         = 0x%x\n", info->vrsave_mask);
18569
18570   if (info->push_p)
18571     fprintf (stderr, "\tpush_p              = %5d\n", info->push_p);
18572
18573   if (info->calls_p)
18574     fprintf (stderr, "\tcalls_p             = %5d\n", info->calls_p);
18575
18576   if (info->gp_save_offset)
18577     fprintf (stderr, "\tgp_save_offset      = %5d\n", info->gp_save_offset);
18578
18579   if (info->fp_save_offset)
18580     fprintf (stderr, "\tfp_save_offset      = %5d\n", info->fp_save_offset);
18581
18582   if (info->altivec_save_offset)
18583     fprintf (stderr, "\taltivec_save_offset = %5d\n",
18584              info->altivec_save_offset);
18585
18586   if (info->spe_gp_save_offset)
18587     fprintf (stderr, "\tspe_gp_save_offset  = %5d\n",
18588              info->spe_gp_save_offset);
18589
18590   if (info->vrsave_save_offset)
18591     fprintf (stderr, "\tvrsave_save_offset  = %5d\n",
18592              info->vrsave_save_offset);
18593
18594   if (info->lr_save_offset)
18595     fprintf (stderr, "\tlr_save_offset      = %5d\n", info->lr_save_offset);
18596
18597   if (info->cr_save_offset)
18598     fprintf (stderr, "\tcr_save_offset      = %5d\n", info->cr_save_offset);
18599
18600   if (info->varargs_save_offset)
18601     fprintf (stderr, "\tvarargs_save_offset = %5d\n", info->varargs_save_offset);
18602
18603   if (info->total_size)
18604     fprintf (stderr, "\ttotal_size          = "HOST_WIDE_INT_PRINT_DEC"\n",
18605              info->total_size);
18606
18607   if (info->vars_size)
18608     fprintf (stderr, "\tvars_size           = "HOST_WIDE_INT_PRINT_DEC"\n",
18609              info->vars_size);
18610
18611   if (info->parm_size)
18612     fprintf (stderr, "\tparm_size           = %5d\n", info->parm_size);
18613
18614   if (info->fixed_size)
18615     fprintf (stderr, "\tfixed_size          = %5d\n", info->fixed_size);
18616
18617   if (info->gp_size)
18618     fprintf (stderr, "\tgp_size             = %5d\n", info->gp_size);
18619
18620   if (info->spe_gp_size)
18621     fprintf (stderr, "\tspe_gp_size         = %5d\n", info->spe_gp_size);
18622
18623   if (info->fp_size)
18624     fprintf (stderr, "\tfp_size             = %5d\n", info->fp_size);
18625
18626   if (info->altivec_size)
18627     fprintf (stderr, "\taltivec_size        = %5d\n", info->altivec_size);
18628
18629   if (info->vrsave_size)
18630     fprintf (stderr, "\tvrsave_size         = %5d\n", info->vrsave_size);
18631
18632   if (info->altivec_padding_size)
18633     fprintf (stderr, "\taltivec_padding_size= %5d\n",
18634              info->altivec_padding_size);
18635
18636   if (info->spe_padding_size)
18637     fprintf (stderr, "\tspe_padding_size    = %5d\n",
18638              info->spe_padding_size);
18639
18640   if (info->cr_size)
18641     fprintf (stderr, "\tcr_size             = %5d\n", info->cr_size);
18642
18643   if (info->save_size)
18644     fprintf (stderr, "\tsave_size           = %5d\n", info->save_size);
18645
18646   if (info->reg_size != 4)
18647     fprintf (stderr, "\treg_size            = %5d\n", info->reg_size);
18648
18649     fprintf (stderr, "\tsave-strategy       =  %04x\n", info->savres_strategy);
18650
18651   fprintf (stderr, "\n");
18652 }
18653
18654 rtx
18655 rs6000_return_addr (int count, rtx frame)
18656 {
18657   /* Currently we don't optimize very well between prolog and body
18658      code and for PIC code the code can be actually quite bad, so
18659      don't try to be too clever here.  */
18660   if (count != 0 || (DEFAULT_ABI != ABI_AIX && flag_pic))
18661     {
18662       cfun->machine->ra_needs_full_frame = 1;
18663
18664       return
18665         gen_rtx_MEM
18666           (Pmode,
18667            memory_address
18668            (Pmode,
18669             plus_constant (copy_to_reg
18670                            (gen_rtx_MEM (Pmode,
18671                                          memory_address (Pmode, frame))),
18672                            RETURN_ADDRESS_OFFSET)));
18673     }
18674
18675   cfun->machine->ra_need_lr = 1;
18676   return get_hard_reg_initial_val (Pmode, LR_REGNO);
18677 }
18678
18679 /* Say whether a function is a candidate for sibcall handling or not.  */
18680
18681 static bool
18682 rs6000_function_ok_for_sibcall (tree decl, tree exp)
18683 {
18684   tree fntype;
18685
18686   if (decl)
18687     fntype = TREE_TYPE (decl);
18688   else
18689     fntype = TREE_TYPE (TREE_TYPE (CALL_EXPR_FN (exp)));
18690
18691   /* We can't do it if the called function has more vector parameters
18692      than the current function; there's nowhere to put the VRsave code.  */
18693   if (TARGET_ALTIVEC_ABI
18694       && TARGET_ALTIVEC_VRSAVE
18695       && !(decl && decl == current_function_decl))
18696     {
18697       function_args_iterator args_iter;
18698       tree type;
18699       int nvreg = 0;
18700
18701       /* Functions with vector parameters are required to have a
18702          prototype, so the argument type info must be available
18703          here.  */
18704       FOREACH_FUNCTION_ARGS(fntype, type, args_iter)
18705         if (TREE_CODE (type) == VECTOR_TYPE
18706             && ALTIVEC_OR_VSX_VECTOR_MODE (TYPE_MODE (type)))
18707           nvreg++;
18708
18709       FOREACH_FUNCTION_ARGS(TREE_TYPE (current_function_decl), type, args_iter)
18710         if (TREE_CODE (type) == VECTOR_TYPE
18711             && ALTIVEC_OR_VSX_VECTOR_MODE (TYPE_MODE (type)))
18712           nvreg--;
18713
18714       if (nvreg > 0)
18715         return false;
18716     }
18717
18718   /* Under the AIX ABI we can't allow calls to non-local functions,
18719      because the callee may have a different TOC pointer to the
18720      caller and there's no way to ensure we restore the TOC when we
18721      return.  With the secure-plt SYSV ABI we can't make non-local
18722      calls when -fpic/PIC because the plt call stubs use r30.  */
18723   if (DEFAULT_ABI == ABI_DARWIN
18724       || (DEFAULT_ABI == ABI_AIX
18725           && decl
18726           && !DECL_EXTERNAL (decl)
18727           && (*targetm.binds_local_p) (decl))
18728       || (DEFAULT_ABI == ABI_V4
18729           && (!TARGET_SECURE_PLT
18730               || !flag_pic
18731               || (decl
18732                   && (*targetm.binds_local_p) (decl)))))
18733     {
18734       tree attr_list = TYPE_ATTRIBUTES (fntype);
18735
18736       if (!lookup_attribute ("longcall", attr_list)
18737           || lookup_attribute ("shortcall", attr_list))
18738         return true;
18739     }
18740
18741   return false;
18742 }
18743
18744 /* NULL if INSN insn is valid within a low-overhead loop.
18745    Otherwise return why doloop cannot be applied.
18746    PowerPC uses the COUNT register for branch on table instructions.  */
18747
18748 static const char *
18749 rs6000_invalid_within_doloop (const_rtx insn)
18750 {
18751   if (CALL_P (insn))
18752     return "Function call in the loop.";
18753
18754   if (JUMP_P (insn)
18755       && (GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
18756           || GET_CODE (PATTERN (insn)) == ADDR_VEC))
18757     return "Computed branch in the loop.";
18758
18759   return NULL;
18760 }
18761
18762 static int
18763 rs6000_ra_ever_killed (void)
18764 {
18765   rtx top;
18766   rtx reg;
18767   rtx insn;
18768
18769   if (cfun->is_thunk)
18770     return 0;
18771
18772   if (cfun->machine->lr_save_state)
18773     return cfun->machine->lr_save_state - 1;
18774
18775   /* regs_ever_live has LR marked as used if any sibcalls are present,
18776      but this should not force saving and restoring in the
18777      pro/epilogue.  Likewise, reg_set_between_p thinks a sibcall
18778      clobbers LR, so that is inappropriate.  */
18779
18780   /* Also, the prologue can generate a store into LR that
18781      doesn't really count, like this:
18782
18783         move LR->R0
18784         bcl to set PIC register
18785         move LR->R31
18786         move R0->LR
18787
18788      When we're called from the epilogue, we need to avoid counting
18789      this as a store.  */
18790
18791   push_topmost_sequence ();
18792   top = get_insns ();
18793   pop_topmost_sequence ();
18794   reg = gen_rtx_REG (Pmode, LR_REGNO);
18795
18796   for (insn = NEXT_INSN (top); insn != NULL_RTX; insn = NEXT_INSN (insn))
18797     {
18798       if (INSN_P (insn))
18799         {
18800           if (CALL_P (insn))
18801             {
18802               if (!SIBLING_CALL_P (insn))
18803                 return 1;
18804             }
18805           else if (find_regno_note (insn, REG_INC, LR_REGNO))
18806             return 1;
18807           else if (set_of (reg, insn) != NULL_RTX
18808                    && !prologue_epilogue_contains (insn))
18809             return 1;
18810         }
18811     }
18812   return 0;
18813 }
18814 \f
18815 /* Emit instructions needed to load the TOC register.
18816    This is only needed when TARGET_TOC, TARGET_MINIMAL_TOC, and there is
18817    a constant pool; or for SVR4 -fpic.  */
18818
18819 void
18820 rs6000_emit_load_toc_table (int fromprolog)
18821 {
18822   rtx dest;
18823   dest = gen_rtx_REG (Pmode, RS6000_PIC_OFFSET_TABLE_REGNUM);
18824
18825   if (TARGET_ELF && TARGET_SECURE_PLT && DEFAULT_ABI != ABI_AIX && flag_pic)
18826     {
18827       char buf[30];
18828       rtx lab, tmp1, tmp2, got;
18829
18830       lab = gen_label_rtx ();
18831       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (lab));
18832       lab = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
18833       if (flag_pic == 2)
18834         got = gen_rtx_SYMBOL_REF (Pmode, toc_label_name);
18835       else
18836         got = rs6000_got_sym ();
18837       tmp1 = tmp2 = dest;
18838       if (!fromprolog)
18839         {
18840           tmp1 = gen_reg_rtx (Pmode);
18841           tmp2 = gen_reg_rtx (Pmode);
18842         }
18843       emit_insn (gen_load_toc_v4_PIC_1 (lab));
18844       emit_move_insn (tmp1, gen_rtx_REG (Pmode, LR_REGNO));
18845       emit_insn (gen_load_toc_v4_PIC_3b (tmp2, tmp1, got, lab));
18846       emit_insn (gen_load_toc_v4_PIC_3c (dest, tmp2, got, lab));
18847     }
18848   else if (TARGET_ELF && DEFAULT_ABI == ABI_V4 && flag_pic == 1)
18849     {
18850       emit_insn (gen_load_toc_v4_pic_si ());
18851       emit_move_insn (dest, gen_rtx_REG (Pmode, LR_REGNO));
18852     }
18853   else if (TARGET_ELF && DEFAULT_ABI != ABI_AIX && flag_pic == 2)
18854     {
18855       char buf[30];
18856       rtx temp0 = (fromprolog
18857                    ? gen_rtx_REG (Pmode, 0)
18858                    : gen_reg_rtx (Pmode));
18859
18860       if (fromprolog)
18861         {
18862           rtx symF, symL;
18863
18864           ASM_GENERATE_INTERNAL_LABEL (buf, "LCF", rs6000_pic_labelno);
18865           symF = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
18866
18867           ASM_GENERATE_INTERNAL_LABEL (buf, "LCL", rs6000_pic_labelno);
18868           symL = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
18869
18870           emit_insn (gen_load_toc_v4_PIC_1 (symF));
18871           emit_move_insn (dest, gen_rtx_REG (Pmode, LR_REGNO));
18872           emit_insn (gen_load_toc_v4_PIC_2 (temp0, dest, symL, symF));
18873         }
18874       else
18875         {
18876           rtx tocsym, lab;
18877
18878           tocsym = gen_rtx_SYMBOL_REF (Pmode, toc_label_name);
18879           lab = gen_label_rtx ();
18880           emit_insn (gen_load_toc_v4_PIC_1b (tocsym, lab));
18881           emit_move_insn (dest, gen_rtx_REG (Pmode, LR_REGNO));
18882           if (TARGET_LINK_STACK)
18883             emit_insn (gen_addsi3 (dest, dest, GEN_INT (4)));
18884           emit_move_insn (temp0, gen_rtx_MEM (Pmode, dest));
18885         }
18886       emit_insn (gen_addsi3 (dest, temp0, dest));
18887     }
18888   else if (TARGET_ELF && !TARGET_AIX && flag_pic == 0 && TARGET_MINIMAL_TOC)
18889     {
18890       /* This is for AIX code running in non-PIC ELF32.  */
18891       char buf[30];
18892       rtx realsym;
18893       ASM_GENERATE_INTERNAL_LABEL (buf, "LCTOC", 1);
18894       realsym = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (buf));
18895
18896       emit_insn (gen_elf_high (dest, realsym));
18897       emit_insn (gen_elf_low (dest, dest, realsym));
18898     }
18899   else
18900     {
18901       gcc_assert (DEFAULT_ABI == ABI_AIX);
18902
18903       if (TARGET_32BIT)
18904         emit_insn (gen_load_toc_aix_si (dest));
18905       else
18906         emit_insn (gen_load_toc_aix_di (dest));
18907     }
18908 }
18909
18910 /* Emit instructions to restore the link register after determining where
18911    its value has been stored.  */
18912
18913 void
18914 rs6000_emit_eh_reg_restore (rtx source, rtx scratch)
18915 {
18916   rs6000_stack_t *info = rs6000_stack_info ();
18917   rtx operands[2];
18918
18919   operands[0] = source;
18920   operands[1] = scratch;
18921
18922   if (info->lr_save_p)
18923     {
18924       rtx frame_rtx = stack_pointer_rtx;
18925       HOST_WIDE_INT sp_offset = 0;
18926       rtx tmp;
18927
18928       if (frame_pointer_needed
18929           || cfun->calls_alloca
18930           || info->total_size > 32767)
18931         {
18932           tmp = gen_frame_mem (Pmode, frame_rtx);
18933           emit_move_insn (operands[1], tmp);
18934           frame_rtx = operands[1];
18935         }
18936       else if (info->push_p)
18937         sp_offset = info->total_size;
18938
18939       tmp = plus_constant (frame_rtx, info->lr_save_offset + sp_offset);
18940       tmp = gen_frame_mem (Pmode, tmp);
18941       emit_move_insn (tmp, operands[0]);
18942     }
18943   else
18944     emit_move_insn (gen_rtx_REG (Pmode, LR_REGNO), operands[0]);
18945
18946   /* Freeze lr_save_p.  We've just emitted rtl that depends on the
18947      state of lr_save_p so any change from here on would be a bug.  In
18948      particular, stop rs6000_ra_ever_killed from considering the SET
18949      of lr we may have added just above.  */
18950   cfun->machine->lr_save_state = info->lr_save_p + 1;
18951 }
18952
18953 static GTY(()) alias_set_type set = -1;
18954
18955 alias_set_type
18956 get_TOC_alias_set (void)
18957 {
18958   if (set == -1)
18959     set = new_alias_set ();
18960   return set;
18961 }
18962
18963 /* This returns nonzero if the current function uses the TOC.  This is
18964    determined by the presence of (use (unspec ... UNSPEC_TOC)), which
18965    is generated by the ABI_V4 load_toc_* patterns.  */
18966 #if TARGET_ELF
18967 static int
18968 uses_TOC (void)
18969 {
18970   rtx insn;
18971
18972   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
18973     if (INSN_P (insn))
18974       {
18975         rtx pat = PATTERN (insn);
18976         int i;
18977
18978         if (GET_CODE (pat) == PARALLEL)
18979           for (i = 0; i < XVECLEN (pat, 0); i++)
18980             {
18981               rtx sub = XVECEXP (pat, 0, i);
18982               if (GET_CODE (sub) == USE)
18983                 {
18984                   sub = XEXP (sub, 0);
18985                   if (GET_CODE (sub) == UNSPEC
18986                       && XINT (sub, 1) == UNSPEC_TOC)
18987                     return 1;
18988                 }
18989             }
18990       }
18991   return 0;
18992 }
18993 #endif
18994
18995 rtx
18996 create_TOC_reference (rtx symbol, rtx largetoc_reg)
18997 {
18998   rtx tocrel, tocreg;
18999
19000   if (TARGET_DEBUG_ADDR)
19001     {
19002       if (GET_CODE (symbol) == SYMBOL_REF)
19003         fprintf (stderr, "\ncreate_TOC_reference, (symbol_ref %s)\n",
19004                  XSTR (symbol, 0));
19005       else
19006         {
19007           fprintf (stderr, "\ncreate_TOC_reference, code %s:\n",
19008                    GET_RTX_NAME (GET_CODE (symbol)));
19009           debug_rtx (symbol);
19010         }
19011     }
19012
19013   if (!can_create_pseudo_p ())
19014     df_set_regs_ever_live (TOC_REGISTER, true);
19015
19016   tocrel = gen_rtx_CONST (Pmode,
19017                           gen_rtx_UNSPEC (Pmode, gen_rtvec (1, symbol),
19018                                           UNSPEC_TOCREL));
19019   tocreg = gen_rtx_REG (Pmode, TOC_REGISTER);
19020   if (TARGET_CMODEL != CMODEL_SMALL)
19021     {
19022       rtx hi = gen_rtx_CONST (Pmode,
19023                               gen_rtx_PLUS (Pmode, tocreg,
19024                                             gen_rtx_HIGH (Pmode, tocrel)));
19025       if (largetoc_reg != NULL)
19026         {
19027           emit_move_insn (largetoc_reg, hi);
19028           hi = largetoc_reg;
19029         }
19030       return gen_rtx_LO_SUM (Pmode, hi, copy_rtx (tocrel));
19031     }
19032   else
19033     return gen_rtx_PLUS (Pmode, tocreg, tocrel);
19034 }
19035
19036 /* Issue assembly directives that create a reference to the given DWARF
19037    FRAME_TABLE_LABEL from the current function section.  */
19038 void
19039 rs6000_aix_asm_output_dwarf_table_ref (char * frame_table_label)
19040 {
19041   fprintf (asm_out_file, "\t.ref %s\n",
19042            TARGET_STRIP_NAME_ENCODING (frame_table_label));
19043 }
19044 \f
19045 /* This ties together stack memory (MEM with an alias set of frame_alias_set)
19046    and the change to the stack pointer.  */
19047
19048 static void
19049 rs6000_emit_stack_tie (void)
19050 {
19051   rtx mem = gen_frame_mem (BLKmode,
19052                            gen_rtx_REG (Pmode, STACK_POINTER_REGNUM));
19053
19054   emit_insn (gen_stack_tie (mem));
19055 }
19056
19057 /* Emit the correct code for allocating stack space, as insns.
19058    If COPY_REG, make sure a copy of the old frame is left there.
19059    The generated code may use hard register 0 as a temporary.  */
19060
19061 static void
19062 rs6000_emit_allocate_stack (HOST_WIDE_INT size, rtx copy_reg)
19063 {
19064   rtx insn;
19065   rtx stack_reg = gen_rtx_REG (Pmode, STACK_POINTER_REGNUM);
19066   rtx tmp_reg = gen_rtx_REG (Pmode, 0);
19067   rtx todec = gen_int_mode (-size, Pmode);
19068   rtx par, set, mem;
19069
19070   if (INTVAL (todec) != -size)
19071     {
19072       warning (0, "stack frame too large");
19073       emit_insn (gen_trap ());
19074       return;
19075     }
19076
19077   if (crtl->limit_stack)
19078     {
19079       if (REG_P (stack_limit_rtx)
19080           && REGNO (stack_limit_rtx) > 1
19081           && REGNO (stack_limit_rtx) <= 31)
19082         {
19083           emit_insn (gen_add3_insn (tmp_reg, stack_limit_rtx, GEN_INT (size)));
19084           emit_insn (gen_cond_trap (LTU, stack_reg, tmp_reg,
19085                                     const0_rtx));
19086         }
19087       else if (GET_CODE (stack_limit_rtx) == SYMBOL_REF
19088                && TARGET_32BIT
19089                && DEFAULT_ABI == ABI_V4)
19090         {
19091           rtx toload = gen_rtx_CONST (VOIDmode,
19092                                       gen_rtx_PLUS (Pmode,
19093                                                     stack_limit_rtx,
19094                                                     GEN_INT (size)));
19095
19096           emit_insn (gen_elf_high (tmp_reg, toload));
19097           emit_insn (gen_elf_low (tmp_reg, tmp_reg, toload));
19098           emit_insn (gen_cond_trap (LTU, stack_reg, tmp_reg,
19099                                     const0_rtx));
19100         }
19101       else
19102         warning (0, "stack limit expression is not supported");
19103     }
19104
19105   if (copy_reg)
19106     emit_move_insn (copy_reg, stack_reg);
19107
19108   if (size > 32767)
19109     {
19110       /* Need a note here so that try_split doesn't get confused.  */
19111       if (get_last_insn () == NULL_RTX)
19112         emit_note (NOTE_INSN_DELETED);
19113       insn = emit_move_insn (tmp_reg, todec);
19114       try_split (PATTERN (insn), insn, 0);
19115       todec = tmp_reg;
19116     }
19117
19118   insn = emit_insn (TARGET_32BIT
19119                     ? gen_movsi_update_stack (stack_reg, stack_reg,
19120                                         todec, stack_reg)
19121                     : gen_movdi_di_update_stack (stack_reg, stack_reg,
19122                                            todec, stack_reg));
19123   /* Since we didn't use gen_frame_mem to generate the MEM, grab
19124      it now and set the alias set/attributes. The above gen_*_update
19125      calls will generate a PARALLEL with the MEM set being the first
19126      operation. */
19127   par = PATTERN (insn);
19128   gcc_assert (GET_CODE (par) == PARALLEL);
19129   set = XVECEXP (par, 0, 0);
19130   gcc_assert (GET_CODE (set) == SET);
19131   mem = SET_DEST (set);
19132   gcc_assert (MEM_P (mem));
19133   MEM_NOTRAP_P (mem) = 1;
19134   set_mem_alias_set (mem, get_frame_alias_set ());
19135
19136   RTX_FRAME_RELATED_P (insn) = 1;
19137   add_reg_note (insn, REG_FRAME_RELATED_EXPR,
19138                 gen_rtx_SET (VOIDmode, stack_reg,
19139                              gen_rtx_PLUS (Pmode, stack_reg,
19140                                            GEN_INT (-size))));
19141 }
19142
19143 #define PROBE_INTERVAL (1 << STACK_CHECK_PROBE_INTERVAL_EXP)
19144
19145 #if PROBE_INTERVAL > 32768
19146 #error Cannot use indexed addressing mode for stack probing
19147 #endif
19148
19149 /* Emit code to probe a range of stack addresses from FIRST to FIRST+SIZE,
19150    inclusive.  These are offsets from the current stack pointer.  */
19151
19152 static void
19153 rs6000_emit_probe_stack_range (HOST_WIDE_INT first, HOST_WIDE_INT size)
19154 {
19155   /* See if we have a constant small number of probes to generate.  If so,
19156      that's the easy case.  */
19157   if (first + size <= 32768)
19158     {
19159       HOST_WIDE_INT i;
19160
19161       /* Probe at FIRST + N * PROBE_INTERVAL for values of N from 1 until
19162          it exceeds SIZE.  If only one probe is needed, this will not
19163          generate any code.  Then probe at FIRST + SIZE.  */
19164       for (i = PROBE_INTERVAL; i < size; i += PROBE_INTERVAL)
19165         emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + i)));
19166
19167       emit_stack_probe (plus_constant (stack_pointer_rtx, -(first + size)));
19168     }
19169
19170   /* Otherwise, do the same as above, but in a loop.  Note that we must be
19171      extra careful with variables wrapping around because we might be at
19172      the very top (or the very bottom) of the address space and we have
19173      to be able to handle this case properly; in particular, we use an
19174      equality test for the loop condition.  */
19175   else
19176     {
19177       HOST_WIDE_INT rounded_size;
19178       rtx r12 = gen_rtx_REG (Pmode, 12);
19179       rtx r0 = gen_rtx_REG (Pmode, 0);
19180
19181       /* Sanity check for the addressing mode we're going to use.  */
19182       gcc_assert (first <= 32768);
19183
19184       /* Step 1: round SIZE to the previous multiple of the interval.  */
19185
19186       rounded_size = size & -PROBE_INTERVAL;
19187
19188
19189       /* Step 2: compute initial and final value of the loop counter.  */
19190
19191       /* TEST_ADDR = SP + FIRST.  */
19192       emit_insn (gen_rtx_SET (VOIDmode, r12,
19193                               plus_constant (stack_pointer_rtx, -first)));
19194
19195       /* LAST_ADDR = SP + FIRST + ROUNDED_SIZE.  */
19196       if (rounded_size > 32768)
19197         {
19198           emit_move_insn (r0, GEN_INT (-rounded_size));
19199           emit_insn (gen_rtx_SET (VOIDmode, r0,
19200                                   gen_rtx_PLUS (Pmode, r12, r0)));
19201         }
19202       else
19203         emit_insn (gen_rtx_SET (VOIDmode, r0,
19204                                 plus_constant (r12, -rounded_size)));
19205
19206
19207       /* Step 3: the loop
19208
19209          while (TEST_ADDR != LAST_ADDR)
19210            {
19211              TEST_ADDR = TEST_ADDR + PROBE_INTERVAL
19212              probe at TEST_ADDR
19213            }
19214
19215          probes at FIRST + N * PROBE_INTERVAL for values of N from 1
19216          until it is equal to ROUNDED_SIZE.  */
19217
19218       if (TARGET_64BIT)
19219         emit_insn (gen_probe_stack_rangedi (r12, r12, r0));
19220       else
19221         emit_insn (gen_probe_stack_rangesi (r12, r12, r0));
19222
19223
19224       /* Step 4: probe at FIRST + SIZE if we cannot assert at compile-time
19225          that SIZE is equal to ROUNDED_SIZE.  */
19226
19227       if (size != rounded_size)
19228         emit_stack_probe (plus_constant (r12, rounded_size - size));
19229     }
19230 }
19231
19232 /* Probe a range of stack addresses from REG1 to REG2 inclusive.  These are
19233    absolute addresses.  */
19234
19235 const char *
19236 output_probe_stack_range (rtx reg1, rtx reg2)
19237 {
19238   static int labelno = 0;
19239   char loop_lab[32], end_lab[32];
19240   rtx xops[2];
19241
19242   ASM_GENERATE_INTERNAL_LABEL (loop_lab, "LPSRL", labelno);
19243   ASM_GENERATE_INTERNAL_LABEL (end_lab, "LPSRE", labelno++);
19244
19245   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, loop_lab);
19246
19247   /* Jump to END_LAB if TEST_ADDR == LAST_ADDR.  */
19248   xops[0] = reg1;
19249   xops[1] = reg2;
19250   if (TARGET_64BIT)
19251     output_asm_insn ("{cmp|cmpd} 0,%0,%1", xops);
19252   else
19253     output_asm_insn ("{cmp|cmpw} 0,%0,%1", xops);
19254
19255   fputs ("\tbeq 0,", asm_out_file);
19256   assemble_name_raw (asm_out_file, end_lab);
19257   fputc ('\n', asm_out_file);
19258
19259   /* TEST_ADDR = TEST_ADDR + PROBE_INTERVAL.  */
19260   xops[1] = GEN_INT (-PROBE_INTERVAL);
19261   output_asm_insn ("{cal %0,%1(%0)|addi %0,%0,%1}", xops);
19262
19263   /* Probe at TEST_ADDR and branch.  */
19264   xops[1] = gen_rtx_REG (Pmode, 0);
19265   output_asm_insn ("{st|stw} %1,0(%0)", xops);
19266   fprintf (asm_out_file, "\tb ");
19267   assemble_name_raw (asm_out_file, loop_lab);
19268   fputc ('\n', asm_out_file);
19269
19270   ASM_OUTPUT_INTERNAL_LABEL (asm_out_file, end_lab);
19271
19272   return "";
19273 }
19274
19275 /* Add to 'insn' a note which is PATTERN (INSN) but with REG replaced
19276    with (plus:P (reg 1) VAL), and with REG2 replaced with RREG if REG2
19277    is not NULL.  It would be nice if dwarf2out_frame_debug_expr could
19278    deduce these equivalences by itself so it wasn't necessary to hold
19279    its hand so much.  */
19280
19281 static rtx
19282 rs6000_frame_related (rtx insn, rtx reg, HOST_WIDE_INT val,
19283                       rtx reg2, rtx rreg)
19284 {
19285   rtx real, temp;
19286
19287   /* copy_rtx will not make unique copies of registers, so we need to
19288      ensure we don't have unwanted sharing here.  */
19289   if (reg == reg2)
19290     reg = gen_raw_REG (GET_MODE (reg), REGNO (reg));
19291
19292   if (reg == rreg)
19293     reg = gen_raw_REG (GET_MODE (reg), REGNO (reg));
19294
19295   real = copy_rtx (PATTERN (insn));
19296
19297   if (reg2 != NULL_RTX)
19298     real = replace_rtx (real, reg2, rreg);
19299
19300   real = replace_rtx (real, reg,
19301                       gen_rtx_PLUS (Pmode, gen_rtx_REG (Pmode,
19302                                                         STACK_POINTER_REGNUM),
19303                                     GEN_INT (val)));
19304
19305   /* We expect that 'real' is either a SET or a PARALLEL containing
19306      SETs (and possibly other stuff).  In a PARALLEL, all the SETs
19307      are important so they all have to be marked RTX_FRAME_RELATED_P.  */
19308
19309   if (GET_CODE (real) == SET)
19310     {
19311       rtx set = real;
19312
19313       temp = simplify_rtx (SET_SRC (set));
19314       if (temp)
19315         SET_SRC (set) = temp;
19316       temp = simplify_rtx (SET_DEST (set));
19317       if (temp)
19318         SET_DEST (set) = temp;
19319       if (GET_CODE (SET_DEST (set)) == MEM)
19320         {
19321           temp = simplify_rtx (XEXP (SET_DEST (set), 0));
19322           if (temp)
19323             XEXP (SET_DEST (set), 0) = temp;
19324         }
19325     }
19326   else
19327     {
19328       int i;
19329
19330       gcc_assert (GET_CODE (real) == PARALLEL);
19331       for (i = 0; i < XVECLEN (real, 0); i++)
19332         if (GET_CODE (XVECEXP (real, 0, i)) == SET)
19333           {
19334             rtx set = XVECEXP (real, 0, i);
19335
19336             temp = simplify_rtx (SET_SRC (set));
19337             if (temp)
19338               SET_SRC (set) = temp;
19339             temp = simplify_rtx (SET_DEST (set));
19340             if (temp)
19341               SET_DEST (set) = temp;
19342             if (GET_CODE (SET_DEST (set)) == MEM)
19343               {
19344                 temp = simplify_rtx (XEXP (SET_DEST (set), 0));
19345                 if (temp)
19346                   XEXP (SET_DEST (set), 0) = temp;
19347               }
19348             RTX_FRAME_RELATED_P (set) = 1;
19349           }
19350     }
19351
19352   RTX_FRAME_RELATED_P (insn) = 1;
19353   add_reg_note (insn, REG_FRAME_RELATED_EXPR, real);
19354
19355   return insn;
19356 }
19357
19358 /* Returns an insn that has a vrsave set operation with the
19359    appropriate CLOBBERs.  */
19360
19361 static rtx
19362 generate_set_vrsave (rtx reg, rs6000_stack_t *info, int epiloguep)
19363 {
19364   int nclobs, i;
19365   rtx insn, clobs[TOTAL_ALTIVEC_REGS + 1];
19366   rtx vrsave = gen_rtx_REG (SImode, VRSAVE_REGNO);
19367
19368   clobs[0]
19369     = gen_rtx_SET (VOIDmode,
19370                    vrsave,
19371                    gen_rtx_UNSPEC_VOLATILE (SImode,
19372                                             gen_rtvec (2, reg, vrsave),
19373                                             UNSPECV_SET_VRSAVE));
19374
19375   nclobs = 1;
19376
19377   /* We need to clobber the registers in the mask so the scheduler
19378      does not move sets to VRSAVE before sets of AltiVec registers.
19379
19380      However, if the function receives nonlocal gotos, reload will set
19381      all call saved registers live.  We will end up with:
19382
19383         (set (reg 999) (mem))
19384         (parallel [ (set (reg vrsave) (unspec blah))
19385                     (clobber (reg 999))])
19386
19387      The clobber will cause the store into reg 999 to be dead, and
19388      flow will attempt to delete an epilogue insn.  In this case, we
19389      need an unspec use/set of the register.  */
19390
19391   for (i = FIRST_ALTIVEC_REGNO; i <= LAST_ALTIVEC_REGNO; ++i)
19392     if (info->vrsave_mask & ALTIVEC_REG_BIT (i))
19393       {
19394         if (!epiloguep || call_used_regs [i])
19395           clobs[nclobs++] = gen_rtx_CLOBBER (VOIDmode,
19396                                              gen_rtx_REG (V4SImode, i));
19397         else
19398           {
19399             rtx reg = gen_rtx_REG (V4SImode, i);
19400
19401             clobs[nclobs++]
19402               = gen_rtx_SET (VOIDmode,
19403                              reg,
19404                              gen_rtx_UNSPEC (V4SImode,
19405                                              gen_rtvec (1, reg), 27));
19406           }
19407       }
19408
19409   insn = gen_rtx_PARALLEL (VOIDmode, rtvec_alloc (nclobs));
19410
19411   for (i = 0; i < nclobs; ++i)
19412     XVECEXP (insn, 0, i) = clobs[i];
19413
19414   return insn;
19415 }
19416
19417 /* Save a register into the frame, and emit RTX_FRAME_RELATED_P notes.
19418    Save REGNO into [FRAME_REG + OFFSET] in mode MODE.  */
19419
19420 static rtx
19421 emit_frame_save (rtx frame_reg, rtx frame_ptr, enum machine_mode mode,
19422                  unsigned int regno, int offset, HOST_WIDE_INT total_size)
19423 {
19424   rtx reg, offset_rtx, insn, mem, addr, int_rtx;
19425   rtx replacea, replaceb;
19426
19427   int_rtx = GEN_INT (offset);
19428
19429   /* Some cases that need register indexed addressing.  */
19430   if ((TARGET_ALTIVEC_ABI && ALTIVEC_VECTOR_MODE (mode))
19431       || (TARGET_VSX && ALTIVEC_OR_VSX_VECTOR_MODE (mode))
19432       || (TARGET_E500_DOUBLE && mode == DFmode)
19433       || (TARGET_SPE_ABI
19434           && SPE_VECTOR_MODE (mode)
19435           && !SPE_CONST_OFFSET_OK (offset)))
19436     {
19437       /* Whomever calls us must make sure r11 is available in the
19438          flow path of instructions in the prologue.  */
19439       offset_rtx = gen_rtx_REG (Pmode, 11);
19440       emit_move_insn (offset_rtx, int_rtx);
19441
19442       replacea = offset_rtx;
19443       replaceb = int_rtx;
19444     }
19445   else
19446     {
19447       offset_rtx = int_rtx;
19448       replacea = NULL_RTX;
19449       replaceb = NULL_RTX;
19450     }
19451
19452   reg = gen_rtx_REG (mode, regno);
19453   addr = gen_rtx_PLUS (Pmode, frame_reg, offset_rtx);
19454   mem = gen_frame_mem (mode, addr);
19455
19456   insn = emit_move_insn (mem, reg);
19457
19458   return rs6000_frame_related (insn, frame_ptr, total_size, replacea, replaceb);
19459 }
19460
19461 /* Emit an offset memory reference suitable for a frame store, while
19462    converting to a valid addressing mode.  */
19463
19464 static rtx
19465 gen_frame_mem_offset (enum machine_mode mode, rtx reg, int offset)
19466 {
19467   rtx int_rtx, offset_rtx;
19468
19469   int_rtx = GEN_INT (offset);
19470
19471   if ((TARGET_SPE_ABI && SPE_VECTOR_MODE (mode))
19472       || (TARGET_E500_DOUBLE && mode == DFmode))
19473     {
19474       offset_rtx = gen_rtx_REG (Pmode, FIXED_SCRATCH);
19475       emit_move_insn (offset_rtx, int_rtx);
19476     }
19477   else
19478     offset_rtx = int_rtx;
19479
19480   return gen_frame_mem (mode, gen_rtx_PLUS (Pmode, reg, offset_rtx));
19481 }
19482
19483 /* Look for user-defined global regs.  We should not save and restore these,
19484    and cannot use stmw/lmw if there are any in its range.  */
19485
19486 static bool
19487 no_global_regs_above (int first, bool gpr)
19488 {
19489   int i;
19490   int last = gpr ? 32 : 64;
19491   for (i = first; i < last; i++)
19492     if (global_regs[i])
19493       return false;
19494   return true;
19495 }
19496
19497 #ifndef TARGET_FIX_AND_CONTINUE
19498 #define TARGET_FIX_AND_CONTINUE 0
19499 #endif
19500
19501 /* It's really GPR 13 and FPR 14, but we need the smaller of the two.  */
19502 #define FIRST_SAVRES_REGISTER FIRST_SAVED_GP_REGNO
19503 #define LAST_SAVRES_REGISTER 31
19504 #define N_SAVRES_REGISTERS (LAST_SAVRES_REGISTER - FIRST_SAVRES_REGISTER + 1)
19505
19506 static GTY(()) rtx savres_routine_syms[N_SAVRES_REGISTERS][8];
19507
19508 /* Temporary holding space for an out-of-line register save/restore
19509    routine name.  */
19510 static char savres_routine_name[30];
19511
19512 /* Return the name for an out-of-line register save/restore routine.
19513    We are saving/restoring GPRs if GPR is true.  */
19514
19515 static char *
19516 rs6000_savres_routine_name (rs6000_stack_t *info, int regno,
19517                             bool savep, bool gpr, bool lr)
19518 {
19519   const char *prefix = "";
19520   const char *suffix = "";
19521
19522   /* Different targets are supposed to define
19523      {SAVE,RESTORE}_FP_{PREFIX,SUFFIX} with the idea that the needed
19524      routine name could be defined with:
19525
19526      sprintf (name, "%s%d%s", SAVE_FP_PREFIX, regno, SAVE_FP_SUFFIX)
19527
19528      This is a nice idea in practice, but in reality, things are
19529      complicated in several ways:
19530
19531      - ELF targets have save/restore routines for GPRs.
19532
19533      - SPE targets use different prefixes for 32/64-bit registers, and
19534        neither of them fit neatly in the FOO_{PREFIX,SUFFIX} regimen.
19535
19536      - PPC64 ELF targets have routines for save/restore of GPRs that
19537        differ in what they do with the link register, so having a set
19538        prefix doesn't work.  (We only use one of the save routines at
19539        the moment, though.)
19540
19541      - PPC32 elf targets have "exit" versions of the restore routines
19542        that restore the link register and can save some extra space.
19543        These require an extra suffix.  (There are also "tail" versions
19544        of the restore routines and "GOT" versions of the save routines,
19545        but we don't generate those at present.  Same problems apply,
19546        though.)
19547
19548      We deal with all this by synthesizing our own prefix/suffix and
19549      using that for the simple sprintf call shown above.  */
19550   if (TARGET_SPE)
19551     {
19552       /* No floating point saves on the SPE.  */
19553       gcc_assert (gpr);
19554
19555       if (savep)
19556         prefix = info->spe_64bit_regs_used ? "_save64gpr_" : "_save32gpr_";
19557       else
19558         prefix = info->spe_64bit_regs_used ? "_rest64gpr_" : "_rest32gpr_";
19559
19560       if (lr)
19561         suffix = "_x";
19562     }
19563   else if (DEFAULT_ABI == ABI_V4)
19564     {
19565       if (TARGET_64BIT)
19566         goto aix_names;
19567
19568       if (gpr)
19569         prefix = savep ? "_savegpr_" : "_restgpr_";
19570       else
19571         prefix = savep ? "_savefpr_" : "_restfpr_";
19572
19573       if (lr)
19574         suffix = "_x";
19575     }
19576   else if (DEFAULT_ABI == ABI_AIX)
19577     {
19578 #ifndef POWERPC_LINUX
19579       /* No out-of-line save/restore routines for GPRs on AIX.  */
19580       gcc_assert (!TARGET_AIX || !gpr);
19581 #endif
19582
19583     aix_names:
19584       if (gpr)
19585         prefix = (savep
19586                   ? (lr ? "_savegpr0_" : "_savegpr1_")
19587                   : (lr ? "_restgpr0_" : "_restgpr1_"));
19588 #ifdef POWERPC_LINUX
19589       else if (lr)
19590         prefix = (savep ? "_savefpr_" : "_restfpr_");
19591 #endif
19592       else
19593         {
19594           prefix = savep ? SAVE_FP_PREFIX : RESTORE_FP_PREFIX;
19595           suffix = savep ? SAVE_FP_SUFFIX : RESTORE_FP_SUFFIX;
19596         }
19597     }
19598
19599    if (DEFAULT_ABI == ABI_DARWIN)
19600     {
19601       /* The Darwin approach is (slightly) different, in order to be
19602          compatible with code generated by the system toolchain.  There is a
19603          single symbol for the start of save sequence, and the code here
19604          embeds an offset into that code on the basis of the first register
19605          to be saved.  */
19606       prefix = savep ? "save" : "rest" ;
19607       if (gpr)
19608         sprintf (savres_routine_name, "*%sGPR%s%s%.0d ; %s r%d-r31",
19609                prefix, (lr ? "x" : ""), (regno == 13 ? "" : "+"),
19610                (regno-13) * 4, prefix, regno);
19611       else
19612         sprintf (savres_routine_name, "*%sFP%s%.0d ; %s f%d-f31",
19613                prefix, (regno == 14 ? "" : "+"),  (regno-14) * 4, prefix, regno);
19614     }
19615   else
19616     sprintf (savres_routine_name, "%s%d%s", prefix, regno, suffix);
19617
19618   return savres_routine_name;
19619 }
19620
19621 /* Return an RTL SYMBOL_REF for an out-of-line register save/restore routine.
19622    We are saving/restoring GPRs if GPR is true.  */
19623
19624 static rtx
19625 rs6000_savres_routine_sym (rs6000_stack_t *info, bool savep,
19626                            bool gpr, bool lr)
19627 {
19628   int regno = gpr ? info->first_gp_reg_save : (info->first_fp_reg_save - 32);
19629   rtx sym;
19630   int select = ((savep ? 1 : 0) << 2
19631                 | ((TARGET_SPE_ABI
19632                     /* On the SPE, we never have any FPRs, but we do have
19633                        32/64-bit versions of the routines.  */
19634                     ? (info->spe_64bit_regs_used ? 1 : 0)
19635                     : (gpr ? 1 : 0)) << 1)
19636                 | (lr ? 1: 0));
19637
19638   /* Don't generate bogus routine names.  */
19639   gcc_assert (FIRST_SAVRES_REGISTER <= regno
19640               && regno <= LAST_SAVRES_REGISTER);
19641
19642   sym = savres_routine_syms[regno-FIRST_SAVRES_REGISTER][select];
19643
19644   if (sym == NULL)
19645     {
19646       char *name;
19647
19648       name = rs6000_savres_routine_name (info, regno, savep, gpr, lr);
19649
19650       sym = savres_routine_syms[regno-FIRST_SAVRES_REGISTER][select]
19651         = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (name));
19652       SYMBOL_REF_FLAGS (sym) |= SYMBOL_FLAG_FUNCTION;
19653     }
19654
19655   return sym;
19656 }
19657
19658 /* Emit a sequence of insns, including a stack tie if needed, for
19659    resetting the stack pointer.  If SAVRES is true, then don't reset the
19660    stack pointer, but move the base of the frame into r11 for use by
19661    out-of-line register restore routines.  */
19662
19663 static rtx
19664 rs6000_emit_stack_reset (rs6000_stack_t *info,
19665                          rtx sp_reg_rtx, rtx frame_reg_rtx,
19666                          int sp_offset, bool savres)
19667 {
19668   /* This blockage is needed so that sched doesn't decide to move
19669      the sp change before the register restores.  */
19670   if (DEFAULT_ABI == ABI_V4
19671       || (TARGET_SPE_ABI
19672           && info->spe_64bit_regs_used != 0
19673           && info->first_gp_reg_save != 32))
19674     rs6000_emit_stack_tie ();
19675
19676   if (frame_reg_rtx != sp_reg_rtx)
19677     {
19678       if (sp_offset != 0)
19679         {
19680           rtx dest_reg = savres ? gen_rtx_REG (Pmode, 11) : sp_reg_rtx;
19681           rtx insn = emit_insn (gen_add3_insn (dest_reg, frame_reg_rtx,
19682                                                GEN_INT (sp_offset)));
19683           if (!savres)
19684             return insn;
19685         }
19686       else if (!savres)
19687         return emit_move_insn (sp_reg_rtx, frame_reg_rtx);
19688     }
19689   else if (sp_offset != 0)
19690     {
19691       /* If we are restoring registers out-of-line, we will be using the
19692          "exit" variants of the restore routines, which will reset the
19693          stack for us.  But we do need to point r11 into the right place
19694          for those routines.  */
19695       rtx dest_reg = (savres
19696                       ? gen_rtx_REG (Pmode, 11)
19697                       : sp_reg_rtx);
19698
19699       rtx insn = emit_insn (gen_add3_insn (dest_reg, sp_reg_rtx,
19700                                            GEN_INT (sp_offset)));
19701       if (!savres)
19702         return insn;
19703     }
19704   return NULL_RTX;
19705 }
19706
19707 /* Construct a parallel rtx describing the effect of a call to an
19708    out-of-line register save/restore routine, and emit the insn
19709    or jump_insn as appropriate.  */
19710
19711 static rtx
19712 rs6000_emit_savres_rtx (rs6000_stack_t *info,
19713                         rtx frame_reg_rtx, int save_area_offset,
19714                         enum machine_mode reg_mode,
19715                         bool savep, bool gpr, bool lr)
19716 {
19717   int i;
19718   int offset, start_reg, end_reg, n_regs, use_reg;
19719   int reg_size = GET_MODE_SIZE (reg_mode);
19720   rtx sym;
19721   rtvec p;
19722   rtx par, insn;
19723
19724   offset = 0;
19725   start_reg = (gpr
19726                ? info->first_gp_reg_save
19727                : info->first_fp_reg_save);
19728   end_reg = gpr ? 32 : 64;
19729   n_regs = end_reg - start_reg;
19730   p = rtvec_alloc ((lr ? 4 : 3) + n_regs);
19731
19732   if (!savep && lr)
19733     RTVEC_ELT (p, offset++) = ret_rtx;
19734
19735   RTVEC_ELT (p, offset++)
19736     = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, LR_REGNO));
19737
19738   sym = rs6000_savres_routine_sym (info, savep, gpr, lr);
19739   RTVEC_ELT (p, offset++) = gen_rtx_USE (VOIDmode, sym);
19740   use_reg = DEFAULT_ABI == ABI_AIX ? (gpr && !lr ? 12 : 1)
19741                                    : DEFAULT_ABI == ABI_DARWIN && !gpr ? 1
19742                                                                        : 11;
19743   RTVEC_ELT (p, offset++)
19744     = gen_rtx_USE (VOIDmode,
19745                    gen_rtx_REG (Pmode, use_reg));
19746
19747   for (i = 0; i < end_reg - start_reg; i++)
19748     {
19749       rtx addr, reg, mem;
19750       reg = gen_rtx_REG (reg_mode, start_reg + i);
19751       addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
19752                            GEN_INT (save_area_offset + reg_size*i));
19753       mem = gen_frame_mem (reg_mode, addr);
19754
19755       RTVEC_ELT (p, i + offset) = gen_rtx_SET (VOIDmode,
19756                                                savep ? mem : reg,
19757                                                savep ? reg : mem);
19758     }
19759
19760   if (savep && lr)
19761     {
19762       rtx addr, reg, mem;
19763       reg = gen_rtx_REG (Pmode, 0);
19764       addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
19765                            GEN_INT (info->lr_save_offset));
19766       mem = gen_frame_mem (Pmode, addr);
19767       RTVEC_ELT (p, i + offset) = gen_rtx_SET (VOIDmode, mem, reg);
19768     }
19769
19770   par = gen_rtx_PARALLEL (VOIDmode, p);
19771
19772   if (!savep && lr)
19773     {
19774       insn = emit_jump_insn (par);
19775       JUMP_LABEL (insn) = ret_rtx;
19776     }
19777   else
19778     insn = emit_insn (par);
19779   return insn;
19780 }
19781
19782 /* Determine whether the gp REG is really used.  */
19783
19784 static bool
19785 rs6000_reg_live_or_pic_offset_p (int reg)
19786 {
19787   /* If the function calls eh_return, claim used all the registers that would
19788      be checked for liveness otherwise.  This is required for the PIC offset
19789      register with -mminimal-toc on AIX, as it is advertised as "fixed" for
19790      register allocation purposes in this case.  */
19791
19792   return (((crtl->calls_eh_return || df_regs_ever_live_p (reg))
19793            && (!call_used_regs[reg]
19794                || (reg == RS6000_PIC_OFFSET_TABLE_REGNUM
19795                    && !TARGET_SINGLE_PIC_BASE
19796                    && TARGET_TOC && TARGET_MINIMAL_TOC)))
19797           || (reg == RS6000_PIC_OFFSET_TABLE_REGNUM
19798               && !TARGET_SINGLE_PIC_BASE
19799               && ((DEFAULT_ABI == ABI_V4 && flag_pic != 0)
19800                   || (DEFAULT_ABI == ABI_DARWIN && flag_pic))));
19801 }
19802
19803 /* Emit function prologue as insns.  */
19804
19805 void
19806 rs6000_emit_prologue (void)
19807 {
19808   rs6000_stack_t *info = rs6000_stack_info ();
19809   enum machine_mode reg_mode = Pmode;
19810   int reg_size = TARGET_32BIT ? 4 : 8;
19811   rtx sp_reg_rtx = gen_rtx_REG (Pmode, STACK_POINTER_REGNUM);
19812   rtx frame_ptr_rtx = gen_rtx_REG (Pmode, 12);
19813   rtx frame_reg_rtx = sp_reg_rtx;
19814   rtx cr_save_rtx = NULL_RTX;
19815   rtx insn;
19816   int strategy;
19817   int saving_FPRs_inline;
19818   int saving_GPRs_inline;
19819   int using_store_multiple;
19820   int using_static_chain_p = (cfun->static_chain_decl != NULL_TREE
19821                               && df_regs_ever_live_p (STATIC_CHAIN_REGNUM)
19822                               && call_used_regs[STATIC_CHAIN_REGNUM]);
19823   HOST_WIDE_INT sp_offset = 0;
19824
19825   if (flag_stack_usage_info)
19826     current_function_static_stack_size = info->total_size;
19827
19828   if (flag_stack_check == STATIC_BUILTIN_STACK_CHECK && info->total_size)
19829     rs6000_emit_probe_stack_range (STACK_CHECK_PROTECT, info->total_size);
19830
19831   if (TARGET_FIX_AND_CONTINUE)
19832     {
19833       /* gdb on darwin arranges to forward a function from the old
19834          address by modifying the first 5 instructions of the function
19835          to branch to the overriding function.  This is necessary to
19836          permit function pointers that point to the old function to
19837          actually forward to the new function.  */
19838       emit_insn (gen_nop ());
19839       emit_insn (gen_nop ());
19840       emit_insn (gen_nop ());
19841       emit_insn (gen_nop ());
19842       emit_insn (gen_nop ());
19843     }
19844
19845   if (TARGET_SPE_ABI && info->spe_64bit_regs_used != 0)
19846     {
19847       reg_mode = V2SImode;
19848       reg_size = 8;
19849     }
19850
19851   strategy = info->savres_strategy;
19852   using_store_multiple = strategy & SAVRES_MULTIPLE;
19853   saving_FPRs_inline = strategy & SAVE_INLINE_FPRS;
19854   saving_GPRs_inline = strategy & SAVE_INLINE_GPRS;
19855
19856   /* For V.4, update stack before we do any saving and set back pointer.  */
19857   if (! WORLD_SAVE_P (info)
19858       && info->push_p
19859       && (DEFAULT_ABI == ABI_V4
19860           || crtl->calls_eh_return))
19861     {
19862       bool need_r11 = (TARGET_SPE
19863                        ? (!saving_GPRs_inline
19864                           && info->spe_64bit_regs_used == 0)
19865                        : (!saving_FPRs_inline || !saving_GPRs_inline));
19866       rtx copy_reg = need_r11 ? gen_rtx_REG (Pmode, 11) : NULL;
19867
19868       if (info->total_size < 32767)
19869         sp_offset = info->total_size;
19870       else if (need_r11)
19871         frame_reg_rtx = copy_reg;
19872       else if (info->cr_save_p
19873                || info->lr_save_p
19874                || info->first_fp_reg_save < 64
19875                || info->first_gp_reg_save < 32
19876                || info->altivec_size != 0
19877                || info->vrsave_mask != 0
19878                || crtl->calls_eh_return)
19879         {
19880           copy_reg = frame_ptr_rtx;
19881           frame_reg_rtx = copy_reg;
19882         }
19883       else
19884         {
19885           /* The prologue won't be saving any regs so there is no need
19886              to set up a frame register to access any frame save area.
19887              We also won't be using sp_offset anywhere below, but set
19888              the correct value anyway to protect against future
19889              changes to this function.  */
19890           sp_offset = info->total_size;
19891         }
19892       rs6000_emit_allocate_stack (info->total_size, copy_reg);
19893       if (frame_reg_rtx != sp_reg_rtx)
19894         rs6000_emit_stack_tie ();
19895     }
19896
19897   /* Handle world saves specially here.  */
19898   if (WORLD_SAVE_P (info))
19899     {
19900       int i, j, sz;
19901       rtx treg;
19902       rtvec p;
19903       rtx reg0;
19904
19905       /* save_world expects lr in r0. */
19906       reg0 = gen_rtx_REG (Pmode, 0);
19907       if (info->lr_save_p)
19908         {
19909           insn = emit_move_insn (reg0,
19910                                  gen_rtx_REG (Pmode, LR_REGNO));
19911           RTX_FRAME_RELATED_P (insn) = 1;
19912         }
19913
19914       /* The SAVE_WORLD and RESTORE_WORLD routines make a number of
19915          assumptions about the offsets of various bits of the stack
19916          frame.  */
19917       gcc_assert (info->gp_save_offset == -220
19918                   && info->fp_save_offset == -144
19919                   && info->lr_save_offset == 8
19920                   && info->cr_save_offset == 4
19921                   && info->push_p
19922                   && info->lr_save_p
19923                   && (!crtl->calls_eh_return
19924                        || info->ehrd_offset == -432)
19925                   && info->vrsave_save_offset == -224
19926                   && info->altivec_save_offset == -416);
19927
19928       treg = gen_rtx_REG (SImode, 11);
19929       emit_move_insn (treg, GEN_INT (-info->total_size));
19930
19931       /* SAVE_WORLD takes the caller's LR in R0 and the frame size
19932          in R11.  It also clobbers R12, so beware!  */
19933
19934       /* Preserve CR2 for save_world prologues */
19935       sz = 5;
19936       sz += 32 - info->first_gp_reg_save;
19937       sz += 64 - info->first_fp_reg_save;
19938       sz += LAST_ALTIVEC_REGNO - info->first_altivec_reg_save + 1;
19939       p = rtvec_alloc (sz);
19940       j = 0;
19941       RTVEC_ELT (p, j++) = gen_rtx_CLOBBER (VOIDmode,
19942                                             gen_rtx_REG (SImode,
19943                                                          LR_REGNO));
19944       RTVEC_ELT (p, j++) = gen_rtx_USE (VOIDmode,
19945                                         gen_rtx_SYMBOL_REF (Pmode,
19946                                                             "*save_world"));
19947       /* We do floats first so that the instruction pattern matches
19948          properly.  */
19949       for (i = 0; i < 64 - info->first_fp_reg_save; i++)
19950         {
19951           rtx reg = gen_rtx_REG (((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
19952                                    ? DFmode : SFmode),
19953                                  info->first_fp_reg_save + i);
19954           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
19955                                    GEN_INT (info->fp_save_offset
19956                                             + sp_offset + 8 * i));
19957           rtx mem = gen_frame_mem (((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
19958                                      ? DFmode : SFmode), addr);
19959
19960           RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, mem, reg);
19961         }
19962       for (i = 0; info->first_altivec_reg_save + i <= LAST_ALTIVEC_REGNO; i++)
19963         {
19964           rtx reg = gen_rtx_REG (V4SImode, info->first_altivec_reg_save + i);
19965           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
19966                                    GEN_INT (info->altivec_save_offset
19967                                             + sp_offset + 16 * i));
19968           rtx mem = gen_frame_mem (V4SImode, addr);
19969
19970           RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, mem, reg);
19971         }
19972       for (i = 0; i < 32 - info->first_gp_reg_save; i++)
19973         {
19974           rtx reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
19975           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
19976                                    GEN_INT (info->gp_save_offset
19977                                             + sp_offset + reg_size * i));
19978           rtx mem = gen_frame_mem (reg_mode, addr);
19979
19980           RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, mem, reg);
19981         }
19982
19983       {
19984         /* CR register traditionally saved as CR2.  */
19985         rtx reg = gen_rtx_REG (reg_mode, CR2_REGNO);
19986         rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
19987                                  GEN_INT (info->cr_save_offset
19988                                           + sp_offset));
19989         rtx mem = gen_frame_mem (reg_mode, addr);
19990
19991         RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, mem, reg);
19992       }
19993       /* Explain about use of R0.  */
19994       if (info->lr_save_p)
19995         {
19996           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
19997                                    GEN_INT (info->lr_save_offset
19998                                             + sp_offset));
19999           rtx mem = gen_frame_mem (reg_mode, addr);
20000
20001           RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, mem, reg0);
20002         }
20003       /* Explain what happens to the stack pointer.  */
20004       {
20005         rtx newval = gen_rtx_PLUS (Pmode, sp_reg_rtx, treg);
20006         RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, sp_reg_rtx, newval);
20007       }
20008
20009       insn = emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
20010       rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20011                             treg, GEN_INT (-info->total_size));
20012       sp_offset = info->total_size;
20013     }
20014
20015   /* If we use the link register, get it into r0.  */
20016   if (!WORLD_SAVE_P (info) && info->lr_save_p)
20017     {
20018       rtx addr, reg, mem;
20019
20020       insn = emit_move_insn (gen_rtx_REG (Pmode, 0),
20021                              gen_rtx_REG (Pmode, LR_REGNO));
20022       RTX_FRAME_RELATED_P (insn) = 1;
20023
20024       if (!(strategy & (SAVE_NOINLINE_GPRS_SAVES_LR
20025                         | SAVE_NOINLINE_FPRS_SAVES_LR)))
20026         {
20027           addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20028                                GEN_INT (info->lr_save_offset + sp_offset));
20029           reg = gen_rtx_REG (Pmode, 0);
20030           mem = gen_rtx_MEM (Pmode, addr);
20031           /* This should not be of rs6000_sr_alias_set, because of
20032              __builtin_return_address.  */
20033
20034           insn = emit_move_insn (mem, reg);
20035           rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20036                                 NULL_RTX, NULL_RTX);
20037         }
20038     }
20039
20040   /* If we need to save CR, put it into r12 or r11.  */
20041   if (!WORLD_SAVE_P (info) && info->cr_save_p && frame_reg_rtx != frame_ptr_rtx)
20042     {
20043       rtx set;
20044
20045       cr_save_rtx
20046         = gen_rtx_REG (SImode, DEFAULT_ABI == ABI_AIX && !saving_GPRs_inline
20047                        ? 11 : 12);
20048       insn = emit_insn (gen_movesi_from_cr (cr_save_rtx));
20049       RTX_FRAME_RELATED_P (insn) = 1;
20050       /* Now, there's no way that dwarf2out_frame_debug_expr is going
20051          to understand '(unspec:SI [(reg:CC 68) ...] UNSPEC_MOVESI_FROM_CR)'.
20052          But that's OK.  All we have to do is specify that _one_ condition
20053          code register is saved in this stack slot.  The thrower's epilogue
20054          will then restore all the call-saved registers.
20055          We use CR2_REGNO (70) to be compatible with gcc-2.95 on Linux.  */
20056       set = gen_rtx_SET (VOIDmode, cr_save_rtx,
20057                          gen_rtx_REG (SImode, CR2_REGNO));
20058       add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
20059     }
20060
20061   /* Do any required saving of fpr's.  If only one or two to save, do
20062      it ourselves.  Otherwise, call function.  */
20063   if (!WORLD_SAVE_P (info) && saving_FPRs_inline)
20064     {
20065       int i;
20066       for (i = 0; i < 64 - info->first_fp_reg_save; i++)
20067         if ((df_regs_ever_live_p (info->first_fp_reg_save+i)
20068              && ! call_used_regs[info->first_fp_reg_save+i]))
20069           emit_frame_save (frame_reg_rtx, frame_ptr_rtx,
20070                            (TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
20071                             ? DFmode : SFmode,
20072                            info->first_fp_reg_save + i,
20073                            info->fp_save_offset + sp_offset + 8 * i,
20074                            info->total_size);
20075     }
20076   else if (!WORLD_SAVE_P (info) && info->first_fp_reg_save != 64)
20077     {
20078       insn = rs6000_emit_savres_rtx (info, frame_reg_rtx,
20079                                      info->fp_save_offset + sp_offset,
20080                                      DFmode,
20081                                      /*savep=*/true, /*gpr=*/false,
20082                                      /*lr=*/((strategy
20083                                               & SAVE_NOINLINE_FPRS_SAVES_LR)
20084                                              != 0));
20085       rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20086                             NULL_RTX, NULL_RTX);
20087     }
20088
20089   /* Save GPRs.  This is done as a PARALLEL if we are using
20090      the store-multiple instructions.  */
20091   if (!WORLD_SAVE_P (info)
20092       && TARGET_SPE_ABI
20093       && info->spe_64bit_regs_used != 0
20094       && info->first_gp_reg_save != 32)
20095     {
20096       int i;
20097       rtx spe_save_area_ptr;
20098
20099       /* Determine whether we can address all of the registers that need
20100          to be saved with an offset from the stack pointer that fits in
20101          the small const field for SPE memory instructions.  */
20102       int spe_regs_addressable_via_sp
20103         = (SPE_CONST_OFFSET_OK(info->spe_gp_save_offset + sp_offset
20104                                + (32 - info->first_gp_reg_save - 1) * reg_size)
20105            && saving_GPRs_inline);
20106       int spe_offset;
20107
20108       if (spe_regs_addressable_via_sp)
20109         {
20110           spe_save_area_ptr = frame_reg_rtx;
20111           spe_offset = info->spe_gp_save_offset + sp_offset;
20112         }
20113       else
20114         {
20115           /* Make r11 point to the start of the SPE save area.  We need
20116              to be careful here if r11 is holding the static chain.  If
20117              it is, then temporarily save it in r0.  We would use r0 as
20118              our base register here, but using r0 as a base register in
20119              loads and stores means something different from what we
20120              would like.  */
20121           int ool_adjust = (saving_GPRs_inline
20122                             ? 0
20123                             : (info->first_gp_reg_save
20124                                - (FIRST_SAVRES_REGISTER+1))*8);
20125           HOST_WIDE_INT offset = (info->spe_gp_save_offset
20126                                   + sp_offset - ool_adjust);
20127
20128           if (using_static_chain_p)
20129             {
20130               rtx r0 = gen_rtx_REG (Pmode, 0);
20131               gcc_assert (info->first_gp_reg_save > 11);
20132
20133               emit_move_insn (r0, gen_rtx_REG (Pmode, 11));
20134             }
20135
20136           spe_save_area_ptr = gen_rtx_REG (Pmode, 11);
20137           insn = emit_insn (gen_addsi3 (spe_save_area_ptr,
20138                                         frame_reg_rtx,
20139                                         GEN_INT (offset)));
20140           /* We need to make sure the move to r11 gets noted for
20141              properly outputting unwind information.  */
20142           if (!saving_GPRs_inline)
20143             rs6000_frame_related (insn, frame_reg_rtx, offset,
20144                                   NULL_RTX, NULL_RTX);
20145           spe_offset = 0;
20146         }
20147
20148       if (saving_GPRs_inline)
20149         {
20150           for (i = 0; i < 32 - info->first_gp_reg_save; i++)
20151             if (rs6000_reg_live_or_pic_offset_p (info->first_gp_reg_save + i))
20152               {
20153                 rtx reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
20154                 rtx offset, addr, mem;
20155
20156                 /* We're doing all this to ensure that the offset fits into
20157                    the immediate offset of 'evstdd'.  */
20158                 gcc_assert (SPE_CONST_OFFSET_OK (reg_size * i + spe_offset));
20159
20160                 offset = GEN_INT (reg_size * i + spe_offset);
20161                 addr = gen_rtx_PLUS (Pmode, spe_save_area_ptr, offset);
20162                 mem = gen_rtx_MEM (V2SImode, addr);
20163
20164                 insn = emit_move_insn (mem, reg);
20165
20166                 rs6000_frame_related (insn, spe_save_area_ptr,
20167                                       info->spe_gp_save_offset
20168                                       + sp_offset + reg_size * i,
20169                                       offset, const0_rtx);
20170               }
20171         }
20172       else
20173         {
20174           insn = rs6000_emit_savres_rtx (info, gen_rtx_REG (Pmode, 11),
20175                                          0, reg_mode,
20176                                          /*savep=*/true, /*gpr=*/true,
20177                                          /*lr=*/false);
20178           rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20179                                 NULL_RTX, NULL_RTX);
20180         }
20181
20182
20183       /* Move the static chain pointer back.  */
20184       if (using_static_chain_p && !spe_regs_addressable_via_sp)
20185         emit_move_insn (gen_rtx_REG (Pmode, 11), gen_rtx_REG (Pmode, 0));
20186     }
20187   else if (!WORLD_SAVE_P (info) && !saving_GPRs_inline)
20188     {
20189       if (DEFAULT_ABI == ABI_DARWIN)
20190         {
20191           rtx dest_reg = gen_rtx_REG (reg_mode, 11);
20192           if (info->first_fp_reg_save == 64)
20193             /* we only need a copy, no fprs were saved.  */
20194             emit_move_insn (dest_reg, frame_reg_rtx);
20195           else
20196             {
20197               rtx offset = GEN_INT (sp_offset
20198                                     + (-8 * (64-info->first_fp_reg_save)));
20199               emit_insn (gen_add3_insn (dest_reg, frame_reg_rtx, offset));
20200             }
20201         }
20202       /* Need to adjust r11 (r12) if we saved any FPRs.  */
20203       else if (info->first_fp_reg_save != 64)
20204         {
20205           rtx dest_reg = gen_rtx_REG (reg_mode, DEFAULT_ABI == ABI_AIX
20206                                       ? 12 : 11);
20207           rtx offset = GEN_INT (sp_offset
20208                                 + (-8 * (64-info->first_fp_reg_save)));
20209           emit_insn (gen_add3_insn (dest_reg, frame_reg_rtx, offset));
20210         }
20211
20212       insn = rs6000_emit_savres_rtx (info, frame_reg_rtx,
20213                                      info->gp_save_offset + sp_offset,
20214                                      reg_mode,
20215                                      /*savep=*/true, /*gpr=*/true,
20216                                      /*lr=*/((strategy
20217                                               & SAVE_NOINLINE_GPRS_SAVES_LR)
20218                                              != 0));
20219       rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20220                             NULL_RTX, NULL_RTX);
20221     }
20222   else if (!WORLD_SAVE_P (info) && using_store_multiple)
20223     {
20224       rtvec p;
20225       int i;
20226       p = rtvec_alloc (32 - info->first_gp_reg_save);
20227       for (i = 0; i < 32 - info->first_gp_reg_save; i++)
20228         {
20229           rtx addr, reg, mem;
20230           reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
20231           addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20232                                GEN_INT (info->gp_save_offset
20233                                         + sp_offset
20234                                         + reg_size * i));
20235           mem = gen_frame_mem (reg_mode, addr);
20236
20237           RTVEC_ELT (p, i) = gen_rtx_SET (VOIDmode, mem, reg);
20238         }
20239       insn = emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
20240       rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20241                             NULL_RTX, NULL_RTX);
20242     }
20243   else if (!WORLD_SAVE_P (info))
20244     {
20245       int i;
20246       for (i = 0; i < 32 - info->first_gp_reg_save; i++)
20247         if (rs6000_reg_live_or_pic_offset_p (info->first_gp_reg_save + i))
20248           {
20249             rtx addr, reg, mem;
20250             reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
20251
20252             addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20253                                  GEN_INT (info->gp_save_offset
20254                                           + sp_offset
20255                                           + reg_size * i));
20256             mem = gen_frame_mem (reg_mode, addr);
20257
20258             insn = emit_move_insn (mem, reg);
20259             rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20260                                   NULL_RTX, NULL_RTX);
20261           }
20262     }
20263
20264   /* ??? There's no need to emit actual instructions here, but it's the
20265      easiest way to get the frame unwind information emitted.  */
20266   if (crtl->calls_eh_return)
20267     {
20268       unsigned int i, regno;
20269
20270       for (i = 0; ; ++i)
20271         {
20272           regno = EH_RETURN_DATA_REGNO (i);
20273           if (regno == INVALID_REGNUM)
20274             break;
20275
20276           emit_frame_save (frame_reg_rtx, frame_ptr_rtx, reg_mode, regno,
20277                            info->ehrd_offset + sp_offset
20278                            + reg_size * (int) i,
20279                            info->total_size);
20280         }
20281     }
20282
20283   /* In AIX ABI we need to make sure r2 is really saved.  */
20284   if (TARGET_AIX && crtl->calls_eh_return)
20285     {
20286       rtx tmp_reg, tmp_reg_si, hi, lo, compare_result, toc_save_done, jump;
20287       rtx save_insn, join_insn, note;
20288       long toc_restore_insn;
20289
20290       gcc_assert (frame_reg_rtx == frame_ptr_rtx
20291                   || frame_reg_rtx == sp_reg_rtx);
20292       tmp_reg = gen_rtx_REG (Pmode, 11);
20293       tmp_reg_si = gen_rtx_REG (SImode, 11);
20294       if (using_static_chain_p)
20295         emit_move_insn (gen_rtx_REG (Pmode, 0), tmp_reg);
20296       gcc_assert (saving_GPRs_inline && saving_FPRs_inline);
20297       emit_move_insn (tmp_reg, gen_rtx_REG (Pmode, LR_REGNO));
20298       /* Peek at instruction to which this function returns.  If it's
20299          restoring r2, then we know we've already saved r2.  We can't
20300          unconditionally save r2 because the value we have will already
20301          be updated if we arrived at this function via a plt call or
20302          toc adjusting stub.  */
20303       emit_move_insn (tmp_reg_si, gen_rtx_MEM (SImode, tmp_reg));
20304       toc_restore_insn = TARGET_32BIT ? 0x80410014 : 0xE8410028;
20305       hi = gen_int_mode (toc_restore_insn & ~0xffff, SImode);
20306       emit_insn (gen_xorsi3 (tmp_reg_si, tmp_reg_si, hi));
20307       compare_result = gen_rtx_REG (CCUNSmode, CR0_REGNO);
20308       validate_condition_mode (EQ, CCUNSmode);
20309       lo = gen_int_mode (toc_restore_insn & 0xffff, SImode);
20310       emit_insn (gen_rtx_SET (VOIDmode, compare_result,
20311                               gen_rtx_COMPARE (CCUNSmode, tmp_reg_si, lo)));
20312       toc_save_done = gen_label_rtx ();
20313       jump = gen_rtx_IF_THEN_ELSE (VOIDmode,
20314                                    gen_rtx_EQ (VOIDmode, compare_result,
20315                                                const0_rtx),
20316                                    gen_rtx_LABEL_REF (VOIDmode, toc_save_done),
20317                                    pc_rtx);
20318       jump = emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx, jump));
20319       JUMP_LABEL (jump) = toc_save_done;
20320       LABEL_NUSES (toc_save_done) += 1;
20321
20322       save_insn = emit_frame_save (frame_reg_rtx, frame_ptr_rtx, reg_mode,
20323                                    TOC_REGNUM, sp_offset + 5 * reg_size,
20324                                    info->total_size);
20325
20326       emit_label (toc_save_done);
20327
20328       /* ??? If we leave SAVE_INSN as marked as saving R2, then we'll
20329          have a CFG that has different saves along different paths.
20330          Move the note to a dummy blockage insn, which describes that
20331          R2 is unconditionally saved after the label.  */
20332       /* ??? An alternate representation might be a special insn pattern
20333          containing both the branch and the store.  That might let the
20334          code that minimizes the number of DW_CFA_advance opcodes better
20335          freedom in placing the annotations.  */
20336       note = find_reg_note (save_insn, REG_FRAME_RELATED_EXPR, NULL);
20337       gcc_assert (note);
20338       remove_note (save_insn, note);
20339       RTX_FRAME_RELATED_P (save_insn) = 0;
20340
20341       join_insn = emit_insn (gen_blockage ());
20342       REG_NOTES (join_insn) = note;
20343       RTX_FRAME_RELATED_P (join_insn) = 1;
20344
20345       if (using_static_chain_p)
20346         emit_move_insn (tmp_reg, gen_rtx_REG (Pmode, 0));
20347     }
20348
20349   /* Save CR if we use any that must be preserved.  */
20350   if (!WORLD_SAVE_P (info) && info->cr_save_p)
20351     {
20352       rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20353                                GEN_INT (info->cr_save_offset + sp_offset));
20354       rtx mem = gen_frame_mem (SImode, addr);
20355       /* See the large comment above about why CR2_REGNO is used.  */
20356       rtx magic_eh_cr_reg = gen_rtx_REG (SImode, CR2_REGNO);
20357
20358       /* If r12 was used to hold the original sp, copy cr into r0 now
20359          that it's free.  */
20360       if (REGNO (frame_reg_rtx) == 12)
20361         {
20362           rtx set;
20363
20364           cr_save_rtx = gen_rtx_REG (SImode, 0);
20365           insn = emit_insn (gen_movesi_from_cr (cr_save_rtx));
20366           RTX_FRAME_RELATED_P (insn) = 1;
20367           set = gen_rtx_SET (VOIDmode, cr_save_rtx, magic_eh_cr_reg);
20368           add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
20369         }
20370       insn = emit_move_insn (mem, cr_save_rtx);
20371
20372       rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20373                             NULL_RTX, NULL_RTX);
20374     }
20375
20376   /* Update stack and set back pointer unless this is V.4,
20377      for which it was done previously.  */
20378   if (!WORLD_SAVE_P (info) && info->push_p
20379       && !(DEFAULT_ABI == ABI_V4 || crtl->calls_eh_return))
20380     {
20381       rtx copy_reg = NULL;
20382
20383       if (info->total_size < 32767)
20384         sp_offset = info->total_size;
20385       else if (info->altivec_size != 0
20386                || info->vrsave_mask != 0)
20387         {
20388           copy_reg = frame_ptr_rtx;
20389           frame_reg_rtx = copy_reg;
20390         }
20391       else
20392         sp_offset = info->total_size;
20393       rs6000_emit_allocate_stack (info->total_size, copy_reg);
20394       if (frame_reg_rtx != sp_reg_rtx)
20395         rs6000_emit_stack_tie ();
20396     }
20397
20398   /* Set frame pointer, if needed.  */
20399   if (frame_pointer_needed)
20400     {
20401       insn = emit_move_insn (gen_rtx_REG (Pmode, HARD_FRAME_POINTER_REGNUM),
20402                              sp_reg_rtx);
20403       RTX_FRAME_RELATED_P (insn) = 1;
20404     }
20405
20406   /* Save AltiVec registers if needed.  Save here because the red zone does
20407      not include AltiVec registers.  */
20408   if (!WORLD_SAVE_P (info) && TARGET_ALTIVEC_ABI && info->altivec_size != 0)
20409     {
20410       int i;
20411
20412       /* There should be a non inline version of this, for when we
20413          are saving lots of vector registers.  */
20414       for (i = info->first_altivec_reg_save; i <= LAST_ALTIVEC_REGNO; ++i)
20415         if (info->vrsave_mask & ALTIVEC_REG_BIT (i))
20416           {
20417             rtx areg, savereg, mem;
20418             int offset;
20419
20420             offset = info->altivec_save_offset + sp_offset
20421               + 16 * (i - info->first_altivec_reg_save);
20422
20423             savereg = gen_rtx_REG (V4SImode, i);
20424
20425             areg = gen_rtx_REG (Pmode, 0);
20426             emit_move_insn (areg, GEN_INT (offset));
20427
20428             /* AltiVec addressing mode is [reg+reg].  */
20429             mem = gen_frame_mem (V4SImode,
20430                                  gen_rtx_PLUS (Pmode, frame_reg_rtx, areg));
20431
20432             insn = emit_move_insn (mem, savereg);
20433
20434             rs6000_frame_related (insn, frame_ptr_rtx, info->total_size,
20435                                   areg, GEN_INT (offset));
20436           }
20437     }
20438
20439   /* VRSAVE is a bit vector representing which AltiVec registers
20440      are used.  The OS uses this to determine which vector
20441      registers to save on a context switch.  We need to save
20442      VRSAVE on the stack frame, add whatever AltiVec registers we
20443      used in this function, and do the corresponding magic in the
20444      epilogue.  */
20445
20446   if (TARGET_ALTIVEC && TARGET_ALTIVEC_VRSAVE
20447       && info->vrsave_mask != 0)
20448     {
20449       rtx reg, mem, vrsave;
20450       int offset;
20451
20452       /* Get VRSAVE onto a GPR.  Note that ABI_V4 might be using r12
20453          as frame_reg_rtx and r11 as the static chain pointer for
20454          nested functions.  */
20455       reg = gen_rtx_REG (SImode, 0);
20456       vrsave = gen_rtx_REG (SImode, VRSAVE_REGNO);
20457       if (TARGET_MACHO)
20458         emit_insn (gen_get_vrsave_internal (reg));
20459       else
20460         emit_insn (gen_rtx_SET (VOIDmode, reg, vrsave));
20461
20462       if (!WORLD_SAVE_P (info))
20463         {
20464           /* Save VRSAVE.  */
20465           offset = info->vrsave_save_offset + sp_offset;
20466           mem = gen_frame_mem (SImode,
20467                                gen_rtx_PLUS (Pmode, frame_reg_rtx,
20468                                              GEN_INT (offset)));
20469           insn = emit_move_insn (mem, reg);
20470         }
20471
20472       /* Include the registers in the mask.  */
20473       emit_insn (gen_iorsi3 (reg, reg, GEN_INT ((int) info->vrsave_mask)));
20474
20475       insn = emit_insn (generate_set_vrsave (reg, info, 0));
20476     }
20477
20478   /* If we are using RS6000_PIC_OFFSET_TABLE_REGNUM, we need to set it up.  */
20479   if (!TARGET_SINGLE_PIC_BASE
20480       && ((TARGET_TOC && TARGET_MINIMAL_TOC && get_pool_size () != 0)
20481           || (DEFAULT_ABI == ABI_V4
20482               && (flag_pic == 1 || (flag_pic && TARGET_SECURE_PLT))
20483               && df_regs_ever_live_p (RS6000_PIC_OFFSET_TABLE_REGNUM))))
20484     {
20485       /* If emit_load_toc_table will use the link register, we need to save
20486          it.  We use R12 for this purpose because emit_load_toc_table
20487          can use register 0.  This allows us to use a plain 'blr' to return
20488          from the procedure more often.  */
20489       int save_LR_around_toc_setup = (TARGET_ELF
20490                                       && DEFAULT_ABI != ABI_AIX
20491                                       && flag_pic
20492                                       && ! info->lr_save_p
20493                                       && EDGE_COUNT (EXIT_BLOCK_PTR->preds) > 0);
20494       if (save_LR_around_toc_setup)
20495         {
20496           rtx lr = gen_rtx_REG (Pmode, LR_REGNO);
20497
20498           insn = emit_move_insn (frame_ptr_rtx, lr);
20499           RTX_FRAME_RELATED_P (insn) = 1;
20500
20501           rs6000_emit_load_toc_table (TRUE);
20502
20503           insn = emit_move_insn (lr, frame_ptr_rtx);
20504           add_reg_note (insn, REG_CFA_RESTORE, lr);
20505           RTX_FRAME_RELATED_P (insn) = 1;
20506         }
20507       else
20508         rs6000_emit_load_toc_table (TRUE);
20509     }
20510
20511 #if TARGET_MACHO
20512   if (!TARGET_SINGLE_PIC_BASE
20513       && DEFAULT_ABI == ABI_DARWIN
20514       && flag_pic && crtl->uses_pic_offset_table)
20515     {
20516       rtx lr = gen_rtx_REG (Pmode, LR_REGNO);
20517       rtx src = gen_rtx_SYMBOL_REF (Pmode, MACHOPIC_FUNCTION_BASE_NAME);
20518
20519       /* Save and restore LR locally around this call (in R0).  */
20520       if (!info->lr_save_p)
20521         emit_move_insn (gen_rtx_REG (Pmode, 0), lr);
20522
20523       emit_insn (gen_load_macho_picbase (src));
20524
20525       emit_move_insn (gen_rtx_REG (Pmode,
20526                                    RS6000_PIC_OFFSET_TABLE_REGNUM),
20527                       lr);
20528
20529       if (!info->lr_save_p)
20530         emit_move_insn (lr, gen_rtx_REG (Pmode, 0));
20531     }
20532 #endif
20533
20534   /* If we need to, save the TOC register after doing the stack setup.
20535      Do not emit eh frame info for this save.  The unwinder wants info,
20536      conceptually attached to instructions in this function, about
20537      register values in the caller of this function.  This R2 may have
20538      already been changed from the value in the caller.
20539      We don't attempt to write accurate DWARF EH frame info for R2
20540      because code emitted by gcc for a (non-pointer) function call
20541      doesn't save and restore R2.  Instead, R2 is managed out-of-line
20542      by a linker generated plt call stub when the function resides in
20543      a shared library.  This behaviour is costly to describe in DWARF,
20544      both in terms of the size of DWARF info and the time taken in the
20545      unwinder to interpret it.  R2 changes, apart from the
20546      calls_eh_return case earlier in this function, are handled by
20547      linux-unwind.h frob_update_context.  */
20548   if (rs6000_save_toc_in_prologue_p ())
20549     {
20550       rtx addr = gen_rtx_PLUS (Pmode, sp_reg_rtx, GEN_INT (5 * reg_size));
20551       rtx mem = gen_frame_mem (reg_mode, addr);
20552       emit_move_insn (mem, gen_rtx_REG (reg_mode, TOC_REGNUM));
20553     }
20554 }
20555
20556 /* Write function prologue.  */
20557
20558 static void
20559 rs6000_output_function_prologue (FILE *file,
20560                                  HOST_WIDE_INT size ATTRIBUTE_UNUSED)
20561 {
20562   rs6000_stack_t *info = rs6000_stack_info ();
20563
20564   if (TARGET_DEBUG_STACK)
20565     debug_stack_info (info);
20566
20567   /* Write .extern for any function we will call to save and restore
20568      fp values.  */
20569   if (info->first_fp_reg_save < 64
20570       && !TARGET_MACHO)
20571     {
20572       char *name;
20573       int regno = info->first_fp_reg_save - 32;
20574
20575       if ((info->savres_strategy & SAVE_INLINE_FPRS) == 0)
20576         {
20577           name = rs6000_savres_routine_name (info, regno, /*savep=*/true,
20578                                              /*gpr=*/false, /*lr=*/false);
20579           fprintf (file, "\t.extern %s\n", name);
20580         }
20581       if ((info->savres_strategy & REST_INLINE_FPRS) == 0)
20582         {
20583           name = rs6000_savres_routine_name (info, regno, /*savep=*/false,
20584                                              /*gpr=*/false, /*lr=*/true);
20585           fprintf (file, "\t.extern %s\n", name);
20586         }
20587     }
20588
20589   /* Write .extern for AIX common mode routines, if needed.  */
20590   if (! TARGET_POWER && ! TARGET_POWERPC && ! common_mode_defined)
20591     {
20592       fputs ("\t.extern __mulh\n", file);
20593       fputs ("\t.extern __mull\n", file);
20594       fputs ("\t.extern __divss\n", file);
20595       fputs ("\t.extern __divus\n", file);
20596       fputs ("\t.extern __quoss\n", file);
20597       fputs ("\t.extern __quous\n", file);
20598       common_mode_defined = 1;
20599     }
20600
20601   rs6000_pic_labelno++;
20602 }
20603
20604 /* Non-zero if vmx regs are restored before the frame pop, zero if
20605    we restore after the pop when possible.  */
20606 #define ALWAYS_RESTORE_ALTIVEC_BEFORE_POP 0
20607
20608 /* Reload CR from REG.  */
20609
20610 static void
20611 rs6000_restore_saved_cr (rtx reg, int using_mfcr_multiple)
20612 {
20613   int count = 0;
20614   int i;
20615
20616   if (using_mfcr_multiple)
20617     {
20618       for (i = 0; i < 8; i++)
20619         if (df_regs_ever_live_p (CR0_REGNO+i) && ! call_used_regs[CR0_REGNO+i])
20620           count++;
20621       gcc_assert (count);
20622     }
20623
20624   if (using_mfcr_multiple && count > 1)
20625     {
20626       rtvec p;
20627       int ndx;
20628
20629       p = rtvec_alloc (count);
20630
20631       ndx = 0;
20632       for (i = 0; i < 8; i++)
20633         if (df_regs_ever_live_p (CR0_REGNO+i) && ! call_used_regs[CR0_REGNO+i])
20634           {
20635             rtvec r = rtvec_alloc (2);
20636             RTVEC_ELT (r, 0) = reg;
20637             RTVEC_ELT (r, 1) = GEN_INT (1 << (7-i));
20638             RTVEC_ELT (p, ndx) =
20639               gen_rtx_SET (VOIDmode, gen_rtx_REG (CCmode, CR0_REGNO+i),
20640                            gen_rtx_UNSPEC (CCmode, r, UNSPEC_MOVESI_TO_CR));
20641             ndx++;
20642           }
20643       emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
20644       gcc_assert (ndx == count);
20645     }
20646   else
20647     for (i = 0; i < 8; i++)
20648       if (df_regs_ever_live_p (CR0_REGNO+i) && ! call_used_regs[CR0_REGNO+i])
20649         {
20650           emit_insn (gen_movsi_to_cr_one (gen_rtx_REG (CCmode,
20651                                                        CR0_REGNO+i),
20652                                           reg));
20653         }
20654 }
20655
20656 /* Return true if OFFSET from stack pointer can be clobbered by signals.
20657    V.4 doesn't have any stack cushion, AIX ABIs have 220 or 288 bytes
20658    below stack pointer not cloberred by signals.  */
20659
20660 static inline bool
20661 offset_below_red_zone_p (HOST_WIDE_INT offset)
20662 {
20663   return offset < (DEFAULT_ABI == ABI_V4
20664                    ? 0
20665                    : TARGET_32BIT ? -220 : -288);
20666 }
20667
20668 /* Append CFA_RESTORES to any existing REG_NOTES on the last insn.  */
20669
20670 static void
20671 emit_cfa_restores (rtx cfa_restores)
20672 {
20673   rtx insn = get_last_insn ();
20674   rtx *loc = &REG_NOTES (insn);
20675
20676   while (*loc)
20677     loc = &XEXP (*loc, 1);
20678   *loc = cfa_restores;
20679   RTX_FRAME_RELATED_P (insn) = 1;
20680 }
20681
20682 /* Emit function epilogue as insns.  */
20683
20684 void
20685 rs6000_emit_epilogue (int sibcall)
20686 {
20687   rs6000_stack_t *info;
20688   int restoring_GPRs_inline;
20689   int restoring_FPRs_inline;
20690   int using_load_multiple;
20691   int using_mtcr_multiple;
20692   int use_backchain_to_restore_sp;
20693   int restore_lr;
20694   int strategy;
20695   int sp_offset = 0;
20696   rtx sp_reg_rtx = gen_rtx_REG (Pmode, 1);
20697   rtx frame_reg_rtx = sp_reg_rtx;
20698   rtx cfa_restores = NULL_RTX;
20699   rtx insn;
20700   rtx cr_save_reg = NULL_RTX;
20701   enum machine_mode reg_mode = Pmode;
20702   int reg_size = TARGET_32BIT ? 4 : 8;
20703   int i;
20704
20705   info = rs6000_stack_info ();
20706
20707   if (TARGET_SPE_ABI && info->spe_64bit_regs_used != 0)
20708     {
20709       reg_mode = V2SImode;
20710       reg_size = 8;
20711     }
20712
20713   strategy = info->savres_strategy;
20714   using_load_multiple = strategy & SAVRES_MULTIPLE;
20715   restoring_FPRs_inline = sibcall || (strategy & REST_INLINE_FPRS);
20716   restoring_GPRs_inline = sibcall || (strategy & REST_INLINE_GPRS);
20717   using_mtcr_multiple = (rs6000_cpu == PROCESSOR_PPC601
20718                          || rs6000_cpu == PROCESSOR_PPC603
20719                          || rs6000_cpu == PROCESSOR_PPC750
20720                          || optimize_size);
20721   /* Restore via the backchain when we have a large frame, since this
20722      is more efficient than an addis, addi pair.  The second condition
20723      here will not trigger at the moment;  We don't actually need a
20724      frame pointer for alloca, but the generic parts of the compiler
20725      give us one anyway.  */
20726   use_backchain_to_restore_sp = (info->total_size > 32767 - info->lr_save_offset
20727                                  || (cfun->calls_alloca
20728                                      && !frame_pointer_needed));
20729   restore_lr = (info->lr_save_p
20730                 && (restoring_FPRs_inline
20731                     || (strategy & REST_NOINLINE_FPRS_DOESNT_RESTORE_LR))
20732                 && (restoring_GPRs_inline
20733                     || info->first_fp_reg_save < 64));
20734
20735   if (WORLD_SAVE_P (info))
20736     {
20737       int i, j;
20738       char rname[30];
20739       const char *alloc_rname;
20740       rtvec p;
20741
20742       /* eh_rest_world_r10 will return to the location saved in the LR
20743          stack slot (which is not likely to be our caller.)
20744          Input: R10 -- stack adjustment.  Clobbers R0, R11, R12, R7, R8.
20745          rest_world is similar, except any R10 parameter is ignored.
20746          The exception-handling stuff that was here in 2.95 is no
20747          longer necessary.  */
20748
20749       p = rtvec_alloc (9
20750                        + 1
20751                        + 32 - info->first_gp_reg_save
20752                        + LAST_ALTIVEC_REGNO + 1 - info->first_altivec_reg_save
20753                        + 63 + 1 - info->first_fp_reg_save);
20754
20755       strcpy (rname, ((crtl->calls_eh_return) ?
20756                       "*eh_rest_world_r10" : "*rest_world"));
20757       alloc_rname = ggc_strdup (rname);
20758
20759       j = 0;
20760       RTVEC_ELT (p, j++) = ret_rtx;
20761       RTVEC_ELT (p, j++) = gen_rtx_USE (VOIDmode,
20762                                         gen_rtx_REG (Pmode,
20763                                                      LR_REGNO));
20764       RTVEC_ELT (p, j++)
20765         = gen_rtx_USE (VOIDmode, gen_rtx_SYMBOL_REF (Pmode, alloc_rname));
20766       /* The instruction pattern requires a clobber here;
20767          it is shared with the restVEC helper. */
20768       RTVEC_ELT (p, j++)
20769         = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 11));
20770
20771       {
20772         /* CR register traditionally saved as CR2.  */
20773         rtx reg = gen_rtx_REG (reg_mode, CR2_REGNO);
20774         rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20775                                  GEN_INT (info->cr_save_offset));
20776         rtx mem = gen_frame_mem (reg_mode, addr);
20777
20778         RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, reg, mem);
20779
20780         if (flag_shrink_wrap)
20781           {
20782             cfa_restores = alloc_reg_note (REG_CFA_RESTORE,
20783                                            gen_rtx_REG (Pmode, LR_REGNO),
20784                                            cfa_restores);
20785             cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg, cfa_restores);
20786           }
20787       }
20788
20789       for (i = 0; i < 32 - info->first_gp_reg_save; i++)
20790         {
20791           rtx reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
20792           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20793                                    GEN_INT (info->gp_save_offset
20794                                             + reg_size * i));
20795           rtx mem = gen_frame_mem (reg_mode, addr);
20796
20797           RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, reg, mem);
20798           if (flag_shrink_wrap)
20799             cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg, cfa_restores);
20800         }
20801       for (i = 0; info->first_altivec_reg_save + i <= LAST_ALTIVEC_REGNO; i++)
20802         {
20803           rtx reg = gen_rtx_REG (V4SImode, info->first_altivec_reg_save + i);
20804           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20805                                    GEN_INT (info->altivec_save_offset
20806                                             + 16 * i));
20807           rtx mem = gen_frame_mem (V4SImode, addr);
20808
20809           RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, reg, mem);
20810           if (flag_shrink_wrap)
20811             cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg, cfa_restores);
20812         }
20813       for (i = 0; info->first_fp_reg_save + i <= 63; i++)
20814         {
20815           rtx reg = gen_rtx_REG (((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
20816                                    ? DFmode : SFmode),
20817                                  info->first_fp_reg_save + i);
20818           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20819                                    GEN_INT (info->fp_save_offset
20820                                             + 8 * i));
20821           rtx mem = gen_frame_mem (((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
20822                                      ? DFmode : SFmode), addr);
20823
20824           RTVEC_ELT (p, j++) = gen_rtx_SET (VOIDmode, reg, mem);
20825           if (flag_shrink_wrap)
20826             cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg, cfa_restores);
20827         }
20828       RTVEC_ELT (p, j++)
20829         = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (Pmode, 0));
20830       RTVEC_ELT (p, j++)
20831         = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, 12));
20832       RTVEC_ELT (p, j++)
20833         = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, 7));
20834       RTVEC_ELT (p, j++)
20835         = gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, 8));
20836       RTVEC_ELT (p, j++)
20837         = gen_rtx_USE (VOIDmode, gen_rtx_REG (SImode, 10));
20838       insn = emit_jump_insn (gen_rtx_PARALLEL (VOIDmode, p));
20839
20840       if (flag_shrink_wrap)
20841         {
20842           REG_NOTES (insn) = cfa_restores;
20843           add_reg_note (insn, REG_CFA_DEF_CFA, sp_reg_rtx);
20844           RTX_FRAME_RELATED_P (insn) = 1;
20845         }
20846       return;
20847     }
20848
20849   /* frame_reg_rtx + sp_offset points to the top of this stack frame.  */
20850   if (info->push_p)
20851     sp_offset = info->total_size;
20852
20853   /* Restore AltiVec registers if we must do so before adjusting the
20854      stack.  */
20855   if (TARGET_ALTIVEC_ABI
20856       && info->altivec_size != 0
20857       && (ALWAYS_RESTORE_ALTIVEC_BEFORE_POP
20858           || (DEFAULT_ABI != ABI_V4
20859               && offset_below_red_zone_p (info->altivec_save_offset))))
20860     {
20861       int i;
20862
20863       if (use_backchain_to_restore_sp)
20864         {
20865           frame_reg_rtx = gen_rtx_REG (Pmode, 11);
20866           emit_move_insn (frame_reg_rtx,
20867                           gen_rtx_MEM (Pmode, sp_reg_rtx));
20868           sp_offset = 0;
20869         }
20870       else if (frame_pointer_needed)
20871         frame_reg_rtx = hard_frame_pointer_rtx;
20872
20873       for (i = info->first_altivec_reg_save; i <= LAST_ALTIVEC_REGNO; ++i)
20874         if (info->vrsave_mask & ALTIVEC_REG_BIT (i))
20875           {
20876             rtx addr, areg, mem, reg;
20877
20878             areg = gen_rtx_REG (Pmode, 0);
20879             emit_move_insn
20880               (areg, GEN_INT (info->altivec_save_offset
20881                               + sp_offset
20882                               + 16 * (i - info->first_altivec_reg_save)));
20883
20884             /* AltiVec addressing mode is [reg+reg].  */
20885             addr = gen_rtx_PLUS (Pmode, frame_reg_rtx, areg);
20886             mem = gen_frame_mem (V4SImode, addr);
20887
20888             reg = gen_rtx_REG (V4SImode, i);
20889             emit_move_insn (reg, mem);
20890             if (flag_shrink_wrap
20891                 || offset_below_red_zone_p (info->altivec_save_offset
20892                                             + (i - info->first_altivec_reg_save)
20893                                             * 16))
20894               cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg,
20895                                              cfa_restores);
20896           }
20897     }
20898
20899   /* Restore VRSAVE if we must do so before adjusting the stack.  */
20900   if (TARGET_ALTIVEC
20901       && TARGET_ALTIVEC_VRSAVE
20902       && info->vrsave_mask != 0
20903       && (ALWAYS_RESTORE_ALTIVEC_BEFORE_POP
20904           || (DEFAULT_ABI != ABI_V4
20905               && offset_below_red_zone_p (info->vrsave_save_offset))))
20906     {
20907       rtx addr, mem, reg;
20908
20909       if (frame_reg_rtx == sp_reg_rtx)
20910         {
20911           if (use_backchain_to_restore_sp)
20912             {
20913               frame_reg_rtx = gen_rtx_REG (Pmode, 11);
20914               emit_move_insn (frame_reg_rtx,
20915                               gen_rtx_MEM (Pmode, sp_reg_rtx));
20916               sp_offset = 0;
20917             }
20918           else if (frame_pointer_needed)
20919             frame_reg_rtx = hard_frame_pointer_rtx;
20920         }
20921
20922       addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
20923                            GEN_INT (info->vrsave_save_offset + sp_offset));
20924       mem = gen_frame_mem (SImode, addr);
20925       reg = gen_rtx_REG (SImode, 12);
20926       emit_move_insn (reg, mem);
20927
20928       emit_insn (generate_set_vrsave (reg, info, 1));
20929     }
20930
20931   insn = NULL_RTX;
20932   /* If we have a large stack frame, restore the old stack pointer
20933      using the backchain.  */
20934   if (use_backchain_to_restore_sp)
20935     {
20936       if (frame_reg_rtx == sp_reg_rtx)
20937         {
20938           /* Under V.4, don't reset the stack pointer until after we're done
20939              loading the saved registers.  */
20940           if (DEFAULT_ABI == ABI_V4)
20941             frame_reg_rtx = gen_rtx_REG (Pmode, 11);
20942
20943           insn = emit_move_insn (frame_reg_rtx,
20944                                  gen_rtx_MEM (Pmode, sp_reg_rtx));
20945           sp_offset = 0;
20946         }
20947       else if (ALWAYS_RESTORE_ALTIVEC_BEFORE_POP
20948                && DEFAULT_ABI == ABI_V4)
20949         /* frame_reg_rtx has been set up by the altivec restore.  */
20950         ;
20951       else
20952         {
20953           insn = emit_move_insn (sp_reg_rtx, frame_reg_rtx);
20954           frame_reg_rtx = sp_reg_rtx;
20955         }
20956     }
20957   /* If we have a frame pointer, we can restore the old stack pointer
20958      from it.  */
20959   else if (frame_pointer_needed)
20960     {
20961       frame_reg_rtx = sp_reg_rtx;
20962       if (DEFAULT_ABI == ABI_V4)
20963         frame_reg_rtx = gen_rtx_REG (Pmode, 11);
20964       /* Prevent reordering memory accesses against stack pointer restore.  */
20965       else if (cfun->calls_alloca
20966                || offset_below_red_zone_p (-info->total_size))
20967         {
20968           rtx mem1 = gen_rtx_MEM (BLKmode, hard_frame_pointer_rtx);
20969           rtx mem2 = gen_rtx_MEM (BLKmode, sp_reg_rtx);
20970           MEM_NOTRAP_P (mem1) = 1;
20971           MEM_NOTRAP_P (mem2) = 1;
20972           emit_insn (gen_frame_tie (mem1, mem2));
20973         }
20974
20975       insn = emit_insn (gen_add3_insn (frame_reg_rtx, hard_frame_pointer_rtx,
20976                                        GEN_INT (info->total_size)));
20977       sp_offset = 0;
20978     }
20979   else if (info->push_p
20980            && DEFAULT_ABI != ABI_V4
20981            && !crtl->calls_eh_return)
20982     {
20983       /* Prevent reordering memory accesses against stack pointer restore.  */
20984       if (cfun->calls_alloca
20985           || offset_below_red_zone_p (-info->total_size))
20986         {
20987           rtx mem = gen_rtx_MEM (BLKmode, sp_reg_rtx);
20988           MEM_NOTRAP_P (mem) = 1;
20989           emit_insn (gen_stack_tie (mem));
20990         }
20991       insn = emit_insn (gen_add3_insn (sp_reg_rtx, sp_reg_rtx,
20992                                        GEN_INT (info->total_size)));
20993       sp_offset = 0;
20994     }
20995   if (insn && frame_reg_rtx == sp_reg_rtx)
20996     {
20997       if (cfa_restores)
20998         {
20999           REG_NOTES (insn) = cfa_restores;
21000           cfa_restores = NULL_RTX;
21001         }
21002       add_reg_note (insn, REG_CFA_DEF_CFA, sp_reg_rtx);
21003       RTX_FRAME_RELATED_P (insn) = 1;
21004     }
21005
21006   /* Restore AltiVec registers if we have not done so already.  */
21007   if (!ALWAYS_RESTORE_ALTIVEC_BEFORE_POP
21008       && TARGET_ALTIVEC_ABI
21009       && info->altivec_size != 0
21010       && (DEFAULT_ABI == ABI_V4
21011           || !offset_below_red_zone_p (info->altivec_save_offset)))
21012     {
21013       int i;
21014
21015       for (i = info->first_altivec_reg_save; i <= LAST_ALTIVEC_REGNO; ++i)
21016         if (info->vrsave_mask & ALTIVEC_REG_BIT (i))
21017           {
21018             rtx addr, areg, mem, reg;
21019
21020             areg = gen_rtx_REG (Pmode, 0);
21021             emit_move_insn
21022               (areg, GEN_INT (info->altivec_save_offset
21023                               + sp_offset
21024                               + 16 * (i - info->first_altivec_reg_save)));
21025
21026             /* AltiVec addressing mode is [reg+reg].  */
21027             addr = gen_rtx_PLUS (Pmode, frame_reg_rtx, areg);
21028             mem = gen_frame_mem (V4SImode, addr);
21029
21030             reg = gen_rtx_REG (V4SImode, i);
21031             emit_move_insn (reg, mem);
21032             if (DEFAULT_ABI == ABI_V4 || flag_shrink_wrap)
21033               cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg,
21034                                              cfa_restores);
21035           }
21036     }
21037
21038   /* Restore VRSAVE if we have not done so already.  */
21039   if (!ALWAYS_RESTORE_ALTIVEC_BEFORE_POP
21040       && TARGET_ALTIVEC
21041       && TARGET_ALTIVEC_VRSAVE
21042       && info->vrsave_mask != 0
21043       && (DEFAULT_ABI == ABI_V4
21044           || !offset_below_red_zone_p (info->vrsave_save_offset)))
21045     {
21046       rtx addr, mem, reg;
21047
21048       addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
21049                            GEN_INT (info->vrsave_save_offset + sp_offset));
21050       mem = gen_frame_mem (SImode, addr);
21051       reg = gen_rtx_REG (SImode, 12);
21052       emit_move_insn (reg, mem);
21053
21054       emit_insn (generate_set_vrsave (reg, info, 1));
21055     }
21056
21057   /* Get the old lr if we saved it.  If we are restoring registers
21058      out-of-line, then the out-of-line routines can do this for us.  */
21059   if (restore_lr && restoring_GPRs_inline)
21060     {
21061       rtx mem = gen_frame_mem_offset (Pmode, frame_reg_rtx,
21062                                       info->lr_save_offset + sp_offset);
21063
21064       emit_move_insn (gen_rtx_REG (Pmode, 0), mem);
21065     }
21066
21067   /* Get the old cr if we saved it.  */
21068   if (info->cr_save_p)
21069     {
21070       rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
21071                                GEN_INT (info->cr_save_offset + sp_offset));
21072       rtx mem = gen_frame_mem (SImode, addr);
21073
21074       cr_save_reg = gen_rtx_REG (SImode,
21075                                  DEFAULT_ABI == ABI_AIX
21076                                  && !restoring_GPRs_inline
21077                                  && info->first_fp_reg_save < 64
21078                                  ? 11 : 12);
21079       emit_move_insn (cr_save_reg, mem);
21080     }
21081
21082   /* Set LR here to try to overlap restores below.  */
21083   if (restore_lr && restoring_GPRs_inline)
21084     emit_move_insn (gen_rtx_REG (Pmode, LR_REGNO),
21085                     gen_rtx_REG (Pmode, 0));
21086
21087   /* Load exception handler data registers, if needed.  */
21088   if (crtl->calls_eh_return)
21089     {
21090       unsigned int i, regno;
21091
21092       if (TARGET_AIX)
21093         {
21094           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
21095                                    GEN_INT (sp_offset + 5 * reg_size));
21096           rtx mem = gen_frame_mem (reg_mode, addr);
21097
21098           emit_move_insn (gen_rtx_REG (reg_mode, 2), mem);
21099         }
21100
21101       for (i = 0; ; ++i)
21102         {
21103           rtx mem;
21104
21105           regno = EH_RETURN_DATA_REGNO (i);
21106           if (regno == INVALID_REGNUM)
21107             break;
21108
21109           mem = gen_frame_mem_offset (reg_mode, frame_reg_rtx,
21110                                       info->ehrd_offset + sp_offset
21111                                       + reg_size * (int) i);
21112
21113           emit_move_insn (gen_rtx_REG (reg_mode, regno), mem);
21114         }
21115     }
21116
21117   /* Restore GPRs.  This is done as a PARALLEL if we are using
21118      the load-multiple instructions.  */
21119   if (TARGET_SPE_ABI
21120       && info->spe_64bit_regs_used
21121       && info->first_gp_reg_save != 32)
21122     {
21123       /* Determine whether we can address all of the registers that need
21124          to be saved with an offset from the stack pointer that fits in
21125          the small const field for SPE memory instructions.  */
21126       int spe_regs_addressable_via_sp
21127         = (SPE_CONST_OFFSET_OK(info->spe_gp_save_offset + sp_offset
21128                                + (32 - info->first_gp_reg_save - 1) * reg_size)
21129            && restoring_GPRs_inline);
21130       int spe_offset;
21131
21132       if (spe_regs_addressable_via_sp)
21133         spe_offset = info->spe_gp_save_offset + sp_offset;
21134       else
21135         {
21136           rtx old_frame_reg_rtx = frame_reg_rtx;
21137           /* Make r11 point to the start of the SPE save area.  We worried about
21138              not clobbering it when we were saving registers in the prologue.
21139              There's no need to worry here because the static chain is passed
21140              anew to every function.  */
21141           int ool_adjust = (restoring_GPRs_inline
21142                             ? 0
21143                             : (info->first_gp_reg_save
21144                                - (FIRST_SAVRES_REGISTER + 1)) * 8);
21145
21146           if (frame_reg_rtx == sp_reg_rtx)
21147             frame_reg_rtx = gen_rtx_REG (Pmode, 11);
21148           emit_insn (gen_addsi3 (frame_reg_rtx, old_frame_reg_rtx,
21149                                  GEN_INT (info->spe_gp_save_offset
21150                                           + sp_offset
21151                                           - ool_adjust)));
21152           /* Keep the invariant that frame_reg_rtx + sp_offset points
21153              at the top of the stack frame.  */
21154           sp_offset = -info->spe_gp_save_offset;
21155
21156           spe_offset = 0;
21157         }
21158
21159       if (restoring_GPRs_inline)
21160         {
21161           for (i = 0; i < 32 - info->first_gp_reg_save; i++)
21162             if (rs6000_reg_live_or_pic_offset_p (info->first_gp_reg_save + i))
21163               {
21164                 rtx offset, addr, mem, reg;
21165
21166                 /* We're doing all this to ensure that the immediate offset
21167                    fits into the immediate field of 'evldd'.  */
21168                 gcc_assert (SPE_CONST_OFFSET_OK (spe_offset + reg_size * i));
21169
21170                 offset = GEN_INT (spe_offset + reg_size * i);
21171                 addr = gen_rtx_PLUS (Pmode, frame_reg_rtx, offset);
21172                 mem = gen_rtx_MEM (V2SImode, addr);
21173                 reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
21174
21175                 emit_move_insn (reg, mem);
21176               }
21177         }
21178       else
21179         rs6000_emit_savres_rtx (info, gen_rtx_REG (Pmode, 11),
21180                                 0, reg_mode,
21181                                 /*savep=*/false, /*gpr=*/true,
21182                                 /*lr=*/true);
21183     }
21184   else if (!restoring_GPRs_inline)
21185     {
21186       /* We are jumping to an out-of-line function.  */
21187       bool can_use_exit = info->first_fp_reg_save == 64;
21188
21189       /* Emit stack reset code if we need it.  */
21190       if (can_use_exit)
21191         {
21192           rs6000_emit_stack_reset (info, sp_reg_rtx, frame_reg_rtx,
21193                                  sp_offset, can_use_exit);
21194           if (DEFAULT_ABI == ABI_DARWIN)
21195             /* we only need a copy, no fprs were saved.  */
21196             emit_move_insn (gen_rtx_REG (reg_mode, 11), frame_reg_rtx);
21197
21198           if (info->cr_save_p)
21199             rs6000_restore_saved_cr (cr_save_reg, using_mtcr_multiple);
21200         }
21201       else
21202         {
21203           emit_insn (gen_add3_insn (gen_rtx_REG (Pmode, DEFAULT_ABI == ABI_AIX
21204                                                         ? 12 : 11),
21205                                     frame_reg_rtx,
21206                                     GEN_INT (sp_offset - info->fp_size)));
21207           if (REGNO (frame_reg_rtx) == 11)
21208             sp_offset += info->fp_size;
21209         }
21210
21211       rs6000_emit_savres_rtx (info, frame_reg_rtx,
21212                               info->gp_save_offset, reg_mode,
21213                               /*savep=*/false, /*gpr=*/true,
21214                               /*lr=*/can_use_exit);
21215     }
21216   else if (using_load_multiple)
21217     {
21218       rtvec p;
21219       p = rtvec_alloc (32 - info->first_gp_reg_save);
21220       for (i = 0; i < 32 - info->first_gp_reg_save; i++)
21221         {
21222           rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
21223                                    GEN_INT (info->gp_save_offset
21224                                             + sp_offset
21225                                             + reg_size * i));
21226           rtx mem = gen_frame_mem (reg_mode, addr);
21227           rtx reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
21228
21229           RTVEC_ELT (p, i) = gen_rtx_SET (VOIDmode, reg, mem);
21230         }
21231       emit_insn (gen_rtx_PARALLEL (VOIDmode, p));
21232     }
21233   else
21234     {
21235       for (i = 0; i < 32 - info->first_gp_reg_save; i++)
21236         if (rs6000_reg_live_or_pic_offset_p (info->first_gp_reg_save + i))
21237           {
21238             rtx addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
21239                                      GEN_INT (info->gp_save_offset
21240                                               + sp_offset
21241                                               + reg_size * i));
21242             rtx mem = gen_frame_mem (reg_mode, addr);
21243             rtx reg = gen_rtx_REG (reg_mode, info->first_gp_reg_save + i);
21244
21245             emit_move_insn (reg, mem);
21246           }
21247     }
21248
21249   if (DEFAULT_ABI == ABI_V4 || flag_shrink_wrap)
21250     {
21251       /* If the frame pointer was used then we can't delay emitting
21252          a REG_CFA_DEF_CFA note.  This must happen on the insn that
21253          restores the frame pointer, r31.  We may have already emitted
21254          a REG_CFA_DEF_CFA note, but that's OK;  A duplicate is
21255          discarded by dwarf2cfi.c/dwarf2out.c, and in any case would
21256          be harmless if emitted.  */
21257       if (frame_pointer_needed)
21258         {
21259           insn = get_last_insn ();
21260           add_reg_note (insn, REG_CFA_DEF_CFA,
21261                         plus_constant (frame_reg_rtx, sp_offset));
21262           RTX_FRAME_RELATED_P (insn) = 1;
21263         }
21264
21265       /* Set up cfa_restores.  We always need these when
21266          shrink-wrapping.  If not shrink-wrapping then we only need
21267          the cfa_restore when the stack location is no longer valid.
21268          The cfa_restores must be emitted on or before the insn that
21269          invalidates the stack, and of course must not be emitted
21270          before the insn that actually does the restore.  The latter
21271          is why the LR cfa_restore condition below is a little
21272          complicated.  It's also why it is a bad idea to emit the
21273          cfa_restores as a group on the last instruction here that
21274          actually does a restore: That insn may be reordered with
21275          respect to others doing restores.  */
21276       if (info->cr_save_p)
21277         cfa_restores = alloc_reg_note (REG_CFA_RESTORE,
21278                                        gen_rtx_REG (SImode, CR2_REGNO),
21279                                        cfa_restores);
21280       if (flag_shrink_wrap
21281           && (restore_lr
21282               || (info->lr_save_p
21283                   && !restoring_GPRs_inline
21284                   && info->first_fp_reg_save == 64)))
21285         cfa_restores = alloc_reg_note (REG_CFA_RESTORE,
21286                                        gen_rtx_REG (Pmode, LR_REGNO),
21287                                        cfa_restores);
21288
21289       for (i = info->first_gp_reg_save; i < 32; i++)
21290         if (!restoring_GPRs_inline
21291             || using_load_multiple
21292             || rs6000_reg_live_or_pic_offset_p (i))
21293           {
21294             rtx reg = gen_rtx_REG (reg_mode, i);
21295
21296             cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg, cfa_restores);
21297           }
21298     }
21299
21300   if (!restoring_GPRs_inline
21301       && info->first_fp_reg_save == 64)
21302     {
21303       /* We are jumping to an out-of-line function.  */
21304       if (cfa_restores)
21305         emit_cfa_restores (cfa_restores);
21306       return;
21307     }
21308
21309   if (restore_lr && !restoring_GPRs_inline)
21310     {
21311       rtx mem = gen_frame_mem_offset (Pmode, frame_reg_rtx,
21312                                      info->lr_save_offset + sp_offset);
21313
21314       emit_move_insn (gen_rtx_REG (Pmode, 0), mem);
21315       emit_move_insn (gen_rtx_REG (Pmode, LR_REGNO),
21316                       gen_rtx_REG (Pmode, 0));
21317     }
21318
21319   /* Restore fpr's if we need to do it without calling a function.  */
21320   if (restoring_FPRs_inline)
21321     for (i = 0; i < 64 - info->first_fp_reg_save; i++)
21322       if ((df_regs_ever_live_p (info->first_fp_reg_save + i)
21323            && !call_used_regs[info->first_fp_reg_save + i]))
21324         {
21325           rtx addr, mem, reg;
21326           addr = gen_rtx_PLUS (Pmode, frame_reg_rtx,
21327                                GEN_INT (info->fp_save_offset
21328                                         + sp_offset
21329                                         + 8 * i));
21330           mem = gen_frame_mem (((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
21331                                  ? DFmode : SFmode), addr);
21332           reg = gen_rtx_REG (((TARGET_HARD_FLOAT && TARGET_DOUBLE_FLOAT)
21333                                ? DFmode : SFmode),
21334                              info->first_fp_reg_save + i);
21335
21336           emit_move_insn (reg, mem);
21337           if (DEFAULT_ABI == ABI_V4 || flag_shrink_wrap)
21338             cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg, cfa_restores);
21339         }
21340
21341   /* If we saved cr, restore it here.  Just those that were used.  */
21342   if (info->cr_save_p)
21343     rs6000_restore_saved_cr (cr_save_reg, using_mtcr_multiple);
21344
21345   /* If this is V.4, unwind the stack pointer after all of the loads
21346      have been done.  */
21347   insn = rs6000_emit_stack_reset (info, sp_reg_rtx, frame_reg_rtx,
21348                                   sp_offset, !restoring_FPRs_inline);
21349   if (insn)
21350     {
21351       if (cfa_restores)
21352         {
21353           REG_NOTES (insn) = cfa_restores;
21354           cfa_restores = NULL_RTX;
21355         }
21356       add_reg_note (insn, REG_CFA_DEF_CFA, sp_reg_rtx);
21357       RTX_FRAME_RELATED_P (insn) = 1;
21358     }
21359
21360   if (crtl->calls_eh_return)
21361     {
21362       rtx sa = EH_RETURN_STACKADJ_RTX;
21363       emit_insn (gen_add3_insn (sp_reg_rtx, sp_reg_rtx, sa));
21364     }
21365
21366   if (!sibcall)
21367     {
21368       rtvec p;
21369       bool lr = (strategy & REST_NOINLINE_FPRS_DOESNT_RESTORE_LR) == 0;
21370       if (! restoring_FPRs_inline)
21371         {
21372           p = rtvec_alloc (4 + 64 - info->first_fp_reg_save);
21373           RTVEC_ELT (p, 0) = ret_rtx;
21374         }
21375       else
21376         {
21377           if (cfa_restores)
21378             {
21379               /* We can't hang the cfa_restores off a simple return,
21380                  since the shrink-wrap code sometimes uses an existing
21381                  return.  This means there might be a path from
21382                  pre-prologue code to this return, and dwarf2cfi code
21383                  wants the eh_frame unwinder state to be the same on
21384                  all paths to any point.  So we need to emit the
21385                  cfa_restores before the return.  For -m64 we really
21386                  don't need epilogue cfa_restores at all, except for
21387                  this irritating dwarf2cfi with shrink-wrap
21388                  requirement;  The stack red-zone means eh_frame info
21389                  from the prologue telling the unwinder to restore
21390                  from the stack is perfectly good right to the end of
21391                  the function.  */
21392               emit_insn (gen_blockage ());
21393               emit_cfa_restores (cfa_restores);
21394               cfa_restores = NULL_RTX;
21395             }
21396           p = rtvec_alloc (2);
21397           RTVEC_ELT (p, 0) = simple_return_rtx;
21398         }
21399
21400       RTVEC_ELT (p, 1) = ((restoring_FPRs_inline || !lr)
21401                           ? gen_rtx_USE (VOIDmode,
21402                                          gen_rtx_REG (Pmode, LR_REGNO))
21403                           : gen_rtx_CLOBBER (VOIDmode,
21404                                              gen_rtx_REG (Pmode, LR_REGNO)));
21405
21406       /* If we have to restore more than two FP registers, branch to the
21407          restore function.  It will return to our caller.  */
21408       if (! restoring_FPRs_inline)
21409         {
21410           int i;
21411           rtx sym;
21412
21413           if ((DEFAULT_ABI == ABI_V4 || flag_shrink_wrap)
21414               && lr)
21415             cfa_restores = alloc_reg_note (REG_CFA_RESTORE,
21416                                            gen_rtx_REG (Pmode, LR_REGNO),
21417                                            cfa_restores);
21418
21419           sym = rs6000_savres_routine_sym (info,
21420                                            /*savep=*/false,
21421                                            /*gpr=*/false,
21422                                            /*lr=*/lr);
21423           RTVEC_ELT (p, 2) = gen_rtx_USE (VOIDmode, sym);
21424           RTVEC_ELT (p, 3) = gen_rtx_USE (VOIDmode,
21425                                           gen_rtx_REG (Pmode,
21426                                                        DEFAULT_ABI == ABI_AIX
21427                                                        ? 1 : 11));
21428           for (i = 0; i < 64 - info->first_fp_reg_save; i++)
21429             {
21430               rtx addr, mem, reg;
21431
21432               addr = gen_rtx_PLUS (Pmode, sp_reg_rtx,
21433                                    GEN_INT (info->fp_save_offset + 8 * i));
21434               mem = gen_frame_mem (DFmode, addr);
21435               reg = gen_rtx_REG (DFmode, info->first_fp_reg_save + i);
21436
21437               RTVEC_ELT (p, i + 4) = gen_rtx_SET (VOIDmode, reg, mem);
21438               if (DEFAULT_ABI == ABI_V4 || flag_shrink_wrap)
21439                 cfa_restores = alloc_reg_note (REG_CFA_RESTORE, reg,
21440                                                cfa_restores);
21441             }
21442         }
21443
21444       emit_jump_insn (gen_rtx_PARALLEL (VOIDmode, p));
21445     }
21446
21447   if (cfa_restores)
21448     {
21449       if (sibcall)
21450         /* Ensure the cfa_restores are hung off an insn that won't
21451            be reordered above other restores.  */
21452         emit_insn (gen_blockage ());
21453
21454       emit_cfa_restores (cfa_restores);
21455     }
21456 }
21457
21458 /* Write function epilogue.  */
21459
21460 static void
21461 rs6000_output_function_epilogue (FILE *file,
21462                                  HOST_WIDE_INT size ATTRIBUTE_UNUSED)
21463 {
21464 #if TARGET_MACHO
21465   macho_branch_islands ();
21466   /* Mach-O doesn't support labels at the end of objects, so if
21467      it looks like we might want one, insert a NOP.  */
21468   {
21469     rtx insn = get_last_insn ();
21470     rtx deleted_debug_label = NULL_RTX;
21471     while (insn
21472            && NOTE_P (insn)
21473            && NOTE_KIND (insn) != NOTE_INSN_DELETED_LABEL)
21474       {
21475         /* Don't insert a nop for NOTE_INSN_DELETED_DEBUG_LABEL
21476            notes only, instead set their CODE_LABEL_NUMBER to -1,
21477            otherwise there would be code generation differences
21478            in between -g and -g0.  */
21479         if (NOTE_P (insn) && NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL)
21480           deleted_debug_label = insn;
21481         insn = PREV_INSN (insn);
21482       }
21483     if (insn
21484         && (LABEL_P (insn)
21485             || (NOTE_P (insn)
21486                 && NOTE_KIND (insn) == NOTE_INSN_DELETED_LABEL)))
21487       fputs ("\tnop\n", file);
21488     else if (deleted_debug_label)
21489       for (insn = deleted_debug_label; insn; insn = NEXT_INSN (insn))
21490         if (NOTE_KIND (insn) == NOTE_INSN_DELETED_DEBUG_LABEL)
21491           CODE_LABEL_NUMBER (insn) = -1;
21492   }
21493 #endif
21494
21495   /* Output a traceback table here.  See /usr/include/sys/debug.h for info
21496      on its format.
21497
21498      We don't output a traceback table if -finhibit-size-directive was
21499      used.  The documentation for -finhibit-size-directive reads
21500      ``don't output a @code{.size} assembler directive, or anything
21501      else that would cause trouble if the function is split in the
21502      middle, and the two halves are placed at locations far apart in
21503      memory.''  The traceback table has this property, since it
21504      includes the offset from the start of the function to the
21505      traceback table itself.
21506
21507      System V.4 Powerpc's (and the embedded ABI derived from it) use a
21508      different traceback table.  */
21509   if (DEFAULT_ABI == ABI_AIX && ! flag_inhibit_size_directive
21510       && rs6000_traceback != traceback_none && !cfun->is_thunk)
21511     {
21512       const char *fname = NULL;
21513       const char *language_string = lang_hooks.name;
21514       int fixed_parms = 0, float_parms = 0, parm_info = 0;
21515       int i;
21516       int optional_tbtab;
21517       rs6000_stack_t *info = rs6000_stack_info ();
21518
21519       if (rs6000_traceback == traceback_full)
21520         optional_tbtab = 1;
21521       else if (rs6000_traceback == traceback_part)
21522         optional_tbtab = 0;
21523       else
21524         optional_tbtab = !optimize_size && !TARGET_ELF;
21525
21526       if (optional_tbtab)
21527         {
21528           fname = XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0);
21529           while (*fname == '.') /* V.4 encodes . in the name */
21530             fname++;
21531
21532           /* Need label immediately before tbtab, so we can compute
21533              its offset from the function start.  */
21534           ASM_OUTPUT_INTERNAL_LABEL_PREFIX (file, "LT");
21535           ASM_OUTPUT_LABEL (file, fname);
21536         }
21537
21538       /* The .tbtab pseudo-op can only be used for the first eight
21539          expressions, since it can't handle the possibly variable
21540          length fields that follow.  However, if you omit the optional
21541          fields, the assembler outputs zeros for all optional fields
21542          anyways, giving each variable length field is minimum length
21543          (as defined in sys/debug.h).  Thus we can not use the .tbtab
21544          pseudo-op at all.  */
21545
21546       /* An all-zero word flags the start of the tbtab, for debuggers
21547          that have to find it by searching forward from the entry
21548          point or from the current pc.  */
21549       fputs ("\t.long 0\n", file);
21550
21551       /* Tbtab format type.  Use format type 0.  */
21552       fputs ("\t.byte 0,", file);
21553
21554       /* Language type.  Unfortunately, there does not seem to be any
21555          official way to discover the language being compiled, so we
21556          use language_string.
21557          C is 0.  Fortran is 1.  Pascal is 2.  Ada is 3.  C++ is 9.
21558          Java is 13.  Objective-C is 14.  Objective-C++ isn't assigned
21559          a number, so for now use 9.  LTO and Go aren't assigned numbers
21560          either, so for now use 0.  */
21561       if (! strcmp (language_string, "GNU C")
21562           || ! strcmp (language_string, "GNU GIMPLE")
21563           || ! strcmp (language_string, "GNU Go"))
21564         i = 0;
21565       else if (! strcmp (language_string, "GNU F77")
21566                || ! strcmp (language_string, "GNU Fortran"))
21567         i = 1;
21568       else if (! strcmp (language_string, "GNU Pascal"))
21569         i = 2;
21570       else if (! strcmp (language_string, "GNU Ada"))
21571         i = 3;
21572       else if (! strcmp (language_string, "GNU C++")
21573                || ! strcmp (language_string, "GNU Objective-C++"))
21574         i = 9;
21575       else if (! strcmp (language_string, "GNU Java"))
21576         i = 13;
21577       else if (! strcmp (language_string, "GNU Objective-C"))
21578         i = 14;
21579       else
21580         gcc_unreachable ();
21581       fprintf (file, "%d,", i);
21582
21583       /* 8 single bit fields: global linkage (not set for C extern linkage,
21584          apparently a PL/I convention?), out-of-line epilogue/prologue, offset
21585          from start of procedure stored in tbtab, internal function, function
21586          has controlled storage, function has no toc, function uses fp,
21587          function logs/aborts fp operations.  */
21588       /* Assume that fp operations are used if any fp reg must be saved.  */
21589       fprintf (file, "%d,",
21590                (optional_tbtab << 5) | ((info->first_fp_reg_save != 64) << 1));
21591
21592       /* 6 bitfields: function is interrupt handler, name present in
21593          proc table, function calls alloca, on condition directives
21594          (controls stack walks, 3 bits), saves condition reg, saves
21595          link reg.  */
21596       /* The `function calls alloca' bit seems to be set whenever reg 31 is
21597          set up as a frame pointer, even when there is no alloca call.  */
21598       fprintf (file, "%d,",
21599                ((optional_tbtab << 6)
21600                 | ((optional_tbtab & frame_pointer_needed) << 5)
21601                 | (info->cr_save_p << 1)
21602                 | (info->lr_save_p)));
21603
21604       /* 3 bitfields: saves backchain, fixup code, number of fpr saved
21605          (6 bits).  */
21606       fprintf (file, "%d,",
21607                (info->push_p << 7) | (64 - info->first_fp_reg_save));
21608
21609       /* 2 bitfields: spare bits (2 bits), number of gpr saved (6 bits).  */
21610       fprintf (file, "%d,", (32 - first_reg_to_save ()));
21611
21612       if (optional_tbtab)
21613         {
21614           /* Compute the parameter info from the function decl argument
21615              list.  */
21616           tree decl;
21617           int next_parm_info_bit = 31;
21618
21619           for (decl = DECL_ARGUMENTS (current_function_decl);
21620                decl; decl = DECL_CHAIN (decl))
21621             {
21622               rtx parameter = DECL_INCOMING_RTL (decl);
21623               enum machine_mode mode = GET_MODE (parameter);
21624
21625               if (GET_CODE (parameter) == REG)
21626                 {
21627                   if (SCALAR_FLOAT_MODE_P (mode))
21628                     {
21629                       int bits;
21630
21631                       float_parms++;
21632
21633                       switch (mode)
21634                         {
21635                         case SFmode:
21636                         case SDmode:
21637                           bits = 0x2;
21638                           break;
21639
21640                         case DFmode:
21641                         case DDmode:
21642                         case TFmode:
21643                         case TDmode:
21644                           bits = 0x3;
21645                           break;
21646
21647                         default:
21648                           gcc_unreachable ();
21649                         }
21650
21651                       /* If only one bit will fit, don't or in this entry.  */
21652                       if (next_parm_info_bit > 0)
21653                         parm_info |= (bits << (next_parm_info_bit - 1));
21654                       next_parm_info_bit -= 2;
21655                     }
21656                   else
21657                     {
21658                       fixed_parms += ((GET_MODE_SIZE (mode)
21659                                        + (UNITS_PER_WORD - 1))
21660                                       / UNITS_PER_WORD);
21661                       next_parm_info_bit -= 1;
21662                     }
21663                 }
21664             }
21665         }
21666
21667       /* Number of fixed point parameters.  */
21668       /* This is actually the number of words of fixed point parameters; thus
21669          an 8 byte struct counts as 2; and thus the maximum value is 8.  */
21670       fprintf (file, "%d,", fixed_parms);
21671
21672       /* 2 bitfields: number of floating point parameters (7 bits), parameters
21673          all on stack.  */
21674       /* This is actually the number of fp registers that hold parameters;
21675          and thus the maximum value is 13.  */
21676       /* Set parameters on stack bit if parameters are not in their original
21677          registers, regardless of whether they are on the stack?  Xlc
21678          seems to set the bit when not optimizing.  */
21679       fprintf (file, "%d\n", ((float_parms << 1) | (! optimize)));
21680
21681       if (! optional_tbtab)
21682         return;
21683
21684       /* Optional fields follow.  Some are variable length.  */
21685
21686       /* Parameter types, left adjusted bit fields: 0 fixed, 10 single float,
21687          11 double float.  */
21688       /* There is an entry for each parameter in a register, in the order that
21689          they occur in the parameter list.  Any intervening arguments on the
21690          stack are ignored.  If the list overflows a long (max possible length
21691          34 bits) then completely leave off all elements that don't fit.  */
21692       /* Only emit this long if there was at least one parameter.  */
21693       if (fixed_parms || float_parms)
21694         fprintf (file, "\t.long %d\n", parm_info);
21695
21696       /* Offset from start of code to tb table.  */
21697       fputs ("\t.long ", file);
21698       ASM_OUTPUT_INTERNAL_LABEL_PREFIX (file, "LT");
21699       RS6000_OUTPUT_BASENAME (file, fname);
21700       putc ('-', file);
21701       rs6000_output_function_entry (file, fname);
21702       putc ('\n', file);
21703
21704       /* Interrupt handler mask.  */
21705       /* Omit this long, since we never set the interrupt handler bit
21706          above.  */
21707
21708       /* Number of CTL (controlled storage) anchors.  */
21709       /* Omit this long, since the has_ctl bit is never set above.  */
21710
21711       /* Displacement into stack of each CTL anchor.  */
21712       /* Omit this list of longs, because there are no CTL anchors.  */
21713
21714       /* Length of function name.  */
21715       if (*fname == '*')
21716         ++fname;
21717       fprintf (file, "\t.short %d\n", (int) strlen (fname));
21718
21719       /* Function name.  */
21720       assemble_string (fname, strlen (fname));
21721
21722       /* Register for alloca automatic storage; this is always reg 31.
21723          Only emit this if the alloca bit was set above.  */
21724       if (frame_pointer_needed)
21725         fputs ("\t.byte 31\n", file);
21726
21727       fputs ("\t.align 2\n", file);
21728     }
21729 }
21730 \f
21731 /* A C compound statement that outputs the assembler code for a thunk
21732    function, used to implement C++ virtual function calls with
21733    multiple inheritance.  The thunk acts as a wrapper around a virtual
21734    function, adjusting the implicit object parameter before handing
21735    control off to the real function.
21736
21737    First, emit code to add the integer DELTA to the location that
21738    contains the incoming first argument.  Assume that this argument
21739    contains a pointer, and is the one used to pass the `this' pointer
21740    in C++.  This is the incoming argument *before* the function
21741    prologue, e.g. `%o0' on a sparc.  The addition must preserve the
21742    values of all other incoming arguments.
21743
21744    After the addition, emit code to jump to FUNCTION, which is a
21745    `FUNCTION_DECL'.  This is a direct pure jump, not a call, and does
21746    not touch the return address.  Hence returning from FUNCTION will
21747    return to whoever called the current `thunk'.
21748
21749    The effect must be as if FUNCTION had been called directly with the
21750    adjusted first argument.  This macro is responsible for emitting
21751    all of the code for a thunk function; output_function_prologue()
21752    and output_function_epilogue() are not invoked.
21753
21754    The THUNK_FNDECL is redundant.  (DELTA and FUNCTION have already
21755    been extracted from it.)  It might possibly be useful on some
21756    targets, but probably not.
21757
21758    If you do not define this macro, the target-independent code in the
21759    C++ frontend will generate a less efficient heavyweight thunk that
21760    calls FUNCTION instead of jumping to it.  The generic approach does
21761    not support varargs.  */
21762
21763 static void
21764 rs6000_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
21765                         HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
21766                         tree function)
21767 {
21768   rtx this_rtx, insn, funexp;
21769
21770   reload_completed = 1;
21771   epilogue_completed = 1;
21772
21773   /* Mark the end of the (empty) prologue.  */
21774   emit_note (NOTE_INSN_PROLOGUE_END);
21775
21776   /* Find the "this" pointer.  If the function returns a structure,
21777      the structure return pointer is in r3.  */
21778   if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
21779     this_rtx = gen_rtx_REG (Pmode, 4);
21780   else
21781     this_rtx = gen_rtx_REG (Pmode, 3);
21782
21783   /* Apply the constant offset, if required.  */
21784   if (delta)
21785     emit_insn (gen_add3_insn (this_rtx, this_rtx, GEN_INT (delta)));
21786
21787   /* Apply the offset from the vtable, if required.  */
21788   if (vcall_offset)
21789     {
21790       rtx vcall_offset_rtx = GEN_INT (vcall_offset);
21791       rtx tmp = gen_rtx_REG (Pmode, 12);
21792
21793       emit_move_insn (tmp, gen_rtx_MEM (Pmode, this_rtx));
21794       if (((unsigned HOST_WIDE_INT) vcall_offset) + 0x8000 >= 0x10000)
21795         {
21796           emit_insn (gen_add3_insn (tmp, tmp, vcall_offset_rtx));
21797           emit_move_insn (tmp, gen_rtx_MEM (Pmode, tmp));
21798         }
21799       else
21800         {
21801           rtx loc = gen_rtx_PLUS (Pmode, tmp, vcall_offset_rtx);
21802
21803           emit_move_insn (tmp, gen_rtx_MEM (Pmode, loc));
21804         }
21805       emit_insn (gen_add3_insn (this_rtx, this_rtx, tmp));
21806     }
21807
21808   /* Generate a tail call to the target function.  */
21809   if (!TREE_USED (function))
21810     {
21811       assemble_external (function);
21812       TREE_USED (function) = 1;
21813     }
21814   funexp = XEXP (DECL_RTL (function), 0);
21815   funexp = gen_rtx_MEM (FUNCTION_MODE, funexp);
21816
21817 #if TARGET_MACHO
21818   if (MACHOPIC_INDIRECT)
21819     funexp = machopic_indirect_call_target (funexp);
21820 #endif
21821
21822   /* gen_sibcall expects reload to convert scratch pseudo to LR so we must
21823      generate sibcall RTL explicitly.  */
21824   insn = emit_call_insn (
21825            gen_rtx_PARALLEL (VOIDmode,
21826              gen_rtvec (4,
21827                         gen_rtx_CALL (VOIDmode,
21828                                       funexp, const0_rtx),
21829                         gen_rtx_USE (VOIDmode, const0_rtx),
21830                         gen_rtx_USE (VOIDmode,
21831                                      gen_rtx_REG (SImode,
21832                                                   LR_REGNO)),
21833                         simple_return_rtx)));
21834   SIBLING_CALL_P (insn) = 1;
21835   emit_barrier ();
21836
21837   /* Run just enough of rest_of_compilation to get the insns emitted.
21838      There's not really enough bulk here to make other passes such as
21839      instruction scheduling worth while.  Note that use_thunk calls
21840      assemble_start_function and assemble_end_function.  */
21841   insn = get_insns ();
21842   insn_locators_alloc ();
21843   shorten_branches (insn);
21844   final_start_function (insn, file, 1);
21845   final (insn, file, 1);
21846   final_end_function ();
21847
21848   reload_completed = 0;
21849   epilogue_completed = 0;
21850 }
21851 \f
21852 /* A quick summary of the various types of 'constant-pool tables'
21853    under PowerPC:
21854
21855    Target       Flags           Name            One table per
21856    AIX          (none)          AIX TOC         object file
21857    AIX          -mfull-toc      AIX TOC         object file
21858    AIX          -mminimal-toc   AIX minimal TOC translation unit
21859    SVR4/EABI    (none)          SVR4 SDATA      object file
21860    SVR4/EABI    -fpic           SVR4 pic        object file
21861    SVR4/EABI    -fPIC           SVR4 PIC        translation unit
21862    SVR4/EABI    -mrelocatable   EABI TOC        function
21863    SVR4/EABI    -maix           AIX TOC         object file
21864    SVR4/EABI    -maix -mminimal-toc
21865                                 AIX minimal TOC translation unit
21866
21867    Name                 Reg.    Set by  entries       contains:
21868                                         made by  addrs? fp?     sum?
21869
21870    AIX TOC              2       crt0    as       Y      option  option
21871    AIX minimal TOC      30      prolog  gcc      Y      Y       option
21872    SVR4 SDATA           13      crt0    gcc      N      Y       N
21873    SVR4 pic             30      prolog  ld       Y      not yet N
21874    SVR4 PIC             30      prolog  gcc      Y      option  option
21875    EABI TOC             30      prolog  gcc      Y      option  option
21876
21877 */
21878
21879 /* Hash functions for the hash table.  */
21880
21881 static unsigned
21882 rs6000_hash_constant (rtx k)
21883 {
21884   enum rtx_code code = GET_CODE (k);
21885   enum machine_mode mode = GET_MODE (k);
21886   unsigned result = (code << 3) ^ mode;
21887   const char *format;
21888   int flen, fidx;
21889
21890   format = GET_RTX_FORMAT (code);
21891   flen = strlen (format);
21892   fidx = 0;
21893
21894   switch (code)
21895     {
21896     case LABEL_REF:
21897       return result * 1231 + (unsigned) INSN_UID (XEXP (k, 0));
21898
21899     case CONST_DOUBLE:
21900       if (mode != VOIDmode)
21901         return real_hash (CONST_DOUBLE_REAL_VALUE (k)) * result;
21902       flen = 2;
21903       break;
21904
21905     case CODE_LABEL:
21906       fidx = 3;
21907       break;
21908
21909     default:
21910       break;
21911     }
21912
21913   for (; fidx < flen; fidx++)
21914     switch (format[fidx])
21915       {
21916       case 's':
21917         {
21918           unsigned i, len;
21919           const char *str = XSTR (k, fidx);
21920           len = strlen (str);
21921           result = result * 613 + len;
21922           for (i = 0; i < len; i++)
21923             result = result * 613 + (unsigned) str[i];
21924           break;
21925         }
21926       case 'u':
21927       case 'e':
21928         result = result * 1231 + rs6000_hash_constant (XEXP (k, fidx));
21929         break;
21930       case 'i':
21931       case 'n':
21932         result = result * 613 + (unsigned) XINT (k, fidx);
21933         break;
21934       case 'w':
21935         if (sizeof (unsigned) >= sizeof (HOST_WIDE_INT))
21936           result = result * 613 + (unsigned) XWINT (k, fidx);
21937         else
21938           {
21939             size_t i;
21940             for (i = 0; i < sizeof (HOST_WIDE_INT) / sizeof (unsigned); i++)
21941               result = result * 613 + (unsigned) (XWINT (k, fidx)
21942                                                   >> CHAR_BIT * i);
21943           }
21944         break;
21945       case '0':
21946         break;
21947       default:
21948         gcc_unreachable ();
21949       }
21950
21951   return result;
21952 }
21953
21954 static unsigned
21955 toc_hash_function (const void *hash_entry)
21956 {
21957   const struct toc_hash_struct *thc =
21958     (const struct toc_hash_struct *) hash_entry;
21959   return rs6000_hash_constant (thc->key) ^ thc->key_mode;
21960 }
21961
21962 /* Compare H1 and H2 for equivalence.  */
21963
21964 static int
21965 toc_hash_eq (const void *h1, const void *h2)
21966 {
21967   rtx r1 = ((const struct toc_hash_struct *) h1)->key;
21968   rtx r2 = ((const struct toc_hash_struct *) h2)->key;
21969
21970   if (((const struct toc_hash_struct *) h1)->key_mode
21971       != ((const struct toc_hash_struct *) h2)->key_mode)
21972     return 0;
21973
21974   return rtx_equal_p (r1, r2);
21975 }
21976
21977 /* These are the names given by the C++ front-end to vtables, and
21978    vtable-like objects.  Ideally, this logic should not be here;
21979    instead, there should be some programmatic way of inquiring as
21980    to whether or not an object is a vtable.  */
21981
21982 #define VTABLE_NAME_P(NAME)                             \
21983   (strncmp ("_vt.", name, strlen ("_vt.")) == 0         \
21984   || strncmp ("_ZTV", name, strlen ("_ZTV")) == 0       \
21985   || strncmp ("_ZTT", name, strlen ("_ZTT")) == 0       \
21986   || strncmp ("_ZTI", name, strlen ("_ZTI")) == 0       \
21987   || strncmp ("_ZTC", name, strlen ("_ZTC")) == 0)
21988
21989 #ifdef NO_DOLLAR_IN_LABEL
21990 /* Return a GGC-allocated character string translating dollar signs in
21991    input NAME to underscores.  Used by XCOFF ASM_OUTPUT_LABELREF.  */
21992
21993 const char *
21994 rs6000_xcoff_strip_dollar (const char *name)
21995 {
21996   char *strip, *p;
21997   const char *q;
21998   size_t len;
21999
22000   q = (const char *) strchr (name, '$');
22001
22002   if (q == 0 || q == name)
22003     return name;
22004
22005   len = strlen (name);
22006   strip = XALLOCAVEC (char, len + 1);
22007   strcpy (strip, name);
22008   p = strip + (q - name);
22009   while (p)
22010     {
22011       *p = '_';
22012       p = strchr (p + 1, '$');
22013     }
22014
22015   return ggc_alloc_string (strip, len);
22016 }
22017 #endif
22018
22019 void
22020 rs6000_output_symbol_ref (FILE *file, rtx x)
22021 {
22022   /* Currently C++ toc references to vtables can be emitted before it
22023      is decided whether the vtable is public or private.  If this is
22024      the case, then the linker will eventually complain that there is
22025      a reference to an unknown section.  Thus, for vtables only,
22026      we emit the TOC reference to reference the symbol and not the
22027      section.  */
22028   const char *name = XSTR (x, 0);
22029
22030   if (VTABLE_NAME_P (name))
22031     {
22032       RS6000_OUTPUT_BASENAME (file, name);
22033     }
22034   else
22035     assemble_name (file, name);
22036 }
22037
22038 /* Output a TOC entry.  We derive the entry name from what is being
22039    written.  */
22040
22041 void
22042 output_toc (FILE *file, rtx x, int labelno, enum machine_mode mode)
22043 {
22044   char buf[256];
22045   const char *name = buf;
22046   rtx base = x;
22047   HOST_WIDE_INT offset = 0;
22048
22049   gcc_assert (!TARGET_NO_TOC);
22050
22051   /* When the linker won't eliminate them, don't output duplicate
22052      TOC entries (this happens on AIX if there is any kind of TOC,
22053      and on SVR4 under -fPIC or -mrelocatable).  Don't do this for
22054      CODE_LABELs.  */
22055   if (TARGET_TOC && GET_CODE (x) != LABEL_REF)
22056     {
22057       struct toc_hash_struct *h;
22058       void * * found;
22059
22060       /* Create toc_hash_table.  This can't be done at TARGET_OPTION_OVERRIDE
22061          time because GGC is not initialized at that point.  */
22062       if (toc_hash_table == NULL)
22063         toc_hash_table = htab_create_ggc (1021, toc_hash_function,
22064                                           toc_hash_eq, NULL);
22065
22066       h = ggc_alloc_toc_hash_struct ();
22067       h->key = x;
22068       h->key_mode = mode;
22069       h->labelno = labelno;
22070
22071       found = htab_find_slot (toc_hash_table, h, INSERT);
22072       if (*found == NULL)
22073         *found = h;
22074       else  /* This is indeed a duplicate.
22075                Set this label equal to that label.  */
22076         {
22077           fputs ("\t.set ", file);
22078           ASM_OUTPUT_INTERNAL_LABEL_PREFIX (file, "LC");
22079           fprintf (file, "%d,", labelno);
22080           ASM_OUTPUT_INTERNAL_LABEL_PREFIX (file, "LC");
22081           fprintf (file, "%d\n", ((*(const struct toc_hash_struct **)
22082                                               found)->labelno));
22083           return;
22084         }
22085     }
22086
22087   /* If we're going to put a double constant in the TOC, make sure it's
22088      aligned properly when strict alignment is on.  */
22089   if (GET_CODE (x) == CONST_DOUBLE
22090       && STRICT_ALIGNMENT
22091       && GET_MODE_BITSIZE (mode) >= 64
22092       && ! (TARGET_NO_FP_IN_TOC && ! TARGET_MINIMAL_TOC)) {
22093     ASM_OUTPUT_ALIGN (file, 3);
22094   }
22095
22096   (*targetm.asm_out.internal_label) (file, "LC", labelno);
22097
22098   /* Handle FP constants specially.  Note that if we have a minimal
22099      TOC, things we put here aren't actually in the TOC, so we can allow
22100      FP constants.  */
22101   if (GET_CODE (x) == CONST_DOUBLE &&
22102       (GET_MODE (x) == TFmode || GET_MODE (x) == TDmode))
22103     {
22104       REAL_VALUE_TYPE rv;
22105       long k[4];
22106
22107       REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
22108       if (DECIMAL_FLOAT_MODE_P (GET_MODE (x)))
22109         REAL_VALUE_TO_TARGET_DECIMAL128 (rv, k);
22110       else
22111         REAL_VALUE_TO_TARGET_LONG_DOUBLE (rv, k);
22112
22113       if (TARGET_64BIT)
22114         {
22115           if (TARGET_MINIMAL_TOC)
22116             fputs (DOUBLE_INT_ASM_OP, file);
22117           else
22118             fprintf (file, "\t.tc FT_%lx_%lx_%lx_%lx[TC],",
22119                      k[0] & 0xffffffff, k[1] & 0xffffffff,
22120                      k[2] & 0xffffffff, k[3] & 0xffffffff);
22121           fprintf (file, "0x%lx%08lx,0x%lx%08lx\n",
22122                    k[0] & 0xffffffff, k[1] & 0xffffffff,
22123                    k[2] & 0xffffffff, k[3] & 0xffffffff);
22124           return;
22125         }
22126       else
22127         {
22128           if (TARGET_MINIMAL_TOC)
22129             fputs ("\t.long ", file);
22130           else
22131             fprintf (file, "\t.tc FT_%lx_%lx_%lx_%lx[TC],",
22132                      k[0] & 0xffffffff, k[1] & 0xffffffff,
22133                      k[2] & 0xffffffff, k[3] & 0xffffffff);
22134           fprintf (file, "0x%lx,0x%lx,0x%lx,0x%lx\n",
22135                    k[0] & 0xffffffff, k[1] & 0xffffffff,
22136                    k[2] & 0xffffffff, k[3] & 0xffffffff);
22137           return;
22138         }
22139     }
22140   else if (GET_CODE (x) == CONST_DOUBLE &&
22141            (GET_MODE (x) == DFmode || GET_MODE (x) == DDmode))
22142     {
22143       REAL_VALUE_TYPE rv;
22144       long k[2];
22145
22146       REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
22147
22148       if (DECIMAL_FLOAT_MODE_P (GET_MODE (x)))
22149         REAL_VALUE_TO_TARGET_DECIMAL64 (rv, k);
22150       else
22151         REAL_VALUE_TO_TARGET_DOUBLE (rv, k);
22152
22153       if (TARGET_64BIT)
22154         {
22155           if (TARGET_MINIMAL_TOC)
22156             fputs (DOUBLE_INT_ASM_OP, file);
22157           else
22158             fprintf (file, "\t.tc FD_%lx_%lx[TC],",
22159                      k[0] & 0xffffffff, k[1] & 0xffffffff);
22160           fprintf (file, "0x%lx%08lx\n",
22161                    k[0] & 0xffffffff, k[1] & 0xffffffff);
22162           return;
22163         }
22164       else
22165         {
22166           if (TARGET_MINIMAL_TOC)
22167             fputs ("\t.long ", file);
22168           else
22169             fprintf (file, "\t.tc FD_%lx_%lx[TC],",
22170                      k[0] & 0xffffffff, k[1] & 0xffffffff);
22171           fprintf (file, "0x%lx,0x%lx\n",
22172                    k[0] & 0xffffffff, k[1] & 0xffffffff);
22173           return;
22174         }
22175     }
22176   else if (GET_CODE (x) == CONST_DOUBLE &&
22177            (GET_MODE (x) == SFmode || GET_MODE (x) == SDmode))
22178     {
22179       REAL_VALUE_TYPE rv;
22180       long l;
22181
22182       REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
22183       if (DECIMAL_FLOAT_MODE_P (GET_MODE (x)))
22184         REAL_VALUE_TO_TARGET_DECIMAL32 (rv, l);
22185       else
22186         REAL_VALUE_TO_TARGET_SINGLE (rv, l);
22187
22188       if (TARGET_64BIT)
22189         {
22190           if (TARGET_MINIMAL_TOC)
22191             fputs (DOUBLE_INT_ASM_OP, file);
22192           else
22193             fprintf (file, "\t.tc FS_%lx[TC],", l & 0xffffffff);
22194           fprintf (file, "0x%lx00000000\n", l & 0xffffffff);
22195           return;
22196         }
22197       else
22198         {
22199           if (TARGET_MINIMAL_TOC)
22200             fputs ("\t.long ", file);
22201           else
22202             fprintf (file, "\t.tc FS_%lx[TC],", l & 0xffffffff);
22203           fprintf (file, "0x%lx\n", l & 0xffffffff);
22204           return;
22205         }
22206     }
22207   else if (GET_MODE (x) == VOIDmode
22208            && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE))
22209     {
22210       unsigned HOST_WIDE_INT low;
22211       HOST_WIDE_INT high;
22212
22213       if (GET_CODE (x) == CONST_DOUBLE)
22214         {
22215           low = CONST_DOUBLE_LOW (x);
22216           high = CONST_DOUBLE_HIGH (x);
22217         }
22218       else
22219 #if HOST_BITS_PER_WIDE_INT == 32
22220         {
22221           low = INTVAL (x);
22222           high = (low & 0x80000000) ? ~0 : 0;
22223         }
22224 #else
22225         {
22226           low = INTVAL (x) & 0xffffffff;
22227           high = (HOST_WIDE_INT) INTVAL (x) >> 32;
22228         }
22229 #endif
22230
22231       /* TOC entries are always Pmode-sized, but since this
22232          is a bigendian machine then if we're putting smaller
22233          integer constants in the TOC we have to pad them.
22234          (This is still a win over putting the constants in
22235          a separate constant pool, because then we'd have
22236          to have both a TOC entry _and_ the actual constant.)
22237
22238          For a 32-bit target, CONST_INT values are loaded and shifted
22239          entirely within `low' and can be stored in one TOC entry.  */
22240
22241       /* It would be easy to make this work, but it doesn't now.  */
22242       gcc_assert (!TARGET_64BIT || POINTER_SIZE >= GET_MODE_BITSIZE (mode));
22243
22244       if (POINTER_SIZE > GET_MODE_BITSIZE (mode))
22245         {
22246 #if HOST_BITS_PER_WIDE_INT == 32
22247           lshift_double (low, high, POINTER_SIZE - GET_MODE_BITSIZE (mode),
22248                          POINTER_SIZE, &low, &high, 0);
22249 #else
22250           low |= high << 32;
22251           low <<= POINTER_SIZE - GET_MODE_BITSIZE (mode);
22252           high = (HOST_WIDE_INT) low >> 32;
22253           low &= 0xffffffff;
22254 #endif
22255         }
22256
22257       if (TARGET_64BIT)
22258         {
22259           if (TARGET_MINIMAL_TOC)
22260             fputs (DOUBLE_INT_ASM_OP, file);
22261           else
22262             fprintf (file, "\t.tc ID_%lx_%lx[TC],",
22263                      (long) high & 0xffffffff, (long) low & 0xffffffff);
22264           fprintf (file, "0x%lx%08lx\n",
22265                    (long) high & 0xffffffff, (long) low & 0xffffffff);
22266           return;
22267         }
22268       else
22269         {
22270           if (POINTER_SIZE < GET_MODE_BITSIZE (mode))
22271             {
22272               if (TARGET_MINIMAL_TOC)
22273                 fputs ("\t.long ", file);
22274               else
22275                 fprintf (file, "\t.tc ID_%lx_%lx[TC],",
22276                          (long) high & 0xffffffff, (long) low & 0xffffffff);
22277               fprintf (file, "0x%lx,0x%lx\n",
22278                        (long) high & 0xffffffff, (long) low & 0xffffffff);
22279             }
22280           else
22281             {
22282               if (TARGET_MINIMAL_TOC)
22283                 fputs ("\t.long ", file);
22284               else
22285                 fprintf (file, "\t.tc IS_%lx[TC],", (long) low & 0xffffffff);
22286               fprintf (file, "0x%lx\n", (long) low & 0xffffffff);
22287             }
22288           return;
22289         }
22290     }
22291
22292   if (GET_CODE (x) == CONST)
22293     {
22294       gcc_assert (GET_CODE (XEXP (x, 0)) == PLUS
22295                   && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT);
22296
22297       base = XEXP (XEXP (x, 0), 0);
22298       offset = INTVAL (XEXP (XEXP (x, 0), 1));
22299     }
22300
22301   switch (GET_CODE (base))
22302     {
22303     case SYMBOL_REF:
22304       name = XSTR (base, 0);
22305       break;
22306
22307     case LABEL_REF:
22308       ASM_GENERATE_INTERNAL_LABEL (buf, "L",
22309                                    CODE_LABEL_NUMBER (XEXP (base, 0)));
22310       break;
22311
22312     case CODE_LABEL:
22313       ASM_GENERATE_INTERNAL_LABEL (buf, "L", CODE_LABEL_NUMBER (base));
22314       break;
22315
22316     default:
22317       gcc_unreachable ();
22318     }
22319
22320   if (TARGET_MINIMAL_TOC)
22321     fputs (TARGET_32BIT ? "\t.long " : DOUBLE_INT_ASM_OP, file);
22322   else
22323     {
22324       fputs ("\t.tc ", file);
22325       RS6000_OUTPUT_BASENAME (file, name);
22326
22327       if (offset < 0)
22328         fprintf (file, ".N" HOST_WIDE_INT_PRINT_UNSIGNED, - offset);
22329       else if (offset)
22330         fprintf (file, ".P" HOST_WIDE_INT_PRINT_UNSIGNED, offset);
22331
22332       fputs ("[TC],", file);
22333     }
22334
22335   /* Currently C++ toc references to vtables can be emitted before it
22336      is decided whether the vtable is public or private.  If this is
22337      the case, then the linker will eventually complain that there is
22338      a TOC reference to an unknown section.  Thus, for vtables only,
22339      we emit the TOC reference to reference the symbol and not the
22340      section.  */
22341   if (VTABLE_NAME_P (name))
22342     {
22343       RS6000_OUTPUT_BASENAME (file, name);
22344       if (offset < 0)
22345         fprintf (file, HOST_WIDE_INT_PRINT_DEC, offset);
22346       else if (offset > 0)
22347         fprintf (file, "+" HOST_WIDE_INT_PRINT_DEC, offset);
22348     }
22349   else
22350     output_addr_const (file, x);
22351   putc ('\n', file);
22352 }
22353 \f
22354 /* Output an assembler pseudo-op to write an ASCII string of N characters
22355    starting at P to FILE.
22356
22357    On the RS/6000, we have to do this using the .byte operation and
22358    write out special characters outside the quoted string.
22359    Also, the assembler is broken; very long strings are truncated,
22360    so we must artificially break them up early.  */
22361
22362 void
22363 output_ascii (FILE *file, const char *p, int n)
22364 {
22365   char c;
22366   int i, count_string;
22367   const char *for_string = "\t.byte \"";
22368   const char *for_decimal = "\t.byte ";
22369   const char *to_close = NULL;
22370
22371   count_string = 0;
22372   for (i = 0; i < n; i++)
22373     {
22374       c = *p++;
22375       if (c >= ' ' && c < 0177)
22376         {
22377           if (for_string)
22378             fputs (for_string, file);
22379           putc (c, file);
22380
22381           /* Write two quotes to get one.  */
22382           if (c == '"')
22383             {
22384               putc (c, file);
22385               ++count_string;
22386             }
22387
22388           for_string = NULL;
22389           for_decimal = "\"\n\t.byte ";
22390           to_close = "\"\n";
22391           ++count_string;
22392
22393           if (count_string >= 512)
22394             {
22395               fputs (to_close, file);
22396
22397               for_string = "\t.byte \"";
22398               for_decimal = "\t.byte ";
22399               to_close = NULL;
22400               count_string = 0;
22401             }
22402         }
22403       else
22404         {
22405           if (for_decimal)
22406             fputs (for_decimal, file);
22407           fprintf (file, "%d", c);
22408
22409           for_string = "\n\t.byte \"";
22410           for_decimal = ", ";
22411           to_close = "\n";
22412           count_string = 0;
22413         }
22414     }
22415
22416   /* Now close the string if we have written one.  Then end the line.  */
22417   if (to_close)
22418     fputs (to_close, file);
22419 }
22420 \f
22421 /* Generate a unique section name for FILENAME for a section type
22422    represented by SECTION_DESC.  Output goes into BUF.
22423
22424    SECTION_DESC can be any string, as long as it is different for each
22425    possible section type.
22426
22427    We name the section in the same manner as xlc.  The name begins with an
22428    underscore followed by the filename (after stripping any leading directory
22429    names) with the last period replaced by the string SECTION_DESC.  If
22430    FILENAME does not contain a period, SECTION_DESC is appended to the end of
22431    the name.  */
22432
22433 void
22434 rs6000_gen_section_name (char **buf, const char *filename,
22435                          const char *section_desc)
22436 {
22437   const char *q, *after_last_slash, *last_period = 0;
22438   char *p;
22439   int len;
22440
22441   after_last_slash = filename;
22442   for (q = filename; *q; q++)
22443     {
22444       if (*q == '/')
22445         after_last_slash = q + 1;
22446       else if (*q == '.')
22447         last_period = q;
22448     }
22449
22450   len = strlen (after_last_slash) + strlen (section_desc) + 2;
22451   *buf = (char *) xmalloc (len);
22452
22453   p = *buf;
22454   *p++ = '_';
22455
22456   for (q = after_last_slash; *q; q++)
22457     {
22458       if (q == last_period)
22459         {
22460           strcpy (p, section_desc);
22461           p += strlen (section_desc);
22462           break;
22463         }
22464
22465       else if (ISALNUM (*q))
22466         *p++ = *q;
22467     }
22468
22469   if (last_period == 0)
22470     strcpy (p, section_desc);
22471   else
22472     *p = '\0';
22473 }
22474 \f
22475 /* Emit profile function.  */
22476
22477 void
22478 output_profile_hook (int labelno ATTRIBUTE_UNUSED)
22479 {
22480   /* Non-standard profiling for kernels, which just saves LR then calls
22481      _mcount without worrying about arg saves.  The idea is to change
22482      the function prologue as little as possible as it isn't easy to
22483      account for arg save/restore code added just for _mcount.  */
22484   if (TARGET_PROFILE_KERNEL)
22485     return;
22486
22487   if (DEFAULT_ABI == ABI_AIX)
22488     {
22489 #ifndef NO_PROFILE_COUNTERS
22490 # define NO_PROFILE_COUNTERS 0
22491 #endif
22492       if (NO_PROFILE_COUNTERS)
22493         emit_library_call (init_one_libfunc (RS6000_MCOUNT),
22494                            LCT_NORMAL, VOIDmode, 0);
22495       else
22496         {
22497           char buf[30];
22498           const char *label_name;
22499           rtx fun;
22500
22501           ASM_GENERATE_INTERNAL_LABEL (buf, "LP", labelno);
22502           label_name = ggc_strdup ((*targetm.strip_name_encoding) (buf));
22503           fun = gen_rtx_SYMBOL_REF (Pmode, label_name);
22504
22505           emit_library_call (init_one_libfunc (RS6000_MCOUNT),
22506                              LCT_NORMAL, VOIDmode, 1, fun, Pmode);
22507         }
22508     }
22509   else if (DEFAULT_ABI == ABI_DARWIN)
22510     {
22511       const char *mcount_name = RS6000_MCOUNT;
22512       int caller_addr_regno = LR_REGNO;
22513
22514       /* Be conservative and always set this, at least for now.  */
22515       crtl->uses_pic_offset_table = 1;
22516
22517 #if TARGET_MACHO
22518       /* For PIC code, set up a stub and collect the caller's address
22519          from r0, which is where the prologue puts it.  */
22520       if (MACHOPIC_INDIRECT
22521           && crtl->uses_pic_offset_table)
22522         caller_addr_regno = 0;
22523 #endif
22524       emit_library_call (gen_rtx_SYMBOL_REF (Pmode, mcount_name),
22525                          LCT_NORMAL, VOIDmode, 1,
22526                          gen_rtx_REG (Pmode, caller_addr_regno), Pmode);
22527     }
22528 }
22529
22530 /* Write function profiler code.  */
22531
22532 void
22533 output_function_profiler (FILE *file, int labelno)
22534 {
22535   char buf[100];
22536
22537   switch (DEFAULT_ABI)
22538     {
22539     default:
22540       gcc_unreachable ();
22541
22542     case ABI_V4:
22543       if (!TARGET_32BIT)
22544         {
22545           warning (0, "no profiling of 64-bit code for this ABI");
22546           return;
22547         }
22548       ASM_GENERATE_INTERNAL_LABEL (buf, "LP", labelno);
22549       fprintf (file, "\tmflr %s\n", reg_names[0]);
22550       if (NO_PROFILE_COUNTERS)
22551         {
22552           asm_fprintf (file, "\t{st|stw} %s,4(%s)\n",
22553                        reg_names[0], reg_names[1]);
22554         }
22555       else if (TARGET_SECURE_PLT && flag_pic)
22556         {
22557           if (TARGET_LINK_STACK)
22558             {
22559               char name[32];
22560               get_ppc476_thunk_name (name);
22561               asm_fprintf (file, "\tbl %s\n", name);
22562             }
22563           else
22564             asm_fprintf (file, "\tbcl 20,31,1f\n1:\n");
22565           asm_fprintf (file, "\t{st|stw} %s,4(%s)\n",
22566                        reg_names[0], reg_names[1]);
22567           asm_fprintf (file, "\tmflr %s\n", reg_names[12]);
22568           asm_fprintf (file, "\t{cau|addis} %s,%s,",
22569                        reg_names[12], reg_names[12]);
22570           assemble_name (file, buf);
22571           asm_fprintf (file, "-1b@ha\n\t{cal|la} %s,", reg_names[0]);
22572           assemble_name (file, buf);
22573           asm_fprintf (file, "-1b@l(%s)\n", reg_names[12]);
22574         }
22575       else if (flag_pic == 1)
22576         {
22577           fputs ("\tbl _GLOBAL_OFFSET_TABLE_@local-4\n", file);
22578           asm_fprintf (file, "\t{st|stw} %s,4(%s)\n",
22579                        reg_names[0], reg_names[1]);
22580           asm_fprintf (file, "\tmflr %s\n", reg_names[12]);
22581           asm_fprintf (file, "\t{l|lwz} %s,", reg_names[0]);
22582           assemble_name (file, buf);
22583           asm_fprintf (file, "@got(%s)\n", reg_names[12]);
22584         }
22585       else if (flag_pic > 1)
22586         {
22587           asm_fprintf (file, "\t{st|stw} %s,4(%s)\n",
22588                        reg_names[0], reg_names[1]);
22589           /* Now, we need to get the address of the label.  */
22590           if (TARGET_LINK_STACK)
22591             {
22592               char name[32];
22593               get_ppc476_thunk_name (name);
22594               asm_fprintf (file, "\tbl %s\n\tb 1f\n\t.long ", name);
22595               assemble_name (file, buf);
22596               fputs ("-.\n1:", file);
22597               asm_fprintf (file, "\tmflr %s\n", reg_names[11]);
22598               asm_fprintf (file, "\taddi %s,%s,4\n",
22599                            reg_names[11], reg_names[11]);
22600             }
22601           else
22602             {
22603               fputs ("\tbcl 20,31,1f\n\t.long ", file);
22604               assemble_name (file, buf);
22605               fputs ("-.\n1:", file);
22606               asm_fprintf (file, "\tmflr %s\n", reg_names[11]);
22607             }
22608           asm_fprintf (file, "\t{l|lwz} %s,0(%s)\n",
22609                        reg_names[0], reg_names[11]);
22610           asm_fprintf (file, "\t{cax|add} %s,%s,%s\n",
22611                        reg_names[0], reg_names[0], reg_names[11]);
22612         }
22613       else
22614         {
22615           asm_fprintf (file, "\t{liu|lis} %s,", reg_names[12]);
22616           assemble_name (file, buf);
22617           fputs ("@ha\n", file);
22618           asm_fprintf (file, "\t{st|stw} %s,4(%s)\n",
22619                        reg_names[0], reg_names[1]);
22620           asm_fprintf (file, "\t{cal|la} %s,", reg_names[0]);
22621           assemble_name (file, buf);
22622           asm_fprintf (file, "@l(%s)\n", reg_names[12]);
22623         }
22624
22625       /* ABI_V4 saves the static chain reg with ASM_OUTPUT_REG_PUSH.  */
22626       fprintf (file, "\tbl %s%s\n",
22627                RS6000_MCOUNT, flag_pic ? "@plt" : "");
22628       break;
22629
22630     case ABI_AIX:
22631     case ABI_DARWIN:
22632       if (!TARGET_PROFILE_KERNEL)
22633         {
22634           /* Don't do anything, done in output_profile_hook ().  */
22635         }
22636       else
22637         {
22638           gcc_assert (!TARGET_32BIT);
22639
22640           asm_fprintf (file, "\tmflr %s\n", reg_names[0]);
22641           asm_fprintf (file, "\tstd %s,16(%s)\n", reg_names[0], reg_names[1]);
22642
22643           if (cfun->static_chain_decl != NULL)
22644             {
22645               asm_fprintf (file, "\tstd %s,24(%s)\n",
22646                            reg_names[STATIC_CHAIN_REGNUM], reg_names[1]);
22647               fprintf (file, "\tbl %s\n", RS6000_MCOUNT);
22648               asm_fprintf (file, "\tld %s,24(%s)\n",
22649                            reg_names[STATIC_CHAIN_REGNUM], reg_names[1]);
22650             }
22651           else
22652             fprintf (file, "\tbl %s\n", RS6000_MCOUNT);
22653         }
22654       break;
22655     }
22656 }
22657
22658 \f
22659
22660 /* The following variable value is the last issued insn.  */
22661
22662 static rtx last_scheduled_insn;
22663
22664 /* The following variable helps to balance issuing of load and
22665    store instructions */
22666
22667 static int load_store_pendulum;
22668
22669 /* Power4 load update and store update instructions are cracked into a
22670    load or store and an integer insn which are executed in the same cycle.
22671    Branches have their own dispatch slot which does not count against the
22672    GCC issue rate, but it changes the program flow so there are no other
22673    instructions to issue in this cycle.  */
22674
22675 static int
22676 rs6000_variable_issue_1 (rtx insn, int more)
22677 {
22678   last_scheduled_insn = insn;
22679   if (GET_CODE (PATTERN (insn)) == USE
22680       || GET_CODE (PATTERN (insn)) == CLOBBER)
22681     {
22682       cached_can_issue_more = more;
22683       return cached_can_issue_more;
22684     }
22685
22686   if (insn_terminates_group_p (insn, current_group))
22687     {
22688       cached_can_issue_more = 0;
22689       return cached_can_issue_more;
22690     }
22691
22692   /* If no reservation, but reach here */
22693   if (recog_memoized (insn) < 0)
22694     return more;
22695
22696   if (rs6000_sched_groups)
22697     {
22698       if (is_microcoded_insn (insn))
22699         cached_can_issue_more = 0;
22700       else if (is_cracked_insn (insn))
22701         cached_can_issue_more = more > 2 ? more - 2 : 0;
22702       else
22703         cached_can_issue_more = more - 1;
22704
22705       return cached_can_issue_more;
22706     }
22707
22708   if (rs6000_cpu_attr == CPU_CELL && is_nonpipeline_insn (insn))
22709     return 0;
22710
22711   cached_can_issue_more = more - 1;
22712   return cached_can_issue_more;
22713 }
22714
22715 static int
22716 rs6000_variable_issue (FILE *stream, int verbose, rtx insn, int more)
22717 {
22718   int r = rs6000_variable_issue_1 (insn, more);
22719   if (verbose)
22720     fprintf (stream, "// rs6000_variable_issue (more = %d) = %d\n", more, r);
22721   return r;
22722 }
22723
22724 /* Adjust the cost of a scheduling dependency.  Return the new cost of
22725    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
22726
22727 static int
22728 rs6000_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
22729 {
22730   enum attr_type attr_type;
22731
22732   if (! recog_memoized (insn))
22733     return 0;
22734
22735   switch (REG_NOTE_KIND (link))
22736     {
22737     case REG_DEP_TRUE:
22738       {
22739         /* Data dependency; DEP_INSN writes a register that INSN reads
22740            some cycles later.  */
22741
22742         /* Separate a load from a narrower, dependent store.  */
22743         if (rs6000_sched_groups
22744             && GET_CODE (PATTERN (insn)) == SET
22745             && GET_CODE (PATTERN (dep_insn)) == SET
22746             && GET_CODE (XEXP (PATTERN (insn), 1)) == MEM
22747             && GET_CODE (XEXP (PATTERN (dep_insn), 0)) == MEM
22748             && (GET_MODE_SIZE (GET_MODE (XEXP (PATTERN (insn), 1)))
22749                 > GET_MODE_SIZE (GET_MODE (XEXP (PATTERN (dep_insn), 0)))))
22750           return cost + 14;
22751
22752         attr_type = get_attr_type (insn);
22753
22754         switch (attr_type)
22755           {
22756           case TYPE_JMPREG:
22757             /* Tell the first scheduling pass about the latency between
22758                a mtctr and bctr (and mtlr and br/blr).  The first
22759                scheduling pass will not know about this latency since
22760                the mtctr instruction, which has the latency associated
22761                to it, will be generated by reload.  */
22762             return TARGET_POWER ? 5 : 4;
22763           case TYPE_BRANCH:
22764             /* Leave some extra cycles between a compare and its
22765                dependent branch, to inhibit expensive mispredicts.  */
22766             if ((rs6000_cpu_attr == CPU_PPC603
22767                  || rs6000_cpu_attr == CPU_PPC604
22768                  || rs6000_cpu_attr == CPU_PPC604E
22769                  || rs6000_cpu_attr == CPU_PPC620
22770                  || rs6000_cpu_attr == CPU_PPC630
22771                  || rs6000_cpu_attr == CPU_PPC750
22772                  || rs6000_cpu_attr == CPU_PPC7400
22773                  || rs6000_cpu_attr == CPU_PPC7450
22774                  || rs6000_cpu_attr == CPU_POWER4
22775                  || rs6000_cpu_attr == CPU_POWER5
22776                  || rs6000_cpu_attr == CPU_POWER7
22777                  || rs6000_cpu_attr == CPU_CELL)
22778                 && recog_memoized (dep_insn)
22779                 && (INSN_CODE (dep_insn) >= 0))
22780
22781               switch (get_attr_type (dep_insn))
22782                 {
22783                 case TYPE_CMP:
22784                 case TYPE_COMPARE:
22785                 case TYPE_DELAYED_COMPARE:
22786                 case TYPE_IMUL_COMPARE:
22787                 case TYPE_LMUL_COMPARE:
22788                 case TYPE_FPCOMPARE:
22789                 case TYPE_CR_LOGICAL:
22790                 case TYPE_DELAYED_CR:
22791                   return cost + 2;
22792                 default:
22793                   break;
22794                 }
22795             break;
22796
22797           case TYPE_STORE:
22798           case TYPE_STORE_U:
22799           case TYPE_STORE_UX:
22800           case TYPE_FPSTORE:
22801           case TYPE_FPSTORE_U:
22802           case TYPE_FPSTORE_UX:
22803             if ((rs6000_cpu == PROCESSOR_POWER6)
22804                 && recog_memoized (dep_insn)
22805                 && (INSN_CODE (dep_insn) >= 0))
22806               {
22807
22808                 if (GET_CODE (PATTERN (insn)) != SET)
22809                   /* If this happens, we have to extend this to schedule
22810                      optimally.  Return default for now.  */
22811                   return cost;
22812
22813                 /* Adjust the cost for the case where the value written
22814                    by a fixed point operation is used as the address
22815                    gen value on a store. */
22816                 switch (get_attr_type (dep_insn))
22817                   {
22818                   case TYPE_LOAD:
22819                   case TYPE_LOAD_U:
22820                   case TYPE_LOAD_UX:
22821                   case TYPE_CNTLZ:
22822                     {
22823                       if (! store_data_bypass_p (dep_insn, insn))
22824                         return 4;
22825                       break;
22826                     }
22827                   case TYPE_LOAD_EXT:
22828                   case TYPE_LOAD_EXT_U:
22829                   case TYPE_LOAD_EXT_UX:
22830                   case TYPE_VAR_SHIFT_ROTATE:
22831                   case TYPE_VAR_DELAYED_COMPARE:
22832                     {
22833                       if (! store_data_bypass_p (dep_insn, insn))
22834                         return 6;
22835                       break;
22836                     }
22837                   case TYPE_INTEGER:
22838                   case TYPE_COMPARE:
22839                   case TYPE_FAST_COMPARE:
22840                   case TYPE_EXTS:
22841                   case TYPE_SHIFT:
22842                   case TYPE_INSERT_WORD:
22843                   case TYPE_INSERT_DWORD:
22844                   case TYPE_FPLOAD_U:
22845                   case TYPE_FPLOAD_UX:
22846                   case TYPE_STORE_U:
22847                   case TYPE_STORE_UX:
22848                   case TYPE_FPSTORE_U:
22849                   case TYPE_FPSTORE_UX:
22850                     {
22851                       if (! store_data_bypass_p (dep_insn, insn))
22852                         return 3;
22853                       break;
22854                     }
22855                   case TYPE_IMUL:
22856                   case TYPE_IMUL2:
22857                   case TYPE_IMUL3:
22858                   case TYPE_LMUL:
22859                   case TYPE_IMUL_COMPARE:
22860                   case TYPE_LMUL_COMPARE:
22861                     {
22862                       if (! store_data_bypass_p (dep_insn, insn))
22863                         return 17;
22864                       break;
22865                     }
22866                   case TYPE_IDIV:
22867                     {
22868                       if (! store_data_bypass_p (dep_insn, insn))
22869                         return 45;
22870                       break;
22871                     }
22872                   case TYPE_LDIV:
22873                     {
22874                       if (! store_data_bypass_p (dep_insn, insn))
22875                         return 57;
22876                       break;
22877                     }
22878                   default:
22879                     break;
22880                   }
22881               }
22882             break;
22883
22884           case TYPE_LOAD:
22885           case TYPE_LOAD_U:
22886           case TYPE_LOAD_UX:
22887           case TYPE_LOAD_EXT:
22888           case TYPE_LOAD_EXT_U:
22889           case TYPE_LOAD_EXT_UX:
22890             if ((rs6000_cpu == PROCESSOR_POWER6)
22891                 && recog_memoized (dep_insn)
22892                 && (INSN_CODE (dep_insn) >= 0))
22893               {
22894
22895                 /* Adjust the cost for the case where the value written
22896                    by a fixed point instruction is used within the address
22897                    gen portion of a subsequent load(u)(x) */
22898                 switch (get_attr_type (dep_insn))
22899                   {
22900                   case TYPE_LOAD:
22901                   case TYPE_LOAD_U:
22902                   case TYPE_LOAD_UX:
22903                   case TYPE_CNTLZ:
22904                     {
22905                       if (set_to_load_agen (dep_insn, insn))
22906                         return 4;
22907                       break;
22908                     }
22909                   case TYPE_LOAD_EXT:
22910                   case TYPE_LOAD_EXT_U:
22911                   case TYPE_LOAD_EXT_UX:
22912                   case TYPE_VAR_SHIFT_ROTATE:
22913                   case TYPE_VAR_DELAYED_COMPARE:
22914                     {
22915                       if (set_to_load_agen (dep_insn, insn))
22916                         return 6;
22917                       break;
22918                     }
22919                   case TYPE_INTEGER:
22920                   case TYPE_COMPARE:
22921                   case TYPE_FAST_COMPARE:
22922                   case TYPE_EXTS:
22923                   case TYPE_SHIFT:
22924                   case TYPE_INSERT_WORD:
22925                   case TYPE_INSERT_DWORD:
22926                   case TYPE_FPLOAD_U:
22927                   case TYPE_FPLOAD_UX:
22928                   case TYPE_STORE_U:
22929                   case TYPE_STORE_UX:
22930                   case TYPE_FPSTORE_U:
22931                   case TYPE_FPSTORE_UX:
22932                     {
22933                       if (set_to_load_agen (dep_insn, insn))
22934                         return 3;
22935                       break;
22936                     }
22937                   case TYPE_IMUL:
22938                   case TYPE_IMUL2:
22939                   case TYPE_IMUL3:
22940                   case TYPE_LMUL:
22941                   case TYPE_IMUL_COMPARE:
22942                   case TYPE_LMUL_COMPARE:
22943                     {
22944                       if (set_to_load_agen (dep_insn, insn))
22945                         return 17;
22946                       break;
22947                     }
22948                   case TYPE_IDIV:
22949                     {
22950                       if (set_to_load_agen (dep_insn, insn))
22951                         return 45;
22952                       break;
22953                     }
22954                   case TYPE_LDIV:
22955                     {
22956                       if (set_to_load_agen (dep_insn, insn))
22957                         return 57;
22958                       break;
22959                     }
22960                   default:
22961                     break;
22962                   }
22963               }
22964             break;
22965
22966           case TYPE_FPLOAD:
22967             if ((rs6000_cpu == PROCESSOR_POWER6)
22968                 && recog_memoized (dep_insn)
22969                 && (INSN_CODE (dep_insn) >= 0)
22970                 && (get_attr_type (dep_insn) == TYPE_MFFGPR))
22971               return 2;
22972
22973           default:
22974             break;
22975           }
22976
22977         /* Fall out to return default cost.  */
22978       }
22979       break;
22980
22981     case REG_DEP_OUTPUT:
22982       /* Output dependency; DEP_INSN writes a register that INSN writes some
22983          cycles later.  */
22984       if ((rs6000_cpu == PROCESSOR_POWER6)
22985           && recog_memoized (dep_insn)
22986           && (INSN_CODE (dep_insn) >= 0))
22987         {
22988           attr_type = get_attr_type (insn);
22989
22990           switch (attr_type)
22991             {
22992             case TYPE_FP:
22993               if (get_attr_type (dep_insn) == TYPE_FP)
22994                 return 1;
22995               break;
22996             case TYPE_FPLOAD:
22997               if (get_attr_type (dep_insn) == TYPE_MFFGPR)
22998                 return 2;
22999               break;
23000             default:
23001               break;
23002             }
23003         }
23004     case REG_DEP_ANTI:
23005       /* Anti dependency; DEP_INSN reads a register that INSN writes some
23006          cycles later.  */
23007       return 0;
23008
23009     default:
23010       gcc_unreachable ();
23011     }
23012
23013   return cost;
23014 }
23015
23016 /* Debug version of rs6000_adjust_cost.  */
23017
23018 static int
23019 rs6000_debug_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
23020 {
23021   int ret = rs6000_adjust_cost (insn, link, dep_insn, cost);
23022
23023   if (ret != cost)
23024     {
23025       const char *dep;
23026
23027       switch (REG_NOTE_KIND (link))
23028         {
23029         default:             dep = "unknown depencency"; break;
23030         case REG_DEP_TRUE:   dep = "data dependency";    break;
23031         case REG_DEP_OUTPUT: dep = "output dependency";  break;
23032         case REG_DEP_ANTI:   dep = "anti depencency";    break;
23033         }
23034
23035       fprintf (stderr,
23036                "\nrs6000_adjust_cost, final cost = %d, orig cost = %d, "
23037                "%s, insn:\n", ret, cost, dep);
23038
23039       debug_rtx (insn);
23040     }
23041
23042   return ret;
23043 }
23044
23045 /* The function returns a true if INSN is microcoded.
23046    Return false otherwise.  */
23047
23048 static bool
23049 is_microcoded_insn (rtx insn)
23050 {
23051   if (!insn || !NONDEBUG_INSN_P (insn)
23052       || GET_CODE (PATTERN (insn)) == USE
23053       || GET_CODE (PATTERN (insn)) == CLOBBER)
23054     return false;
23055
23056   if (rs6000_cpu_attr == CPU_CELL)
23057     return get_attr_cell_micro (insn) == CELL_MICRO_ALWAYS;
23058
23059   if (rs6000_sched_groups)
23060     {
23061       enum attr_type type = get_attr_type (insn);
23062       if (type == TYPE_LOAD_EXT_U
23063           || type == TYPE_LOAD_EXT_UX
23064           || type == TYPE_LOAD_UX
23065           || type == TYPE_STORE_UX
23066           || type == TYPE_MFCR)
23067         return true;
23068     }
23069
23070   return false;
23071 }
23072
23073 /* The function returns true if INSN is cracked into 2 instructions
23074    by the processor (and therefore occupies 2 issue slots).  */
23075
23076 static bool
23077 is_cracked_insn (rtx insn)
23078 {
23079   if (!insn || !NONDEBUG_INSN_P (insn)
23080       || GET_CODE (PATTERN (insn)) == USE
23081       || GET_CODE (PATTERN (insn)) == CLOBBER)
23082     return false;
23083
23084   if (rs6000_sched_groups)
23085     {
23086       enum attr_type type = get_attr_type (insn);
23087       if (type == TYPE_LOAD_U || type == TYPE_STORE_U
23088           || type == TYPE_FPLOAD_U || type == TYPE_FPSTORE_U
23089           || type == TYPE_FPLOAD_UX || type == TYPE_FPSTORE_UX
23090           || type == TYPE_LOAD_EXT || type == TYPE_DELAYED_CR
23091           || type == TYPE_COMPARE || type == TYPE_DELAYED_COMPARE
23092           || type == TYPE_IMUL_COMPARE || type == TYPE_LMUL_COMPARE
23093           || type == TYPE_IDIV || type == TYPE_LDIV
23094           || type == TYPE_INSERT_WORD)
23095         return true;
23096     }
23097
23098   return false;
23099 }
23100
23101 /* The function returns true if INSN can be issued only from
23102    the branch slot.  */
23103
23104 static bool
23105 is_branch_slot_insn (rtx insn)
23106 {
23107   if (!insn || !NONDEBUG_INSN_P (insn)
23108       || GET_CODE (PATTERN (insn)) == USE
23109       || GET_CODE (PATTERN (insn)) == CLOBBER)
23110     return false;
23111
23112   if (rs6000_sched_groups)
23113     {
23114       enum attr_type type = get_attr_type (insn);
23115       if (type == TYPE_BRANCH || type == TYPE_JMPREG)
23116         return true;
23117       return false;
23118     }
23119
23120   return false;
23121 }
23122
23123 /* The function returns true if out_inst sets a value that is
23124    used in the address generation computation of in_insn */
23125 static bool
23126 set_to_load_agen (rtx out_insn, rtx in_insn)
23127 {
23128   rtx out_set, in_set;
23129
23130   /* For performance reasons, only handle the simple case where
23131      both loads are a single_set. */
23132   out_set = single_set (out_insn);
23133   if (out_set)
23134     {
23135       in_set = single_set (in_insn);
23136       if (in_set)
23137         return reg_mentioned_p (SET_DEST (out_set), SET_SRC (in_set));
23138     }
23139
23140   return false;
23141 }
23142
23143 /* The function returns true if the target storage location of
23144    out_insn is adjacent to the target storage location of in_insn */
23145 /* Return 1 if memory locations are adjacent.  */
23146
23147 static bool
23148 adjacent_mem_locations (rtx insn1, rtx insn2)
23149 {
23150
23151   rtx a = get_store_dest (PATTERN (insn1));
23152   rtx b = get_store_dest (PATTERN (insn2));
23153
23154   if ((GET_CODE (XEXP (a, 0)) == REG
23155        || (GET_CODE (XEXP (a, 0)) == PLUS
23156            && GET_CODE (XEXP (XEXP (a, 0), 1)) == CONST_INT))
23157       && (GET_CODE (XEXP (b, 0)) == REG
23158           || (GET_CODE (XEXP (b, 0)) == PLUS
23159               && GET_CODE (XEXP (XEXP (b, 0), 1)) == CONST_INT)))
23160     {
23161       HOST_WIDE_INT val0 = 0, val1 = 0, val_diff;
23162       rtx reg0, reg1;
23163
23164       if (GET_CODE (XEXP (a, 0)) == PLUS)
23165         {
23166           reg0 = XEXP (XEXP (a, 0), 0);
23167           val0 = INTVAL (XEXP (XEXP (a, 0), 1));
23168         }
23169       else
23170         reg0 = XEXP (a, 0);
23171
23172       if (GET_CODE (XEXP (b, 0)) == PLUS)
23173         {
23174           reg1 = XEXP (XEXP (b, 0), 0);
23175           val1 = INTVAL (XEXP (XEXP (b, 0), 1));
23176         }
23177       else
23178         reg1 = XEXP (b, 0);
23179
23180       val_diff = val1 - val0;
23181
23182       return ((REGNO (reg0) == REGNO (reg1))
23183               && ((MEM_SIZE_KNOWN_P (a) && val_diff == MEM_SIZE (a))
23184                   || (MEM_SIZE_KNOWN_P (b) && val_diff == -MEM_SIZE (b))));
23185     }
23186
23187   return false;
23188 }
23189
23190 /* A C statement (sans semicolon) to update the integer scheduling
23191    priority INSN_PRIORITY (INSN). Increase the priority to execute the
23192    INSN earlier, reduce the priority to execute INSN later.  Do not
23193    define this macro if you do not need to adjust the scheduling
23194    priorities of insns.  */
23195
23196 static int
23197 rs6000_adjust_priority (rtx insn ATTRIBUTE_UNUSED, int priority)
23198 {
23199   /* On machines (like the 750) which have asymmetric integer units,
23200      where one integer unit can do multiply and divides and the other
23201      can't, reduce the priority of multiply/divide so it is scheduled
23202      before other integer operations.  */
23203
23204 #if 0
23205   if (! INSN_P (insn))
23206     return priority;
23207
23208   if (GET_CODE (PATTERN (insn)) == USE)
23209     return priority;
23210
23211   switch (rs6000_cpu_attr) {
23212   case CPU_PPC750:
23213     switch (get_attr_type (insn))
23214       {
23215       default:
23216         break;
23217
23218       case TYPE_IMUL:
23219       case TYPE_IDIV:
23220         fprintf (stderr, "priority was %#x (%d) before adjustment\n",
23221                  priority, priority);
23222         if (priority >= 0 && priority < 0x01000000)
23223           priority >>= 3;
23224         break;
23225       }
23226   }
23227 #endif
23228
23229   if (insn_must_be_first_in_group (insn)
23230       && reload_completed
23231       && current_sched_info->sched_max_insns_priority
23232       && rs6000_sched_restricted_insns_priority)
23233     {
23234
23235       /* Prioritize insns that can be dispatched only in the first
23236          dispatch slot.  */
23237       if (rs6000_sched_restricted_insns_priority == 1)
23238         /* Attach highest priority to insn. This means that in
23239            haifa-sched.c:ready_sort(), dispatch-slot restriction considerations
23240            precede 'priority' (critical path) considerations.  */
23241         return current_sched_info->sched_max_insns_priority;
23242       else if (rs6000_sched_restricted_insns_priority == 2)
23243         /* Increase priority of insn by a minimal amount. This means that in
23244            haifa-sched.c:ready_sort(), only 'priority' (critical path)
23245            considerations precede dispatch-slot restriction considerations.  */
23246         return (priority + 1);
23247     }
23248
23249   if (rs6000_cpu == PROCESSOR_POWER6
23250       && ((load_store_pendulum == -2 && is_load_insn (insn))
23251           || (load_store_pendulum == 2 && is_store_insn (insn))))
23252     /* Attach highest priority to insn if the scheduler has just issued two
23253        stores and this instruction is a load, or two loads and this instruction
23254        is a store. Power6 wants loads and stores scheduled alternately
23255        when possible */
23256     return current_sched_info->sched_max_insns_priority;
23257
23258   return priority;
23259 }
23260
23261 /* Return true if the instruction is nonpipelined on the Cell. */
23262 static bool
23263 is_nonpipeline_insn (rtx insn)
23264 {
23265   enum attr_type type;
23266   if (!insn || !NONDEBUG_INSN_P (insn)
23267       || GET_CODE (PATTERN (insn)) == USE
23268       || GET_CODE (PATTERN (insn)) == CLOBBER)
23269     return false;
23270
23271   type = get_attr_type (insn);
23272   if (type == TYPE_IMUL
23273       || type == TYPE_IMUL2
23274       || type == TYPE_IMUL3
23275       || type == TYPE_LMUL
23276       || type == TYPE_IDIV
23277       || type == TYPE_LDIV
23278       || type == TYPE_SDIV
23279       || type == TYPE_DDIV
23280       || type == TYPE_SSQRT
23281       || type == TYPE_DSQRT
23282       || type == TYPE_MFCR
23283       || type == TYPE_MFCRF
23284       || type == TYPE_MFJMPR)
23285     {
23286       return true;
23287     }
23288   return false;
23289 }
23290
23291
23292 /* Return how many instructions the machine can issue per cycle.  */
23293
23294 static int
23295 rs6000_issue_rate (void)
23296 {
23297   /* Unless scheduling for register pressure, use issue rate of 1 for
23298      first scheduling pass to decrease degradation.  */
23299   if (!reload_completed && !flag_sched_pressure)
23300     return 1;
23301
23302   switch (rs6000_cpu_attr) {
23303   case CPU_RIOS1:  /* ? */
23304   case CPU_RS64A:
23305   case CPU_PPC601: /* ? */
23306   case CPU_PPC7450:
23307     return 3;
23308   case CPU_PPC440:
23309   case CPU_PPC603:
23310   case CPU_PPC750:
23311   case CPU_PPC7400:
23312   case CPU_PPC8540:
23313   case CPU_CELL:
23314   case CPU_PPCE300C2:
23315   case CPU_PPCE300C3:
23316   case CPU_PPCE500MC:
23317   case CPU_PPCE500MC64:
23318   case CPU_TITAN:
23319     return 2;
23320   case CPU_RIOS2:
23321   case CPU_PPC476:
23322   case CPU_PPC604:
23323   case CPU_PPC604E:
23324   case CPU_PPC620:
23325   case CPU_PPC630:
23326     return 4;
23327   case CPU_POWER4:
23328   case CPU_POWER5:
23329   case CPU_POWER6:
23330   case CPU_POWER7:
23331     return 5;
23332   default:
23333     return 1;
23334   }
23335 }
23336
23337 /* Return how many instructions to look ahead for better insn
23338    scheduling.  */
23339
23340 static int
23341 rs6000_use_sched_lookahead (void)
23342 {
23343   if (rs6000_cpu_attr == CPU_PPC8540)
23344     return 4;
23345   if (rs6000_cpu_attr == CPU_CELL)
23346     return (reload_completed ? 8 : 0);
23347   return 0;
23348 }
23349
23350 /* We are choosing insn from the ready queue.  Return nonzero if INSN can be chosen.  */
23351 static int
23352 rs6000_use_sched_lookahead_guard (rtx insn)
23353 {
23354   if (rs6000_cpu_attr != CPU_CELL)
23355     return 1;
23356
23357    if (insn == NULL_RTX || !INSN_P (insn))
23358      abort ();
23359
23360   if (!reload_completed
23361       || is_nonpipeline_insn (insn)
23362       || is_microcoded_insn (insn))
23363     return 0;
23364
23365   return 1;
23366 }
23367
23368 /* Determine is PAT refers to memory.  */
23369
23370 static bool
23371 is_mem_ref (rtx pat)
23372 {
23373   const char * fmt;
23374   int i, j;
23375   bool ret = false;
23376
23377   /* stack_tie does not produce any real memory traffic.  */
23378   if (GET_CODE (pat) == UNSPEC
23379       && XINT (pat, 1) == UNSPEC_TIE)
23380     return false;
23381
23382   if (GET_CODE (pat) == MEM)
23383     return true;
23384
23385   /* Recursively process the pattern.  */
23386   fmt = GET_RTX_FORMAT (GET_CODE (pat));
23387
23388   for (i = GET_RTX_LENGTH (GET_CODE (pat)) - 1; i >= 0 && !ret; i--)
23389     {
23390       if (fmt[i] == 'e')
23391         ret |= is_mem_ref (XEXP (pat, i));
23392       else if (fmt[i] == 'E')
23393         for (j = XVECLEN (pat, i) - 1; j >= 0; j--)
23394           ret |= is_mem_ref (XVECEXP (pat, i, j));
23395     }
23396
23397   return ret;
23398 }
23399
23400 /* Determine if PAT is a PATTERN of a load insn.  */
23401
23402 static bool
23403 is_load_insn1 (rtx pat)
23404 {
23405   if (!pat || pat == NULL_RTX)
23406     return false;
23407
23408   if (GET_CODE (pat) == SET)
23409     return is_mem_ref (SET_SRC (pat));
23410
23411   if (GET_CODE (pat) == PARALLEL)
23412     {
23413       int i;
23414
23415       for (i = 0; i < XVECLEN (pat, 0); i++)
23416         if (is_load_insn1 (XVECEXP (pat, 0, i)))
23417           return true;
23418     }
23419
23420   return false;
23421 }
23422
23423 /* Determine if INSN loads from memory.  */
23424
23425 static bool
23426 is_load_insn (rtx insn)
23427 {
23428   if (!insn || !INSN_P (insn))
23429     return false;
23430
23431   if (GET_CODE (insn) == CALL_INSN)
23432     return false;
23433
23434   return is_load_insn1 (PATTERN (insn));
23435 }
23436
23437 /* Determine if PAT is a PATTERN of a store insn.  */
23438
23439 static bool
23440 is_store_insn1 (rtx pat)
23441 {
23442   if (!pat || pat == NULL_RTX)
23443     return false;
23444
23445   if (GET_CODE (pat) == SET)
23446     return is_mem_ref (SET_DEST (pat));
23447
23448   if (GET_CODE (pat) == PARALLEL)
23449     {
23450       int i;
23451
23452       for (i = 0; i < XVECLEN (pat, 0); i++)
23453         if (is_store_insn1 (XVECEXP (pat, 0, i)))
23454           return true;
23455     }
23456
23457   return false;
23458 }
23459
23460 /* Determine if INSN stores to memory.  */
23461
23462 static bool
23463 is_store_insn (rtx insn)
23464 {
23465   if (!insn || !INSN_P (insn))
23466     return false;
23467
23468   return is_store_insn1 (PATTERN (insn));
23469 }
23470
23471 /* Return the dest of a store insn.  */
23472
23473 static rtx
23474 get_store_dest (rtx pat)
23475 {
23476   gcc_assert (is_store_insn1 (pat));
23477
23478   if (GET_CODE (pat) == SET)
23479     return SET_DEST (pat);
23480   else if (GET_CODE (pat) == PARALLEL)
23481     {
23482       int i;
23483
23484       for (i = 0; i < XVECLEN (pat, 0); i++)
23485         {
23486           rtx inner_pat = XVECEXP (pat, 0, i);
23487           if (GET_CODE (inner_pat) == SET
23488               && is_mem_ref (SET_DEST (inner_pat)))
23489             return inner_pat;
23490         }
23491     }
23492   /* We shouldn't get here, because we should have either a simple
23493      store insn or a store with update which are covered above.  */
23494   gcc_unreachable();
23495 }
23496
23497 /* Returns whether the dependence between INSN and NEXT is considered
23498    costly by the given target.  */
23499
23500 static bool
23501 rs6000_is_costly_dependence (dep_t dep, int cost, int distance)
23502 {
23503   rtx insn;
23504   rtx next;
23505
23506   /* If the flag is not enabled - no dependence is considered costly;
23507      allow all dependent insns in the same group.
23508      This is the most aggressive option.  */
23509   if (rs6000_sched_costly_dep == no_dep_costly)
23510     return false;
23511
23512   /* If the flag is set to 1 - a dependence is always considered costly;
23513      do not allow dependent instructions in the same group.
23514      This is the most conservative option.  */
23515   if (rs6000_sched_costly_dep == all_deps_costly)
23516     return true;
23517
23518   insn = DEP_PRO (dep);
23519   next = DEP_CON (dep);
23520
23521   if (rs6000_sched_costly_dep == store_to_load_dep_costly
23522       && is_load_insn (next)
23523       && is_store_insn (insn))
23524     /* Prevent load after store in the same group.  */
23525     return true;
23526
23527   if (rs6000_sched_costly_dep == true_store_to_load_dep_costly
23528       && is_load_insn (next)
23529       && is_store_insn (insn)
23530       && DEP_TYPE (dep) == REG_DEP_TRUE)
23531      /* Prevent load after store in the same group if it is a true
23532         dependence.  */
23533      return true;
23534
23535   /* The flag is set to X; dependences with latency >= X are considered costly,
23536      and will not be scheduled in the same group.  */
23537   if (rs6000_sched_costly_dep <= max_dep_latency
23538       && ((cost - distance) >= (int)rs6000_sched_costly_dep))
23539     return true;
23540
23541   return false;
23542 }
23543
23544 /* Return the next insn after INSN that is found before TAIL is reached,
23545    skipping any "non-active" insns - insns that will not actually occupy
23546    an issue slot.  Return NULL_RTX if such an insn is not found.  */
23547
23548 static rtx
23549 get_next_active_insn (rtx insn, rtx tail)
23550 {
23551   if (insn == NULL_RTX || insn == tail)
23552     return NULL_RTX;
23553
23554   while (1)
23555     {
23556       insn = NEXT_INSN (insn);
23557       if (insn == NULL_RTX || insn == tail)
23558         return NULL_RTX;
23559
23560       if (CALL_P (insn)
23561           || JUMP_P (insn)
23562           || (NONJUMP_INSN_P (insn)
23563               && GET_CODE (PATTERN (insn)) != USE
23564               && GET_CODE (PATTERN (insn)) != CLOBBER
23565               && INSN_CODE (insn) != CODE_FOR_stack_tie))
23566         break;
23567     }
23568   return insn;
23569 }
23570
23571 /* We are about to begin issuing insns for this clock cycle. */
23572
23573 static int
23574 rs6000_sched_reorder (FILE *dump ATTRIBUTE_UNUSED, int sched_verbose,
23575                         rtx *ready ATTRIBUTE_UNUSED,
23576                         int *pn_ready ATTRIBUTE_UNUSED,
23577                         int clock_var ATTRIBUTE_UNUSED)
23578 {
23579   int n_ready = *pn_ready;
23580
23581   if (sched_verbose)
23582     fprintf (dump, "// rs6000_sched_reorder :\n");
23583
23584   /* Reorder the ready list, if the second to last ready insn
23585      is a nonepipeline insn.  */
23586   if (rs6000_cpu_attr == CPU_CELL && n_ready > 1)
23587   {
23588     if (is_nonpipeline_insn (ready[n_ready - 1])
23589         && (recog_memoized (ready[n_ready - 2]) > 0))
23590       /* Simply swap first two insns.  */
23591       {
23592         rtx tmp = ready[n_ready - 1];
23593         ready[n_ready - 1] = ready[n_ready - 2];
23594         ready[n_ready - 2] = tmp;
23595       }
23596   }
23597
23598   if (rs6000_cpu == PROCESSOR_POWER6)
23599     load_store_pendulum = 0;
23600
23601   return rs6000_issue_rate ();
23602 }
23603
23604 /* Like rs6000_sched_reorder, but called after issuing each insn.  */
23605
23606 static int
23607 rs6000_sched_reorder2 (FILE *dump, int sched_verbose, rtx *ready,
23608                          int *pn_ready, int clock_var ATTRIBUTE_UNUSED)
23609 {
23610   if (sched_verbose)
23611     fprintf (dump, "// rs6000_sched_reorder2 :\n");
23612
23613   /* For Power6, we need to handle some special cases to try and keep the
23614      store queue from overflowing and triggering expensive flushes.
23615
23616      This code monitors how load and store instructions are being issued
23617      and skews the ready list one way or the other to increase the likelihood
23618      that a desired instruction is issued at the proper time.
23619
23620      A couple of things are done.  First, we maintain a "load_store_pendulum"
23621      to track the current state of load/store issue.
23622
23623        - If the pendulum is at zero, then no loads or stores have been
23624          issued in the current cycle so we do nothing.
23625
23626        - If the pendulum is 1, then a single load has been issued in this
23627          cycle and we attempt to locate another load in the ready list to
23628          issue with it.
23629
23630        - If the pendulum is -2, then two stores have already been
23631          issued in this cycle, so we increase the priority of the first load
23632          in the ready list to increase it's likelihood of being chosen first
23633          in the next cycle.
23634
23635        - If the pendulum is -1, then a single store has been issued in this
23636          cycle and we attempt to locate another store in the ready list to
23637          issue with it, preferring a store to an adjacent memory location to
23638          facilitate store pairing in the store queue.
23639
23640        - If the pendulum is 2, then two loads have already been
23641          issued in this cycle, so we increase the priority of the first store
23642          in the ready list to increase it's likelihood of being chosen first
23643          in the next cycle.
23644
23645        - If the pendulum < -2 or > 2, then do nothing.
23646
23647        Note: This code covers the most common scenarios.  There exist non
23648              load/store instructions which make use of the LSU and which
23649              would need to be accounted for to strictly model the behavior
23650              of the machine.  Those instructions are currently unaccounted
23651              for to help minimize compile time overhead of this code.
23652    */
23653   if (rs6000_cpu == PROCESSOR_POWER6 && last_scheduled_insn)
23654     {
23655       int pos;
23656       int i;
23657       rtx tmp;
23658
23659       if (is_store_insn (last_scheduled_insn))
23660         /* Issuing a store, swing the load_store_pendulum to the left */
23661         load_store_pendulum--;
23662       else if (is_load_insn (last_scheduled_insn))
23663         /* Issuing a load, swing the load_store_pendulum to the right */
23664         load_store_pendulum++;
23665       else
23666         return cached_can_issue_more;
23667
23668       /* If the pendulum is balanced, or there is only one instruction on
23669          the ready list, then all is well, so return. */
23670       if ((load_store_pendulum == 0) || (*pn_ready <= 1))
23671         return cached_can_issue_more;
23672
23673       if (load_store_pendulum == 1)
23674         {
23675           /* A load has been issued in this cycle.  Scan the ready list
23676              for another load to issue with it */
23677           pos = *pn_ready-1;
23678
23679           while (pos >= 0)
23680             {
23681               if (is_load_insn (ready[pos]))
23682                 {
23683                   /* Found a load.  Move it to the head of the ready list,
23684                      and adjust it's priority so that it is more likely to
23685                      stay there */
23686                   tmp = ready[pos];
23687                   for (i=pos; i<*pn_ready-1; i++)
23688                     ready[i] = ready[i + 1];
23689                   ready[*pn_ready-1] = tmp;
23690
23691                   if (!sel_sched_p () && INSN_PRIORITY_KNOWN (tmp))
23692                     INSN_PRIORITY (tmp)++;
23693                   break;
23694                 }
23695               pos--;
23696             }
23697         }
23698       else if (load_store_pendulum == -2)
23699         {
23700           /* Two stores have been issued in this cycle.  Increase the
23701              priority of the first load in the ready list to favor it for
23702              issuing in the next cycle. */
23703           pos = *pn_ready-1;
23704
23705           while (pos >= 0)
23706             {
23707               if (is_load_insn (ready[pos])
23708                   && !sel_sched_p ()
23709                   && INSN_PRIORITY_KNOWN (ready[pos]))
23710                 {
23711                   INSN_PRIORITY (ready[pos])++;
23712
23713                   /* Adjust the pendulum to account for the fact that a load
23714                      was found and increased in priority.  This is to prevent
23715                      increasing the priority of multiple loads */
23716                   load_store_pendulum--;
23717
23718                   break;
23719                 }
23720               pos--;
23721             }
23722         }
23723       else if (load_store_pendulum == -1)
23724         {
23725           /* A store has been issued in this cycle.  Scan the ready list for
23726              another store to issue with it, preferring a store to an adjacent
23727              memory location */
23728           int first_store_pos = -1;
23729
23730           pos = *pn_ready-1;
23731
23732           while (pos >= 0)
23733             {
23734               if (is_store_insn (ready[pos]))
23735                 {
23736                   /* Maintain the index of the first store found on the
23737                      list */
23738                   if (first_store_pos == -1)
23739                     first_store_pos = pos;
23740
23741                   if (is_store_insn (last_scheduled_insn)
23742                       && adjacent_mem_locations (last_scheduled_insn,ready[pos]))
23743                     {
23744                       /* Found an adjacent store.  Move it to the head of the
23745                          ready list, and adjust it's priority so that it is
23746                          more likely to stay there */
23747                       tmp = ready[pos];
23748                       for (i=pos; i<*pn_ready-1; i++)
23749                         ready[i] = ready[i + 1];
23750                       ready[*pn_ready-1] = tmp;
23751
23752                       if (!sel_sched_p () && INSN_PRIORITY_KNOWN (tmp))
23753                         INSN_PRIORITY (tmp)++;
23754
23755                       first_store_pos = -1;
23756
23757                       break;
23758                     };
23759                 }
23760               pos--;
23761             }
23762
23763           if (first_store_pos >= 0)
23764             {
23765               /* An adjacent store wasn't found, but a non-adjacent store was,
23766                  so move the non-adjacent store to the front of the ready
23767                  list, and adjust its priority so that it is more likely to
23768                  stay there. */
23769               tmp = ready[first_store_pos];
23770               for (i=first_store_pos; i<*pn_ready-1; i++)
23771                 ready[i] = ready[i + 1];
23772               ready[*pn_ready-1] = tmp;
23773               if (!sel_sched_p () && INSN_PRIORITY_KNOWN (tmp))
23774                 INSN_PRIORITY (tmp)++;
23775             }
23776         }
23777       else if (load_store_pendulum == 2)
23778        {
23779            /* Two loads have been issued in this cycle.  Increase the priority
23780               of the first store in the ready list to favor it for issuing in
23781               the next cycle. */
23782           pos = *pn_ready-1;
23783
23784           while (pos >= 0)
23785             {
23786               if (is_store_insn (ready[pos])
23787                   && !sel_sched_p ()
23788                   && INSN_PRIORITY_KNOWN (ready[pos]))
23789                 {
23790                   INSN_PRIORITY (ready[pos])++;
23791
23792                   /* Adjust the pendulum to account for the fact that a store
23793                      was found and increased in priority.  This is to prevent
23794                      increasing the priority of multiple stores */
23795                   load_store_pendulum++;
23796
23797                   break;
23798                 }
23799               pos--;
23800             }
23801         }
23802     }
23803
23804   return cached_can_issue_more;
23805 }
23806
23807 /* Return whether the presence of INSN causes a dispatch group termination
23808    of group WHICH_GROUP.
23809
23810    If WHICH_GROUP == current_group, this function will return true if INSN
23811    causes the termination of the current group (i.e, the dispatch group to
23812    which INSN belongs). This means that INSN will be the last insn in the
23813    group it belongs to.
23814
23815    If WHICH_GROUP == previous_group, this function will return true if INSN
23816    causes the termination of the previous group (i.e, the dispatch group that
23817    precedes the group to which INSN belongs).  This means that INSN will be
23818    the first insn in the group it belongs to).  */
23819
23820 static bool
23821 insn_terminates_group_p (rtx insn, enum group_termination which_group)
23822 {
23823   bool first, last;
23824
23825   if (! insn)
23826     return false;
23827
23828   first = insn_must_be_first_in_group (insn);
23829   last = insn_must_be_last_in_group (insn);
23830
23831   if (first && last)
23832     return true;
23833
23834   if (which_group == current_group)
23835     return last;
23836   else if (which_group == previous_group)
23837     return first;
23838
23839   return false;
23840 }
23841
23842
23843 static bool
23844 insn_must_be_first_in_group (rtx insn)
23845 {
23846   enum attr_type type;
23847
23848   if (!insn
23849       || GET_CODE (insn) == NOTE
23850       || DEBUG_INSN_P (insn)
23851       || GET_CODE (PATTERN (insn)) == USE
23852       || GET_CODE (PATTERN (insn)) == CLOBBER)
23853     return false;
23854
23855   switch (rs6000_cpu)
23856     {
23857     case PROCESSOR_POWER5:
23858       if (is_cracked_insn (insn))
23859         return true;
23860     case PROCESSOR_POWER4:
23861       if (is_microcoded_insn (insn))
23862         return true;
23863
23864       if (!rs6000_sched_groups)
23865         return false;
23866
23867       type = get_attr_type (insn);
23868
23869       switch (type)
23870         {
23871         case TYPE_MFCR:
23872         case TYPE_MFCRF:
23873         case TYPE_MTCR:
23874         case TYPE_DELAYED_CR:
23875         case TYPE_CR_LOGICAL:
23876         case TYPE_MTJMPR:
23877         case TYPE_MFJMPR:
23878         case TYPE_IDIV:
23879         case TYPE_LDIV:
23880         case TYPE_LOAD_L:
23881         case TYPE_STORE_C:
23882         case TYPE_ISYNC:
23883         case TYPE_SYNC:
23884           return true;
23885         default:
23886           break;
23887         }
23888       break;
23889     case PROCESSOR_POWER6:
23890       type = get_attr_type (insn);
23891
23892       switch (type)
23893         {
23894         case TYPE_INSERT_DWORD:
23895         case TYPE_EXTS:
23896         case TYPE_CNTLZ:
23897         case TYPE_SHIFT:
23898         case TYPE_VAR_SHIFT_ROTATE:
23899         case TYPE_TRAP:
23900         case TYPE_IMUL:
23901         case TYPE_IMUL2:
23902         case TYPE_IMUL3:
23903         case TYPE_LMUL:
23904         case TYPE_IDIV:
23905         case TYPE_INSERT_WORD:
23906         case TYPE_DELAYED_COMPARE:
23907         case TYPE_IMUL_COMPARE:
23908         case TYPE_LMUL_COMPARE:
23909         case TYPE_FPCOMPARE:
23910         case TYPE_MFCR:
23911         case TYPE_MTCR:
23912         case TYPE_MFJMPR:
23913         case TYPE_MTJMPR:
23914         case TYPE_ISYNC:
23915         case TYPE_SYNC:
23916         case TYPE_LOAD_L:
23917         case TYPE_STORE_C:
23918         case TYPE_LOAD_U:
23919         case TYPE_LOAD_UX:
23920         case TYPE_LOAD_EXT_UX:
23921         case TYPE_STORE_U:
23922         case TYPE_STORE_UX:
23923         case TYPE_FPLOAD_U:
23924         case TYPE_FPLOAD_UX:
23925         case TYPE_FPSTORE_U:
23926         case TYPE_FPSTORE_UX:
23927           return true;
23928         default:
23929           break;
23930         }
23931       break;
23932     case PROCESSOR_POWER7:
23933       type = get_attr_type (insn);
23934
23935       switch (type)
23936         {
23937         case TYPE_CR_LOGICAL:
23938         case TYPE_MFCR:
23939         case TYPE_MFCRF:
23940         case TYPE_MTCR:
23941         case TYPE_IDIV:
23942         case TYPE_LDIV:
23943         case TYPE_COMPARE:
23944         case TYPE_DELAYED_COMPARE:
23945         case TYPE_VAR_DELAYED_COMPARE:
23946         case TYPE_ISYNC:
23947         case TYPE_LOAD_L:
23948         case TYPE_STORE_C:
23949         case TYPE_LOAD_U:
23950         case TYPE_LOAD_UX:
23951         case TYPE_LOAD_EXT:
23952         case TYPE_LOAD_EXT_U:
23953         case TYPE_LOAD_EXT_UX:
23954         case TYPE_STORE_U:
23955         case TYPE_STORE_UX:
23956         case TYPE_FPLOAD_U:
23957         case TYPE_FPLOAD_UX:
23958         case TYPE_FPSTORE_U:
23959         case TYPE_FPSTORE_UX:
23960         case TYPE_MFJMPR:
23961         case TYPE_MTJMPR:
23962           return true;
23963         default:
23964           break;
23965         }
23966       break;
23967     default:
23968       break;
23969     }
23970
23971   return false;
23972 }
23973
23974 static bool
23975 insn_must_be_last_in_group (rtx insn)
23976 {
23977   enum attr_type type;
23978
23979   if (!insn
23980       || GET_CODE (insn) == NOTE
23981       || DEBUG_INSN_P (insn)
23982       || GET_CODE (PATTERN (insn)) == USE
23983       || GET_CODE (PATTERN (insn)) == CLOBBER)
23984     return false;
23985
23986   switch (rs6000_cpu) {
23987   case PROCESSOR_POWER4:
23988   case PROCESSOR_POWER5:
23989     if (is_microcoded_insn (insn))
23990       return true;
23991
23992     if (is_branch_slot_insn (insn))
23993       return true;
23994
23995     break;
23996   case PROCESSOR_POWER6:
23997     type = get_attr_type (insn);
23998
23999     switch (type)
24000       {
24001       case TYPE_EXTS:
24002       case TYPE_CNTLZ:
24003       case TYPE_SHIFT:
24004       case TYPE_VAR_SHIFT_ROTATE:
24005       case TYPE_TRAP:
24006       case TYPE_IMUL:
24007       case TYPE_IMUL2:
24008       case TYPE_IMUL3:
24009       case TYPE_LMUL:
24010       case TYPE_IDIV:
24011       case TYPE_DELAYED_COMPARE:
24012       case TYPE_IMUL_COMPARE:
24013       case TYPE_LMUL_COMPARE:
24014       case TYPE_FPCOMPARE:
24015       case TYPE_MFCR:
24016       case TYPE_MTCR:
24017       case TYPE_MFJMPR:
24018       case TYPE_MTJMPR:
24019       case TYPE_ISYNC:
24020       case TYPE_SYNC:
24021       case TYPE_LOAD_L:
24022       case TYPE_STORE_C:
24023         return true;
24024       default:
24025         break;
24026     }
24027     break;
24028   case PROCESSOR_POWER7:
24029     type = get_attr_type (insn);
24030
24031     switch (type)
24032       {
24033       case TYPE_ISYNC:
24034       case TYPE_SYNC:
24035       case TYPE_LOAD_L:
24036       case TYPE_STORE_C:
24037       case TYPE_LOAD_EXT_U:
24038       case TYPE_LOAD_EXT_UX:
24039       case TYPE_STORE_UX:
24040         return true;
24041       default:
24042         break;
24043     }
24044     break;
24045   default:
24046     break;
24047   }
24048
24049   return false;
24050 }
24051
24052 /* Return true if it is recommended to keep NEXT_INSN "far" (in a separate
24053    dispatch group) from the insns in GROUP_INSNS.  Return false otherwise.  */
24054
24055 static bool
24056 is_costly_group (rtx *group_insns, rtx next_insn)
24057 {
24058   int i;
24059   int issue_rate = rs6000_issue_rate ();
24060
24061   for (i = 0; i < issue_rate; i++)
24062     {
24063       sd_iterator_def sd_it;
24064       dep_t dep;
24065       rtx insn = group_insns[i];
24066
24067       if (!insn)
24068         continue;
24069
24070       FOR_EACH_DEP (insn, SD_LIST_FORW, sd_it, dep)
24071         {
24072           rtx next = DEP_CON (dep);
24073
24074           if (next == next_insn
24075               && rs6000_is_costly_dependence (dep, dep_cost (dep), 0))
24076             return true;
24077         }
24078     }
24079
24080   return false;
24081 }
24082
24083 /* Utility of the function redefine_groups.
24084    Check if it is too costly to schedule NEXT_INSN together with GROUP_INSNS
24085    in the same dispatch group.  If so, insert nops before NEXT_INSN, in order
24086    to keep it "far" (in a separate group) from GROUP_INSNS, following
24087    one of the following schemes, depending on the value of the flag
24088    -minsert_sched_nops = X:
24089    (1) X == sched_finish_regroup_exact: insert exactly as many nops as needed
24090        in order to force NEXT_INSN into a separate group.
24091    (2) X < sched_finish_regroup_exact: insert exactly X nops.
24092    GROUP_END, CAN_ISSUE_MORE and GROUP_COUNT record the state after nop
24093    insertion (has a group just ended, how many vacant issue slots remain in the
24094    last group, and how many dispatch groups were encountered so far).  */
24095
24096 static int
24097 force_new_group (int sched_verbose, FILE *dump, rtx *group_insns,
24098                  rtx next_insn, bool *group_end, int can_issue_more,
24099                  int *group_count)
24100 {
24101   rtx nop;
24102   bool force;
24103   int issue_rate = rs6000_issue_rate ();
24104   bool end = *group_end;
24105   int i;
24106
24107   if (next_insn == NULL_RTX || DEBUG_INSN_P (next_insn))
24108     return can_issue_more;
24109
24110   if (rs6000_sched_insert_nops > sched_finish_regroup_exact)
24111     return can_issue_more;
24112
24113   force = is_costly_group (group_insns, next_insn);
24114   if (!force)
24115     return can_issue_more;
24116
24117   if (sched_verbose > 6)
24118     fprintf (dump,"force: group count = %d, can_issue_more = %d\n",
24119              *group_count ,can_issue_more);
24120
24121   if (rs6000_sched_insert_nops == sched_finish_regroup_exact)
24122     {
24123       if (*group_end)
24124         can_issue_more = 0;
24125
24126       /* Since only a branch can be issued in the last issue_slot, it is
24127          sufficient to insert 'can_issue_more - 1' nops if next_insn is not
24128          a branch. If next_insn is a branch, we insert 'can_issue_more' nops;
24129          in this case the last nop will start a new group and the branch
24130          will be forced to the new group.  */
24131       if (can_issue_more && !is_branch_slot_insn (next_insn))
24132         can_issue_more--;
24133
24134       while (can_issue_more > 0)
24135         {
24136           nop = gen_nop ();
24137           emit_insn_before (nop, next_insn);
24138           can_issue_more--;
24139         }
24140
24141       *group_end = true;
24142       return 0;
24143     }
24144
24145   if (rs6000_sched_insert_nops < sched_finish_regroup_exact)
24146     {
24147       int n_nops = rs6000_sched_insert_nops;
24148
24149       /* Nops can't be issued from the branch slot, so the effective
24150          issue_rate for nops is 'issue_rate - 1'.  */
24151       if (can_issue_more == 0)
24152         can_issue_more = issue_rate;
24153       can_issue_more--;
24154       if (can_issue_more == 0)
24155         {
24156           can_issue_more = issue_rate - 1;
24157           (*group_count)++;
24158           end = true;
24159           for (i = 0; i < issue_rate; i++)
24160             {
24161               group_insns[i] = 0;
24162             }
24163         }
24164
24165       while (n_nops > 0)
24166         {
24167           nop = gen_nop ();
24168           emit_insn_before (nop, next_insn);
24169           if (can_issue_more == issue_rate - 1) /* new group begins */
24170             end = false;
24171           can_issue_more--;
24172           if (can_issue_more == 0)
24173             {
24174               can_issue_more = issue_rate - 1;
24175               (*group_count)++;
24176               end = true;
24177               for (i = 0; i < issue_rate; i++)
24178                 {
24179                   group_insns[i] = 0;
24180                 }
24181             }
24182           n_nops--;
24183         }
24184
24185       /* Scale back relative to 'issue_rate' (instead of 'issue_rate - 1').  */
24186       can_issue_more++;
24187
24188       /* Is next_insn going to start a new group?  */
24189       *group_end
24190         = (end
24191            || (can_issue_more == 1 && !is_branch_slot_insn (next_insn))
24192            || (can_issue_more <= 2 && is_cracked_insn (next_insn))
24193            || (can_issue_more < issue_rate &&
24194                insn_terminates_group_p (next_insn, previous_group)));
24195       if (*group_end && end)
24196         (*group_count)--;
24197
24198       if (sched_verbose > 6)
24199         fprintf (dump, "done force: group count = %d, can_issue_more = %d\n",
24200                  *group_count, can_issue_more);
24201       return can_issue_more;
24202     }
24203
24204   return can_issue_more;
24205 }
24206
24207 /* This function tries to synch the dispatch groups that the compiler "sees"
24208    with the dispatch groups that the processor dispatcher is expected to
24209    form in practice.  It tries to achieve this synchronization by forcing the
24210    estimated processor grouping on the compiler (as opposed to the function
24211    'pad_goups' which tries to force the scheduler's grouping on the processor).
24212
24213    The function scans the insn sequence between PREV_HEAD_INSN and TAIL and
24214    examines the (estimated) dispatch groups that will be formed by the processor
24215    dispatcher.  It marks these group boundaries to reflect the estimated
24216    processor grouping, overriding the grouping that the scheduler had marked.
24217    Depending on the value of the flag '-minsert-sched-nops' this function can
24218    force certain insns into separate groups or force a certain distance between
24219    them by inserting nops, for example, if there exists a "costly dependence"
24220    between the insns.
24221
24222    The function estimates the group boundaries that the processor will form as
24223    follows:  It keeps track of how many vacant issue slots are available after
24224    each insn.  A subsequent insn will start a new group if one of the following
24225    4 cases applies:
24226    - no more vacant issue slots remain in the current dispatch group.
24227    - only the last issue slot, which is the branch slot, is vacant, but the next
24228      insn is not a branch.
24229    - only the last 2 or less issue slots, including the branch slot, are vacant,
24230      which means that a cracked insn (which occupies two issue slots) can't be
24231      issued in this group.
24232    - less than 'issue_rate' slots are vacant, and the next insn always needs to
24233      start a new group.  */
24234
24235 static int
24236 redefine_groups (FILE *dump, int sched_verbose, rtx prev_head_insn, rtx tail)
24237 {
24238   rtx insn, next_insn;
24239   int issue_rate;
24240   int can_issue_more;
24241   int slot, i;
24242   bool group_end;
24243   int group_count = 0;
24244   rtx *group_insns;
24245
24246   /* Initialize.  */
24247   issue_rate = rs6000_issue_rate ();
24248   group_insns = XALLOCAVEC (rtx, issue_rate);
24249   for (i = 0; i < issue_rate; i++)
24250     {
24251       group_insns[i] = 0;
24252     }
24253   can_issue_more = issue_rate;
24254   slot = 0;
24255   insn = get_next_active_insn (prev_head_insn, tail);
24256   group_end = false;
24257
24258   while (insn != NULL_RTX)
24259     {
24260       slot = (issue_rate - can_issue_more);
24261       group_insns[slot] = insn;
24262       can_issue_more =
24263         rs6000_variable_issue (dump, sched_verbose, insn, can_issue_more);
24264       if (insn_terminates_group_p (insn, current_group))
24265         can_issue_more = 0;
24266
24267       next_insn = get_next_active_insn (insn, tail);
24268       if (next_insn == NULL_RTX)
24269         return group_count + 1;
24270
24271       /* Is next_insn going to start a new group?  */
24272       group_end
24273         = (can_issue_more == 0
24274            || (can_issue_more == 1 && !is_branch_slot_insn (next_insn))
24275            || (can_issue_more <= 2 && is_cracked_insn (next_insn))
24276            || (can_issue_more < issue_rate &&
24277                insn_terminates_group_p (next_insn, previous_group)));
24278
24279       can_issue_more = force_new_group (sched_verbose, dump, group_insns,
24280                                         next_insn, &group_end, can_issue_more,
24281                                         &group_count);
24282
24283       if (group_end)
24284         {
24285           group_count++;
24286           can_issue_more = 0;
24287           for (i = 0; i < issue_rate; i++)
24288             {
24289               group_insns[i] = 0;
24290             }
24291         }
24292
24293       if (GET_MODE (next_insn) == TImode && can_issue_more)
24294         PUT_MODE (next_insn, VOIDmode);
24295       else if (!can_issue_more && GET_MODE (next_insn) != TImode)
24296         PUT_MODE (next_insn, TImode);
24297
24298       insn = next_insn;
24299       if (can_issue_more == 0)
24300         can_issue_more = issue_rate;
24301     } /* while */
24302
24303   return group_count;
24304 }
24305
24306 /* Scan the insn sequence between PREV_HEAD_INSN and TAIL and examine the
24307    dispatch group boundaries that the scheduler had marked.  Pad with nops
24308    any dispatch groups which have vacant issue slots, in order to force the
24309    scheduler's grouping on the processor dispatcher.  The function
24310    returns the number of dispatch groups found.  */
24311
24312 static int
24313 pad_groups (FILE *dump, int sched_verbose, rtx prev_head_insn, rtx tail)
24314 {
24315   rtx insn, next_insn;
24316   rtx nop;
24317   int issue_rate;
24318   int can_issue_more;
24319   int group_end;
24320   int group_count = 0;
24321
24322   /* Initialize issue_rate.  */
24323   issue_rate = rs6000_issue_rate ();
24324   can_issue_more = issue_rate;
24325
24326   insn = get_next_active_insn (prev_head_insn, tail);
24327   next_insn = get_next_active_insn (insn, tail);
24328
24329   while (insn != NULL_RTX)
24330     {
24331       can_issue_more =
24332         rs6000_variable_issue (dump, sched_verbose, insn, can_issue_more);
24333
24334       group_end = (next_insn == NULL_RTX || GET_MODE (next_insn) == TImode);
24335
24336       if (next_insn == NULL_RTX)
24337         break;
24338
24339       if (group_end)
24340         {
24341           /* If the scheduler had marked group termination at this location
24342              (between insn and next_insn), and neither insn nor next_insn will
24343              force group termination, pad the group with nops to force group
24344              termination.  */
24345           if (can_issue_more
24346               && (rs6000_sched_insert_nops == sched_finish_pad_groups)
24347               && !insn_terminates_group_p (insn, current_group)
24348               && !insn_terminates_group_p (next_insn, previous_group))
24349             {
24350               if (!is_branch_slot_insn (next_insn))
24351                 can_issue_more--;
24352
24353               while (can_issue_more)
24354                 {
24355                   nop = gen_nop ();
24356                   emit_insn_before (nop, next_insn);
24357                   can_issue_more--;
24358                 }
24359             }
24360
24361           can_issue_more = issue_rate;
24362           group_count++;
24363         }
24364
24365       insn = next_insn;
24366       next_insn = get_next_active_insn (insn, tail);
24367     }
24368
24369   return group_count;
24370 }
24371
24372 /* We're beginning a new block.  Initialize data structures as necessary.  */
24373
24374 static void
24375 rs6000_sched_init (FILE *dump ATTRIBUTE_UNUSED,
24376                      int sched_verbose ATTRIBUTE_UNUSED,
24377                      int max_ready ATTRIBUTE_UNUSED)
24378 {
24379   last_scheduled_insn = NULL_RTX;
24380   load_store_pendulum = 0;
24381 }
24382
24383 /* The following function is called at the end of scheduling BB.
24384    After reload, it inserts nops at insn group bundling.  */
24385
24386 static void
24387 rs6000_sched_finish (FILE *dump, int sched_verbose)
24388 {
24389   int n_groups;
24390
24391   if (sched_verbose)
24392     fprintf (dump, "=== Finishing schedule.\n");
24393
24394   if (reload_completed && rs6000_sched_groups)
24395     {
24396       /* Do not run sched_finish hook when selective scheduling enabled.  */
24397       if (sel_sched_p ())
24398         return;
24399
24400       if (rs6000_sched_insert_nops == sched_finish_none)
24401         return;
24402
24403       if (rs6000_sched_insert_nops == sched_finish_pad_groups)
24404         n_groups = pad_groups (dump, sched_verbose,
24405                                current_sched_info->prev_head,
24406                                current_sched_info->next_tail);
24407       else
24408         n_groups = redefine_groups (dump, sched_verbose,
24409                                     current_sched_info->prev_head,
24410                                     current_sched_info->next_tail);
24411
24412       if (sched_verbose >= 6)
24413         {
24414           fprintf (dump, "ngroups = %d\n", n_groups);
24415           print_rtl (dump, current_sched_info->prev_head);
24416           fprintf (dump, "Done finish_sched\n");
24417         }
24418     }
24419 }
24420
24421 struct _rs6000_sched_context
24422 {
24423   short cached_can_issue_more;
24424   rtx last_scheduled_insn;
24425   int load_store_pendulum;
24426 };
24427
24428 typedef struct _rs6000_sched_context rs6000_sched_context_def;
24429 typedef rs6000_sched_context_def *rs6000_sched_context_t;
24430
24431 /* Allocate store for new scheduling context.  */
24432 static void *
24433 rs6000_alloc_sched_context (void)
24434 {
24435   return xmalloc (sizeof (rs6000_sched_context_def));
24436 }
24437
24438 /* If CLEAN_P is true then initializes _SC with clean data,
24439    and from the global context otherwise.  */
24440 static void
24441 rs6000_init_sched_context (void *_sc, bool clean_p)
24442 {
24443   rs6000_sched_context_t sc = (rs6000_sched_context_t) _sc;
24444
24445   if (clean_p)
24446     {
24447       sc->cached_can_issue_more = 0;
24448       sc->last_scheduled_insn = NULL_RTX;
24449       sc->load_store_pendulum = 0;
24450     }
24451   else
24452     {
24453       sc->cached_can_issue_more = cached_can_issue_more;
24454       sc->last_scheduled_insn = last_scheduled_insn;
24455       sc->load_store_pendulum = load_store_pendulum;
24456     }
24457 }
24458
24459 /* Sets the global scheduling context to the one pointed to by _SC.  */
24460 static void
24461 rs6000_set_sched_context (void *_sc)
24462 {
24463   rs6000_sched_context_t sc = (rs6000_sched_context_t) _sc;
24464
24465   gcc_assert (sc != NULL);
24466
24467   cached_can_issue_more = sc->cached_can_issue_more;
24468   last_scheduled_insn = sc->last_scheduled_insn;
24469   load_store_pendulum = sc->load_store_pendulum;
24470 }
24471
24472 /* Free _SC.  */
24473 static void
24474 rs6000_free_sched_context (void *_sc)
24475 {
24476   gcc_assert (_sc != NULL);
24477
24478   free (_sc);
24479 }
24480
24481 \f
24482 /* Length in units of the trampoline for entering a nested function.  */
24483
24484 int
24485 rs6000_trampoline_size (void)
24486 {
24487   int ret = 0;
24488
24489   switch (DEFAULT_ABI)
24490     {
24491     default:
24492       gcc_unreachable ();
24493
24494     case ABI_AIX:
24495       ret = (TARGET_32BIT) ? 12 : 24;
24496       break;
24497
24498     case ABI_DARWIN:
24499     case ABI_V4:
24500       ret = (TARGET_32BIT) ? 40 : 48;
24501       break;
24502     }
24503
24504   return ret;
24505 }
24506
24507 /* Emit RTL insns to initialize the variable parts of a trampoline.
24508    FNADDR is an RTX for the address of the function's pure code.
24509    CXT is an RTX for the static chain value for the function.  */
24510
24511 static void
24512 rs6000_trampoline_init (rtx m_tramp, tree fndecl, rtx cxt)
24513 {
24514   int regsize = (TARGET_32BIT) ? 4 : 8;
24515   rtx fnaddr = XEXP (DECL_RTL (fndecl), 0);
24516   rtx ctx_reg = force_reg (Pmode, cxt);
24517   rtx addr = force_reg (Pmode, XEXP (m_tramp, 0));
24518
24519   switch (DEFAULT_ABI)
24520     {
24521     default:
24522       gcc_unreachable ();
24523
24524     /* Under AIX, just build the 3 word function descriptor */
24525     case ABI_AIX:
24526       {
24527         rtx fnmem, fn_reg, toc_reg;
24528
24529         if (!TARGET_POINTERS_TO_NESTED_FUNCTIONS)
24530           error ("-mno-r11 must not be used if you have trampolines");
24531
24532         fnmem = gen_const_mem (Pmode, force_reg (Pmode, fnaddr));
24533         fn_reg = gen_reg_rtx (Pmode);
24534         toc_reg = gen_reg_rtx (Pmode);
24535
24536   /* Macro to shorten the code expansions below.  */
24537 # define MEM_PLUS(MEM, OFFSET) adjust_address (MEM, Pmode, OFFSET)
24538
24539         m_tramp = replace_equiv_address (m_tramp, addr);
24540
24541         emit_move_insn (fn_reg, MEM_PLUS (fnmem, 0));
24542         emit_move_insn (toc_reg, MEM_PLUS (fnmem, regsize));
24543         emit_move_insn (MEM_PLUS (m_tramp, 0), fn_reg);
24544         emit_move_insn (MEM_PLUS (m_tramp, regsize), toc_reg);
24545         emit_move_insn (MEM_PLUS (m_tramp, 2*regsize), ctx_reg);
24546
24547 # undef MEM_PLUS
24548       }
24549       break;
24550
24551     /* Under V.4/eabi/darwin, __trampoline_setup does the real work.  */
24552     case ABI_DARWIN:
24553     case ABI_V4:
24554       emit_library_call (gen_rtx_SYMBOL_REF (Pmode, "__trampoline_setup"),
24555                          LCT_NORMAL, VOIDmode, 4,
24556                          addr, Pmode,
24557                          GEN_INT (rs6000_trampoline_size ()), SImode,
24558                          fnaddr, Pmode,
24559                          ctx_reg, Pmode);
24560       break;
24561     }
24562 }
24563
24564 \f
24565 /* Returns TRUE iff the target attribute indicated by ATTR_ID takes a plain
24566    identifier as an argument, so the front end shouldn't look it up.  */
24567
24568 static bool
24569 rs6000_attribute_takes_identifier_p (const_tree attr_id)
24570 {
24571   return is_attribute_p ("altivec", attr_id);
24572 }
24573
24574 /* Handle the "altivec" attribute.  The attribute may have
24575    arguments as follows:
24576
24577         __attribute__((altivec(vector__)))
24578         __attribute__((altivec(pixel__)))       (always followed by 'unsigned short')
24579         __attribute__((altivec(bool__)))        (always followed by 'unsigned')
24580
24581   and may appear more than once (e.g., 'vector bool char') in a
24582   given declaration.  */
24583
24584 static tree
24585 rs6000_handle_altivec_attribute (tree *node,
24586                                  tree name ATTRIBUTE_UNUSED,
24587                                  tree args,
24588                                  int flags ATTRIBUTE_UNUSED,
24589                                  bool *no_add_attrs)
24590 {
24591   tree type = *node, result = NULL_TREE;
24592   enum machine_mode mode;
24593   int unsigned_p;
24594   char altivec_type
24595     = ((args && TREE_CODE (args) == TREE_LIST && TREE_VALUE (args)
24596         && TREE_CODE (TREE_VALUE (args)) == IDENTIFIER_NODE)
24597        ? *IDENTIFIER_POINTER (TREE_VALUE (args))
24598        : '?');
24599
24600   while (POINTER_TYPE_P (type)
24601          || TREE_CODE (type) == FUNCTION_TYPE
24602          || TREE_CODE (type) == METHOD_TYPE
24603          || TREE_CODE (type) == ARRAY_TYPE)
24604     type = TREE_TYPE (type);
24605
24606   mode = TYPE_MODE (type);
24607
24608   /* Check for invalid AltiVec type qualifiers.  */
24609   if (type == long_double_type_node)
24610     error ("use of %<long double%> in AltiVec types is invalid");
24611   else if (type == boolean_type_node)
24612     error ("use of boolean types in AltiVec types is invalid");
24613   else if (TREE_CODE (type) == COMPLEX_TYPE)
24614     error ("use of %<complex%> in AltiVec types is invalid");
24615   else if (DECIMAL_FLOAT_MODE_P (mode))
24616     error ("use of decimal floating point types in AltiVec types is invalid");
24617   else if (!TARGET_VSX)
24618     {
24619       if (type == long_unsigned_type_node || type == long_integer_type_node)
24620         {
24621           if (TARGET_64BIT)
24622             error ("use of %<long%> in AltiVec types is invalid for "
24623                    "64-bit code without -mvsx");
24624           else if (rs6000_warn_altivec_long)
24625             warning (0, "use of %<long%> in AltiVec types is deprecated; "
24626                      "use %<int%>");
24627         }
24628       else if (type == long_long_unsigned_type_node
24629                || type == long_long_integer_type_node)
24630         error ("use of %<long long%> in AltiVec types is invalid without "
24631                "-mvsx");
24632       else if (type == double_type_node)
24633         error ("use of %<double%> in AltiVec types is invalid without -mvsx");
24634     }
24635
24636   switch (altivec_type)
24637     {
24638     case 'v':
24639       unsigned_p = TYPE_UNSIGNED (type);
24640       switch (mode)
24641         {
24642         case DImode:
24643           result = (unsigned_p ? unsigned_V2DI_type_node : V2DI_type_node);
24644           break;
24645         case SImode:
24646           result = (unsigned_p ? unsigned_V4SI_type_node : V4SI_type_node);
24647           break;
24648         case HImode:
24649           result = (unsigned_p ? unsigned_V8HI_type_node : V8HI_type_node);
24650           break;
24651         case QImode:
24652           result = (unsigned_p ? unsigned_V16QI_type_node : V16QI_type_node);
24653           break;
24654         case SFmode: result = V4SF_type_node; break;
24655         case DFmode: result = V2DF_type_node; break;
24656           /* If the user says 'vector int bool', we may be handed the 'bool'
24657              attribute _before_ the 'vector' attribute, and so select the
24658              proper type in the 'b' case below.  */
24659         case V4SImode: case V8HImode: case V16QImode: case V4SFmode:
24660         case V2DImode: case V2DFmode:
24661           result = type;
24662         default: break;
24663         }
24664       break;
24665     case 'b':
24666       switch (mode)
24667         {
24668         case DImode: case V2DImode: result = bool_V2DI_type_node; break;
24669         case SImode: case V4SImode: result = bool_V4SI_type_node; break;
24670         case HImode: case V8HImode: result = bool_V8HI_type_node; break;
24671         case QImode: case V16QImode: result = bool_V16QI_type_node;
24672         default: break;
24673         }
24674       break;
24675     case 'p':
24676       switch (mode)
24677         {
24678         case V8HImode: result = pixel_V8HI_type_node;
24679         default: break;
24680         }
24681     default: break;
24682     }
24683
24684   /* Propagate qualifiers attached to the element type
24685      onto the vector type.  */
24686   if (result && result != type && TYPE_QUALS (type))
24687     result = build_qualified_type (result, TYPE_QUALS (type));
24688
24689   *no_add_attrs = true;  /* No need to hang on to the attribute.  */
24690
24691   if (result)
24692     *node = lang_hooks.types.reconstruct_complex_type (*node, result);
24693
24694   return NULL_TREE;
24695 }
24696
24697 /* AltiVec defines four built-in scalar types that serve as vector
24698    elements; we must teach the compiler how to mangle them.  */
24699
24700 static const char *
24701 rs6000_mangle_type (const_tree type)
24702 {
24703   type = TYPE_MAIN_VARIANT (type);
24704
24705   if (TREE_CODE (type) != VOID_TYPE && TREE_CODE (type) != BOOLEAN_TYPE
24706       && TREE_CODE (type) != INTEGER_TYPE && TREE_CODE (type) != REAL_TYPE)
24707     return NULL;
24708
24709   if (type == bool_char_type_node) return "U6__boolc";
24710   if (type == bool_short_type_node) return "U6__bools";
24711   if (type == pixel_type_node) return "u7__pixel";
24712   if (type == bool_int_type_node) return "U6__booli";
24713   if (type == bool_long_type_node) return "U6__booll";
24714
24715   /* Mangle IBM extended float long double as `g' (__float128) on
24716      powerpc*-linux where long-double-64 previously was the default.  */
24717   if (TYPE_MAIN_VARIANT (type) == long_double_type_node
24718       && TARGET_ELF
24719       && TARGET_LONG_DOUBLE_128
24720       && !TARGET_IEEEQUAD)
24721     return "g";
24722
24723   /* For all other types, use normal C++ mangling.  */
24724   return NULL;
24725 }
24726
24727 /* Handle a "longcall" or "shortcall" attribute; arguments as in
24728    struct attribute_spec.handler.  */
24729
24730 static tree
24731 rs6000_handle_longcall_attribute (tree *node, tree name,
24732                                   tree args ATTRIBUTE_UNUSED,
24733                                   int flags ATTRIBUTE_UNUSED,
24734                                   bool *no_add_attrs)
24735 {
24736   if (TREE_CODE (*node) != FUNCTION_TYPE
24737       && TREE_CODE (*node) != FIELD_DECL
24738       && TREE_CODE (*node) != TYPE_DECL)
24739     {
24740       warning (OPT_Wattributes, "%qE attribute only applies to functions",
24741                name);
24742       *no_add_attrs = true;
24743     }
24744
24745   return NULL_TREE;
24746 }
24747
24748 /* Set longcall attributes on all functions declared when
24749    rs6000_default_long_calls is true.  */
24750 static void
24751 rs6000_set_default_type_attributes (tree type)
24752 {
24753   if (rs6000_default_long_calls
24754       && (TREE_CODE (type) == FUNCTION_TYPE
24755           || TREE_CODE (type) == METHOD_TYPE))
24756     TYPE_ATTRIBUTES (type) = tree_cons (get_identifier ("longcall"),
24757                                         NULL_TREE,
24758                                         TYPE_ATTRIBUTES (type));
24759
24760 #if TARGET_MACHO
24761   darwin_set_default_type_attributes (type);
24762 #endif
24763 }
24764
24765 /* Return a reference suitable for calling a function with the
24766    longcall attribute.  */
24767
24768 rtx
24769 rs6000_longcall_ref (rtx call_ref)
24770 {
24771   const char *call_name;
24772   tree node;
24773
24774   if (GET_CODE (call_ref) != SYMBOL_REF)
24775     return call_ref;
24776
24777   /* System V adds '.' to the internal name, so skip them.  */
24778   call_name = XSTR (call_ref, 0);
24779   if (*call_name == '.')
24780     {
24781       while (*call_name == '.')
24782         call_name++;
24783
24784       node = get_identifier (call_name);
24785       call_ref = gen_rtx_SYMBOL_REF (VOIDmode, IDENTIFIER_POINTER (node));
24786     }
24787
24788   return force_reg (Pmode, call_ref);
24789 }
24790 \f
24791 #ifndef TARGET_USE_MS_BITFIELD_LAYOUT
24792 #define TARGET_USE_MS_BITFIELD_LAYOUT 0
24793 #endif
24794
24795 /* Handle a "ms_struct" or "gcc_struct" attribute; arguments as in
24796    struct attribute_spec.handler.  */
24797 static tree
24798 rs6000_handle_struct_attribute (tree *node, tree name,
24799                                 tree args ATTRIBUTE_UNUSED,
24800                                 int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
24801 {
24802   tree *type = NULL;
24803   if (DECL_P (*node))
24804     {
24805       if (TREE_CODE (*node) == TYPE_DECL)
24806         type = &TREE_TYPE (*node);
24807     }
24808   else
24809     type = node;
24810
24811   if (!(type && (TREE_CODE (*type) == RECORD_TYPE
24812                  || TREE_CODE (*type) == UNION_TYPE)))
24813     {
24814       warning (OPT_Wattributes, "%qE attribute ignored", name);
24815       *no_add_attrs = true;
24816     }
24817
24818   else if ((is_attribute_p ("ms_struct", name)
24819             && lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (*type)))
24820            || ((is_attribute_p ("gcc_struct", name)
24821                 && lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (*type)))))
24822     {
24823       warning (OPT_Wattributes, "%qE incompatible attribute ignored",
24824                name);
24825       *no_add_attrs = true;
24826     }
24827
24828   return NULL_TREE;
24829 }
24830
24831 static bool
24832 rs6000_ms_bitfield_layout_p (const_tree record_type)
24833 {
24834   return (TARGET_USE_MS_BITFIELD_LAYOUT &&
24835           !lookup_attribute ("gcc_struct", TYPE_ATTRIBUTES (record_type)))
24836     || lookup_attribute ("ms_struct", TYPE_ATTRIBUTES (record_type));
24837 }
24838 \f
24839 #ifdef USING_ELFOS_H
24840
24841 /* A get_unnamed_section callback, used for switching to toc_section.  */
24842
24843 static void
24844 rs6000_elf_output_toc_section_asm_op (const void *data ATTRIBUTE_UNUSED)
24845 {
24846   if (DEFAULT_ABI == ABI_AIX
24847       && TARGET_MINIMAL_TOC
24848       && !TARGET_RELOCATABLE)
24849     {
24850       if (!toc_initialized)
24851         {
24852           toc_initialized = 1;
24853           fprintf (asm_out_file, "%s\n", TOC_SECTION_ASM_OP);
24854           (*targetm.asm_out.internal_label) (asm_out_file, "LCTOC", 0);
24855           fprintf (asm_out_file, "\t.tc ");
24856           ASM_OUTPUT_INTERNAL_LABEL_PREFIX (asm_out_file, "LCTOC1[TC],");
24857           ASM_OUTPUT_INTERNAL_LABEL_PREFIX (asm_out_file, "LCTOC1");
24858           fprintf (asm_out_file, "\n");
24859
24860           fprintf (asm_out_file, "%s\n", MINIMAL_TOC_SECTION_ASM_OP);
24861           ASM_OUTPUT_INTERNAL_LABEL_PREFIX (asm_out_file, "LCTOC1");
24862           fprintf (asm_out_file, " = .+32768\n");
24863         }
24864       else
24865         fprintf (asm_out_file, "%s\n", MINIMAL_TOC_SECTION_ASM_OP);
24866     }
24867   else if (DEFAULT_ABI == ABI_AIX && !TARGET_RELOCATABLE)
24868     fprintf (asm_out_file, "%s\n", TOC_SECTION_ASM_OP);
24869   else
24870     {
24871       fprintf (asm_out_file, "%s\n", MINIMAL_TOC_SECTION_ASM_OP);
24872       if (!toc_initialized)
24873         {
24874           ASM_OUTPUT_INTERNAL_LABEL_PREFIX (asm_out_file, "LCTOC1");
24875           fprintf (asm_out_file, " = .+32768\n");
24876           toc_initialized = 1;
24877         }
24878     }
24879 }
24880
24881 /* Implement TARGET_ASM_INIT_SECTIONS.  */
24882
24883 static void
24884 rs6000_elf_asm_init_sections (void)
24885 {
24886   toc_section
24887     = get_unnamed_section (0, rs6000_elf_output_toc_section_asm_op, NULL);
24888
24889   sdata2_section
24890     = get_unnamed_section (SECTION_WRITE, output_section_asm_op,
24891                            SDATA2_SECTION_ASM_OP);
24892 }
24893
24894 /* Implement TARGET_SELECT_RTX_SECTION.  */
24895
24896 static section *
24897 rs6000_elf_select_rtx_section (enum machine_mode mode, rtx x,
24898                                unsigned HOST_WIDE_INT align)
24899 {
24900   if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (x, mode))
24901     return toc_section;
24902   else
24903     return default_elf_select_rtx_section (mode, x, align);
24904 }
24905 \f
24906 /* For a SYMBOL_REF, set generic flags and then perform some
24907    target-specific processing.
24908
24909    When the AIX ABI is requested on a non-AIX system, replace the
24910    function name with the real name (with a leading .) rather than the
24911    function descriptor name.  This saves a lot of overriding code to
24912    read the prefixes.  */
24913
24914 static void
24915 rs6000_elf_encode_section_info (tree decl, rtx rtl, int first)
24916 {
24917   default_encode_section_info (decl, rtl, first);
24918
24919   if (first
24920       && TREE_CODE (decl) == FUNCTION_DECL
24921       && !TARGET_AIX
24922       && DEFAULT_ABI == ABI_AIX)
24923     {
24924       rtx sym_ref = XEXP (rtl, 0);
24925       size_t len = strlen (XSTR (sym_ref, 0));
24926       char *str = XALLOCAVEC (char, len + 2);
24927       str[0] = '.';
24928       memcpy (str + 1, XSTR (sym_ref, 0), len + 1);
24929       XSTR (sym_ref, 0) = ggc_alloc_string (str, len + 1);
24930     }
24931 }
24932
24933 static inline bool
24934 compare_section_name (const char *section, const char *templ)
24935 {
24936   int len;
24937
24938   len = strlen (templ);
24939   return (strncmp (section, templ, len) == 0
24940           && (section[len] == 0 || section[len] == '.'));
24941 }
24942
24943 bool
24944 rs6000_elf_in_small_data_p (const_tree decl)
24945 {
24946   if (rs6000_sdata == SDATA_NONE)
24947     return false;
24948
24949   /* We want to merge strings, so we never consider them small data.  */
24950   if (TREE_CODE (decl) == STRING_CST)
24951     return false;
24952
24953   /* Functions are never in the small data area.  */
24954   if (TREE_CODE (decl) == FUNCTION_DECL)
24955     return false;
24956
24957   if (TREE_CODE (decl) == VAR_DECL && DECL_SECTION_NAME (decl))
24958     {
24959       const char *section = TREE_STRING_POINTER (DECL_SECTION_NAME (decl));
24960       if (compare_section_name (section, ".sdata")
24961           || compare_section_name (section, ".sdata2")
24962           || compare_section_name (section, ".gnu.linkonce.s")
24963           || compare_section_name (section, ".sbss")
24964           || compare_section_name (section, ".sbss2")
24965           || compare_section_name (section, ".gnu.linkonce.sb")
24966           || strcmp (section, ".PPC.EMB.sdata0") == 0
24967           || strcmp (section, ".PPC.EMB.sbss0") == 0)
24968         return true;
24969     }
24970   else
24971     {
24972       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (decl));
24973
24974       if (size > 0
24975           && size <= g_switch_value
24976           /* If it's not public, and we're not going to reference it there,
24977              there's no need to put it in the small data section.  */
24978           && (rs6000_sdata != SDATA_DATA || TREE_PUBLIC (decl)))
24979         return true;
24980     }
24981
24982   return false;
24983 }
24984
24985 #endif /* USING_ELFOS_H */
24986 \f
24987 /* Implement TARGET_USE_BLOCKS_FOR_CONSTANT_P.  */
24988
24989 static bool
24990 rs6000_use_blocks_for_constant_p (enum machine_mode mode, const_rtx x)
24991 {
24992   return !ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (x, mode);
24993 }
24994 \f
24995 /* Return a REG that occurs in ADDR with coefficient 1.
24996    ADDR can be effectively incremented by incrementing REG.
24997
24998    r0 is special and we must not select it as an address
24999    register by this routine since our caller will try to
25000    increment the returned register via an "la" instruction.  */
25001
25002 rtx
25003 find_addr_reg (rtx addr)
25004 {
25005   while (GET_CODE (addr) == PLUS)
25006     {
25007       if (GET_CODE (XEXP (addr, 0)) == REG
25008           && REGNO (XEXP (addr, 0)) != 0)
25009         addr = XEXP (addr, 0);
25010       else if (GET_CODE (XEXP (addr, 1)) == REG
25011                && REGNO (XEXP (addr, 1)) != 0)
25012         addr = XEXP (addr, 1);
25013       else if (CONSTANT_P (XEXP (addr, 0)))
25014         addr = XEXP (addr, 1);
25015       else if (CONSTANT_P (XEXP (addr, 1)))
25016         addr = XEXP (addr, 0);
25017       else
25018         gcc_unreachable ();
25019     }
25020   gcc_assert (GET_CODE (addr) == REG && REGNO (addr) != 0);
25021   return addr;
25022 }
25023
25024 void
25025 rs6000_fatal_bad_address (rtx op)
25026 {
25027   fatal_insn ("bad address", op);
25028 }
25029
25030 #if TARGET_MACHO
25031
25032 typedef struct branch_island_d {
25033   tree function_name;
25034   tree label_name;
25035   int line_number;
25036 } branch_island;
25037
25038 DEF_VEC_O(branch_island);
25039 DEF_VEC_ALLOC_O(branch_island,gc);
25040
25041 static VEC(branch_island,gc) *branch_islands;
25042
25043 /* Remember to generate a branch island for far calls to the given
25044    function.  */
25045
25046 static void
25047 add_compiler_branch_island (tree label_name, tree function_name,
25048                             int line_number)
25049 {
25050   branch_island *bi = VEC_safe_push (branch_island, gc, branch_islands, NULL);
25051
25052   bi->function_name = function_name;
25053   bi->label_name = label_name;
25054   bi->line_number = line_number;
25055 }
25056
25057 /* Generate far-jump branch islands for everything recorded in
25058    branch_islands.  Invoked immediately after the last instruction of
25059    the epilogue has been emitted; the branch islands must be appended
25060    to, and contiguous with, the function body.  Mach-O stubs are
25061    generated in machopic_output_stub().  */
25062
25063 static void
25064 macho_branch_islands (void)
25065 {
25066   char tmp_buf[512];
25067
25068   while (!VEC_empty (branch_island, branch_islands))
25069     {
25070       branch_island *bi = VEC_last (branch_island, branch_islands);
25071       const char *label = IDENTIFIER_POINTER (bi->label_name);
25072       const char *name = IDENTIFIER_POINTER (bi->function_name);
25073       char name_buf[512];
25074       /* Cheap copy of the details from the Darwin ASM_OUTPUT_LABELREF().  */
25075       if (name[0] == '*' || name[0] == '&')
25076         strcpy (name_buf, name+1);
25077       else
25078         {
25079           name_buf[0] = '_';
25080           strcpy (name_buf+1, name);
25081         }
25082       strcpy (tmp_buf, "\n");
25083       strcat (tmp_buf, label);
25084 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
25085       if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
25086         dbxout_stabd (N_SLINE, bi->line_number);
25087 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
25088       if (flag_pic)
25089         {
25090           if (TARGET_LINK_STACK)
25091             {
25092               char name[32];
25093               get_ppc476_thunk_name (name);
25094               strcat (tmp_buf, ":\n\tmflr r0\n\tbl ");
25095               strcat (tmp_buf, name);
25096               strcat (tmp_buf, "\n");
25097               strcat (tmp_buf, label);
25098               strcat (tmp_buf, "_pic:\n\tmflr r11\n");
25099             }
25100           else
25101             {
25102               strcat (tmp_buf, ":\n\tmflr r0\n\tbcl 20,31,");
25103               strcat (tmp_buf, label);
25104               strcat (tmp_buf, "_pic\n");
25105               strcat (tmp_buf, label);
25106               strcat (tmp_buf, "_pic:\n\tmflr r11\n");
25107             }
25108
25109           strcat (tmp_buf, "\taddis r11,r11,ha16(");
25110           strcat (tmp_buf, name_buf);
25111           strcat (tmp_buf, " - ");
25112           strcat (tmp_buf, label);
25113           strcat (tmp_buf, "_pic)\n");
25114
25115           strcat (tmp_buf, "\tmtlr r0\n");
25116
25117           strcat (tmp_buf, "\taddi r12,r11,lo16(");
25118           strcat (tmp_buf, name_buf);
25119           strcat (tmp_buf, " - ");
25120           strcat (tmp_buf, label);
25121           strcat (tmp_buf, "_pic)\n");
25122
25123           strcat (tmp_buf, "\tmtctr r12\n\tbctr\n");
25124         }
25125       else
25126         {
25127           strcat (tmp_buf, ":\nlis r12,hi16(");
25128           strcat (tmp_buf, name_buf);
25129           strcat (tmp_buf, ")\n\tori r12,r12,lo16(");
25130           strcat (tmp_buf, name_buf);
25131           strcat (tmp_buf, ")\n\tmtctr r12\n\tbctr");
25132         }
25133       output_asm_insn (tmp_buf, 0);
25134 #if defined (DBX_DEBUGGING_INFO) || defined (XCOFF_DEBUGGING_INFO)
25135       if (write_symbols == DBX_DEBUG || write_symbols == XCOFF_DEBUG)
25136         dbxout_stabd (N_SLINE, bi->line_number);
25137 #endif /* DBX_DEBUGGING_INFO || XCOFF_DEBUGGING_INFO */
25138       VEC_pop (branch_island, branch_islands);
25139     }
25140 }
25141
25142 /* NO_PREVIOUS_DEF checks in the link list whether the function name is
25143    already there or not.  */
25144
25145 static int
25146 no_previous_def (tree function_name)
25147 {
25148   branch_island *bi;
25149   unsigned ix;
25150
25151   FOR_EACH_VEC_ELT (branch_island, branch_islands, ix, bi)
25152     if (function_name == bi->function_name)
25153       return 0;
25154   return 1;
25155 }
25156
25157 /* GET_PREV_LABEL gets the label name from the previous definition of
25158    the function.  */
25159
25160 static tree
25161 get_prev_label (tree function_name)
25162 {
25163   branch_island *bi;
25164   unsigned ix;
25165
25166   FOR_EACH_VEC_ELT (branch_island, branch_islands, ix, bi)
25167     if (function_name == bi->function_name)
25168       return bi->label_name;
25169   return NULL_TREE;
25170 }
25171
25172 /* INSN is either a function call or a millicode call.  It may have an
25173    unconditional jump in its delay slot.
25174
25175    CALL_DEST is the routine we are calling.  */
25176
25177 char *
25178 output_call (rtx insn, rtx *operands, int dest_operand_number,
25179              int cookie_operand_number)
25180 {
25181   static char buf[256];
25182   if (darwin_emit_branch_islands
25183       && GET_CODE (operands[dest_operand_number]) == SYMBOL_REF
25184       && (INTVAL (operands[cookie_operand_number]) & CALL_LONG))
25185     {
25186       tree labelname;
25187       tree funname = get_identifier (XSTR (operands[dest_operand_number], 0));
25188
25189       if (no_previous_def (funname))
25190         {
25191           rtx label_rtx = gen_label_rtx ();
25192           char *label_buf, temp_buf[256];
25193           ASM_GENERATE_INTERNAL_LABEL (temp_buf, "L",
25194                                        CODE_LABEL_NUMBER (label_rtx));
25195           label_buf = temp_buf[0] == '*' ? temp_buf + 1 : temp_buf;
25196           labelname = get_identifier (label_buf);
25197           add_compiler_branch_island (labelname, funname, insn_line (insn));
25198         }
25199       else
25200         labelname = get_prev_label (funname);
25201
25202       /* "jbsr foo, L42" is Mach-O for "Link as 'bl foo' if a 'bl'
25203          instruction will reach 'foo', otherwise link as 'bl L42'".
25204          "L42" should be a 'branch island', that will do a far jump to
25205          'foo'.  Branch islands are generated in
25206          macho_branch_islands().  */
25207       sprintf (buf, "jbsr %%z%d,%.246s",
25208                dest_operand_number, IDENTIFIER_POINTER (labelname));
25209     }
25210   else
25211     sprintf (buf, "bl %%z%d", dest_operand_number);
25212   return buf;
25213 }
25214
25215 /* Generate PIC and indirect symbol stubs.  */
25216
25217 void
25218 machopic_output_stub (FILE *file, const char *symb, const char *stub)
25219 {
25220   unsigned int length;
25221   char *symbol_name, *lazy_ptr_name;
25222   char *local_label_0;
25223   static int label = 0;
25224
25225   /* Lose our funky encoding stuff so it doesn't contaminate the stub.  */
25226   symb = (*targetm.strip_name_encoding) (symb);
25227
25228
25229   length = strlen (symb);
25230   symbol_name = XALLOCAVEC (char, length + 32);
25231   GEN_SYMBOL_NAME_FOR_SYMBOL (symbol_name, symb, length);
25232
25233   lazy_ptr_name = XALLOCAVEC (char, length + 32);
25234   GEN_LAZY_PTR_NAME_FOR_SYMBOL (lazy_ptr_name, symb, length);
25235
25236   if (flag_pic == 2)
25237     switch_to_section (darwin_sections[machopic_picsymbol_stub1_section]);
25238   else
25239     switch_to_section (darwin_sections[machopic_symbol_stub1_section]);
25240
25241   if (flag_pic == 2)
25242     {
25243       fprintf (file, "\t.align 5\n");
25244
25245       fprintf (file, "%s:\n", stub);
25246       fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
25247
25248       label++;
25249       local_label_0 = XALLOCAVEC (char, sizeof ("\"L00000000000$spb\""));
25250       sprintf (local_label_0, "\"L%011d$spb\"", label);
25251
25252       fprintf (file, "\tmflr r0\n");
25253       if (TARGET_LINK_STACK)
25254         {
25255           char name[32];
25256           get_ppc476_thunk_name (name);
25257           fprintf (file, "\tbl %s\n", name);
25258           fprintf (file, "%s:\n\tmflr r11\n", local_label_0);
25259         }
25260       else
25261         {
25262           fprintf (file, "\tbcl 20,31,%s\n", local_label_0);
25263           fprintf (file, "%s:\n\tmflr r11\n", local_label_0);
25264         }
25265       fprintf (file, "\taddis r11,r11,ha16(%s-%s)\n",
25266                lazy_ptr_name, local_label_0);
25267       fprintf (file, "\tmtlr r0\n");
25268       fprintf (file, "\t%s r12,lo16(%s-%s)(r11)\n",
25269                (TARGET_64BIT ? "ldu" : "lwzu"),
25270                lazy_ptr_name, local_label_0);
25271       fprintf (file, "\tmtctr r12\n");
25272       fprintf (file, "\tbctr\n");
25273     }
25274   else
25275     {
25276       fprintf (file, "\t.align 4\n");
25277
25278       fprintf (file, "%s:\n", stub);
25279       fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
25280
25281       fprintf (file, "\tlis r11,ha16(%s)\n", lazy_ptr_name);
25282       fprintf (file, "\t%s r12,lo16(%s)(r11)\n",
25283                (TARGET_64BIT ? "ldu" : "lwzu"),
25284                lazy_ptr_name);
25285       fprintf (file, "\tmtctr r12\n");
25286       fprintf (file, "\tbctr\n");
25287     }
25288
25289   switch_to_section (darwin_sections[machopic_lazy_symbol_ptr_section]);
25290   fprintf (file, "%s:\n", lazy_ptr_name);
25291   fprintf (file, "\t.indirect_symbol %s\n", symbol_name);
25292   fprintf (file, "%sdyld_stub_binding_helper\n",
25293            (TARGET_64BIT ? DOUBLE_INT_ASM_OP : "\t.long\t"));
25294 }
25295
25296 /* Legitimize PIC addresses.  If the address is already
25297    position-independent, we return ORIG.  Newly generated
25298    position-independent addresses go into a reg.  This is REG if non
25299    zero, otherwise we allocate register(s) as necessary.  */
25300
25301 #define SMALL_INT(X) ((UINTVAL (X) + 0x8000) < 0x10000)
25302
25303 rtx
25304 rs6000_machopic_legitimize_pic_address (rtx orig, enum machine_mode mode,
25305                                         rtx reg)
25306 {
25307   rtx base, offset;
25308
25309   if (reg == NULL && ! reload_in_progress && ! reload_completed)
25310     reg = gen_reg_rtx (Pmode);
25311
25312   if (GET_CODE (orig) == CONST)
25313     {
25314       rtx reg_temp;
25315
25316       if (GET_CODE (XEXP (orig, 0)) == PLUS
25317           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
25318         return orig;
25319
25320       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
25321
25322       /* Use a different reg for the intermediate value, as
25323          it will be marked UNCHANGING.  */
25324       reg_temp = !can_create_pseudo_p () ? reg : gen_reg_rtx (Pmode);
25325       base = rs6000_machopic_legitimize_pic_address (XEXP (XEXP (orig, 0), 0),
25326                                                      Pmode, reg_temp);
25327       offset =
25328         rs6000_machopic_legitimize_pic_address (XEXP (XEXP (orig, 0), 1),
25329                                                 Pmode, reg);
25330
25331       if (GET_CODE (offset) == CONST_INT)
25332         {
25333           if (SMALL_INT (offset))
25334             return plus_constant (base, INTVAL (offset));
25335           else if (! reload_in_progress && ! reload_completed)
25336             offset = force_reg (Pmode, offset);
25337           else
25338             {
25339               rtx mem = force_const_mem (Pmode, orig);
25340               return machopic_legitimize_pic_address (mem, Pmode, reg);
25341             }
25342         }
25343       return gen_rtx_PLUS (Pmode, base, offset);
25344     }
25345
25346   /* Fall back on generic machopic code.  */
25347   return machopic_legitimize_pic_address (orig, mode, reg);
25348 }
25349
25350 /* Output a .machine directive for the Darwin assembler, and call
25351    the generic start_file routine.  */
25352
25353 static void
25354 rs6000_darwin_file_start (void)
25355 {
25356   static const struct
25357   {
25358     const char *arg;
25359     const char *name;
25360     int if_set;
25361   } mapping[] = {
25362     { "ppc64", "ppc64", MASK_64BIT },
25363     { "970", "ppc970", MASK_PPC_GPOPT | MASK_MFCRF | MASK_POWERPC64 },
25364     { "power4", "ppc970", 0 },
25365     { "G5", "ppc970", 0 },
25366     { "7450", "ppc7450", 0 },
25367     { "7400", "ppc7400", MASK_ALTIVEC },
25368     { "G4", "ppc7400", 0 },
25369     { "750", "ppc750", 0 },
25370     { "740", "ppc750", 0 },
25371     { "G3", "ppc750", 0 },
25372     { "604e", "ppc604e", 0 },
25373     { "604", "ppc604", 0 },
25374     { "603e", "ppc603", 0 },
25375     { "603", "ppc603", 0 },
25376     { "601", "ppc601", 0 },
25377     { NULL, "ppc", 0 } };
25378   const char *cpu_id = "";
25379   size_t i;
25380
25381   rs6000_file_start ();
25382   darwin_file_start ();
25383
25384   /* Determine the argument to -mcpu=.  Default to G3 if not specified.  */
25385
25386   if (rs6000_default_cpu != 0 && rs6000_default_cpu[0] != '\0')
25387     cpu_id = rs6000_default_cpu;
25388
25389   if (global_options_set.x_rs6000_cpu_index)
25390     cpu_id = processor_target_table[rs6000_cpu_index].name;
25391
25392   /* Look through the mapping array.  Pick the first name that either
25393      matches the argument, has a bit set in IF_SET that is also set
25394      in the target flags, or has a NULL name.  */
25395
25396   i = 0;
25397   while (mapping[i].arg != NULL
25398          && strcmp (mapping[i].arg, cpu_id) != 0
25399          && (mapping[i].if_set & target_flags) == 0)
25400     i++;
25401
25402   fprintf (asm_out_file, "\t.machine %s\n", mapping[i].name);
25403 }
25404
25405 #endif /* TARGET_MACHO */
25406
25407 #if TARGET_ELF
25408 static int
25409 rs6000_elf_reloc_rw_mask (void)
25410 {
25411   if (flag_pic)
25412     return 3;
25413   else if (DEFAULT_ABI == ABI_AIX)
25414     return 2;
25415   else
25416     return 0;
25417 }
25418
25419 /* Record an element in the table of global constructors.  SYMBOL is
25420    a SYMBOL_REF of the function to be called; PRIORITY is a number
25421    between 0 and MAX_INIT_PRIORITY.
25422
25423    This differs from default_named_section_asm_out_constructor in
25424    that we have special handling for -mrelocatable.  */
25425
25426 static void
25427 rs6000_elf_asm_out_constructor (rtx symbol, int priority)
25428 {
25429   const char *section = ".ctors";
25430   char buf[16];
25431
25432   if (priority != DEFAULT_INIT_PRIORITY)
25433     {
25434       sprintf (buf, ".ctors.%.5u",
25435                /* Invert the numbering so the linker puts us in the proper
25436                   order; constructors are run from right to left, and the
25437                   linker sorts in increasing order.  */
25438                MAX_INIT_PRIORITY - priority);
25439       section = buf;
25440     }
25441
25442   switch_to_section (get_section (section, SECTION_WRITE, NULL));
25443   assemble_align (POINTER_SIZE);
25444
25445   if (TARGET_RELOCATABLE)
25446     {
25447       fputs ("\t.long (", asm_out_file);
25448       output_addr_const (asm_out_file, symbol);
25449       fputs (")@fixup\n", asm_out_file);
25450     }
25451   else
25452     assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
25453 }
25454
25455 static void
25456 rs6000_elf_asm_out_destructor (rtx symbol, int priority)
25457 {
25458   const char *section = ".dtors";
25459   char buf[16];
25460
25461   if (priority != DEFAULT_INIT_PRIORITY)
25462     {
25463       sprintf (buf, ".dtors.%.5u",
25464                /* Invert the numbering so the linker puts us in the proper
25465                   order; constructors are run from right to left, and the
25466                   linker sorts in increasing order.  */
25467                MAX_INIT_PRIORITY - priority);
25468       section = buf;
25469     }
25470
25471   switch_to_section (get_section (section, SECTION_WRITE, NULL));
25472   assemble_align (POINTER_SIZE);
25473
25474   if (TARGET_RELOCATABLE)
25475     {
25476       fputs ("\t.long (", asm_out_file);
25477       output_addr_const (asm_out_file, symbol);
25478       fputs (")@fixup\n", asm_out_file);
25479     }
25480   else
25481     assemble_integer (symbol, POINTER_SIZE / BITS_PER_UNIT, POINTER_SIZE, 1);
25482 }
25483
25484 void
25485 rs6000_elf_declare_function_name (FILE *file, const char *name, tree decl)
25486 {
25487   if (TARGET_64BIT)
25488     {
25489       fputs ("\t.section\t\".opd\",\"aw\"\n\t.align 3\n", file);
25490       ASM_OUTPUT_LABEL (file, name);
25491       fputs (DOUBLE_INT_ASM_OP, file);
25492       rs6000_output_function_entry (file, name);
25493       fputs (",.TOC.@tocbase,0\n\t.previous\n", file);
25494       if (DOT_SYMBOLS)
25495         {
25496           fputs ("\t.size\t", file);
25497           assemble_name (file, name);
25498           fputs (",24\n\t.type\t.", file);
25499           assemble_name (file, name);
25500           fputs (",@function\n", file);
25501           if (TREE_PUBLIC (decl) && ! DECL_WEAK (decl))
25502             {
25503               fputs ("\t.globl\t.", file);
25504               assemble_name (file, name);
25505               putc ('\n', file);
25506             }
25507         }
25508       else
25509         ASM_OUTPUT_TYPE_DIRECTIVE (file, name, "function");
25510       ASM_DECLARE_RESULT (file, DECL_RESULT (decl));
25511       rs6000_output_function_entry (file, name);
25512       fputs (":\n", file);
25513       return;
25514     }
25515
25516   if (TARGET_RELOCATABLE
25517       && !TARGET_SECURE_PLT
25518       && (get_pool_size () != 0 || crtl->profile)
25519       && uses_TOC ())
25520     {
25521       char buf[256];
25522
25523       (*targetm.asm_out.internal_label) (file, "LCL", rs6000_pic_labelno);
25524
25525       ASM_GENERATE_INTERNAL_LABEL (buf, "LCTOC", 1);
25526       fprintf (file, "\t.long ");
25527       assemble_name (file, buf);
25528       putc ('-', file);
25529       ASM_GENERATE_INTERNAL_LABEL (buf, "LCF", rs6000_pic_labelno);
25530       assemble_name (file, buf);
25531       putc ('\n', file);
25532     }
25533
25534   ASM_OUTPUT_TYPE_DIRECTIVE (file, name, "function");
25535   ASM_DECLARE_RESULT (file, DECL_RESULT (decl));
25536
25537   if (DEFAULT_ABI == ABI_AIX)
25538     {
25539       const char *desc_name, *orig_name;
25540
25541       orig_name = (*targetm.strip_name_encoding) (name);
25542       desc_name = orig_name;
25543       while (*desc_name == '.')
25544         desc_name++;
25545
25546       if (TREE_PUBLIC (decl))
25547         fprintf (file, "\t.globl %s\n", desc_name);
25548
25549       fprintf (file, "%s\n", MINIMAL_TOC_SECTION_ASM_OP);
25550       fprintf (file, "%s:\n", desc_name);
25551       fprintf (file, "\t.long %s\n", orig_name);
25552       fputs ("\t.long _GLOBAL_OFFSET_TABLE_\n", file);
25553       if (DEFAULT_ABI == ABI_AIX)
25554         fputs ("\t.long 0\n", file);
25555       fprintf (file, "\t.previous\n");
25556     }
25557   ASM_OUTPUT_LABEL (file, name);
25558 }
25559
25560 static void
25561 rs6000_elf_file_end (void)
25562 {
25563 #ifdef HAVE_AS_GNU_ATTRIBUTE
25564   if (TARGET_32BIT && DEFAULT_ABI == ABI_V4)
25565     {
25566       if (rs6000_passes_float)
25567         fprintf (asm_out_file, "\t.gnu_attribute 4, %d\n",
25568                  ((TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_DOUBLE_FLOAT) ? 1
25569                   : (TARGET_HARD_FLOAT && TARGET_FPRS && TARGET_SINGLE_FLOAT) ? 3
25570                   : 2));
25571       if (rs6000_passes_vector)
25572         fprintf (asm_out_file, "\t.gnu_attribute 8, %d\n",
25573                  (TARGET_ALTIVEC_ABI ? 2
25574                   : TARGET_SPE_ABI ? 3
25575                   : 1));
25576       if (rs6000_returns_struct)
25577         fprintf (asm_out_file, "\t.gnu_attribute 12, %d\n",
25578                  aix_struct_return ? 2 : 1);
25579     }
25580 #endif
25581 #ifdef POWERPC_LINUX
25582   if (TARGET_32BIT)
25583     file_end_indicate_exec_stack ();
25584 #endif
25585 }
25586 #endif
25587
25588 #if TARGET_XCOFF
25589 static void
25590 rs6000_xcoff_asm_output_anchor (rtx symbol)
25591 {
25592   char buffer[100];
25593
25594   sprintf (buffer, "$ + " HOST_WIDE_INT_PRINT_DEC,
25595            SYMBOL_REF_BLOCK_OFFSET (symbol));
25596   ASM_OUTPUT_DEF (asm_out_file, XSTR (symbol, 0), buffer);
25597 }
25598
25599 static void
25600 rs6000_xcoff_asm_globalize_label (FILE *stream, const char *name)
25601 {
25602   fputs (GLOBAL_ASM_OP, stream);
25603   RS6000_OUTPUT_BASENAME (stream, name);
25604   putc ('\n', stream);
25605 }
25606
25607 /* A get_unnamed_decl callback, used for read-only sections.  PTR
25608    points to the section string variable.  */
25609
25610 static void
25611 rs6000_xcoff_output_readonly_section_asm_op (const void *directive)
25612 {
25613   fprintf (asm_out_file, "\t.csect %s[RO],%s\n",
25614            *(const char *const *) directive,
25615            XCOFF_CSECT_DEFAULT_ALIGNMENT_STR);
25616 }
25617
25618 /* Likewise for read-write sections.  */
25619
25620 static void
25621 rs6000_xcoff_output_readwrite_section_asm_op (const void *directive)
25622 {
25623   fprintf (asm_out_file, "\t.csect %s[RW],%s\n",
25624            *(const char *const *) directive,
25625            XCOFF_CSECT_DEFAULT_ALIGNMENT_STR);
25626 }
25627
25628 /* A get_unnamed_section callback, used for switching to toc_section.  */
25629
25630 static void
25631 rs6000_xcoff_output_toc_section_asm_op (const void *data ATTRIBUTE_UNUSED)
25632 {
25633   if (TARGET_MINIMAL_TOC)
25634     {
25635       /* toc_section is always selected at least once from
25636          rs6000_xcoff_file_start, so this is guaranteed to
25637          always be defined once and only once in each file.  */
25638       if (!toc_initialized)
25639         {
25640           fputs ("\t.toc\nLCTOC..1:\n", asm_out_file);
25641           fputs ("\t.tc toc_table[TC],toc_table[RW]\n", asm_out_file);
25642           toc_initialized = 1;
25643         }
25644       fprintf (asm_out_file, "\t.csect toc_table[RW]%s\n",
25645                (TARGET_32BIT ? "" : ",3"));
25646     }
25647   else
25648     fputs ("\t.toc\n", asm_out_file);
25649 }
25650
25651 /* Implement TARGET_ASM_INIT_SECTIONS.  */
25652
25653 static void
25654 rs6000_xcoff_asm_init_sections (void)
25655 {
25656   read_only_data_section
25657     = get_unnamed_section (0, rs6000_xcoff_output_readonly_section_asm_op,
25658                            &xcoff_read_only_section_name);
25659
25660   private_data_section
25661     = get_unnamed_section (SECTION_WRITE,
25662                            rs6000_xcoff_output_readwrite_section_asm_op,
25663                            &xcoff_private_data_section_name);
25664
25665   read_only_private_data_section
25666     = get_unnamed_section (0, rs6000_xcoff_output_readonly_section_asm_op,
25667                            &xcoff_private_data_section_name);
25668
25669   toc_section
25670     = get_unnamed_section (0, rs6000_xcoff_output_toc_section_asm_op, NULL);
25671
25672   readonly_data_section = read_only_data_section;
25673   exception_section = data_section;
25674 }
25675
25676 static int
25677 rs6000_xcoff_reloc_rw_mask (void)
25678 {
25679   return 3;
25680 }
25681
25682 static void
25683 rs6000_xcoff_asm_named_section (const char *name, unsigned int flags,
25684                                 tree decl ATTRIBUTE_UNUSED)
25685 {
25686   int smclass;
25687   static const char * const suffix[3] = { "PR", "RO", "RW" };
25688
25689   if (flags & SECTION_CODE)
25690     smclass = 0;
25691   else if (flags & SECTION_WRITE)
25692     smclass = 2;
25693   else
25694     smclass = 1;
25695
25696   fprintf (asm_out_file, "\t.csect %s%s[%s],%u\n",
25697            (flags & SECTION_CODE) ? "." : "",
25698            name, suffix[smclass], flags & SECTION_ENTSIZE);
25699 }
25700
25701 static section *
25702 rs6000_xcoff_select_section (tree decl, int reloc,
25703                              unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
25704 {
25705   if (decl_readonly_section (decl, reloc))
25706     {
25707       if (TREE_PUBLIC (decl))
25708         return read_only_data_section;
25709       else
25710         return read_only_private_data_section;
25711     }
25712   else
25713     {
25714       if (TREE_PUBLIC (decl))
25715         return data_section;
25716       else
25717         return private_data_section;
25718     }
25719 }
25720
25721 static void
25722 rs6000_xcoff_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED)
25723 {
25724   const char *name;
25725
25726   /* Use select_section for private and uninitialized data.  */
25727   if (!TREE_PUBLIC (decl)
25728       || DECL_COMMON (decl)
25729       || DECL_INITIAL (decl) == NULL_TREE
25730       || DECL_INITIAL (decl) == error_mark_node
25731       || (flag_zero_initialized_in_bss
25732           && initializer_zerop (DECL_INITIAL (decl))))
25733     return;
25734
25735   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
25736   name = (*targetm.strip_name_encoding) (name);
25737   DECL_SECTION_NAME (decl) = build_string (strlen (name), name);
25738 }
25739
25740 /* Select section for constant in constant pool.
25741
25742    On RS/6000, all constants are in the private read-only data area.
25743    However, if this is being placed in the TOC it must be output as a
25744    toc entry.  */
25745
25746 static section *
25747 rs6000_xcoff_select_rtx_section (enum machine_mode mode, rtx x,
25748                                  unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
25749 {
25750   if (ASM_OUTPUT_SPECIAL_POOL_ENTRY_P (x, mode))
25751     return toc_section;
25752   else
25753     return read_only_private_data_section;
25754 }
25755
25756 /* Remove any trailing [DS] or the like from the symbol name.  */
25757
25758 static const char *
25759 rs6000_xcoff_strip_name_encoding (const char *name)
25760 {
25761   size_t len;
25762   if (*name == '*')
25763     name++;
25764   len = strlen (name);
25765   if (name[len - 1] == ']')
25766     return ggc_alloc_string (name, len - 4);
25767   else
25768     return name;
25769 }
25770
25771 /* Section attributes.  AIX is always PIC.  */
25772
25773 static unsigned int
25774 rs6000_xcoff_section_type_flags (tree decl, const char *name, int reloc)
25775 {
25776   unsigned int align;
25777   unsigned int flags = default_section_type_flags (decl, name, reloc);
25778
25779   /* Align to at least UNIT size.  */
25780   if (flags & SECTION_CODE)
25781     align = MIN_UNITS_PER_WORD;
25782   else
25783     /* Increase alignment of large objects if not already stricter.  */
25784     align = MAX ((DECL_ALIGN (decl) / BITS_PER_UNIT),
25785                  int_size_in_bytes (TREE_TYPE (decl)) > MIN_UNITS_PER_WORD
25786                  ? UNITS_PER_FP_WORD : MIN_UNITS_PER_WORD);
25787
25788   return flags | (exact_log2 (align) & SECTION_ENTSIZE);
25789 }
25790
25791 /* Output at beginning of assembler file.
25792
25793    Initialize the section names for the RS/6000 at this point.
25794
25795    Specify filename, including full path, to assembler.
25796
25797    We want to go into the TOC section so at least one .toc will be emitted.
25798    Also, in order to output proper .bs/.es pairs, we need at least one static
25799    [RW] section emitted.
25800
25801    Finally, declare mcount when profiling to make the assembler happy.  */
25802
25803 static void
25804 rs6000_xcoff_file_start (void)
25805 {
25806   rs6000_gen_section_name (&xcoff_bss_section_name,
25807                            main_input_filename, ".bss_");
25808   rs6000_gen_section_name (&xcoff_private_data_section_name,
25809                            main_input_filename, ".rw_");
25810   rs6000_gen_section_name (&xcoff_read_only_section_name,
25811                            main_input_filename, ".ro_");
25812
25813   fputs ("\t.file\t", asm_out_file);
25814   output_quoted_string (asm_out_file, main_input_filename);
25815   fputc ('\n', asm_out_file);
25816   if (write_symbols != NO_DEBUG)
25817     switch_to_section (private_data_section);
25818   switch_to_section (text_section);
25819   if (profile_flag)
25820     fprintf (asm_out_file, "\t.extern %s\n", RS6000_MCOUNT);
25821   rs6000_file_start ();
25822 }
25823
25824 /* Output at end of assembler file.
25825    On the RS/6000, referencing data should automatically pull in text.  */
25826
25827 static void
25828 rs6000_xcoff_file_end (void)
25829 {
25830   switch_to_section (text_section);
25831   fputs ("_section_.text:\n", asm_out_file);
25832   switch_to_section (data_section);
25833   fputs (TARGET_32BIT
25834          ? "\t.long _section_.text\n" : "\t.llong _section_.text\n",
25835          asm_out_file);
25836 }
25837 #endif /* TARGET_XCOFF */
25838
25839 /* Compute a (partial) cost for rtx X.  Return true if the complete
25840    cost has been computed, and false if subexpressions should be
25841    scanned.  In either case, *TOTAL contains the cost result.  */
25842
25843 static bool
25844 rs6000_rtx_costs (rtx x, int code, int outer_code, int opno ATTRIBUTE_UNUSED,
25845                   int *total, bool speed)
25846 {
25847   enum machine_mode mode = GET_MODE (x);
25848
25849   switch (code)
25850     {
25851       /* On the RS/6000, if it is valid in the insn, it is free.  */
25852     case CONST_INT:
25853       if (((outer_code == SET
25854             || outer_code == PLUS
25855             || outer_code == MINUS)
25856            && (satisfies_constraint_I (x)
25857                || satisfies_constraint_L (x)))
25858           || (outer_code == AND
25859               && (satisfies_constraint_K (x)
25860                   || (mode == SImode
25861                       ? satisfies_constraint_L (x)
25862                       : satisfies_constraint_J (x))
25863                   || mask_operand (x, mode)
25864                   || (mode == DImode
25865                       && mask64_operand (x, DImode))))
25866           || ((outer_code == IOR || outer_code == XOR)
25867               && (satisfies_constraint_K (x)
25868                   || (mode == SImode
25869                       ? satisfies_constraint_L (x)
25870                       : satisfies_constraint_J (x))))
25871           || outer_code == ASHIFT
25872           || outer_code == ASHIFTRT
25873           || outer_code == LSHIFTRT
25874           || outer_code == ROTATE
25875           || outer_code == ROTATERT
25876           || outer_code == ZERO_EXTRACT
25877           || (outer_code == MULT
25878               && satisfies_constraint_I (x))
25879           || ((outer_code == DIV || outer_code == UDIV
25880                || outer_code == MOD || outer_code == UMOD)
25881               && exact_log2 (INTVAL (x)) >= 0)
25882           || (outer_code == COMPARE
25883               && (satisfies_constraint_I (x)
25884                   || satisfies_constraint_K (x)))
25885           || ((outer_code == EQ || outer_code == NE)
25886               && (satisfies_constraint_I (x)
25887                   || satisfies_constraint_K (x)
25888                   || (mode == SImode
25889                       ? satisfies_constraint_L (x)
25890                       : satisfies_constraint_J (x))))
25891           || (outer_code == GTU
25892               && satisfies_constraint_I (x))
25893           || (outer_code == LTU
25894               && satisfies_constraint_P (x)))
25895         {
25896           *total = 0;
25897           return true;
25898         }
25899       else if ((outer_code == PLUS
25900                 && reg_or_add_cint_operand (x, VOIDmode))
25901                || (outer_code == MINUS
25902                    && reg_or_sub_cint_operand (x, VOIDmode))
25903                || ((outer_code == SET
25904                     || outer_code == IOR
25905                     || outer_code == XOR)
25906                    && (INTVAL (x)
25907                        & ~ (unsigned HOST_WIDE_INT) 0xffffffff) == 0))
25908         {
25909           *total = COSTS_N_INSNS (1);
25910           return true;
25911         }
25912       /* FALLTHRU */
25913
25914     case CONST_DOUBLE:
25915       if (mode == DImode && code == CONST_DOUBLE)
25916         {
25917           if ((outer_code == IOR || outer_code == XOR)
25918               && CONST_DOUBLE_HIGH (x) == 0
25919               && (CONST_DOUBLE_LOW (x)
25920                   & ~ (unsigned HOST_WIDE_INT) 0xffff) == 0)
25921             {
25922               *total = 0;
25923               return true;
25924             }
25925           else if ((outer_code == AND && and64_2_operand (x, DImode))
25926                    || ((outer_code == SET
25927                         || outer_code == IOR
25928                         || outer_code == XOR)
25929                        && CONST_DOUBLE_HIGH (x) == 0))
25930             {
25931               *total = COSTS_N_INSNS (1);
25932               return true;
25933             }
25934         }
25935       /* FALLTHRU */
25936
25937     case CONST:
25938     case HIGH:
25939     case SYMBOL_REF:
25940     case MEM:
25941       /* When optimizing for size, MEM should be slightly more expensive
25942          than generating address, e.g., (plus (reg) (const)).
25943          L1 cache latency is about two instructions.  */
25944       *total = !speed ? COSTS_N_INSNS (1) + 1 : COSTS_N_INSNS (2);
25945       return true;
25946
25947     case LABEL_REF:
25948       *total = 0;
25949       return true;
25950
25951     case PLUS:
25952     case MINUS:
25953       if (FLOAT_MODE_P (mode))
25954         *total = rs6000_cost->fp;
25955       else
25956         *total = COSTS_N_INSNS (1);
25957       return false;
25958
25959     case MULT:
25960       if (GET_CODE (XEXP (x, 1)) == CONST_INT
25961           && satisfies_constraint_I (XEXP (x, 1)))
25962         {
25963           if (INTVAL (XEXP (x, 1)) >= -256
25964               && INTVAL (XEXP (x, 1)) <= 255)
25965             *total = rs6000_cost->mulsi_const9;
25966           else
25967             *total = rs6000_cost->mulsi_const;
25968         }
25969       else if (mode == SFmode)
25970         *total = rs6000_cost->fp;
25971       else if (FLOAT_MODE_P (mode))
25972         *total = rs6000_cost->dmul;
25973       else if (mode == DImode)
25974         *total = rs6000_cost->muldi;
25975       else
25976         *total = rs6000_cost->mulsi;
25977       return false;
25978
25979     case FMA:
25980       if (mode == SFmode)
25981         *total = rs6000_cost->fp;
25982       else
25983         *total = rs6000_cost->dmul;
25984       break;
25985
25986     case DIV:
25987     case MOD:
25988       if (FLOAT_MODE_P (mode))
25989         {
25990           *total = mode == DFmode ? rs6000_cost->ddiv
25991                                   : rs6000_cost->sdiv;
25992           return false;
25993         }
25994       /* FALLTHRU */
25995
25996     case UDIV:
25997     case UMOD:
25998       if (GET_CODE (XEXP (x, 1)) == CONST_INT
25999           && exact_log2 (INTVAL (XEXP (x, 1))) >= 0)
26000         {
26001           if (code == DIV || code == MOD)
26002             /* Shift, addze */
26003             *total = COSTS_N_INSNS (2);
26004           else
26005             /* Shift */
26006             *total = COSTS_N_INSNS (1);
26007         }
26008       else
26009         {
26010           if (GET_MODE (XEXP (x, 1)) == DImode)
26011             *total = rs6000_cost->divdi;
26012           else
26013             *total = rs6000_cost->divsi;
26014         }
26015       /* Add in shift and subtract for MOD. */
26016       if (code == MOD || code == UMOD)
26017         *total += COSTS_N_INSNS (2);
26018       return false;
26019
26020     case CTZ:
26021     case FFS:
26022       *total = COSTS_N_INSNS (4);
26023       return false;
26024
26025     case POPCOUNT:
26026       *total = COSTS_N_INSNS (TARGET_POPCNTD ? 1 : 6);
26027       return false;
26028
26029     case PARITY:
26030       *total = COSTS_N_INSNS (TARGET_CMPB ? 2 : 6);
26031       return false;
26032
26033     case NOT:
26034       if (outer_code == AND || outer_code == IOR || outer_code == XOR)
26035         {
26036           *total = 0;
26037           return false;
26038         }
26039       /* FALLTHRU */
26040
26041     case AND:
26042     case CLZ:
26043     case IOR:
26044     case XOR:
26045     case ZERO_EXTRACT:
26046       *total = COSTS_N_INSNS (1);
26047       return false;
26048
26049     case ASHIFT:
26050     case ASHIFTRT:
26051     case LSHIFTRT:
26052     case ROTATE:
26053     case ROTATERT:
26054       /* Handle mul_highpart.  */
26055       if (outer_code == TRUNCATE
26056           && GET_CODE (XEXP (x, 0)) == MULT)
26057         {
26058           if (mode == DImode)
26059             *total = rs6000_cost->muldi;
26060           else
26061             *total = rs6000_cost->mulsi;
26062           return true;
26063         }
26064       else if (outer_code == AND)
26065         *total = 0;
26066       else
26067         *total = COSTS_N_INSNS (1);
26068       return false;
26069
26070     case SIGN_EXTEND:
26071     case ZERO_EXTEND:
26072       if (GET_CODE (XEXP (x, 0)) == MEM)
26073         *total = 0;
26074       else
26075         *total = COSTS_N_INSNS (1);
26076       return false;
26077
26078     case COMPARE:
26079     case NEG:
26080     case ABS:
26081       if (!FLOAT_MODE_P (mode))
26082         {
26083           *total = COSTS_N_INSNS (1);
26084           return false;
26085         }
26086       /* FALLTHRU */
26087
26088     case FLOAT:
26089     case UNSIGNED_FLOAT:
26090     case FIX:
26091     case UNSIGNED_FIX:
26092     case FLOAT_TRUNCATE:
26093       *total = rs6000_cost->fp;
26094       return false;
26095
26096     case FLOAT_EXTEND:
26097       if (mode == DFmode)
26098         *total = 0;
26099       else
26100         *total = rs6000_cost->fp;
26101       return false;
26102
26103     case UNSPEC:
26104       switch (XINT (x, 1))
26105         {
26106         case UNSPEC_FRSP:
26107           *total = rs6000_cost->fp;
26108           return true;
26109
26110         default:
26111           break;
26112         }
26113       break;
26114
26115     case CALL:
26116     case IF_THEN_ELSE:
26117       if (!speed)
26118         {
26119           *total = COSTS_N_INSNS (1);
26120           return true;
26121         }
26122       else if (FLOAT_MODE_P (mode)
26123                && TARGET_PPC_GFXOPT && TARGET_HARD_FLOAT && TARGET_FPRS)
26124         {
26125           *total = rs6000_cost->fp;
26126           return false;
26127         }
26128       break;
26129
26130     case EQ:
26131     case GTU:
26132     case LTU:
26133       /* Carry bit requires mode == Pmode.
26134          NEG or PLUS already counted so only add one.  */
26135       if (mode == Pmode
26136           && (outer_code == NEG || outer_code == PLUS))
26137         {
26138           *total = COSTS_N_INSNS (1);
26139           return true;
26140         }
26141       if (outer_code == SET)
26142         {
26143           if (XEXP (x, 1) == const0_rtx)
26144             {
26145               if (TARGET_ISEL && !TARGET_MFCRF)
26146                 *total = COSTS_N_INSNS (8);
26147               else
26148                 *total = COSTS_N_INSNS (2);
26149               return true;
26150             }
26151           else if (mode == Pmode)
26152             {
26153               *total = COSTS_N_INSNS (3);
26154               return false;
26155             }
26156         }
26157       /* FALLTHRU */
26158
26159     case GT:
26160     case LT:
26161     case UNORDERED:
26162       if (outer_code == SET && (XEXP (x, 1) == const0_rtx))
26163         {
26164           if (TARGET_ISEL && !TARGET_MFCRF)
26165             *total = COSTS_N_INSNS (8);
26166           else
26167             *total = COSTS_N_INSNS (2);
26168           return true;
26169         }
26170       /* CC COMPARE.  */
26171       if (outer_code == COMPARE)
26172         {
26173           *total = 0;
26174           return true;
26175         }
26176       break;
26177
26178     default:
26179       break;
26180     }
26181
26182   return false;
26183 }
26184
26185 /* Debug form of r6000_rtx_costs that is selected if -mdebug=cost.  */
26186
26187 static bool
26188 rs6000_debug_rtx_costs (rtx x, int code, int outer_code, int opno, int *total,
26189                         bool speed)
26190 {
26191   bool ret = rs6000_rtx_costs (x, code, outer_code, opno, total, speed);
26192
26193   fprintf (stderr,
26194            "\nrs6000_rtx_costs, return = %s, code = %s, outer_code = %s, "
26195            "opno = %d, total = %d, speed = %s, x:\n",
26196            ret ? "complete" : "scan inner",
26197            GET_RTX_NAME (code),
26198            GET_RTX_NAME (outer_code),
26199            opno,
26200            *total,
26201            speed ? "true" : "false");
26202
26203   debug_rtx (x);
26204
26205   return ret;
26206 }
26207
26208 /* Debug form of ADDRESS_COST that is selected if -mdebug=cost.  */
26209
26210 static int
26211 rs6000_debug_address_cost (rtx x, bool speed)
26212 {
26213   int ret = TARGET_ADDRESS_COST (x, speed);
26214
26215   fprintf (stderr, "\nrs6000_address_cost, return = %d, speed = %s, x:\n",
26216            ret, speed ? "true" : "false");
26217   debug_rtx (x);
26218
26219   return ret;
26220 }
26221
26222
26223 /* A C expression returning the cost of moving data from a register of class
26224    CLASS1 to one of CLASS2.  */
26225
26226 static int
26227 rs6000_register_move_cost (enum machine_mode mode,
26228                            reg_class_t from, reg_class_t to)
26229 {
26230   int ret;
26231
26232   if (TARGET_DEBUG_COST)
26233     dbg_cost_ctrl++;
26234
26235   /*  Moves from/to GENERAL_REGS.  */
26236   if (reg_classes_intersect_p (to, GENERAL_REGS)
26237       || reg_classes_intersect_p (from, GENERAL_REGS))
26238     {
26239       reg_class_t rclass = from;
26240
26241       if (! reg_classes_intersect_p (to, GENERAL_REGS))
26242         rclass = to;
26243
26244       if (rclass == FLOAT_REGS || rclass == ALTIVEC_REGS || rclass == VSX_REGS)
26245         ret = (rs6000_memory_move_cost (mode, rclass, false)
26246                + rs6000_memory_move_cost (mode, GENERAL_REGS, false));
26247
26248       /* It's more expensive to move CR_REGS than CR0_REGS because of the
26249          shift.  */
26250       else if (rclass == CR_REGS)
26251         ret = 4;
26252
26253       /* For those processors that have slow LR/CTR moves, make them more
26254          expensive than memory in order to bias spills to memory .*/
26255       else if ((rs6000_cpu == PROCESSOR_POWER6
26256                 || rs6000_cpu == PROCESSOR_POWER7)
26257                && reg_classes_intersect_p (rclass, LINK_OR_CTR_REGS))
26258         ret = 6 * hard_regno_nregs[0][mode];
26259
26260       else
26261         /* A move will cost one instruction per GPR moved.  */
26262         ret = 2 * hard_regno_nregs[0][mode];
26263     }
26264
26265   /* If we have VSX, we can easily move between FPR or Altivec registers.  */
26266   else if (VECTOR_UNIT_VSX_P (mode)
26267            && reg_classes_intersect_p (to, VSX_REGS)
26268            && reg_classes_intersect_p (from, VSX_REGS))
26269     ret = 2 * hard_regno_nregs[32][mode];
26270
26271   /* Moving between two similar registers is just one instruction.  */
26272   else if (reg_classes_intersect_p (to, from))
26273     ret = (mode == TFmode || mode == TDmode) ? 4 : 2;
26274
26275   /* Everything else has to go through GENERAL_REGS.  */
26276   else
26277     ret = (rs6000_register_move_cost (mode, GENERAL_REGS, to)
26278            + rs6000_register_move_cost (mode, from, GENERAL_REGS));
26279
26280   if (TARGET_DEBUG_COST)
26281     {
26282       if (dbg_cost_ctrl == 1)
26283         fprintf (stderr,
26284                  "rs6000_register_move_cost:, ret=%d, mode=%s, from=%s, to=%s\n",
26285                  ret, GET_MODE_NAME (mode), reg_class_names[from],
26286                  reg_class_names[to]);
26287       dbg_cost_ctrl--;
26288     }
26289
26290   return ret;
26291 }
26292
26293 /* A C expressions returning the cost of moving data of MODE from a register to
26294    or from memory.  */
26295
26296 static int
26297 rs6000_memory_move_cost (enum machine_mode mode, reg_class_t rclass,
26298                          bool in ATTRIBUTE_UNUSED)
26299 {
26300   int ret;
26301
26302   if (TARGET_DEBUG_COST)
26303     dbg_cost_ctrl++;
26304
26305   if (reg_classes_intersect_p (rclass, GENERAL_REGS))
26306     ret = 4 * hard_regno_nregs[0][mode];
26307   else if (reg_classes_intersect_p (rclass, FLOAT_REGS))
26308     ret = 4 * hard_regno_nregs[32][mode];
26309   else if (reg_classes_intersect_p (rclass, ALTIVEC_REGS))
26310     ret = 4 * hard_regno_nregs[FIRST_ALTIVEC_REGNO][mode];
26311   else
26312     ret = 4 + rs6000_register_move_cost (mode, rclass, GENERAL_REGS);
26313
26314   if (TARGET_DEBUG_COST)
26315     {
26316       if (dbg_cost_ctrl == 1)
26317         fprintf (stderr,
26318                  "rs6000_memory_move_cost: ret=%d, mode=%s, rclass=%s, in=%d\n",
26319                  ret, GET_MODE_NAME (mode), reg_class_names[rclass], in);
26320       dbg_cost_ctrl--;
26321     }
26322
26323   return ret;
26324 }
26325
26326 /* Returns a code for a target-specific builtin that implements
26327    reciprocal of the function, or NULL_TREE if not available.  */
26328
26329 static tree
26330 rs6000_builtin_reciprocal (unsigned int fn, bool md_fn,
26331                            bool sqrt ATTRIBUTE_UNUSED)
26332 {
26333   if (optimize_insn_for_size_p ())
26334     return NULL_TREE;
26335
26336   if (md_fn)
26337     switch (fn)
26338       {
26339       case VSX_BUILTIN_XVSQRTDP:
26340         if (!RS6000_RECIP_AUTO_RSQRTE_P (V2DFmode))
26341           return NULL_TREE;
26342
26343         return rs6000_builtin_decls[VSX_BUILTIN_VEC_RSQRT_V2DF];
26344
26345       case VSX_BUILTIN_XVSQRTSP:
26346         if (!RS6000_RECIP_AUTO_RSQRTE_P (V4SFmode))
26347           return NULL_TREE;
26348
26349         return rs6000_builtin_decls[VSX_BUILTIN_VEC_RSQRT_V4SF];
26350
26351       default:
26352         return NULL_TREE;
26353       }
26354
26355   else
26356     switch (fn)
26357       {
26358       case BUILT_IN_SQRT:
26359         if (!RS6000_RECIP_AUTO_RSQRTE_P (DFmode))
26360           return NULL_TREE;
26361
26362         return rs6000_builtin_decls[RS6000_BUILTIN_RSQRT];
26363
26364       case BUILT_IN_SQRTF:
26365         if (!RS6000_RECIP_AUTO_RSQRTE_P (SFmode))
26366           return NULL_TREE;
26367
26368         return rs6000_builtin_decls[RS6000_BUILTIN_RSQRTF];
26369
26370       default:
26371         return NULL_TREE;
26372       }
26373 }
26374
26375 /* Load up a constant.  If the mode is a vector mode, splat the value across
26376    all of the vector elements.  */
26377
26378 static rtx
26379 rs6000_load_constant_and_splat (enum machine_mode mode, REAL_VALUE_TYPE dconst)
26380 {
26381   rtx reg;
26382
26383   if (mode == SFmode || mode == DFmode)
26384     {
26385       rtx d = CONST_DOUBLE_FROM_REAL_VALUE (dconst, mode);
26386       reg = force_reg (mode, d);
26387     }
26388   else if (mode == V4SFmode)
26389     {
26390       rtx d = CONST_DOUBLE_FROM_REAL_VALUE (dconst, SFmode);
26391       rtvec v = gen_rtvec (4, d, d, d, d);
26392       reg = gen_reg_rtx (mode);
26393       rs6000_expand_vector_init (reg, gen_rtx_PARALLEL (mode, v));
26394     }
26395   else if (mode == V2DFmode)
26396     {
26397       rtx d = CONST_DOUBLE_FROM_REAL_VALUE (dconst, DFmode);
26398       rtvec v = gen_rtvec (2, d, d);
26399       reg = gen_reg_rtx (mode);
26400       rs6000_expand_vector_init (reg, gen_rtx_PARALLEL (mode, v));
26401     }
26402   else
26403     gcc_unreachable ();
26404
26405   return reg;
26406 }
26407
26408 /* Generate an FMA instruction.  */
26409
26410 static void
26411 rs6000_emit_madd (rtx target, rtx m1, rtx m2, rtx a)
26412 {
26413   enum machine_mode mode = GET_MODE (target);
26414   rtx dst;
26415
26416   dst = expand_ternary_op (mode, fma_optab, m1, m2, a, target, 0);
26417   gcc_assert (dst != NULL);
26418
26419   if (dst != target)
26420     emit_move_insn (target, dst);
26421 }
26422
26423 /* Generate a FMSUB instruction: dst = fma(m1, m2, -a).  */
26424
26425 static void
26426 rs6000_emit_msub (rtx target, rtx m1, rtx m2, rtx a)
26427 {
26428   enum machine_mode mode = GET_MODE (target);
26429   rtx dst;
26430
26431   /* Altivec does not support fms directly;
26432      generate in terms of fma in that case.  */
26433   if (optab_handler (fms_optab, mode) != CODE_FOR_nothing)
26434     dst = expand_ternary_op (mode, fms_optab, m1, m2, a, target, 0);
26435   else
26436     {
26437       a = expand_unop (mode, neg_optab, a, NULL_RTX, 0);
26438       dst = expand_ternary_op (mode, fma_optab, m1, m2, a, target, 0);
26439     }
26440   gcc_assert (dst != NULL);
26441
26442   if (dst != target)
26443     emit_move_insn (target, dst);
26444 }
26445
26446 /* Generate a FNMSUB instruction: dst = -fma(m1, m2, -a).  */
26447
26448 static void
26449 rs6000_emit_nmsub (rtx dst, rtx m1, rtx m2, rtx a)
26450 {
26451   enum machine_mode mode = GET_MODE (dst);
26452   rtx r;
26453
26454   /* This is a tad more complicated, since the fnma_optab is for
26455      a different expression: fma(-m1, m2, a), which is the same
26456      thing except in the case of signed zeros.
26457
26458      Fortunately we know that if FMA is supported that FNMSUB is
26459      also supported in the ISA.  Just expand it directly.  */
26460
26461   gcc_assert (optab_handler (fma_optab, mode) != CODE_FOR_nothing);
26462
26463   r = gen_rtx_NEG (mode, a);
26464   r = gen_rtx_FMA (mode, m1, m2, r);
26465   r = gen_rtx_NEG (mode, r);
26466   emit_insn (gen_rtx_SET (VOIDmode, dst, r));
26467 }
26468
26469 /* Newton-Raphson approximation of floating point divide with just 2 passes
26470    (either single precision floating point, or newer machines with higher
26471    accuracy estimates).  Support both scalar and vector divide.  Assumes no
26472    trapping math and finite arguments.  */
26473
26474 static void
26475 rs6000_emit_swdiv_high_precision (rtx dst, rtx n, rtx d)
26476 {
26477   enum machine_mode mode = GET_MODE (dst);
26478   rtx x0, e0, e1, y1, u0, v0;
26479   enum insn_code code = optab_handler (smul_optab, mode);
26480   gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (code);
26481   rtx one = rs6000_load_constant_and_splat (mode, dconst1);
26482
26483   gcc_assert (code != CODE_FOR_nothing);
26484
26485   /* x0 = 1./d estimate */
26486   x0 = gen_reg_rtx (mode);
26487   emit_insn (gen_rtx_SET (VOIDmode, x0,
26488                           gen_rtx_UNSPEC (mode, gen_rtvec (1, d),
26489                                           UNSPEC_FRES)));
26490
26491   e0 = gen_reg_rtx (mode);
26492   rs6000_emit_nmsub (e0, d, x0, one);           /* e0 = 1. - (d * x0) */
26493
26494   e1 = gen_reg_rtx (mode);
26495   rs6000_emit_madd (e1, e0, e0, e0);            /* e1 = (e0 * e0) + e0 */
26496
26497   y1 = gen_reg_rtx (mode);
26498   rs6000_emit_madd (y1, e1, x0, x0);            /* y1 = (e1 * x0) + x0 */
26499
26500   u0 = gen_reg_rtx (mode);
26501   emit_insn (gen_mul (u0, n, y1));              /* u0 = n * y1 */
26502
26503   v0 = gen_reg_rtx (mode);
26504   rs6000_emit_nmsub (v0, d, u0, n);             /* v0 = n - (d * u0) */
26505
26506   rs6000_emit_madd (dst, v0, y1, u0);           /* dst = (v0 * y1) + u0 */
26507 }
26508
26509 /* Newton-Raphson approximation of floating point divide that has a low
26510    precision estimate.  Assumes no trapping math and finite arguments.  */
26511
26512 static void
26513 rs6000_emit_swdiv_low_precision (rtx dst, rtx n, rtx d)
26514 {
26515   enum machine_mode mode = GET_MODE (dst);
26516   rtx x0, e0, e1, e2, y1, y2, y3, u0, v0, one;
26517   enum insn_code code = optab_handler (smul_optab, mode);
26518   gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (code);
26519
26520   gcc_assert (code != CODE_FOR_nothing);
26521
26522   one = rs6000_load_constant_and_splat (mode, dconst1);
26523
26524   /* x0 = 1./d estimate */
26525   x0 = gen_reg_rtx (mode);
26526   emit_insn (gen_rtx_SET (VOIDmode, x0,
26527                           gen_rtx_UNSPEC (mode, gen_rtvec (1, d),
26528                                           UNSPEC_FRES)));
26529
26530   e0 = gen_reg_rtx (mode);
26531   rs6000_emit_nmsub (e0, d, x0, one);           /* e0 = 1. - d * x0 */
26532
26533   y1 = gen_reg_rtx (mode);
26534   rs6000_emit_madd (y1, e0, x0, x0);            /* y1 = x0 + e0 * x0 */
26535
26536   e1 = gen_reg_rtx (mode);
26537   emit_insn (gen_mul (e1, e0, e0));             /* e1 = e0 * e0 */
26538
26539   y2 = gen_reg_rtx (mode);
26540   rs6000_emit_madd (y2, e1, y1, y1);            /* y2 = y1 + e1 * y1 */
26541
26542   e2 = gen_reg_rtx (mode);
26543   emit_insn (gen_mul (e2, e1, e1));             /* e2 = e1 * e1 */
26544
26545   y3 = gen_reg_rtx (mode);
26546   rs6000_emit_madd (y3, e2, y2, y2);            /* y3 = y2 + e2 * y2 */
26547
26548   u0 = gen_reg_rtx (mode);
26549   emit_insn (gen_mul (u0, n, y3));              /* u0 = n * y3 */
26550
26551   v0 = gen_reg_rtx (mode);
26552   rs6000_emit_nmsub (v0, d, u0, n);             /* v0 = n - d * u0 */
26553
26554   rs6000_emit_madd (dst, v0, y3, u0);           /* dst = u0 + v0 * y3 */
26555 }
26556
26557 /* Newton-Raphson approximation of floating point divide DST = N/D.  If NOTE_P,
26558    add a reg_note saying that this was a division.  Support both scalar and
26559    vector divide.  Assumes no trapping math and finite arguments.  */
26560
26561 void
26562 rs6000_emit_swdiv (rtx dst, rtx n, rtx d, bool note_p)
26563 {
26564   enum machine_mode mode = GET_MODE (dst);
26565
26566   if (RS6000_RECIP_HIGH_PRECISION_P (mode))
26567     rs6000_emit_swdiv_high_precision (dst, n, d);
26568   else
26569     rs6000_emit_swdiv_low_precision (dst, n, d);
26570
26571   if (note_p)
26572     add_reg_note (get_last_insn (), REG_EQUAL, gen_rtx_DIV (mode, n, d));
26573 }
26574
26575 /* Newton-Raphson approximation of single/double-precision floating point
26576    rsqrt.  Assumes no trapping math and finite arguments.  */
26577
26578 void
26579 rs6000_emit_swrsqrt (rtx dst, rtx src)
26580 {
26581   enum machine_mode mode = GET_MODE (src);
26582   rtx x0 = gen_reg_rtx (mode);
26583   rtx y = gen_reg_rtx (mode);
26584   int passes = (TARGET_RECIP_PRECISION) ? 2 : 3;
26585   REAL_VALUE_TYPE dconst3_2;
26586   int i;
26587   rtx halfthree;
26588   enum insn_code code = optab_handler (smul_optab, mode);
26589   gen_2arg_fn_t gen_mul = (gen_2arg_fn_t) GEN_FCN (code);
26590
26591   gcc_assert (code != CODE_FOR_nothing);
26592
26593   /* Load up the constant 1.5 either as a scalar, or as a vector.  */
26594   real_from_integer (&dconst3_2, VOIDmode, 3, 0, 0);
26595   SET_REAL_EXP (&dconst3_2, REAL_EXP (&dconst3_2) - 1);
26596
26597   halfthree = rs6000_load_constant_and_splat (mode, dconst3_2);
26598
26599   /* x0 = rsqrt estimate */
26600   emit_insn (gen_rtx_SET (VOIDmode, x0,
26601                           gen_rtx_UNSPEC (mode, gen_rtvec (1, src),
26602                                           UNSPEC_RSQRT)));
26603
26604   /* y = 0.5 * src = 1.5 * src - src -> fewer constants */
26605   rs6000_emit_msub (y, src, halfthree, src);
26606
26607   for (i = 0; i < passes; i++)
26608     {
26609       rtx x1 = gen_reg_rtx (mode);
26610       rtx u = gen_reg_rtx (mode);
26611       rtx v = gen_reg_rtx (mode);
26612
26613       /* x1 = x0 * (1.5 - y * (x0 * x0)) */
26614       emit_insn (gen_mul (u, x0, x0));
26615       rs6000_emit_nmsub (v, y, u, halfthree);
26616       emit_insn (gen_mul (x1, x0, v));
26617       x0 = x1;
26618     }
26619
26620   emit_move_insn (dst, x0);
26621   return;
26622 }
26623
26624 /* Emit popcount intrinsic on TARGET_POPCNTB (Power5) and TARGET_POPCNTD
26625    (Power7) targets.  DST is the target, and SRC is the argument operand.  */
26626
26627 void
26628 rs6000_emit_popcount (rtx dst, rtx src)
26629 {
26630   enum machine_mode mode = GET_MODE (dst);
26631   rtx tmp1, tmp2;
26632
26633   /* Use the PPC ISA 2.06 popcnt{w,d} instruction if we can.  */
26634   if (TARGET_POPCNTD)
26635     {
26636       if (mode == SImode)
26637         emit_insn (gen_popcntdsi2 (dst, src));
26638       else
26639         emit_insn (gen_popcntddi2 (dst, src));
26640       return;
26641     }
26642
26643   tmp1 = gen_reg_rtx (mode);
26644
26645   if (mode == SImode)
26646     {
26647       emit_insn (gen_popcntbsi2 (tmp1, src));
26648       tmp2 = expand_mult (SImode, tmp1, GEN_INT (0x01010101),
26649                            NULL_RTX, 0);
26650       tmp2 = force_reg (SImode, tmp2);
26651       emit_insn (gen_lshrsi3 (dst, tmp2, GEN_INT (24)));
26652     }
26653   else
26654     {
26655       emit_insn (gen_popcntbdi2 (tmp1, src));
26656       tmp2 = expand_mult (DImode, tmp1,
26657                           GEN_INT ((HOST_WIDE_INT)
26658                                    0x01010101 << 32 | 0x01010101),
26659                           NULL_RTX, 0);
26660       tmp2 = force_reg (DImode, tmp2);
26661       emit_insn (gen_lshrdi3 (dst, tmp2, GEN_INT (56)));
26662     }
26663 }
26664
26665
26666 /* Emit parity intrinsic on TARGET_POPCNTB targets.  DST is the
26667    target, and SRC is the argument operand.  */
26668
26669 void
26670 rs6000_emit_parity (rtx dst, rtx src)
26671 {
26672   enum machine_mode mode = GET_MODE (dst);
26673   rtx tmp;
26674
26675   tmp = gen_reg_rtx (mode);
26676
26677   /* Use the PPC ISA 2.05 prtyw/prtyd instruction if we can.  */
26678   if (TARGET_CMPB)
26679     {
26680       if (mode == SImode)
26681         {
26682           emit_insn (gen_popcntbsi2 (tmp, src));
26683           emit_insn (gen_paritysi2_cmpb (dst, tmp));
26684         }
26685       else
26686         {
26687           emit_insn (gen_popcntbdi2 (tmp, src));
26688           emit_insn (gen_paritydi2_cmpb (dst, tmp));
26689         }
26690       return;
26691     }
26692
26693   if (mode == SImode)
26694     {
26695       /* Is mult+shift >= shift+xor+shift+xor?  */
26696       if (rs6000_cost->mulsi_const >= COSTS_N_INSNS (3))
26697         {
26698           rtx tmp1, tmp2, tmp3, tmp4;
26699
26700           tmp1 = gen_reg_rtx (SImode);
26701           emit_insn (gen_popcntbsi2 (tmp1, src));
26702
26703           tmp2 = gen_reg_rtx (SImode);
26704           emit_insn (gen_lshrsi3 (tmp2, tmp1, GEN_INT (16)));
26705           tmp3 = gen_reg_rtx (SImode);
26706           emit_insn (gen_xorsi3 (tmp3, tmp1, tmp2));
26707
26708           tmp4 = gen_reg_rtx (SImode);
26709           emit_insn (gen_lshrsi3 (tmp4, tmp3, GEN_INT (8)));
26710           emit_insn (gen_xorsi3 (tmp, tmp3, tmp4));
26711         }
26712       else
26713         rs6000_emit_popcount (tmp, src);
26714       emit_insn (gen_andsi3 (dst, tmp, const1_rtx));
26715     }
26716   else
26717     {
26718       /* Is mult+shift >= shift+xor+shift+xor+shift+xor?  */
26719       if (rs6000_cost->muldi >= COSTS_N_INSNS (5))
26720         {
26721           rtx tmp1, tmp2, tmp3, tmp4, tmp5, tmp6;
26722
26723           tmp1 = gen_reg_rtx (DImode);
26724           emit_insn (gen_popcntbdi2 (tmp1, src));
26725
26726           tmp2 = gen_reg_rtx (DImode);
26727           emit_insn (gen_lshrdi3 (tmp2, tmp1, GEN_INT (32)));
26728           tmp3 = gen_reg_rtx (DImode);
26729           emit_insn (gen_xordi3 (tmp3, tmp1, tmp2));
26730
26731           tmp4 = gen_reg_rtx (DImode);
26732           emit_insn (gen_lshrdi3 (tmp4, tmp3, GEN_INT (16)));
26733           tmp5 = gen_reg_rtx (DImode);
26734           emit_insn (gen_xordi3 (tmp5, tmp3, tmp4));
26735
26736           tmp6 = gen_reg_rtx (DImode);
26737           emit_insn (gen_lshrdi3 (tmp6, tmp5, GEN_INT (8)));
26738           emit_insn (gen_xordi3 (tmp, tmp5, tmp6));
26739         }
26740       else
26741         rs6000_emit_popcount (tmp, src);
26742       emit_insn (gen_anddi3 (dst, tmp, const1_rtx));
26743     }
26744 }
26745
26746 /* Return an RTX representing where to find the function value of a
26747    function returning MODE.  */
26748 static rtx
26749 rs6000_complex_function_value (enum machine_mode mode)
26750 {
26751   unsigned int regno;
26752   rtx r1, r2;
26753   enum machine_mode inner = GET_MODE_INNER (mode);
26754   unsigned int inner_bytes = GET_MODE_SIZE (inner);
26755
26756   if (FLOAT_MODE_P (mode) && TARGET_HARD_FLOAT && TARGET_FPRS)
26757     regno = FP_ARG_RETURN;
26758   else
26759     {
26760       regno = GP_ARG_RETURN;
26761
26762       /* 32-bit is OK since it'll go in r3/r4.  */
26763       if (TARGET_32BIT && inner_bytes >= 4)
26764         return gen_rtx_REG (mode, regno);
26765     }
26766
26767   if (inner_bytes >= 8)
26768     return gen_rtx_REG (mode, regno);
26769
26770   r1 = gen_rtx_EXPR_LIST (inner, gen_rtx_REG (inner, regno),
26771                           const0_rtx);
26772   r2 = gen_rtx_EXPR_LIST (inner, gen_rtx_REG (inner, regno + 1),
26773                           GEN_INT (inner_bytes));
26774   return gen_rtx_PARALLEL (mode, gen_rtvec (2, r1, r2));
26775 }
26776
26777 /* Target hook for TARGET_FUNCTION_VALUE.
26778
26779    On the SPE, both FPs and vectors are returned in r3.
26780
26781    On RS/6000 an integer value is in r3 and a floating-point value is in
26782    fp1, unless -msoft-float.  */
26783
26784 rtx
26785 rs6000_function_value (const_tree valtype,
26786                        const_tree fn_decl_or_type ATTRIBUTE_UNUSED,
26787                        bool outgoing ATTRIBUTE_UNUSED)
26788 {
26789   enum machine_mode mode;
26790   unsigned int regno;
26791
26792   /* Special handling for structs in darwin64.  */
26793   if (TARGET_MACHO
26794       && rs6000_darwin64_struct_check_p (TYPE_MODE (valtype), valtype))
26795     {
26796       CUMULATIVE_ARGS valcum;
26797       rtx valret;
26798
26799       valcum.words = 0;
26800       valcum.fregno = FP_ARG_MIN_REG;
26801       valcum.vregno = ALTIVEC_ARG_MIN_REG;
26802       /* Do a trial code generation as if this were going to be passed as
26803          an argument; if any part goes in memory, we return NULL.  */
26804       valret = rs6000_darwin64_record_arg (&valcum, valtype, true, /* retval= */ true);
26805       if (valret)
26806         return valret;
26807       /* Otherwise fall through to standard ABI rules.  */
26808     }
26809
26810   if (TARGET_32BIT && TARGET_POWERPC64 && TYPE_MODE (valtype) == DImode)
26811     {
26812       /* Long long return value need be split in -mpowerpc64, 32bit ABI.  */
26813       return gen_rtx_PARALLEL (DImode,
26814         gen_rtvec (2,
26815                    gen_rtx_EXPR_LIST (VOIDmode,
26816                                       gen_rtx_REG (SImode, GP_ARG_RETURN),
26817                                       const0_rtx),
26818                    gen_rtx_EXPR_LIST (VOIDmode,
26819                                       gen_rtx_REG (SImode,
26820                                                    GP_ARG_RETURN + 1),
26821                                       GEN_INT (4))));
26822     }
26823   if (TARGET_32BIT && TARGET_POWERPC64 && TYPE_MODE (valtype) == DCmode)
26824     {
26825       return gen_rtx_PARALLEL (DCmode,
26826         gen_rtvec (4,
26827                    gen_rtx_EXPR_LIST (VOIDmode,
26828                                       gen_rtx_REG (SImode, GP_ARG_RETURN),
26829                                       const0_rtx),
26830                    gen_rtx_EXPR_LIST (VOIDmode,
26831                                       gen_rtx_REG (SImode,
26832                                                    GP_ARG_RETURN + 1),
26833                                       GEN_INT (4)),
26834                    gen_rtx_EXPR_LIST (VOIDmode,
26835                                       gen_rtx_REG (SImode,
26836                                                    GP_ARG_RETURN + 2),
26837                                       GEN_INT (8)),
26838                    gen_rtx_EXPR_LIST (VOIDmode,
26839                                       gen_rtx_REG (SImode,
26840                                                    GP_ARG_RETURN + 3),
26841                                       GEN_INT (12))));
26842     }
26843
26844   mode = TYPE_MODE (valtype);
26845   if ((INTEGRAL_TYPE_P (valtype) && GET_MODE_BITSIZE (mode) < BITS_PER_WORD)
26846       || POINTER_TYPE_P (valtype))
26847     mode = TARGET_32BIT ? SImode : DImode;
26848
26849   if (DECIMAL_FLOAT_MODE_P (mode) && TARGET_HARD_FLOAT && TARGET_FPRS)
26850     /* _Decimal128 must use an even/odd register pair.  */
26851     regno = (mode == TDmode) ? FP_ARG_RETURN + 1 : FP_ARG_RETURN;
26852   else if (SCALAR_FLOAT_TYPE_P (valtype) && TARGET_HARD_FLOAT && TARGET_FPRS
26853            && ((TARGET_SINGLE_FLOAT && (mode == SFmode)) || TARGET_DOUBLE_FLOAT))
26854     regno = FP_ARG_RETURN;
26855   else if (TREE_CODE (valtype) == COMPLEX_TYPE
26856            && targetm.calls.split_complex_arg)
26857     return rs6000_complex_function_value (mode);
26858   /* VSX is a superset of Altivec and adds V2DImode/V2DFmode.  Since the same
26859      return register is used in both cases, and we won't see V2DImode/V2DFmode
26860      for pure altivec, combine the two cases.  */
26861   else if (TREE_CODE (valtype) == VECTOR_TYPE
26862            && TARGET_ALTIVEC && TARGET_ALTIVEC_ABI
26863            && ALTIVEC_OR_VSX_VECTOR_MODE (mode))
26864     regno = ALTIVEC_ARG_RETURN;
26865   else if (TARGET_E500_DOUBLE && TARGET_HARD_FLOAT
26866            && (mode == DFmode || mode == DCmode
26867                || mode == TFmode || mode == TCmode))
26868     return spe_build_register_parallel (mode, GP_ARG_RETURN);
26869   else
26870     regno = GP_ARG_RETURN;
26871
26872   return gen_rtx_REG (mode, regno);
26873 }
26874
26875 /* Define how to find the value returned by a library function
26876    assuming the value has mode MODE.  */
26877 rtx
26878 rs6000_libcall_value (enum machine_mode mode)
26879 {
26880   unsigned int regno;
26881
26882   if (TARGET_32BIT && TARGET_POWERPC64 && mode == DImode)
26883     {
26884       /* Long long return value need be split in -mpowerpc64, 32bit ABI.  */
26885       return gen_rtx_PARALLEL (DImode,
26886         gen_rtvec (2,
26887                    gen_rtx_EXPR_LIST (VOIDmode,
26888                                       gen_rtx_REG (SImode, GP_ARG_RETURN),
26889                                       const0_rtx),
26890                    gen_rtx_EXPR_LIST (VOIDmode,
26891                                       gen_rtx_REG (SImode,
26892                                                    GP_ARG_RETURN + 1),
26893                                       GEN_INT (4))));
26894     }
26895
26896   if (DECIMAL_FLOAT_MODE_P (mode) && TARGET_HARD_FLOAT && TARGET_FPRS)
26897     /* _Decimal128 must use an even/odd register pair.  */
26898     regno = (mode == TDmode) ? FP_ARG_RETURN + 1 : FP_ARG_RETURN;
26899   else if (SCALAR_FLOAT_MODE_P (mode)
26900            && TARGET_HARD_FLOAT && TARGET_FPRS
26901            && ((TARGET_SINGLE_FLOAT && mode == SFmode) || TARGET_DOUBLE_FLOAT))
26902     regno = FP_ARG_RETURN;
26903   /* VSX is a superset of Altivec and adds V2DImode/V2DFmode.  Since the same
26904      return register is used in both cases, and we won't see V2DImode/V2DFmode
26905      for pure altivec, combine the two cases.  */
26906   else if (ALTIVEC_OR_VSX_VECTOR_MODE (mode)
26907            && TARGET_ALTIVEC && TARGET_ALTIVEC_ABI)
26908     regno = ALTIVEC_ARG_RETURN;
26909   else if (COMPLEX_MODE_P (mode) && targetm.calls.split_complex_arg)
26910     return rs6000_complex_function_value (mode);
26911   else if (TARGET_E500_DOUBLE && TARGET_HARD_FLOAT
26912            && (mode == DFmode || mode == DCmode
26913                || mode == TFmode || mode == TCmode))
26914     return spe_build_register_parallel (mode, GP_ARG_RETURN);
26915   else
26916     regno = GP_ARG_RETURN;
26917
26918   return gen_rtx_REG (mode, regno);
26919 }
26920
26921
26922 /* Given FROM and TO register numbers, say whether this elimination is allowed.
26923    Frame pointer elimination is automatically handled.
26924
26925    For the RS/6000, if frame pointer elimination is being done, we would like
26926    to convert ap into fp, not sp.
26927
26928    We need r30 if -mminimal-toc was specified, and there are constant pool
26929    references.  */
26930
26931 bool
26932 rs6000_can_eliminate (const int from, const int to)
26933 {
26934   return (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM
26935           ? ! frame_pointer_needed
26936           : from == RS6000_PIC_OFFSET_TABLE_REGNUM
26937             ? ! TARGET_MINIMAL_TOC || TARGET_NO_TOC || get_pool_size () == 0
26938             : true);
26939 }
26940
26941 /* Define the offset between two registers, FROM to be eliminated and its
26942    replacement TO, at the start of a routine.  */
26943 HOST_WIDE_INT
26944 rs6000_initial_elimination_offset (int from, int to)
26945 {
26946   rs6000_stack_t *info = rs6000_stack_info ();
26947   HOST_WIDE_INT offset;
26948
26949   if (from == HARD_FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
26950     offset = info->push_p ? 0 : -info->total_size;
26951   else if (from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
26952     {
26953       offset = info->push_p ? 0 : -info->total_size;
26954       if (FRAME_GROWS_DOWNWARD)
26955         offset += info->fixed_size + info->vars_size + info->parm_size;
26956     }
26957   else if (from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
26958     offset = FRAME_GROWS_DOWNWARD
26959              ? info->fixed_size + info->vars_size + info->parm_size
26960              : 0;
26961   else if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
26962     offset = info->total_size;
26963   else if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
26964     offset = info->push_p ? info->total_size : 0;
26965   else if (from == RS6000_PIC_OFFSET_TABLE_REGNUM)
26966     offset = 0;
26967   else
26968     gcc_unreachable ();
26969
26970   return offset;
26971 }
26972
26973 static rtx
26974 rs6000_dwarf_register_span (rtx reg)
26975 {
26976   rtx parts[8];
26977   int i, words;
26978   unsigned regno = REGNO (reg);
26979   enum machine_mode mode = GET_MODE (reg);
26980
26981   if (TARGET_SPE
26982       && regno < 32
26983       && (SPE_VECTOR_MODE (GET_MODE (reg))
26984           || (TARGET_E500_DOUBLE && FLOAT_MODE_P (mode)
26985               && mode != SFmode && mode != SDmode && mode != SCmode)))
26986     ;
26987   else
26988     return NULL_RTX;
26989
26990   regno = REGNO (reg);
26991
26992   /* The duality of the SPE register size wreaks all kinds of havoc.
26993      This is a way of distinguishing r0 in 32-bits from r0 in
26994      64-bits.  */
26995   words = (GET_MODE_SIZE (mode) + UNITS_PER_FP_WORD - 1) / UNITS_PER_FP_WORD;
26996   gcc_assert (words <= 4);
26997   for (i = 0; i < words; i++, regno++)
26998     {
26999       if (BYTES_BIG_ENDIAN)
27000         {
27001           parts[2 * i] = gen_rtx_REG (SImode, regno + 1200);
27002           parts[2 * i + 1] = gen_rtx_REG (SImode, regno);
27003         }
27004       else
27005         {
27006           parts[2 * i] = gen_rtx_REG (SImode, regno);
27007           parts[2 * i + 1] = gen_rtx_REG (SImode, regno + 1200);
27008         }
27009     }
27010
27011   return gen_rtx_PARALLEL (VOIDmode, gen_rtvec_v (words * 2, parts));
27012 }
27013
27014 /* Fill in sizes for SPE register high parts in table used by unwinder.  */
27015
27016 static void
27017 rs6000_init_dwarf_reg_sizes_extra (tree address)
27018 {
27019   if (TARGET_SPE)
27020     {
27021       int i;
27022       enum machine_mode mode = TYPE_MODE (char_type_node);
27023       rtx addr = expand_expr (address, NULL_RTX, VOIDmode, EXPAND_NORMAL);
27024       rtx mem = gen_rtx_MEM (BLKmode, addr);
27025       rtx value = gen_int_mode (4, mode);
27026
27027       for (i = 1201; i < 1232; i++)
27028         {
27029           int column = DWARF_REG_TO_UNWIND_COLUMN (i);
27030           HOST_WIDE_INT offset
27031             = DWARF_FRAME_REGNUM (column) * GET_MODE_SIZE (mode);
27032
27033           emit_move_insn (adjust_address (mem, mode, offset), value);
27034         }
27035     }
27036 }
27037
27038 /* Map internal gcc register numbers to DWARF2 register numbers.  */
27039
27040 unsigned int
27041 rs6000_dbx_register_number (unsigned int regno)
27042 {
27043   if (regno <= 63 || write_symbols != DWARF2_DEBUG)
27044     return regno;
27045   if (regno == MQ_REGNO)
27046     return 100;
27047   if (regno == LR_REGNO)
27048     return 108;
27049   if (regno == CTR_REGNO)
27050     return 109;
27051   if (CR_REGNO_P (regno))
27052     return regno - CR0_REGNO + 86;
27053   if (regno == CA_REGNO)
27054     return 101;  /* XER */
27055   if (ALTIVEC_REGNO_P (regno))
27056     return regno - FIRST_ALTIVEC_REGNO + 1124;
27057   if (regno == VRSAVE_REGNO)
27058     return 356;
27059   if (regno == VSCR_REGNO)
27060     return 67;
27061   if (regno == SPE_ACC_REGNO)
27062     return 99;
27063   if (regno == SPEFSCR_REGNO)
27064     return 612;
27065   /* SPE high reg number.  We get these values of regno from
27066      rs6000_dwarf_register_span.  */
27067   gcc_assert (regno >= 1200 && regno < 1232);
27068   return regno;
27069 }
27070
27071 /* target hook eh_return_filter_mode */
27072 static enum machine_mode
27073 rs6000_eh_return_filter_mode (void)
27074 {
27075   return TARGET_32BIT ? SImode : word_mode;
27076 }
27077
27078 /* Target hook for scalar_mode_supported_p.  */
27079 static bool
27080 rs6000_scalar_mode_supported_p (enum machine_mode mode)
27081 {
27082   if (DECIMAL_FLOAT_MODE_P (mode))
27083     return default_decimal_float_supported_p ();
27084   else
27085     return default_scalar_mode_supported_p (mode);
27086 }
27087
27088 /* Target hook for vector_mode_supported_p.  */
27089 static bool
27090 rs6000_vector_mode_supported_p (enum machine_mode mode)
27091 {
27092
27093   if (TARGET_PAIRED_FLOAT && PAIRED_VECTOR_MODE (mode))
27094     return true;
27095
27096   if (TARGET_SPE && SPE_VECTOR_MODE (mode))
27097     return true;
27098
27099   else if (VECTOR_MEM_ALTIVEC_OR_VSX_P (mode))
27100     return true;
27101
27102   else
27103     return false;
27104 }
27105
27106 /* Target hook for invalid_arg_for_unprototyped_fn. */
27107 static const char *
27108 invalid_arg_for_unprototyped_fn (const_tree typelist, const_tree funcdecl, const_tree val)
27109 {
27110   return (!rs6000_darwin64_abi
27111           && typelist == 0
27112           && TREE_CODE (TREE_TYPE (val)) == VECTOR_TYPE
27113           && (funcdecl == NULL_TREE
27114               || (TREE_CODE (funcdecl) == FUNCTION_DECL
27115                   && DECL_BUILT_IN_CLASS (funcdecl) != BUILT_IN_MD)))
27116           ? N_("AltiVec argument passed to unprototyped function")
27117           : NULL;
27118 }
27119
27120 /* For TARGET_SECURE_PLT 32-bit PIC code we can save PIC register
27121    setup by using __stack_chk_fail_local hidden function instead of
27122    calling __stack_chk_fail directly.  Otherwise it is better to call
27123    __stack_chk_fail directly.  */
27124
27125 static tree ATTRIBUTE_UNUSED
27126 rs6000_stack_protect_fail (void)
27127 {
27128   return (DEFAULT_ABI == ABI_V4 && TARGET_SECURE_PLT && flag_pic)
27129          ? default_hidden_stack_protect_fail ()
27130          : default_external_stack_protect_fail ();
27131 }
27132
27133 void
27134 rs6000_final_prescan_insn (rtx insn, rtx *operand ATTRIBUTE_UNUSED,
27135                            int num_operands ATTRIBUTE_UNUSED)
27136 {
27137   if (rs6000_warn_cell_microcode)
27138     {
27139       const char *temp;
27140       int insn_code_number = recog_memoized (insn);
27141       location_t location = locator_location (INSN_LOCATOR (insn));
27142
27143       /* Punt on insns we cannot recognize.  */
27144       if (insn_code_number < 0)
27145         return;
27146
27147       temp = get_insn_template (insn_code_number, insn);
27148
27149       if (get_attr_cell_micro (insn) == CELL_MICRO_ALWAYS)
27150         warning_at (location, OPT_mwarn_cell_microcode,
27151                     "emitting microcode insn %s\t[%s] #%d",
27152                     temp, insn_data[INSN_CODE (insn)].name, INSN_UID (insn));
27153       else if (get_attr_cell_micro (insn) == CELL_MICRO_CONDITIONAL)
27154         warning_at (location, OPT_mwarn_cell_microcode,
27155                     "emitting conditional microcode insn %s\t[%s] #%d",
27156                     temp, insn_data[INSN_CODE (insn)].name, INSN_UID (insn));
27157     }
27158 }
27159
27160 \f
27161 /* Mask options that we want to support inside of attribute((target)) and
27162    #pragma GCC target operations.  Note, we do not include things like
27163    64/32-bit, endianess, hard/soft floating point, etc. that would have
27164    different calling sequences.  */
27165
27166 struct rs6000_opt_mask {
27167   const char *name;             /* option name */
27168   int mask;                     /* mask to set */
27169   bool invert;                  /* invert sense of mask */
27170   bool valid_target;            /* option is a target option */
27171 };
27172
27173 static struct rs6000_opt_mask const rs6000_opt_masks[] =
27174 {
27175   { "altivec",          MASK_ALTIVEC,           false, true  },
27176   { "cmpb",             MASK_CMPB,              false, true  },
27177   { "dlmzb",            MASK_DLMZB,             false, true  },
27178   { "fprnd",            MASK_FPRND,             false, true  },
27179   { "hard-dfp",         MASK_DFP,               false, true  },
27180   { "isel",             MASK_ISEL,              false, true  },
27181   { "mfcrf",            MASK_MFCRF,             false, true  },
27182   { "mfpgpr",           MASK_MFPGPR,            false, true  },
27183   { "mulhw",            MASK_MULHW,             false, true  },
27184   { "multiple",         MASK_MULTIPLE,          false, true  },
27185   { "update",           MASK_NO_UPDATE,         true , true  },
27186   { "popcntb",          MASK_POPCNTB,           false, true  },
27187   { "popcntd",          MASK_POPCNTD,           false, true  },
27188   { "powerpc-gfxopt",   MASK_PPC_GFXOPT,        false, true  },
27189   { "powerpc-gpopt",    MASK_PPC_GPOPT,         false, true  },
27190   { "recip-precision",  MASK_RECIP_PRECISION,   false, true  },
27191   { "string",           MASK_STRING,            false, true  },
27192   { "vsx",              MASK_VSX,               false, true  },
27193 #ifdef MASK_64BIT
27194 #if TARGET_AIX_OS
27195   { "aix64",            MASK_64BIT,             false, false },
27196   { "aix32",            MASK_64BIT,             true,  false },
27197 #else
27198   { "64",               MASK_64BIT,             false, false },
27199   { "32",               MASK_64BIT,             true,  false },
27200 #endif
27201 #endif
27202 #ifdef MASK_EABI
27203   { "eabi",             MASK_EABI,              false, false },
27204 #endif
27205 #ifdef MASK_LITTLE_ENDIAN
27206   { "little",           MASK_LITTLE_ENDIAN,     false, false },
27207   { "big",              MASK_LITTLE_ENDIAN,     true,  false },
27208 #endif
27209 #ifdef MASK_RELOCATABLE
27210   { "relocatable",      MASK_RELOCATABLE,       false, false },
27211 #endif
27212 #ifdef MASK_STRICT_ALIGN
27213   { "strict-align",     MASK_STRICT_ALIGN,      false, false },
27214 #endif
27215   { "power",            MASK_POWER,             false, false },
27216   { "power2",           MASK_POWER2,            false, false },
27217   { "powerpc",          MASK_POWERPC,           false, false },
27218   { "soft-float",       MASK_SOFT_FLOAT,        false, false },
27219   { "string",           MASK_STRING,            false, false },
27220 };
27221
27222 /* Option variables that we want to support inside attribute((target)) and
27223    #pragma GCC target operations.  */
27224
27225 struct rs6000_opt_var {
27226   const char *name;             /* option name */
27227   size_t global_offset;         /* offset of the option in global_options.  */
27228   size_t target_offset;         /* offset of the option in target optiosn.  */
27229 };
27230
27231 static struct rs6000_opt_var const rs6000_opt_vars[] =
27232 {
27233   { "friz",
27234     offsetof (struct gcc_options, x_TARGET_FRIZ),
27235     offsetof (struct cl_target_option, x_TARGET_FRIZ), },
27236   { "avoid-indexed-addresses",
27237     offsetof (struct gcc_options, x_TARGET_AVOID_XFORM),
27238     offsetof (struct cl_target_option, x_TARGET_AVOID_XFORM) },
27239   { "paired",
27240     offsetof (struct gcc_options, x_rs6000_paired_float),
27241     offsetof (struct cl_target_option, x_rs6000_paired_float), },
27242   { "longcall",
27243     offsetof (struct gcc_options, x_rs6000_default_long_calls),
27244     offsetof (struct cl_target_option, x_rs6000_default_long_calls), },
27245 };
27246
27247 /* Inner function to handle attribute((target("..."))) and #pragma GCC target
27248    parsing.  Return true if there were no errors.  */
27249
27250 static bool
27251 rs6000_inner_target_options (tree args, bool attr_p)
27252 {
27253   bool ret = true;
27254
27255   if (args == NULL_TREE)
27256     ;
27257
27258   else if (TREE_CODE (args) == STRING_CST)
27259     {
27260       char *p = ASTRDUP (TREE_STRING_POINTER (args));
27261       char *q;
27262
27263       while ((q = strtok (p, ",")) != NULL)
27264         {
27265           bool error_p = false;
27266           bool not_valid_p = false;
27267           const char *cpu_opt = NULL;
27268
27269           p = NULL;
27270           if (strncmp (q, "cpu=", 4) == 0)
27271             {
27272               int cpu_index = rs6000_cpu_name_lookup (q+4);
27273               if (cpu_index >= 0)
27274                 rs6000_cpu_index = cpu_index;
27275               else
27276                 {
27277                   error_p = true;
27278                   cpu_opt = q+4;
27279                 }
27280             }
27281           else if (strncmp (q, "tune=", 5) == 0)
27282             {
27283               int tune_index = rs6000_cpu_name_lookup (q+5);
27284               if (tune_index >= 0)
27285                 rs6000_tune_index = tune_index;
27286               else
27287                 {
27288                   error_p = true;
27289                   cpu_opt = q+5;
27290                 }
27291             }
27292           else
27293             {
27294               size_t i;
27295               bool invert = false;
27296               char *r = q;
27297
27298               error_p = true;
27299               if (strncmp (r, "no-", 3) == 0)
27300                 {
27301                   invert = true;
27302                   r += 3;
27303                 }
27304
27305               for (i = 0; i < ARRAY_SIZE (rs6000_opt_masks); i++)
27306                 if (strcmp (r, rs6000_opt_masks[i].name) == 0)
27307                   {
27308                     int mask = rs6000_opt_masks[i].mask;
27309
27310                     if (!rs6000_opt_masks[i].valid_target)
27311                       not_valid_p = true;
27312                     else
27313                       {
27314                         error_p = false;
27315                         target_flags_explicit |= mask;
27316
27317                         if (rs6000_opt_masks[i].invert)
27318                           invert = !invert;
27319
27320                         if (invert)
27321                           target_flags &= ~mask;
27322                         else
27323                           target_flags |= mask;
27324                       }
27325                     break;
27326                   }
27327
27328               if (error_p && !not_valid_p)
27329                 {
27330                   for (i = 0; i < ARRAY_SIZE (rs6000_opt_vars); i++)
27331                     if (strcmp (r, rs6000_opt_vars[i].name) == 0)
27332                       {
27333                         size_t j = rs6000_opt_vars[i].global_offset;
27334                         ((int *) &global_options)[j] = !invert;
27335                         error_p = false;
27336                         break;
27337                       }
27338                 }
27339             }
27340
27341           if (error_p)
27342             {
27343               const char *eprefix, *esuffix;
27344
27345               ret = false;
27346               if (attr_p)
27347                 {
27348                   eprefix = "__attribute__((__target__(";
27349                   esuffix = ")))";
27350                 }
27351               else
27352                 {
27353                   eprefix = "#pragma GCC target ";
27354                   esuffix = "";
27355                 }
27356
27357               if (cpu_opt)
27358                 error ("invalid cpu \"%s\" for %s\"%s\"%s", cpu_opt, eprefix,
27359                        q, esuffix);
27360               else if (not_valid_p)
27361                 error ("%s\"%s\"%s is not allowed", eprefix, q, esuffix);
27362               else
27363                 error ("%s\"%s\"%s is invalid", eprefix, q, esuffix);
27364             }
27365         }
27366     }
27367
27368   else if (TREE_CODE (args) == TREE_LIST)
27369     {
27370       do
27371         {
27372           tree value = TREE_VALUE (args);
27373           if (value)
27374             {
27375               bool ret2 = rs6000_inner_target_options (value, attr_p);
27376               if (!ret2)
27377                 ret = false;
27378             }
27379           args = TREE_CHAIN (args);
27380         }
27381       while (args != NULL_TREE);
27382     }
27383
27384   else
27385     gcc_unreachable ();
27386
27387   return ret;
27388 }
27389
27390 /* Print out the target options as a list for -mdebug=target.  */
27391
27392 static void
27393 rs6000_debug_target_options (tree args, const char *prefix)
27394 {
27395   if (args == NULL_TREE)
27396     fprintf (stderr, "%s<NULL>", prefix);
27397
27398   else if (TREE_CODE (args) == STRING_CST)
27399     {
27400       char *p = ASTRDUP (TREE_STRING_POINTER (args));
27401       char *q;
27402
27403       while ((q = strtok (p, ",")) != NULL)
27404         {
27405           p = NULL;
27406           fprintf (stderr, "%s\"%s\"", prefix, q);
27407           prefix = ", ";
27408         }
27409     }
27410
27411   else if (TREE_CODE (args) == TREE_LIST)
27412     {
27413       do
27414         {
27415           tree value = TREE_VALUE (args);
27416           if (value)
27417             {
27418               rs6000_debug_target_options (value, prefix);
27419               prefix = ", ";
27420             }
27421           args = TREE_CHAIN (args);
27422         }
27423       while (args != NULL_TREE);
27424     }
27425
27426   else
27427     gcc_unreachable ();
27428
27429   return;
27430 }
27431
27432 \f
27433 /* Hook to validate attribute((target("..."))).  */
27434
27435 static bool
27436 rs6000_valid_attribute_p (tree fndecl,
27437                           tree ARG_UNUSED (name),
27438                           tree args,
27439                           int flags)
27440 {
27441   struct cl_target_option cur_target;
27442   bool ret;
27443   tree old_optimize = build_optimization_node ();
27444   tree new_target, new_optimize;
27445   tree func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
27446
27447   gcc_assert ((fndecl != NULL_TREE) && (args != NULL_TREE));
27448
27449   if (TARGET_DEBUG_TARGET)
27450     {
27451       tree tname = DECL_NAME (fndecl);
27452       fprintf (stderr, "\n==================== rs6000_valid_attribute_p:\n");
27453       if (tname)
27454         fprintf (stderr, "function: %.*s\n",
27455                  (int) IDENTIFIER_LENGTH (tname),
27456                  IDENTIFIER_POINTER (tname));
27457       else
27458         fprintf (stderr, "function: unknown\n");
27459
27460       fprintf (stderr, "args:");
27461       rs6000_debug_target_options (args, " ");
27462       fprintf (stderr, "\n");
27463
27464       if (flags)
27465         fprintf (stderr, "flags: 0x%x\n", flags);
27466
27467       fprintf (stderr, "--------------------\n");
27468     }
27469
27470   old_optimize = build_optimization_node ();
27471   func_optimize = DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl);
27472
27473   /* If the function changed the optimization levels as well as setting target
27474      options, start with the optimizations specified.  */
27475   if (func_optimize && func_optimize != old_optimize)
27476     cl_optimization_restore (&global_options,
27477                              TREE_OPTIMIZATION (func_optimize));
27478
27479   /* The target attributes may also change some optimization flags, so update
27480      the optimization options if necessary.  */
27481   cl_target_option_save (&cur_target, &global_options);
27482   rs6000_cpu_index = rs6000_tune_index = -1;
27483   ret = rs6000_inner_target_options (args, true);
27484
27485   /* Set up any additional state.  */
27486   if (ret)
27487     {
27488       ret = rs6000_option_override_internal (false);
27489       new_target = build_target_option_node ();
27490     }
27491   else
27492     new_target = NULL;
27493
27494   new_optimize = build_optimization_node ();
27495
27496   if (!new_target)
27497     ret = false;
27498
27499   else if (fndecl)
27500     {
27501       DECL_FUNCTION_SPECIFIC_TARGET (fndecl) = new_target;
27502
27503       if (old_optimize != new_optimize)
27504         DECL_FUNCTION_SPECIFIC_OPTIMIZATION (fndecl) = new_optimize;
27505     }
27506
27507   cl_target_option_restore (&global_options, &cur_target);
27508
27509   if (old_optimize != new_optimize)
27510     cl_optimization_restore (&global_options,
27511                              TREE_OPTIMIZATION (old_optimize));
27512
27513   return ret;
27514 }
27515
27516 \f
27517 /* Hook to validate the current #pragma GCC target and set the state, and
27518    update the macros based on what was changed.  If ARGS is NULL, then
27519    POP_TARGET is used to reset the options.  */
27520
27521 bool
27522 rs6000_pragma_target_parse (tree args, tree pop_target)
27523 {
27524   tree cur_tree;
27525   bool ret;
27526
27527   if (TARGET_DEBUG_TARGET)
27528     {
27529       fprintf (stderr, "\n==================== rs6000_pragma_target_parse\n");
27530       fprintf (stderr, "args:");
27531       rs6000_debug_target_options (args, " ");
27532       fprintf (stderr, "\n");
27533
27534       if (pop_target)
27535         {
27536           fprintf (stderr, "pop_target:\n");
27537           debug_tree (pop_target);
27538         }
27539       else
27540         fprintf (stderr, "pop_target: <NULL>\n");
27541
27542       fprintf (stderr, "--------------------\n");
27543     }
27544
27545   if (! args)
27546     {
27547       ret = true;
27548       cur_tree = ((pop_target)
27549                   ? pop_target
27550                   : target_option_default_node);
27551       cl_target_option_restore (&global_options,
27552                                 TREE_TARGET_OPTION (cur_tree));
27553     }
27554   else
27555     {
27556       rs6000_cpu_index = rs6000_tune_index = -1;
27557       ret = rs6000_inner_target_options (args, false);
27558       cur_tree = build_target_option_node ();
27559
27560       if (!cur_tree)
27561         ret = false;
27562     }
27563
27564   if (cur_tree)
27565     target_option_current_node = cur_tree;
27566
27567   return ret;
27568 }
27569
27570 \f
27571 /* Remember the last target of rs6000_set_current_function.  */
27572 static GTY(()) tree rs6000_previous_fndecl;
27573
27574 /* Establish appropriate back-end context for processing the function
27575    FNDECL.  The argument might be NULL to indicate processing at top
27576    level, outside of any function scope.  */
27577 static void
27578 rs6000_set_current_function (tree fndecl)
27579 {
27580   tree old_tree = (rs6000_previous_fndecl
27581                    ? DECL_FUNCTION_SPECIFIC_TARGET (rs6000_previous_fndecl)
27582                    : NULL_TREE);
27583
27584   tree new_tree = (fndecl
27585                    ? DECL_FUNCTION_SPECIFIC_TARGET (fndecl)
27586                    : NULL_TREE);
27587
27588   if (TARGET_DEBUG_TARGET)
27589     {
27590       bool print_final = false;
27591       fprintf (stderr, "\n==================== rs6000_set_current_function");
27592
27593       if (fndecl)
27594         fprintf (stderr, ", fndecl %s (%p)",
27595                  (DECL_NAME (fndecl)
27596                   ? IDENTIFIER_POINTER (DECL_NAME (fndecl))
27597                   : "<unknown>"), (void *)fndecl);
27598
27599       if (rs6000_previous_fndecl)
27600         fprintf (stderr, ", prev_fndecl (%p)", (void *)rs6000_previous_fndecl);
27601
27602       fprintf (stderr, "\n");
27603       if (new_tree)
27604         {
27605           fprintf (stderr, "\nnew fndecl target specific options:\n");
27606           debug_tree (new_tree);
27607           print_final = true;
27608         }
27609
27610       if (old_tree)
27611         {
27612           fprintf (stderr, "\nold fndecl target specific options:\n");
27613           debug_tree (old_tree);
27614           print_final = true;
27615         }
27616
27617       if (print_final)
27618         fprintf (stderr, "--------------------\n");
27619     }
27620
27621   /* Only change the context if the function changes.  This hook is called
27622      several times in the course of compiling a function, and we don't want to
27623      slow things down too much or call target_reinit when it isn't safe.  */
27624   if (fndecl && fndecl != rs6000_previous_fndecl)
27625     {
27626       rs6000_previous_fndecl = fndecl;
27627       if (old_tree == new_tree)
27628         ;
27629
27630       else if (new_tree)
27631         {
27632           cl_target_option_restore (&global_options,
27633                                     TREE_TARGET_OPTION (new_tree));
27634           target_reinit ();
27635         }
27636
27637       else if (old_tree)
27638         {
27639           struct cl_target_option *def
27640             = TREE_TARGET_OPTION (target_option_current_node);
27641
27642           cl_target_option_restore (&global_options, def);
27643           target_reinit ();
27644         }
27645     }
27646 }
27647
27648 \f
27649 /* Save the current options */
27650
27651 static void
27652 rs6000_function_specific_save (struct cl_target_option *ptr)
27653 {
27654   ptr->rs6000_target_flags_explicit = target_flags_explicit;
27655 }
27656
27657 /* Restore the current options */
27658
27659 static void
27660 rs6000_function_specific_restore (struct cl_target_option *ptr)
27661 {
27662   target_flags_explicit = ptr->rs6000_target_flags_explicit;
27663   (void) rs6000_option_override_internal (false);
27664 }
27665
27666 /* Print the current options */
27667
27668 static void
27669 rs6000_function_specific_print (FILE *file, int indent,
27670                                 struct cl_target_option *ptr)
27671 {
27672   size_t i;
27673   int flags = ptr->x_target_flags;
27674
27675   /* Print the various mask options.  */
27676   for (i = 0; i < ARRAY_SIZE (rs6000_opt_masks); i++)
27677     if ((flags & rs6000_opt_masks[i].mask) != 0)
27678       {
27679         flags &= ~ rs6000_opt_masks[i].mask;
27680         fprintf (file, "%*s-m%s%s\n", indent, "",
27681                  rs6000_opt_masks[i].invert ? "no-" : "",
27682                  rs6000_opt_masks[i].name);
27683       }
27684
27685   /* Print the various options that are variables.  */
27686   for (i = 0; i < ARRAY_SIZE (rs6000_opt_vars); i++)
27687     {
27688       size_t j = rs6000_opt_vars[i].target_offset;
27689       if (((signed char *) ptr)[j])
27690         fprintf (file, "%*s-m%s\n", indent, "",
27691                  rs6000_opt_vars[i].name);
27692     }
27693 }
27694
27695 \f
27696 /* Hook to determine if one function can safely inline another.  */
27697
27698 static bool
27699 rs6000_can_inline_p (tree caller, tree callee)
27700 {
27701   bool ret = false;
27702   tree caller_tree = DECL_FUNCTION_SPECIFIC_TARGET (caller);
27703   tree callee_tree = DECL_FUNCTION_SPECIFIC_TARGET (callee);
27704
27705   /* If callee has no option attributes, then it is ok to inline.  */
27706   if (!callee_tree)
27707     ret = true;
27708
27709   /* If caller has no option attributes, but callee does then it is not ok to
27710      inline.  */
27711   else if (!caller_tree)
27712     ret = false;
27713
27714   else
27715     {
27716       struct cl_target_option *caller_opts = TREE_TARGET_OPTION (caller_tree);
27717       struct cl_target_option *callee_opts = TREE_TARGET_OPTION (callee_tree);
27718
27719       /* Callee's options should a subset of the caller's, i.e. a vsx function
27720          can inline an altivec function but a non-vsx function can't inline a
27721          vsx function.  */
27722       if ((caller_opts->x_target_flags & callee_opts->x_target_flags)
27723           == callee_opts->x_target_flags)
27724         ret = true;
27725     }
27726
27727   if (TARGET_DEBUG_TARGET)
27728     fprintf (stderr, "rs6000_can_inline_p:, caller %s, callee %s, %s inline\n",
27729              (DECL_NAME (caller)
27730               ? IDENTIFIER_POINTER (DECL_NAME (caller))
27731               : "<unknown>"),
27732              (DECL_NAME (callee)
27733               ? IDENTIFIER_POINTER (DECL_NAME (callee))
27734               : "<unknown>"),
27735              (ret ? "can" : "cannot"));
27736
27737   return ret;
27738 }
27739 \f
27740 /* Allocate a stack temp and fixup the address so it meets the particular
27741    memory requirements (either offetable or REG+REG addressing).  */
27742
27743 rtx
27744 rs6000_allocate_stack_temp (enum machine_mode mode,
27745                             bool offsettable_p,
27746                             bool reg_reg_p)
27747 {
27748   rtx stack = assign_stack_temp (mode, GET_MODE_SIZE (mode), 0);
27749   rtx addr = XEXP (stack, 0);
27750   int strict_p = (reload_in_progress || reload_completed);
27751
27752   if (!legitimate_indirect_address_p (addr, strict_p))
27753     {
27754       if (offsettable_p
27755           && !rs6000_legitimate_offset_address_p (mode, addr, strict_p))
27756         stack = replace_equiv_address (stack, copy_addr_to_reg (addr));
27757
27758       else if (reg_reg_p && !legitimate_indexed_address_p (addr, strict_p))
27759         stack = replace_equiv_address (stack, copy_addr_to_reg (addr));
27760     }
27761
27762   return stack;
27763 }
27764
27765 /* Given a memory reference, if it is not a reg or reg+reg addressing, convert
27766    to such a form to deal with memory reference instructions like STFIWX that
27767    only take reg+reg addressing.  */
27768
27769 rtx
27770 rs6000_address_for_fpconvert (rtx x)
27771 {
27772   int strict_p = (reload_in_progress || reload_completed);
27773   rtx addr;
27774
27775   gcc_assert (MEM_P (x));
27776   addr = XEXP (x, 0);
27777   if (! legitimate_indirect_address_p (addr, strict_p)
27778       && ! legitimate_indexed_address_p (addr, strict_p))
27779     {
27780       if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
27781         {
27782           rtx reg = XEXP (addr, 0);
27783           HOST_WIDE_INT size = GET_MODE_SIZE (GET_MODE (x));
27784           rtx size_rtx = GEN_INT ((GET_CODE (addr) == PRE_DEC) ? -size : size);
27785           gcc_assert (REG_P (reg));
27786           emit_insn (gen_add3_insn (reg, reg, size_rtx));
27787           addr = reg;
27788         }
27789       else if (GET_CODE (addr) == PRE_MODIFY)
27790         {
27791           rtx reg = XEXP (addr, 0);
27792           rtx expr = XEXP (addr, 1);
27793           gcc_assert (REG_P (reg));
27794           gcc_assert (GET_CODE (expr) == PLUS);
27795           emit_insn (gen_add3_insn (reg, XEXP (expr, 0), XEXP (expr, 1)));
27796           addr = reg;
27797         }
27798
27799       x = replace_equiv_address (x, copy_addr_to_reg (addr));
27800     }
27801
27802   return x;
27803 }
27804
27805 /* Given a memory reference, if it is not in the form for altivec memory
27806    reference instructions (i.e. reg or reg+reg addressing with AND of -16),
27807    convert to the altivec format.  */
27808
27809 rtx
27810 rs6000_address_for_altivec (rtx x)
27811 {
27812   gcc_assert (MEM_P (x));
27813   if (!altivec_indexed_or_indirect_operand (x, GET_MODE (x)))
27814     {
27815       rtx addr = XEXP (x, 0);
27816       int strict_p = (reload_in_progress || reload_completed);
27817
27818       if (!legitimate_indexed_address_p (addr, strict_p)
27819           && !legitimate_indirect_address_p (addr, strict_p))
27820         addr = copy_to_mode_reg (Pmode, addr);
27821
27822       addr = gen_rtx_AND (Pmode, addr, GEN_INT (-16));
27823       x = change_address (x, GET_MODE (x), addr);
27824     }
27825
27826   return x;
27827 }
27828
27829 /* Implement TARGET_LEGITIMATE_CONSTANT_P.
27830
27831    On the RS/6000, all integer constants are acceptable, most won't be valid
27832    for particular insns, though.  Only easy FP constants are acceptable.  */
27833
27834 static bool
27835 rs6000_legitimate_constant_p (enum machine_mode mode, rtx x)
27836 {
27837   if (rs6000_tls_referenced_p (x))
27838     return false;
27839
27840   return ((GET_CODE (x) != CONST_DOUBLE && GET_CODE (x) != CONST_VECTOR)
27841           || GET_MODE (x) == VOIDmode
27842           || (TARGET_POWERPC64 && mode == DImode)
27843           || easy_fp_constant (x, mode)
27844           || easy_vector_constant (x, mode));
27845 }
27846
27847 \f
27848 /* A function pointer under AIX is a pointer to a data area whose first word
27849    contains the actual address of the function, whose second word contains a
27850    pointer to its TOC, and whose third word contains a value to place in the
27851    static chain register (r11).  Note that if we load the static chain, our
27852    "trampoline" need not have any executable code.  */
27853
27854 void
27855 rs6000_call_indirect_aix (rtx value, rtx func_desc, rtx flag)
27856 {
27857   rtx func_addr;
27858   rtx toc_reg;
27859   rtx sc_reg;
27860   rtx stack_ptr;
27861   rtx stack_toc_offset;
27862   rtx stack_toc_mem;
27863   rtx func_toc_offset;
27864   rtx func_toc_mem;
27865   rtx func_sc_offset;
27866   rtx func_sc_mem;
27867   rtx insn;
27868   rtx (*call_func) (rtx, rtx, rtx, rtx);
27869   rtx (*call_value_func) (rtx, rtx, rtx, rtx, rtx);
27870
27871   stack_ptr = gen_rtx_REG (Pmode, STACK_POINTER_REGNUM);
27872   toc_reg = gen_rtx_REG (Pmode, TOC_REGNUM);
27873
27874   /* Load up address of the actual function.  */
27875   func_desc = force_reg (Pmode, func_desc);
27876   func_addr = gen_reg_rtx (Pmode);
27877   emit_move_insn (func_addr, gen_rtx_MEM (Pmode, func_desc));
27878
27879   if (TARGET_32BIT)
27880     {
27881
27882       stack_toc_offset = GEN_INT (TOC_SAVE_OFFSET_32BIT);
27883       func_toc_offset = GEN_INT (AIX_FUNC_DESC_TOC_32BIT);
27884       func_sc_offset = GEN_INT (AIX_FUNC_DESC_SC_32BIT);
27885       if (TARGET_POINTERS_TO_NESTED_FUNCTIONS)
27886         {
27887           call_func = gen_call_indirect_aix32bit;
27888           call_value_func = gen_call_value_indirect_aix32bit;
27889         }
27890       else
27891         {
27892           call_func = gen_call_indirect_aix32bit_nor11;
27893           call_value_func = gen_call_value_indirect_aix32bit_nor11;
27894         }
27895     }
27896   else
27897     {
27898       stack_toc_offset = GEN_INT (TOC_SAVE_OFFSET_64BIT);
27899       func_toc_offset = GEN_INT (AIX_FUNC_DESC_TOC_64BIT);
27900       func_sc_offset = GEN_INT (AIX_FUNC_DESC_SC_64BIT);
27901       if (TARGET_POINTERS_TO_NESTED_FUNCTIONS)
27902         {
27903           call_func = gen_call_indirect_aix64bit;
27904           call_value_func = gen_call_value_indirect_aix64bit;
27905         }
27906       else
27907         {
27908           call_func = gen_call_indirect_aix64bit_nor11;
27909           call_value_func = gen_call_value_indirect_aix64bit_nor11;
27910         }
27911     }
27912
27913   /* Reserved spot to store the TOC.  */
27914   stack_toc_mem = gen_frame_mem (Pmode,
27915                                  gen_rtx_PLUS (Pmode,
27916                                                stack_ptr,
27917                                                stack_toc_offset));
27918
27919   gcc_assert (cfun);
27920   gcc_assert (cfun->machine);
27921
27922   /* Can we optimize saving the TOC in the prologue or do we need to do it at
27923      every call?  */
27924   if (TARGET_SAVE_TOC_INDIRECT && !cfun->calls_alloca)
27925     cfun->machine->save_toc_in_prologue = true;
27926
27927   else
27928     {
27929       MEM_VOLATILE_P (stack_toc_mem) = 1;
27930       emit_move_insn (stack_toc_mem, toc_reg);
27931     }
27932
27933   /* Calculate the address to load the TOC of the called function.  We don't
27934      actually load this until the split after reload.  */
27935   func_toc_mem = gen_rtx_MEM (Pmode,
27936                               gen_rtx_PLUS (Pmode,
27937                                             func_desc,
27938                                             func_toc_offset));
27939
27940   /* If we have a static chain, load it up.  */
27941   if (TARGET_POINTERS_TO_NESTED_FUNCTIONS)
27942     {
27943       func_sc_mem = gen_rtx_MEM (Pmode,
27944                                  gen_rtx_PLUS (Pmode,
27945                                                func_desc,
27946                                                func_sc_offset));
27947
27948       sc_reg = gen_rtx_REG (Pmode, STATIC_CHAIN_REGNUM);
27949       emit_move_insn (sc_reg, func_sc_mem);
27950     }
27951
27952   /* Create the call.  */
27953   if (value)
27954     insn = call_value_func (value, func_addr, flag, func_toc_mem,
27955                             stack_toc_mem);
27956   else
27957     insn = call_func (func_addr, flag, func_toc_mem, stack_toc_mem);
27958
27959   emit_call_insn (insn);
27960 }
27961
27962 /* Return whether we need to always update the saved TOC pointer when we update
27963    the stack pointer.  */
27964
27965 static bool
27966 rs6000_save_toc_in_prologue_p (void)
27967 {
27968   return (cfun && cfun->machine && cfun->machine->save_toc_in_prologue);
27969 }
27970
27971 #ifdef HAVE_GAS_HIDDEN
27972 # define USE_HIDDEN_LINKONCE 1
27973 #else
27974 # define USE_HIDDEN_LINKONCE 0
27975 #endif
27976
27977 /* Fills in the label name that should be used for a 476 link stack thunk.  */
27978
27979 void
27980 get_ppc476_thunk_name (char name[32])
27981 {
27982   gcc_assert (TARGET_LINK_STACK);
27983
27984   if (USE_HIDDEN_LINKONCE)
27985     sprintf (name, "__ppc476.get_thunk");
27986   else
27987     ASM_GENERATE_INTERNAL_LABEL (name, "LPPC476_", 0);
27988 }
27989
27990 /* This function emits the simple thunk routine that is used to preserve
27991    the link stack on the 476 cpu.  */
27992
27993 static void
27994 rs6000_code_end (void)
27995 {
27996   char name[32];
27997   tree decl;
27998
27999   if (!TARGET_LINK_STACK)
28000     return;
28001
28002   get_ppc476_thunk_name (name);
28003
28004   decl = build_decl (BUILTINS_LOCATION, FUNCTION_DECL, get_identifier (name),
28005                      build_function_type_list (void_type_node, NULL_TREE));
28006   DECL_RESULT (decl) = build_decl (BUILTINS_LOCATION, RESULT_DECL,
28007                                    NULL_TREE, void_type_node);
28008   TREE_PUBLIC (decl) = 1;
28009   TREE_STATIC (decl) = 1;
28010
28011   if (USE_HIDDEN_LINKONCE)
28012     {
28013       DECL_COMDAT_GROUP (decl) = DECL_ASSEMBLER_NAME (decl);
28014       targetm.asm_out.unique_section (decl, 0);
28015       switch_to_section (get_named_section (decl, NULL, 0));
28016       DECL_WEAK (decl) = 1;
28017       ASM_WEAKEN_DECL (asm_out_file, decl, name, 0);
28018       targetm.asm_out.globalize_label (asm_out_file, name);
28019       targetm.asm_out.assemble_visibility (decl, VISIBILITY_HIDDEN);
28020       ASM_DECLARE_FUNCTION_NAME (asm_out_file, name, decl);
28021     }
28022   else
28023     {
28024       switch_to_section (text_section);
28025       ASM_OUTPUT_LABEL (asm_out_file, name);
28026     }
28027
28028   DECL_INITIAL (decl) = make_node (BLOCK);
28029   current_function_decl = decl;
28030   init_function_start (decl);
28031   first_function_block_is_cold = false;
28032   /* Make sure unwind info is emitted for the thunk if needed.  */
28033   final_start_function (emit_barrier (), asm_out_file, 1);
28034
28035   fputs ("\tblr\n", asm_out_file);
28036
28037   final_end_function ();
28038   init_insn_lengths ();
28039   free_after_compilation (cfun);
28040   set_cfun (NULL);
28041   current_function_decl = NULL;
28042 }
28043
28044 struct gcc_target targetm = TARGET_INITIALIZER;
28045
28046 #include "gt-rs6000.h"