gcc/config/alpha/alpha.c

   1 /* Subroutines used for code generation on the DEC Alpha.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999,
   3    2000, 2001, 2002, 2003 Free Software Foundation, Inc.
   4    Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 59 Temple Place - Suite 330,
  21 Boston, MA 02111-1307, USA.  */
  22
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "rtl.h"
  29 #include "tree.h"
  30 #include "regs.h"
  31 #include "hard-reg-set.h"
  32 #include "real.h"
  33 #include "insn-config.h"
  34 #include "conditions.h"
  35 #include "output.h"
  36 #include "insn-attr.h"
  37 #include "flags.h"
  38 #include "recog.h"
  39 #include "expr.h"
  40 #include "optabs.h"
  41 #include "reload.h"
  42 #include "obstack.h"
  43 #include "except.h"
  44 #include "function.h"
  45 #include "toplev.h"
  46 #include "ggc.h"
  47 #include "integrate.h"
  48 #include "tm_p.h"
  49 #include "target.h"
  50 #include "target-def.h"
  51 #include "debug.h"
  52 #include "langhooks.h"
  53 #include <splay-tree.h>
  54 #include "cfglayout.h"
  55
  56 /* Specify which cpu to schedule for.  */
  57
  58 enum processor_type alpha_cpu;
  59 static const char * const alpha_cpu_name[] =
  60 {
  61   "ev4", "ev5", "ev6"
  62 };
  63
  64 /* Specify how accurate floating-point traps need to be.  */
  65
  66 enum alpha_trap_precision alpha_tp;
  67
  68 /* Specify the floating-point rounding mode.  */
  69
  70 enum alpha_fp_rounding_mode alpha_fprm;
  71
  72 /* Specify which things cause traps.  */
  73
  74 enum alpha_fp_trap_mode alpha_fptm;
  75
  76 /* Specify bit size of immediate TLS offsets.  */
  77
  78 int alpha_tls_size = 32;
  79
  80 /* Strings decoded into the above options.  */
  81
  82 const char *alpha_cpu_string;   /* -mcpu= */
  83 const char *alpha_tune_string;  /* -mtune= */
  84 const char *alpha_tp_string;    /* -mtrap-precision=[p|s|i] */
  85 const char *alpha_fprm_string;  /* -mfp-rounding-mode=[n|m|c|d] */
  86 const char *alpha_fptm_string;  /* -mfp-trap-mode=[n|u|su|sui] */
  87 const char *alpha_mlat_string;  /* -mmemory-latency= */
  88 const char *alpha_tls_size_string; /* -mtls-size=[16|32|64] */
  89
  90 /* Save information from a "cmpxx" operation until the branch or scc is
  91    emitted.  */
  92
  93 struct alpha_compare alpha_compare;
  94
  95 /* Nonzero if inside of a function, because the Alpha asm can't
  96    handle .files inside of functions.  */
  97
  98 static int inside_function = FALSE;
  99
 100 /* The number of cycles of latency we should assume on memory reads.  */
 101
 102 int alpha_memory_latency = 3;
 103
 104 /* Whether the function needs the GP.  */
 105
 106 static int alpha_function_needs_gp;
 107
 108 /* The alias set for prologue/epilogue register save/restore.  */
 109
 110 static GTY(()) int alpha_sr_alias_set;
 111
 112 /* The assembler name of the current function.  */
 113
 114 static const char *alpha_fnname;
 115
 116 /* The next explicit relocation sequence number.  */
 117 extern GTY(()) int alpha_next_sequence_number;
 118 int alpha_next_sequence_number = 1;
 119
 120 /* The literal and gpdisp sequence numbers for this insn, as printed
 121    by %# and %* respectively.  */
 122 extern GTY(()) int alpha_this_literal_sequence_number;
 123 extern GTY(()) int alpha_this_gpdisp_sequence_number;
 124 int alpha_this_literal_sequence_number;
 125 int alpha_this_gpdisp_sequence_number;
 126
 127 /* Costs of various operations on the different architectures.  */
 128
 129 struct alpha_rtx_cost_data
 130 {
 131   unsigned char fp_add;
 132   unsigned char fp_mult;
 133   unsigned char fp_div_sf;
 134   unsigned char fp_div_df;
 135   unsigned char int_mult_si;
 136   unsigned char int_mult_di;
 137   unsigned char int_shift;
 138   unsigned char int_cmov;
 139 };
 140
 141 static struct alpha_rtx_cost_data const alpha_rtx_cost_data[PROCESSOR_MAX] =
 142 {
 143   { /* EV4 */
 144     COSTS_N_INSNS (6),          /* fp_add */
 145     COSTS_N_INSNS (6),          /* fp_mult */
 146     COSTS_N_INSNS (34),         /* fp_div_sf */
 147     COSTS_N_INSNS (63),         /* fp_div_df */
 148     COSTS_N_INSNS (23),         /* int_mult_si */
 149     COSTS_N_INSNS (23),         /* int_mult_di */
 150     COSTS_N_INSNS (2),          /* int_shift */
 151     COSTS_N_INSNS (2),          /* int_cmov */
 152   },
 153   { /* EV5 */
 154     COSTS_N_INSNS (4),          /* fp_add */
 155     COSTS_N_INSNS (4),          /* fp_mult */
 156     COSTS_N_INSNS (15),         /* fp_div_sf */
 157     COSTS_N_INSNS (22),         /* fp_div_df */
 158     COSTS_N_INSNS (8),          /* int_mult_si */
 159     COSTS_N_INSNS (12),         /* int_mult_di */
 160     COSTS_N_INSNS (1) + 1,      /* int_shift */
 161     COSTS_N_INSNS (1),          /* int_cmov */
 162   },
 163   { /* EV6 */
 164     COSTS_N_INSNS (4),          /* fp_add */
 165     COSTS_N_INSNS (4),          /* fp_mult */
 166     COSTS_N_INSNS (12),         /* fp_div_sf */
 167     COSTS_N_INSNS (15),         /* fp_div_df */
 168     COSTS_N_INSNS (7),          /* int_mult_si */
 169     COSTS_N_INSNS (7),          /* int_mult_di */
 170     COSTS_N_INSNS (1),          /* int_shift */
 171     COSTS_N_INSNS (2),          /* int_cmov */
 172   },
 173 };
 174
 175 /* Get the number of args of a function in one of two ways.  */
 176 #if TARGET_ABI_OPEN_VMS || TARGET_ABI_UNICOSMK
 177 #define NUM_ARGS current_function_args_info.num_args
 178 #else
 179 #define NUM_ARGS current_function_args_info
 180 #endif
 181
 182 #define REG_PV 27
 183 #define REG_RA 26
 184
 185 /* Declarations of static functions.  */
 186 static struct machine_function *alpha_init_machine_status (void);
 187 static rtx alpha_emit_xfloating_compare (enum rtx_code, rtx, rtx);
 188
 189 #if TARGET_ABI_OPEN_VMS
 190 static void alpha_write_linkage (FILE *, const char *, tree);
 191 #endif
 192
 193 static void unicosmk_output_deferred_case_vectors (FILE *);
 194 static void unicosmk_gen_dsib (unsigned long *);
 195 static void unicosmk_output_ssib (FILE *, const char *);
 196 static int unicosmk_need_dex (rtx);
 197 \f
 198 /* Parse target option strings.  */
 199
 200 void
 201 override_options (void)
 202 {
 203   int i;
 204   static const struct cpu_table {
 205     const char *const name;
 206     const enum processor_type processor;
 207     const int flags;
 208   } cpu_table[] = {
 209 #define EV5_MASK (MASK_CPU_EV5)
 210 #define EV6_MASK (MASK_CPU_EV6|MASK_BWX|MASK_MAX|MASK_FIX)
 211     { "ev4",    PROCESSOR_EV4, 0 },
 212     { "ev45",   PROCESSOR_EV4, 0 },
 213     { "21064",  PROCESSOR_EV4, 0 },
 214     { "ev5",    PROCESSOR_EV5, EV5_MASK },
 215     { "21164",  PROCESSOR_EV5, EV5_MASK },
 216     { "ev56",   PROCESSOR_EV5, EV5_MASK|MASK_BWX },
 217     { "21164a", PROCESSOR_EV5, EV5_MASK|MASK_BWX },
 218     { "pca56",  PROCESSOR_EV5, EV5_MASK|MASK_BWX|MASK_MAX },
 219     { "21164PC",PROCESSOR_EV5, EV5_MASK|MASK_BWX|MASK_MAX },
 220     { "21164pc",PROCESSOR_EV5, EV5_MASK|MASK_BWX|MASK_MAX },
 221     { "ev6",    PROCESSOR_EV6, EV6_MASK },
 222     { "21264",  PROCESSOR_EV6, EV6_MASK },
 223     { "ev67",   PROCESSOR_EV6, EV6_MASK|MASK_CIX },
 224     { "21264a", PROCESSOR_EV6, EV6_MASK|MASK_CIX },
 225     { 0, 0, 0 }
 226   };
 227
 228   /* Unicos/Mk doesn't have shared libraries.  */
 229   if (TARGET_ABI_UNICOSMK && flag_pic)
 230     {
 231       warning ("-f%s ignored for Unicos/Mk (not supported)",
 232                (flag_pic > 1) ? "PIC" : "pic");
 233       flag_pic = 0;
 234     }
 235
 236   /* On Unicos/Mk, the native compiler consistently generates /d suffices for
 237      floating-point instructions.  Make that the default for this target.  */
 238   if (TARGET_ABI_UNICOSMK)
 239     alpha_fprm = ALPHA_FPRM_DYN;
 240   else
 241     alpha_fprm = ALPHA_FPRM_NORM;
 242
 243   alpha_tp = ALPHA_TP_PROG;
 244   alpha_fptm = ALPHA_FPTM_N;
 245
 246   /* We cannot use su and sui qualifiers for conversion instructions on
 247      Unicos/Mk.  I'm not sure if this is due to assembler or hardware
 248      limitations.  Right now, we issue a warning if -mieee is specified
 249      and then ignore it; eventually, we should either get it right or
 250      disable the option altogether.  */
 251
 252   if (TARGET_IEEE)
 253     {
 254       if (TARGET_ABI_UNICOSMK)
 255         warning ("-mieee not supported on Unicos/Mk");
 256       else
 257         {
 258           alpha_tp = ALPHA_TP_INSN;
 259           alpha_fptm = ALPHA_FPTM_SU;
 260         }
 261     }
 262
 263   if (TARGET_IEEE_WITH_INEXACT)
 264     {
 265       if (TARGET_ABI_UNICOSMK)
 266         warning ("-mieee-with-inexact not supported on Unicos/Mk");
 267       else
 268         {
 269           alpha_tp = ALPHA_TP_INSN;
 270           alpha_fptm = ALPHA_FPTM_SUI;
 271         }
 272     }
 273
 274   if (alpha_tp_string)
 275     {
 276       if (! strcmp (alpha_tp_string, "p"))
 277         alpha_tp = ALPHA_TP_PROG;
 278       else if (! strcmp (alpha_tp_string, "f"))
 279         alpha_tp = ALPHA_TP_FUNC;
 280       else if (! strcmp (alpha_tp_string, "i"))
 281         alpha_tp = ALPHA_TP_INSN;
 282       else
 283         error ("bad value `%s' for -mtrap-precision switch", alpha_tp_string);
 284     }
 285
 286   if (alpha_fprm_string)
 287     {
 288       if (! strcmp (alpha_fprm_string, "n"))
 289         alpha_fprm = ALPHA_FPRM_NORM;
 290       else if (! strcmp (alpha_fprm_string, "m"))
 291         alpha_fprm = ALPHA_FPRM_MINF;
 292       else if (! strcmp (alpha_fprm_string, "c"))
 293         alpha_fprm = ALPHA_FPRM_CHOP;
 294       else if (! strcmp (alpha_fprm_string,"d"))
 295         alpha_fprm = ALPHA_FPRM_DYN;
 296       else
 297         error ("bad value `%s' for -mfp-rounding-mode switch",
 298                alpha_fprm_string);
 299     }
 300
 301   if (alpha_fptm_string)
 302     {
 303       if (strcmp (alpha_fptm_string, "n") == 0)
 304         alpha_fptm = ALPHA_FPTM_N;
 305       else if (strcmp (alpha_fptm_string, "u") == 0)
 306         alpha_fptm = ALPHA_FPTM_U;
 307       else if (strcmp (alpha_fptm_string, "su") == 0)
 308         alpha_fptm = ALPHA_FPTM_SU;
 309       else if (strcmp (alpha_fptm_string, "sui") == 0)
 310         alpha_fptm = ALPHA_FPTM_SUI;
 311       else
 312         error ("bad value `%s' for -mfp-trap-mode switch", alpha_fptm_string);
 313     }
 314
 315   if (alpha_tls_size_string)
 316     {
 317       if (strcmp (alpha_tls_size_string, "16") == 0)
 318         alpha_tls_size = 16;
 319       else if (strcmp (alpha_tls_size_string, "32") == 0)
 320         alpha_tls_size = 32;
 321       else if (strcmp (alpha_tls_size_string, "64") == 0)
 322         alpha_tls_size = 64;
 323       else
 324         error ("bad value `%s' for -mtls-size switch", alpha_tls_size_string);
 325     }
 326
 327   alpha_cpu
 328     = TARGET_CPU_DEFAULT & MASK_CPU_EV6 ? PROCESSOR_EV6
 329       : (TARGET_CPU_DEFAULT & MASK_CPU_EV5 ? PROCESSOR_EV5 : PROCESSOR_EV4);
 330
 331   if (alpha_cpu_string)
 332     {
 333       for (i = 0; cpu_table [i].name; i++)
 334         if (! strcmp (alpha_cpu_string, cpu_table [i].name))
 335           {
 336             alpha_cpu = cpu_table [i].processor;
 337             target_flags &= ~ (MASK_BWX | MASK_MAX | MASK_FIX | MASK_CIX
 338                                | MASK_CPU_EV5 | MASK_CPU_EV6);
 339             target_flags |= cpu_table [i].flags;
 340             break;
 341           }
 342       if (! cpu_table [i].name)
 343         error ("bad value `%s' for -mcpu switch", alpha_cpu_string);
 344     }
 345
 346   if (alpha_tune_string)
 347     {
 348       for (i = 0; cpu_table [i].name; i++)
 349         if (! strcmp (alpha_tune_string, cpu_table [i].name))
 350           {
 351             alpha_cpu = cpu_table [i].processor;
 352             break;
 353           }
 354       if (! cpu_table [i].name)
 355         error ("bad value `%s' for -mcpu switch", alpha_tune_string);
 356     }
 357
 358   /* Do some sanity checks on the above options.  */
 359
 360   if (TARGET_ABI_UNICOSMK && alpha_fptm != ALPHA_FPTM_N)
 361     {
 362       warning ("trap mode not supported on Unicos/Mk");
 363       alpha_fptm = ALPHA_FPTM_N;
 364     }
 365
 366   if ((alpha_fptm == ALPHA_FPTM_SU || alpha_fptm == ALPHA_FPTM_SUI)
 367       && alpha_tp != ALPHA_TP_INSN && ! TARGET_CPU_EV6)
 368     {
 369       warning ("fp software completion requires -mtrap-precision=i");
 370       alpha_tp = ALPHA_TP_INSN;
 371     }
 372
 373   if (TARGET_CPU_EV6)
 374     {
 375       /* Except for EV6 pass 1 (not released), we always have precise
 376          arithmetic traps.  Which means we can do software completion
 377          without minding trap shadows.  */
 378       alpha_tp = ALPHA_TP_PROG;
 379     }
 380
 381   if (TARGET_FLOAT_VAX)
 382     {
 383       if (alpha_fprm == ALPHA_FPRM_MINF || alpha_fprm == ALPHA_FPRM_DYN)
 384         {
 385           warning ("rounding mode not supported for VAX floats");
 386           alpha_fprm = ALPHA_FPRM_NORM;
 387         }
 388       if (alpha_fptm == ALPHA_FPTM_SUI)
 389         {
 390           warning ("trap mode not supported for VAX floats");
 391           alpha_fptm = ALPHA_FPTM_SU;
 392         }
 393     }
 394
 395   {
 396     char *end;
 397     int lat;
 398
 399     if (!alpha_mlat_string)
 400       alpha_mlat_string = "L1";
 401
 402     if (ISDIGIT ((unsigned char)alpha_mlat_string[0])
 403         && (lat = strtol (alpha_mlat_string, &end, 10), *end == '\0'))
 404       ;
 405     else if ((alpha_mlat_string[0] == 'L' || alpha_mlat_string[0] == 'l')
 406              && ISDIGIT ((unsigned char)alpha_mlat_string[1])
 407              && alpha_mlat_string[2] == '\0')
 408       {
 409         static int const cache_latency[][4] =
 410         {
 411           { 3, 30, -1 },        /* ev4 -- Bcache is a guess */
 412           { 2, 12, 38 },        /* ev5 -- Bcache from PC164 LMbench numbers */
 413           { 3, 12, 30 },        /* ev6 -- Bcache from DS20 LMbench.  */
 414         };
 415
 416         lat = alpha_mlat_string[1] - '0';
 417         if (lat <= 0 || lat > 3 || cache_latency[alpha_cpu][lat-1] == -1)
 418           {
 419             warning ("L%d cache latency unknown for %s",
 420                      lat, alpha_cpu_name[alpha_cpu]);
 421             lat = 3;
 422           }
 423         else
 424           lat = cache_latency[alpha_cpu][lat-1];
 425       }
 426     else if (! strcmp (alpha_mlat_string, "main"))
 427       {
 428         /* Most current memories have about 370ns latency.  This is
 429            a reasonable guess for a fast cpu.  */
 430         lat = 150;
 431       }
 432     else
 433       {
 434         warning ("bad value `%s' for -mmemory-latency", alpha_mlat_string);
 435         lat = 3;
 436       }
 437
 438     alpha_memory_latency = lat;
 439   }
 440
 441   /* Default the definition of "small data" to 8 bytes.  */
 442   if (!g_switch_set)
 443     g_switch_value = 8;
 444
 445   /* Infer TARGET_SMALL_DATA from -fpic/-fPIC.  */
 446   if (flag_pic == 1)
 447     target_flags |= MASK_SMALL_DATA;
 448   else if (flag_pic == 2)
 449     target_flags &= ~MASK_SMALL_DATA;
 450
 451   /* Align labels and loops for optimal branching.  */
 452   /* ??? Kludge these by not doing anything if we don't optimize and also if
 453      we are writing ECOFF symbols to work around a bug in DEC's assembler.  */
 454   if (optimize > 0 && write_symbols != SDB_DEBUG)
 455     {
 456       if (align_loops <= 0)
 457         align_loops = 16;
 458       if (align_jumps <= 0)
 459         align_jumps = 16;
 460     }
 461   if (align_functions <= 0)
 462     align_functions = 16;
 463
 464   /* Acquire a unique set number for our register saves and restores.  */
 465   alpha_sr_alias_set = new_alias_set ();
 466
 467   /* Register variables and functions with the garbage collector.  */
 468
 469   /* Set up function hooks.  */
 470   init_machine_status = alpha_init_machine_status;
 471
 472   /* Tell the compiler when we're using VAX floating point.  */
 473   if (TARGET_FLOAT_VAX)
 474     {
 475       real_format_for_mode[SFmode - QFmode] = &vax_f_format;
 476       real_format_for_mode[DFmode - QFmode] = &vax_g_format;
 477       real_format_for_mode[TFmode - QFmode] = NULL;
 478     }
 479 }
 480 \f
 481 /* Returns 1 if VALUE is a mask that contains full bytes of zero or ones.  */
 482
 483 int
 484 zap_mask (HOST_WIDE_INT value)
 485 {
 486   int i;
 487
 488   for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
 489        i++, value >>= 8)
 490     if ((value & 0xff) != 0 && (value & 0xff) != 0xff)
 491       return 0;
 492
 493   return 1;
 494 }
 495
 496 /* Returns 1 if OP is either the constant zero or a register.  If a
 497    register, it must be in the proper mode unless MODE is VOIDmode.  */
 498
 499 int
 500 reg_or_0_operand (rtx op, enum machine_mode mode)
 501 {
 502   return op == CONST0_RTX (mode) || register_operand (op, mode);
 503 }
 504
 505 /* Return 1 if OP is a constant in the range of 0-63 (for a shift) or
 506    any register.  */
 507
 508 int
 509 reg_or_6bit_operand (rtx op, enum machine_mode mode)
 510 {
 511   return ((GET_CODE (op) == CONST_INT
 512            && (unsigned HOST_WIDE_INT) INTVAL (op) < 64)
 513           || register_operand (op, mode));
 514 }
 515
 516
 517 /* Return 1 if OP is an 8-bit constant or any register.  */
 518
 519 int
 520 reg_or_8bit_operand (rtx op, enum machine_mode mode)
 521 {
 522   return ((GET_CODE (op) == CONST_INT
 523            && (unsigned HOST_WIDE_INT) INTVAL (op) < 0x100)
 524           || register_operand (op, mode));
 525 }
 526
 527 /* Return 1 if OP is a constant or any register.  */
 528
 529 int
 530 reg_or_const_int_operand (rtx op, enum machine_mode mode)
 531 {
 532   return GET_CODE (op) == CONST_INT || register_operand (op, mode);
 533 }
 534
 535 /* Return 1 if OP is an 8-bit constant.  */
 536
 537 int
 538 cint8_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
 539 {
 540   return ((GET_CODE (op) == CONST_INT
 541            && (unsigned HOST_WIDE_INT) INTVAL (op) < 0x100));
 542 }
 543
 544 /* Return 1 if the operand is a valid second operand to an add insn.  */
 545
 546 int
 547 add_operand (rtx op, enum machine_mode mode)
 548 {
 549   if (GET_CODE (op) == CONST_INT)
 550     /* Constraints I, J, O and P are covered by K.  */
 551     return (CONST_OK_FOR_LETTER_P (INTVAL (op), 'K')
 552             || CONST_OK_FOR_LETTER_P (INTVAL (op), 'L'));
 553
 554   return register_operand (op, mode);
 555 }
 556
 557 /* Return 1 if the operand is a valid second operand to a sign-extending
 558    add insn.  */
 559
 560 int
 561 sext_add_operand (rtx op, enum machine_mode mode)
 562 {
 563   if (GET_CODE (op) == CONST_INT)
 564     return (CONST_OK_FOR_LETTER_P (INTVAL (op), 'I')
 565             || CONST_OK_FOR_LETTER_P (INTVAL (op), 'O'));
 566
 567   return reg_not_elim_operand (op, mode);
 568 }
 569
 570 /* Return 1 if OP is the constant 4 or 8.  */
 571
 572 int
 573 const48_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
 574 {
 575   return (GET_CODE (op) == CONST_INT
 576           && (INTVAL (op) == 4 || INTVAL (op) == 8));
 577 }
 578
 579 /* Return 1 if OP is a valid first operand to an AND insn.  */
 580
 581 int
 582 and_operand (rtx op, enum machine_mode mode)
 583 {
 584   if (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == VOIDmode)
 585     return (zap_mask (CONST_DOUBLE_LOW (op))
 586             && zap_mask (CONST_DOUBLE_HIGH (op)));
 587
 588   if (GET_CODE (op) == CONST_INT)
 589     return ((unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
 590             || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100
 591             || zap_mask (INTVAL (op)));
 592
 593   return register_operand (op, mode);
 594 }
 595
 596 /* Return 1 if OP is a valid first operand to an IOR or XOR insn.  */
 597
 598 int
 599 or_operand (rtx op, enum machine_mode mode)
 600 {
 601   if (GET_CODE (op) == CONST_INT)
 602     return ((unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
 603             || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100);
 604
 605   return register_operand (op, mode);
 606 }
 607
 608 /* Return 1 if OP is a constant that is the width, in bits, of an integral
 609    mode smaller than DImode.  */
 610
 611 int
 612 mode_width_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
 613 {
 614   return (GET_CODE (op) == CONST_INT
 615           && (INTVAL (op) == 8 || INTVAL (op) == 16
 616               || INTVAL (op) == 32 || INTVAL (op) == 64));
 617 }
 618
 619 /* Return 1 if OP is a constant that is the width of an integral machine mode
 620    smaller than an integer.  */
 621
 622 int
 623 mode_mask_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
 624 {
 625   if (GET_CODE (op) == CONST_INT)
 626     {
 627       HOST_WIDE_INT value = INTVAL (op);
 628
 629       if (value == 0xff)
 630         return 1;
 631       if (value == 0xffff)
 632         return 1;
 633       if (value == 0xffffffff)
 634         return 1;
 635       if (value == -1)
 636         return 1;
 637     }
 638   else if (HOST_BITS_PER_WIDE_INT == 32 && GET_CODE (op) == CONST_DOUBLE)
 639     {
 640       if (CONST_DOUBLE_LOW (op) == 0xffffffff && CONST_DOUBLE_HIGH (op) == 0)
 641         return 1;
 642     }
 643
 644   return 0;
 645 }
 646
 647 /* Return 1 if OP is a multiple of 8 less than 64.  */
 648
 649 int
 650 mul8_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
 651 {
 652   return (GET_CODE (op) == CONST_INT
 653           && (unsigned HOST_WIDE_INT) INTVAL (op) < 64
 654           && (INTVAL (op) & 7) == 0);
 655 }
 656
 657 /* Return 1 if OP is the zero constant for MODE.  */
 658
 659 int
 660 const0_operand (rtx op, enum machine_mode mode)
 661 {
 662   return op == CONST0_RTX (mode);
 663 }
 664
 665 /* Return 1 if OP is a hard floating-point register.  */
 666
 667 int
 668 hard_fp_register_operand (rtx op, enum machine_mode mode)
 669 {
 670   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 671     return 0;
 672
 673   if (GET_CODE (op) == SUBREG)
 674     op = SUBREG_REG (op);
 675   return GET_CODE (op) == REG && REGNO_REG_CLASS (REGNO (op)) == FLOAT_REGS;
 676 }
 677
 678 /* Return 1 if OP is a hard general register.  */
 679
 680 int
 681 hard_int_register_operand (rtx op, enum machine_mode mode)
 682 {
 683   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 684     return 0;
 685
 686   if (GET_CODE (op) == SUBREG)
 687     op = SUBREG_REG (op);
 688   return GET_CODE (op) == REG && REGNO_REG_CLASS (REGNO (op)) == GENERAL_REGS;
 689 }
 690
 691 /* Return 1 if OP is a register or a constant integer.  */
 692
 693
 694 int
 695 reg_or_cint_operand (rtx op, enum machine_mode mode)
 696 {
 697      return (GET_CODE (op) == CONST_INT
 698              || register_operand (op, mode));
 699 }
 700
 701 /* Return 1 if OP is something that can be reloaded into a register;
 702    if it is a MEM, it need not be valid.  */
 703
 704 int
 705 some_operand (rtx op, enum machine_mode mode)
 706 {
 707   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 708     return 0;
 709
 710   switch (GET_CODE (op))
 711     {
 712     case REG:
 713     case MEM:
 714     case CONST_INT:
 715     case CONST_DOUBLE:
 716     case CONST_VECTOR:
 717     case LABEL_REF:
 718     case SYMBOL_REF:
 719     case CONST:
 720     case HIGH:
 721       return 1;
 722
 723     case SUBREG:
 724       return some_operand (SUBREG_REG (op), VOIDmode);
 725
 726     default:
 727       break;
 728     }
 729
 730   return 0;
 731 }
 732
 733 /* Likewise, but don't accept constants.  */
 734
 735 int
 736 some_ni_operand (rtx op, enum machine_mode mode)
 737 {
 738   if (GET_MODE (op) != mode && mode != VOIDmode)
 739     return 0;
 740
 741   if (GET_CODE (op) == SUBREG)
 742     op = SUBREG_REG (op);
 743
 744   return (GET_CODE (op) == REG || GET_CODE (op) == MEM);
 745 }
 746
 747 /* Return 1 if OP is a valid operand for the source of a move insn.  */
 748
 749 int
 750 input_operand (rtx op, enum machine_mode mode)
 751 {
 752   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 753     return 0;
 754
 755   if (GET_MODE_CLASS (mode) == MODE_FLOAT && GET_MODE (op) != mode)
 756     return 0;
 757
 758   switch (GET_CODE (op))
 759     {
 760     case LABEL_REF:
 761     case SYMBOL_REF:
 762     case CONST:
 763       if (TARGET_EXPLICIT_RELOCS)
 764         {
 765           /* We don't split symbolic operands into something unintelligable
 766              until after reload, but we do not wish non-small, non-global
 767              symbolic operands to be reconstructed from their high/lo_sum
 768              form.  */
 769           return (small_symbolic_operand (op, mode)
 770                   || global_symbolic_operand (op, mode)
 771                   || gotdtp_symbolic_operand (op, mode)
 772                   || gottp_symbolic_operand (op, mode));
 773         }
 774
 775       /* This handles both the Windows/NT and OSF cases.  */
 776       return mode == ptr_mode || mode == DImode;
 777
 778     case HIGH:
 779       return (TARGET_EXPLICIT_RELOCS
 780               && local_symbolic_operand (XEXP (op, 0), mode));
 781
 782     case REG:
 783     case ADDRESSOF:
 784       return 1;
 785
 786     case SUBREG:
 787       if (register_operand (op, mode))
 788         return 1;
 789       /* ... fall through ...  */
 790     case MEM:
 791       return ((TARGET_BWX || (mode != HImode && mode != QImode))
 792               && general_operand (op, mode));
 793
 794     case CONST_DOUBLE:
 795     case CONST_VECTOR:
 796       return op == CONST0_RTX (mode);
 797
 798     case CONST_INT:
 799       return mode == QImode || mode == HImode || add_operand (op, mode);
 800
 801     case CONSTANT_P_RTX:
 802       return 1;
 803
 804     default:
 805       break;
 806     }
 807
 808   return 0;
 809 }
 810
 811 /* Return 1 if OP is a SYMBOL_REF for a function known to be in this
 812    file, and in the same section as the current function.  */
 813
 814 int
 815 samegp_function_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
 816 {
 817   if (GET_CODE (op) != SYMBOL_REF)
 818     return false;
 819
 820   /* Easy test for recursion.  */
 821   if (op == XEXP (DECL_RTL (current_function_decl), 0))
 822     return true;
 823
 824   /* Functions that are not local can be overridden, and thus may
 825      not share the same gp.  */
 826   if (! SYMBOL_REF_LOCAL_P (op))
 827     return false;
 828
 829   /* If -msmall-data is in effect, assume that there is only one GP
 830      for the module, and so any local symbol has this property.  We
 831      need explicit relocations to be able to enforce this for symbols
 832      not defined in this unit of translation, however.  */
 833   if (TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA)
 834     return true;
 835
 836   /* Functions that are not external are defined in this UoT,
 837      and thus must share the same gp.  */
 838   return ! SYMBOL_REF_EXTERNAL_P (op);
 839 }
 840
 841 /* Return 1 if OP is a SYMBOL_REF for which we can make a call via bsr.  */
 842
 843 int
 844 direct_call_operand (rtx op, enum machine_mode mode)
 845 {
 846   tree op_decl, cfun_sec, op_sec;
 847
 848   /* Must share the same GP.  */
 849   if (!samegp_function_operand (op, mode))
 850     return false;
 851
 852   /* If profiling is implemented via linker tricks, we can't jump
 853      to the nogp alternate entry point.  Note that current_function_profile
 854      would not be correct, since that doesn't indicate if the target
 855      function uses profiling.  */
 856   /* ??? TARGET_PROFILING_NEEDS_GP isn't really the right test,
 857      but is approximately correct for the OSF ABIs.  Don't know
 858      what to do for VMS, NT, or UMK.  */
 859   if (!TARGET_PROFILING_NEEDS_GP && profile_flag)
 860     return false;
 861
 862   /* Must be a function.  In some cases folks create thunks in static
 863      data structures and then make calls to them.  If we allow the
 864      direct call, we'll get an error from the linker about !samegp reloc
 865      against a symbol without a .prologue directive.  */
 866   if (!SYMBOL_REF_FUNCTION_P (op))
 867     return false;
 868
 869   /* Must be "near" so that the branch is assumed to reach.  With
 870      -msmall-text, this is assumed true of all local symbols.  Since
 871      we've already checked samegp, locality is already assured.  */
 872   if (TARGET_SMALL_TEXT)
 873     return true;
 874
 875   /* Otherwise, a decl is "near" if it is defined in the same section.  */
 876   if (flag_function_sections)
 877     return false;
 878
 879   op_decl = SYMBOL_REF_DECL (op);
 880   if (DECL_ONE_ONLY (current_function_decl)
 881       || (op_decl && DECL_ONE_ONLY (op_decl)))
 882     return false;
 883
 884   cfun_sec = DECL_SECTION_NAME (current_function_decl);
 885   op_sec = op_decl ? DECL_SECTION_NAME (op_decl) : NULL;
 886   return ((!cfun_sec && !op_sec)
 887           || (cfun_sec && op_sec
 888               && strcmp (TREE_STRING_POINTER (cfun_sec),
 889                          TREE_STRING_POINTER (op_sec)) == 0));
 890 }
 891
 892 /* Return true if OP is a LABEL_REF, or SYMBOL_REF or CONST referencing
 893    a (non-tls) variable known to be defined in this file.  */
 894
 895 int
 896 local_symbolic_operand (rtx op, enum machine_mode mode)
 897 {
 898   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 899     return 0;
 900
 901   if (GET_CODE (op) == LABEL_REF)
 902     return 1;
 903
 904   if (GET_CODE (op) == CONST
 905       && GET_CODE (XEXP (op, 0)) == PLUS
 906       && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
 907     op = XEXP (XEXP (op, 0), 0);
 908
 909   if (GET_CODE (op) != SYMBOL_REF)
 910     return 0;
 911
 912   return SYMBOL_REF_LOCAL_P (op) && !SYMBOL_REF_TLS_MODEL (op);
 913 }
 914
 915 /* Return true if OP is a SYMBOL_REF or CONST referencing a variable
 916    known to be defined in this file in the small data area.  */
 917
 918 int
 919 small_symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
 920 {
 921   if (! TARGET_SMALL_DATA)
 922     return 0;
 923
 924   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 925     return 0;
 926
 927   if (GET_CODE (op) == CONST
 928       && GET_CODE (XEXP (op, 0)) == PLUS
 929       && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
 930     op = XEXP (XEXP (op, 0), 0);
 931
 932   if (GET_CODE (op) != SYMBOL_REF)
 933     return 0;
 934
 935   /* ??? There's no encode_section_info equivalent for the rtl
 936      constant pool, so SYMBOL_FLAG_SMALL never gets set.  */
 937   if (CONSTANT_POOL_ADDRESS_P (op))
 938     return GET_MODE_SIZE (get_pool_mode (op)) <= g_switch_value;
 939
 940   return (SYMBOL_REF_LOCAL_P (op)
 941           && SYMBOL_REF_SMALL_P (op)
 942           && SYMBOL_REF_TLS_MODEL (op) == 0);
 943 }
 944
 945 /* Return true if OP is a SYMBOL_REF or CONST referencing a variable
 946    not known (or known not) to be defined in this file.  */
 947
 948 int
 949 global_symbolic_operand (rtx op, enum machine_mode mode)
 950 {
 951   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 952     return 0;
 953
 954   if (GET_CODE (op) == CONST
 955       && GET_CODE (XEXP (op, 0)) == PLUS
 956       && GET_CODE (XEXP (XEXP (op, 0), 1)) == CONST_INT)
 957     op = XEXP (XEXP (op, 0), 0);
 958
 959   if (GET_CODE (op) != SYMBOL_REF)
 960     return 0;
 961
 962   return !SYMBOL_REF_LOCAL_P (op) && !SYMBOL_REF_TLS_MODEL (op);
 963 }
 964
 965 /* Return 1 if OP is a valid operand for the MEM of a CALL insn.  */
 966
 967 int
 968 call_operand (rtx op, enum machine_mode mode)
 969 {
 970   if (mode != Pmode)
 971     return 0;
 972
 973   if (GET_CODE (op) == REG)
 974     {
 975       if (TARGET_ABI_OSF)
 976         {
 977           /* Disallow virtual registers to cope with pathological test cases
 978              such as compile/930117-1.c in which the virtual reg decomposes
 979              to the frame pointer.  Which is a hard reg that is not $27.  */
 980           return (REGNO (op) == 27 || REGNO (op) > LAST_VIRTUAL_REGISTER);
 981         }
 982       else
 983         return 1;
 984     }
 985   if (TARGET_ABI_UNICOSMK)
 986     return 0;
 987   if (GET_CODE (op) == SYMBOL_REF)
 988     return 1;
 989
 990   return 0;
 991 }
 992
 993 /* Returns 1 if OP is a symbolic operand, i.e. a symbol_ref or a label_ref,
 994    possibly with an offset.  */
 995
 996 int
 997 symbolic_operand (rtx op, enum machine_mode mode)
 998 {
 999   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
1000     return 0;
1001   if (GET_CODE (op) == SYMBOL_REF || GET_CODE (op) == LABEL_REF)
1002     return 1;
1003   if (GET_CODE (op) == CONST
1004       && GET_CODE (XEXP (op,0)) == PLUS
1005       && GET_CODE (XEXP (XEXP (op,0), 0)) == SYMBOL_REF
1006       && GET_CODE (XEXP (XEXP (op,0), 1)) == CONST_INT)
1007     return 1;
1008   return 0;
1009 }
1010
1011 /* Return true if OP is valid for a particular TLS relocation.  */
1012
1013 static int
1014 tls_symbolic_operand_1 (rtx op, enum machine_mode mode, int size, int unspec)
1015 {
1016   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
1017     return 0;
1018
1019   if (GET_CODE (op) != CONST)
1020     return 0;
1021   op = XEXP (op, 0);
1022
1023   if (GET_CODE (op) != UNSPEC || XINT (op, 1) != unspec)
1024     return 0;
1025   op = XVECEXP (op, 0, 0);
1026
1027   if (GET_CODE (op) != SYMBOL_REF)
1028     return 0;
1029
1030   if (SYMBOL_REF_LOCAL_P (op))
1031     {
1032       if (alpha_tls_size > size)
1033         return 0;
1034     }
1035   else
1036     {
1037       if (size != 64)
1038         return 0;
1039     }
1040
1041   switch (SYMBOL_REF_TLS_MODEL (op))
1042     {
1043     case TLS_MODEL_LOCAL_DYNAMIC:
1044       return unspec == UNSPEC_DTPREL;
1045     case TLS_MODEL_INITIAL_EXEC:
1046       return unspec == UNSPEC_TPREL && size == 64;
1047     case TLS_MODEL_LOCAL_EXEC:
1048       return unspec == UNSPEC_TPREL;
1049     default:
1050       abort ();
1051     }
1052 }
1053
1054 /* Return true if OP is valid for 16-bit DTP relative relocations.  */
1055
1056 int
1057 dtp16_symbolic_operand (rtx op, enum machine_mode mode)
1058 {
1059   return tls_symbolic_operand_1 (op, mode, 16, UNSPEC_DTPREL);
1060 }
1061
1062 /* Return true if OP is valid for 32-bit DTP relative relocations.  */
1063
1064 int
1065 dtp32_symbolic_operand (rtx op, enum machine_mode mode)
1066 {
1067   return tls_symbolic_operand_1 (op, mode, 32, UNSPEC_DTPREL);
1068 }
1069
1070 /* Return true if OP is valid for 64-bit DTP relative relocations.  */
1071
1072 int
1073 gotdtp_symbolic_operand (rtx op, enum machine_mode mode)
1074 {
1075   return tls_symbolic_operand_1 (op, mode, 64, UNSPEC_DTPREL);
1076 }
1077
1078 /* Return true if OP is valid for 16-bit TP relative relocations.  */
1079
1080 int
1081 tp16_symbolic_operand (rtx op, enum machine_mode mode)
1082 {
1083   return tls_symbolic_operand_1 (op, mode, 16, UNSPEC_TPREL);
1084 }
1085
1086 /* Return true if OP is valid for 32-bit TP relative relocations.  */
1087
1088 int
1089 tp32_symbolic_operand (rtx op, enum machine_mode mode)
1090 {
1091   return tls_symbolic_operand_1 (op, mode, 32, UNSPEC_TPREL);
1092 }
1093
1094 /* Return true if OP is valid for 64-bit TP relative relocations.  */
1095
1096 int
1097 gottp_symbolic_operand (rtx op, enum machine_mode mode)
1098 {
1099   return tls_symbolic_operand_1 (op, mode, 64, UNSPEC_TPREL);
1100 }
1101
1102 /* Return 1 if OP is a valid Alpha comparison operator.  Here we know which
1103    comparisons are valid in which insn.  */
1104
1105 int
1106 alpha_comparison_operator (rtx op, enum machine_mode mode)
1107 {
1108   enum rtx_code code = GET_CODE (op);
1109
1110   if (mode != GET_MODE (op) && mode != VOIDmode)
1111     return 0;
1112
1113   return (code == EQ || code == LE || code == LT
1114           || code == LEU || code == LTU);
1115 }
1116
1117 /* Return 1 if OP is a valid Alpha comparison operator against zero.
1118    Here we know which comparisons are valid in which insn.  */
1119
1120 int
1121 alpha_zero_comparison_operator (rtx op, enum machine_mode mode)
1122 {
1123   enum rtx_code code = GET_CODE (op);
1124
1125   if (mode != GET_MODE (op) && mode != VOIDmode)
1126     return 0;
1127
1128   return (code == EQ || code == NE || code == LE || code == LT
1129           || code == LEU || code == LTU);
1130 }
1131
1132 /* Return 1 if OP is a valid Alpha swapped comparison operator.  */
1133
1134 int
1135 alpha_swapped_comparison_operator (rtx op, enum machine_mode mode)
1136 {
1137   enum rtx_code code = GET_CODE (op);
1138
1139   if ((mode != GET_MODE (op) && mode != VOIDmode)
1140       || GET_RTX_CLASS (code) != '<')
1141     return 0;
1142
1143   code = swap_condition (code);
1144   return (code == EQ || code == LE || code == LT
1145           || code == LEU || code == LTU);
1146 }
1147
1148 /* Return 1 if OP is a signed comparison operation.  */
1149
1150 int
1151 signed_comparison_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1152 {
1153   enum rtx_code code = GET_CODE (op);
1154
1155   if (mode != GET_MODE (op) && mode != VOIDmode)
1156     return 0;
1157
1158   return (code == EQ || code == NE
1159           || code == LE || code == LT
1160           || code == GE || code == GT);
1161 }
1162
1163 /* Return 1 if OP is a valid Alpha floating point comparison operator.
1164    Here we know which comparisons are valid in which insn.  */
1165
1166 int
1167 alpha_fp_comparison_operator (rtx op, enum machine_mode mode)
1168 {
1169   enum rtx_code code = GET_CODE (op);
1170
1171   if (mode != GET_MODE (op) && mode != VOIDmode)
1172     return 0;
1173
1174   return (code == EQ || code == LE || code == LT || code == UNORDERED);
1175 }
1176
1177 /* Return 1 if this is a divide or modulus operator.  */
1178
1179 int
1180 divmod_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1181 {
1182   switch (GET_CODE (op))
1183     {
1184     case DIV:  case MOD:  case UDIV:  case UMOD:
1185       return 1;
1186
1187     default:
1188       break;
1189     }
1190
1191   return 0;
1192 }
1193
1194 /* Return 1 if this memory address is a known aligned register plus
1195    a constant.  It must be a valid address.  This means that we can do
1196    this as an aligned reference plus some offset.
1197
1198    Take into account what reload will do.  */
1199
1200 int
1201 aligned_memory_operand (rtx op, enum machine_mode mode)
1202 {
1203   rtx base;
1204
1205   if (reload_in_progress)
1206     {
1207       rtx tmp = op;
1208       if (GET_CODE (tmp) == SUBREG)
1209         tmp = SUBREG_REG (tmp);
1210       if (GET_CODE (tmp) == REG
1211           && REGNO (tmp) >= FIRST_PSEUDO_REGISTER)
1212         {
1213           op = reg_equiv_memory_loc[REGNO (tmp)];
1214           if (op == 0)
1215             return 0;
1216         }
1217     }
1218
1219   if (GET_CODE (op) != MEM
1220       || GET_MODE (op) != mode)
1221     return 0;
1222   op = XEXP (op, 0);
1223
1224   /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
1225      sorts of constructs.  Dig for the real base register.  */
1226   if (reload_in_progress
1227       && GET_CODE (op) == PLUS
1228       && GET_CODE (XEXP (op, 0)) == PLUS)
1229     base = XEXP (XEXP (op, 0), 0);
1230   else
1231     {
1232       if (! memory_address_p (mode, op))
1233         return 0;
1234       base = (GET_CODE (op) == PLUS ? XEXP (op, 0) : op);
1235     }
1236
1237   return (GET_CODE (base) == REG && REGNO_POINTER_ALIGN (REGNO (base)) >= 32);
1238 }
1239
1240 /* Similar, but return 1 if OP is a MEM which is not alignable.  */
1241
1242 int
1243 unaligned_memory_operand (rtx op, enum machine_mode mode)
1244 {
1245   rtx base;
1246
1247   if (reload_in_progress)
1248     {
1249       rtx tmp = op;
1250       if (GET_CODE (tmp) == SUBREG)
1251         tmp = SUBREG_REG (tmp);
1252       if (GET_CODE (tmp) == REG
1253           && REGNO (tmp) >= FIRST_PSEUDO_REGISTER)
1254         {
1255           op = reg_equiv_memory_loc[REGNO (tmp)];
1256           if (op == 0)
1257             return 0;
1258         }
1259     }
1260
1261   if (GET_CODE (op) != MEM
1262       || GET_MODE (op) != mode)
1263     return 0;
1264   op = XEXP (op, 0);
1265
1266   /* LEGITIMIZE_RELOAD_ADDRESS creates (plus (plus reg const_hi) const_lo)
1267      sorts of constructs.  Dig for the real base register.  */
1268   if (reload_in_progress
1269       && GET_CODE (op) == PLUS
1270       && GET_CODE (XEXP (op, 0)) == PLUS)
1271     base = XEXP (XEXP (op, 0), 0);
1272   else
1273     {
1274       if (! memory_address_p (mode, op))
1275         return 0;
1276       base = (GET_CODE (op) == PLUS ? XEXP (op, 0) : op);
1277     }
1278
1279   return (GET_CODE (base) == REG && REGNO_POINTER_ALIGN (REGNO (base)) < 32);
1280 }
1281
1282 /* Return 1 if OP is either a register or an unaligned memory location.  */
1283
1284 int
1285 reg_or_unaligned_mem_operand (rtx op, enum machine_mode mode)
1286 {
1287   return register_operand (op, mode) || unaligned_memory_operand (op, mode);
1288 }
1289
1290 /* Return 1 if OP is any memory location.  During reload a pseudo matches.  */
1291
1292 int
1293 any_memory_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1294 {
1295   return (GET_CODE (op) == MEM
1296           || (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == REG)
1297           || (reload_in_progress && GET_CODE (op) == REG
1298               && REGNO (op) >= FIRST_PSEUDO_REGISTER)
1299           || (reload_in_progress && GET_CODE (op) == SUBREG
1300               && GET_CODE (SUBREG_REG (op)) == REG
1301               && REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER));
1302 }
1303
1304 /* Returns 1 if OP is not an eliminable register.
1305
1306    This exists to cure a pathological abort in the s8addq (et al) patterns,
1307
1308         long foo () { long t; bar(); return (long) &t * 26107; }
1309
1310    which run afoul of a hack in reload to cure a (presumably) similar
1311    problem with lea-type instructions on other targets.  But there is
1312    one of us and many of them, so work around the problem by selectively
1313    preventing combine from making the optimization.  */
1314
1315 int
1316 reg_not_elim_operand (rtx op, enum machine_mode mode)
1317 {
1318   rtx inner = op;
1319   if (GET_CODE (op) == SUBREG)
1320     inner = SUBREG_REG (op);
1321   if (inner == frame_pointer_rtx || inner == arg_pointer_rtx)
1322     return 0;
1323
1324   return register_operand (op, mode);
1325 }
1326
1327 /* Return 1 is OP is a memory location that is not a reference (using
1328    an AND) to an unaligned location.  Take into account what reload
1329    will do.  */
1330
1331 int
1332 normal_memory_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
1333 {
1334   if (reload_in_progress)
1335     {
1336       rtx tmp = op;
1337       if (GET_CODE (tmp) == SUBREG)
1338         tmp = SUBREG_REG (tmp);
1339       if (GET_CODE (tmp) == REG
1340           && REGNO (tmp) >= FIRST_PSEUDO_REGISTER)
1341         {
1342           op = reg_equiv_memory_loc[REGNO (tmp)];
1343
1344           /* This may not have been assigned an equivalent address if it will
1345              be eliminated.  In that case, it doesn't matter what we do.  */
1346           if (op == 0)
1347             return 1;
1348         }
1349     }
1350
1351   return GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) != AND;
1352 }
1353
1354 /* Accept a register, but not a subreg of any kind.  This allows us to
1355    avoid pathological cases in reload wrt data movement common in
1356    int->fp conversion.  */
1357
1358 int
1359 reg_no_subreg_operand (rtx op, enum machine_mode mode)
1360 {
1361   if (GET_CODE (op) != REG)
1362     return 0;
1363   return register_operand (op, mode);
1364 }
1365
1366 /* Recognize an addition operation that includes a constant.  Used to
1367    convince reload to canonize (plus (plus reg c1) c2) during register
1368    elimination.  */
1369
1370 int
1371 addition_operation (rtx op, enum machine_mode mode)
1372 {
1373   if (GET_MODE (op) != mode && mode != VOIDmode)
1374     return 0;
1375   if (GET_CODE (op) == PLUS
1376       && register_operand (XEXP (op, 0), mode)
1377       && GET_CODE (XEXP (op, 1)) == CONST_INT
1378       && CONST_OK_FOR_LETTER_P (INTVAL (XEXP (op, 1)), 'K'))
1379     return 1;
1380   return 0;
1381 }
1382
1383 /* Implements CONST_OK_FOR_LETTER_P.  Return true if the value matches
1384    the range defined for C in [I-P].  */
1385
1386 bool
1387 alpha_const_ok_for_letter_p (HOST_WIDE_INT value, int c)
1388 {
1389   switch (c)
1390     {
1391     case 'I':
1392       /* An unsigned 8 bit constant.  */
1393       return (unsigned HOST_WIDE_INT) value < 0x100;
1394     case 'J':
1395       /* The constant zero.  */
1396       return value == 0;
1397     case 'K':
1398       /* A signed 16 bit constant.  */
1399       return (unsigned HOST_WIDE_INT) (value + 0x8000) < 0x10000;
1400     case 'L':
1401       /* A shifted signed 16 bit constant appropriate for LDAH.  */
1402       return ((value & 0xffff) == 0
1403               && ((value) >> 31 == -1 || value >> 31 == 0));
1404     case 'M':
1405       /* A constant that can be AND'ed with using a ZAP insn.  */
1406       return zap_mask (value);
1407     case 'N':
1408       /* A complemented unsigned 8 bit constant.  */
1409       return (unsigned HOST_WIDE_INT) (~ value) < 0x100;
1410     case 'O':
1411       /* A negated unsigned 8 bit constant.  */
1412       return (unsigned HOST_WIDE_INT) (- value) < 0x100;
1413     case 'P':
1414       /* The constant 1, 2 or 3.  */
1415       return value == 1 || value == 2 || value == 3;
1416
1417     default:
1418       return false;
1419     }
1420 }
1421
1422 /* Implements CONST_DOUBLE_OK_FOR_LETTER_P.  Return true if VALUE
1423    matches for C in [GH].  */
1424
1425 bool
1426 alpha_const_double_ok_for_letter_p (rtx value, int c)
1427 {
1428   switch (c)
1429     {
1430     case 'G':
1431       /* The floating point zero constant.  */
1432       return (GET_MODE_CLASS (GET_MODE (value)) == MODE_FLOAT
1433               && value == CONST0_RTX (GET_MODE (value)));
1434
1435     case 'H':
1436       /* A valid operand of a ZAP insn.  */
1437       return (GET_MODE (value) == VOIDmode
1438               && zap_mask (CONST_DOUBLE_LOW (value))
1439               && zap_mask (CONST_DOUBLE_HIGH (value)));
1440
1441     default:
1442       return false;
1443     }
1444 }
1445
1446 /* Implements CONST_DOUBLE_OK_FOR_LETTER_P.  Return true if VALUE
1447    matches for C.  */
1448
1449 bool
1450 alpha_extra_constraint (rtx value, int c)
1451 {
1452   switch (c)
1453     {
1454     case 'Q':
1455       return normal_memory_operand (value, VOIDmode);
1456     case 'R':
1457       return direct_call_operand (value, Pmode);
1458     case 'S':
1459       return (GET_CODE (value) == CONST_INT
1460               && (unsigned HOST_WIDE_INT) INTVAL (value) < 64);
1461     case 'T':
1462       return GET_CODE (value) == HIGH;
1463     case 'U':
1464       return TARGET_ABI_UNICOSMK && symbolic_operand (value, VOIDmode);
1465     case 'W':
1466       return (GET_CODE (value) == CONST_VECTOR
1467               && value == CONST0_RTX (GET_MODE (value)));
1468     default:
1469       return false;
1470     }
1471 }
1472
1473 /* Return 1 if this function can directly return via $26.  */
1474
1475 int
1476 direct_return (void)
1477 {
1478   return (! TARGET_ABI_OPEN_VMS && ! TARGET_ABI_UNICOSMK
1479           && reload_completed
1480           && alpha_sa_size () == 0
1481           && get_frame_size () == 0
1482           && current_function_outgoing_args_size == 0
1483           && current_function_pretend_args_size == 0);
1484 }
1485
1486 /* Return the ADDR_VEC associated with a tablejump insn.  */
1487
1488 rtx
1489 alpha_tablejump_addr_vec (rtx insn)
1490 {
1491   rtx tmp;
1492
1493   tmp = JUMP_LABEL (insn);
1494   if (!tmp)
1495     return NULL_RTX;
1496   tmp = NEXT_INSN (tmp);
1497   if (!tmp)
1498     return NULL_RTX;
1499   if (GET_CODE (tmp) == JUMP_INSN
1500       && GET_CODE (PATTERN (tmp)) == ADDR_DIFF_VEC)
1501     return PATTERN (tmp);
1502   return NULL_RTX;
1503 }
1504
1505 /* Return the label of the predicted edge, or CONST0_RTX if we don't know.  */
1506
1507 rtx
1508 alpha_tablejump_best_label (rtx insn)
1509 {
1510   rtx jump_table = alpha_tablejump_addr_vec (insn);
1511   rtx best_label = NULL_RTX;
1512
1513   /* ??? Once the CFG doesn't keep getting completely rebuilt, look
1514      there for edge frequency counts from profile data.  */
1515
1516   if (jump_table)
1517     {
1518       int n_labels = XVECLEN (jump_table, 1);
1519       int best_count = -1;
1520       int i, j;
1521
1522       for (i = 0; i < n_labels; i++)
1523         {
1524           int count = 1;
1525
1526           for (j = i + 1; j < n_labels; j++)
1527             if (XEXP (XVECEXP (jump_table, 1, i), 0)
1528                 == XEXP (XVECEXP (jump_table, 1, j), 0))
1529               count++;
1530
1531           if (count > best_count)
1532             best_count = count, best_label = XVECEXP (jump_table, 1, i);
1533         }
1534     }
1535
1536   return best_label ? best_label : const0_rtx;
1537 }
1538
1539 /* Return the TLS model to use for SYMBOL.  */
1540
1541 static enum tls_model
1542 tls_symbolic_operand_type (rtx symbol)
1543 {
1544   enum tls_model model;
1545
1546   if (GET_CODE (symbol) != SYMBOL_REF)
1547     return 0;
1548   model = SYMBOL_REF_TLS_MODEL (symbol);
1549
1550   /* Local-exec with a 64-bit size is the same code as initial-exec.  */
1551   if (model == TLS_MODEL_LOCAL_EXEC && alpha_tls_size == 64)
1552     model = TLS_MODEL_INITIAL_EXEC;
1553
1554   return model;
1555 }
1556 \f
1557 /* Return true if the function DECL will share the same GP as any
1558    function in the current unit of translation.  */
1559
1560 static bool
1561 decl_has_samegp (tree decl)
1562 {
1563   /* Functions that are not local can be overridden, and thus may
1564      not share the same gp.  */
1565   if (!(*targetm.binds_local_p) (decl))
1566     return false;
1567
1568   /* If -msmall-data is in effect, assume that there is only one GP
1569      for the module, and so any local symbol has this property.  We
1570      need explicit relocations to be able to enforce this for symbols
1571      not defined in this unit of translation, however.  */
1572   if (TARGET_EXPLICIT_RELOCS && TARGET_SMALL_DATA)
1573     return true;
1574
1575   /* Functions that are not external are defined in this UoT.  */
1576   /* ??? Irritatingly, static functions not yet emitted are still
1577      marked "external".  Apply this to non-static functions only.  */
1578   return !TREE_PUBLIC (decl) || !DECL_EXTERNAL (decl);
1579 }
1580
1581 /* Return true if EXP should be placed in the small data section.  */
1582
1583 static bool
1584 alpha_in_small_data_p (tree exp)
1585 {
1586   /* We want to merge strings, so we never consider them small data.  */
1587   if (TREE_CODE (exp) == STRING_CST)
1588     return false;
1589
1590   if (TREE_CODE (exp) == VAR_DECL && DECL_SECTION_NAME (exp))
1591     {
1592       const char *section = TREE_STRING_POINTER (DECL_SECTION_NAME (exp));
1593       if (strcmp (section, ".sdata") == 0
1594           || strcmp (section, ".sbss") == 0)
1595         return true;
1596     }
1597   else
1598     {
1599       HOST_WIDE_INT size = int_size_in_bytes (TREE_TYPE (exp));
1600
1601       /* If this is an incomplete type with size 0, then we can't put it
1602          in sdata because it might be too big when completed.  */
1603       if (size > 0 && (unsigned HOST_WIDE_INT) size <= g_switch_value)
1604         return true;
1605     }
1606
1607   return false;
1608 }
1609
1610 #if TARGET_ABI_OPEN_VMS
1611 static bool
1612 alpha_linkage_symbol_p (const char *symname)
1613 {
1614   int symlen = strlen (symname);
1615
1616   if (symlen > 4)
1617     return strcmp (&symname [symlen - 4], "..lk") == 0;
1618
1619   return false;
1620 }
1621
1622 #define LINKAGE_SYMBOL_REF_P(X) \
1623   ((GET_CODE (X) == SYMBOL_REF   \
1624     && alpha_linkage_symbol_p (XSTR (X, 0))) \
1625    || (GET_CODE (X) == CONST                 \
1626        && GET_CODE (XEXP (X, 0)) == PLUS     \
1627        && GET_CODE (XEXP (XEXP (X, 0), 0)) == SYMBOL_REF \
1628        && alpha_linkage_symbol_p (XSTR (XEXP (XEXP (X, 0), 0), 0))))
1629 #endif
1630
1631 /* legitimate_address_p recognizes an RTL expression that is a valid
1632    memory address for an instruction.  The MODE argument is the
1633    machine mode for the MEM expression that wants to use this address.
1634
1635    For Alpha, we have either a constant address or the sum of a
1636    register and a constant address, or just a register.  For DImode,
1637    any of those forms can be surrounded with an AND that clear the
1638    low-order three bits; this is an "unaligned" access.  */
1639
1640 bool
1641 alpha_legitimate_address_p (enum machine_mode mode, rtx x, int strict)
1642 {
1643   /* If this is an ldq_u type address, discard the outer AND.  */
1644   if (mode == DImode
1645       && GET_CODE (x) == AND
1646       && GET_CODE (XEXP (x, 1)) == CONST_INT
1647       && INTVAL (XEXP (x, 1)) == -8)
1648     x = XEXP (x, 0);
1649
1650   /* Discard non-paradoxical subregs.  */
1651   if (GET_CODE (x) == SUBREG
1652       && (GET_MODE_SIZE (GET_MODE (x))
1653           < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
1654     x = SUBREG_REG (x);
1655
1656   /* Unadorned general registers are valid.  */
1657   if (REG_P (x)
1658       && (strict
1659           ? STRICT_REG_OK_FOR_BASE_P (x)
1660           : NONSTRICT_REG_OK_FOR_BASE_P (x)))
1661     return true;
1662
1663   /* Constant addresses (i.e. +/- 32k) are valid.  */
1664   if (CONSTANT_ADDRESS_P (x))
1665     return true;
1666
1667 #if TARGET_ABI_OPEN_VMS
1668   if (LINKAGE_SYMBOL_REF_P (x))
1669     return true;
1670 #endif
1671
1672   /* Register plus a small constant offset is valid.  */
1673   if (GET_CODE (x) == PLUS)
1674     {
1675       rtx ofs = XEXP (x, 1);
1676       x = XEXP (x, 0);
1677
1678       /* Discard non-paradoxical subregs.  */
1679       if (GET_CODE (x) == SUBREG
1680           && (GET_MODE_SIZE (GET_MODE (x))
1681               < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
1682         x = SUBREG_REG (x);
1683
1684       if (REG_P (x))
1685         {
1686           if (! strict
1687               && NONSTRICT_REG_OK_FP_BASE_P (x)
1688               && GET_CODE (ofs) == CONST_INT)
1689             return true;
1690           if ((strict
1691                ? STRICT_REG_OK_FOR_BASE_P (x)
1692                : NONSTRICT_REG_OK_FOR_BASE_P (x))
1693               && CONSTANT_ADDRESS_P (ofs))
1694             return true;
1695         }
1696       else if (GET_CODE (x) == ADDRESSOF
1697                && GET_CODE (ofs) == CONST_INT)
1698         return true;
1699     }
1700
1701   /* If we're managing explicit relocations, LO_SUM is valid, as
1702      are small data symbols.  */
1703   else if (TARGET_EXPLICIT_RELOCS)
1704     {
1705       if (small_symbolic_operand (x, Pmode))
1706         return true;
1707
1708       if (GET_CODE (x) == LO_SUM)
1709         {
1710           rtx ofs = XEXP (x, 1);
1711           x = XEXP (x, 0);
1712
1713           /* Discard non-paradoxical subregs.  */
1714           if (GET_CODE (x) == SUBREG
1715               && (GET_MODE_SIZE (GET_MODE (x))
1716                   < GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
1717             x = SUBREG_REG (x);
1718
1719           /* Must have a valid base register.  */
1720           if (! (REG_P (x)
1721                  && (strict
1722                      ? STRICT_REG_OK_FOR_BASE_P (x)
1723                      : NONSTRICT_REG_OK_FOR_BASE_P (x))))
1724             return false;
1725
1726           /* The symbol must be local.  */
1727           if (local_symbolic_operand (ofs, Pmode)
1728               || dtp32_symbolic_operand (ofs, Pmode)
1729               || tp32_symbolic_operand (ofs, Pmode))
1730             return true;
1731         }
1732     }
1733
1734   return false;
1735 }
1736
1737 /* Build the SYMBOL_REF for __tls_get_addr.  */
1738
1739 static GTY(()) rtx tls_get_addr_libfunc;
1740
1741 static rtx
1742 get_tls_get_addr (void)
1743 {
1744   if (!tls_get_addr_libfunc)
1745     tls_get_addr_libfunc = init_one_libfunc ("__tls_get_addr");
1746   return tls_get_addr_libfunc;
1747 }
1748
1749 /* Try machine-dependent ways of modifying an illegitimate address
1750    to be legitimate.  If we find one, return the new, valid address.  */
1751
1752 rtx
1753 alpha_legitimize_address (rtx x, rtx scratch,
1754                           enum machine_mode mode ATTRIBUTE_UNUSED)
1755 {
1756   HOST_WIDE_INT addend;
1757
1758   /* If the address is (plus reg const_int) and the CONST_INT is not a
1759      valid offset, compute the high part of the constant and add it to
1760      the register.  Then our address is (plus temp low-part-const).  */
1761   if (GET_CODE (x) == PLUS
1762       && GET_CODE (XEXP (x, 0)) == REG
1763       && GET_CODE (XEXP (x, 1)) == CONST_INT
1764       && ! CONSTANT_ADDRESS_P (XEXP (x, 1)))
1765     {
1766       addend = INTVAL (XEXP (x, 1));
1767       x = XEXP (x, 0);
1768       goto split_addend;
1769     }
1770
1771   /* If the address is (const (plus FOO const_int)), find the low-order
1772      part of the CONST_INT.  Then load FOO plus any high-order part of the
1773      CONST_INT into a register.  Our address is (plus reg low-part-const).
1774      This is done to reduce the number of GOT entries.  */
1775   if (!no_new_pseudos
1776       && GET_CODE (x) == CONST
1777       && GET_CODE (XEXP (x, 0)) == PLUS
1778       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT)
1779     {
1780       addend = INTVAL (XEXP (XEXP (x, 0), 1));
1781       x = force_reg (Pmode, XEXP (XEXP (x, 0), 0));
1782       goto split_addend;
1783     }
1784
1785   /* If we have a (plus reg const), emit the load as in (2), then add
1786      the two registers, and finally generate (plus reg low-part-const) as
1787      our address.  */
1788   if (!no_new_pseudos
1789       && GET_CODE (x) == PLUS
1790       && GET_CODE (XEXP (x, 0)) == REG
1791       && GET_CODE (XEXP (x, 1)) == CONST
1792       && GET_CODE (XEXP (XEXP (x, 1), 0)) == PLUS
1793       && GET_CODE (XEXP (XEXP (XEXP (x, 1), 0), 1)) == CONST_INT)
1794     {
1795       addend = INTVAL (XEXP (XEXP (XEXP (x, 1), 0), 1));
1796       x = expand_simple_binop (Pmode, PLUS, XEXP (x, 0),
1797                                XEXP (XEXP (XEXP (x, 1), 0), 0),
1798                                NULL_RTX, 1, OPTAB_LIB_WIDEN);
1799       goto split_addend;
1800     }
1801
1802   /* If this is a local symbol, split the address into HIGH/LO_SUM parts.  */
1803   if (TARGET_EXPLICIT_RELOCS && symbolic_operand (x, Pmode))
1804     {
1805       rtx r0, r16, eqv, tga, tp, insn, dest, seq;
1806
1807       switch (tls_symbolic_operand_type (x))
1808         {
1809         case TLS_MODEL_GLOBAL_DYNAMIC:
1810           start_sequence ();
1811
1812           r0 = gen_rtx_REG (Pmode, 0);
1813           r16 = gen_rtx_REG (Pmode, 16);
1814           tga = get_tls_get_addr ();
1815           dest = gen_reg_rtx (Pmode);
1816           seq = GEN_INT (alpha_next_sequence_number++);
1817
1818           emit_insn (gen_movdi_er_tlsgd (r16, pic_offset_table_rtx, x, seq));
1819           insn = gen_call_value_osf_tlsgd (r0, tga, seq);
1820           insn = emit_call_insn (insn);
1821           CONST_OR_PURE_CALL_P (insn) = 1;
1822           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r16);
1823
1824           insn = get_insns ();
1825           end_sequence ();
1826
1827           emit_libcall_block (insn, dest, r0, x);
1828           return dest;
1829
1830         case TLS_MODEL_LOCAL_DYNAMIC:
1831           start_sequence ();
1832
1833           r0 = gen_rtx_REG (Pmode, 0);
1834           r16 = gen_rtx_REG (Pmode, 16);
1835           tga = get_tls_get_addr ();
1836           scratch = gen_reg_rtx (Pmode);
1837           seq = GEN_INT (alpha_next_sequence_number++);
1838
1839           emit_insn (gen_movdi_er_tlsldm (r16, pic_offset_table_rtx, seq));
1840           insn = gen_call_value_osf_tlsldm (r0, tga, seq);
1841           insn = emit_call_insn (insn);
1842           CONST_OR_PURE_CALL_P (insn) = 1;
1843           use_reg (&CALL_INSN_FUNCTION_USAGE (insn), r16);
1844
1845           insn = get_insns ();
1846           end_sequence ();
1847
1848           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
1849                                 UNSPEC_TLSLDM_CALL);
1850           emit_libcall_block (insn, scratch, r0, eqv);
1851
1852           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_DTPREL);
1853           eqv = gen_rtx_CONST (Pmode, eqv);
1854
1855           if (alpha_tls_size == 64)
1856             {
1857               dest = gen_reg_rtx (Pmode);
1858               emit_insn (gen_rtx_SET (VOIDmode, dest, eqv));
1859               emit_insn (gen_adddi3 (dest, dest, scratch));
1860               return dest;
1861             }
1862           if (alpha_tls_size == 32)
1863             {
1864               insn = gen_rtx_HIGH (Pmode, eqv);
1865               insn = gen_rtx_PLUS (Pmode, scratch, insn);
1866               scratch = gen_reg_rtx (Pmode);
1867               emit_insn (gen_rtx_SET (VOIDmode, scratch, insn));
1868             }
1869           return gen_rtx_LO_SUM (Pmode, scratch, eqv);
1870
1871         case TLS_MODEL_INITIAL_EXEC:
1872           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_TPREL);
1873           eqv = gen_rtx_CONST (Pmode, eqv);
1874           tp = gen_reg_rtx (Pmode);
1875           scratch = gen_reg_rtx (Pmode);
1876           dest = gen_reg_rtx (Pmode);
1877
1878           emit_insn (gen_load_tp (tp));
1879           emit_insn (gen_rtx_SET (VOIDmode, scratch, eqv));
1880           emit_insn (gen_adddi3 (dest, tp, scratch));
1881           return dest;
1882
1883         case TLS_MODEL_LOCAL_EXEC:
1884           eqv = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, x), UNSPEC_TPREL);
1885           eqv = gen_rtx_CONST (Pmode, eqv);
1886           tp = gen_reg_rtx (Pmode);
1887
1888           emit_insn (gen_load_tp (tp));
1889           if (alpha_tls_size == 32)
1890             {
1891               insn = gen_rtx_HIGH (Pmode, eqv);
1892               insn = gen_rtx_PLUS (Pmode, tp, insn);
1893               tp = gen_reg_rtx (Pmode);
1894               emit_insn (gen_rtx_SET (VOIDmode, tp, insn));
1895             }
1896           return gen_rtx_LO_SUM (Pmode, tp, eqv);
1897         }
1898
1899       if (local_symbolic_operand (x, Pmode))
1900         {
1901           if (small_symbolic_operand (x, Pmode))
1902             return x;
1903           else
1904             {
1905               if (!no_new_pseudos)
1906                 scratch = gen_reg_rtx (Pmode);
1907               emit_insn (gen_rtx_SET (VOIDmode, scratch,
1908                                       gen_rtx_HIGH (Pmode, x)));
1909               return gen_rtx_LO_SUM (Pmode, scratch, x);
1910             }
1911         }
1912     }
1913
1914   return NULL;
1915
1916  split_addend:
1917   {
1918     HOST_WIDE_INT low, high;
1919
1920     low = ((addend & 0xffff) ^ 0x8000) - 0x8000;
1921     addend -= low;
1922     high = ((addend & 0xffffffff) ^ 0x80000000) - 0x80000000;
1923     addend -= high;
1924
1925     if (addend)
1926       x = expand_simple_binop (Pmode, PLUS, x, GEN_INT (addend),
1927                                (no_new_pseudos ? scratch : NULL_RTX),
1928                                1, OPTAB_LIB_WIDEN);
1929     if (high)
1930       x = expand_simple_binop (Pmode, PLUS, x, GEN_INT (high),
1931                                (no_new_pseudos ? scratch : NULL_RTX),
1932                                1, OPTAB_LIB_WIDEN);
1933
1934     return plus_constant (x, low);
1935   }
1936 }
1937
1938 /* We do not allow indirect calls to be optimized into sibling calls, nor
1939    can we allow a call to a function with a different GP to be optimized
1940    into a sibcall.  */
1941
1942 static bool
1943 alpha_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
1944 {
1945   /* Can't do indirect tail calls, since we don't know if the target
1946      uses the same GP.  */
1947   if (!decl)
1948     return false;
1949
1950   /* Otherwise, we can make a tail call if the target function shares
1951      the same GP.  */
1952   return decl_has_samegp (decl);
1953 }
1954
1955 /* For TARGET_EXPLICIT_RELOCS, we don't obfuscate a SYMBOL_REF to a
1956    small symbolic operand until after reload.  At which point we need
1957    to replace (mem (symbol_ref)) with (mem (lo_sum $29 symbol_ref))
1958    so that sched2 has the proper dependency information.  */
1959
1960 static int
1961 some_small_symbolic_operand_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
1962 {
1963   rtx x = *px;
1964
1965   /* Don't re-split.  */
1966   if (GET_CODE (x) == LO_SUM)
1967     return -1;
1968
1969   return small_symbolic_operand (x, Pmode) != 0;
1970 }
1971
1972 int
1973 some_small_symbolic_operand (rtx x, enum machine_mode mode ATTRIBUTE_UNUSED)
1974 {
1975   return for_each_rtx (&x, some_small_symbolic_operand_1, NULL);
1976 }
1977
1978 static int
1979 split_small_symbolic_operand_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
1980 {
1981   rtx x = *px;
1982
1983   /* Don't re-split.  */
1984   if (GET_CODE (x) == LO_SUM)
1985     return -1;
1986
1987   if (small_symbolic_operand (x, Pmode))
1988     {
1989       x = gen_rtx_LO_SUM (Pmode, pic_offset_table_rtx, x);
1990       *px = x;
1991       return -1;
1992     }
1993
1994   return 0;
1995 }
1996
1997 rtx
1998 split_small_symbolic_operand (rtx x)
1999 {
2000   x = copy_insn (x);
2001   for_each_rtx (&x, split_small_symbolic_operand_1, NULL);
2002   return x;
2003 }
2004
2005 /* Indicate that INSN cannot be duplicated.  This is true for any insn
2006    that we've marked with gpdisp relocs, since those have to stay in
2007    1-1 correspondence with one another.
2008
2009    Technically we could copy them if we could set up a mapping from one
2010    sequence number to another, across the set of insns to be duplicated.
2011    This seems overly complicated and error-prone since interblock motion
2012    from sched-ebb could move one of the pair of insns to a different block.  */
2013
2014 static bool
2015 alpha_cannot_copy_insn_p (rtx insn)
2016 {
2017   rtx pat;
2018
2019   if (!reload_completed || !TARGET_EXPLICIT_RELOCS)
2020     return false;
2021
2022   if (GET_CODE (insn) != INSN)
2023     return false;
2024   if (asm_noperands (insn) >= 0)
2025     return false;
2026
2027   pat = PATTERN (insn);
2028   if (GET_CODE (pat) != SET)
2029     return false;
2030   pat = SET_SRC (pat);
2031   if (GET_CODE (pat) == UNSPEC_VOLATILE)
2032     {
2033       if (XINT (pat, 1) == UNSPECV_LDGP1
2034           || XINT (pat, 1) == UNSPECV_PLDGP2)
2035         return true;
2036     }
2037   else if (GET_CODE (pat) == UNSPEC)
2038     {
2039       if (XINT (pat, 1) == UNSPEC_LDGP2)
2040         return true;
2041     }
2042
2043   return false;
2044 }
2045
2046
2047 /* Try a machine-dependent way of reloading an illegitimate address
2048    operand.  If we find one, push the reload and return the new rtx.  */
2049
2050 rtx
2051 alpha_legitimize_reload_address (rtx x,
2052                                  enum machine_mode mode ATTRIBUTE_UNUSED,
2053                                  int opnum, int type,
2054                                  int ind_levels ATTRIBUTE_UNUSED)
2055 {
2056   /* We must recognize output that we have already generated ourselves.  */
2057   if (GET_CODE (x) == PLUS
2058       && GET_CODE (XEXP (x, 0)) == PLUS
2059       && GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
2060       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
2061       && GET_CODE (XEXP (x, 1)) == CONST_INT)
2062     {
2063       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
2064                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
2065                    opnum, type);
2066       return x;
2067     }
2068
2069   /* We wish to handle large displacements off a base register by
2070      splitting the addend across an ldah and the mem insn.  This
2071      cuts number of extra insns needed from 3 to 1.  */
2072   if (GET_CODE (x) == PLUS
2073       && GET_CODE (XEXP (x, 0)) == REG
2074       && REGNO (XEXP (x, 0)) < FIRST_PSEUDO_REGISTER
2075       && REGNO_OK_FOR_BASE_P (REGNO (XEXP (x, 0)))
2076       && GET_CODE (XEXP (x, 1)) == CONST_INT)
2077     {
2078       HOST_WIDE_INT val = INTVAL (XEXP (x, 1));
2079       HOST_WIDE_INT low = ((val & 0xffff) ^ 0x8000) - 0x8000;
2080       HOST_WIDE_INT high
2081         = (((val - low) & 0xffffffff) ^ 0x80000000) - 0x80000000;
2082
2083       /* Check for 32-bit overflow.  */
2084       if (high + low != val)
2085         return NULL_RTX;
2086
2087       /* Reload the high part into a base reg; leave the low part
2088          in the mem directly.  */
2089       x = gen_rtx_PLUS (GET_MODE (x),
2090                         gen_rtx_PLUS (GET_MODE (x), XEXP (x, 0),
2091                                       GEN_INT (high)),
2092                         GEN_INT (low));
2093
2094       push_reload (XEXP (x, 0), NULL_RTX, &XEXP (x, 0), NULL,
2095                    BASE_REG_CLASS, GET_MODE (x), VOIDmode, 0, 0,
2096                    opnum, type);
2097       return x;
2098     }
2099
2100   return NULL_RTX;
2101 }
2102 \f
2103 /* Compute a (partial) cost for rtx X.  Return true if the complete
2104    cost has been computed, and false if subexpressions should be
2105    scanned.  In either case, *TOTAL contains the cost result.  */
2106
2107 static bool
2108 alpha_rtx_costs (rtx x, int code, int outer_code, int *total)
2109 {
2110   enum machine_mode mode = GET_MODE (x);
2111   bool float_mode_p = FLOAT_MODE_P (mode);
2112
2113   switch (code)
2114     {
2115       /* If this is an 8-bit constant, return zero since it can be used
2116          nearly anywhere with no cost.  If it is a valid operand for an
2117          ADD or AND, likewise return 0 if we know it will be used in that
2118          context.  Otherwise, return 2 since it might be used there later.
2119          All other constants take at least two insns.  */
2120     case CONST_INT:
2121       if (INTVAL (x) >= 0 && INTVAL (x) < 256)
2122         {
2123           *total = 0;
2124           return true;
2125         }
2126       /* FALLTHRU */
2127
2128     case CONST_DOUBLE:
2129       if (x == CONST0_RTX (mode))
2130         *total = 0;
2131       else if ((outer_code == PLUS && add_operand (x, VOIDmode))
2132                || (outer_code == AND && and_operand (x, VOIDmode)))
2133         *total = 0;
2134       else if (add_operand (x, VOIDmode) || and_operand (x, VOIDmode))
2135         *total = 2;
2136       else
2137         *total = COSTS_N_INSNS (2);
2138       return true;
2139
2140     case CONST:
2141     case SYMBOL_REF:
2142     case LABEL_REF:
2143       if (TARGET_EXPLICIT_RELOCS && small_symbolic_operand (x, VOIDmode))
2144         *total = COSTS_N_INSNS (outer_code != MEM);
2145       else if (TARGET_EXPLICIT_RELOCS && local_symbolic_operand (x, VOIDmode))
2146         *total = COSTS_N_INSNS (1 + (outer_code != MEM));
2147       else if (tls_symbolic_operand_type (x))
2148         /* Estimate of cost for call_pal rduniq.  */
2149         *total = COSTS_N_INSNS (15);
2150       else
2151         /* Otherwise we do a load from the GOT.  */
2152         *total = COSTS_N_INSNS (alpha_memory_latency);
2153       return true;
2154
2155     case PLUS:
2156     case MINUS:
2157       if (float_mode_p)
2158         *total = alpha_rtx_cost_data[alpha_cpu].fp_add;
2159       else if (GET_CODE (XEXP (x, 0)) == MULT
2160                && const48_operand (XEXP (XEXP (x, 0), 1), VOIDmode))
2161         {
2162           *total = (rtx_cost (XEXP (XEXP (x, 0), 0), outer_code)
2163                     + rtx_cost (XEXP (x, 1), outer_code) + 2);
2164           return true;
2165         }
2166       return false;
2167
2168     case MULT:
2169       if (float_mode_p)
2170         *total = alpha_rtx_cost_data[alpha_cpu].fp_mult;
2171       else if (mode == DImode)
2172         *total = alpha_rtx_cost_data[alpha_cpu].int_mult_di;
2173       else
2174         *total = alpha_rtx_cost_data[alpha_cpu].int_mult_si;
2175       return false;
2176
2177     case ASHIFT:
2178       if (GET_CODE (XEXP (x, 1)) == CONST_INT
2179           && INTVAL (XEXP (x, 1)) <= 3)
2180         {
2181           *total = COSTS_N_INSNS (1);
2182           return false;
2183         }
2184       /* FALLTHRU */
2185
2186     case ASHIFTRT:
2187     case LSHIFTRT:
2188       *total = alpha_rtx_cost_data[alpha_cpu].int_shift;
2189       return false;
2190
2191     case IF_THEN_ELSE:
2192       if (float_mode_p)
2193         *total = alpha_rtx_cost_data[alpha_cpu].fp_add;
2194       else
2195         *total = alpha_rtx_cost_data[alpha_cpu].int_cmov;
2196       return false;
2197
2198     case DIV:
2199     case UDIV:
2200     case MOD:
2201     case UMOD:
2202       if (!float_mode_p)
2203         *total = COSTS_N_INSNS (70);    /* ??? */
2204       else if (mode == SFmode)
2205         *total = alpha_rtx_cost_data[alpha_cpu].fp_div_sf;
2206       else
2207         *total = alpha_rtx_cost_data[alpha_cpu].fp_div_df;
2208       return false;
2209
2210     case MEM:
2211       *total = COSTS_N_INSNS (alpha_memory_latency);
2212       return true;
2213
2214     case NEG:
2215       if (! float_mode_p)
2216         {
2217           *total = COSTS_N_INSNS (1);
2218           return false;
2219         }
2220       /* FALLTHRU */
2221
2222     case ABS:
2223       if (! float_mode_p)
2224         {
2225           *total = COSTS_N_INSNS (1) + alpha_rtx_cost_data[alpha_cpu].int_cmov;
2226           return false;
2227         }
2228       /* FALLTHRU */
2229
2230     case FLOAT:
2231     case UNSIGNED_FLOAT:
2232     case FIX:
2233     case UNSIGNED_FIX:
2234     case FLOAT_EXTEND:
2235     case FLOAT_TRUNCATE:
2236       *total = alpha_rtx_cost_data[alpha_cpu].fp_add;
2237       return false;
2238
2239     default:
2240       return false;
2241     }
2242 }
2243 \f
2244 /* REF is an alignable memory location.  Place an aligned SImode
2245    reference into *PALIGNED_MEM and the number of bits to shift into
2246    *PBITNUM.  SCRATCH is a free register for use in reloading out
2247    of range stack slots.  */
2248
2249 void
2250 get_aligned_mem (rtx ref, rtx *paligned_mem, rtx *pbitnum)
2251 {
2252   rtx base;
2253   HOST_WIDE_INT offset = 0;
2254
2255   if (GET_CODE (ref) != MEM)
2256     abort ();
2257
2258   if (reload_in_progress
2259       && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
2260     {
2261       base = find_replacement (&XEXP (ref, 0));
2262
2263       if (! memory_address_p (GET_MODE (ref), base))
2264         abort ();
2265     }
2266   else
2267     {
2268       base = XEXP (ref, 0);
2269     }
2270
2271   if (GET_CODE (base) == PLUS)
2272     offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
2273
2274   *paligned_mem
2275     = widen_memory_access (ref, SImode, (offset & ~3) - offset);
2276
2277   if (WORDS_BIG_ENDIAN)
2278     *pbitnum = GEN_INT (32 - (GET_MODE_BITSIZE (GET_MODE (ref))
2279                               + (offset & 3) * 8));
2280   else
2281     *pbitnum = GEN_INT ((offset & 3) * 8);
2282 }
2283
2284 /* Similar, but just get the address.  Handle the two reload cases.
2285    Add EXTRA_OFFSET to the address we return.  */
2286
2287 rtx
2288 get_unaligned_address (rtx ref, int extra_offset)
2289 {
2290   rtx base;
2291   HOST_WIDE_INT offset = 0;
2292
2293   if (GET_CODE (ref) != MEM)
2294     abort ();
2295
2296   if (reload_in_progress
2297       && ! memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
2298     {
2299       base = find_replacement (&XEXP (ref, 0));
2300
2301       if (! memory_address_p (GET_MODE (ref), base))
2302         abort ();
2303     }
2304   else
2305     {
2306       base = XEXP (ref, 0);
2307     }
2308
2309   if (GET_CODE (base) == PLUS)
2310     offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
2311
2312   return plus_constant (base, offset + extra_offset);
2313 }
2314
2315 /* On the Alpha, all (non-symbolic) constants except zero go into
2316    a floating-point register via memory.  Note that we cannot
2317    return anything that is not a subset of CLASS, and that some
2318    symbolic constants cannot be dropped to memory.  */
2319
2320 enum reg_class
2321 alpha_preferred_reload_class(rtx x, enum reg_class class)
2322 {
2323   /* Zero is present in any register class.  */
2324   if (x == CONST0_RTX (GET_MODE (x)))
2325     return class;
2326
2327   /* These sorts of constants we can easily drop to memory.  */
2328   if (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE)
2329     {
2330       if (class == FLOAT_REGS)
2331         return NO_REGS;
2332       if (class == ALL_REGS)
2333         return GENERAL_REGS;
2334       return class;
2335     }
2336
2337   /* All other kinds of constants should not (and in the case of HIGH
2338      cannot) be dropped to memory -- instead we use a GENERAL_REGS
2339      secondary reload.  */
2340   if (CONSTANT_P (x))
2341     return (class == ALL_REGS ? GENERAL_REGS : class);
2342
2343   return class;
2344 }
2345
2346 /* Loading and storing HImode or QImode values to and from memory
2347    usually requires a scratch register.  The exceptions are loading
2348    QImode and HImode from an aligned address to a general register
2349    unless byte instructions are permitted.
2350
2351    We also cannot load an unaligned address or a paradoxical SUBREG
2352    into an FP register.
2353
2354    We also cannot do integral arithmetic into FP regs, as might result
2355    from register elimination into a DImode fp register.  */
2356
2357 enum reg_class
2358 secondary_reload_class (enum reg_class class, enum machine_mode mode,
2359                         rtx x, int in)
2360 {
2361   if ((mode == QImode || mode == HImode) && ! TARGET_BWX)
2362     {
2363       if (GET_CODE (x) == MEM
2364           || (GET_CODE (x) == REG && REGNO (x) >= FIRST_PSEUDO_REGISTER)
2365           || (GET_CODE (x) == SUBREG
2366               && (GET_CODE (SUBREG_REG (x)) == MEM
2367                   || (GET_CODE (SUBREG_REG (x)) == REG
2368                       && REGNO (SUBREG_REG (x)) >= FIRST_PSEUDO_REGISTER))))
2369         {
2370           if (!in || !aligned_memory_operand(x, mode))
2371             return GENERAL_REGS;
2372         }
2373     }
2374
2375   if (class == FLOAT_REGS)
2376     {
2377       if (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == AND)
2378         return GENERAL_REGS;
2379
2380       if (GET_CODE (x) == SUBREG
2381           && (GET_MODE_SIZE (GET_MODE (x))
2382               > GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
2383         return GENERAL_REGS;
2384
2385       if (in && INTEGRAL_MODE_P (mode)
2386           && ! (memory_operand (x, mode) || x == const0_rtx))
2387         return GENERAL_REGS;
2388     }
2389
2390   return NO_REGS;
2391 }
2392 \f
2393 /* Subfunction of the following function.  Update the flags of any MEM
2394    found in part of X.  */
2395
2396 static void
2397 alpha_set_memflags_1 (rtx x, int in_struct_p, int volatile_p, int unchanging_p)
2398 {
2399   int i;
2400
2401   switch (GET_CODE (x))
2402     {
2403     case SEQUENCE:
2404       abort ();
2405
2406     case PARALLEL:
2407       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
2408         alpha_set_memflags_1 (XVECEXP (x, 0, i), in_struct_p, volatile_p,
2409                               unchanging_p);
2410       break;
2411
2412     case INSN:
2413       alpha_set_memflags_1 (PATTERN (x), in_struct_p, volatile_p,
2414                             unchanging_p);
2415       break;
2416
2417     case SET:
2418       alpha_set_memflags_1 (SET_DEST (x), in_struct_p, volatile_p,
2419                             unchanging_p);
2420       alpha_set_memflags_1 (SET_SRC (x), in_struct_p, volatile_p,
2421                             unchanging_p);
2422       break;
2423
2424     case MEM:
2425       MEM_IN_STRUCT_P (x) = in_struct_p;
2426       MEM_VOLATILE_P (x) = volatile_p;
2427       RTX_UNCHANGING_P (x) = unchanging_p;
2428       /* Sadly, we cannot use alias sets because the extra aliasing
2429          produced by the AND interferes.  Given that two-byte quantities
2430          are the only thing we would be able to differentiate anyway,
2431          there does not seem to be any point in convoluting the early
2432          out of the alias check.  */
2433       break;
2434
2435     default:
2436       break;
2437     }
2438 }
2439
2440 /* Given INSN, which is an INSN list or the PATTERN of a single insn
2441    generated to perform a memory operation, look for any MEMs in either
2442    a SET_DEST or a SET_SRC and copy the in-struct, unchanging, and
2443    volatile flags from REF into each of the MEMs found.  If REF is not
2444    a MEM, don't do anything.  */
2445
2446 void
2447 alpha_set_memflags (rtx insn, rtx ref)
2448 {
2449   int in_struct_p, volatile_p, unchanging_p;
2450
2451   if (GET_CODE (ref) != MEM)
2452     return;
2453
2454   in_struct_p = MEM_IN_STRUCT_P (ref);
2455   volatile_p = MEM_VOLATILE_P (ref);
2456   unchanging_p = RTX_UNCHANGING_P (ref);
2457
2458   /* This is only called from alpha.md, after having had something
2459      generated from one of the insn patterns.  So if everything is
2460      zero, the pattern is already up-to-date.  */
2461   if (! in_struct_p && ! volatile_p && ! unchanging_p)
2462     return;
2463
2464   alpha_set_memflags_1 (insn, in_struct_p, volatile_p, unchanging_p);
2465 }
2466 \f
2467 /* Internal routine for alpha_emit_set_const to check for N or below insns.  */
2468
2469 static rtx
2470 alpha_emit_set_const_1 (rtx target, enum machine_mode mode,
2471                         HOST_WIDE_INT c, int n)
2472 {
2473   HOST_WIDE_INT new;
2474   int i, bits;
2475   /* Use a pseudo if highly optimizing and still generating RTL.  */
2476   rtx subtarget
2477     = (flag_expensive_optimizations && !no_new_pseudos ? 0 : target);
2478   rtx temp, insn;
2479
2480   /* If this is a sign-extended 32-bit constant, we can do this in at most
2481      three insns, so do it if we have enough insns left.  We always have
2482      a sign-extended 32-bit constant when compiling on a narrow machine.  */
2483
2484   if (HOST_BITS_PER_WIDE_INT != 64
2485       || c >> 31 == -1 || c >> 31 == 0)
2486     {
2487       HOST_WIDE_INT low = ((c & 0xffff) ^ 0x8000) - 0x8000;
2488       HOST_WIDE_INT tmp1 = c - low;
2489       HOST_WIDE_INT high = (((tmp1 >> 16) & 0xffff) ^ 0x8000) - 0x8000;
2490       HOST_WIDE_INT extra = 0;
2491
2492       /* If HIGH will be interpreted as negative but the constant is
2493          positive, we must adjust it to do two ldha insns.  */
2494
2495       if ((high & 0x8000) != 0 && c >= 0)
2496         {
2497           extra = 0x4000;
2498           tmp1 -= 0x40000000;
2499           high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
2500         }
2501
2502       if (c == low || (low == 0 && extra == 0))
2503         {
2504           /* We used to use copy_to_suggested_reg (GEN_INT (c), target, mode)
2505              but that meant that we can't handle INT_MIN on 32-bit machines
2506              (like NT/Alpha), because we recurse indefinitely through
2507              emit_move_insn to gen_movdi.  So instead, since we know exactly
2508              what we want, create it explicitly.  */
2509
2510           if (target == NULL)
2511             target = gen_reg_rtx (mode);
2512           emit_insn (gen_rtx_SET (VOIDmode, target, GEN_INT (c)));
2513           return target;
2514         }
2515       else if (n >= 2 + (extra != 0))
2516         {
2517           temp = copy_to_suggested_reg (GEN_INT (high << 16), subtarget, mode);
2518
2519           /* As of 2002-02-23, addsi3 is only available when not optimizing.
2520              This means that if we go through expand_binop, we'll try to
2521              generate extensions, etc, which will require new pseudos, which
2522              will fail during some split phases.  The SImode add patterns
2523              still exist, but are not named.  So build the insns by hand.  */
2524
2525           if (extra != 0)
2526             {
2527               if (! subtarget)
2528                 subtarget = gen_reg_rtx (mode);
2529               insn = gen_rtx_PLUS (mode, temp, GEN_INT (extra << 16));
2530               insn = gen_rtx_SET (VOIDmode, subtarget, insn);
2531               emit_insn (insn);
2532               temp = subtarget;
2533             }
2534
2535           if (target == NULL)
2536             target = gen_reg_rtx (mode);
2537           insn = gen_rtx_PLUS (mode, temp, GEN_INT (low));
2538           insn = gen_rtx_SET (VOIDmode, target, insn);
2539           emit_insn (insn);
2540           return target;
2541         }
2542     }
2543
2544   /* If we couldn't do it that way, try some other methods.  But if we have
2545      no instructions left, don't bother.  Likewise, if this is SImode and
2546      we can't make pseudos, we can't do anything since the expand_binop
2547      and expand_unop calls will widen and try to make pseudos.  */
2548
2549   if (n == 1 || (mode == SImode && no_new_pseudos))
2550     return 0;
2551
2552   /* Next, see if we can load a related constant and then shift and possibly
2553      negate it to get the constant we want.  Try this once each increasing
2554      numbers of insns.  */
2555
2556   for (i = 1; i < n; i++)
2557     {
2558       /* First, see if minus some low bits, we've an easy load of
2559          high bits.  */
2560
2561       new = ((c & 0xffff) ^ 0x8000) - 0x8000;
2562       if (new != 0
2563           && (temp = alpha_emit_set_const (subtarget, mode, c - new, i)) != 0)
2564         return expand_binop (mode, add_optab, temp, GEN_INT (new),
2565                              target, 0, OPTAB_WIDEN);
2566
2567       /* Next try complementing.  */
2568       if ((temp = alpha_emit_set_const (subtarget, mode, ~ c, i)) != 0)
2569         return expand_unop (mode, one_cmpl_optab, temp, target, 0);
2570
2571       /* Next try to form a constant and do a left shift.  We can do this
2572          if some low-order bits are zero; the exact_log2 call below tells
2573          us that information.  The bits we are shifting out could be any
2574          value, but here we'll just try the 0- and sign-extended forms of
2575          the constant.  To try to increase the chance of having the same
2576          constant in more than one insn, start at the highest number of
2577          bits to shift, but try all possibilities in case a ZAPNOT will
2578          be useful.  */
2579
2580       if ((bits = exact_log2 (c & - c)) > 0)
2581         for (; bits > 0; bits--)
2582           if ((temp = (alpha_emit_set_const
2583                        (subtarget, mode, c >> bits, i))) != 0
2584               || ((temp = (alpha_emit_set_const
2585                           (subtarget, mode,
2586                            ((unsigned HOST_WIDE_INT) c) >> bits, i)))
2587                   != 0))
2588             return expand_binop (mode, ashl_optab, temp, GEN_INT (bits),
2589                                  target, 0, OPTAB_WIDEN);
2590
2591       /* Now try high-order zero bits.  Here we try the shifted-in bits as
2592          all zero and all ones.  Be careful to avoid shifting outside the
2593          mode and to avoid shifting outside the host wide int size.  */
2594       /* On narrow hosts, don't shift a 1 into the high bit, since we'll
2595          confuse the recursive call and set all of the high 32 bits.  */
2596
2597       if ((bits = (MIN (HOST_BITS_PER_WIDE_INT, GET_MODE_SIZE (mode) * 8)
2598                    - floor_log2 (c) - 1 - (HOST_BITS_PER_WIDE_INT < 64))) > 0)
2599         for (; bits > 0; bits--)
2600           if ((temp = alpha_emit_set_const (subtarget, mode,
2601                                             c << bits, i)) != 0
2602               || ((temp = (alpha_emit_set_const
2603                            (subtarget, mode,
2604                             ((c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1)),
2605                             i)))
2606                   != 0))
2607             return expand_binop (mode, lshr_optab, temp, GEN_INT (bits),
2608                                  target, 1, OPTAB_WIDEN);
2609
2610       /* Now try high-order 1 bits.  We get that with a sign-extension.
2611          But one bit isn't enough here.  Be careful to avoid shifting outside
2612          the mode and to avoid shifting outside the host wide int size.  */
2613
2614       if ((bits = (MIN (HOST_BITS_PER_WIDE_INT, GET_MODE_SIZE (mode) * 8)
2615                    - floor_log2 (~ c) - 2)) > 0)
2616         for (; bits > 0; bits--)
2617           if ((temp = alpha_emit_set_const (subtarget, mode,
2618                                             c << bits, i)) != 0
2619               || ((temp = (alpha_emit_set_const
2620                            (subtarget, mode,
2621                             ((c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1)),
2622                             i)))
2623                   != 0))
2624             return expand_binop (mode, ashr_optab, temp, GEN_INT (bits),
2625                                  target, 0, OPTAB_WIDEN);
2626     }
2627
2628 #if HOST_BITS_PER_WIDE_INT == 64
2629   /* Finally, see if can load a value into the target that is the same as the
2630      constant except that all bytes that are 0 are changed to be 0xff.  If we
2631      can, then we can do a ZAPNOT to obtain the desired constant.  */
2632
2633   new = c;
2634   for (i = 0; i < 64; i += 8)
2635     if ((new & ((HOST_WIDE_INT) 0xff << i)) == 0)
2636       new |= (HOST_WIDE_INT) 0xff << i;
2637
2638   /* We are only called for SImode and DImode.  If this is SImode, ensure that
2639      we are sign extended to a full word.  */
2640
2641   if (mode == SImode)
2642     new = ((new & 0xffffffff) ^ 0x80000000) - 0x80000000;
2643
2644   if (new != c && new != -1
2645       && (temp = alpha_emit_set_const (subtarget, mode, new, n - 1)) != 0)
2646     return expand_binop (mode, and_optab, temp, GEN_INT (c | ~ new),
2647                          target, 0, OPTAB_WIDEN);
2648 #endif
2649
2650   return 0;
2651 }
2652
2653 /* Try to output insns to set TARGET equal to the constant C if it can be
2654    done in less than N insns.  Do all computations in MODE.  Returns the place
2655    where the output has been placed if it can be done and the insns have been
2656    emitted.  If it would take more than N insns, zero is returned and no
2657    insns and emitted.  */
2658
2659 rtx
2660 alpha_emit_set_const (rtx target, enum machine_mode mode,
2661                       HOST_WIDE_INT c, int n)
2662 {
2663   rtx result = 0;
2664   rtx orig_target = target;
2665   int i;
2666
2667   /* If we can't make any pseudos, TARGET is an SImode hard register, we
2668      can't load this constant in one insn, do this in DImode.  */
2669   if (no_new_pseudos && mode == SImode
2670       && GET_CODE (target) == REG && REGNO (target) < FIRST_PSEUDO_REGISTER
2671       && (result = alpha_emit_set_const_1 (target, mode, c, 1)) == 0)
2672     {
2673       target = gen_lowpart (DImode, target);
2674       mode = DImode;
2675     }
2676
2677   /* Try 1 insn, then 2, then up to N.  */
2678   for (i = 1; i <= n; i++)
2679     {
2680       result = alpha_emit_set_const_1 (target, mode, c, i);
2681       if (result)
2682         {
2683           rtx insn = get_last_insn ();
2684           rtx set = single_set (insn);
2685           if (! CONSTANT_P (SET_SRC (set)))
2686             set_unique_reg_note (get_last_insn (), REG_EQUAL, GEN_INT (c));
2687           break;
2688         }
2689     }
2690
2691   /* Allow for the case where we changed the mode of TARGET.  */
2692   if (result == target)
2693     result = orig_target;
2694
2695   return result;
2696 }
2697
2698 /* Having failed to find a 3 insn sequence in alpha_emit_set_const,
2699    fall back to a straight forward decomposition.  We do this to avoid
2700    exponential run times encountered when looking for longer sequences
2701    with alpha_emit_set_const.  */
2702
2703 rtx
2704 alpha_emit_set_long_const (rtx target, HOST_WIDE_INT c1, HOST_WIDE_INT c2)
2705 {
2706   HOST_WIDE_INT d1, d2, d3, d4;
2707
2708   /* Decompose the entire word */
2709 #if HOST_BITS_PER_WIDE_INT >= 64
2710   if (c2 != -(c1 < 0))
2711     abort ();
2712   d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
2713   c1 -= d1;
2714   d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
2715   c1 = (c1 - d2) >> 32;
2716   d3 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
2717   c1 -= d3;
2718   d4 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
2719   if (c1 != d4)
2720     abort ();
2721 #else
2722   d1 = ((c1 & 0xffff) ^ 0x8000) - 0x8000;
2723   c1 -= d1;
2724   d2 = ((c1 & 0xffffffff) ^ 0x80000000) - 0x80000000;
2725   if (c1 != d2)
2726     abort ();
2727   c2 += (d2 < 0);
2728   d3 = ((c2 & 0xffff) ^ 0x8000) - 0x8000;
2729   c2 -= d3;
2730   d4 = ((c2 & 0xffffffff) ^ 0x80000000) - 0x80000000;
2731   if (c2 != d4)
2732     abort ();
2733 #endif
2734
2735   /* Construct the high word */
2736   if (d4)
2737     {
2738       emit_move_insn (target, GEN_INT (d4));
2739       if (d3)
2740         emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d3)));
2741     }
2742   else
2743     emit_move_insn (target, GEN_INT (d3));
2744
2745   /* Shift it into place */
2746   emit_move_insn (target, gen_rtx_ASHIFT (DImode, target, GEN_INT (32)));
2747
2748   /* Add in the low bits.  */
2749   if (d2)
2750     emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d2)));
2751   if (d1)
2752     emit_move_insn (target, gen_rtx_PLUS (DImode, target, GEN_INT (d1)));
2753
2754   return target;
2755 }
2756
2757 /* Expand a move instruction; return true if all work is done.
2758    We don't handle non-bwx subword loads here.  */
2759
2760 bool
2761 alpha_expand_mov (enum machine_mode mode, rtx *operands)
2762 {
2763   /* If the output is not a register, the input must be.  */
2764   if (GET_CODE (operands[0]) == MEM
2765       && ! reg_or_0_operand (operands[1], mode))
2766     operands[1] = force_reg (mode, operands[1]);
2767
2768   /* Allow legitimize_address to perform some simplifications.  */
2769   if (mode == Pmode && symbolic_operand (operands[1], mode))
2770     {
2771       rtx tmp;
2772
2773       /* With RTL inlining, at -O3, rtl is generated, stored, then actually
2774          compiled at the end of compilation.  In the meantime, someone can
2775          re-encode-section-info on some symbol changing it e.g. from global
2776          to local-not-small.  If this happens, we'd have emitted a plain
2777          load rather than a high+losum load and not recognize the insn.
2778
2779          So if rtl inlining is in effect, we delay the global/not-global
2780          decision until rest_of_compilation by wrapping it in an
2781          UNSPEC_SYMBOL.  */
2782       if (TARGET_EXPLICIT_RELOCS && flag_inline_functions
2783           && rtx_equal_function_value_matters
2784           && global_symbolic_operand (operands[1], mode))
2785         {
2786           emit_insn (gen_movdi_er_maybe_g (operands[0], operands[1]));
2787           return true;
2788         }
2789
2790       tmp = alpha_legitimize_address (operands[1], operands[0], mode);
2791       if (tmp)
2792         {
2793           if (tmp == operands[0])
2794             return true;
2795           operands[1] = tmp;
2796           return false;
2797         }
2798     }
2799
2800   /* Early out for non-constants and valid constants.  */
2801   if (! CONSTANT_P (operands[1]) || input_operand (operands[1], mode))
2802     return false;
2803
2804   /* Split large integers.  */
2805   if (GET_CODE (operands[1]) == CONST_INT
2806       || GET_CODE (operands[1]) == CONST_DOUBLE)
2807     {
2808       HOST_WIDE_INT i0, i1;
2809       rtx temp = NULL_RTX;
2810
2811       if (GET_CODE (operands[1]) == CONST_INT)
2812         {
2813           i0 = INTVAL (operands[1]);
2814           i1 = -(i0 < 0);
2815         }
2816       else if (HOST_BITS_PER_WIDE_INT >= 64)
2817         {
2818           i0 = CONST_DOUBLE_LOW (operands[1]);
2819           i1 = -(i0 < 0);
2820         }
2821       else
2822         {
2823           i0 = CONST_DOUBLE_LOW (operands[1]);
2824           i1 = CONST_DOUBLE_HIGH (operands[1]);
2825         }
2826
2827       if (HOST_BITS_PER_WIDE_INT >= 64 || i1 == -(i0 < 0))
2828         temp = alpha_emit_set_const (operands[0], mode, i0, 3);
2829
2830       if (!temp && TARGET_BUILD_CONSTANTS)
2831         temp = alpha_emit_set_long_const (operands[0], i0, i1);
2832
2833       if (temp)
2834         {
2835           if (rtx_equal_p (operands[0], temp))
2836             return true;
2837           operands[1] = temp;
2838           return false;
2839         }
2840     }
2841
2842   /* Otherwise we've nothing left but to drop the thing to memory.  */
2843   operands[1] = force_const_mem (mode, operands[1]);
2844   if (reload_in_progress)
2845     {
2846       emit_move_insn (operands[0], XEXP (operands[1], 0));
2847       operands[1] = copy_rtx (operands[1]);
2848       XEXP (operands[1], 0) = operands[0];
2849     }
2850   else
2851     operands[1] = validize_mem (operands[1]);
2852   return false;
2853 }
2854
2855 /* Expand a non-bwx QImode or HImode move instruction;
2856    return true if all work is done.  */
2857
2858 bool
2859 alpha_expand_mov_nobwx (enum machine_mode mode, rtx *operands)
2860 {
2861   /* If the output is not a register, the input must be.  */
2862   if (GET_CODE (operands[0]) == MEM)
2863     operands[1] = force_reg (mode, operands[1]);
2864
2865   /* Handle four memory cases, unaligned and aligned for either the input
2866      or the output.  The only case where we can be called during reload is
2867      for aligned loads; all other cases require temporaries.  */
2868
2869   if (GET_CODE (operands[1]) == MEM
2870       || (GET_CODE (operands[1]) == SUBREG
2871           && GET_CODE (SUBREG_REG (operands[1])) == MEM)
2872       || (reload_in_progress && GET_CODE (operands[1]) == REG
2873           && REGNO (operands[1]) >= FIRST_PSEUDO_REGISTER)
2874       || (reload_in_progress && GET_CODE (operands[1]) == SUBREG
2875           && GET_CODE (SUBREG_REG (operands[1])) == REG
2876           && REGNO (SUBREG_REG (operands[1])) >= FIRST_PSEUDO_REGISTER))
2877     {
2878       if (aligned_memory_operand (operands[1], mode))
2879         {
2880           if (reload_in_progress)
2881             {
2882               emit_insn ((mode == QImode
2883                           ? gen_reload_inqi_help
2884                           : gen_reload_inhi_help)
2885                          (operands[0], operands[1],
2886                           gen_rtx_REG (SImode, REGNO (operands[0]))));
2887             }
2888           else
2889             {
2890               rtx aligned_mem, bitnum;
2891               rtx scratch = gen_reg_rtx (SImode);
2892
2893               get_aligned_mem (operands[1], &aligned_mem, &bitnum);
2894
2895               emit_insn ((mode == QImode
2896                           ? gen_aligned_loadqi
2897                           : gen_aligned_loadhi)
2898                          (operands[0], aligned_mem, bitnum, scratch));
2899             }
2900         }
2901       else
2902         {
2903           /* Don't pass these as parameters since that makes the generated
2904              code depend on parameter evaluation order which will cause
2905              bootstrap failures.  */
2906
2907           rtx temp1 = gen_reg_rtx (DImode);
2908           rtx temp2 = gen_reg_rtx (DImode);
2909           rtx seq = ((mode == QImode
2910                       ? gen_unaligned_loadqi
2911                       : gen_unaligned_loadhi)
2912                      (operands[0], get_unaligned_address (operands[1], 0),
2913                       temp1, temp2));
2914
2915           alpha_set_memflags (seq, operands[1]);
2916           emit_insn (seq);
2917         }
2918       return true;
2919     }
2920
2921   if (GET_CODE (operands[0]) == MEM
2922       || (GET_CODE (operands[0]) == SUBREG
2923           && GET_CODE (SUBREG_REG (operands[0])) == MEM)
2924       || (reload_in_progress && GET_CODE (operands[0]) == REG
2925           && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER)
2926       || (reload_in_progress && GET_CODE (operands[0]) == SUBREG
2927           && GET_CODE (SUBREG_REG (operands[0])) == REG
2928           && REGNO (operands[0]) >= FIRST_PSEUDO_REGISTER))
2929     {
2930       if (aligned_memory_operand (operands[0], mode))
2931         {
2932           rtx aligned_mem, bitnum;
2933           rtx temp1 = gen_reg_rtx (SImode);
2934           rtx temp2 = gen_reg_rtx (SImode);
2935
2936           get_aligned_mem (operands[0], &aligned_mem, &bitnum);
2937
2938           emit_insn (gen_aligned_store (aligned_mem, operands[1], bitnum,
2939                                         temp1, temp2));
2940         }
2941       else
2942         {
2943           rtx temp1 = gen_reg_rtx (DImode);
2944           rtx temp2 = gen_reg_rtx (DImode);
2945           rtx temp3 = gen_reg_rtx (DImode);
2946           rtx seq = ((mode == QImode
2947                       ? gen_unaligned_storeqi
2948                       : gen_unaligned_storehi)
2949                      (get_unaligned_address (operands[0], 0),
2950                       operands[1], temp1, temp2, temp3));
2951
2952           alpha_set_memflags (seq, operands[0]);
2953           emit_insn (seq);
2954         }
2955       return true;
2956     }
2957
2958   return false;
2959 }
2960
2961 /* Generate an unsigned DImode to FP conversion.  This is the same code
2962    optabs would emit if we didn't have TFmode patterns.
2963
2964    For SFmode, this is the only construction I've found that can pass
2965    gcc.c-torture/execute/ieee/rbug.c.  No scenario that uses DFmode
2966    intermediates will work, because you'll get intermediate rounding
2967    that ruins the end result.  Some of this could be fixed by turning
2968    on round-to-positive-infinity, but that requires diddling the fpsr,
2969    which kills performance.  I tried turning this around and converting
2970    to a negative number, so that I could turn on /m, but either I did
2971    it wrong or there's something else cause I wound up with the exact
2972    same single-bit error.  There is a branch-less form of this same code:
2973
2974         srl     $16,1,$1
2975         and     $16,1,$2
2976         cmplt   $16,0,$3
2977         or      $1,$2,$2
2978         cmovge  $16,$16,$2
2979         itoft   $3,$f10
2980         itoft   $2,$f11
2981         cvtqs   $f11,$f11
2982         adds    $f11,$f11,$f0
2983         fcmoveq $f10,$f11,$f0
2984
2985    I'm not using it because it's the same number of instructions as
2986    this branch-full form, and it has more serialized long latency
2987    instructions on the critical path.
2988
2989    For DFmode, we can avoid rounding errors by breaking up the word
2990    into two pieces, converting them separately, and adding them back:
2991
2992    LC0: .long 0,0x5f800000
2993
2994         itoft   $16,$f11
2995         lda     $2,LC0
2996         cmplt   $16,0,$1
2997         cpyse   $f11,$f31,$f10
2998         cpyse   $f31,$f11,$f11
2999         s4addq  $1,$2,$1
3000         lds     $f12,0($1)
3001         cvtqt   $f10,$f10
3002         cvtqt   $f11,$f11
3003         addt    $f12,$f10,$f0
3004         addt    $f0,$f11,$f0
3005
3006    This doesn't seem to be a clear-cut win over the optabs form.
3007    It probably all depends on the distribution of numbers being
3008    converted -- in the optabs form, all but high-bit-set has a
3009    much lower minimum execution time.  */
3010
3011 void
3012 alpha_emit_floatuns (rtx operands[2])
3013 {
3014   rtx neglab, donelab, i0, i1, f0, in, out;
3015   enum machine_mode mode;
3016
3017   out = operands[0];
3018   in = force_reg (DImode, operands[1]);
3019   mode = GET_MODE (out);
3020   neglab = gen_label_rtx ();
3021   donelab = gen_label_rtx ();
3022   i0 = gen_reg_rtx (DImode);
3023   i1 = gen_reg_rtx (DImode);
3024   f0 = gen_reg_rtx (mode);
3025
3026   emit_cmp_and_jump_insns (in, const0_rtx, LT, const0_rtx, DImode, 0, neglab);
3027
3028   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_FLOAT (mode, in)));
3029   emit_jump_insn (gen_jump (donelab));
3030   emit_barrier ();
3031
3032   emit_label (neglab);
3033
3034   emit_insn (gen_lshrdi3 (i0, in, const1_rtx));
3035   emit_insn (gen_anddi3 (i1, in, const1_rtx));
3036   emit_insn (gen_iordi3 (i0, i0, i1));
3037   emit_insn (gen_rtx_SET (VOIDmode, f0, gen_rtx_FLOAT (mode, i0)));
3038   emit_insn (gen_rtx_SET (VOIDmode, out, gen_rtx_PLUS (mode, f0, f0)));
3039
3040   emit_label (donelab);
3041 }
3042
3043 /* Generate the comparison for a conditional branch.  */
3044
3045 rtx
3046 alpha_emit_conditional_branch (enum rtx_code code)
3047 {
3048   enum rtx_code cmp_code, branch_code;
3049   enum machine_mode cmp_mode, branch_mode = VOIDmode;
3050   rtx op0 = alpha_compare.op0, op1 = alpha_compare.op1;
3051   rtx tem;
3052
3053   if (alpha_compare.fp_p && GET_MODE (op0) == TFmode)
3054     {
3055       if (! TARGET_HAS_XFLOATING_LIBS)
3056         abort ();
3057
3058       /* X_floating library comparison functions return
3059            -1  unordered
3060             0  false
3061             1  true
3062          Convert the compare against the raw return value.  */
3063
3064       switch (code)
3065         {
3066         case UNORDERED:
3067           cmp_code = EQ;
3068           code = LT;
3069           break;
3070         case ORDERED:
3071           cmp_code = EQ;
3072           code = GE;
3073           break;
3074         case NE:
3075           cmp_code = NE;
3076           code = NE;
3077           break;
3078         default:
3079           cmp_code = code;
3080           code = GT;
3081           break;
3082         }
3083
3084       op0 = alpha_emit_xfloating_compare (cmp_code, op0, op1);
3085       op1 = const0_rtx;
3086       alpha_compare.fp_p = 0;
3087     }
3088
3089   /* The general case: fold the comparison code to the types of compares
3090      that we have, choosing the branch as necessary.  */
3091   switch (code)
3092     {
3093     case EQ:  case LE:  case LT:  case LEU:  case LTU:
3094     case UNORDERED:
3095       /* We have these compares: */
3096       cmp_code = code, branch_code = NE;
3097       break;
3098
3099     case NE:
3100     case ORDERED:
3101       /* These must be reversed.  */
3102       cmp_code = reverse_condition (code), branch_code = EQ;
3103       break;
3104
3105     case GE:  case GT: case GEU:  case GTU:
3106       /* For FP, we swap them, for INT, we reverse them.  */
3107       if (alpha_compare.fp_p)
3108         {
3109           cmp_code = swap_condition (code);
3110           branch_code = NE;
3111           tem = op0, op0 = op1, op1 = tem;
3112         }
3113       else
3114         {
3115           cmp_code = reverse_condition (code);
3116           branch_code = EQ;
3117         }
3118       break;
3119
3120     default:
3121       abort ();
3122     }
3123
3124   if (alpha_compare.fp_p)
3125     {
3126       cmp_mode = DFmode;
3127       if (flag_unsafe_math_optimizations)
3128         {
3129           /* When we are not as concerned about non-finite values, and we
3130              are comparing against zero, we can branch directly.  */
3131           if (op1 == CONST0_RTX (DFmode))
3132             cmp_code = NIL, branch_code = code;
3133           else if (op0 == CONST0_RTX (DFmode))
3134             {
3135               /* Undo the swap we probably did just above.  */
3136               tem = op0, op0 = op1, op1 = tem;
3137               branch_code = swap_condition (cmp_code);
3138               cmp_code = NIL;
3139             }
3140         }
3141       else
3142         {
3143           /* ??? We mark the branch mode to be CCmode to prevent the
3144              compare and branch from being combined, since the compare
3145              insn follows IEEE rules that the branch does not.  */
3146           branch_mode = CCmode;
3147         }
3148     }
3149   else
3150     {
3151       cmp_mode = DImode;
3152
3153       /* The following optimizations are only for signed compares.  */
3154       if (code != LEU && code != LTU && code != GEU && code != GTU)
3155         {
3156           /* Whee.  Compare and branch against 0 directly.  */
3157           if (op1 == const0_rtx)
3158             cmp_code = NIL, branch_code = code;
3159
3160           /* We want to use cmpcc/bcc when we can, since there is a zero delay
3161              bypass between logicals and br/cmov on EV5.  But we don't want to
3162              force valid immediate constants into registers needlessly.  */
3163           else if (GET_CODE (op1) == CONST_INT)
3164             {
3165               HOST_WIDE_INT v = INTVAL (op1), n = -v;
3166
3167               if (! CONST_OK_FOR_LETTER_P (v, 'I')
3168                   && (CONST_OK_FOR_LETTER_P (n, 'K')
3169                       || CONST_OK_FOR_LETTER_P (n, 'L')))
3170                 {
3171                   cmp_code = PLUS, branch_code = code;
3172                   op1 = GEN_INT (n);
3173                 }
3174             }
3175         }
3176
3177       if (!reg_or_0_operand (op0, DImode))
3178         op0 = force_reg (DImode, op0);
3179       if (cmp_code != PLUS && !reg_or_8bit_operand (op1, DImode))
3180         op1 = force_reg (DImode, op1);
3181     }
3182
3183   /* Emit an initial compare instruction, if necessary.  */
3184   tem = op0;
3185   if (cmp_code != NIL)
3186     {
3187       tem = gen_reg_rtx (cmp_mode);
3188       emit_move_insn (tem, gen_rtx_fmt_ee (cmp_code, cmp_mode, op0, op1));
3189     }
3190
3191   /* Zero the operands.  */
3192   memset (&alpha_compare, 0, sizeof (alpha_compare));
3193
3194   /* Return the branch comparison.  */
3195   return gen_rtx_fmt_ee (branch_code, branch_mode, tem, CONST0_RTX (cmp_mode));
3196 }
3197
3198 /* Certain simplifications can be done to make invalid setcc operations
3199    valid.  Return the final comparison, or NULL if we can't work.  */
3200
3201 rtx
3202 alpha_emit_setcc (enum rtx_code code)
3203 {
3204   enum rtx_code cmp_code;
3205   rtx op0 = alpha_compare.op0, op1 = alpha_compare.op1;
3206   int fp_p = alpha_compare.fp_p;
3207   rtx tmp;
3208
3209   /* Zero the operands.  */
3210   memset (&alpha_compare, 0, sizeof (alpha_compare));
3211
3212   if (fp_p && GET_MODE (op0) == TFmode)
3213     {
3214       if (! TARGET_HAS_XFLOATING_LIBS)
3215         abort ();
3216
3217       /* X_floating library comparison functions return
3218            -1  unordered
3219             0  false
3220             1  true
3221          Convert the compare against the raw return value.  */
3222
3223       if (code == UNORDERED || code == ORDERED)
3224         cmp_code = EQ;
3225       else
3226         cmp_code = code;
3227
3228       op0 = alpha_emit_xfloating_compare (cmp_code, op0, op1);
3229       op1 = const0_rtx;
3230       fp_p = 0;
3231
3232       if (code == UNORDERED)
3233         code = LT;
3234       else if (code == ORDERED)
3235         code = GE;
3236       else
3237         code = GT;
3238     }
3239
3240   if (fp_p && !TARGET_FIX)
3241     return NULL_RTX;
3242
3243   /* The general case: fold the comparison code to the types of compares
3244      that we have, choosing the branch as necessary.  */
3245
3246   cmp_code = NIL;
3247   switch (code)
3248     {
3249     case EQ:  case LE:  case LT:  case LEU:  case LTU:
3250     case UNORDERED:
3251       /* We have these compares.  */
3252       if (fp_p)
3253         cmp_code = code, code = NE;
3254       break;
3255
3256     case NE:
3257       if (!fp_p && op1 == const0_rtx)
3258         break;
3259       /* FALLTHRU */
3260
3261     case ORDERED:
3262       cmp_code = reverse_condition (code);
3263       code = EQ;
3264       break;
3265
3266     case GE:  case GT: case GEU:  case GTU:
3267       /* These normally need swapping, but for integer zero we have
3268          special patterns that recognize swapped operands.  */
3269       if (!fp_p && op1 == const0_rtx)
3270         break;
3271       code = swap_condition (code);
3272       if (fp_p)
3273         cmp_code = code, code = NE;
3274       tmp = op0, op0 = op1, op1 = tmp;
3275       break;
3276
3277     default:
3278       abort ();
3279     }
3280
3281   if (!fp_p)
3282     {
3283       if (!register_operand (op0, DImode))
3284         op0 = force_reg (DImode, op0);
3285       if (!reg_or_8bit_operand (op1, DImode))
3286         op1 = force_reg (DImode, op1);
3287     }
3288
3289   /* Emit an initial compare instruction, if necessary.  */
3290   if (cmp_code != NIL)
3291     {
3292       enum machine_mode mode = fp_p ? DFmode : DImode;
3293
3294       tmp = gen_reg_rtx (mode);
3295       emit_insn (gen_rtx_SET (VOIDmode, tmp,
3296                               gen_rtx_fmt_ee (cmp_code, mode, op0, op1)));
3297
3298       op0 = fp_p ? gen_lowpart (DImode, tmp) : tmp;
3299       op1 = const0_rtx;
3300     }
3301
3302   /* Return the setcc comparison.  */
3303   return gen_rtx_fmt_ee (code, DImode, op0, op1);
3304 }
3305
3306
3307 /* Rewrite a comparison against zero CMP of the form
3308    (CODE (cc0) (const_int 0)) so it can be written validly in
3309    a conditional move (if_then_else CMP ...).
3310    If both of the operands that set cc0 are nonzero we must emit
3311    an insn to perform the compare (it can't be done within
3312    the conditional move).  */
3313
3314 rtx
3315 alpha_emit_conditional_move (rtx cmp, enum machine_mode mode)
3316 {
3317   enum rtx_code code = GET_CODE (cmp);
3318   enum rtx_code cmov_code = NE;
3319   rtx op0 = alpha_compare.op0;
3320   rtx op1 = alpha_compare.op1;
3321   int fp_p = alpha_compare.fp_p;
3322   enum machine_mode cmp_mode
3323     = (GET_MODE (op0) == VOIDmode ? DImode : GET_MODE (op0));
3324   enum machine_mode cmp_op_mode = fp_p ? DFmode : DImode;
3325   enum machine_mode cmov_mode = VOIDmode;
3326   int local_fast_math = flag_unsafe_math_optimizations;
3327   rtx tem;
3328
3329   /* Zero the operands.  */
3330   memset (&alpha_compare, 0, sizeof (alpha_compare));
3331
3332   if (fp_p != FLOAT_MODE_P (mode))
3333     {
3334       enum rtx_code cmp_code;
3335
3336       if (! TARGET_FIX)
3337         return 0;
3338
3339       /* If we have fp<->int register move instructions, do a cmov by
3340          performing the comparison in fp registers, and move the
3341          zero/nonzero value to integer registers, where we can then
3342          use a normal cmov, or vice-versa.  */
3343
3344       switch (code)
3345         {
3346         case EQ: case LE: case LT: case LEU: case LTU:
3347           /* We have these compares.  */
3348           cmp_code = code, code = NE;
3349           break;
3350
3351         case NE:
3352           /* This must be reversed.  */
3353           cmp_code = EQ, code = EQ;
3354           break;
3355
3356         case GE: case GT: case GEU: case GTU:
3357           /* These normally need swapping, but for integer zero we have
3358              special patterns that recognize swapped operands.  */
3359           if (!fp_p && op1 == const0_rtx)
3360             cmp_code = code, code = NE;
3361           else
3362             {
3363               cmp_code = swap_condition (code);
3364               code = NE;
3365               tem = op0, op0 = op1, op1 = tem;
3366             }
3367           break;
3368
3369         default:
3370           abort ();
3371         }
3372
3373       tem = gen_reg_rtx (cmp_op_mode);
3374       emit_insn (gen_rtx_SET (VOIDmode, tem,
3375                               gen_rtx_fmt_ee (cmp_code, cmp_op_mode,
3376                                               op0, op1)));
3377
3378       cmp_mode = cmp_op_mode = fp_p ? DImode : DFmode;
3379       op0 = gen_lowpart (cmp_op_mode, tem);
3380       op1 = CONST0_RTX (cmp_op_mode);
3381       fp_p = !fp_p;
3382       local_fast_math = 1;
3383     }
3384
3385   /* We may be able to use a conditional move directly.
3386      This avoids emitting spurious compares.  */
3387   if (signed_comparison_operator (cmp, VOIDmode)
3388       && (!fp_p || local_fast_math)
3389       && (op0 == CONST0_RTX (cmp_mode) || op1 == CONST0_RTX (cmp_mode)))
3390     return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
3391
3392   /* We can't put the comparison inside the conditional move;
3393      emit a compare instruction and put that inside the
3394      conditional move.  Make sure we emit only comparisons we have;
3395      swap or reverse as necessary.  */
3396
3397   if (no_new_pseudos)
3398     return NULL_RTX;
3399
3400   switch (code)
3401     {
3402     case EQ:  case LE:  case LT:  case LEU:  case LTU:
3403       /* We have these compares: */
3404       break;
3405
3406     case NE:
3407       /* This must be reversed.  */
3408       code = reverse_condition (code);
3409       cmov_code = EQ;
3410       break;
3411
3412     case GE:  case GT:  case GEU:  case GTU:
3413       /* These must be swapped.  */
3414       if (op1 != CONST0_RTX (cmp_mode))
3415         {
3416           code = swap_condition (code);
3417           tem = op0, op0 = op1, op1 = tem;
3418         }
3419       break;
3420
3421     default:
3422       abort ();
3423     }
3424
3425   if (!fp_p)
3426     {
3427       if (!reg_or_0_operand (op0, DImode))
3428         op0 = force_reg (DImode, op0);
3429       if (!reg_or_8bit_operand (op1, DImode))
3430         op1 = force_reg (DImode, op1);
3431     }
3432
3433   /* ??? We mark the branch mode to be CCmode to prevent the compare
3434      and cmov from being combined, since the compare insn follows IEEE
3435      rules that the cmov does not.  */
3436   if (fp_p && !local_fast_math)
3437     cmov_mode = CCmode;
3438
3439   tem = gen_reg_rtx (cmp_op_mode);
3440   emit_move_insn (tem, gen_rtx_fmt_ee (code, cmp_op_mode, op0, op1));
3441   return gen_rtx_fmt_ee (cmov_code, cmov_mode, tem, CONST0_RTX (cmp_op_mode));
3442 }
3443
3444 /* Simplify a conditional move of two constants into a setcc with
3445    arithmetic.  This is done with a splitter since combine would
3446    just undo the work if done during code generation.  It also catches
3447    cases we wouldn't have before cse.  */
3448
3449 int
3450 alpha_split_conditional_move (enum rtx_code code, rtx dest, rtx cond,
3451                               rtx t_rtx, rtx f_rtx)
3452 {
3453   HOST_WIDE_INT t, f, diff;
3454   enum machine_mode mode;
3455   rtx target, subtarget, tmp;
3456
3457   mode = GET_MODE (dest);
3458   t = INTVAL (t_rtx);
3459   f = INTVAL (f_rtx);
3460   diff = t - f;
3461
3462   if (((code == NE || code == EQ) && diff < 0)
3463       || (code == GE || code == GT))
3464     {
3465       code = reverse_condition (code);
3466       diff = t, t = f, f = diff;
3467       diff = t - f;
3468     }
3469
3470   subtarget = target = dest;
3471   if (mode != DImode)
3472     {
3473       target = gen_lowpart (DImode, dest);
3474       if (! no_new_pseudos)
3475         subtarget = gen_reg_rtx (DImode);
3476       else
3477         subtarget = target;
3478     }
3479   /* Below, we must be careful to use copy_rtx on target and subtarget
3480      in intermediate insns, as they may be a subreg rtx, which may not
3481      be shared.  */
3482
3483   if (f == 0 && exact_log2 (diff) > 0
3484       /* On EV6, we've got enough shifters to make non-arithmetic shifts
3485          viable over a longer latency cmove.  On EV5, the E0 slot is a
3486          scarce resource, and on EV4 shift has the same latency as a cmove.  */
3487       && (diff <= 8 || alpha_cpu == PROCESSOR_EV6))
3488     {
3489       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
3490       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
3491
3492       tmp = gen_rtx_ASHIFT (DImode, copy_rtx (subtarget),
3493                             GEN_INT (exact_log2 (t)));
3494       emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
3495     }
3496   else if (f == 0 && t == -1)
3497     {
3498       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
3499       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
3500
3501       emit_insn (gen_negdi2 (target, copy_rtx (subtarget)));
3502     }
3503   else if (diff == 1 || diff == 4 || diff == 8)
3504     {
3505       rtx add_op;
3506
3507       tmp = gen_rtx_fmt_ee (code, DImode, cond, const0_rtx);
3508       emit_insn (gen_rtx_SET (VOIDmode, copy_rtx (subtarget), tmp));
3509
3510       if (diff == 1)
3511         emit_insn (gen_adddi3 (target, copy_rtx (subtarget), GEN_INT (f)));
3512       else
3513         {
3514           add_op = GEN_INT (f);
3515           if (sext_add_operand (add_op, mode))
3516             {
3517               tmp = gen_rtx_MULT (DImode, copy_rtx (subtarget),
3518                                   GEN_INT (diff));
3519               tmp = gen_rtx_PLUS (DImode, tmp, add_op);
3520               emit_insn (gen_rtx_SET (VOIDmode, target, tmp));
3521             }
3522           else
3523             return 0;
3524         }
3525     }
3526   else
3527     return 0;
3528
3529   return 1;
3530 }
3531 \f
3532 /* Look up the function X_floating library function name for the
3533    given operation.  */
3534
3535 static const char *
3536 alpha_lookup_xfloating_lib_func (enum rtx_code code)
3537 {
3538   struct xfloating_op
3539     {
3540       const enum rtx_code code;
3541       const char *const func;
3542     };
3543
3544   static const struct xfloating_op vms_xfloating_ops[] =
3545     {
3546       { PLUS,           "OTS$ADD_X" },
3547       { MINUS,          "OTS$SUB_X" },
3548       { MULT,           "OTS$MUL_X" },
3549       { DIV,            "OTS$DIV_X" },
3550       { EQ,             "OTS$EQL_X" },
3551       { NE,             "OTS$NEQ_X" },
3552       { LT,             "OTS$LSS_X" },
3553       { LE,             "OTS$LEQ_X" },
3554       { GT,             "OTS$GTR_X" },
3555       { GE,             "OTS$GEQ_X" },
3556       { FIX,            "OTS$CVTXQ" },
3557       { FLOAT,          "OTS$CVTQX" },
3558       { UNSIGNED_FLOAT, "OTS$CVTQUX" },
3559       { FLOAT_EXTEND,   "OTS$CVT_FLOAT_T_X" },
3560       { FLOAT_TRUNCATE, "OTS$CVT_FLOAT_X_T" },
3561     };
3562
3563   static const struct xfloating_op osf_xfloating_ops[] =
3564     {
3565       { PLUS,           "_OtsAddX" },
3566       { MINUS,          "_OtsSubX" },
3567       { MULT,           "_OtsMulX" },
3568       { DIV,            "_OtsDivX" },
3569       { EQ,             "_OtsEqlX" },
3570       { NE,             "_OtsNeqX" },
3571       { LT,             "_OtsLssX" },
3572       { LE,             "_OtsLeqX" },
3573       { GT,             "_OtsGtrX" },
3574       { GE,             "_OtsGeqX" },
3575       { FIX,            "_OtsCvtXQ" },
3576       { FLOAT,          "_OtsCvtQX" },
3577       { UNSIGNED_FLOAT, "_OtsCvtQUX" },
3578       { FLOAT_EXTEND,   "_OtsConvertFloatTX" },
3579       { FLOAT_TRUNCATE, "_OtsConvertFloatXT" },
3580     };
3581
3582   const struct xfloating_op *ops;
3583   const long n = ARRAY_SIZE (osf_xfloating_ops);
3584   long i;
3585
3586   /* How irritating.  Nothing to key off for the table.  Hardcode
3587      knowledge of the G_floating routines.  */
3588   if (TARGET_FLOAT_VAX)
3589     {
3590       if (TARGET_ABI_OPEN_VMS)
3591         {
3592           if (code == FLOAT_EXTEND)
3593             return "OTS$CVT_FLOAT_G_X";
3594           if (code == FLOAT_TRUNCATE)
3595             return "OTS$CVT_FLOAT_X_G";
3596         }
3597       else
3598         {
3599           if (code == FLOAT_EXTEND)
3600             return "_OtsConvertFloatGX";
3601           if (code == FLOAT_TRUNCATE)
3602             return "_OtsConvertFloatXG";
3603         }
3604     }
3605
3606   if (TARGET_ABI_OPEN_VMS)
3607     ops = vms_xfloating_ops;
3608   else
3609     ops = osf_xfloating_ops;
3610
3611   for (i = 0; i < n; ++i)
3612     if (ops[i].code == code)
3613       return ops[i].func;
3614
3615   abort();
3616 }
3617
3618 /* Most X_floating operations take the rounding mode as an argument.
3619    Compute that here.  */
3620
3621 static int
3622 alpha_compute_xfloating_mode_arg (enum rtx_code code,
3623                                   enum alpha_fp_rounding_mode round)
3624 {
3625   int mode;
3626
3627   switch (round)
3628     {
3629     case ALPHA_FPRM_NORM:
3630       mode = 2;
3631       break;
3632     case ALPHA_FPRM_MINF:
3633       mode = 1;
3634       break;
3635     case ALPHA_FPRM_CHOP:
3636       mode = 0;
3637       break;
3638     case ALPHA_FPRM_DYN:
3639       mode = 4;
3640       break;
3641     default:
3642       abort ();
3643
3644     /* XXX For reference, round to +inf is mode = 3.  */
3645     }
3646
3647   if (code == FLOAT_TRUNCATE && alpha_fptm == ALPHA_FPTM_N)
3648     mode |= 0x10000;
3649
3650   return mode;
3651 }
3652
3653 /* Emit an X_floating library function call.
3654
3655    Note that these functions do not follow normal calling conventions:
3656    TFmode arguments are passed in two integer registers (as opposed to
3657    indirect); TFmode return values appear in R16+R17.
3658
3659    FUNC is the function name to call.
3660    TARGET is where the output belongs.
3661    OPERANDS are the inputs.
3662    NOPERANDS is the count of inputs.
3663    EQUIV is the expression equivalent for the function.
3664 */
3665
3666 static void
3667 alpha_emit_xfloating_libcall (const char *func, rtx target, rtx operands[],
3668                               int noperands, rtx equiv)
3669 {
3670   rtx usage = NULL_RTX, tmp, reg;
3671   int regno = 16, i;
3672
3673   start_sequence ();
3674
3675   for (i = 0; i < noperands; ++i)
3676     {
3677       switch (GET_MODE (operands[i]))
3678         {
3679         case TFmode:
3680           reg = gen_rtx_REG (TFmode, regno);
3681           regno += 2;
3682           break;
3683
3684         case DFmode:
3685           reg = gen_rtx_REG (DFmode, regno + 32);
3686           regno += 1;
3687           break;
3688
3689         case VOIDmode:
3690           if (GET_CODE (operands[i]) != CONST_INT)
3691             abort ();
3692           /* FALLTHRU */
3693         case DImode:
3694           reg = gen_rtx_REG (DImode, regno);
3695           regno += 1;
3696           break;
3697
3698         default:
3699           abort ();
3700         }
3701
3702       emit_move_insn (reg, operands[i]);
3703       usage = alloc_EXPR_LIST (0, gen_rtx_USE (VOIDmode, reg), usage);
3704     }
3705
3706   switch (GET_MODE (target))
3707     {
3708     case TFmode:
3709       reg = gen_rtx_REG (TFmode, 16);
3710       break;
3711     case DFmode:
3712       reg = gen_rtx_REG (DFmode, 32);
3713       break;
3714     case DImode:
3715       reg = gen_rtx_REG (DImode, 0);
3716       break;
3717     default:
3718       abort ();
3719     }
3720
3721   tmp = gen_rtx_MEM (QImode, init_one_libfunc (func));
3722   tmp = emit_call_insn (GEN_CALL_VALUE (reg, tmp, const0_rtx,
3723                                         const0_rtx, const0_rtx));
3724   CALL_INSN_FUNCTION_USAGE (tmp) = usage;
3725
3726   tmp = get_insns ();
3727   end_sequence ();
3728
3729   emit_libcall_block (tmp, target, reg, equiv);
3730 }
3731
3732 /* Emit an X_floating library function call for arithmetic (+,-,*,/).  */
3733
3734 void
3735 alpha_emit_xfloating_arith (enum rtx_code code, rtx operands[])
3736 {
3737   const char *func;
3738   int mode;
3739   rtx out_operands[3];
3740
3741   func = alpha_lookup_xfloating_lib_func (code);
3742   mode = alpha_compute_xfloating_mode_arg (code, alpha_fprm);
3743
3744   out_operands[0] = operands[1];
3745   out_operands[1] = operands[2];
3746   out_operands[2] = GEN_INT (mode);
3747   alpha_emit_xfloating_libcall (func, operands[0], out_operands, 3,
3748                                 gen_rtx_fmt_ee (code, TFmode, operands[1],
3749                                                 operands[2]));
3750 }
3751
3752 /* Emit an X_floating library function call for a comparison.  */
3753
3754 static rtx
3755 alpha_emit_xfloating_compare (enum rtx_code code, rtx op0, rtx op1)
3756 {
3757   const char *func;
3758   rtx out, operands[2];
3759
3760   func = alpha_lookup_xfloating_lib_func (code);
3761
3762   operands[0] = op0;
3763   operands[1] = op1;
3764   out = gen_reg_rtx (DImode);
3765
3766   /* ??? Strange mode for equiv because what's actually returned
3767      is -1,0,1, not a proper boolean value.  */
3768   alpha_emit_xfloating_libcall (func, out, operands, 2,
3769                                 gen_rtx_fmt_ee (code, CCmode, op0, op1));
3770
3771   return out;
3772 }
3773
3774 /* Emit an X_floating library function call for a conversion.  */
3775
3776 void
3777 alpha_emit_xfloating_cvt (enum rtx_code code, rtx operands[])
3778 {
3779   int noperands = 1, mode;
3780   rtx out_operands[2];
3781   const char *func;
3782
3783   func = alpha_lookup_xfloating_lib_func (code);
3784
3785   out_operands[0] = operands[1];
3786
3787   switch (code)
3788     {
3789     case FIX:
3790       mode = alpha_compute_xfloating_mode_arg (code, ALPHA_FPRM_CHOP);
3791       out_operands[1] = GEN_INT (mode);
3792       noperands = 2;
3793       break;
3794     case FLOAT_TRUNCATE:
3795       mode = alpha_compute_xfloating_mode_arg (code, alpha_fprm);
3796       out_operands[1] = GEN_INT (mode);
3797       noperands = 2;
3798       break;
3799     default:
3800       break;
3801     }
3802
3803   alpha_emit_xfloating_libcall (func, operands[0], out_operands, noperands,
3804                                 gen_rtx_fmt_e (code, GET_MODE (operands[0]),
3805                                                operands[1]));
3806 }
3807
3808 /* Split a TFmode OP[1] into DImode OP[2,3] and likewise for
3809    OP[0] into OP[0,1].  Naturally, output operand ordering is
3810    little-endian.  */
3811
3812 void
3813 alpha_split_tfmode_pair (rtx operands[4])
3814 {
3815   if (GET_CODE (operands[1]) == REG)
3816     {
3817       operands[3] = gen_rtx_REG (DImode, REGNO (operands[1]) + 1);
3818       operands[2] = gen_rtx_REG (DImode, REGNO (operands[1]));
3819     }
3820   else if (GET_CODE (operands[1]) == MEM)
3821     {
3822       operands[3] = adjust_address (operands[1], DImode, 8);
3823       operands[2] = adjust_address (operands[1], DImode, 0);
3824     }
3825   else if (operands[1] == CONST0_RTX (TFmode))
3826     operands[2] = operands[3] = const0_rtx;
3827   else
3828     abort ();
3829
3830   if (GET_CODE (operands[0]) == REG)
3831     {
3832       operands[1] = gen_rtx_REG (DImode, REGNO (operands[0]) + 1);
3833       operands[0] = gen_rtx_REG (DImode, REGNO (operands[0]));
3834     }
3835   else if (GET_CODE (operands[0]) == MEM)
3836     {
3837       operands[1] = adjust_address (operands[0], DImode, 8);
3838       operands[0] = adjust_address (operands[0], DImode, 0);
3839     }
3840   else
3841     abort ();
3842 }
3843
3844 /* Implement negtf2 or abstf2.  Op0 is destination, op1 is source,
3845    op2 is a register containing the sign bit, operation is the
3846    logical operation to be performed.  */
3847
3848 void
3849 alpha_split_tfmode_frobsign (rtx operands[3], rtx (*operation) (rtx, rtx, rtx))
3850 {
3851   rtx high_bit = operands[2];
3852   rtx scratch;
3853   int move;
3854
3855   alpha_split_tfmode_pair (operands);
3856
3857   /* Detect three flavors of operand overlap.  */
3858   move = 1;
3859   if (rtx_equal_p (operands[0], operands[2]))
3860     move = 0;
3861   else if (rtx_equal_p (operands[1], operands[2]))
3862     {
3863       if (rtx_equal_p (operands[0], high_bit))
3864         move = 2;
3865       else
3866         move = -1;
3867     }
3868
3869   if (move < 0)
3870     emit_move_insn (operands[0], operands[2]);
3871
3872   /* ??? If the destination overlaps both source tf and high_bit, then
3873      assume source tf is dead in its entirety and use the other half
3874      for a scratch register.  Otherwise "scratch" is just the proper
3875      destination register.  */
3876   scratch = operands[move < 2 ? 1 : 3];
3877
3878   emit_insn ((*operation) (scratch, high_bit, operands[3]));
3879
3880   if (move > 0)
3881     {
3882       emit_move_insn (operands[0], operands[2]);
3883       if (move > 1)
3884         emit_move_insn (operands[1], scratch);
3885     }
3886 }
3887 \f
3888 /* Use ext[wlq][lh] as the Architecture Handbook describes for extracting
3889    unaligned data:
3890
3891            unsigned:                       signed:
3892    word:   ldq_u  r1,X(r11)                ldq_u  r1,X(r11)
3893            ldq_u  r2,X+1(r11)              ldq_u  r2,X+1(r11)
3894            lda    r3,X(r11)                lda    r3,X+2(r11)
3895            extwl  r1,r3,r1                 extql  r1,r3,r1
3896            extwh  r2,r3,r2                 extqh  r2,r3,r2
3897            or     r1.r2.r1                 or     r1,r2,r1
3898                                            sra    r1,48,r1
3899
3900    long:   ldq_u  r1,X(r11)                ldq_u  r1,X(r11)
3901            ldq_u  r2,X+3(r11)              ldq_u  r2,X+3(r11)
3902            lda    r3,X(r11)                lda    r3,X(r11)
3903            extll  r1,r3,r1                 extll  r1,r3,r1
3904            extlh  r2,r3,r2                 extlh  r2,r3,r2
3905            or     r1.r2.r1                 addl   r1,r2,r1
3906
3907    quad:   ldq_u  r1,X(r11)
3908            ldq_u  r2,X+7(r11)
3909            lda    r3,X(r11)
3910            extql  r1,r3,r1
3911            extqh  r2,r3,r2
3912            or     r1.r2.r1
3913 */
3914
3915 void
3916 alpha_expand_unaligned_load (rtx tgt, rtx mem, HOST_WIDE_INT size,
3917                              HOST_WIDE_INT ofs, int sign)
3918 {
3919   rtx meml, memh, addr, extl, exth, tmp, mema;
3920   enum machine_mode mode;
3921
3922   meml = gen_reg_rtx (DImode);
3923   memh = gen_reg_rtx (DImode);
3924   addr = gen_reg_rtx (DImode);
3925   extl = gen_reg_rtx (DImode);
3926   exth = gen_reg_rtx (DImode);
3927
3928   mema = XEXP (mem, 0);
3929   if (GET_CODE (mema) == LO_SUM)
3930     mema = force_reg (Pmode, mema);
3931
3932   /* AND addresses cannot be in any alias set, since they may implicitly
3933      alias surrounding code.  Ideally we'd have some alias set that
3934      covered all types except those with alignment 8 or higher.  */
3935
3936   tmp = change_address (mem, DImode,
3937                         gen_rtx_AND (DImode,
3938                                      plus_constant (mema, ofs),
3939                                      GEN_INT (-8)));
3940   set_mem_alias_set (tmp, 0);
3941   emit_move_insn (meml, tmp);
3942
3943   tmp = change_address (mem, DImode,
3944                         gen_rtx_AND (DImode,
3945                                      plus_constant (mema, ofs + size - 1),
3946                                      GEN_INT (-8)));
3947   set_mem_alias_set (tmp, 0);
3948   emit_move_insn (memh, tmp);
3949
3950   if (WORDS_BIG_ENDIAN && sign && (size == 2 || size == 4))
3951     {
3952       emit_move_insn (addr, plus_constant (mema, -1));
3953
3954       emit_insn (gen_extqh_be (extl, meml, addr));
3955       emit_insn (gen_extxl_be (exth, memh, GEN_INT (64), addr));
3956
3957       addr = expand_binop (DImode, ior_optab, extl, exth, tgt, 1, OPTAB_WIDEN);
3958       addr = expand_binop (DImode, ashr_optab, addr, GEN_INT (64 - size*8),
3959                            addr, 1, OPTAB_WIDEN);
3960     }
3961   else if (sign && size == 2)
3962     {
3963       emit_move_insn (addr, plus_constant (mema, ofs+2));
3964
3965       emit_insn (gen_extxl_le (extl, meml, GEN_INT (64), addr));
3966       emit_insn (gen_extqh_le (exth, memh, addr));
3967
3968       /* We must use tgt here for the target.  Alpha-vms port fails if we use
3969          addr for the target, because addr is marked as a pointer and combine
3970          knows that pointers are always sign-extended 32 bit values.  */
3971       addr = expand_binop (DImode, ior_optab, extl, exth, tgt, 1, OPTAB_WIDEN);
3972       addr = expand_binop (DImode, ashr_optab, addr, GEN_INT (48),
3973                            addr, 1, OPTAB_WIDEN);
3974     }
3975   else
3976     {
3977       if (WORDS_BIG_ENDIAN)
3978         {
3979           emit_move_insn (addr, plus_constant (mema, ofs+size-1));
3980           switch ((int) size)
3981             {
3982             case 2:
3983               emit_insn (gen_extwh_be (extl, meml, addr));
3984               mode = HImode;
3985               break;
3986
3987             case 4:
3988               emit_insn (gen_extlh_be (extl, meml, addr));
3989               mode = SImode;
3990               break;
3991
3992             case 8:
3993               emit_insn (gen_extqh_be (extl, meml, addr));
3994               mode = DImode;
3995               break;
3996
3997             default:
3998               abort ();
3999             }
4000           emit_insn (gen_extxl_be (exth, memh, GEN_INT (size*8), addr));
4001         }
4002       else
4003         {
4004           emit_move_insn (addr, plus_constant (mema, ofs));
4005           emit_insn (gen_extxl_le (extl, meml, GEN_INT (size*8), addr));
4006           switch ((int) size)
4007             {
4008             case 2:
4009               emit_insn (gen_extwh_le (exth, memh, addr));
4010               mode = HImode;
4011               break;
4012
4013             case 4:
4014               emit_insn (gen_extlh_le (exth, memh, addr));
4015               mode = SImode;
4016               break;
4017
4018             case 8:
4019               emit_insn (gen_extqh_le (exth, memh, addr));
4020               mode = DImode;
4021               break;
4022
4023             default:
4024               abort();
4025             }
4026         }
4027
4028       addr = expand_binop (mode, ior_optab, gen_lowpart (mode, extl),
4029                            gen_lowpart (mode, exth), gen_lowpart (mode, tgt),
4030                            sign, OPTAB_WIDEN);
4031     }
4032
4033   if (addr != tgt)
4034     emit_move_insn (tgt, gen_lowpart(GET_MODE (tgt), addr));
4035 }
4036
4037 /* Similarly, use ins and msk instructions to perform unaligned stores.  */
4038
4039 void
4040 alpha_expand_unaligned_store (rtx dst, rtx src,
4041                               HOST_WIDE_INT size, HOST_WIDE_INT ofs)
4042 {
4043   rtx dstl, dsth, addr, insl, insh, meml, memh, dsta;
4044
4045   dstl = gen_reg_rtx (DImode);
4046   dsth = gen_reg_rtx (DImode);
4047   insl = gen_reg_rtx (DImode);
4048   insh = gen_reg_rtx (DImode);
4049
4050   dsta = XEXP (dst, 0);
4051   if (GET_CODE (dsta) == LO_SUM)
4052     dsta = force_reg (Pmode, dsta);
4053
4054   /* AND addresses cannot be in any alias set, since they may implicitly
4055      alias surrounding code.  Ideally we'd have some alias set that
4056      covered all types except those with alignment 8 or higher.  */
4057
4058   meml = change_address (dst, DImode,
4059                          gen_rtx_AND (DImode,
4060                                       plus_constant (dsta, ofs),
4061                                       GEN_INT (-8)));
4062   set_mem_alias_set (meml, 0);
4063
4064   memh = change_address (dst, DImode,
4065                          gen_rtx_AND (DImode,
4066                                       plus_constant (dsta, ofs + size - 1),
4067                                       GEN_INT (-8)));
4068   set_mem_alias_set (memh, 0);
4069
4070   emit_move_insn (dsth, memh);
4071   emit_move_insn (dstl, meml);
4072   if (WORDS_BIG_ENDIAN)
4073     {
4074       addr = copy_addr_to_reg (plus_constant (dsta, ofs+size-1));
4075
4076       if (src != const0_rtx)
4077         {
4078           switch ((int) size)
4079             {
4080             case 2:
4081               emit_insn (gen_inswl_be (insh, gen_lowpart (HImode,src), addr));
4082               break;
4083             case 4:
4084               emit_insn (gen_insll_be (insh, gen_lowpart (SImode,src), addr));
4085               break;
4086             case 8:
4087               emit_insn (gen_insql_be (insh, gen_lowpart (DImode,src), addr));
4088               break;
4089             }
4090           emit_insn (gen_insxh (insl, gen_lowpart (DImode, src),
4091                                 GEN_INT (size*8), addr));
4092         }
4093
4094       switch ((int) size)
4095         {
4096         case 2:
4097           emit_insn (gen_mskxl_be (dsth, dsth, GEN_INT (0xffff), addr));
4098           break;
4099         case 4:
4100           {
4101             rtx msk = immed_double_const (0xffffffff, 0, DImode);
4102             emit_insn (gen_mskxl_be (dsth, dsth, msk, addr));
4103             break;
4104           }
4105         case 8:
4106           emit_insn (gen_mskxl_be (dsth, dsth, constm1_rtx, addr));
4107           break;
4108         }
4109
4110       emit_insn (gen_mskxh (dstl, dstl, GEN_INT (size*8), addr));
4111     }
4112   else
4113     {
4114       addr = copy_addr_to_reg (plus_constant (dsta, ofs));
4115
4116       if (src != const0_rtx)
4117         {
4118           emit_insn (gen_insxh (insh, gen_lowpart (DImode, src),
4119                                 GEN_INT (size*8), addr));
4120
4121           switch ((int) size)
4122             {
4123             case 2:
4124               emit_insn (gen_inswl_le (insl, gen_lowpart (HImode, src), addr));
4125               break;
4126             case 4:
4127               emit_insn (gen_insll_le (insl, gen_lowpart (SImode, src), addr));
4128               break;
4129             case 8:
4130               emit_insn (gen_insql_le (insl, src, addr));
4131               break;
4132             }
4133         }
4134
4135       emit_insn (gen_mskxh (dsth, dsth, GEN_INT (size*8), addr));
4136
4137       switch ((int) size)
4138         {
4139         case 2:
4140           emit_insn (gen_mskxl_le (dstl, dstl, GEN_INT (0xffff), addr));
4141           break;
4142         case 4:
4143           {
4144             rtx msk = immed_double_const (0xffffffff, 0, DImode);
4145             emit_insn (gen_mskxl_le (dstl, dstl, msk, addr));
4146             break;
4147           }
4148         case 8:
4149           emit_insn (gen_mskxl_le (dstl, dstl, constm1_rtx, addr));
4150           break;
4151         }
4152     }
4153
4154   if (src != const0_rtx)
4155     {
4156       dsth = expand_binop (DImode, ior_optab, insh, dsth, dsth, 0, OPTAB_WIDEN);
4157       dstl = expand_binop (DImode, ior_optab, insl, dstl, dstl, 0, OPTAB_WIDEN);
4158     }
4159
4160   if (WORDS_BIG_ENDIAN)
4161     {
4162       emit_move_insn (meml, dstl);
4163       emit_move_insn (memh, dsth);
4164     }
4165   else
4166     {
4167       /* Must store high before low for degenerate case of aligned.  */
4168       emit_move_insn (memh, dsth);
4169       emit_move_insn (meml, dstl);
4170     }
4171 }
4172
4173 /* The block move code tries to maximize speed by separating loads and
4174    stores at the expense of register pressure: we load all of the data
4175    before we store it back out.  There are two secondary effects worth
4176    mentioning, that this speeds copying to/from aligned and unaligned
4177    buffers, and that it makes the code significantly easier to write.  */
4178
4179 #define MAX_MOVE_WORDS  8
4180
4181 /* Load an integral number of consecutive unaligned quadwords.  */
4182
4183 static void
4184 alpha_expand_unaligned_load_words (rtx *out_regs, rtx smem,
4185                                    HOST_WIDE_INT words, HOST_WIDE_INT ofs)
4186 {
4187   rtx const im8 = GEN_INT (-8);
4188   rtx const i64 = GEN_INT (64);
4189   rtx ext_tmps[MAX_MOVE_WORDS], data_regs[MAX_MOVE_WORDS+1];
4190   rtx sreg, areg, tmp, smema;
4191   HOST_WIDE_INT i;
4192
4193   smema = XEXP (smem, 0);
4194   if (GET_CODE (smema) == LO_SUM)
4195     smema = force_reg (Pmode, smema);
4196
4197   /* Generate all the tmp registers we need.  */
4198   for (i = 0; i < words; ++i)
4199     {
4200       data_regs[i] = out_regs[i];
4201       ext_tmps[i] = gen_reg_rtx (DImode);
4202     }
4203   data_regs[words] = gen_reg_rtx (DImode);
4204
4205   if (ofs != 0)
4206     smem = adjust_address (smem, GET_MODE (smem), ofs);
4207
4208   /* Load up all of the source data.  */
4209   for (i = 0; i < words; ++i)
4210     {
4211       tmp = change_address (smem, DImode,
4212                             gen_rtx_AND (DImode,
4213                                          plus_constant (smema, 8*i),
4214                                          im8));
4215       set_mem_alias_set (tmp, 0);
4216       emit_move_insn (data_regs[i], tmp);
4217     }
4218
4219   tmp = change_address (smem, DImode,
4220                         gen_rtx_AND (DImode,
4221                                      plus_constant (smema, 8*words - 1),
4222                                      im8));
4223   set_mem_alias_set (tmp, 0);
4224   emit_move_insn (data_regs[words], tmp);
4225
4226   /* Extract the half-word fragments.  Unfortunately DEC decided to make
4227      extxh with offset zero a noop instead of zeroing the register, so
4228      we must take care of that edge condition ourselves with cmov.  */
4229
4230   sreg = copy_addr_to_reg (smema);
4231   areg = expand_binop (DImode, and_optab, sreg, GEN_INT (7), NULL,
4232                        1, OPTAB_WIDEN);
4233   if (WORDS_BIG_ENDIAN)
4234     emit_move_insn (sreg, plus_constant (sreg, 7));
4235   for (i = 0; i < words; ++i)
4236     {
4237       if (WORDS_BIG_ENDIAN)
4238         {
4239           emit_insn (gen_extqh_be (data_regs[i], data_regs[i], sreg));
4240           emit_insn (gen_extxl_be (ext_tmps[i], data_regs[i+1], i64, sreg));
4241         }
4242       else
4243         {
4244           emit_insn (gen_extxl_le (data_regs[i], data_regs[i], i64, sreg));
4245           emit_insn (gen_extqh_le (ext_tmps[i], data_regs[i+1], sreg));
4246         }
4247       emit_insn (gen_rtx_SET (VOIDmode, ext_tmps[i],
4248                               gen_rtx_IF_THEN_ELSE (DImode,
4249                                                     gen_rtx_EQ (DImode, areg,
4250                                                                 const0_rtx),
4251                                                     const0_rtx, ext_tmps[i])));
4252     }
4253
4254   /* Merge the half-words into whole words.  */
4255   for (i = 0; i < words; ++i)
4256     {
4257       out_regs[i] = expand_binop (DImode, ior_optab, data_regs[i],
4258                                   ext_tmps[i], data_regs[i], 1, OPTAB_WIDEN);
4259     }
4260 }
4261
4262 /* Store an integral number of consecutive unaligned quadwords.  DATA_REGS
4263    may be NULL to store zeros.  */
4264
4265 static void
4266 alpha_expand_unaligned_store_words (rtx *data_regs, rtx dmem,
4267                                     HOST_WIDE_INT words, HOST_WIDE_INT ofs)
4268 {
4269   rtx const im8 = GEN_INT (-8);
4270   rtx const i64 = GEN_INT (64);
4271   rtx ins_tmps[MAX_MOVE_WORDS];
4272   rtx st_tmp_1, st_tmp_2, dreg;
4273   rtx st_addr_1, st_addr_2, dmema;
4274   HOST_WIDE_INT i;
4275
4276   dmema = XEXP (dmem, 0);
4277   if (GET_CODE (dmema) == LO_SUM)
4278     dmema = force_reg (Pmode, dmema);
4279
4280   /* Generate all the tmp registers we need.  */
4281   if (data_regs != NULL)
4282     for (i = 0; i < words; ++i)
4283       ins_tmps[i] = gen_reg_rtx(DImode);
4284   st_tmp_1 = gen_reg_rtx(DImode);
4285   st_tmp_2 = gen_reg_rtx(DImode);
4286
4287   if (ofs != 0)
4288     dmem = adjust_address (dmem, GET_MODE (dmem), ofs);
4289
4290   st_addr_2 = change_address (dmem, DImode,
4291                               gen_rtx_AND (DImode,
4292                                            plus_constant (dmema, words*8 - 1),
4293                                        im8));
4294   set_mem_alias_set (st_addr_2, 0);
4295
4296   st_addr_1 = change_address (dmem, DImode,
4297                               gen_rtx_AND (DImode, dmema, im8));
4298   set_mem_alias_set (st_addr_1, 0);
4299
4300   /* Load up the destination end bits.  */
4301   emit_move_insn (st_tmp_2, st_addr_2);
4302   emit_move_insn (st_tmp_1, st_addr_1);
4303
4304   /* Shift the input data into place.  */
4305   dreg = copy_addr_to_reg (dmema);
4306   if (WORDS_BIG_ENDIAN)
4307     emit_move_insn (dreg, plus_constant (dreg, 7));
4308   if (data_regs != NULL)
4309     {
4310       for (i = words-1; i >= 0; --i)
4311         {
4312           if (WORDS_BIG_ENDIAN)
4313             {
4314               emit_insn (gen_insql_be (ins_tmps[i], data_regs[i], dreg));
4315               emit_insn (gen_insxh (data_regs[i], data_regs[i], i64, dreg));
4316             }
4317           else
4318             {
4319               emit_insn (gen_insxh (ins_tmps[i], data_regs[i], i64, dreg));
4320               emit_insn (gen_insql_le (data_regs[i], data_regs[i], dreg));
4321             }
4322         }
4323       for (i = words-1; i > 0; --i)
4324         {
4325           ins_tmps[i-1] = expand_binop (DImode, ior_optab, data_regs[i],
4326                                         ins_tmps[i-1], ins_tmps[i-1], 1,
4327                                         OPTAB_WIDEN);
4328         }
4329     }
4330
4331   /* Split and merge the ends with the destination data.  */
4332   if (WORDS_BIG_ENDIAN)
4333     {
4334       emit_insn (gen_mskxl_be (st_tmp_2, st_tmp_2, constm1_rtx, dreg));
4335       emit_insn (gen_mskxh (st_tmp_1, st_tmp_1, i64, dreg));
4336     }
4337   else
4338     {
4339       emit_insn (gen_mskxh (st_tmp_2, st_tmp_2, i64, dreg));
4340       emit_insn (gen_mskxl_le (st_tmp_1, st_tmp_1, constm1_rtx, dreg));
4341     }
4342
4343   if (data_regs != NULL)
4344     {
4345       st_tmp_2 = expand_binop (DImode, ior_optab, st_tmp_2, ins_tmps[words-1],
4346                                st_tmp_2, 1, OPTAB_WIDEN);
4347       st_tmp_1 = expand_binop (DImode, ior_optab, st_tmp_1, data_regs[0],
4348                                st_tmp_1, 1, OPTAB_WIDEN);
4349     }
4350
4351   /* Store it all.  */
4352   if (WORDS_BIG_ENDIAN)
4353     emit_move_insn (st_addr_1, st_tmp_1);
4354   else
4355     emit_move_insn (st_addr_2, st_tmp_2);
4356   for (i = words-1; i > 0; --i)
4357     {
4358       rtx tmp = change_address (dmem, DImode,
4359                                 gen_rtx_AND (DImode,
4360                                              plus_constant(dmema,
4361                                              WORDS_BIG_ENDIAN ? i*8-1 : i*8),
4362                                              im8));
4363       set_mem_alias_set (tmp, 0);
4364       emit_move_insn (tmp, data_regs ? ins_tmps[i-1] : const0_rtx);
4365     }
4366   if (WORDS_BIG_ENDIAN)
4367     emit_move_insn (st_addr_2, st_tmp_2);
4368   else
4369     emit_move_insn (st_addr_1, st_tmp_1);
4370 }
4371
4372
4373 /* Expand string/block move operations.
4374
4375    operands[0] is the pointer to the destination.
4376    operands[1] is the pointer to the source.
4377    operands[2] is the number of bytes to move.
4378    operands[3] is the alignment.  */
4379
4380 int
4381 alpha_expand_block_move (rtx operands[])
4382 {
4383   rtx bytes_rtx = operands[2];
4384   rtx align_rtx = operands[3];
4385   HOST_WIDE_INT orig_bytes = INTVAL (bytes_rtx);
4386   HOST_WIDE_INT bytes = orig_bytes;
4387   HOST_WIDE_INT src_align = INTVAL (align_rtx) * BITS_PER_UNIT;
4388   HOST_WIDE_INT dst_align = src_align;
4389   rtx orig_src = operands[1];
4390   rtx orig_dst = operands[0];
4391   rtx data_regs[2 * MAX_MOVE_WORDS + 16];
4392   rtx tmp;
4393   unsigned int i, words, ofs, nregs = 0;
4394
4395   if (orig_bytes <= 0)
4396     return 1;
4397   else if (orig_bytes > MAX_MOVE_WORDS * UNITS_PER_WORD)
4398     return 0;
4399
4400   /* Look for additional alignment information from recorded register info.  */
4401
4402   tmp = XEXP (orig_src, 0);
4403   if (GET_CODE (tmp) == REG)
4404     src_align = MAX (src_align, REGNO_POINTER_ALIGN (REGNO (tmp)));
4405   else if (GET_CODE (tmp) == PLUS
4406            && GET_CODE (XEXP (tmp, 0)) == REG
4407            && GET_CODE (XEXP (tmp, 1)) == CONST_INT)
4408     {
4409       unsigned HOST_WIDE_INT c = INTVAL (XEXP (tmp, 1));
4410       unsigned int a = REGNO_POINTER_ALIGN (REGNO (XEXP (tmp, 0)));
4411
4412       if (a > src_align)
4413         {
4414           if (a >= 64 && c % 8 == 0)
4415             src_align = 64;
4416           else if (a >= 32 && c % 4 == 0)
4417             src_align = 32;
4418           else if (a >= 16 && c % 2 == 0)
4419             src_align = 16;
4420         }
4421     }
4422
4423   tmp = XEXP (orig_dst, 0);
4424   if (GET_CODE (tmp) == REG)
4425     dst_align = MAX (dst_align, REGNO_POINTER_ALIGN (REGNO (tmp)));
4426   else if (GET_CODE (tmp) == PLUS
4427            && GET_CODE (XEXP (tmp, 0)) == REG
4428            && GET_CODE (XEXP (tmp, 1)) == CONST_INT)
4429     {
4430       unsigned HOST_WIDE_INT c = INTVAL (XEXP (tmp, 1));
4431       unsigned int a = REGNO_POINTER_ALIGN (REGNO (XEXP (tmp, 0)));
4432
4433       if (a > dst_align)
4434         {
4435           if (a >= 64 && c % 8 == 0)
4436             dst_align = 64;
4437           else if (a >= 32 && c % 4 == 0)
4438             dst_align = 32;
4439           else if (a >= 16 && c % 2 == 0)
4440             dst_align = 16;
4441         }
4442     }
4443
4444   /* Load the entire block into registers.  */
4445   if (GET_CODE (XEXP (orig_src, 0)) == ADDRESSOF)
4446     {
4447       enum machine_mode mode;
4448
4449       tmp = XEXP (XEXP (orig_src, 0), 0);
4450
4451       /* Don't use the existing register if we're reading more than
4452          is held in the register.  Nor if there is not a mode that
4453          handles the exact size.  */
4454       mode = mode_for_size (bytes * BITS_PER_UNIT, MODE_INT, 1);
4455       if (mode != BLKmode
4456           && GET_MODE_SIZE (GET_MODE (tmp)) >= bytes)
4457         {
4458           if (mode == TImode)
4459             {
4460               data_regs[nregs] = gen_lowpart (DImode, tmp);
4461               data_regs[nregs + 1] = gen_highpart (DImode, tmp);
4462               nregs += 2;
4463             }
4464           else
4465             data_regs[nregs++] = gen_lowpart (mode, tmp);
4466
4467           goto src_done;
4468         }
4469
4470       /* No appropriate mode; fall back on memory.  */
4471       orig_src = replace_equiv_address (orig_src,
4472                                         copy_addr_to_reg (XEXP (orig_src, 0)));
4473       src_align = GET_MODE_BITSIZE (GET_MODE (tmp));
4474     }
4475
4476   ofs = 0;
4477   if (src_align >= 64 && bytes >= 8)
4478     {
4479       words = bytes / 8;
4480
4481       for (i = 0; i < words; ++i)
4482         data_regs[nregs + i] = gen_reg_rtx (DImode);
4483
4484       for (i = 0; i < words; ++i)
4485         emit_move_insn (data_regs[nregs + i],
4486                         adjust_address (orig_src, DImode, ofs + i * 8));
4487
4488       nregs += words;
4489       bytes -= words * 8;
4490       ofs += words * 8;
4491     }
4492
4493   if (src_align >= 32 && bytes >= 4)
4494     {
4495       words = bytes / 4;
4496
4497       for (i = 0; i < words; ++i)
4498         data_regs[nregs + i] = gen_reg_rtx (SImode);
4499
4500       for (i = 0; i < words; ++i)
4501         emit_move_insn (data_regs[nregs + i],
4502                         adjust_address (orig_src, SImode, ofs + i * 4));
4503
4504       nregs += words;
4505       bytes -= words * 4;
4506       ofs += words * 4;
4507     }
4508
4509   if (bytes >= 8)
4510     {
4511       words = bytes / 8;
4512
4513       for (i = 0; i < words+1; ++i)
4514         data_regs[nregs + i] = gen_reg_rtx (DImode);
4515
4516       alpha_expand_unaligned_load_words (data_regs + nregs, orig_src,
4517                                          words, ofs);
4518
4519       nregs += words;
4520       bytes -= words * 8;
4521       ofs += words * 8;
4522     }
4523
4524   if (! TARGET_BWX && bytes >= 4)
4525     {
4526       data_regs[nregs++] = tmp = gen_reg_rtx (SImode);
4527       alpha_expand_unaligned_load (tmp, orig_src, 4, ofs, 0);
4528       bytes -= 4;
4529       ofs += 4;
4530     }
4531
4532   if (bytes >= 2)
4533     {
4534       if (src_align >= 16)
4535         {
4536           do {
4537             data_regs[nregs++] = tmp = gen_reg_rtx (HImode);
4538             emit_move_insn (tmp, adjust_address (orig_src, HImode, ofs));
4539             bytes -= 2;
4540             ofs += 2;
4541           } while (bytes >= 2);
4542         }
4543       else if (! TARGET_BWX)
4544         {
4545           data_regs[nregs++] = tmp = gen_reg_rtx (HImode);
4546           alpha_expand_unaligned_load (tmp, orig_src, 2, ofs, 0);
4547           bytes -= 2;
4548           ofs += 2;
4549         }
4550     }
4551
4552   while (bytes > 0)
4553     {
4554       data_regs[nregs++] = tmp = gen_reg_rtx (QImode);
4555       emit_move_insn (tmp, adjust_address (orig_src, QImode, ofs));
4556       bytes -= 1;
4557       ofs += 1;
4558     }
4559
4560  src_done:
4561
4562   if (nregs > ARRAY_SIZE (data_regs))
4563     abort ();
4564
4565   /* Now save it back out again.  */
4566
4567   i = 0, ofs = 0;
4568
4569   if (GET_CODE (XEXP (orig_dst, 0)) == ADDRESSOF)
4570     {
4571       enum machine_mode mode;
4572       tmp = XEXP (XEXP (orig_dst, 0), 0);
4573
4574       mode = mode_for_size (orig_bytes * BITS_PER_UNIT, MODE_INT, 1);
4575       if (GET_MODE (tmp) == mode)
4576         {
4577           if (nregs == 1)
4578             {
4579               emit_move_insn (tmp, data_regs[0]);
4580               i = 1;
4581               goto dst_done;
4582             }
4583
4584           else if (nregs == 2 && mode == TImode)
4585             {
4586               /* Undo the subregging done above when copying between
4587                  two TImode registers.  */
4588               if (GET_CODE (data_regs[0]) == SUBREG
4589                   && GET_MODE (SUBREG_REG (data_regs[0])) == TImode)
4590                 emit_move_insn (tmp, SUBREG_REG (data_regs[0]));
4591               else
4592                 {
4593                   rtx seq;
4594
4595                   start_sequence ();
4596                   emit_move_insn (gen_lowpart (DImode, tmp), data_regs[0]);
4597                   emit_move_insn (gen_highpart (DImode, tmp), data_regs[1]);
4598                   seq = get_insns ();
4599                   end_sequence ();
4600
4601                   emit_no_conflict_block (seq, tmp, data_regs[0],
4602                                           data_regs[1], NULL_RTX);
4603                 }
4604
4605               i = 2;
4606               goto dst_done;
4607             }
4608         }
4609
4610       /* ??? If nregs > 1, consider reconstructing the word in regs.  */
4611       /* ??? Optimize mode < dst_mode with strict_low_part.  */
4612
4613       /* No appropriate mode; fall back on memory.  We can speed things
4614          up by recognizing extra alignment information.  */
4615       orig_dst = replace_equiv_address (orig_dst,
4616                                         copy_addr_to_reg (XEXP (orig_dst, 0)));
4617       dst_align = GET_MODE_BITSIZE (GET_MODE (tmp));
4618     }
4619
4620   /* Write out the data in whatever chunks reading the source allowed.  */
4621   if (dst_align >= 64)
4622     {
4623       while (i < nregs && GET_MODE (data_regs[i]) == DImode)
4624         {
4625           emit_move_insn (adjust_address (orig_dst, DImode, ofs),
4626                           data_regs[i]);
4627           ofs += 8;
4628           i++;
4629         }
4630     }
4631
4632   if (dst_align >= 32)
4633     {
4634       /* If the source has remaining DImode regs, write them out in
4635          two pieces.  */
4636       while (i < nregs && GET_MODE (data_regs[i]) == DImode)
4637         {
4638           tmp = expand_binop (DImode, lshr_optab, data_regs[i], GEN_INT (32),
4639                               NULL_RTX, 1, OPTAB_WIDEN);
4640
4641           emit_move_insn (adjust_address (orig_dst, SImode, ofs),
4642                           gen_lowpart (SImode, data_regs[i]));
4643           emit_move_insn (adjust_address (orig_dst, SImode, ofs + 4),
4644                           gen_lowpart (SImode, tmp));
4645           ofs += 8;
4646           i++;
4647         }
4648
4649       while (i < nregs && GET_MODE (data_regs[i]) == SImode)
4650         {
4651           emit_move_insn (adjust_address (orig_dst, SImode, ofs),
4652                           data_regs[i]);
4653           ofs += 4;
4654           i++;
4655         }
4656     }
4657
4658   if (i < nregs && GET_MODE (data_regs[i]) == DImode)
4659     {
4660       /* Write out a remaining block of words using unaligned methods.  */
4661
4662       for (words = 1; i + words < nregs; words++)
4663         if (GET_MODE (data_regs[i + words]) != DImode)
4664           break;
4665
4666       if (words == 1)
4667         alpha_expand_unaligned_store (orig_dst, data_regs[i], 8, ofs);
4668       else
4669         alpha_expand_unaligned_store_words (data_regs + i, orig_dst,
4670                                             words, ofs);
4671
4672       i += words;
4673       ofs += words * 8;
4674     }
4675
4676   /* Due to the above, this won't be aligned.  */
4677   /* ??? If we have more than one of these, consider constructing full
4678      words in registers and using alpha_expand_unaligned_store_words.  */
4679   while (i < nregs && GET_MODE (data_regs[i]) == SImode)
4680     {
4681       alpha_expand_unaligned_store (orig_dst, data_regs[i], 4, ofs);
4682       ofs += 4;
4683       i++;
4684     }
4685
4686   if (dst_align >= 16)
4687     while (i < nregs && GET_MODE (data_regs[i]) == HImode)
4688       {
4689         emit_move_insn (adjust_address (orig_dst, HImode, ofs), data_regs[i]);
4690         i++;
4691         ofs += 2;
4692       }
4693   else
4694     while (i < nregs && GET_MODE (data_regs[i]) == HImode)
4695       {
4696         alpha_expand_unaligned_store (orig_dst, data_regs[i], 2, ofs);
4697         i++;
4698         ofs += 2;
4699       }
4700
4701   while (i < nregs && GET_MODE (data_regs[i]) == QImode)
4702     {
4703       emit_move_insn (adjust_address (orig_dst, QImode, ofs), data_regs[i]);
4704       i++;
4705       ofs += 1;
4706     }
4707
4708  dst_done:
4709
4710   if (i != nregs)
4711     abort ();
4712
4713   return 1;
4714 }
4715
4716 int
4717 alpha_expand_block_clear (rtx operands[])
4718 {
4719   rtx bytes_rtx = operands[1];
4720   rtx align_rtx = operands[2];
4721   HOST_WIDE_INT orig_bytes = INTVAL (bytes_rtx);
4722   HOST_WIDE_INT bytes = orig_bytes;
4723   HOST_WIDE_INT align = INTVAL (align_rtx) * BITS_PER_UNIT;
4724   HOST_WIDE_INT alignofs = 0;
4725   rtx orig_dst = operands[0];
4726   rtx tmp;
4727   int i, words, ofs = 0;
4728
4729   if (orig_bytes <= 0)
4730     return 1;
4731   if (orig_bytes > MAX_MOVE_WORDS * UNITS_PER_WORD)
4732     return 0;
4733
4734   /* Look for stricter alignment.  */
4735   tmp = XEXP (orig_dst, 0);
4736   if (GET_CODE (tmp) == REG)
4737     align = MAX (align, REGNO_POINTER_ALIGN (REGNO (tmp)));
4738   else if (GET_CODE (tmp) == PLUS
4739            && GET_CODE (XEXP (tmp, 0)) == REG
4740            && GET_CODE (XEXP (tmp, 1)) == CONST_INT)
4741     {
4742       HOST_WIDE_INT c = INTVAL (XEXP (tmp, 1));
4743       int a = REGNO_POINTER_ALIGN (REGNO (XEXP (tmp, 0)));
4744
4745       if (a > align)
4746         {
4747           if (a >= 64)
4748             align = a, alignofs = 8 - c % 8;
4749           else if (a >= 32)
4750             align = a, alignofs = 4 - c % 4;
4751           else if (a >= 16)
4752             align = a, alignofs = 2 - c % 2;
4753         }
4754     }
4755   else if (GET_CODE (tmp) == ADDRESSOF)
4756     {
4757       enum machine_mode mode;
4758
4759       mode = mode_for_size (bytes * BITS_PER_UNIT, MODE_INT, 1);
4760       if (GET_MODE (XEXP (tmp, 0)) == mode)
4761         {
4762           emit_move_insn (XEXP (tmp, 0), const0_rtx);
4763           return 1;
4764         }
4765
4766       /* No appropriate mode; fall back on memory.  */
4767       orig_dst = replace_equiv_address (orig_dst, copy_addr_to_reg (tmp));
4768       align = GET_MODE_BITSIZE (GET_MODE (XEXP (tmp, 0)));
4769     }
4770
4771   /* Handle an unaligned prefix first.  */
4772
4773   if (alignofs > 0)
4774     {
4775 #if HOST_BITS_PER_WIDE_INT >= 64
4776       /* Given that alignofs is bounded by align, the only time BWX could
4777          generate three stores is for a 7 byte fill.  Prefer two individual
4778          stores over a load/mask/store sequence.  */
4779       if ((!TARGET_BWX || alignofs == 7)
4780                && align >= 32
4781                && !(alignofs == 4 && bytes >= 4))
4782         {
4783           enum machine_mode mode = (align >= 64 ? DImode : SImode);
4784           int inv_alignofs = (align >= 64 ? 8 : 4) - alignofs;
4785           rtx mem, tmp;
4786           HOST_WIDE_INT mask;
4787
4788           mem = adjust_address (orig_dst, mode, ofs - inv_alignofs);
4789           set_mem_alias_set (mem, 0);
4790
4791           mask = ~(~(HOST_WIDE_INT)0 << (inv_alignofs * 8));
4792           if (bytes < alignofs)
4793             {
4794               mask |= ~(HOST_WIDE_INT)0 << ((inv_alignofs + bytes) * 8);
4795               ofs += bytes;
4796               bytes = 0;
4797             }
4798           else
4799             {
4800               bytes -= alignofs;
4801               ofs += alignofs;
4802             }
4803           alignofs = 0;
4804
4805           tmp = expand_binop (mode, and_optab, mem, GEN_INT (mask),
4806                               NULL_RTX, 1, OPTAB_WIDEN);
4807
4808           emit_move_insn (mem, tmp);
4809         }
4810 #endif
4811
4812       if (TARGET_BWX && (alignofs & 1) && bytes >= 1)
4813         {
4814           emit_move_insn (adjust_address (orig_dst, QImode, ofs), const0_rtx);
4815           bytes -= 1;
4816           ofs += 1;
4817           alignofs -= 1;
4818         }
4819       if (TARGET_BWX && align >= 16 && (alignofs & 3) == 2 && bytes >= 2)
4820         {
4821           emit_move_insn (adjust_address (orig_dst, HImode, ofs), const0_rtx);
4822           bytes -= 2;
4823           ofs += 2;
4824           alignofs -= 2;
4825         }
4826       if (alignofs == 4 && bytes >= 4)
4827         {
4828           emit_move_insn (adjust_address (orig_dst, SImode, ofs), const0_rtx);
4829           bytes -= 4;
4830           ofs += 4;
4831           alignofs = 0;
4832         }
4833
4834       /* If we've not used the extra lead alignment information by now,
4835          we won't be able to.  Downgrade align to match what's left over.  */
4836       if (alignofs > 0)
4837         {
4838           alignofs = alignofs & -alignofs;
4839           align = MIN (align, alignofs * BITS_PER_UNIT);
4840         }
4841     }
4842
4843   /* Handle a block of contiguous long-words.  */
4844
4845   if (align >= 64 && bytes >= 8)
4846     {
4847       words = bytes / 8;
4848
4849       for (i = 0; i < words; ++i)
4850         emit_move_insn (adjust_address (orig_dst, DImode, ofs + i * 8),
4851                         const0_rtx);
4852
4853       bytes -= words * 8;
4854       ofs += words * 8;
4855     }
4856
4857   /* If the block is large and appropriately aligned, emit a single
4858      store followed by a sequence of stq_u insns.  */
4859
4860   if (align >= 32 && bytes > 16)
4861     {
4862       rtx orig_dsta;
4863
4864       emit_move_insn (adjust_address (orig_dst, SImode, ofs), const0_rtx);
4865       bytes -= 4;
4866       ofs += 4;
4867
4868       orig_dsta = XEXP (orig_dst, 0);
4869       if (GET_CODE (orig_dsta) == LO_SUM)
4870         orig_dsta = force_reg (Pmode, orig_dsta);
4871
4872       words = bytes / 8;
4873       for (i = 0; i < words; ++i)
4874         {
4875           rtx mem
4876             = change_address (orig_dst, DImode,
4877                               gen_rtx_AND (DImode,
4878                                            plus_constant (orig_dsta, ofs + i*8),
4879                                            GEN_INT (-8)));
4880           set_mem_alias_set (mem, 0);
4881           emit_move_insn (mem, const0_rtx);
4882         }
4883
4884       /* Depending on the alignment, the first stq_u may have overlapped
4885          with the initial stl, which means that the last stq_u didn't
4886          write as much as it would appear.  Leave those questionable bytes
4887          unaccounted for.  */
4888       bytes -= words * 8 - 4;
4889       ofs += words * 8 - 4;
4890     }
4891
4892   /* Handle a smaller block of aligned words.  */
4893
4894   if ((align >= 64 && bytes == 4)
4895       || (align == 32 && bytes >= 4))
4896     {
4897       words = bytes / 4;
4898
4899       for (i = 0; i < words; ++i)
4900         emit_move_insn (adjust_address (orig_dst, SImode, ofs + i * 4),
4901                         const0_rtx);
4902
4903       bytes -= words * 4;
4904       ofs += words * 4;
4905     }
4906
4907   /* An unaligned block uses stq_u stores for as many as possible.  */
4908
4909   if (bytes >= 8)
4910     {
4911       words = bytes / 8;
4912
4913       alpha_expand_unaligned_store_words (NULL, orig_dst, words, ofs);
4914
4915       bytes -= words * 8;
4916       ofs += words * 8;
4917     }
4918
4919   /* Next clean up any trailing pieces.  */
4920
4921 #if HOST_BITS_PER_WIDE_INT >= 64
4922   /* Count the number of bits in BYTES for which aligned stores could
4923      be emitted.  */
4924   words = 0;
4925   for (i = (TARGET_BWX ? 1 : 4); i * BITS_PER_UNIT <= align ; i <<= 1)
4926     if (bytes & i)
4927       words += 1;
4928
4929   /* If we have appropriate alignment (and it wouldn't take too many
4930      instructions otherwise), mask out the bytes we need.  */
4931   if (TARGET_BWX ? words > 2 : bytes > 0)
4932     {
4933       if (align >= 64)
4934         {
4935           rtx mem, tmp;
4936           HOST_WIDE_INT mask;
4937
4938           mem = adjust_address (orig_dst, DImode, ofs);
4939           set_mem_alias_set (mem, 0);
4940
4941           mask = ~(HOST_WIDE_INT)0 << (bytes * 8);
4942
4943           tmp = expand_binop (DImode, and_optab, mem, GEN_INT (mask),
4944                               NULL_RTX, 1, OPTAB_WIDEN);
4945
4946           emit_move_insn (mem, tmp);
4947           return 1;
4948         }
4949       else if (align >= 32 && bytes < 4)
4950         {
4951           rtx mem, tmp;
4952           HOST_WIDE_INT mask;
4953
4954           mem = adjust_address (orig_dst, SImode, ofs);
4955           set_mem_alias_set (mem, 0);
4956
4957           mask = ~(HOST_WIDE_INT)0 << (bytes * 8);
4958
4959           tmp = expand_binop (SImode, and_optab, mem, GEN_INT (mask),
4960                               NULL_RTX, 1, OPTAB_WIDEN);
4961
4962           emit_move_insn (mem, tmp);
4963           return 1;
4964         }
4965     }
4966 #endif
4967
4968   if (!TARGET_BWX && bytes >= 4)
4969     {
4970       alpha_expand_unaligned_store (orig_dst, const0_rtx, 4, ofs);
4971       bytes -= 4;
4972       ofs += 4;
4973     }
4974
4975   if (bytes >= 2)
4976     {
4977       if (align >= 16)
4978         {
4979           do {
4980             emit_move_insn (adjust_address (orig_dst, HImode, ofs),
4981                             const0_rtx);
4982             bytes -= 2;
4983             ofs += 2;
4984           } while (bytes >= 2);
4985         }
4986       else if (! TARGET_BWX)
4987         {
4988           alpha_expand_unaligned_store (orig_dst, const0_rtx, 2, ofs);
4989           bytes -= 2;
4990           ofs += 2;
4991         }
4992     }
4993
4994   while (bytes > 0)
4995     {
4996       emit_move_insn (adjust_address (orig_dst, QImode, ofs), const0_rtx);
4997       bytes -= 1;
4998       ofs += 1;
4999     }
5000
5001   return 1;
5002 }
5003
5004 /* Returns a mask so that zap(x, value) == x & mask.  */
5005
5006 rtx
5007 alpha_expand_zap_mask (HOST_WIDE_INT value)
5008 {
5009   rtx result;
5010   int i;
5011
5012   if (HOST_BITS_PER_WIDE_INT >= 64)
5013     {
5014       HOST_WIDE_INT mask = 0;
5015
5016       for (i = 7; i >= 0; --i)
5017         {
5018           mask <<= 8;
5019           if (!((value >> i) & 1))
5020             mask |= 0xff;
5021         }
5022
5023       result = gen_int_mode (mask, DImode);
5024     }
5025   else if (HOST_BITS_PER_WIDE_INT == 32)
5026     {
5027       HOST_WIDE_INT mask_lo = 0, mask_hi = 0;
5028
5029       for (i = 7; i >= 4; --i)
5030         {
5031           mask_hi <<= 8;
5032           if (!((value >> i) & 1))
5033             mask_hi |= 0xff;
5034         }
5035
5036       for (i = 3; i >= 0; --i)
5037         {
5038           mask_lo <<= 8;
5039           if (!((value >> i) & 1))
5040             mask_lo |= 0xff;
5041         }
5042
5043       result = immed_double_const (mask_lo, mask_hi, DImode);
5044     }
5045   else
5046     abort ();
5047
5048   return result;
5049 }
5050
5051 void
5052 alpha_expand_builtin_vector_binop (rtx (*gen) (rtx, rtx, rtx),
5053                                    enum machine_mode mode,
5054                                    rtx op0, rtx op1, rtx op2)
5055 {
5056   op0 = gen_lowpart (mode, op0);
5057
5058   if (op1 == const0_rtx)
5059     op1 = CONST0_RTX (mode);
5060   else
5061     op1 = gen_lowpart (mode, op1);
5062
5063   if (op2 == const0_rtx)
5064     op2 = CONST0_RTX (mode);
5065   else
5066     op2 = gen_lowpart (mode, op2);
5067
5068   emit_insn ((*gen) (op0, op1, op2));
5069 }
5070 \f
5071 /* Adjust the cost of a scheduling dependency.  Return the new cost of
5072    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
5073
5074 static int
5075 alpha_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
5076 {
5077   enum attr_type insn_type, dep_insn_type;
5078
5079   /* If the dependence is an anti-dependence, there is no cost.  For an
5080      output dependence, there is sometimes a cost, but it doesn't seem
5081      worth handling those few cases.  */
5082   if (REG_NOTE_KIND (link) != 0)
5083     return cost;
5084
5085   /* If we can't recognize the insns, we can't really do anything.  */
5086   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
5087     return cost;
5088
5089   insn_type = get_attr_type (insn);
5090   dep_insn_type = get_attr_type (dep_insn);
5091
5092   /* Bring in the user-defined memory latency.  */
5093   if (dep_insn_type == TYPE_ILD
5094       || dep_insn_type == TYPE_FLD
5095       || dep_insn_type == TYPE_LDSYM)
5096     cost += alpha_memory_latency-1;
5097
5098   /* Everything else handled in DFA bypasses now.  */
5099
5100   return cost;
5101 }
5102
5103 /* The number of instructions that can be issued per cycle.  */
5104
5105 static int
5106 alpha_issue_rate (void)
5107 {
5108   return (alpha_cpu == PROCESSOR_EV4 ? 2 : 4);
5109 }
5110
5111 static int
5112 alpha_use_dfa_pipeline_interface (void)
5113 {
5114   return true;
5115 }
5116
5117 /* How many alternative schedules to try.  This should be as wide as the
5118    scheduling freedom in the DFA, but no wider.  Making this value too
5119    large results extra work for the scheduler.
5120
5121    For EV4, loads can be issued to either IB0 or IB1, thus we have 2
5122    alternative schedules.  For EV5, we can choose between E0/E1 and
5123    FA/FM.  For EV6, an arithmetic insn can be issued to U0/U1/L0/L1.  */
5124
5125 static int
5126 alpha_multipass_dfa_lookahead (void)
5127 {
5128   return (alpha_cpu == PROCESSOR_EV6 ? 4 : 2);
5129 }
5130 \f
5131 /* Machine-specific function data.  */
5132
5133 struct machine_function GTY(())
5134 {
5135   /* For unicosmk. */
5136   /* List of call information words for calls from this function.  */
5137   struct rtx_def *first_ciw;
5138   struct rtx_def *last_ciw;
5139   int ciw_count;
5140
5141   /* List of deferred case vectors.  */
5142   struct rtx_def *addr_list;
5143
5144   /* For OSF. */
5145   const char *some_ld_name;
5146 };
5147
5148 /* How to allocate a 'struct machine_function'.  */
5149
5150 static struct machine_function *
5151 alpha_init_machine_status (void)
5152 {
5153   return ((struct machine_function *)
5154                 ggc_alloc_cleared (sizeof (struct machine_function)));
5155 }
5156
5157 /* Functions to save and restore alpha_return_addr_rtx.  */
5158
5159 /* Start the ball rolling with RETURN_ADDR_RTX.  */
5160
5161 rtx
5162 alpha_return_addr (int count, rtx frame ATTRIBUTE_UNUSED)
5163 {
5164   if (count != 0)
5165     return const0_rtx;
5166
5167   return get_hard_reg_initial_val (Pmode, REG_RA);
5168 }
5169
5170 /* Return or create a pseudo containing the gp value for the current
5171    function.  Needed only if TARGET_LD_BUGGY_LDGP.  */
5172
5173 rtx
5174 alpha_gp_save_rtx (void)
5175 {
5176   rtx r = get_hard_reg_initial_val (DImode, 29);
5177   if (GET_CODE (r) != MEM)
5178     r = gen_mem_addressof (r, NULL_TREE, /*rescan=*/true);
5179   return r;
5180 }
5181
5182 static int
5183 alpha_ra_ever_killed (void)
5184 {
5185   rtx top;
5186
5187   if (!has_hard_reg_initial_val (Pmode, REG_RA))
5188     return regs_ever_live[REG_RA];
5189
5190   push_topmost_sequence ();
5191   top = get_insns ();
5192   pop_topmost_sequence ();
5193
5194   return reg_set_between_p (gen_rtx_REG (Pmode, REG_RA), top, NULL_RTX);
5195 }
5196
5197 \f
5198 /* Return the trap mode suffix applicable to the current
5199    instruction, or NULL.  */
5200
5201 static const char *
5202 get_trap_mode_suffix (void)
5203 {
5204   enum attr_trap_suffix s = get_attr_trap_suffix (current_output_insn);
5205
5206   switch (s)
5207     {
5208     case TRAP_SUFFIX_NONE:
5209       return NULL;
5210
5211     case TRAP_SUFFIX_SU:
5212       if (alpha_fptm >= ALPHA_FPTM_SU)
5213         return "su";
5214       return NULL;
5215
5216     case TRAP_SUFFIX_SUI:
5217       if (alpha_fptm >= ALPHA_FPTM_SUI)
5218         return "sui";
5219       return NULL;
5220
5221     case TRAP_SUFFIX_V_SV:
5222       switch (alpha_fptm)
5223         {
5224         case ALPHA_FPTM_N:
5225           return NULL;
5226         case ALPHA_FPTM_U:
5227           return "v";
5228         case ALPHA_FPTM_SU:
5229         case ALPHA_FPTM_SUI:
5230           return "sv";
5231         }
5232       break;
5233
5234     case TRAP_SUFFIX_V_SV_SVI:
5235       switch (alpha_fptm)
5236         {
5237         case ALPHA_FPTM_N:
5238           return NULL;
5239         case ALPHA_FPTM_U:
5240           return "v";
5241         case ALPHA_FPTM_SU:
5242           return "sv";
5243         case ALPHA_FPTM_SUI:
5244           return "svi";
5245         }
5246       break;
5247
5248     case TRAP_SUFFIX_U_SU_SUI:
5249       switch (alpha_fptm)
5250         {
5251         case ALPHA_FPTM_N:
5252           return NULL;
5253         case ALPHA_FPTM_U:
5254           return "u";
5255         case ALPHA_FPTM_SU:
5256           return "su";
5257         case ALPHA_FPTM_SUI:
5258           return "sui";
5259         }
5260       break;
5261     }
5262   abort ();
5263 }
5264
5265 /* Return the rounding mode suffix applicable to the current
5266    instruction, or NULL.  */
5267
5268 static const char *
5269 get_round_mode_suffix (void)
5270 {
5271   enum attr_round_suffix s = get_attr_round_suffix (current_output_insn);
5272
5273   switch (s)
5274     {
5275     case ROUND_SUFFIX_NONE:
5276       return NULL;
5277     case ROUND_SUFFIX_NORMAL:
5278       switch (alpha_fprm)
5279         {
5280         case ALPHA_FPRM_NORM:
5281           return NULL;
5282         case ALPHA_FPRM_MINF:
5283           return "m";
5284         case ALPHA_FPRM_CHOP:
5285           return "c";
5286         case ALPHA_FPRM_DYN:
5287           return "d";
5288         }
5289       break;
5290
5291     case ROUND_SUFFIX_C:
5292       return "c";
5293     }
5294   abort ();
5295 }
5296
5297 /* Locate some local-dynamic symbol still in use by this function
5298    so that we can print its name in some movdi_er_tlsldm pattern.  */
5299
5300 static int
5301 get_some_local_dynamic_name_1 (rtx *px, void *data ATTRIBUTE_UNUSED)
5302 {
5303   rtx x = *px;
5304
5305   if (GET_CODE (x) == SYMBOL_REF
5306       && SYMBOL_REF_TLS_MODEL (x) == TLS_MODEL_LOCAL_DYNAMIC)
5307     {
5308       cfun->machine->some_ld_name = XSTR (x, 0);
5309       return 1;
5310     }
5311
5312   return 0;
5313 }
5314
5315 static const char *
5316 get_some_local_dynamic_name (void)
5317 {
5318   rtx insn;
5319
5320   if (cfun->machine->some_ld_name)
5321     return cfun->machine->some_ld_name;
5322
5323   for (insn = get_insns (); insn ; insn = NEXT_INSN (insn))
5324     if (INSN_P (insn)
5325         && for_each_rtx (&PATTERN (insn), get_some_local_dynamic_name_1, 0))
5326       return cfun->machine->some_ld_name;
5327
5328   abort ();
5329 }
5330
5331 /* Print an operand.  Recognize special options, documented below.  */
5332
5333 void
5334 print_operand (FILE *file, rtx x, int code)
5335 {
5336   int i;
5337
5338   switch (code)
5339     {
5340     case '~':
5341       /* Print the assembler name of the current function.  */
5342       assemble_name (file, alpha_fnname);
5343       break;
5344
5345     case '&':
5346       assemble_name (file, get_some_local_dynamic_name ());
5347       break;
5348
5349     case '/':
5350       {
5351         const char *trap = get_trap_mode_suffix ();
5352         const char *round = get_round_mode_suffix ();
5353
5354         if (trap || round)
5355           fprintf (file, (TARGET_AS_SLASH_BEFORE_SUFFIX ? "/%s%s" : "%s%s"),
5356                    (trap ? trap : ""), (round ? round : ""));
5357         break;
5358       }
5359
5360     case ',':
5361       /* Generates single precision instruction suffix.  */
5362       fputc ((TARGET_FLOAT_VAX ? 'f' : 's'), file);
5363       break;
5364
5365     case '-':
5366       /* Generates double precision instruction suffix.  */
5367       fputc ((TARGET_FLOAT_VAX ? 'g' : 't'), file);
5368       break;
5369
5370     case '+':
5371       /* Generates a nop after a noreturn call at the very end of the
5372          function.  */
5373       if (next_real_insn (current_output_insn) == 0)
5374         fprintf (file, "\n\tnop");
5375       break;
5376
5377     case '#':
5378       if (alpha_this_literal_sequence_number == 0)
5379         alpha_this_literal_sequence_number = alpha_next_sequence_number++;
5380       fprintf (file, "%d", alpha_this_literal_sequence_number);
5381       break;
5382
5383     case '*':
5384       if (alpha_this_gpdisp_sequence_number == 0)
5385         alpha_this_gpdisp_sequence_number = alpha_next_sequence_number++;
5386       fprintf (file, "%d", alpha_this_gpdisp_sequence_number);
5387       break;
5388
5389     case 'H':
5390       if (GET_CODE (x) == HIGH)
5391         output_addr_const (file, XEXP (x, 0));
5392       else
5393         output_operand_lossage ("invalid %%H value");
5394       break;
5395
5396     case 'J':
5397       {
5398         const char *lituse;
5399
5400         if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_TLSGD_CALL)
5401           {
5402             x = XVECEXP (x, 0, 0);
5403             lituse = "lituse_tlsgd";
5404           }
5405         else if (GET_CODE (x) == UNSPEC && XINT (x, 1) == UNSPEC_TLSLDM_CALL)
5406           {
5407             x = XVECEXP (x, 0, 0);
5408             lituse = "lituse_tlsldm";
5409           }
5410         else if (GET_CODE (x) == CONST_INT)
5411           lituse = "lituse_jsr";
5412         else
5413           {
5414             output_operand_lossage ("invalid %%J value");
5415             break;
5416           }
5417
5418         if (x != const0_rtx)
5419           fprintf (file, "\t\t!%s!%d", lituse, (int) INTVAL (x));
5420       }
5421       break;
5422
5423     case 'r':
5424       /* If this operand is the constant zero, write it as "$31".  */
5425       if (GET_CODE (x) == REG)
5426         fprintf (file, "%s", reg_names[REGNO (x)]);
5427       else if (x == CONST0_RTX (GET_MODE (x)))
5428         fprintf (file, "$31");
5429       else
5430         output_operand_lossage ("invalid %%r value");
5431       break;
5432
5433     case 'R':
5434       /* Similar, but for floating-point.  */
5435       if (GET_CODE (x) == REG)
5436         fprintf (file, "%s", reg_names[REGNO (x)]);
5437       else if (x == CONST0_RTX (GET_MODE (x)))
5438         fprintf (file, "$f31");
5439       else
5440         output_operand_lossage ("invalid %%R value");
5441       break;
5442
5443     case 'N':
5444       /* Write the 1's complement of a constant.  */
5445       if (GET_CODE (x) != CONST_INT)
5446         output_operand_lossage ("invalid %%N value");
5447
5448       fprintf (file, HOST_WIDE_INT_PRINT_DEC, ~ INTVAL (x));
5449       break;
5450
5451     case 'P':
5452       /* Write 1 << C, for a constant C.  */
5453       if (GET_CODE (x) != CONST_INT)
5454         output_operand_lossage ("invalid %%P value");
5455
5456       fprintf (file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) 1 << INTVAL (x));
5457       break;
5458
5459     case 'h':
5460       /* Write the high-order 16 bits of a constant, sign-extended.  */
5461       if (GET_CODE (x) != CONST_INT)
5462         output_operand_lossage ("invalid %%h value");
5463
5464       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) >> 16);
5465       break;
5466
5467     case 'L':
5468       /* Write the low-order 16 bits of a constant, sign-extended.  */
5469       if (GET_CODE (x) != CONST_INT)
5470         output_operand_lossage ("invalid %%L value");
5471
5472       fprintf (file, HOST_WIDE_INT_PRINT_DEC,
5473                (INTVAL (x) & 0xffff) - 2 * (INTVAL (x) & 0x8000));
5474       break;
5475
5476     case 'm':
5477       /* Write mask for ZAP insn.  */
5478       if (GET_CODE (x) == CONST_DOUBLE)
5479         {
5480           HOST_WIDE_INT mask = 0;
5481           HOST_WIDE_INT value;
5482
5483           value = CONST_DOUBLE_LOW (x);
5484           for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
5485                i++, value >>= 8)
5486             if (value & 0xff)
5487               mask |= (1 << i);
5488
5489           value = CONST_DOUBLE_HIGH (x);
5490           for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
5491                i++, value >>= 8)
5492             if (value & 0xff)
5493               mask |= (1 << (i + sizeof (int)));
5494
5495           fprintf (file, HOST_WIDE_INT_PRINT_DEC, mask & 0xff);
5496         }
5497
5498       else if (GET_CODE (x) == CONST_INT)
5499         {
5500           HOST_WIDE_INT mask = 0, value = INTVAL (x);
5501
5502           for (i = 0; i < 8; i++, value >>= 8)
5503             if (value & 0xff)
5504               mask |= (1 << i);
5505
5506           fprintf (file, HOST_WIDE_INT_PRINT_DEC, mask);
5507         }
5508       else
5509         output_operand_lossage ("invalid %%m value");
5510       break;
5511
5512     case 'M':
5513       /* 'b', 'w', 'l', or 'q' as the value of the constant.  */
5514       if (GET_CODE (x) != CONST_INT
5515           || (INTVAL (x) != 8 && INTVAL (x) != 16
5516               && INTVAL (x) != 32 && INTVAL (x) != 64))
5517         output_operand_lossage ("invalid %%M value");
5518
5519       fprintf (file, "%s",
5520                (INTVAL (x) == 8 ? "b"
5521                 : INTVAL (x) == 16 ? "w"
5522                 : INTVAL (x) == 32 ? "l"
5523                 : "q"));
5524       break;
5525
5526     case 'U':
5527       /* Similar, except do it from the mask.  */
5528       if (GET_CODE (x) == CONST_INT)
5529         {
5530           HOST_WIDE_INT value = INTVAL (x);
5531
5532           if (value == 0xff)
5533             {
5534               fputc ('b', file);
5535               break;
5536             }
5537           if (value == 0xffff)
5538             {
5539               fputc ('w', file);
5540               break;
5541             }
5542           if (value == 0xffffffff)
5543             {
5544               fputc ('l', file);
5545               break;
5546             }
5547           if (value == -1)
5548             {
5549               fputc ('q', file);
5550               break;
5551             }
5552         }
5553       else if (HOST_BITS_PER_WIDE_INT == 32
5554                && GET_CODE (x) == CONST_DOUBLE
5555                && CONST_DOUBLE_LOW (x) == 0xffffffff
5556                && CONST_DOUBLE_HIGH (x) == 0)
5557         {
5558           fputc ('l', file);
5559           break;
5560         }
5561       output_operand_lossage ("invalid %%U value");
5562       break;
5563
5564     case 's':
5565       /* Write the constant value divided by 8 for little-endian mode or
5566          (56 - value) / 8 for big-endian mode.  */
5567
5568       if (GET_CODE (x) != CONST_INT
5569           || (unsigned HOST_WIDE_INT) INTVAL (x) >= (WORDS_BIG_ENDIAN
5570                                                      ? 56
5571                                                      : 64)
5572           || (INTVAL (x) & 7) != 0)
5573         output_operand_lossage ("invalid %%s value");
5574
5575       fprintf (file, HOST_WIDE_INT_PRINT_DEC,
5576                WORDS_BIG_ENDIAN
5577                ? (56 - INTVAL (x)) / 8
5578                : INTVAL (x) / 8);
5579       break;
5580
5581     case 'S':
5582       /* Same, except compute (64 - c) / 8 */
5583
5584       if (GET_CODE (x) != CONST_INT
5585           && (unsigned HOST_WIDE_INT) INTVAL (x) >= 64
5586           && (INTVAL (x) & 7) != 8)
5587         output_operand_lossage ("invalid %%s value");
5588
5589       fprintf (file, HOST_WIDE_INT_PRINT_DEC, (64 - INTVAL (x)) / 8);
5590       break;
5591
5592     case 't':
5593       {
5594         /* On Unicos/Mk systems: use a DEX expression if the symbol
5595            clashes with a register name.  */
5596         int dex = unicosmk_need_dex (x);
5597         if (dex)
5598           fprintf (file, "DEX(%d)", dex);
5599         else
5600           output_addr_const (file, x);
5601       }
5602       break;
5603
5604     case 'C': case 'D': case 'c': case 'd':
5605       /* Write out comparison name.  */
5606       {
5607         enum rtx_code c = GET_CODE (x);
5608
5609         if (GET_RTX_CLASS (c) != '<')
5610           output_operand_lossage ("invalid %%C value");
5611
5612         else if (code == 'D')
5613           c = reverse_condition (c);
5614         else if (code == 'c')
5615           c = swap_condition (c);
5616         else if (code == 'd')
5617           c = swap_condition (reverse_condition (c));
5618
5619         if (c == LEU)
5620           fprintf (file, "ule");
5621         else if (c == LTU)
5622           fprintf (file, "ult");
5623         else if (c == UNORDERED)
5624           fprintf (file, "un");
5625         else
5626           fprintf (file, "%s", GET_RTX_NAME (c));
5627       }
5628       break;
5629
5630     case 'E':
5631       /* Write the divide or modulus operator.  */
5632       switch (GET_CODE (x))
5633         {
5634         case DIV:
5635           fprintf (file, "div%s", GET_MODE (x) == SImode ? "l" : "q");
5636           break;
5637         case UDIV:
5638           fprintf (file, "div%su", GET_MODE (x) == SImode ? "l" : "q");
5639           break;
5640         case MOD:
5641           fprintf (file, "rem%s", GET_MODE (x) == SImode ? "l" : "q");
5642           break;
5643         case UMOD:
5644           fprintf (file, "rem%su", GET_MODE (x) == SImode ? "l" : "q");
5645           break;
5646         default:
5647           output_operand_lossage ("invalid %%E value");
5648           break;
5649         }
5650       break;
5651
5652     case 'A':
5653       /* Write "_u" for unaligned access.  */
5654       if (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == AND)
5655         fprintf (file, "_u");
5656       break;
5657
5658     case 0:
5659       if (GET_CODE (x) == REG)
5660         fprintf (file, "%s", reg_names[REGNO (x)]);
5661       else if (GET_CODE (x) == MEM)
5662         output_address (XEXP (x, 0));
5663       else if (GET_CODE (x) == CONST && GET_CODE (XEXP (x, 0)) == UNSPEC)
5664         {
5665           switch (XINT (XEXP (x, 0), 1))
5666             {
5667             case UNSPEC_DTPREL:
5668             case UNSPEC_TPREL:
5669               output_addr_const (file, XVECEXP (XEXP (x, 0), 0, 0));
5670               break;
5671             default:
5672               output_operand_lossage ("unknown relocation unspec");
5673               break;
5674             }
5675         }
5676       else
5677         output_addr_const (file, x);
5678       break;
5679
5680     default:
5681       output_operand_lossage ("invalid %%xn code");
5682     }
5683 }
5684
5685 void
5686 print_operand_address (FILE *file, rtx addr)
5687 {
5688   int basereg = 31;
5689   HOST_WIDE_INT offset = 0;
5690
5691   if (GET_CODE (addr) == AND)
5692     addr = XEXP (addr, 0);
5693
5694   if (GET_CODE (addr) == PLUS
5695       && GET_CODE (XEXP (addr, 1)) == CONST_INT)
5696     {
5697       offset = INTVAL (XEXP (addr, 1));
5698       addr = XEXP (addr, 0);
5699     }
5700
5701   if (GET_CODE (addr) == LO_SUM)
5702     {
5703       const char *reloc16, *reloclo;
5704       rtx op1 = XEXP (addr, 1);
5705
5706       if (GET_CODE (op1) == CONST && GET_CODE (XEXP (op1, 0)) == UNSPEC)
5707         {
5708           op1 = XEXP (op1, 0);
5709           switch (XINT (op1, 1))
5710             {
5711             case UNSPEC_DTPREL:
5712               reloc16 = NULL;
5713               reloclo = (alpha_tls_size == 16 ? "dtprel" : "dtprello");
5714               break;
5715             case UNSPEC_TPREL:
5716               reloc16 = NULL;
5717               reloclo = (alpha_tls_size == 16 ? "tprel" : "tprello");
5718               break;
5719             default:
5720               output_operand_lossage ("unknown relocation unspec");
5721               return;
5722             }
5723
5724           output_addr_const (file, XVECEXP (op1, 0, 0));
5725         }
5726       else
5727         {
5728           reloc16 = "gprel";
5729           reloclo = "gprellow";
5730           output_addr_const (file, op1);
5731         }
5732
5733       if (offset)
5734         fprintf (file, "+" HOST_WIDE_INT_PRINT_DEC, offset);
5735
5736       addr = XEXP (addr, 0);
5737       if (GET_CODE (addr) == REG)
5738         basereg = REGNO (addr);
5739       else if (GET_CODE (addr) == SUBREG
5740                && GET_CODE (SUBREG_REG (addr)) == REG)
5741         basereg = subreg_regno (addr);
5742       else
5743         abort ();
5744
5745       fprintf (file, "($%d)\t\t!%s", basereg,
5746                (basereg == 29 ? reloc16 : reloclo));
5747       return;
5748     }
5749
5750   if (GET_CODE (addr) == REG)
5751     basereg = REGNO (addr);
5752   else if (GET_CODE (addr) == SUBREG
5753            && GET_CODE (SUBREG_REG (addr)) == REG)
5754     basereg = subreg_regno (addr);
5755   else if (GET_CODE (addr) == CONST_INT)
5756     offset = INTVAL (addr);
5757
5758 #if TARGET_ABI_OPEN_VMS
5759   else if (GET_CODE (addr) == SYMBOL_REF)
5760     {
5761       fprintf (file, "%s", XSTR (addr, 0));
5762       return;
5763     }
5764   else if (GET_CODE (addr) == CONST
5765            && GET_CODE (XEXP (addr, 0)) == PLUS
5766            && GET_CODE (XEXP (XEXP (addr, 0), 0)) == SYMBOL_REF)
5767     {
5768       fprintf (file, "%s+" HOST_WIDE_INT_PRINT_DEC,
5769                XSTR (XEXP (XEXP (addr, 0), 0), 0),
5770                INTVAL (XEXP (XEXP (addr, 0), 1)));
5771       return;
5772     }
5773 #endif
5774
5775   else
5776     abort ();
5777
5778   fprintf (file, HOST_WIDE_INT_PRINT_DEC "($%d)", offset, basereg);
5779 }
5780 \f
5781 /* Emit RTL insns to initialize the variable parts of a trampoline at
5782    TRAMP. FNADDR is an RTX for the address of the function's pure
5783    code.  CXT is an RTX for the static chain value for the function.
5784
5785    The three offset parameters are for the individual template's
5786    layout.  A JMPOFS < 0 indicates that the trampoline does not
5787    contain instructions at all.
5788
5789    We assume here that a function will be called many more times than
5790    its address is taken (e.g., it might be passed to qsort), so we
5791    take the trouble to initialize the "hint" field in the JMP insn.
5792    Note that the hint field is PC (new) + 4 * bits 13:0.  */
5793
5794 void
5795 alpha_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt,
5796                              int fnofs, int cxtofs, int jmpofs)
5797 {
5798   rtx temp, temp1, addr;
5799   /* VMS really uses DImode pointers in memory at this point.  */
5800   enum machine_mode mode = TARGET_ABI_OPEN_VMS ? Pmode : ptr_mode;
5801
5802 #ifdef POINTERS_EXTEND_UNSIGNED
5803   fnaddr = convert_memory_address (mode, fnaddr);
5804   cxt = convert_memory_address (mode, cxt);
5805 #endif
5806
5807   /* Store function address and CXT.  */
5808   addr = memory_address (mode, plus_constant (tramp, fnofs));
5809   emit_move_insn (gen_rtx_MEM (mode, addr), fnaddr);
5810   addr = memory_address (mode, plus_constant (tramp, cxtofs));
5811   emit_move_insn (gen_rtx_MEM (mode, addr), cxt);
5812
5813   /* This has been disabled since the hint only has a 32k range, and in
5814      no existing OS is the stack within 32k of the text segment.  */
5815   if (0 && jmpofs >= 0)
5816     {
5817       /* Compute hint value.  */
5818       temp = force_operand (plus_constant (tramp, jmpofs+4), NULL_RTX);
5819       temp = expand_binop (DImode, sub_optab, fnaddr, temp, temp, 1,
5820                            OPTAB_WIDEN);
5821       temp = expand_shift (RSHIFT_EXPR, Pmode, temp,
5822                            build_int_2 (2, 0), NULL_RTX, 1);
5823       temp = expand_and (SImode, gen_lowpart (SImode, temp),
5824                          GEN_INT (0x3fff), 0);
5825
5826       /* Merge in the hint.  */
5827       addr = memory_address (SImode, plus_constant (tramp, jmpofs));
5828       temp1 = force_reg (SImode, gen_rtx_MEM (SImode, addr));
5829       temp1 = expand_and (SImode, temp1, GEN_INT (0xffffc000), NULL_RTX);
5830       temp1 = expand_binop (SImode, ior_optab, temp1, temp, temp1, 1,
5831                             OPTAB_WIDEN);
5832       emit_move_insn (gen_rtx_MEM (SImode, addr), temp1);
5833     }
5834
5835 #ifdef TRANSFER_FROM_TRAMPOLINE
5836   emit_library_call (init_one_libfunc ("__enable_execute_stack"),
5837                      0, VOIDmode, 1, tramp, Pmode);
5838 #endif
5839
5840   if (jmpofs >= 0)
5841     emit_insn (gen_imb ());
5842 }
5843 \f
5844 /* Determine where to put an argument to a function.
5845    Value is zero to push the argument on the stack,
5846    or a hard register in which to store the argument.
5847
5848    MODE is the argument's machine mode.
5849    TYPE is the data type of the argument (as a tree).
5850     This is null for libcalls where that information may
5851     not be available.
5852    CUM is a variable of type CUMULATIVE_ARGS which gives info about
5853     the preceding args and about the function being called.
5854    NAMED is nonzero if this argument is a named parameter
5855     (otherwise it is an extra parameter matching an ellipsis).
5856
5857    On Alpha the first 6 words of args are normally in registers
5858    and the rest are pushed.  */
5859
5860 rtx
5861 function_arg (CUMULATIVE_ARGS cum, enum machine_mode mode, tree type,
5862               int named ATTRIBUTE_UNUSED)
5863 {
5864   int basereg;
5865   int num_args;
5866
5867   /* Don't get confused and pass small structures in FP registers.  */
5868   if (type && AGGREGATE_TYPE_P (type))
5869     basereg = 16;
5870   else
5871     {
5872 #ifdef ENABLE_CHECKING
5873       /* With SPLIT_COMPLEX_ARGS, we shouldn't see any raw complex
5874          values here.  */
5875       if (COMPLEX_MODE_P (mode))
5876         abort ();
5877 #endif
5878
5879       /* Set up defaults for FP operands passed in FP registers, and
5880          integral operands passed in integer registers.  */
5881       if (TARGET_FPREGS && GET_MODE_CLASS (mode) == MODE_FLOAT)
5882         basereg = 32 + 16;
5883       else
5884         basereg = 16;
5885     }
5886
5887   /* ??? Irritatingly, the definition of CUMULATIVE_ARGS is different for
5888      the three platforms, so we can't avoid conditional compilation.  */
5889 #if TARGET_ABI_OPEN_VMS
5890     {
5891       if (mode == VOIDmode)
5892         return alpha_arg_info_reg_val (cum);
5893
5894       num_args = cum.num_args;
5895       if (num_args >= 6 || MUST_PASS_IN_STACK (mode, type))
5896         return NULL_RTX;
5897     }
5898 #elif TARGET_ABI_UNICOSMK
5899     {
5900       int size;
5901
5902       /* If this is the last argument, generate the call info word (CIW).  */
5903       /* ??? We don't include the caller's line number in the CIW because
5904          I don't know how to determine it if debug infos are turned off.  */
5905       if (mode == VOIDmode)
5906         {
5907           int i;
5908           HOST_WIDE_INT lo;
5909           HOST_WIDE_INT hi;
5910           rtx ciw;
5911
5912           lo = 0;
5913
5914           for (i = 0; i < cum.num_reg_words && i < 5; i++)
5915             if (cum.reg_args_type[i])
5916               lo |= (1 << (7 - i));
5917
5918           if (cum.num_reg_words == 6 && cum.reg_args_type[5])
5919             lo |= 7;
5920           else
5921             lo |= cum.num_reg_words;
5922
5923 #if HOST_BITS_PER_WIDE_INT == 32
5924           hi = (cum.num_args << 20) | cum.num_arg_words;
5925 #else
5926           lo = lo | ((HOST_WIDE_INT) cum.num_args << 52)
5927             | ((HOST_WIDE_INT) cum.num_arg_words << 32);
5928           hi = 0;
5929 #endif
5930           ciw = immed_double_const (lo, hi, DImode);
5931
5932           return gen_rtx_UNSPEC (DImode, gen_rtvec (1, ciw),
5933                                  UNSPEC_UMK_LOAD_CIW);
5934         }
5935
5936       size = ALPHA_ARG_SIZE (mode, type, named);
5937       num_args = cum.num_reg_words;
5938       if (MUST_PASS_IN_STACK (mode, type)
5939           || cum.num_reg_words + size > 6 || cum.force_stack)
5940         return NULL_RTX;
5941       else if (type && TYPE_MODE (type) == BLKmode)
5942         {
5943           rtx reg1, reg2;
5944
5945           reg1 = gen_rtx_REG (DImode, num_args + 16);
5946           reg1 = gen_rtx_EXPR_LIST (DImode, reg1, const0_rtx);
5947
5948           /* The argument fits in two registers. Note that we still need to
5949              reserve a register for empty structures.  */
5950           if (size == 0)
5951             return NULL_RTX;
5952           else if (size == 1)
5953             return gen_rtx_PARALLEL (mode, gen_rtvec (1, reg1));
5954           else
5955             {
5956               reg2 = gen_rtx_REG (DImode, num_args + 17);
5957               reg2 = gen_rtx_EXPR_LIST (DImode, reg2, GEN_INT (8));
5958               return gen_rtx_PARALLEL (mode, gen_rtvec (2, reg1, reg2));
5959             }
5960         }
5961     }
5962 #elif TARGET_ABI_OSF
5963     {
5964       if (cum >= 6)
5965         return NULL_RTX;
5966       num_args = cum;
5967
5968       /* VOID is passed as a special flag for "last argument".  */
5969       if (type == void_type_node)
5970         basereg = 16;
5971       else if (MUST_PASS_IN_STACK (mode, type))
5972         return NULL_RTX;
5973       else if (FUNCTION_ARG_PASS_BY_REFERENCE (cum, mode, type, named))
5974         basereg = 16;
5975     }
5976 #else
5977 #error Unhandled ABI
5978 #endif
5979
5980   return gen_rtx_REG (mode, num_args + basereg);
5981 }
5982
5983 /* Return true if TYPE must be returned in memory, instead of in registers.  */
5984
5985 bool
5986 return_in_memory (tree type, enum machine_mode mode)
5987 {
5988   int size;
5989
5990   if (type)
5991     {
5992       mode = TYPE_MODE (type);
5993
5994       /* All aggregates are returned in memory.  */
5995       if (AGGREGATE_TYPE_P (type))
5996         return true;
5997     }
5998
5999   size = GET_MODE_SIZE (mode);
6000   switch (GET_MODE_CLASS (mode))
6001     {
6002     case MODE_VECTOR_FLOAT:
6003       /* Pass all float vectors in memory, like an aggregate.  */
6004       return true;
6005
6006     case MODE_COMPLEX_FLOAT:
6007       /* We judge complex floats on the size of their element,
6008          not the size of the whole type.  */
6009       size = GET_MODE_UNIT_SIZE (mode);
6010       break;
6011
6012     case MODE_INT:
6013     case MODE_FLOAT:
6014     case MODE_COMPLEX_INT:
6015     case MODE_VECTOR_INT:
6016       break;
6017
6018     default:
6019       /* ??? We get called on all sorts of random stuff from
6020          aggregate_value_p.  We can't abort, but it's not clear
6021          what's safe to return.  Pretend it's a struct I guess.  */
6022       return true;
6023     }
6024
6025   /* Otherwise types must fit in one register.  */
6026   return size > UNITS_PER_WORD;
6027 }
6028
6029 /* Define how to find the value returned by a function.  VALTYPE is the
6030    data type of the value (as a tree).  If the precise function being
6031    called is known, FUNC is its FUNCTION_DECL; otherwise, FUNC is 0.
6032    MODE is set instead of VALTYPE for libcalls.
6033
6034    On Alpha the value is found in $0 for integer functions and
6035    $f0 for floating-point functions.  */
6036
6037 rtx
6038 function_value (tree valtype, tree func ATTRIBUTE_UNUSED,
6039                 enum machine_mode mode)
6040 {
6041   unsigned int regnum;
6042   enum mode_class class;
6043
6044 #ifdef ENABLE_CHECKING
6045   if (return_in_memory (valtype, mode))
6046     abort ();
6047 #endif
6048
6049   if (valtype)
6050     mode = TYPE_MODE (valtype);
6051
6052   class = GET_MODE_CLASS (mode);
6053   switch (class)
6054     {
6055     case MODE_INT:
6056       /* Do the same thing as PROMOTE_MODE.  */
6057       mode = DImode;
6058       /* FALLTHRU */
6059
6060     case MODE_COMPLEX_INT:
6061     case MODE_VECTOR_INT:
6062       regnum = 0;
6063       break;
6064
6065     case MODE_FLOAT:
6066       regnum = 32;
6067       break;
6068
6069     case MODE_COMPLEX_FLOAT:
6070       {
6071         enum machine_mode cmode = GET_MODE_INNER (mode);
6072
6073         return gen_rtx_PARALLEL
6074           (VOIDmode,
6075            gen_rtvec (2,
6076                       gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_REG (cmode, 32),
6077                                          GEN_INT (0)),
6078                       gen_rtx_EXPR_LIST (VOIDmode, gen_rtx_REG (cmode, 33),
6079                                          GEN_INT (GET_MODE_SIZE (cmode)))));
6080       }
6081
6082     default:
6083       abort ();
6084     }
6085
6086   return gen_rtx_REG (mode, regnum);
6087 }
6088
6089 tree
6090 alpha_build_va_list (void)
6091 {
6092   tree base, ofs, record, type_decl;
6093
6094   if (TARGET_ABI_OPEN_VMS || TARGET_ABI_UNICOSMK)
6095     return ptr_type_node;
6096
6097   record = (*lang_hooks.types.make_type) (RECORD_TYPE);
6098   type_decl = build_decl (TYPE_DECL, get_identifier ("__va_list_tag"), record);
6099   TREE_CHAIN (record) = type_decl;
6100   TYPE_NAME (record) = type_decl;
6101
6102   /* C++? SET_IS_AGGR_TYPE (record, 1); */
6103
6104   ofs = build_decl (FIELD_DECL, get_identifier ("__offset"),
6105                     integer_type_node);
6106   DECL_FIELD_CONTEXT (ofs) = record;
6107
6108   base = build_decl (FIELD_DECL, get_identifier ("__base"),
6109                      ptr_type_node);
6110   DECL_FIELD_CONTEXT (base) = record;
6111   TREE_CHAIN (base) = ofs;
6112
6113   TYPE_FIELDS (record) = base;
6114   layout_type (record);
6115
6116   return record;
6117 }
6118
6119 /* Perform any needed actions needed for a function that is receiving a
6120    variable number of arguments.
6121
6122    On the Alpha, we allocate space for all 12 arg registers, but only
6123    push those that are remaining.  However, if NO registers need to be
6124    saved, don't allocate any space.  This is not only because we won't
6125    need the space, but because AP includes the current_pretend_args_size
6126    and we don't want to mess up any ap-relative addresses already made.
6127
6128    If we are not to use the floating-point registers, save the integer
6129    registers where we would put the floating-point registers.  This is
6130    not the most efficient way to implement varargs with just one register
6131    class, but it isn't worth doing anything more efficient in this rare
6132    case.  */
6133
6134 #if TARGET_ABI_OSF
6135 void
6136 alpha_setup_incoming_varargs(CUMULATIVE_ARGS cum,
6137                              enum machine_mode mode ATTRIBUTE_UNUSED,
6138                              tree type ATTRIBUTE_UNUSED,
6139                              int *pretend_size, int no_rtl)
6140 {
6141   if (cum >= 6)
6142     return;
6143
6144   if (!no_rtl)
6145     {
6146       int set = get_varargs_alias_set ();
6147       rtx tmp;
6148
6149       tmp = gen_rtx_MEM (BLKmode,
6150                          plus_constant (virtual_incoming_args_rtx,
6151                                         (cum + 6) * UNITS_PER_WORD));
6152       set_mem_alias_set (tmp, set);
6153       move_block_from_reg (16 + cum, tmp, 6 - cum);
6154
6155       tmp = gen_rtx_MEM (BLKmode,
6156                          plus_constant (virtual_incoming_args_rtx,
6157                                         cum * UNITS_PER_WORD));
6158       set_mem_alias_set (tmp, set);
6159       move_block_from_reg (16 + (TARGET_FPREGS ? 32 : 0) + cum, tmp,
6160                            6 - cum);
6161      }
6162   *pretend_size = 12 * UNITS_PER_WORD;
6163 }
6164 #endif
6165
6166 void
6167 alpha_va_start (tree valist, rtx nextarg ATTRIBUTE_UNUSED)
6168 {
6169   HOST_WIDE_INT offset;
6170   tree t, offset_field, base_field;
6171
6172   if (TREE_CODE (TREE_TYPE (valist)) == ERROR_MARK)
6173     return;
6174
6175   if (TARGET_ABI_UNICOSMK)
6176     std_expand_builtin_va_start (valist, nextarg);
6177
6178   /* For Unix, SETUP_INCOMING_VARARGS moves the starting address base
6179      up by 48, storing fp arg registers in the first 48 bytes, and the
6180      integer arg registers in the next 48 bytes.  This is only done,
6181      however, if any integer registers need to be stored.
6182
6183      If no integer registers need be stored, then we must subtract 48
6184      in order to account for the integer arg registers which are counted
6185      in argsize above, but which are not actually stored on the stack.
6186      Must further be careful here about structures straddling the last
6187      integer argument register; that futzes with pretend_args_size,
6188      which changes the meaning of AP.  */
6189
6190   if (NUM_ARGS <= 6)
6191     offset = TARGET_ABI_OPEN_VMS ? UNITS_PER_WORD : 6 * UNITS_PER_WORD;
6192   else
6193     offset = -6 * UNITS_PER_WORD + current_function_pretend_args_size;
6194
6195   if (TARGET_ABI_OPEN_VMS)
6196     {
6197       nextarg = plus_constant (nextarg, offset);
6198       nextarg = plus_constant (nextarg, NUM_ARGS * UNITS_PER_WORD);
6199       t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
6200                  make_tree (ptr_type_node, nextarg));
6201       TREE_SIDE_EFFECTS (t) = 1;
6202
6203       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6204     }
6205   else
6206     {
6207       base_field = TYPE_FIELDS (TREE_TYPE (valist));
6208       offset_field = TREE_CHAIN (base_field);
6209
6210       base_field = build (COMPONENT_REF, TREE_TYPE (base_field),
6211                           valist, base_field);
6212       offset_field = build (COMPONENT_REF, TREE_TYPE (offset_field),
6213                             valist, offset_field);
6214
6215       t = make_tree (ptr_type_node, virtual_incoming_args_rtx);
6216       t = build (PLUS_EXPR, ptr_type_node, t, build_int_2 (offset, 0));
6217       t = build (MODIFY_EXPR, TREE_TYPE (base_field), base_field, t);
6218       TREE_SIDE_EFFECTS (t) = 1;
6219       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6220
6221       t = build_int_2 (NUM_ARGS * UNITS_PER_WORD, 0);
6222       t = build (MODIFY_EXPR, TREE_TYPE (offset_field), offset_field, t);
6223       TREE_SIDE_EFFECTS (t) = 1;
6224       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6225     }
6226 }
6227
6228 rtx
6229 alpha_va_arg (tree valist, tree type)
6230 {
6231   rtx addr;
6232   tree t, type_size, rounded_size;
6233   tree offset_field, base_field, addr_tree, addend;
6234   tree wide_type, wide_ofs;
6235   int indirect = 0;
6236
6237   if (TARGET_ABI_OPEN_VMS || TARGET_ABI_UNICOSMK)
6238     return std_expand_builtin_va_arg (valist, type);
6239
6240   if (type == error_mark_node
6241       || (type_size = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type))) == NULL
6242       || TREE_OVERFLOW (type_size))
6243     rounded_size = size_zero_node;
6244   else
6245     rounded_size = fold (build (MULT_EXPR, sizetype,
6246                                 fold (build (TRUNC_DIV_EXPR, sizetype,
6247                                              fold (build (PLUS_EXPR, sizetype,
6248                                                           type_size,
6249                                                           size_int (7))),
6250                                              size_int (8))),
6251                                 size_int (8)));
6252
6253   base_field = TYPE_FIELDS (TREE_TYPE (valist));
6254   offset_field = TREE_CHAIN (base_field);
6255
6256   base_field = build (COMPONENT_REF, TREE_TYPE (base_field),
6257                       valist, base_field);
6258   offset_field = build (COMPONENT_REF, TREE_TYPE (offset_field),
6259                         valist, offset_field);
6260
6261   /* If the type could not be passed in registers, skip the block
6262      reserved for the registers.  */
6263   if (MUST_PASS_IN_STACK (TYPE_MODE (type), type))
6264     {
6265       t = build (MODIFY_EXPR, TREE_TYPE (offset_field), offset_field,
6266                  build (MAX_EXPR, TREE_TYPE (offset_field),
6267                         offset_field, build_int_2 (6*8, 0)));
6268       TREE_SIDE_EFFECTS (t) = 1;
6269       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6270     }
6271
6272   wide_type = make_signed_type (64);
6273   wide_ofs = save_expr (build1 (CONVERT_EXPR, wide_type, offset_field));
6274
6275   addend = wide_ofs;
6276
6277   if (TYPE_MODE (type) == TFmode || TYPE_MODE (type) == TCmode)
6278     {
6279       indirect = 1;
6280       rounded_size = size_int (UNITS_PER_WORD);
6281     }
6282   else if (TREE_CODE (type) == COMPLEX_TYPE)
6283     {
6284       rtx real_part, imag_part, value, tmp;
6285
6286       real_part = alpha_va_arg (valist, TREE_TYPE (type));
6287       imag_part = alpha_va_arg (valist, TREE_TYPE (type));
6288
6289       /* ??? Most irritatingly, we're not returning the value here,
6290          but the address.  Since real_part and imag_part are not
6291          necessarily contiguous, we must copy to local storage.  */
6292
6293       real_part = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (type)), real_part);
6294       imag_part = gen_rtx_MEM (TYPE_MODE (TREE_TYPE (type)), imag_part);
6295       value = gen_rtx_CONCAT (TYPE_MODE (type), real_part, imag_part);
6296
6297       tmp = assign_temp (type, 0, 1, 0);
6298       emit_move_insn (tmp, value);
6299
6300       return XEXP (tmp, 0);
6301     }
6302   else if (TREE_CODE (type) == REAL_TYPE)
6303     {
6304       tree fpaddend, cond;
6305
6306       fpaddend = fold (build (PLUS_EXPR, TREE_TYPE (addend),
6307                               addend, build_int_2 (-6*8, 0)));
6308
6309       cond = fold (build (LT_EXPR, integer_type_node,
6310                           wide_ofs, build_int_2 (6*8, 0)));
6311
6312       addend = fold (build (COND_EXPR, TREE_TYPE (addend), cond,
6313                             fpaddend, addend));
6314     }
6315
6316   addr_tree = build (PLUS_EXPR, TREE_TYPE (base_field),
6317                      base_field, addend);
6318
6319   addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
6320   addr = copy_to_reg (addr);
6321
6322   t = build (MODIFY_EXPR, TREE_TYPE (offset_field), offset_field,
6323              build (PLUS_EXPR, TREE_TYPE (offset_field),
6324                     offset_field, rounded_size));
6325   TREE_SIDE_EFFECTS (t) = 1;
6326   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
6327
6328   if (indirect)
6329     {
6330       addr = force_reg (Pmode, addr);
6331       addr = gen_rtx_MEM (Pmode, addr);
6332     }
6333
6334   return addr;
6335 }
6336 \f
6337 /* Builtins.  */
6338
6339 enum alpha_builtin
6340 {
6341   ALPHA_BUILTIN_CMPBGE,
6342   ALPHA_BUILTIN_EXTBL,
6343   ALPHA_BUILTIN_EXTWL,
6344   ALPHA_BUILTIN_EXTLL,
6345   ALPHA_BUILTIN_EXTQL,
6346   ALPHA_BUILTIN_EXTWH,
6347   ALPHA_BUILTIN_EXTLH,
6348   ALPHA_BUILTIN_EXTQH,
6349   ALPHA_BUILTIN_INSBL,
6350   ALPHA_BUILTIN_INSWL,
6351   ALPHA_BUILTIN_INSLL,
6352   ALPHA_BUILTIN_INSQL,
6353   ALPHA_BUILTIN_INSWH,
6354   ALPHA_BUILTIN_INSLH,
6355   ALPHA_BUILTIN_INSQH,
6356   ALPHA_BUILTIN_MSKBL,
6357   ALPHA_BUILTIN_MSKWL,
6358   ALPHA_BUILTIN_MSKLL,
6359   ALPHA_BUILTIN_MSKQL,
6360   ALPHA_BUILTIN_MSKWH,
6361   ALPHA_BUILTIN_MSKLH,
6362   ALPHA_BUILTIN_MSKQH,
6363   ALPHA_BUILTIN_UMULH,
6364   ALPHA_BUILTIN_ZAP,
6365   ALPHA_BUILTIN_ZAPNOT,
6366   ALPHA_BUILTIN_AMASK,
6367   ALPHA_BUILTIN_IMPLVER,
6368   ALPHA_BUILTIN_RPCC,
6369   ALPHA_BUILTIN_THREAD_POINTER,
6370   ALPHA_BUILTIN_SET_THREAD_POINTER,
6371
6372   /* TARGET_MAX */
6373   ALPHA_BUILTIN_MINUB8,
6374   ALPHA_BUILTIN_MINSB8,
6375   ALPHA_BUILTIN_MINUW4,
6376   ALPHA_BUILTIN_MINSW4,
6377   ALPHA_BUILTIN_MAXUB8,
6378   ALPHA_BUILTIN_MAXSB8,
6379   ALPHA_BUILTIN_MAXUW4,
6380   ALPHA_BUILTIN_MAXSW4,
6381   ALPHA_BUILTIN_PERR,
6382   ALPHA_BUILTIN_PKLB,
6383   ALPHA_BUILTIN_PKWB,
6384   ALPHA_BUILTIN_UNPKBL,
6385   ALPHA_BUILTIN_UNPKBW,
6386
6387   /* TARGET_CIX */
6388   ALPHA_BUILTIN_CTTZ,
6389   ALPHA_BUILTIN_CTLZ,
6390   ALPHA_BUILTIN_CTPOP,
6391
6392   ALPHA_BUILTIN_max
6393 };
6394
6395 static unsigned int const code_for_builtin[ALPHA_BUILTIN_max] = {
6396   CODE_FOR_builtin_cmpbge,
6397   CODE_FOR_builtin_extbl,
6398   CODE_FOR_builtin_extwl,
6399   CODE_FOR_builtin_extll,
6400   CODE_FOR_builtin_extql,
6401   CODE_FOR_builtin_extwh,
6402   CODE_FOR_builtin_extlh,
6403   CODE_FOR_builtin_extqh,
6404   CODE_FOR_builtin_insbl,
6405   CODE_FOR_builtin_inswl,
6406   CODE_FOR_builtin_insll,
6407   CODE_FOR_builtin_insql,
6408   CODE_FOR_builtin_inswh,
6409   CODE_FOR_builtin_inslh,
6410   CODE_FOR_builtin_insqh,
6411   CODE_FOR_builtin_mskbl,
6412   CODE_FOR_builtin_mskwl,
6413   CODE_FOR_builtin_mskll,
6414   CODE_FOR_builtin_mskql,
6415   CODE_FOR_builtin_mskwh,
6416   CODE_FOR_builtin_msklh,
6417   CODE_FOR_builtin_mskqh,
6418   CODE_FOR_umuldi3_highpart,
6419   CODE_FOR_builtin_zap,
6420   CODE_FOR_builtin_zapnot,
6421   CODE_FOR_builtin_amask,
6422   CODE_FOR_builtin_implver,
6423   CODE_FOR_builtin_rpcc,
6424   CODE_FOR_load_tp,
6425   CODE_FOR_set_tp,
6426
6427   /* TARGET_MAX */
6428   CODE_FOR_builtin_minub8,
6429   CODE_FOR_builtin_minsb8,
6430   CODE_FOR_builtin_minuw4,
6431   CODE_FOR_builtin_minsw4,
6432   CODE_FOR_builtin_maxub8,
6433   CODE_FOR_builtin_maxsb8,
6434   CODE_FOR_builtin_maxuw4,
6435   CODE_FOR_builtin_maxsw4,
6436   CODE_FOR_builtin_perr,
6437   CODE_FOR_builtin_pklb,
6438   CODE_FOR_builtin_pkwb,
6439   CODE_FOR_builtin_unpkbl,
6440   CODE_FOR_builtin_unpkbw,
6441
6442   /* TARGET_CIX */
6443   CODE_FOR_builtin_cttz,
6444   CODE_FOR_builtin_ctlz,
6445   CODE_FOR_builtin_ctpop
6446 };
6447
6448 struct alpha_builtin_def
6449 {
6450   const char *name;
6451   enum alpha_builtin code;
6452   unsigned int target_mask;
6453 };
6454
6455 static struct alpha_builtin_def const zero_arg_builtins[] = {
6456   { "__builtin_alpha_implver",  ALPHA_BUILTIN_IMPLVER,  0 },
6457   { "__builtin_alpha_rpcc",     ALPHA_BUILTIN_RPCC,     0 }
6458 };
6459
6460 static struct alpha_builtin_def const one_arg_builtins[] = {
6461   { "__builtin_alpha_amask",    ALPHA_BUILTIN_AMASK,    0 },
6462   { "__builtin_alpha_pklb",     ALPHA_BUILTIN_PKLB,     MASK_MAX },
6463   { "__builtin_alpha_pkwb",     ALPHA_BUILTIN_PKWB,     MASK_MAX },
6464   { "__builtin_alpha_unpkbl",   ALPHA_BUILTIN_UNPKBL,   MASK_MAX },
6465   { "__builtin_alpha_unpkbw",   ALPHA_BUILTIN_UNPKBW,   MASK_MAX },
6466   { "__builtin_alpha_cttz",     ALPHA_BUILTIN_CTTZ,     MASK_CIX },
6467   { "__builtin_alpha_ctlz",     ALPHA_BUILTIN_CTLZ,     MASK_CIX },
6468   { "__builtin_alpha_ctpop",    ALPHA_BUILTIN_CTPOP,    MASK_CIX }
6469 };
6470
6471 static struct alpha_builtin_def const two_arg_builtins[] = {
6472   { "__builtin_alpha_cmpbge",   ALPHA_BUILTIN_CMPBGE,   0 },
6473   { "__builtin_alpha_extbl",    ALPHA_BUILTIN_EXTBL,    0 },
6474   { "__builtin_alpha_extwl",    ALPHA_BUILTIN_EXTWL,    0 },
6475   { "__builtin_alpha_extll",    ALPHA_BUILTIN_EXTLL,    0 },
6476   { "__builtin_alpha_extql",    ALPHA_BUILTIN_EXTQL,    0 },
6477   { "__builtin_alpha_extwh",    ALPHA_BUILTIN_EXTWH,    0 },
6478   { "__builtin_alpha_extlh",    ALPHA_BUILTIN_EXTLH,    0 },
6479   { "__builtin_alpha_extqh",    ALPHA_BUILTIN_EXTQH,    0 },
6480   { "__builtin_alpha_insbl",    ALPHA_BUILTIN_INSBL,    0 },
6481   { "__builtin_alpha_inswl",    ALPHA_BUILTIN_INSWL,    0 },
6482   { "__builtin_alpha_insll",    ALPHA_BUILTIN_INSLL,    0 },
6483   { "__builtin_alpha_insql",    ALPHA_BUILTIN_INSQL,    0 },
6484   { "__builtin_alpha_inswh",    ALPHA_BUILTIN_INSWH,    0 },
6485   { "__builtin_alpha_inslh",    ALPHA_BUILTIN_INSLH,    0 },
6486   { "__builtin_alpha_insqh",    ALPHA_BUILTIN_INSQH,    0 },
6487   { "__builtin_alpha_mskbl",    ALPHA_BUILTIN_MSKBL,    0 },
6488   { "__builtin_alpha_mskwl",    ALPHA_BUILTIN_MSKWL,    0 },
6489   { "__builtin_alpha_mskll",    ALPHA_BUILTIN_MSKLL,    0 },
6490   { "__builtin_alpha_mskql",    ALPHA_BUILTIN_MSKQL,    0 },
6491   { "__builtin_alpha_mskwh",    ALPHA_BUILTIN_MSKWH,    0 },
6492   { "__builtin_alpha_msklh",    ALPHA_BUILTIN_MSKLH,    0 },
6493   { "__builtin_alpha_mskqh",    ALPHA_BUILTIN_MSKQH,    0 },
6494   { "__builtin_alpha_umulh",    ALPHA_BUILTIN_UMULH,    0 },
6495   { "__builtin_alpha_zap",      ALPHA_BUILTIN_ZAP,      0 },
6496   { "__builtin_alpha_zapnot",   ALPHA_BUILTIN_ZAPNOT,   0 },
6497   { "__builtin_alpha_minub8",   ALPHA_BUILTIN_MINUB8,   MASK_MAX },
6498   { "__builtin_alpha_minsb8",   ALPHA_BUILTIN_MINSB8,   MASK_MAX },
6499   { "__builtin_alpha_minuw4",   ALPHA_BUILTIN_MINUW4,   MASK_MAX },
6500   { "__builtin_alpha_minsw4",   ALPHA_BUILTIN_MINSW4,   MASK_MAX },
6501   { "__builtin_alpha_maxub8",   ALPHA_BUILTIN_MAXUB8,   MASK_MAX },
6502   { "__builtin_alpha_maxsb8",   ALPHA_BUILTIN_MAXSB8,   MASK_MAX },
6503   { "__builtin_alpha_maxuw4",   ALPHA_BUILTIN_MAXUW4,   MASK_MAX },
6504   { "__builtin_alpha_maxsw4",   ALPHA_BUILTIN_MAXSW4,   MASK_MAX },
6505   { "__builtin_alpha_perr",     ALPHA_BUILTIN_PERR,     MASK_MAX }
6506 };
6507
6508 static void
6509 alpha_init_builtins (void)
6510 {
6511   const struct alpha_builtin_def *p;
6512   tree ftype;
6513   size_t i;
6514
6515   ftype = build_function_type (long_integer_type_node, void_list_node);
6516
6517   p = zero_arg_builtins;
6518   for (i = 0; i < ARRAY_SIZE (zero_arg_builtins); ++i, ++p)
6519     if ((target_flags & p->target_mask) == p->target_mask)
6520       builtin_function (p->name, ftype, p->code, BUILT_IN_MD,
6521                         NULL, NULL_TREE);
6522
6523   ftype = build_function_type_list (long_integer_type_node,
6524                                     long_integer_type_node, NULL_TREE);
6525
6526   p = one_arg_builtins;
6527   for (i = 0; i < ARRAY_SIZE (one_arg_builtins); ++i, ++p)
6528     if ((target_flags & p->target_mask) == p->target_mask)
6529       builtin_function (p->name, ftype, p->code, BUILT_IN_MD,
6530                         NULL, NULL_TREE);
6531
6532   ftype = build_function_type_list (long_integer_type_node,
6533                                     long_integer_type_node,
6534                                     long_integer_type_node, NULL_TREE);
6535
6536   p = two_arg_builtins;
6537   for (i = 0; i < ARRAY_SIZE (two_arg_builtins); ++i, ++p)
6538     if ((target_flags & p->target_mask) == p->target_mask)
6539       builtin_function (p->name, ftype, p->code, BUILT_IN_MD,
6540                         NULL, NULL_TREE);
6541
6542   ftype = build_function_type (ptr_type_node, void_list_node);
6543   builtin_function ("__builtin_thread_pointer", ftype,
6544                     ALPHA_BUILTIN_THREAD_POINTER, BUILT_IN_MD,
6545                     NULL, NULL_TREE);
6546
6547   ftype = build_function_type_list (void_type_node, ptr_type_node, NULL_TREE);
6548   builtin_function ("__builtin_set_thread_pointer", ftype,
6549                     ALPHA_BUILTIN_SET_THREAD_POINTER, BUILT_IN_MD,
6550                     NULL, NULL_TREE);
6551 }
6552
6553 /* Expand an expression EXP that calls a built-in function,
6554    with result going to TARGET if that's convenient
6555    (and in mode MODE if that's convenient).
6556    SUBTARGET may be used as the target for computing one of EXP's operands.
6557    IGNORE is nonzero if the value is to be ignored.  */
6558
6559 static rtx
6560 alpha_expand_builtin (tree exp, rtx target,
6561                       rtx subtarget ATTRIBUTE_UNUSED,
6562                       enum machine_mode mode ATTRIBUTE_UNUSED,
6563                       int ignore ATTRIBUTE_UNUSED)
6564 {
6565 #define MAX_ARGS 2
6566
6567   tree fndecl = TREE_OPERAND (TREE_OPERAND (exp, 0), 0);
6568   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
6569   tree arglist = TREE_OPERAND (exp, 1);
6570   enum insn_code icode;
6571   rtx op[MAX_ARGS], pat;
6572   int arity;
6573   bool nonvoid;
6574
6575   if (fcode >= ALPHA_BUILTIN_max)
6576     internal_error ("bad builtin fcode");
6577   icode = code_for_builtin[fcode];
6578   if (icode == 0)
6579     internal_error ("bad builtin fcode");
6580
6581   nonvoid = TREE_TYPE (TREE_TYPE (fndecl)) != void_type_node;
6582
6583   for (arglist = TREE_OPERAND (exp, 1), arity = 0;
6584        arglist;
6585        arglist = TREE_CHAIN (arglist), arity++)
6586     {
6587       const struct insn_operand_data *insn_op;
6588
6589       tree arg = TREE_VALUE (arglist);
6590       if (arg == error_mark_node)
6591         return NULL_RTX;
6592       if (arity > MAX_ARGS)
6593         return NULL_RTX;
6594
6595       insn_op = &insn_data[icode].operand[arity + nonvoid];
6596
6597       op[arity] = expand_expr (arg, NULL_RTX, insn_op->mode, 0);
6598
6599       if (!(*insn_op->predicate) (op[arity], insn_op->mode))
6600         op[arity] = copy_to_mode_reg (insn_op->mode, op[arity]);
6601     }
6602
6603   if (nonvoid)
6604     {
6605       enum machine_mode tmode = insn_data[icode].operand[0].mode;
6606       if (!target
6607           || GET_MODE (target) != tmode
6608           || !(*insn_data[icode].operand[0].predicate) (target, tmode))
6609         target = gen_reg_rtx (tmode);
6610     }
6611
6612   switch (arity)
6613     {
6614     case 0:
6615       pat = GEN_FCN (icode) (target);
6616       break;
6617     case 1:
6618       if (nonvoid)
6619         pat = GEN_FCN (icode) (target, op[0]);
6620       else
6621         pat = GEN_FCN (icode) (op[0]);
6622       break;
6623     case 2:
6624       pat = GEN_FCN (icode) (target, op[0], op[1]);
6625       break;
6626     default:
6627       abort ();
6628     }
6629   if (!pat)
6630     return NULL_RTX;
6631   emit_insn (pat);
6632
6633   if (nonvoid)
6634     return target;
6635   else
6636     return const0_rtx;
6637 }
6638 \f
6639 /* This page contains routines that are used to determine what the function
6640    prologue and epilogue code will do and write them out.  */
6641
6642 /* Compute the size of the save area in the stack.  */
6643
6644 /* These variables are used for communication between the following functions.
6645    They indicate various things about the current function being compiled
6646    that are used to tell what kind of prologue, epilogue and procedure
6647    descriptior to generate.  */
6648
6649 /* Nonzero if we need a stack procedure.  */
6650 enum alpha_procedure_types {PT_NULL = 0, PT_REGISTER = 1, PT_STACK = 2};
6651 static enum alpha_procedure_types alpha_procedure_type;
6652
6653 /* Register number (either FP or SP) that is used to unwind the frame.  */
6654 static int vms_unwind_regno;
6655
6656 /* Register number used to save FP.  We need not have one for RA since
6657    we don't modify it for register procedures.  This is only defined
6658    for register frame procedures.  */
6659 static int vms_save_fp_regno;
6660
6661 /* Register number used to reference objects off our PV.  */
6662 static int vms_base_regno;
6663
6664 /* Compute register masks for saved registers.  */
6665
6666 static void
6667 alpha_sa_mask (unsigned long *imaskP, unsigned long *fmaskP)
6668 {
6669   unsigned long imask = 0;
6670   unsigned long fmask = 0;
6671   unsigned int i;
6672
6673   /* Irritatingly, there are two kinds of thunks -- those created with
6674      TARGET_ASM_OUTPUT_MI_THUNK and those with DECL_THUNK_P that go
6675      through the regular part of the compiler.  In the
6676      TARGET_ASM_OUTPUT_MI_THUNK case we don't have valid register life
6677      info, but assemble_start_function wants to output .frame and
6678      .mask directives.  */
6679   if (current_function_is_thunk && !no_new_pseudos)
6680     {
6681       *imaskP = 0;
6682       *fmaskP = 0;
6683       return;
6684     }
6685
6686   if (TARGET_ABI_OPEN_VMS && alpha_procedure_type == PT_STACK)
6687     imask |= (1UL << HARD_FRAME_POINTER_REGNUM);
6688
6689   /* One for every register we have to save.  */
6690   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
6691     if (! fixed_regs[i] && ! call_used_regs[i]
6692         && regs_ever_live[i] && i != REG_RA
6693         && (!TARGET_ABI_UNICOSMK || i != HARD_FRAME_POINTER_REGNUM))
6694       {
6695         if (i < 32)
6696           imask |= (1UL << i);
6697         else
6698           fmask |= (1UL << (i - 32));
6699       }
6700
6701   /* We need to restore these for the handler.  */
6702   if (current_function_calls_eh_return)
6703     {
6704       for (i = 0; ; ++i)
6705         {
6706           unsigned regno = EH_RETURN_DATA_REGNO (i);
6707           if (regno == INVALID_REGNUM)
6708             break;
6709           imask |= 1UL << regno;
6710         }
6711
6712       /* Glibc likes to use $31 as an unwind stopper for crt0.  To
6713          avoid hackery in unwind-dw2.c, we need to actively store a
6714          zero in the prologue of _Unwind_RaiseException et al.  */
6715       imask |= 1UL << 31;
6716     }
6717
6718   /* If any register spilled, then spill the return address also.  */
6719   /* ??? This is required by the Digital stack unwind specification
6720      and isn't needed if we're doing Dwarf2 unwinding.  */
6721   if (imask || fmask || alpha_ra_ever_killed ())
6722     imask |= (1UL << REG_RA);
6723
6724   *imaskP = imask;
6725   *fmaskP = fmask;
6726 }
6727
6728 int
6729 alpha_sa_size (void)
6730 {
6731   unsigned long mask[2];
6732   int sa_size = 0;
6733   int i, j;
6734
6735   alpha_sa_mask (&mask[0], &mask[1]);
6736
6737   if (TARGET_ABI_UNICOSMK)
6738     {
6739       if (mask[0] || mask[1])
6740         sa_size = 14;
6741     }
6742   else
6743     {
6744       for (j = 0; j < 2; ++j)
6745         for (i = 0; i < 32; ++i)
6746           if ((mask[j] >> i) & 1)
6747             sa_size++;
6748     }
6749
6750   if (TARGET_ABI_UNICOSMK)
6751     {
6752       /* We might not need to generate a frame if we don't make any calls
6753          (including calls to __T3E_MISMATCH if this is a vararg function),
6754          don't have any local variables which require stack slots, don't
6755          use alloca and have not determined that we need a frame for other
6756          reasons.  */
6757
6758       alpha_procedure_type
6759         = (sa_size || get_frame_size() != 0
6760            || current_function_outgoing_args_size
6761            || current_function_stdarg || current_function_calls_alloca
6762            || frame_pointer_needed)
6763           ? PT_STACK : PT_REGISTER;
6764
6765       /* Always reserve space for saving callee-saved registers if we
6766          need a frame as required by the calling convention.  */
6767       if (alpha_procedure_type == PT_STACK)
6768         sa_size = 14;
6769     }
6770   else if (TARGET_ABI_OPEN_VMS)
6771     {
6772       /* Start by assuming we can use a register procedure if we don't
6773          make any calls (REG_RA not used) or need to save any
6774          registers and a stack procedure if we do.  */
6775       if ((mask[0] >> REG_RA) & 1)
6776         alpha_procedure_type = PT_STACK;
6777       else if (get_frame_size() != 0)
6778         alpha_procedure_type = PT_REGISTER;
6779       else
6780         alpha_procedure_type = PT_NULL;
6781
6782       /* Don't reserve space for saving FP & RA yet.  Do that later after we've
6783          made the final decision on stack procedure vs register procedure.  */
6784       if (alpha_procedure_type == PT_STACK)
6785         sa_size -= 2;
6786
6787       /* Decide whether to refer to objects off our PV via FP or PV.
6788          If we need FP for something else or if we receive a nonlocal
6789          goto (which expects PV to contain the value), we must use PV.
6790          Otherwise, start by assuming we can use FP.  */
6791
6792       vms_base_regno
6793         = (frame_pointer_needed
6794            || current_function_has_nonlocal_label
6795            || alpha_procedure_type == PT_STACK
6796            || current_function_outgoing_args_size)
6797           ? REG_PV : HARD_FRAME_POINTER_REGNUM;
6798
6799       /* If we want to copy PV into FP, we need to find some register
6800          in which to save FP.  */
6801
6802       vms_save_fp_regno = -1;
6803       if (vms_base_regno == HARD_FRAME_POINTER_REGNUM)
6804         for (i = 0; i < 32; i++)
6805           if (! fixed_regs[i] && call_used_regs[i] && ! regs_ever_live[i])
6806             vms_save_fp_regno = i;
6807
6808       if (vms_save_fp_regno == -1 && alpha_procedure_type == PT_REGISTER)
6809         vms_base_regno = REG_PV, alpha_procedure_type = PT_STACK;
6810       else if (alpha_procedure_type == PT_NULL)
6811         vms_base_regno = REG_PV;
6812
6813       /* Stack unwinding should be done via FP unless we use it for PV.  */
6814       vms_unwind_regno = (vms_base_regno == REG_PV
6815                           ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM);
6816
6817       /* If this is a stack procedure, allow space for saving FP and RA.  */
6818       if (alpha_procedure_type == PT_STACK)
6819         sa_size += 2;
6820     }
6821   else
6822     {
6823       /* Our size must be even (multiple of 16 bytes).  */
6824       if (sa_size & 1)
6825         sa_size++;
6826     }
6827
6828   return sa_size * 8;
6829 }
6830
6831 /* Define the offset between two registers, one to be eliminated,
6832    and the other its replacement, at the start of a routine.  */
6833
6834 HOST_WIDE_INT
6835 alpha_initial_elimination_offset (unsigned int from,
6836                                   unsigned int to ATTRIBUTE_UNUSED)
6837 {
6838   HOST_WIDE_INT ret;
6839
6840   ret = alpha_sa_size ();
6841   ret += ALPHA_ROUND (current_function_outgoing_args_size);
6842
6843   if (from == FRAME_POINTER_REGNUM)
6844     ;
6845   else if (from == ARG_POINTER_REGNUM)
6846     ret += (ALPHA_ROUND (get_frame_size ()
6847                          + current_function_pretend_args_size)
6848             - current_function_pretend_args_size);
6849   else
6850     abort ();
6851
6852   return ret;
6853 }
6854
6855 int
6856 alpha_pv_save_size (void)
6857 {
6858   alpha_sa_size ();
6859   return alpha_procedure_type == PT_STACK ? 8 : 0;
6860 }
6861
6862 int
6863 alpha_using_fp (void)
6864 {
6865   alpha_sa_size ();
6866   return vms_unwind_regno == HARD_FRAME_POINTER_REGNUM;
6867 }
6868
6869 #if TARGET_ABI_OPEN_VMS
6870
6871 const struct attribute_spec vms_attribute_table[] =
6872 {
6873   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
6874   { "overlaid",   0, 0, true,  false, false, NULL },
6875   { "global",     0, 0, true,  false, false, NULL },
6876   { "initialize", 0, 0, true,  false, false, NULL },
6877   { NULL,         0, 0, false, false, false, NULL }
6878 };
6879
6880 #endif
6881
6882 static int
6883 find_lo_sum_using_gp (rtx *px, void *data ATTRIBUTE_UNUSED)
6884 {
6885   return GET_CODE (*px) == LO_SUM && XEXP (*px, 0) == pic_offset_table_rtx;
6886 }
6887
6888 int
6889 alpha_find_lo_sum_using_gp (rtx insn)
6890 {
6891   return for_each_rtx (&PATTERN (insn), find_lo_sum_using_gp, NULL) > 0;
6892 }
6893
6894 static int
6895 alpha_does_function_need_gp (void)
6896 {
6897   rtx insn;
6898
6899   /* The GP being variable is an OSF abi thing.  */
6900   if (! TARGET_ABI_OSF)
6901     return 0;
6902
6903   if (TARGET_PROFILING_NEEDS_GP && current_function_profile)
6904     return 1;
6905
6906   if (current_function_is_thunk)
6907     return 1;
6908
6909   /* If we need a GP (we have a LDSYM insn or a CALL_INSN), load it first.
6910      Even if we are a static function, we still need to do this in case
6911      our address is taken and passed to something like qsort.  */
6912
6913   push_topmost_sequence ();
6914   insn = get_insns ();
6915   pop_topmost_sequence ();
6916
6917   for (; insn; insn = NEXT_INSN (insn))
6918     if (INSN_P (insn)
6919         && GET_CODE (PATTERN (insn)) != USE
6920         && GET_CODE (PATTERN (insn)) != CLOBBER
6921         && get_attr_usegp (insn))
6922       return 1;
6923
6924   return 0;
6925 }
6926
6927 \f
6928 /* Helper function to set RTX_FRAME_RELATED_P on instructions, including
6929    sequences.  */
6930
6931 static rtx
6932 set_frame_related_p (void)
6933 {
6934   rtx seq = get_insns ();
6935   rtx insn;
6936
6937   end_sequence ();
6938
6939   if (!seq)
6940     return NULL_RTX;
6941
6942   if (INSN_P (seq))
6943     {
6944       insn = seq;
6945       while (insn != NULL_RTX)
6946         {
6947           RTX_FRAME_RELATED_P (insn) = 1;
6948           insn = NEXT_INSN (insn);
6949         }
6950       seq = emit_insn (seq);
6951     }
6952   else
6953     {
6954       seq = emit_insn (seq);
6955       RTX_FRAME_RELATED_P (seq) = 1;
6956     }
6957   return seq;
6958 }
6959
6960 #define FRP(exp)  (start_sequence (), exp, set_frame_related_p ())
6961
6962 /* Write function prologue.  */
6963
6964 /* On vms we have two kinds of functions:
6965
6966    - stack frame (PROC_STACK)
6967         these are 'normal' functions with local vars and which are
6968         calling other functions
6969    - register frame (PROC_REGISTER)
6970         keeps all data in registers, needs no stack
6971
6972    We must pass this to the assembler so it can generate the
6973    proper pdsc (procedure descriptor)
6974    This is done with the '.pdesc' command.
6975
6976    On not-vms, we don't really differentiate between the two, as we can
6977    simply allocate stack without saving registers.  */
6978
6979 void
6980 alpha_expand_prologue (void)
6981 {
6982   /* Registers to save.  */
6983   unsigned long imask = 0;
6984   unsigned long fmask = 0;
6985   /* Stack space needed for pushing registers clobbered by us.  */
6986   HOST_WIDE_INT sa_size;
6987   /* Complete stack size needed.  */
6988   HOST_WIDE_INT frame_size;
6989   /* Offset from base reg to register save area.  */
6990   HOST_WIDE_INT reg_offset;
6991   rtx sa_reg, mem;
6992   int i;
6993
6994   sa_size = alpha_sa_size ();
6995
6996   frame_size = get_frame_size ();
6997   if (TARGET_ABI_OPEN_VMS)
6998     frame_size = ALPHA_ROUND (sa_size
6999                               + (alpha_procedure_type == PT_STACK ? 8 : 0)
7000                               + frame_size
7001                               + current_function_pretend_args_size);
7002   else if (TARGET_ABI_UNICOSMK)
7003     /* We have to allocate space for the DSIB if we generate a frame.  */
7004     frame_size = ALPHA_ROUND (sa_size
7005                               + (alpha_procedure_type == PT_STACK ? 48 : 0))
7006                  + ALPHA_ROUND (frame_size
7007                                 + current_function_outgoing_args_size);
7008   else
7009     frame_size = (ALPHA_ROUND (current_function_outgoing_args_size)
7010                   + sa_size
7011                   + ALPHA_ROUND (frame_size
7012                                  + current_function_pretend_args_size));
7013
7014   if (TARGET_ABI_OPEN_VMS)
7015     reg_offset = 8;
7016   else
7017     reg_offset = ALPHA_ROUND (current_function_outgoing_args_size);
7018
7019   alpha_sa_mask (&imask, &fmask);
7020
7021   /* Emit an insn to reload GP, if needed.  */
7022   if (TARGET_ABI_OSF)
7023     {
7024       alpha_function_needs_gp = alpha_does_function_need_gp ();
7025       if (alpha_function_needs_gp)
7026         emit_insn (gen_prologue_ldgp ());
7027     }
7028
7029   /* TARGET_PROFILING_NEEDS_GP actually implies that we need to insert
7030      the call to mcount ourselves, rather than having the linker do it
7031      magically in response to -pg.  Since _mcount has special linkage,
7032      don't represent the call as a call.  */
7033   if (TARGET_PROFILING_NEEDS_GP && current_function_profile)
7034     emit_insn (gen_prologue_mcount ());
7035
7036   if (TARGET_ABI_UNICOSMK)
7037     unicosmk_gen_dsib (&imask);
7038
7039   /* Adjust the stack by the frame size.  If the frame size is > 4096
7040      bytes, we need to be sure we probe somewhere in the first and last
7041      4096 bytes (we can probably get away without the latter test) and
7042      every 8192 bytes in between.  If the frame size is > 32768, we
7043      do this in a loop.  Otherwise, we generate the explicit probe
7044      instructions.
7045
7046      Note that we are only allowed to adjust sp once in the prologue.  */
7047
7048   if (frame_size <= 32768)
7049     {
7050       if (frame_size > 4096)
7051         {
7052           int probed = 4096;
7053
7054           do
7055             emit_insn (gen_probe_stack (GEN_INT (TARGET_ABI_UNICOSMK
7056                                                  ? -probed + 64
7057                                                  : -probed)));
7058           while ((probed += 8192) < frame_size);
7059
7060           /* We only have to do this probe if we aren't saving registers.  */
7061           if (sa_size == 0 && probed + 4096 < frame_size)
7062             emit_insn (gen_probe_stack (GEN_INT (-frame_size)));
7063         }
7064
7065       if (frame_size != 0)
7066         FRP (emit_insn (gen_adddi3 (stack_pointer_rtx, stack_pointer_rtx,
7067                                     GEN_INT (TARGET_ABI_UNICOSMK
7068                                              ? -frame_size + 64
7069                                              : -frame_size))));
7070     }
7071   else
7072     {
7073       /* Here we generate code to set R22 to SP + 4096 and set R23 to the
7074          number of 8192 byte blocks to probe.  We then probe each block
7075          in the loop and then set SP to the proper location.  If the
7076          amount remaining is > 4096, we have to do one more probe if we
7077          are not saving any registers.  */
7078
7079       HOST_WIDE_INT blocks = (frame_size + 4096) / 8192;
7080       HOST_WIDE_INT leftover = frame_size + 4096 - blocks * 8192;
7081       rtx ptr = gen_rtx_REG (DImode, 22);
7082       rtx count = gen_rtx_REG (DImode, 23);
7083       rtx seq;
7084
7085       emit_move_insn (count, GEN_INT (blocks));
7086       emit_insn (gen_adddi3 (ptr, stack_pointer_rtx,
7087                              GEN_INT (TARGET_ABI_UNICOSMK ? 4096 - 64 : 4096)));
7088
7089       /* Because of the difficulty in emitting a new basic block this
7090          late in the compilation, generate the loop as a single insn.  */
7091       emit_insn (gen_prologue_stack_probe_loop (count, ptr));
7092
7093       if (leftover > 4096 && sa_size == 0)
7094         {
7095           rtx last = gen_rtx_MEM (DImode, plus_constant (ptr, -leftover));
7096           MEM_VOLATILE_P (last) = 1;
7097           emit_move_insn (last, const0_rtx);
7098         }
7099
7100       if (TARGET_ABI_WINDOWS_NT)
7101         {
7102           /* For NT stack unwind (done by 'reverse execution'), it's
7103              not OK to take the result of a loop, even though the value
7104              is already in ptr, so we reload it via a single operation
7105              and subtract it to sp.
7106
7107              Yes, that's correct -- we have to reload the whole constant
7108              into a temporary via ldah+lda then subtract from sp.  To
7109              ensure we get ldah+lda, we use a special pattern.  */
7110
7111           HOST_WIDE_INT lo, hi;
7112           lo = ((frame_size & 0xffff) ^ 0x8000) - 0x8000;
7113           hi = frame_size - lo;
7114
7115           emit_move_insn (ptr, GEN_INT (hi));
7116           emit_insn (gen_nt_lda (ptr, GEN_INT (lo)));
7117           seq = emit_insn (gen_subdi3 (stack_pointer_rtx, stack_pointer_rtx,
7118                                        ptr));
7119         }
7120       else
7121         {
7122           seq = emit_insn (gen_adddi3 (stack_pointer_rtx, ptr,
7123                                        GEN_INT (-leftover)));
7124         }
7125
7126       /* This alternative is special, because the DWARF code cannot
7127          possibly intuit through the loop above.  So we invent this
7128          note it looks at instead.  */
7129       RTX_FRAME_RELATED_P (seq) = 1;
7130       REG_NOTES (seq)
7131         = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
7132                              gen_rtx_SET (VOIDmode, stack_pointer_rtx,
7133                                gen_rtx_PLUS (Pmode, stack_pointer_rtx,
7134                                              GEN_INT (TARGET_ABI_UNICOSMK
7135                                                       ? -frame_size + 64
7136                                                       : -frame_size))),
7137                              REG_NOTES (seq));
7138     }
7139
7140   if (!TARGET_ABI_UNICOSMK)
7141     {
7142       /* Cope with very large offsets to the register save area.  */
7143       sa_reg = stack_pointer_rtx;
7144       if (reg_offset + sa_size > 0x8000)
7145         {
7146           int low = ((reg_offset & 0xffff) ^ 0x8000) - 0x8000;
7147           HOST_WIDE_INT bias;
7148
7149           if (low + sa_size <= 0x8000)
7150             bias = reg_offset - low, reg_offset = low;
7151           else
7152             bias = reg_offset, reg_offset = 0;
7153
7154           sa_reg = gen_rtx_REG (DImode, 24);
7155           FRP (emit_insn (gen_adddi3 (sa_reg, stack_pointer_rtx,
7156                                       GEN_INT (bias))));
7157         }
7158
7159       /* Save regs in stack order.  Beginning with VMS PV.  */
7160       if (TARGET_ABI_OPEN_VMS && alpha_procedure_type == PT_STACK)
7161         {
7162           mem = gen_rtx_MEM (DImode, stack_pointer_rtx);
7163           set_mem_alias_set (mem, alpha_sr_alias_set);
7164           FRP (emit_move_insn (mem, gen_rtx_REG (DImode, REG_PV)));
7165         }
7166
7167       /* Save register RA next.  */
7168       if (imask & (1UL << REG_RA))
7169         {
7170           mem = gen_rtx_MEM (DImode, plus_constant (sa_reg, reg_offset));
7171           set_mem_alias_set (mem, alpha_sr_alias_set);
7172           FRP (emit_move_insn (mem, gen_rtx_REG (DImode, REG_RA)));
7173           imask &= ~(1UL << REG_RA);
7174           reg_offset += 8;
7175         }
7176
7177       /* Now save any other registers required to be saved.  */
7178       for (i = 0; i < 31; i++)
7179         if (imask & (1UL << i))
7180           {
7181             mem = gen_rtx_MEM (DImode, plus_constant (sa_reg, reg_offset));
7182             set_mem_alias_set (mem, alpha_sr_alias_set);
7183             FRP (emit_move_insn (mem, gen_rtx_REG (DImode, i)));
7184             reg_offset += 8;
7185           }
7186
7187       /* Store a zero if requested for unwinding.  */
7188       if (imask & (1UL << 31))
7189         {
7190           rtx insn, t;
7191
7192           mem = gen_rtx_MEM (DImode, plus_constant (sa_reg, reg_offset));
7193           set_mem_alias_set (mem, alpha_sr_alias_set);
7194           insn = emit_move_insn (mem, const0_rtx);
7195
7196           RTX_FRAME_RELATED_P (insn) = 1;
7197           t = gen_rtx_REG (Pmode, 31);
7198           t = gen_rtx_SET (VOIDmode, mem, t);
7199           t = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR, t, REG_NOTES (insn));
7200           REG_NOTES (insn) = t;
7201
7202           reg_offset += 8;
7203         }
7204
7205       for (i = 0; i < 31; i++)
7206         if (fmask & (1UL << i))
7207           {
7208             mem = gen_rtx_MEM (DFmode, plus_constant (sa_reg, reg_offset));
7209             set_mem_alias_set (mem, alpha_sr_alias_set);
7210             FRP (emit_move_insn (mem, gen_rtx_REG (DFmode, i+32)));
7211             reg_offset += 8;
7212           }
7213     }
7214   else if (TARGET_ABI_UNICOSMK && alpha_procedure_type == PT_STACK)
7215     {
7216       /* The standard frame on the T3E includes space for saving registers.
7217          We just have to use it. We don't have to save the return address and
7218          the old frame pointer here - they are saved in the DSIB.  */
7219
7220       reg_offset = -56;
7221       for (i = 9; i < 15; i++)
7222         if (imask & (1UL << i))
7223           {
7224             mem = gen_rtx_MEM (DImode, plus_constant(hard_frame_pointer_rtx,
7225                                                      reg_offset));
7226             set_mem_alias_set (mem, alpha_sr_alias_set);
7227             FRP (emit_move_insn (mem, gen_rtx_REG (DImode, i)));
7228             reg_offset -= 8;
7229           }
7230       for (i = 2; i < 10; i++)
7231         if (fmask & (1UL << i))
7232           {
7233             mem = gen_rtx_MEM (DFmode, plus_constant (hard_frame_pointer_rtx,
7234                                                       reg_offset));
7235             set_mem_alias_set (mem, alpha_sr_alias_set);
7236             FRP (emit_move_insn (mem, gen_rtx_REG (DFmode, i+32)));
7237             reg_offset -= 8;
7238           }
7239     }
7240
7241   if (TARGET_ABI_OPEN_VMS)
7242     {
7243       if (alpha_procedure_type == PT_REGISTER)
7244         /* Register frame procedures save the fp.
7245            ?? Ought to have a dwarf2 save for this.  */
7246         emit_move_insn (gen_rtx_REG (DImode, vms_save_fp_regno),
7247                         hard_frame_pointer_rtx);
7248
7249       if (alpha_procedure_type != PT_NULL && vms_base_regno != REG_PV)
7250         emit_insn (gen_force_movdi (gen_rtx_REG (DImode, vms_base_regno),
7251                                     gen_rtx_REG (DImode, REG_PV)));
7252
7253       if (alpha_procedure_type != PT_NULL
7254           && vms_unwind_regno == HARD_FRAME_POINTER_REGNUM)
7255         FRP (emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx));
7256
7257       /* If we have to allocate space for outgoing args, do it now.  */
7258       if (current_function_outgoing_args_size != 0)
7259         {
7260           rtx seq
7261             = emit_move_insn (stack_pointer_rtx,
7262                               plus_constant
7263                               (hard_frame_pointer_rtx,
7264                                - (ALPHA_ROUND
7265                                   (current_function_outgoing_args_size))));
7266
7267           /* Only set FRAME_RELATED_P on the stack adjustment we just emitted
7268              if ! frame_pointer_needed. Setting the bit will change the CFA
7269              computation rule to use sp again, which would be wrong if we had
7270              frame_pointer_needed, as this means sp might move unpredictably
7271              later on.
7272
7273              Also, note that
7274                frame_pointer_needed
7275                => vms_unwind_regno == HARD_FRAME_POINTER_REGNUM
7276              and
7277                current_function_outgoing_args_size != 0
7278                => alpha_procedure_type != PT_NULL,
7279
7280              so when we are not setting the bit here, we are guaranteed to
7281              have emitted an FRP frame pointer update just before.  */
7282           RTX_FRAME_RELATED_P (seq) = ! frame_pointer_needed;
7283         }
7284     }
7285   else if (!TARGET_ABI_UNICOSMK)
7286     {
7287       /* If we need a frame pointer, set it from the stack pointer.  */
7288       if (frame_pointer_needed)
7289         {
7290           if (TARGET_CAN_FAULT_IN_PROLOGUE)
7291             FRP (emit_move_insn (hard_frame_pointer_rtx, stack_pointer_rtx));
7292           else
7293             /* This must always be the last instruction in the
7294                prologue, thus we emit a special move + clobber.  */
7295               FRP (emit_insn (gen_init_fp (hard_frame_pointer_rtx,
7296                                            stack_pointer_rtx, sa_reg)));
7297         }
7298     }
7299
7300   /* The ABIs for VMS and OSF/1 say that while we can schedule insns into
7301      the prologue, for exception handling reasons, we cannot do this for
7302      any insn that might fault.  We could prevent this for mems with a
7303      (clobber:BLK (scratch)), but this doesn't work for fp insns.  So we
7304      have to prevent all such scheduling with a blockage.
7305
7306      Linux, on the other hand, never bothered to implement OSF/1's
7307      exception handling, and so doesn't care about such things.  Anyone
7308      planning to use dwarf2 frame-unwind info can also omit the blockage.  */
7309
7310   if (! TARGET_CAN_FAULT_IN_PROLOGUE)
7311     emit_insn (gen_blockage ());
7312 }
7313
7314 /* Output the textual info surrounding the prologue.  */
7315
7316 void
7317 alpha_start_function (FILE *file, const char *fnname,
7318                       tree decl ATTRIBUTE_UNUSED)
7319 {
7320   unsigned long imask = 0;
7321   unsigned long fmask = 0;
7322   /* Stack space needed for pushing registers clobbered by us.  */
7323   HOST_WIDE_INT sa_size;
7324   /* Complete stack size needed.  */
7325   unsigned HOST_WIDE_INT frame_size;
7326   /* Offset from base reg to register save area.  */
7327   HOST_WIDE_INT reg_offset;
7328   char *entry_label = (char *) alloca (strlen (fnname) + 6);
7329   int i;
7330
7331   /* Don't emit an extern directive for functions defined in the same file.  */
7332   if (TARGET_ABI_UNICOSMK)
7333     {
7334       tree name_tree;
7335       name_tree = get_identifier (fnname);
7336       TREE_ASM_WRITTEN (name_tree) = 1;
7337     }
7338
7339   alpha_fnname = fnname;
7340   sa_size = alpha_sa_size ();
7341
7342   frame_size = get_frame_size ();
7343   if (TARGET_ABI_OPEN_VMS)
7344     frame_size = ALPHA_ROUND (sa_size
7345                               + (alpha_procedure_type == PT_STACK ? 8 : 0)
7346                               + frame_size
7347                               + current_function_pretend_args_size);
7348   else if (TARGET_ABI_UNICOSMK)
7349     frame_size = ALPHA_ROUND (sa_size
7350                               + (alpha_procedure_type == PT_STACK ? 48 : 0))
7351                  + ALPHA_ROUND (frame_size
7352                               + current_function_outgoing_args_size);
7353   else
7354     frame_size = (ALPHA_ROUND (current_function_outgoing_args_size)
7355                   + sa_size
7356                   + ALPHA_ROUND (frame_size
7357                                  + current_function_pretend_args_size));
7358
7359   if (TARGET_ABI_OPEN_VMS)
7360     reg_offset = 8;
7361   else
7362     reg_offset = ALPHA_ROUND (current_function_outgoing_args_size);
7363
7364   alpha_sa_mask (&imask, &fmask);
7365
7366   /* Ecoff can handle multiple .file directives, so put out file and lineno.
7367      We have to do that before the .ent directive as we cannot switch
7368      files within procedures with native ecoff because line numbers are
7369      linked to procedure descriptors.
7370      Outputting the lineno helps debugging of one line functions as they
7371      would otherwise get no line number at all. Please note that we would
7372      like to put out last_linenum from final.c, but it is not accessible.  */
7373
7374   if (write_symbols == SDB_DEBUG)
7375     {
7376 #ifdef ASM_OUTPUT_SOURCE_FILENAME
7377       ASM_OUTPUT_SOURCE_FILENAME (file,
7378                                   DECL_SOURCE_FILE (current_function_decl));
7379 #endif
7380 #ifdef ASM_OUTPUT_SOURCE_LINE
7381       if (debug_info_level != DINFO_LEVEL_TERSE)
7382         ASM_OUTPUT_SOURCE_LINE (file,
7383                                 DECL_SOURCE_LINE (current_function_decl), 0);
7384 #endif
7385     }
7386
7387   /* Issue function start and label.  */
7388   if (TARGET_ABI_OPEN_VMS
7389       || (!TARGET_ABI_UNICOSMK && !flag_inhibit_size_directive))
7390     {
7391       fputs ("\t.ent ", file);
7392       assemble_name (file, fnname);
7393       putc ('\n', file);
7394
7395       /* If the function needs GP, we'll write the "..ng" label there.
7396          Otherwise, do it here.  */
7397       if (TARGET_ABI_OSF
7398           && ! alpha_function_needs_gp
7399           && ! current_function_is_thunk)
7400         {
7401           putc ('$', file);
7402           assemble_name (file, fnname);
7403           fputs ("..ng:\n", file);
7404         }
7405     }
7406
7407   strcpy (entry_label, fnname);
7408   if (TARGET_ABI_OPEN_VMS)
7409     strcat (entry_label, "..en");
7410
7411   /* For public functions, the label must be globalized by appending an
7412      additional colon.  */
7413   if (TARGET_ABI_UNICOSMK && TREE_PUBLIC (decl))
7414     strcat (entry_label, ":");
7415
7416   ASM_OUTPUT_LABEL (file, entry_label);
7417   inside_function = TRUE;
7418
7419   if (TARGET_ABI_OPEN_VMS)
7420     fprintf (file, "\t.base $%d\n", vms_base_regno);
7421
7422   if (!TARGET_ABI_OPEN_VMS && !TARGET_ABI_UNICOSMK && TARGET_IEEE_CONFORMANT
7423       && !flag_inhibit_size_directive)
7424     {
7425       /* Set flags in procedure descriptor to request IEEE-conformant
7426          math-library routines.  The value we set it to is PDSC_EXC_IEEE
7427          (/usr/include/pdsc.h).  */
7428       fputs ("\t.eflag 48\n", file);
7429     }
7430
7431   /* Set up offsets to alpha virtual arg/local debugging pointer.  */
7432   alpha_auto_offset = -frame_size + current_function_pretend_args_size;
7433   alpha_arg_offset = -frame_size + 48;
7434
7435   /* Describe our frame.  If the frame size is larger than an integer,
7436      print it as zero to avoid an assembler error.  We won't be
7437      properly describing such a frame, but that's the best we can do.  */
7438   if (TARGET_ABI_UNICOSMK)
7439     ;
7440   else if (TARGET_ABI_OPEN_VMS)
7441     fprintf (file, "\t.frame $%d," HOST_WIDE_INT_PRINT_DEC ",$26,"
7442              HOST_WIDE_INT_PRINT_DEC "\n",
7443              vms_unwind_regno,
7444              frame_size >= (1UL << 31) ? 0 : frame_size,
7445              reg_offset);
7446   else if (!flag_inhibit_size_directive)
7447     fprintf (file, "\t.frame $%d," HOST_WIDE_INT_PRINT_DEC ",$26,%d\n",
7448              (frame_pointer_needed
7449               ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM),
7450              frame_size >= (1UL << 31) ? 0 : frame_size,
7451              current_function_pretend_args_size);
7452
7453   /* Describe which registers were spilled.  */
7454   if (TARGET_ABI_UNICOSMK)
7455     ;
7456   else if (TARGET_ABI_OPEN_VMS)
7457     {
7458       if (imask)
7459         /* ??? Does VMS care if mask contains ra?  The old code didn't
7460            set it, so I don't here.  */
7461         fprintf (file, "\t.mask 0x%lx,0\n", imask & ~(1UL << REG_RA));
7462       if (fmask)
7463         fprintf (file, "\t.fmask 0x%lx,0\n", fmask);
7464       if (alpha_procedure_type == PT_REGISTER)
7465         fprintf (file, "\t.fp_save $%d\n", vms_save_fp_regno);
7466     }
7467   else if (!flag_inhibit_size_directive)
7468     {
7469       if (imask)
7470         {
7471           fprintf (file, "\t.mask 0x%lx," HOST_WIDE_INT_PRINT_DEC "\n", imask,
7472                    frame_size >= (1UL << 31) ? 0 : reg_offset - frame_size);
7473
7474           for (i = 0; i < 32; ++i)
7475             if (imask & (1UL << i))
7476               reg_offset += 8;
7477         }
7478
7479       if (fmask)
7480         fprintf (file, "\t.fmask 0x%lx," HOST_WIDE_INT_PRINT_DEC "\n", fmask,
7481                  frame_size >= (1UL << 31) ? 0 : reg_offset - frame_size);
7482     }
7483
7484 #if TARGET_ABI_OPEN_VMS
7485   /* Ifdef'ed cause link_section are only available then.  */
7486   readonly_data_section ();
7487   fprintf (file, "\t.align 3\n");
7488   assemble_name (file, fnname); fputs ("..na:\n", file);
7489   fputs ("\t.ascii \"", file);
7490   assemble_name (file, fnname);
7491   fputs ("\\0\"\n", file);
7492   alpha_need_linkage (fnname, 1);
7493   text_section ();
7494 #endif
7495 }
7496
7497 /* Emit the .prologue note at the scheduled end of the prologue.  */
7498
7499 static void
7500 alpha_output_function_end_prologue (FILE *file)
7501 {
7502   if (TARGET_ABI_UNICOSMK)
7503     ;
7504   else if (TARGET_ABI_OPEN_VMS)
7505     fputs ("\t.prologue\n", file);
7506   else if (TARGET_ABI_WINDOWS_NT)
7507     fputs ("\t.prologue 0\n", file);
7508   else if (!flag_inhibit_size_directive)
7509     fprintf (file, "\t.prologue %d\n",
7510              alpha_function_needs_gp || current_function_is_thunk);
7511 }
7512
7513 /* Write function epilogue.  */
7514
7515 /* ??? At some point we will want to support full unwind, and so will
7516    need to mark the epilogue as well.  At the moment, we just confuse
7517    dwarf2out.  */
7518 #undef FRP
7519 #define FRP(exp) exp
7520
7521 void
7522 alpha_expand_epilogue (void)
7523 {
7524   /* Registers to save.  */
7525   unsigned long imask = 0;
7526   unsigned long fmask = 0;
7527   /* Stack space needed for pushing registers clobbered by us.  */
7528   HOST_WIDE_INT sa_size;
7529   /* Complete stack size needed.  */
7530   HOST_WIDE_INT frame_size;
7531   /* Offset from base reg to register save area.  */
7532   HOST_WIDE_INT reg_offset;
7533   int fp_is_frame_pointer, fp_offset;
7534   rtx sa_reg, sa_reg_exp = NULL;
7535   rtx sp_adj1, sp_adj2, mem;
7536   rtx eh_ofs;
7537   int i;
7538
7539   sa_size = alpha_sa_size ();
7540
7541   frame_size = get_frame_size ();
7542   if (TARGET_ABI_OPEN_VMS)
7543     frame_size = ALPHA_ROUND (sa_size
7544                               + (alpha_procedure_type == PT_STACK ? 8 : 0)
7545                               + frame_size
7546                               + current_function_pretend_args_size);
7547   else if (TARGET_ABI_UNICOSMK)
7548     frame_size = ALPHA_ROUND (sa_size
7549                               + (alpha_procedure_type == PT_STACK ? 48 : 0))
7550                  + ALPHA_ROUND (frame_size
7551                               + current_function_outgoing_args_size);
7552   else
7553     frame_size = (ALPHA_ROUND (current_function_outgoing_args_size)
7554                   + sa_size
7555                   + ALPHA_ROUND (frame_size
7556                                  + current_function_pretend_args_size));
7557
7558   if (TARGET_ABI_OPEN_VMS)
7559     {
7560        if (alpha_procedure_type == PT_STACK)
7561           reg_offset = 8;
7562        else
7563           reg_offset = 0;
7564     }
7565   else
7566     reg_offset = ALPHA_ROUND (current_function_outgoing_args_size);
7567
7568   alpha_sa_mask (&imask, &fmask);
7569
7570   fp_is_frame_pointer
7571     = ((TARGET_ABI_OPEN_VMS && alpha_procedure_type == PT_STACK)
7572        || (!TARGET_ABI_OPEN_VMS && frame_pointer_needed));
7573   fp_offset = 0;
7574   sa_reg = stack_pointer_rtx;
7575
7576   if (current_function_calls_eh_return)
7577     eh_ofs = EH_RETURN_STACKADJ_RTX;
7578   else
7579     eh_ofs = NULL_RTX;
7580
7581   if (!TARGET_ABI_UNICOSMK && sa_size)
7582     {
7583       /* If we have a frame pointer, restore SP from it.  */
7584       if ((TARGET_ABI_OPEN_VMS
7585            && vms_unwind_regno == HARD_FRAME_POINTER_REGNUM)
7586           || (!TARGET_ABI_OPEN_VMS && frame_pointer_needed))
7587         FRP (emit_move_insn (stack_pointer_rtx, hard_frame_pointer_rtx));
7588
7589       /* Cope with very large offsets to the register save area.  */
7590       if (reg_offset + sa_size > 0x8000)
7591         {
7592           int low = ((reg_offset & 0xffff) ^ 0x8000) - 0x8000;
7593           HOST_WIDE_INT bias;
7594
7595           if (low + sa_size <= 0x8000)
7596             bias = reg_offset - low, reg_offset = low;
7597           else
7598             bias = reg_offset, reg_offset = 0;
7599
7600           sa_reg = gen_rtx_REG (DImode, 22);
7601           sa_reg_exp = plus_constant (stack_pointer_rtx, bias);
7602
7603           FRP (emit_move_insn (sa_reg, sa_reg_exp));
7604         }
7605
7606       /* Restore registers in order, excepting a true frame pointer.  */
7607
7608       mem = gen_rtx_MEM (DImode, plus_constant (sa_reg, reg_offset));
7609       if (! eh_ofs)
7610         set_mem_alias_set (mem, alpha_sr_alias_set);
7611       FRP (emit_move_insn (gen_rtx_REG (DImode, REG_RA), mem));
7612
7613       reg_offset += 8;
7614       imask &= ~(1UL << REG_RA);
7615
7616       for (i = 0; i < 31; ++i)
7617         if (imask & (1UL << i))
7618           {
7619             if (i == HARD_FRAME_POINTER_REGNUM && fp_is_frame_pointer)
7620               fp_offset = reg_offset;
7621             else
7622               {
7623                 mem = gen_rtx_MEM (DImode, plus_constant(sa_reg, reg_offset));
7624                 set_mem_alias_set (mem, alpha_sr_alias_set);
7625                 FRP (emit_move_insn (gen_rtx_REG (DImode, i), mem));
7626               }
7627             reg_offset += 8;
7628           }
7629
7630       if (imask & (1UL << 31))
7631         reg_offset += 8;
7632
7633       for (i = 0; i < 31; ++i)
7634         if (fmask & (1UL << i))
7635           {
7636             mem = gen_rtx_MEM (DFmode, plus_constant(sa_reg, reg_offset));
7637             set_mem_alias_set (mem, alpha_sr_alias_set);
7638             FRP (emit_move_insn (gen_rtx_REG (DFmode, i+32), mem));
7639             reg_offset += 8;
7640           }
7641     }
7642   else if (TARGET_ABI_UNICOSMK && alpha_procedure_type == PT_STACK)
7643     {
7644       /* Restore callee-saved general-purpose registers.  */
7645
7646       reg_offset = -56;
7647
7648       for (i = 9; i < 15; i++)
7649         if (imask & (1UL << i))
7650           {
7651             mem = gen_rtx_MEM (DImode, plus_constant(hard_frame_pointer_rtx,
7652                                                      reg_offset));
7653             set_mem_alias_set (mem, alpha_sr_alias_set);
7654             FRP (emit_move_insn (gen_rtx_REG (DImode, i), mem));
7655             reg_offset -= 8;
7656           }
7657
7658       for (i = 2; i < 10; i++)
7659         if (fmask & (1UL << i))
7660           {
7661             mem = gen_rtx_MEM (DFmode, plus_constant(hard_frame_pointer_rtx,
7662                                                      reg_offset));
7663             set_mem_alias_set (mem, alpha_sr_alias_set);
7664             FRP (emit_move_insn (gen_rtx_REG (DFmode, i+32), mem));
7665             reg_offset -= 8;
7666           }
7667
7668       /* Restore the return address from the DSIB.  */
7669
7670       mem = gen_rtx_MEM (DImode, plus_constant(hard_frame_pointer_rtx, -8));
7671       set_mem_alias_set (mem, alpha_sr_alias_set);
7672       FRP (emit_move_insn (gen_rtx_REG (DImode, REG_RA), mem));
7673     }
7674
7675   if (frame_size || eh_ofs)
7676     {
7677       sp_adj1 = stack_pointer_rtx;
7678
7679       if (eh_ofs)
7680         {
7681           sp_adj1 = gen_rtx_REG (DImode, 23);
7682           emit_move_insn (sp_adj1,
7683                           gen_rtx_PLUS (Pmode, stack_pointer_rtx, eh_ofs));
7684         }
7685
7686       /* If the stack size is large, begin computation into a temporary
7687          register so as not to interfere with a potential fp restore,
7688          which must be consecutive with an SP restore.  */
7689       if (frame_size < 32768
7690           && ! (TARGET_ABI_UNICOSMK && current_function_calls_alloca))
7691         sp_adj2 = GEN_INT (frame_size);
7692       else if (TARGET_ABI_UNICOSMK)
7693         {
7694           sp_adj1 = gen_rtx_REG (DImode, 23);
7695           FRP (emit_move_insn (sp_adj1, hard_frame_pointer_rtx));
7696           sp_adj2 = const0_rtx;
7697         }
7698       else if (frame_size < 0x40007fffL)
7699         {
7700           int low = ((frame_size & 0xffff) ^ 0x8000) - 0x8000;
7701
7702           sp_adj2 = plus_constant (sp_adj1, frame_size - low);
7703           if (sa_reg_exp && rtx_equal_p (sa_reg_exp, sp_adj2))
7704             sp_adj1 = sa_reg;
7705           else
7706             {
7707               sp_adj1 = gen_rtx_REG (DImode, 23);
7708               FRP (emit_move_insn (sp_adj1, sp_adj2));
7709             }
7710           sp_adj2 = GEN_INT (low);
7711         }
7712       else
7713         {
7714           rtx tmp = gen_rtx_REG (DImode, 23);
7715           FRP (sp_adj2 = alpha_emit_set_const (tmp, DImode, frame_size, 3));
7716           if (!sp_adj2)
7717             {
7718               /* We can't drop new things to memory this late, afaik,
7719                  so build it up by pieces.  */
7720               FRP (sp_adj2 = alpha_emit_set_long_const (tmp, frame_size,
7721                                                         -(frame_size < 0)));
7722               if (!sp_adj2)
7723                 abort ();
7724             }
7725         }
7726
7727       /* From now on, things must be in order.  So emit blockages.  */
7728
7729       /* Restore the frame pointer.  */
7730       if (TARGET_ABI_UNICOSMK)
7731         {
7732           emit_insn (gen_blockage ());
7733           mem = gen_rtx_MEM (DImode,
7734                              plus_constant (hard_frame_pointer_rtx, -16));
7735           set_mem_alias_set (mem, alpha_sr_alias_set);
7736           FRP (emit_move_insn (hard_frame_pointer_rtx, mem));
7737         }
7738       else if (fp_is_frame_pointer)
7739         {
7740           emit_insn (gen_blockage ());
7741           mem = gen_rtx_MEM (DImode, plus_constant (sa_reg, fp_offset));
7742           set_mem_alias_set (mem, alpha_sr_alias_set);
7743           FRP (emit_move_insn (hard_frame_pointer_rtx, mem));
7744         }
7745       else if (TARGET_ABI_OPEN_VMS)
7746         {
7747           emit_insn (gen_blockage ());
7748           FRP (emit_move_insn (hard_frame_pointer_rtx,
7749                                gen_rtx_REG (DImode, vms_save_fp_regno)));
7750         }
7751
7752       /* Restore the stack pointer.  */
7753       emit_insn (gen_blockage ());
7754       if (sp_adj2 == const0_rtx)
7755         FRP (emit_move_insn (stack_pointer_rtx, sp_adj1));
7756       else
7757         FRP (emit_move_insn (stack_pointer_rtx,
7758                              gen_rtx_PLUS (DImode, sp_adj1, sp_adj2)));
7759     }
7760   else
7761     {
7762       if (TARGET_ABI_OPEN_VMS && alpha_procedure_type == PT_REGISTER)
7763         {
7764           emit_insn (gen_blockage ());
7765           FRP (emit_move_insn (hard_frame_pointer_rtx,
7766                                gen_rtx_REG (DImode, vms_save_fp_regno)));
7767         }
7768       else if (TARGET_ABI_UNICOSMK && alpha_procedure_type != PT_STACK)
7769         {
7770           /* Decrement the frame pointer if the function does not have a
7771              frame.  */
7772
7773           emit_insn (gen_blockage ());
7774           FRP (emit_insn (gen_adddi3 (hard_frame_pointer_rtx,
7775                                       hard_frame_pointer_rtx, GEN_INT (-1))));
7776         }
7777     }
7778 }
7779 \f
7780 /* Output the rest of the textual info surrounding the epilogue.  */
7781
7782 void
7783 alpha_end_function (FILE *file, const char *fnname, tree decl ATTRIBUTE_UNUSED)
7784 {
7785   /* End the function.  */
7786   if (!TARGET_ABI_UNICOSMK && !flag_inhibit_size_directive)
7787     {
7788       fputs ("\t.end ", file);
7789       assemble_name (file, fnname);
7790       putc ('\n', file);
7791     }
7792   inside_function = FALSE;
7793
7794 #if TARGET_ABI_OPEN_VMS
7795   alpha_write_linkage (file, fnname, decl);
7796 #endif
7797
7798   /* Output jump tables and the static subroutine information block.  */
7799   if (TARGET_ABI_UNICOSMK)
7800     {
7801       unicosmk_output_ssib (file, fnname);
7802       unicosmk_output_deferred_case_vectors (file);
7803     }
7804 }
7805
7806 #if TARGET_ABI_OSF
7807 /* Emit a tail call to FUNCTION after adjusting THIS by DELTA.
7808
7809    In order to avoid the hordes of differences between generated code
7810    with and without TARGET_EXPLICIT_RELOCS, and to avoid duplicating
7811    lots of code loading up large constants, generate rtl and emit it
7812    instead of going straight to text.
7813
7814    Not sure why this idea hasn't been explored before...  */
7815
7816 static void
7817 alpha_output_mi_thunk_osf (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
7818                            HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
7819                            tree function)
7820 {
7821   HOST_WIDE_INT hi, lo;
7822   rtx this, insn, funexp;
7823
7824   /* We always require a valid GP.  */
7825   emit_insn (gen_prologue_ldgp ());
7826   emit_note (NOTE_INSN_PROLOGUE_END);
7827
7828   /* Find the "this" pointer.  If the function returns a structure,
7829      the structure return pointer is in $16.  */
7830   if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
7831     this = gen_rtx_REG (Pmode, 17);
7832   else
7833     this = gen_rtx_REG (Pmode, 16);
7834
7835   /* Add DELTA.  When possible we use ldah+lda.  Otherwise load the
7836      entire constant for the add.  */
7837   lo = ((delta & 0xffff) ^ 0x8000) - 0x8000;
7838   hi = (((delta - lo) & 0xffffffff) ^ 0x80000000) - 0x80000000;
7839   if (hi + lo == delta)
7840     {
7841       if (hi)
7842         emit_insn (gen_adddi3 (this, this, GEN_INT (hi)));
7843       if (lo)
7844         emit_insn (gen_adddi3 (this, this, GEN_INT (lo)));
7845     }
7846   else
7847     {
7848       rtx tmp = alpha_emit_set_long_const (gen_rtx_REG (Pmode, 0),
7849                                            delta, -(delta < 0));
7850       emit_insn (gen_adddi3 (this, this, tmp));
7851     }
7852
7853   /* Add a delta stored in the vtable at VCALL_OFFSET.  */
7854   if (vcall_offset)
7855     {
7856       rtx tmp, tmp2;
7857
7858       tmp = gen_rtx_REG (Pmode, 0);
7859       emit_move_insn (tmp, gen_rtx_MEM (Pmode, this));
7860
7861       lo = ((vcall_offset & 0xffff) ^ 0x8000) - 0x8000;
7862       hi = (((vcall_offset - lo) & 0xffffffff) ^ 0x80000000) - 0x80000000;
7863       if (hi + lo == vcall_offset)
7864         {
7865           if (hi)
7866             emit_insn (gen_adddi3 (tmp, tmp, GEN_INT (hi)));
7867         }
7868       else
7869         {
7870           tmp2 = alpha_emit_set_long_const (gen_rtx_REG (Pmode, 1),
7871                                             vcall_offset, -(vcall_offset < 0));
7872           emit_insn (gen_adddi3 (tmp, tmp, tmp2));
7873           lo = 0;
7874         }
7875       if (lo)
7876         tmp2 = gen_rtx_PLUS (Pmode, tmp, GEN_INT (lo));
7877       else
7878         tmp2 = tmp;
7879       emit_move_insn (tmp, gen_rtx_MEM (Pmode, tmp2));
7880
7881       emit_insn (gen_adddi3 (this, this, tmp));
7882     }
7883
7884   /* Generate a tail call to the target function.  */
7885   if (! TREE_USED (function))
7886     {
7887       assemble_external (function);
7888       TREE_USED (function) = 1;
7889     }
7890   funexp = XEXP (DECL_RTL (function), 0);
7891   funexp = gen_rtx_MEM (FUNCTION_MODE, funexp);
7892   insn = emit_call_insn (gen_sibcall (funexp, const0_rtx));
7893   SIBLING_CALL_P (insn) = 1;
7894
7895   /* Run just enough of rest_of_compilation to get the insns emitted.
7896      There's not really enough bulk here to make other passes such as
7897      instruction scheduling worth while.  Note that use_thunk calls
7898      assemble_start_function and assemble_end_function.  */
7899   insn = get_insns ();
7900   insn_locators_initialize ();
7901   shorten_branches (insn);
7902   final_start_function (insn, file, 1);
7903   final (insn, file, 1, 0);
7904   final_end_function ();
7905 }
7906 #endif /* TARGET_ABI_OSF */
7907 \f
7908 /* Debugging support.  */
7909
7910 #include "gstab.h"
7911
7912 /* Count the number of sdb related labels are generated (to find block
7913    start and end boundaries).  */
7914
7915 int sdb_label_count = 0;
7916
7917 /* Next label # for each statement.  */
7918
7919 static int sym_lineno = 0;
7920
7921 /* Count the number of .file directives, so that .loc is up to date.  */
7922
7923 static int num_source_filenames = 0;
7924
7925 /* Name of the file containing the current function.  */
7926
7927 static const char *current_function_file = "";
7928
7929 /* Offsets to alpha virtual arg/local debugging pointers.  */
7930
7931 long alpha_arg_offset;
7932 long alpha_auto_offset;
7933 \f
7934 /* Emit a new filename to a stream.  */
7935
7936 void
7937 alpha_output_filename (FILE *stream, const char *name)
7938 {
7939   static int first_time = TRUE;
7940   char ltext_label_name[100];
7941
7942   if (first_time)
7943     {
7944       first_time = FALSE;
7945       ++num_source_filenames;
7946       current_function_file = name;
7947       fprintf (stream, "\t.file\t%d ", num_source_filenames);
7948       output_quoted_string (stream, name);
7949       fprintf (stream, "\n");
7950       if (!TARGET_GAS && write_symbols == DBX_DEBUG)
7951         fprintf (stream, "\t#@stabs\n");
7952     }
7953
7954   else if (write_symbols == DBX_DEBUG)
7955     {
7956       ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
7957       fprintf (stream, "%s", ASM_STABS_OP);
7958       output_quoted_string (stream, name);
7959       fprintf (stream, ",%d,0,0,%s\n", N_SOL, &ltext_label_name[1]);
7960     }
7961
7962   else if (name != current_function_file
7963            && strcmp (name, current_function_file) != 0)
7964     {
7965       if (inside_function && ! TARGET_GAS)
7966         fprintf (stream, "\t#.file\t%d ", num_source_filenames);
7967       else
7968         {
7969           ++num_source_filenames;
7970           current_function_file = name;
7971           fprintf (stream, "\t.file\t%d ", num_source_filenames);
7972         }
7973
7974       output_quoted_string (stream, name);
7975       fprintf (stream, "\n");
7976     }
7977 }
7978
7979 /* Emit a linenumber to a stream.  */
7980
7981 void
7982 alpha_output_lineno (FILE *stream, int line)
7983 {
7984   if (write_symbols == DBX_DEBUG)
7985     {
7986       /* mips-tfile doesn't understand .stabd directives.  */
7987       ++sym_lineno;
7988       fprintf (stream, "$LM%d:\n%s%d,0,%d,$LM%d\n",
7989                sym_lineno, ASM_STABN_OP, N_SLINE, line, sym_lineno);
7990     }
7991   else
7992     fprintf (stream, "\n\t.loc\t%d %d\n", num_source_filenames, line);
7993 }
7994 \f
7995 /* Structure to show the current status of registers and memory.  */
7996
7997 struct shadow_summary
7998 {
7999   struct {
8000     unsigned int i     : 31;    /* Mask of int regs */
8001     unsigned int fp    : 31;    /* Mask of fp regs */
8002     unsigned int mem   :  1;    /* mem == imem | fpmem */
8003   } used, defd;
8004 };
8005
8006 /* Summary the effects of expression X on the machine.  Update SUM, a pointer
8007    to the summary structure.  SET is nonzero if the insn is setting the
8008    object, otherwise zero.  */
8009
8010 static void
8011 summarize_insn (rtx x, struct shadow_summary *sum, int set)
8012 {
8013   const char *format_ptr;
8014   int i, j;
8015
8016   if (x == 0)
8017     return;
8018
8019   switch (GET_CODE (x))
8020     {
8021       /* ??? Note that this case would be incorrect if the Alpha had a
8022          ZERO_EXTRACT in SET_DEST.  */
8023     case SET:
8024       summarize_insn (SET_SRC (x), sum, 0);
8025       summarize_insn (SET_DEST (x), sum, 1);
8026       break;
8027
8028     case CLOBBER:
8029       summarize_insn (XEXP (x, 0), sum, 1);
8030       break;
8031
8032     case USE:
8033       summarize_insn (XEXP (x, 0), sum, 0);
8034       break;
8035
8036     case ASM_OPERANDS:
8037       for (i = ASM_OPERANDS_INPUT_LENGTH (x) - 1; i >= 0; i--)
8038         summarize_insn (ASM_OPERANDS_INPUT (x, i), sum, 0);
8039       break;
8040
8041     case PARALLEL:
8042       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
8043         summarize_insn (XVECEXP (x, 0, i), sum, 0);
8044       break;
8045
8046     case SUBREG:
8047       summarize_insn (SUBREG_REG (x), sum, 0);
8048       break;
8049
8050     case REG:
8051       {
8052         int regno = REGNO (x);
8053         unsigned long mask = ((unsigned long) 1) << (regno % 32);
8054
8055         if (regno == 31 || regno == 63)
8056           break;
8057
8058         if (set)
8059           {
8060             if (regno < 32)
8061               sum->defd.i |= mask;
8062             else
8063               sum->defd.fp |= mask;
8064           }
8065         else
8066           {
8067             if (regno < 32)
8068               sum->used.i  |= mask;
8069             else
8070               sum->used.fp |= mask;
8071           }
8072         }
8073       break;
8074
8075     case MEM:
8076       if (set)
8077         sum->defd.mem = 1;
8078       else
8079         sum->used.mem = 1;
8080
8081       /* Find the regs used in memory address computation: */
8082       summarize_insn (XEXP (x, 0), sum, 0);
8083       break;
8084
8085     case CONST_INT:   case CONST_DOUBLE:
8086     case SYMBOL_REF:  case LABEL_REF:     case CONST:
8087     case SCRATCH:     case ASM_INPUT:
8088       break;
8089
8090       /* Handle common unary and binary ops for efficiency.  */
8091     case COMPARE:  case PLUS:    case MINUS:   case MULT:      case DIV:
8092     case MOD:      case UDIV:    case UMOD:    case AND:       case IOR:
8093     case XOR:      case ASHIFT:  case ROTATE:  case ASHIFTRT:  case LSHIFTRT:
8094     case ROTATERT: case SMIN:    case SMAX:    case UMIN:      case UMAX:
8095     case NE:       case EQ:      case GE:      case GT:        case LE:
8096     case LT:       case GEU:     case GTU:     case LEU:       case LTU:
8097       summarize_insn (XEXP (x, 0), sum, 0);
8098       summarize_insn (XEXP (x, 1), sum, 0);
8099       break;
8100
8101     case NEG:  case NOT:  case SIGN_EXTEND:  case ZERO_EXTEND:
8102     case TRUNCATE:  case FLOAT_EXTEND:  case FLOAT_TRUNCATE:  case FLOAT:
8103     case FIX:  case UNSIGNED_FLOAT:  case UNSIGNED_FIX:  case ABS:
8104     case SQRT:  case FFS:
8105       summarize_insn (XEXP (x, 0), sum, 0);
8106       break;
8107
8108     default:
8109       format_ptr = GET_RTX_FORMAT (GET_CODE (x));
8110       for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
8111         switch (format_ptr[i])
8112           {
8113           case 'e':
8114             summarize_insn (XEXP (x, i), sum, 0);
8115             break;
8116
8117           case 'E':
8118             for (j = XVECLEN (x, i) - 1; j >= 0; j--)
8119               summarize_insn (XVECEXP (x, i, j), sum, 0);
8120             break;
8121
8122           case 'i':
8123             break;
8124
8125           default:
8126             abort ();
8127           }
8128     }
8129 }
8130
8131 /* Ensure a sufficient number of `trapb' insns are in the code when
8132    the user requests code with a trap precision of functions or
8133    instructions.
8134
8135    In naive mode, when the user requests a trap-precision of
8136    "instruction", a trapb is needed after every instruction that may
8137    generate a trap.  This ensures that the code is resumption safe but
8138    it is also slow.
8139
8140    When optimizations are turned on, we delay issuing a trapb as long
8141    as possible.  In this context, a trap shadow is the sequence of
8142    instructions that starts with a (potentially) trap generating
8143    instruction and extends to the next trapb or call_pal instruction
8144    (but GCC never generates call_pal by itself).  We can delay (and
8145    therefore sometimes omit) a trapb subject to the following
8146    conditions:
8147
8148    (a) On entry to the trap shadow, if any Alpha register or memory
8149    location contains a value that is used as an operand value by some
8150    instruction in the trap shadow (live on entry), then no instruction
8151    in the trap shadow may modify the register or memory location.
8152
8153    (b) Within the trap shadow, the computation of the base register
8154    for a memory load or store instruction may not involve using the
8155    result of an instruction that might generate an UNPREDICTABLE
8156    result.
8157
8158    (c) Within the trap shadow, no register may be used more than once
8159    as a destination register.  (This is to make life easier for the
8160    trap-handler.)
8161
8162    (d) The trap shadow may not include any branch instructions.  */
8163
8164 static void
8165 alpha_handle_trap_shadows (void)
8166 {
8167   struct shadow_summary shadow;
8168   int trap_pending, exception_nesting;
8169   rtx i, n;
8170
8171   trap_pending = 0;
8172   exception_nesting = 0;
8173   shadow.used.i = 0;
8174   shadow.used.fp = 0;
8175   shadow.used.mem = 0;
8176   shadow.defd = shadow.used;
8177
8178   for (i = get_insns (); i ; i = NEXT_INSN (i))
8179     {
8180       if (GET_CODE (i) == NOTE)
8181         {
8182           switch (NOTE_LINE_NUMBER (i))
8183             {
8184             case NOTE_INSN_EH_REGION_BEG:
8185               exception_nesting++;
8186               if (trap_pending)
8187                 goto close_shadow;
8188               break;
8189
8190             case NOTE_INSN_EH_REGION_END:
8191               exception_nesting--;
8192               if (trap_pending)
8193                 goto close_shadow;
8194               break;
8195
8196             case NOTE_INSN_EPILOGUE_BEG:
8197               if (trap_pending && alpha_tp >= ALPHA_TP_FUNC)
8198                 goto close_shadow;
8199               break;
8200             }
8201         }
8202       else if (trap_pending)
8203         {
8204           if (alpha_tp == ALPHA_TP_FUNC)
8205             {
8206               if (GET_CODE (i) == JUMP_INSN
8207                   && GET_CODE (PATTERN (i)) == RETURN)
8208                 goto close_shadow;
8209             }
8210           else if (alpha_tp == ALPHA_TP_INSN)
8211             {
8212               if (optimize > 0)
8213                 {
8214                   struct shadow_summary sum;
8215
8216                   sum.used.i = 0;
8217                   sum.used.fp = 0;
8218                   sum.used.mem = 0;
8219                   sum.defd = sum.used;
8220
8221                   switch (GET_CODE (i))
8222                     {
8223                     case INSN:
8224                       /* Annoyingly, get_attr_trap will abort on these.  */
8225                       if (GET_CODE (PATTERN (i)) == USE
8226                           || GET_CODE (PATTERN (i)) == CLOBBER)
8227                         break;
8228
8229                       summarize_insn (PATTERN (i), &sum, 0);
8230
8231                       if ((sum.defd.i & shadow.defd.i)
8232                           || (sum.defd.fp & shadow.defd.fp))
8233                         {
8234                           /* (c) would be violated */
8235                           goto close_shadow;
8236                         }
8237
8238                       /* Combine shadow with summary of current insn: */
8239                       shadow.used.i   |= sum.used.i;
8240                       shadow.used.fp  |= sum.used.fp;
8241                       shadow.used.mem |= sum.used.mem;
8242                       shadow.defd.i   |= sum.defd.i;
8243                       shadow.defd.fp  |= sum.defd.fp;
8244                       shadow.defd.mem |= sum.defd.mem;
8245
8246                       if ((sum.defd.i & shadow.used.i)
8247                           || (sum.defd.fp & shadow.used.fp)
8248                           || (sum.defd.mem & shadow.used.mem))
8249                         {
8250                           /* (a) would be violated (also takes care of (b))  */
8251                           if (get_attr_trap (i) == TRAP_YES
8252                               && ((sum.defd.i & sum.used.i)
8253                                   || (sum.defd.fp & sum.used.fp)))
8254                             abort ();
8255
8256                           goto close_shadow;
8257                         }
8258                       break;
8259
8260                     case JUMP_INSN:
8261                     case CALL_INSN:
8262                     case CODE_LABEL:
8263                       goto close_shadow;
8264
8265                     default:
8266                       abort ();
8267                     }
8268                 }
8269               else
8270                 {
8271                 close_shadow:
8272                   n = emit_insn_before (gen_trapb (), i);
8273                   PUT_MODE (n, TImode);
8274                   PUT_MODE (i, TImode);
8275                   trap_pending = 0;
8276                   shadow.used.i = 0;
8277                   shadow.used.fp = 0;
8278                   shadow.used.mem = 0;
8279                   shadow.defd = shadow.used;
8280                 }
8281             }
8282         }
8283
8284       if ((exception_nesting > 0 || alpha_tp >= ALPHA_TP_FUNC)
8285           && GET_CODE (i) == INSN
8286           && GET_CODE (PATTERN (i)) != USE
8287           && GET_CODE (PATTERN (i)) != CLOBBER
8288           && get_attr_trap (i) == TRAP_YES)
8289         {
8290           if (optimize && !trap_pending)
8291             summarize_insn (PATTERN (i), &shadow, 0);
8292           trap_pending = 1;
8293         }
8294     }
8295 }
8296 \f
8297 /* Alpha can only issue instruction groups simultaneously if they are
8298    suitably aligned.  This is very processor-specific.  */
8299
8300 enum alphaev4_pipe {
8301   EV4_STOP = 0,
8302   EV4_IB0 = 1,
8303   EV4_IB1 = 2,
8304   EV4_IBX = 4
8305 };
8306
8307 enum alphaev5_pipe {
8308   EV5_STOP = 0,
8309   EV5_NONE = 1,
8310   EV5_E01 = 2,
8311   EV5_E0 = 4,
8312   EV5_E1 = 8,
8313   EV5_FAM = 16,
8314   EV5_FA = 32,
8315   EV5_FM = 64
8316 };
8317
8318 static enum alphaev4_pipe
8319 alphaev4_insn_pipe (rtx insn)
8320 {
8321   if (recog_memoized (insn) < 0)
8322     return EV4_STOP;
8323   if (get_attr_length (insn) != 4)
8324     return EV4_STOP;
8325
8326   switch (get_attr_type (insn))
8327     {
8328     case TYPE_ILD:
8329     case TYPE_FLD:
8330       return EV4_IBX;
8331
8332     case TYPE_LDSYM:
8333     case TYPE_IADD:
8334     case TYPE_ILOG:
8335     case TYPE_ICMOV:
8336     case TYPE_ICMP:
8337     case TYPE_IST:
8338     case TYPE_FST:
8339     case TYPE_SHIFT:
8340     case TYPE_IMUL:
8341     case TYPE_FBR:
8342       return EV4_IB0;
8343
8344     case TYPE_MISC:
8345     case TYPE_IBR:
8346     case TYPE_JSR:
8347     case TYPE_CALLPAL:
8348     case TYPE_FCPYS:
8349     case TYPE_FCMOV:
8350     case TYPE_FADD:
8351     case TYPE_FDIV:
8352     case TYPE_FMUL:
8353       return EV4_IB1;
8354
8355     default:
8356       abort ();
8357     }
8358 }
8359
8360 static enum alphaev5_pipe
8361 alphaev5_insn_pipe (rtx insn)
8362 {
8363   if (recog_memoized (insn) < 0)
8364     return EV5_STOP;
8365   if (get_attr_length (insn) != 4)
8366     return EV5_STOP;
8367
8368   switch (get_attr_type (insn))
8369     {
8370     case TYPE_ILD:
8371     case TYPE_FLD:
8372     case TYPE_LDSYM:
8373     case TYPE_IADD:
8374     case TYPE_ILOG:
8375     case TYPE_ICMOV:
8376     case TYPE_ICMP:
8377       return EV5_E01;
8378
8379     case TYPE_IST:
8380     case TYPE_FST:
8381     case TYPE_SHIFT:
8382     case TYPE_IMUL:
8383     case TYPE_MISC:
8384     case TYPE_MVI:
8385       return EV5_E0;
8386
8387     case TYPE_IBR:
8388     case TYPE_JSR:
8389     case TYPE_CALLPAL:
8390       return EV5_E1;
8391
8392     case TYPE_FCPYS:
8393       return EV5_FAM;
8394
8395     case TYPE_FBR:
8396     case TYPE_FCMOV:
8397     case TYPE_FADD:
8398     case TYPE_FDIV:
8399       return EV5_FA;
8400
8401     case TYPE_FMUL:
8402       return EV5_FM;
8403
8404     default:
8405       abort();
8406     }
8407 }
8408
8409 /* IN_USE is a mask of the slots currently filled within the insn group.
8410    The mask bits come from alphaev4_pipe above.  If EV4_IBX is set, then
8411    the insn in EV4_IB0 can be swapped by the hardware into EV4_IB1.
8412
8413    LEN is, of course, the length of the group in bytes.  */
8414
8415 static rtx
8416 alphaev4_next_group (rtx insn, int *pin_use, int *plen)
8417 {
8418   int len, in_use;
8419
8420   len = in_use = 0;
8421
8422   if (! INSN_P (insn)
8423       || GET_CODE (PATTERN (insn)) == CLOBBER
8424       || GET_CODE (PATTERN (insn)) == USE)
8425     goto next_and_done;
8426
8427   while (1)
8428     {
8429       enum alphaev4_pipe pipe;
8430
8431       pipe = alphaev4_insn_pipe (insn);
8432       switch (pipe)
8433         {
8434         case EV4_STOP:
8435           /* Force complex instructions to start new groups.  */
8436           if (in_use)
8437             goto done;
8438
8439           /* If this is a completely unrecognized insn, its an asm.
8440              We don't know how long it is, so record length as -1 to
8441              signal a needed realignment.  */
8442           if (recog_memoized (insn) < 0)
8443             len = -1;
8444           else
8445             len = get_attr_length (insn);
8446           goto next_and_done;
8447
8448         case EV4_IBX:
8449           if (in_use & EV4_IB0)
8450             {
8451               if (in_use & EV4_IB1)
8452                 goto done;
8453               in_use |= EV4_IB1;
8454             }
8455           else
8456             in_use |= EV4_IB0 | EV4_IBX;
8457           break;
8458
8459         case EV4_IB0:
8460           if (in_use & EV4_IB0)
8461             {
8462               if (!(in_use & EV4_IBX) || (in_use & EV4_IB1))
8463                 goto done;
8464               in_use |= EV4_IB1;
8465             }
8466           in_use |= EV4_IB0;
8467           break;
8468
8469         case EV4_IB1:
8470           if (in_use & EV4_IB1)
8471             goto done;
8472           in_use |= EV4_IB1;
8473           break;
8474
8475         default:
8476           abort();
8477         }
8478       len += 4;
8479
8480       /* Haifa doesn't do well scheduling branches.  */
8481       if (GET_CODE (insn) == JUMP_INSN)
8482         goto next_and_done;
8483
8484     next:
8485       insn = next_nonnote_insn (insn);
8486
8487       if (!insn || ! INSN_P (insn))
8488         goto done;
8489
8490       /* Let Haifa tell us where it thinks insn group boundaries are.  */
8491       if (GET_MODE (insn) == TImode)
8492         goto done;
8493
8494       if (GET_CODE (insn) == CLOBBER || GET_CODE (insn) == USE)
8495         goto next;
8496     }
8497
8498  next_and_done:
8499   insn = next_nonnote_insn (insn);
8500
8501  done:
8502   *plen = len;
8503   *pin_use = in_use;
8504   return insn;
8505 }
8506
8507 /* IN_USE is a mask of the slots currently filled within the insn group.
8508    The mask bits come from alphaev5_pipe above.  If EV5_E01 is set, then
8509    the insn in EV5_E0 can be swapped by the hardware into EV5_E1.
8510
8511    LEN is, of course, the length of the group in bytes.  */
8512
8513 static rtx
8514 alphaev5_next_group (rtx insn, int *pin_use, int *plen)
8515 {
8516   int len, in_use;
8517
8518   len = in_use = 0;
8519
8520   if (! INSN_P (insn)
8521       || GET_CODE (PATTERN (insn)) == CLOBBER
8522       || GET_CODE (PATTERN (insn)) == USE)
8523     goto next_and_done;
8524
8525   while (1)
8526     {
8527       enum alphaev5_pipe pipe;
8528
8529       pipe = alphaev5_insn_pipe (insn);
8530       switch (pipe)
8531         {
8532         case EV5_STOP:
8533           /* Force complex instructions to start new groups.  */
8534           if (in_use)
8535             goto done;
8536
8537           /* If this is a completely unrecognized insn, its an asm.
8538              We don't know how long it is, so record length as -1 to
8539              signal a needed realignment.  */
8540           if (recog_memoized (insn) < 0)
8541             len = -1;
8542           else
8543             len = get_attr_length (insn);
8544           goto next_and_done;
8545
8546         /* ??? Most of the places below, we would like to abort, as
8547            it would indicate an error either in Haifa, or in the
8548            scheduling description.  Unfortunately, Haifa never
8549            schedules the last instruction of the BB, so we don't
8550            have an accurate TI bit to go off.  */
8551         case EV5_E01:
8552           if (in_use & EV5_E0)
8553             {
8554               if (in_use & EV5_E1)
8555                 goto done;
8556               in_use |= EV5_E1;
8557             }
8558           else
8559             in_use |= EV5_E0 | EV5_E01;
8560           break;
8561
8562         case EV5_E0:
8563           if (in_use & EV5_E0)
8564             {
8565               if (!(in_use & EV5_E01) || (in_use & EV5_E1))
8566                 goto done;
8567               in_use |= EV5_E1;
8568             }
8569           in_use |= EV5_E0;
8570           break;
8571
8572         case EV5_E1:
8573           if (in_use & EV5_E1)
8574             goto done;
8575           in_use |= EV5_E1;
8576           break;
8577
8578         case EV5_FAM:
8579           if (in_use & EV5_FA)
8580             {
8581               if (in_use & EV5_FM)
8582                 goto done;
8583               in_use |= EV5_FM;
8584             }
8585           else
8586             in_use |= EV5_FA | EV5_FAM;
8587           break;
8588
8589         case EV5_FA:
8590           if (in_use & EV5_FA)
8591             goto done;
8592           in_use |= EV5_FA;
8593           break;
8594
8595         case EV5_FM:
8596           if (in_use & EV5_FM)
8597             goto done;
8598           in_use |= EV5_FM;
8599           break;
8600
8601         case EV5_NONE:
8602           break;
8603
8604         default:
8605           abort();
8606         }
8607       len += 4;
8608
8609       /* Haifa doesn't do well scheduling branches.  */
8610       /* ??? If this is predicted not-taken, slotting continues, except
8611          that no more IBR, FBR, or JSR insns may be slotted.  */
8612       if (GET_CODE (insn) == JUMP_INSN)
8613         goto next_and_done;
8614
8615     next:
8616       insn = next_nonnote_insn (insn);
8617
8618       if (!insn || ! INSN_P (insn))
8619         goto done;
8620
8621       /* Let Haifa tell us where it thinks insn group boundaries are.  */
8622       if (GET_MODE (insn) == TImode)
8623         goto done;
8624
8625       if (GET_CODE (insn) == CLOBBER || GET_CODE (insn) == USE)
8626         goto next;
8627     }
8628
8629  next_and_done:
8630   insn = next_nonnote_insn (insn);
8631
8632  done:
8633   *plen = len;
8634   *pin_use = in_use;
8635   return insn;
8636 }
8637
8638 static rtx
8639 alphaev4_next_nop (int *pin_use)
8640 {
8641   int in_use = *pin_use;
8642   rtx nop;
8643
8644   if (!(in_use & EV4_IB0))
8645     {
8646       in_use |= EV4_IB0;
8647       nop = gen_nop ();
8648     }
8649   else if ((in_use & (EV4_IBX|EV4_IB1)) == EV4_IBX)
8650     {
8651       in_use |= EV4_IB1;
8652       nop = gen_nop ();
8653     }
8654   else if (TARGET_FP && !(in_use & EV4_IB1))
8655     {
8656       in_use |= EV4_IB1;
8657       nop = gen_fnop ();
8658     }
8659   else
8660     nop = gen_unop ();
8661
8662   *pin_use = in_use;
8663   return nop;
8664 }
8665
8666 static rtx
8667 alphaev5_next_nop (int *pin_use)
8668 {
8669   int in_use = *pin_use;
8670   rtx nop;
8671
8672   if (!(in_use & EV5_E1))
8673     {
8674       in_use |= EV5_E1;
8675       nop = gen_nop ();
8676     }
8677   else if (TARGET_FP && !(in_use & EV5_FA))
8678     {
8679       in_use |= EV5_FA;
8680       nop = gen_fnop ();
8681     }
8682   else if (TARGET_FP && !(in_use & EV5_FM))
8683     {
8684       in_use |= EV5_FM;
8685       nop = gen_fnop ();
8686     }
8687   else
8688     nop = gen_unop ();
8689
8690   *pin_use = in_use;
8691   return nop;
8692 }
8693
8694 /* The instruction group alignment main loop.  */
8695
8696 static void
8697 alpha_align_insns (unsigned int max_align,
8698                    rtx (*next_group) (rtx, int *, int *),
8699                    rtx (*next_nop) (int *))
8700 {
8701   /* ALIGN is the known alignment for the insn group.  */
8702   unsigned int align;
8703   /* OFS is the offset of the current insn in the insn group.  */
8704   int ofs;
8705   int prev_in_use, in_use, len;
8706   rtx i, next;
8707
8708   /* Let shorten branches care for assigning alignments to code labels.  */
8709   shorten_branches (get_insns ());
8710
8711   if (align_functions < 4)
8712     align = 4;
8713   else if ((unsigned int) align_functions < max_align)
8714     align = align_functions;
8715   else
8716     align = max_align;
8717
8718   ofs = prev_in_use = 0;
8719   i = get_insns ();
8720   if (GET_CODE (i) == NOTE)
8721     i = next_nonnote_insn (i);
8722
8723   while (i)
8724     {
8725       next = (*next_group) (i, &in_use, &len);
8726
8727       /* When we see a label, resync alignment etc.  */
8728       if (GET_CODE (i) == CODE_LABEL)
8729         {
8730           unsigned int new_align = 1 << label_to_alignment (i);
8731
8732           if (new_align >= align)
8733             {
8734               align = new_align < max_align ? new_align : max_align;
8735               ofs = 0;
8736             }
8737
8738           else if (ofs & (new_align-1))
8739             ofs = (ofs | (new_align-1)) + 1;
8740           if (len != 0)
8741             abort();
8742         }
8743
8744       /* Handle complex instructions special.  */
8745       else if (in_use == 0)
8746         {
8747           /* Asms will have length < 0.  This is a signal that we have
8748              lost alignment knowledge.  Assume, however, that the asm
8749              will not mis-align instructions.  */
8750           if (len < 0)
8751             {
8752               ofs = 0;
8753               align = 4;
8754               len = 0;
8755             }
8756         }
8757
8758       /* If the known alignment is smaller than the recognized insn group,
8759          realign the output.  */
8760       else if ((int) align < len)
8761         {
8762           unsigned int new_log_align = len > 8 ? 4 : 3;
8763           rtx prev, where;
8764
8765           where = prev = prev_nonnote_insn (i);
8766           if (!where || GET_CODE (where) != CODE_LABEL)
8767             where = i;
8768
8769           /* Can't realign between a call and its gp reload.  */
8770           if (! (TARGET_EXPLICIT_RELOCS
8771                  && prev && GET_CODE (prev) == CALL_INSN))
8772             {
8773               emit_insn_before (gen_realign (GEN_INT (new_log_align)), where);
8774               align = 1 << new_log_align;
8775               ofs = 0;
8776             }
8777         }
8778
8779       /* If the group won't fit in the same INT16 as the previous,
8780          we need to add padding to keep the group together.  Rather
8781          than simply leaving the insn filling to the assembler, we
8782          can make use of the knowledge of what sorts of instructions
8783          were issued in the previous group to make sure that all of
8784          the added nops are really free.  */
8785       else if (ofs + len > (int) align)
8786         {
8787           int nop_count = (align - ofs) / 4;
8788           rtx where;
8789
8790           /* Insert nops before labels, branches, and calls to truely merge
8791              the execution of the nops with the previous instruction group.  */
8792           where = prev_nonnote_insn (i);
8793           if (where)
8794             {
8795               if (GET_CODE (where) == CODE_LABEL)
8796                 {
8797                   rtx where2 = prev_nonnote_insn (where);
8798                   if (where2 && GET_CODE (where2) == JUMP_INSN)
8799                     where = where2;
8800                 }
8801               else if (GET_CODE (where) == INSN)
8802                 where = i;
8803             }
8804           else
8805             where = i;
8806
8807           do
8808             emit_insn_before ((*next_nop)(&prev_in_use), where);
8809           while (--nop_count);
8810           ofs = 0;
8811         }
8812
8813       ofs = (ofs + len) & (align - 1);
8814       prev_in_use = in_use;
8815       i = next;
8816     }
8817 }
8818 \f
8819 /* Machine dependent reorg pass.  */
8820
8821 static void
8822 alpha_reorg (void)
8823 {
8824   if (alpha_tp != ALPHA_TP_PROG || flag_exceptions)
8825     alpha_handle_trap_shadows ();
8826
8827   /* Due to the number of extra trapb insns, don't bother fixing up
8828      alignment when trap precision is instruction.  Moreover, we can
8829      only do our job when sched2 is run.  */
8830   if (optimize && !optimize_size
8831       && alpha_tp != ALPHA_TP_INSN
8832       && flag_schedule_insns_after_reload)
8833     {
8834       if (alpha_cpu == PROCESSOR_EV4)
8835         alpha_align_insns (8, alphaev4_next_group, alphaev4_next_nop);
8836       else if (alpha_cpu == PROCESSOR_EV5)
8837         alpha_align_insns (16, alphaev5_next_group, alphaev5_next_nop);
8838     }
8839 }
8840 \f
8841 #if !TARGET_ABI_UNICOSMK
8842
8843 #ifdef HAVE_STAMP_H
8844 #include <stamp.h>
8845 #endif
8846
8847 static void
8848 alpha_file_start (void)
8849 {
8850 #ifdef OBJECT_FORMAT_ELF
8851   /* If emitting dwarf2 debug information, we cannot generate a .file
8852      directive to start the file, as it will conflict with dwarf2out
8853      file numbers.  So it's only useful when emitting mdebug output.  */
8854   targetm.file_start_file_directive = (write_symbols == DBX_DEBUG);
8855 #endif
8856
8857   default_file_start ();
8858 #ifdef MS_STAMP
8859   fprintf (asm_out_file, "\t.verstamp %d %d\n", MS_STAMP, LS_STAMP);
8860 #endif
8861
8862   fputs ("\t.set noreorder\n", asm_out_file);
8863   fputs ("\t.set volatile\n", asm_out_file);
8864   if (!TARGET_ABI_OPEN_VMS)
8865     fputs ("\t.set noat\n", asm_out_file);
8866   if (TARGET_EXPLICIT_RELOCS)
8867     fputs ("\t.set nomacro\n", asm_out_file);
8868   if (TARGET_SUPPORT_ARCH | TARGET_BWX | TARGET_MAX | TARGET_FIX | TARGET_CIX)
8869     fprintf (asm_out_file,
8870              "\t.arch %s\n",
8871              TARGET_CPU_EV6 ? "ev6"
8872              : (TARGET_CPU_EV5
8873                 ? (TARGET_MAX ? "pca56" : TARGET_BWX ? "ev56" : "ev5")
8874                 : "ev4"));
8875 }
8876 #endif
8877
8878 #ifdef OBJECT_FORMAT_ELF
8879
8880 /* Switch to the section to which we should output X.  The only thing
8881    special we do here is to honor small data.  */
8882
8883 static void
8884 alpha_elf_select_rtx_section (enum machine_mode mode, rtx x,
8885                               unsigned HOST_WIDE_INT align)
8886 {
8887   if (TARGET_SMALL_DATA && GET_MODE_SIZE (mode) <= g_switch_value)
8888     /* ??? Consider using mergeable sdata sections.  */
8889     sdata_section ();
8890   else
8891     default_elf_select_rtx_section (mode, x, align);
8892 }
8893
8894 #endif /* OBJECT_FORMAT_ELF */
8895 \f
8896 /* Structure to collect function names for final output in link section.  */
8897 /* Note that items marked with GTY can't be ifdef'ed out.  */
8898
8899 enum links_kind {KIND_UNUSED, KIND_LOCAL, KIND_EXTERN};
8900 enum reloc_kind {KIND_LINKAGE, KIND_CODEADDR};
8901
8902 struct alpha_links GTY(())
8903 {
8904   int num;
8905   rtx linkage;
8906   enum links_kind lkind;
8907   enum reloc_kind rkind;
8908 };
8909
8910 struct alpha_funcs GTY(())
8911 {
8912   int num;
8913   splay_tree GTY ((param1_is (char *), param2_is (struct alpha_links *)))
8914     links;
8915 };
8916
8917 static GTY ((param1_is (char *), param2_is (struct alpha_links *)))
8918   splay_tree alpha_links_tree;
8919 static GTY ((param1_is (tree), param2_is (struct alpha_funcs *)))
8920   splay_tree alpha_funcs_tree;
8921
8922 static GTY(()) int alpha_funcs_num;
8923
8924 #if TARGET_ABI_OPEN_VMS
8925
8926 /* Return the VMS argument type corresponding to MODE.  */
8927
8928 enum avms_arg_type
8929 alpha_arg_type (enum machine_mode mode)
8930 {
8931   switch (mode)
8932     {
8933     case SFmode:
8934       return TARGET_FLOAT_VAX ? FF : FS;
8935     case DFmode:
8936       return TARGET_FLOAT_VAX ? FD : FT;
8937     default:
8938       return I64;
8939     }
8940 }
8941
8942 /* Return an rtx for an integer representing the VMS Argument Information
8943    register value.  */
8944
8945 rtx
8946 alpha_arg_info_reg_val (CUMULATIVE_ARGS cum)
8947 {
8948   unsigned HOST_WIDE_INT regval = cum.num_args;
8949   int i;
8950
8951   for (i = 0; i < 6; i++)
8952     regval |= ((int) cum.atypes[i]) << (i * 3 + 8);
8953
8954   return GEN_INT (regval);
8955 }
8956 \f
8957 /* Make (or fake) .linkage entry for function call.
8958
8959    IS_LOCAL is 0 if name is used in call, 1 if name is used in definition.
8960
8961    Return an SYMBOL_REF rtx for the linkage.  */
8962
8963 rtx
8964 alpha_need_linkage (const char *name, int is_local)
8965 {
8966   splay_tree_node node;
8967   struct alpha_links *al;
8968
8969   if (name[0] == '*')
8970     name++;
8971
8972   if (is_local)
8973     {
8974       struct alpha_funcs *cfaf;
8975
8976       if (!alpha_funcs_tree)
8977         alpha_funcs_tree = splay_tree_new_ggc ((splay_tree_compare_fn)
8978                                                splay_tree_compare_pointers);
8979
8980       cfaf = (struct alpha_funcs *) ggc_alloc (sizeof (struct alpha_funcs));
8981
8982       cfaf->links = 0;
8983       cfaf->num = ++alpha_funcs_num;
8984
8985       splay_tree_insert (alpha_funcs_tree,
8986                          (splay_tree_key) current_function_decl,
8987                          (splay_tree_value) cfaf);
8988     }
8989
8990   if (alpha_links_tree)
8991     {
8992       /* Is this name already defined?  */
8993
8994       node = splay_tree_lookup (alpha_links_tree, (splay_tree_key) name);
8995       if (node)
8996         {
8997           al = (struct alpha_links *) node->value;
8998           if (is_local)
8999             {
9000               /* Defined here but external assumed.  */
9001               if (al->lkind == KIND_EXTERN)
9002                 al->lkind = KIND_LOCAL;
9003             }
9004           else
9005             {
9006               /* Used here but unused assumed.  */
9007               if (al->lkind == KIND_UNUSED)
9008                 al->lkind = KIND_LOCAL;
9009             }
9010           return al->linkage;
9011         }
9012     }
9013   else
9014     alpha_links_tree = splay_tree_new_ggc ((splay_tree_compare_fn) strcmp);
9015
9016   al = (struct alpha_links *) ggc_alloc (sizeof (struct alpha_links));
9017   name = ggc_strdup (name);
9018
9019   /* Assume external if no definition.  */
9020   al->lkind = (is_local ? KIND_UNUSED : KIND_EXTERN);
9021
9022   /* Ensure we have an IDENTIFIER so assemble_name can mark it used.  */
9023   get_identifier (name);
9024
9025   /* Construct a SYMBOL_REF for us to call.  */
9026   {
9027     size_t name_len = strlen (name);
9028     char *linksym = alloca (name_len + 6);
9029     linksym[0] = '$';
9030     memcpy (linksym + 1, name, name_len);
9031     memcpy (linksym + 1 + name_len, "..lk", 5);
9032     al->linkage = gen_rtx_SYMBOL_REF (Pmode,
9033                                       ggc_alloc_string (linksym, name_len + 5));
9034   }
9035
9036   splay_tree_insert (alpha_links_tree, (splay_tree_key) name,
9037                      (splay_tree_value) al);
9038
9039   return al->linkage;
9040 }
9041
9042 rtx
9043 alpha_use_linkage (rtx linkage, tree cfundecl, int lflag, int rflag)
9044 {
9045   splay_tree_node cfunnode;
9046   struct alpha_funcs *cfaf;
9047   struct alpha_links *al;
9048   const char *name = XSTR (linkage, 0);
9049
9050   cfaf = (struct alpha_funcs *) 0;
9051   al = (struct alpha_links *) 0;
9052
9053   cfunnode = splay_tree_lookup (alpha_funcs_tree, (splay_tree_key) cfundecl);
9054   cfaf = (struct alpha_funcs *) cfunnode->value;
9055
9056   if (cfaf->links)
9057     {
9058       splay_tree_node lnode;
9059
9060       /* Is this name already defined?  */
9061
9062       lnode = splay_tree_lookup (cfaf->links, (splay_tree_key) name);
9063       if (lnode)
9064         al = (struct alpha_links *) lnode->value;
9065     }
9066   else
9067     cfaf->links = splay_tree_new_ggc ((splay_tree_compare_fn) strcmp);
9068
9069   if (!al)
9070     {
9071       size_t name_len;
9072       size_t buflen;
9073       char buf [512];
9074       char *linksym;
9075       splay_tree_node node = 0;
9076       struct alpha_links *anl;
9077
9078       if (name[0] == '*')
9079         name++;
9080
9081       name_len = strlen (name);
9082
9083       al = (struct alpha_links *) ggc_alloc (sizeof (struct alpha_links));
9084       al->num = cfaf->num;
9085
9086       node = splay_tree_lookup (alpha_links_tree, (splay_tree_key) name);
9087       if (node)
9088         {
9089           anl = (struct alpha_links *) node->value;
9090           al->lkind = anl->lkind;
9091         }
9092
9093       sprintf (buf, "$%d..%s..lk", cfaf->num, name);
9094       buflen = strlen (buf);
9095       linksym = alloca (buflen + 1);
9096       memcpy (linksym, buf, buflen + 1);
9097
9098       al->linkage = gen_rtx_SYMBOL_REF
9099         (Pmode, ggc_alloc_string (linksym, buflen + 1));
9100
9101       splay_tree_insert (cfaf->links, (splay_tree_key) name,
9102                          (splay_tree_value) al);
9103     }
9104
9105   if (rflag)
9106     al->rkind = KIND_CODEADDR;
9107   else
9108     al->rkind = KIND_LINKAGE;
9109
9110   if (lflag)
9111     return gen_rtx_MEM (Pmode, plus_constant (al->linkage, 8));
9112   else
9113     return al->linkage;
9114 }
9115
9116 static int
9117 alpha_write_one_linkage (splay_tree_node node, void *data)
9118 {
9119   const char *const name = (const char *) node->key;
9120   struct alpha_links *link = (struct alpha_links *) node->value;
9121   FILE *stream = (FILE *) data;
9122
9123   fprintf (stream, "$%d..%s..lk:\n", link->num, name);
9124   if (link->rkind == KIND_CODEADDR)
9125     {
9126       if (link->lkind == KIND_LOCAL)
9127         {
9128           /* Local and used */
9129           fprintf (stream, "\t.quad %s..en\n", name);
9130         }
9131       else
9132         {
9133           /* External and used, request code address.  */
9134           fprintf (stream, "\t.code_address %s\n", name);
9135         }
9136     }
9137   else
9138     {
9139       if (link->lkind == KIND_LOCAL)
9140         {
9141           /* Local and used, build linkage pair.  */
9142           fprintf (stream, "\t.quad %s..en\n", name);
9143           fprintf (stream, "\t.quad %s\n", name);
9144         }
9145       else
9146         {
9147           /* External and used, request linkage pair.  */
9148           fprintf (stream, "\t.linkage %s\n", name);
9149         }
9150     }
9151
9152   return 0;
9153 }
9154
9155 static void
9156 alpha_write_linkage (FILE *stream, const char *funname, tree fundecl)
9157 {
9158   splay_tree_node node;
9159   struct alpha_funcs *func;
9160
9161   link_section ();
9162   fprintf (stream, "\t.align 3\n");
9163   node = splay_tree_lookup (alpha_funcs_tree, (splay_tree_key) fundecl);
9164   func = (struct alpha_funcs *) node->value;
9165
9166   fputs ("\t.name ", stream);
9167   assemble_name (stream, funname);
9168   fputs ("..na\n", stream);
9169   ASM_OUTPUT_LABEL (stream, funname);
9170   fprintf (stream, "\t.pdesc ");
9171   assemble_name (stream, funname);
9172   fprintf (stream, "..en,%s\n",
9173            alpha_procedure_type == PT_STACK ? "stack"
9174            : alpha_procedure_type == PT_REGISTER ? "reg" : "null");
9175
9176   if (func->links)
9177     {
9178       splay_tree_foreach (func->links, alpha_write_one_linkage, stream);
9179       /* splay_tree_delete (func->links); */
9180     }
9181 }
9182
9183 /* Given a decl, a section name, and whether the decl initializer
9184    has relocs, choose attributes for the section.  */
9185
9186 #define SECTION_VMS_OVERLAY     SECTION_FORGET
9187 #define SECTION_VMS_GLOBAL SECTION_MACH_DEP
9188 #define SECTION_VMS_INITIALIZE (SECTION_VMS_GLOBAL << 1)
9189
9190 static unsigned int
9191 vms_section_type_flags (tree decl, const char *name, int reloc)
9192 {
9193   unsigned int flags = default_section_type_flags (decl, name, reloc);
9194
9195   if (decl && DECL_ATTRIBUTES (decl)
9196       && lookup_attribute ("overlaid", DECL_ATTRIBUTES (decl)))
9197     flags |= SECTION_VMS_OVERLAY;
9198   if (decl && DECL_ATTRIBUTES (decl)
9199       && lookup_attribute ("global", DECL_ATTRIBUTES (decl)))
9200     flags |= SECTION_VMS_GLOBAL;
9201   if (decl && DECL_ATTRIBUTES (decl)
9202       && lookup_attribute ("initialize", DECL_ATTRIBUTES (decl)))
9203     flags |= SECTION_VMS_INITIALIZE;
9204
9205   return flags;
9206 }
9207
9208 /* Switch to an arbitrary section NAME with attributes as specified
9209    by FLAGS.  ALIGN specifies any known alignment requirements for
9210    the section; 0 if the default should be used.  */
9211
9212 static void
9213 vms_asm_named_section (const char *name, unsigned int flags)
9214 {
9215   fputc ('\n', asm_out_file);
9216   fprintf (asm_out_file, ".section\t%s", name);
9217
9218   if (flags & SECTION_VMS_OVERLAY)
9219     fprintf (asm_out_file, ",OVR");
9220   if (flags & SECTION_VMS_GLOBAL)
9221     fprintf (asm_out_file, ",GBL");
9222   if (flags & SECTION_VMS_INITIALIZE)
9223     fprintf (asm_out_file, ",NOMOD");
9224   if (flags & SECTION_DEBUG)
9225     fprintf (asm_out_file, ",NOWRT");
9226
9227   fputc ('\n', asm_out_file);
9228 }
9229
9230 /* Record an element in the table of global constructors.  SYMBOL is
9231    a SYMBOL_REF of the function to be called; PRIORITY is a number
9232    between 0 and MAX_INIT_PRIORITY.
9233
9234    Differs from default_ctors_section_asm_out_constructor in that the
9235    width of the .ctors entry is always 64 bits, rather than the 32 bits
9236    used by a normal pointer.  */
9237
9238 static void
9239 vms_asm_out_constructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
9240 {
9241   ctors_section ();
9242   assemble_align (BITS_PER_WORD);
9243   assemble_integer (symbol, UNITS_PER_WORD, BITS_PER_WORD, 1);
9244 }
9245
9246 static void
9247 vms_asm_out_destructor (rtx symbol, int priority ATTRIBUTE_UNUSED)
9248 {
9249   dtors_section ();
9250   assemble_align (BITS_PER_WORD);
9251   assemble_integer (symbol, UNITS_PER_WORD, BITS_PER_WORD, 1);
9252 }
9253 #else
9254
9255 rtx
9256 alpha_need_linkage (const char *name ATTRIBUTE_UNUSED,
9257                     int is_local ATTRIBUTE_UNUSED)
9258 {
9259   return NULL_RTX;
9260 }
9261
9262 rtx
9263 alpha_use_linkage (rtx linkage ATTRIBUTE_UNUSED,
9264                    tree cfundecl ATTRIBUTE_UNUSED,
9265                    int lflag ATTRIBUTE_UNUSED,
9266                    int rflag ATTRIBUTE_UNUSED)
9267 {
9268   return NULL_RTX;
9269 }
9270
9271 #endif /* TARGET_ABI_OPEN_VMS */
9272 \f
9273 #if TARGET_ABI_UNICOSMK
9274
9275 /* Define the offset between two registers, one to be eliminated, and the
9276    other its replacement, at the start of a routine.  */
9277
9278 int
9279 unicosmk_initial_elimination_offset (int from, int to)
9280 {
9281   int fixed_size;
9282
9283   fixed_size = alpha_sa_size();
9284   if (fixed_size != 0)
9285     fixed_size += 48;
9286
9287   if (from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
9288     return -fixed_size;
9289   else if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
9290     return 0;
9291   else if (from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
9292     return (ALPHA_ROUND (current_function_outgoing_args_size)
9293             + ALPHA_ROUND (get_frame_size()));
9294   else if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
9295     return (ALPHA_ROUND (fixed_size)
9296             + ALPHA_ROUND (get_frame_size()
9297                            + current_function_outgoing_args_size));
9298   else
9299     abort ();
9300 }
9301
9302 /* Output the module name for .ident and .end directives. We have to strip
9303    directories and add make sure that the module name starts with a letter
9304    or '$'.  */
9305
9306 static void
9307 unicosmk_output_module_name (FILE *file)
9308 {
9309   const char *name = lbasename (main_input_filename);
9310   unsigned len = strlen (name);
9311   char *clean_name = alloca (len + 2);
9312   char *ptr = clean_name;
9313
9314   /* CAM only accepts module names that start with a letter or '$'. We
9315      prefix the module name with a '$' if necessary.  */
9316
9317   if (!ISALPHA (*name))
9318     *ptr++ = '$';
9319   memcpy (ptr, name, len + 1);
9320   clean_symbol_name (clean_name);
9321   fputs (clean_name, file);
9322 }
9323
9324 /* Output the definition of a common variable.  */
9325
9326 void
9327 unicosmk_output_common (FILE *file, const char *name, int size, int align)
9328 {
9329   tree name_tree;
9330   printf ("T3E__: common %s\n", name);
9331
9332   common_section ();
9333   fputs("\t.endp\n\n\t.psect ", file);
9334   assemble_name(file, name);
9335   fprintf(file, ",%d,common\n", floor_log2 (align / BITS_PER_UNIT));
9336   fprintf(file, "\t.byte\t0:%d\n", size);
9337
9338   /* Mark the symbol as defined in this module.  */
9339   name_tree = get_identifier (name);
9340   TREE_ASM_WRITTEN (name_tree) = 1;
9341 }
9342
9343 #define SECTION_PUBLIC SECTION_MACH_DEP
9344 #define SECTION_MAIN (SECTION_PUBLIC << 1)
9345 static int current_section_align;
9346
9347 static unsigned int
9348 unicosmk_section_type_flags (tree decl, const char *name,
9349                              int reloc ATTRIBUTE_UNUSED)
9350 {
9351   unsigned int flags = default_section_type_flags (decl, name, reloc);
9352
9353   if (!decl)
9354     return flags;
9355
9356   if (TREE_CODE (decl) == FUNCTION_DECL)
9357     {
9358       current_section_align = floor_log2 (FUNCTION_BOUNDARY / BITS_PER_UNIT);
9359       if (align_functions_log > current_section_align)
9360         current_section_align = align_functions_log;
9361
9362       if (! strcmp (IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl)), "main"))
9363         flags |= SECTION_MAIN;
9364     }
9365   else
9366     current_section_align = floor_log2 (DECL_ALIGN (decl) / BITS_PER_UNIT);
9367
9368   if (TREE_PUBLIC (decl))
9369     flags |= SECTION_PUBLIC;
9370
9371   return flags;
9372 }
9373
9374 /* Generate a section name for decl and associate it with the
9375    declaration.  */
9376
9377 static void
9378 unicosmk_unique_section (tree decl, int reloc ATTRIBUTE_UNUSED)
9379 {
9380   const char *name;
9381   int len;
9382
9383   if (!decl)
9384     abort ();
9385
9386   name = IDENTIFIER_POINTER (DECL_ASSEMBLER_NAME (decl));
9387   name = default_strip_name_encoding (name);
9388   len = strlen (name);
9389
9390   if (TREE_CODE (decl) == FUNCTION_DECL)
9391     {
9392       char *string;
9393
9394       /* It is essential that we prefix the section name here because
9395          otherwise the section names generated for constructors and
9396          destructors confuse collect2.  */
9397
9398       string = alloca (len + 6);
9399       sprintf (string, "code@%s", name);
9400       DECL_SECTION_NAME (decl) = build_string (len + 5, string);
9401     }
9402   else if (TREE_PUBLIC (decl))
9403     DECL_SECTION_NAME (decl) = build_string (len, name);
9404   else
9405     {
9406       char *string;
9407
9408       string = alloca (len + 6);
9409       sprintf (string, "data@%s", name);
9410       DECL_SECTION_NAME (decl) = build_string (len + 5, string);
9411     }
9412 }
9413
9414 /* Switch to an arbitrary section NAME with attributes as specified
9415    by FLAGS.  ALIGN specifies any known alignment requirements for
9416    the section; 0 if the default should be used.  */
9417
9418 static void
9419 unicosmk_asm_named_section (const char *name, unsigned int flags)
9420 {
9421   const char *kind;
9422
9423   /* Close the previous section.  */
9424
9425   fputs ("\t.endp\n\n", asm_out_file);
9426
9427   /* Find out what kind of section we are opening.  */
9428
9429   if (flags & SECTION_MAIN)
9430     fputs ("\t.start\tmain\n", asm_out_file);
9431
9432   if (flags & SECTION_CODE)
9433     kind = "code";
9434   else if (flags & SECTION_PUBLIC)
9435     kind = "common";
9436   else
9437     kind = "data";
9438
9439   if (current_section_align != 0)
9440     fprintf (asm_out_file, "\t.psect\t%s,%d,%s\n", name,
9441              current_section_align, kind);
9442   else
9443     fprintf (asm_out_file, "\t.psect\t%s,%s\n", name, kind);
9444 }
9445
9446 static void
9447 unicosmk_insert_attributes (tree decl, tree *attr_ptr ATTRIBUTE_UNUSED)
9448 {
9449   if (DECL_P (decl)
9450       && (TREE_PUBLIC (decl) || TREE_CODE (decl) == FUNCTION_DECL))
9451     unicosmk_unique_section (decl, 0);
9452 }
9453
9454 /* Output an alignment directive. We have to use the macro 'gcc@code@align'
9455    in code sections because .align fill unused space with zeroes.  */
9456
9457 void
9458 unicosmk_output_align (FILE *file, int align)
9459 {
9460   if (inside_function)
9461     fprintf (file, "\tgcc@code@align\t%d\n", align);
9462   else
9463     fprintf (file, "\t.align\t%d\n", align);
9464 }
9465
9466 /* Add a case vector to the current function's list of deferred case
9467    vectors. Case vectors have to be put into a separate section because CAM
9468    does not allow data definitions in code sections.  */
9469
9470 void
9471 unicosmk_defer_case_vector (rtx lab, rtx vec)
9472 {
9473   struct machine_function *machine = cfun->machine;
9474
9475   vec = gen_rtx_EXPR_LIST (VOIDmode, lab, vec);
9476   machine->addr_list = gen_rtx_EXPR_LIST (VOIDmode, vec,
9477                                           machine->addr_list);
9478 }
9479
9480 /* Output a case vector.  */
9481
9482 static void
9483 unicosmk_output_addr_vec (FILE *file, rtx vec)
9484 {
9485   rtx lab  = XEXP (vec, 0);
9486   rtx body = XEXP (vec, 1);
9487   int vlen = XVECLEN (body, 0);
9488   int idx;
9489
9490   (*targetm.asm_out.internal_label) (file, "L", CODE_LABEL_NUMBER (lab));
9491
9492   for (idx = 0; idx < vlen; idx++)
9493     {
9494       ASM_OUTPUT_ADDR_VEC_ELT
9495         (file, CODE_LABEL_NUMBER (XEXP (XVECEXP (body, 0, idx), 0)));
9496     }
9497 }
9498
9499 /* Output current function's deferred case vectors.  */
9500
9501 static void
9502 unicosmk_output_deferred_case_vectors (FILE *file)
9503 {
9504   struct machine_function *machine = cfun->machine;
9505   rtx t;
9506
9507   if (machine->addr_list == NULL_RTX)
9508     return;
9509
9510   data_section ();
9511   for (t = machine->addr_list; t; t = XEXP (t, 1))
9512     unicosmk_output_addr_vec (file, XEXP (t, 0));
9513 }
9514
9515 /* Generate the name of the SSIB section for the current function.  */
9516
9517 #define SSIB_PREFIX "__SSIB_"
9518 #define SSIB_PREFIX_LEN 7
9519
9520 static const char *
9521 unicosmk_ssib_name (void)
9522 {
9523   /* This is ok since CAM won't be able to deal with names longer than that
9524      anyway.  */
9525
9526   static char name[256];
9527
9528   rtx x;
9529   const char *fnname;
9530   int len;
9531
9532   x = DECL_RTL (cfun->decl);
9533   if (GET_CODE (x) != MEM)
9534     abort ();
9535   x = XEXP (x, 0);
9536   if (GET_CODE (x) != SYMBOL_REF)
9537     abort ();
9538   fnname = XSTR (x, 0);
9539
9540   len = strlen (fnname);
9541   if (len + SSIB_PREFIX_LEN > 255)
9542     len = 255 - SSIB_PREFIX_LEN;
9543
9544   strcpy (name, SSIB_PREFIX);
9545   strncpy (name + SSIB_PREFIX_LEN, fnname, len);
9546   name[len + SSIB_PREFIX_LEN] = 0;
9547
9548   return name;
9549 }
9550
9551 /* Set up the dynamic subprogram information block (DSIB) and update the
9552    frame pointer register ($15) for subroutines which have a frame. If the
9553    subroutine doesn't have a frame, simply increment $15.  */
9554
9555 static void
9556 unicosmk_gen_dsib (unsigned long *imaskP)
9557 {
9558   if (alpha_procedure_type == PT_STACK)
9559     {
9560       const char *ssib_name;
9561       rtx mem;
9562
9563       /* Allocate 64 bytes for the DSIB.  */
9564
9565       FRP (emit_insn (gen_adddi3 (stack_pointer_rtx, stack_pointer_rtx,
9566                                   GEN_INT (-64))));
9567       emit_insn (gen_blockage ());
9568
9569       /* Save the return address.  */
9570
9571       mem = gen_rtx_MEM (DImode, plus_constant (stack_pointer_rtx, 56));
9572       set_mem_alias_set (mem, alpha_sr_alias_set);
9573       FRP (emit_move_insn (mem, gen_rtx_REG (DImode, REG_RA)));
9574       (*imaskP) &= ~(1UL << REG_RA);
9575
9576       /* Save the old frame pointer.  */
9577
9578       mem = gen_rtx_MEM (DImode, plus_constant (stack_pointer_rtx, 48));
9579       set_mem_alias_set (mem, alpha_sr_alias_set);
9580       FRP (emit_move_insn (mem, hard_frame_pointer_rtx));
9581       (*imaskP) &= ~(1UL << HARD_FRAME_POINTER_REGNUM);
9582
9583       emit_insn (gen_blockage ());
9584
9585       /* Store the SSIB pointer.  */
9586
9587       ssib_name = ggc_strdup (unicosmk_ssib_name ());
9588       mem = gen_rtx_MEM (DImode, plus_constant (stack_pointer_rtx, 32));
9589       set_mem_alias_set (mem, alpha_sr_alias_set);
9590
9591       FRP (emit_move_insn (gen_rtx_REG (DImode, 5),
9592                            gen_rtx_SYMBOL_REF (Pmode, ssib_name)));
9593       FRP (emit_move_insn (mem, gen_rtx_REG (DImode, 5)));
9594
9595       /* Save the CIW index.  */
9596
9597       mem = gen_rtx_MEM (DImode, plus_constant (stack_pointer_rtx, 24));
9598       set_mem_alias_set (mem, alpha_sr_alias_set);
9599       FRP (emit_move_insn (mem, gen_rtx_REG (DImode, 25)));
9600
9601       emit_insn (gen_blockage ());
9602
9603       /* Set the new frame pointer.  */
9604
9605       FRP (emit_insn (gen_adddi3 (hard_frame_pointer_rtx,
9606                                   stack_pointer_rtx, GEN_INT (64))));
9607
9608     }
9609   else
9610     {
9611       /* Increment the frame pointer register to indicate that we do not
9612          have a frame.  */
9613
9614       FRP (emit_insn (gen_adddi3 (hard_frame_pointer_rtx,
9615                                   hard_frame_pointer_rtx, GEN_INT (1))));
9616     }
9617 }
9618
9619 /* Output the static subroutine information block for the current
9620    function.  */
9621
9622 static void
9623 unicosmk_output_ssib (FILE *file, const char *fnname)
9624 {
9625   int len;
9626   int i;
9627   rtx x;
9628   rtx ciw;
9629   struct machine_function *machine = cfun->machine;
9630
9631   ssib_section ();
9632   fprintf (file, "\t.endp\n\n\t.psect\t%s%s,data\n", user_label_prefix,
9633            unicosmk_ssib_name ());
9634
9635   /* Some required stuff and the function name length.  */
9636
9637   len = strlen (fnname);
9638   fprintf (file, "\t.quad\t^X20008%2.2X28\n", len);
9639
9640   /* Saved registers
9641      ??? We don't do that yet.  */
9642
9643   fputs ("\t.quad\t0\n", file);
9644
9645   /* Function address.  */
9646
9647   fputs ("\t.quad\t", file);
9648   assemble_name (file, fnname);
9649   putc ('\n', file);
9650
9651   fputs ("\t.quad\t0\n", file);
9652   fputs ("\t.quad\t0\n", file);
9653
9654   /* Function name.
9655      ??? We do it the same way Cray CC does it but this could be
9656      simplified.  */
9657
9658   for( i = 0; i < len; i++ )
9659     fprintf (file, "\t.byte\t%d\n", (int)(fnname[i]));
9660   if( (len % 8) == 0 )
9661     fputs ("\t.quad\t0\n", file);
9662   else
9663     fprintf (file, "\t.bits\t%d : 0\n", (8 - (len % 8))*8);
9664
9665   /* All call information words used in the function.  */
9666
9667   for (x = machine->first_ciw; x; x = XEXP (x, 1))
9668     {
9669       ciw = XEXP (x, 0);
9670 #if HOST_BITS_PER_WIDE_INT == 32
9671       fprintf (file, "\t.quad\t" HOST_WIDE_INT_PRINT_DOUBLE_HEX "\n",
9672                CONST_DOUBLE_HIGH (ciw), CONST_DOUBLE_LOW (ciw));
9673 #else
9674       fprintf (file, "\t.quad\t" HOST_WIDE_INT_PRINT_HEX "\n", INTVAL (ciw));
9675 #endif
9676     }
9677 }
9678
9679 /* Add a call information word (CIW) to the list of the current function's
9680    CIWs and return its index.
9681
9682    X is a CONST_INT or CONST_DOUBLE representing the CIW.  */
9683
9684 rtx
9685 unicosmk_add_call_info_word (rtx x)
9686 {
9687   rtx node;
9688   struct machine_function *machine = cfun->machine;
9689
9690   node = gen_rtx_EXPR_LIST (VOIDmode, x, NULL_RTX);
9691   if (machine->first_ciw == NULL_RTX)
9692     machine->first_ciw = node;
9693   else
9694     XEXP (machine->last_ciw, 1) = node;
9695
9696   machine->last_ciw = node;
9697   ++machine->ciw_count;
9698
9699   return GEN_INT (machine->ciw_count
9700                   + strlen (current_function_name)/8 + 5);
9701 }
9702
9703 static char unicosmk_section_buf[100];
9704
9705 char *
9706 unicosmk_text_section (void)
9707 {
9708   static int count = 0;
9709   sprintf (unicosmk_section_buf, "\t.endp\n\n\t.psect\tgcc@text___%d,code",
9710                                  count++);
9711   return unicosmk_section_buf;
9712 }
9713
9714 char *
9715 unicosmk_data_section (void)
9716 {
9717   static int count = 1;
9718   sprintf (unicosmk_section_buf, "\t.endp\n\n\t.psect\tgcc@data___%d,data",
9719                                  count++);
9720   return unicosmk_section_buf;
9721 }
9722
9723 /* The Cray assembler doesn't accept extern declarations for symbols which
9724    are defined in the same file. We have to keep track of all global
9725    symbols which are referenced and/or defined in a source file and output
9726    extern declarations for those which are referenced but not defined at
9727    the end of file.  */
9728
9729 /* List of identifiers for which an extern declaration might have to be
9730    emitted.  */
9731 /* FIXME: needs to use GC, so it can be saved and restored for PCH.  */
9732
9733 struct unicosmk_extern_list
9734 {
9735   struct unicosmk_extern_list *next;
9736   const char *name;
9737 };
9738
9739 static struct unicosmk_extern_list *unicosmk_extern_head = 0;
9740
9741 /* Output extern declarations which are required for every asm file.  */
9742
9743 static void
9744 unicosmk_output_default_externs (FILE *file)
9745 {
9746   static const char *const externs[] =
9747     { "__T3E_MISMATCH" };
9748
9749   int i;
9750   int n;
9751
9752   n = ARRAY_SIZE (externs);
9753
9754   for (i = 0; i < n; i++)
9755     fprintf (file, "\t.extern\t%s\n", externs[i]);
9756 }
9757
9758 /* Output extern declarations for global symbols which are have been
9759    referenced but not defined.  */
9760
9761 static void
9762 unicosmk_output_externs (FILE *file)
9763 {
9764   struct unicosmk_extern_list *p;
9765   const char *real_name;
9766   int len;
9767   tree name_tree;
9768
9769   len = strlen (user_label_prefix);
9770   for (p = unicosmk_extern_head; p != 0; p = p->next)
9771     {
9772       /* We have to strip the encoding and possibly remove user_label_prefix
9773          from the identifier in order to handle -fleading-underscore and
9774          explicit asm names correctly (cf. gcc.dg/asm-names-1.c).  */
9775       real_name = default_strip_name_encoding (p->name);
9776       if (len && p->name[0] == '*'
9777           && !memcmp (real_name, user_label_prefix, len))
9778         real_name += len;
9779
9780       name_tree = get_identifier (real_name);
9781       if (! TREE_ASM_WRITTEN (name_tree))
9782         {
9783           TREE_ASM_WRITTEN (name_tree) = 1;
9784           fputs ("\t.extern\t", file);
9785           assemble_name (file, p->name);
9786           putc ('\n', file);
9787         }
9788     }
9789 }
9790
9791 /* Record an extern.  */
9792
9793 void
9794 unicosmk_add_extern (const char *name)
9795 {
9796   struct unicosmk_extern_list *p;
9797
9798   p = (struct unicosmk_extern_list *)
9799        xmalloc (sizeof (struct unicosmk_extern_list));
9800   p->next = unicosmk_extern_head;
9801   p->name = name;
9802   unicosmk_extern_head = p;
9803 }
9804
9805 /* The Cray assembler generates incorrect code if identifiers which
9806    conflict with register names are used as instruction operands. We have
9807    to replace such identifiers with DEX expressions.  */
9808
9809 /* Structure to collect identifiers which have been replaced by DEX
9810    expressions.  */
9811 /* FIXME: needs to use GC, so it can be saved and restored for PCH.  */
9812
9813 struct unicosmk_dex {
9814   struct unicosmk_dex *next;
9815   const char *name;
9816 };
9817
9818 /* List of identifiers which have been replaced by DEX expressions. The DEX
9819    number is determined by the position in the list.  */
9820
9821 static struct unicosmk_dex *unicosmk_dex_list = NULL;
9822
9823 /* The number of elements in the DEX list.  */
9824
9825 static int unicosmk_dex_count = 0;
9826
9827 /* Check if NAME must be replaced by a DEX expression.  */
9828
9829 static int
9830 unicosmk_special_name (const char *name)
9831 {
9832   if (name[0] == '*')
9833     ++name;
9834
9835   if (name[0] == '$')
9836     ++name;
9837
9838   if (name[0] != 'r' && name[0] != 'f' && name[0] != 'R' && name[0] != 'F')
9839     return 0;
9840
9841   switch (name[1])
9842     {
9843     case '1':  case '2':
9844       return (name[2] == '\0' || (ISDIGIT (name[2]) && name[3] == '\0'));
9845
9846     case '3':
9847       return (name[2] == '\0'
9848                || ((name[2] == '0' || name[2] == '1') && name[3] == '\0'));
9849
9850     default:
9851       return (ISDIGIT (name[1]) && name[2] == '\0');
9852     }
9853 }
9854
9855 /* Return the DEX number if X must be replaced by a DEX expression and 0
9856    otherwise.  */
9857
9858 static int
9859 unicosmk_need_dex (rtx x)
9860 {
9861   struct unicosmk_dex *dex;
9862   const char *name;
9863   int i;
9864
9865   if (GET_CODE (x) != SYMBOL_REF)
9866     return 0;
9867
9868   name = XSTR (x,0);
9869   if (! unicosmk_special_name (name))
9870     return 0;
9871
9872   i = unicosmk_dex_count;
9873   for (dex = unicosmk_dex_list; dex; dex = dex->next)
9874     {
9875       if (! strcmp (name, dex->name))
9876         return i;
9877       --i;
9878     }
9879
9880   dex = (struct unicosmk_dex *) xmalloc (sizeof (struct unicosmk_dex));
9881   dex->name = name;
9882   dex->next = unicosmk_dex_list;
9883   unicosmk_dex_list = dex;
9884
9885   ++unicosmk_dex_count;
9886   return unicosmk_dex_count;
9887 }
9888
9889 /* Output the DEX definitions for this file.  */
9890
9891 static void
9892 unicosmk_output_dex (FILE *file)
9893 {
9894   struct unicosmk_dex *dex;
9895   int i;
9896
9897   if (unicosmk_dex_list == NULL)
9898     return;
9899
9900   fprintf (file, "\t.dexstart\n");
9901
9902   i = unicosmk_dex_count;
9903   for (dex = unicosmk_dex_list; dex; dex = dex->next)
9904     {
9905       fprintf (file, "\tDEX (%d) = ", i);
9906       assemble_name (file, dex->name);
9907       putc ('\n', file);
9908       --i;
9909     }
9910
9911   fprintf (file, "\t.dexend\n");
9912 }
9913
9914 /* Output text that to appear at the beginning of an assembler file.  */
9915
9916 static void
9917 unicosmk_file_start (void)
9918 {
9919   int i;
9920
9921   fputs ("\t.ident\t", asm_out_file);
9922   unicosmk_output_module_name (asm_out_file);
9923   fputs ("\n\n", asm_out_file);
9924
9925   /* The Unicos/Mk assembler uses different register names. Instead of trying
9926      to support them, we simply use micro definitions.  */
9927
9928   /* CAM has different register names: rN for the integer register N and fN
9929      for the floating-point register N. Instead of trying to use these in
9930      alpha.md, we define the symbols $N and $fN to refer to the appropriate
9931      register.  */
9932
9933   for (i = 0; i < 32; ++i)
9934     fprintf (asm_out_file, "$%d <- r%d\n", i, i);
9935
9936   for (i = 0; i < 32; ++i)
9937     fprintf (asm_out_file, "$f%d <- f%d\n", i, i);
9938
9939   putc ('\n', asm_out_file);
9940
9941   /* The .align directive fill unused space with zeroes which does not work
9942      in code sections. We define the macro 'gcc@code@align' which uses nops
9943      instead. Note that it assumes that code sections always have the
9944      biggest possible alignment since . refers to the current offset from
9945      the beginning of the section.  */
9946
9947   fputs ("\t.macro gcc@code@align n\n", asm_out_file);
9948   fputs ("gcc@n@bytes = 1 << n\n", asm_out_file);
9949   fputs ("gcc@here = . % gcc@n@bytes\n", asm_out_file);
9950   fputs ("\t.if ne, gcc@here, 0\n", asm_out_file);
9951   fputs ("\t.repeat (gcc@n@bytes - gcc@here) / 4\n", asm_out_file);
9952   fputs ("\tbis r31,r31,r31\n", asm_out_file);
9953   fputs ("\t.endr\n", asm_out_file);
9954   fputs ("\t.endif\n", asm_out_file);
9955   fputs ("\t.endm gcc@code@align\n\n", asm_out_file);
9956
9957   /* Output extern declarations which should always be visible.  */
9958   unicosmk_output_default_externs (asm_out_file);
9959
9960   /* Open a dummy section. We always need to be inside a section for the
9961      section-switching code to work correctly.
9962      ??? This should be a module id or something like that. I still have to
9963      figure out what the rules for those are.  */
9964   fputs ("\n\t.psect\t$SG00000,data\n", asm_out_file);
9965 }
9966
9967 /* Output text to appear at the end of an assembler file. This includes all
9968    pending extern declarations and DEX expressions.  */
9969
9970 static void
9971 unicosmk_file_end (void)
9972 {
9973   fputs ("\t.endp\n\n", asm_out_file);
9974
9975   /* Output all pending externs.  */
9976
9977   unicosmk_output_externs (asm_out_file);
9978
9979   /* Output dex definitions used for functions whose names conflict with
9980      register names.  */
9981
9982   unicosmk_output_dex (asm_out_file);
9983
9984   fputs ("\t.end\t", asm_out_file);
9985   unicosmk_output_module_name (asm_out_file);
9986   putc ('\n', asm_out_file);
9987 }
9988
9989 #else
9990
9991 static void
9992 unicosmk_output_deferred_case_vectors (FILE *file ATTRIBUTE_UNUSED)
9993 {}
9994
9995 static void
9996 unicosmk_gen_dsib (unsigned long *imaskP ATTRIBUTE_UNUSED)
9997 {}
9998
9999 static void
10000 unicosmk_output_ssib (FILE * file ATTRIBUTE_UNUSED,
10001                       const char * fnname ATTRIBUTE_UNUSED)
10002 {}
10003
10004 rtx
10005 unicosmk_add_call_info_word (rtx x ATTRIBUTE_UNUSED)
10006 {
10007   return NULL_RTX;
10008 }
10009
10010 static int
10011 unicosmk_need_dex (rtx x ATTRIBUTE_UNUSED)
10012 {
10013   return 0;
10014 }
10015
10016 #endif /* TARGET_ABI_UNICOSMK */
10017
10018 static void
10019 alpha_init_libfuncs (void)
10020 {
10021   if (TARGET_ABI_UNICOSMK)
10022     {
10023       /* Prevent gcc from generating calls to __divsi3.  */
10024       set_optab_libfunc (sdiv_optab, SImode, 0);
10025       set_optab_libfunc (udiv_optab, SImode, 0);
10026
10027       /* Use the functions provided by the system library
10028          for DImode integer division.  */
10029       set_optab_libfunc (sdiv_optab, DImode, "$sldiv");
10030       set_optab_libfunc (udiv_optab, DImode, "$uldiv");
10031     }
10032   else if (TARGET_ABI_OPEN_VMS)
10033     {
10034       /* Use the VMS runtime library functions for division and
10035          remainder.  */
10036       set_optab_libfunc (sdiv_optab, SImode, "OTS$DIV_I");
10037       set_optab_libfunc (sdiv_optab, DImode, "OTS$DIV_L");
10038       set_optab_libfunc (udiv_optab, SImode, "OTS$DIV_UI");
10039       set_optab_libfunc (udiv_optab, DImode, "OTS$DIV_UL");
10040       set_optab_libfunc (smod_optab, SImode, "OTS$REM_I");
10041       set_optab_libfunc (smod_optab, DImode, "OTS$REM_L");
10042       set_optab_libfunc (umod_optab, SImode, "OTS$REM_UI");
10043       set_optab_libfunc (umod_optab, DImode, "OTS$REM_UL");
10044     }
10045 }
10046
10047 \f
10048 /* Initialize the GCC target structure.  */
10049 #if TARGET_ABI_OPEN_VMS
10050 # undef TARGET_ATTRIBUTE_TABLE
10051 # define TARGET_ATTRIBUTE_TABLE vms_attribute_table
10052 # undef TARGET_SECTION_TYPE_FLAGS
10053 # define TARGET_SECTION_TYPE_FLAGS vms_section_type_flags
10054 #endif
10055
10056 #undef TARGET_IN_SMALL_DATA_P
10057 #define TARGET_IN_SMALL_DATA_P alpha_in_small_data_p
10058
10059 #if TARGET_ABI_UNICOSMK
10060 # undef TARGET_INSERT_ATTRIBUTES
10061 # define TARGET_INSERT_ATTRIBUTES unicosmk_insert_attributes
10062 # undef TARGET_SECTION_TYPE_FLAGS
10063 # define TARGET_SECTION_TYPE_FLAGS unicosmk_section_type_flags
10064 # undef TARGET_ASM_UNIQUE_SECTION
10065 # define TARGET_ASM_UNIQUE_SECTION unicosmk_unique_section
10066 # undef TARGET_ASM_GLOBALIZE_LABEL
10067 # define TARGET_ASM_GLOBALIZE_LABEL hook_void_FILEptr_constcharptr
10068 #endif
10069
10070 #undef TARGET_ASM_ALIGNED_HI_OP
10071 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
10072 #undef TARGET_ASM_ALIGNED_DI_OP
10073 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
10074
10075 /* Default unaligned ops are provided for ELF systems.  To get unaligned
10076    data for non-ELF systems, we have to turn off auto alignment.  */
10077 #ifndef OBJECT_FORMAT_ELF
10078 #undef TARGET_ASM_UNALIGNED_HI_OP
10079 #define TARGET_ASM_UNALIGNED_HI_OP "\t.align 0\n\t.word\t"
10080 #undef TARGET_ASM_UNALIGNED_SI_OP
10081 #define TARGET_ASM_UNALIGNED_SI_OP "\t.align 0\n\t.long\t"
10082 #undef TARGET_ASM_UNALIGNED_DI_OP
10083 #define TARGET_ASM_UNALIGNED_DI_OP "\t.align 0\n\t.quad\t"
10084 #endif
10085
10086 #ifdef OBJECT_FORMAT_ELF
10087 #undef  TARGET_ASM_SELECT_RTX_SECTION
10088 #define TARGET_ASM_SELECT_RTX_SECTION  alpha_elf_select_rtx_section
10089 #endif
10090
10091 #undef TARGET_ASM_FUNCTION_END_PROLOGUE
10092 #define TARGET_ASM_FUNCTION_END_PROLOGUE alpha_output_function_end_prologue
10093
10094 #undef TARGET_INIT_LIBFUNCS
10095 #define TARGET_INIT_LIBFUNCS alpha_init_libfuncs
10096
10097 #if TARGET_ABI_UNICOSMK
10098 #undef TARGET_ASM_FILE_START
10099 #define TARGET_ASM_FILE_START unicosmk_file_start
10100 #undef TARGET_ASM_FILE_END
10101 #define TARGET_ASM_FILE_END unicosmk_file_end
10102 #else
10103 #undef TARGET_ASM_FILE_START
10104 #define TARGET_ASM_FILE_START alpha_file_start
10105 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
10106 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
10107 #endif
10108
10109 #undef TARGET_SCHED_ADJUST_COST
10110 #define TARGET_SCHED_ADJUST_COST alpha_adjust_cost
10111 #undef TARGET_SCHED_ISSUE_RATE
10112 #define TARGET_SCHED_ISSUE_RATE alpha_issue_rate
10113 #undef TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE
10114 #define TARGET_SCHED_USE_DFA_PIPELINE_INTERFACE \
10115   alpha_use_dfa_pipeline_interface
10116 #undef TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD
10117 #define TARGET_SCHED_FIRST_CYCLE_MULTIPASS_DFA_LOOKAHEAD \
10118   alpha_multipass_dfa_lookahead
10119
10120 #undef TARGET_HAVE_TLS
10121 #define TARGET_HAVE_TLS HAVE_AS_TLS
10122
10123 #undef  TARGET_INIT_BUILTINS
10124 #define TARGET_INIT_BUILTINS alpha_init_builtins
10125 #undef  TARGET_EXPAND_BUILTIN
10126 #define TARGET_EXPAND_BUILTIN alpha_expand_builtin
10127
10128 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
10129 #define TARGET_FUNCTION_OK_FOR_SIBCALL alpha_function_ok_for_sibcall
10130 #undef TARGET_CANNOT_COPY_INSN_P
10131 #define TARGET_CANNOT_COPY_INSN_P alpha_cannot_copy_insn_p
10132
10133 #if TARGET_ABI_OSF
10134 #undef TARGET_ASM_OUTPUT_MI_THUNK
10135 #define TARGET_ASM_OUTPUT_MI_THUNK alpha_output_mi_thunk_osf
10136 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
10137 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
10138 #endif
10139
10140 #undef TARGET_RTX_COSTS
10141 #define TARGET_RTX_COSTS alpha_rtx_costs
10142 #undef TARGET_ADDRESS_COST
10143 #define TARGET_ADDRESS_COST hook_int_rtx_0
10144
10145 #undef TARGET_MACHINE_DEPENDENT_REORG
10146 #define TARGET_MACHINE_DEPENDENT_REORG alpha_reorg
10147
10148 struct gcc_target targetm = TARGET_INITIALIZER;
10149
10150 \f
10151 #include "gt-alpha.h"
10152