gcc/config/alpha/alpha.c

   1 /* Subroutines used for code generation on the DEC Alpha.
   2    Copyright (C) 1992, 93, 94, 95, 96, 1997 Free Software Foundation, Inc.
   3    Contributed by Richard Kenner (kenner@vlsi1.ultra.nyu.edu)
   4
   5 This file is part of GNU CC.
   6
   7 GNU CC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GNU CC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GNU CC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22
  23 #include "config.h"
  24 #include <stdio.h>
  25 #include <ctype.h>
  26 #include "rtl.h"
  27 #include "regs.h"
  28 #include "hard-reg-set.h"
  29 #include "real.h"
  30 #include "insn-config.h"
  31 #include "conditions.h"
  32 #include "insn-flags.h"
  33 #include "output.h"
  34 #include "insn-attr.h"
  35 #include "flags.h"
  36 #include "recog.h"
  37 #include "reload.h"
  38 #include "expr.h"
  39 #include "obstack.h"
  40 #include "tree.h"
  41 #include "except.h"
  42 #include "function.h"
  43
  44 /* External data.  */
  45 extern char *version_string;
  46 extern int rtx_equal_function_value_matters;
  47
  48 /* Specify which cpu to schedule for. */
  49
  50 enum processor_type alpha_cpu;
  51 static char* const alpha_cpu_name[] =
  52 {
  53   "ev4", "ev5", "ev6"
  54 };
  55
  56 /* Specify how accurate floating-point traps need to be.  */
  57
  58 enum alpha_trap_precision alpha_tp;
  59
  60 /* Specify the floating-point rounding mode.  */
  61
  62 enum alpha_fp_rounding_mode alpha_fprm;
  63
  64 /* Specify which things cause traps.  */
  65
  66 enum alpha_fp_trap_mode alpha_fptm;
  67
  68 /* Strings decoded into the above options.  */
  69
  70 char *alpha_cpu_string;         /* -mcpu= */
  71 char *alpha_tp_string;          /* -mtrap-precision=[p|s|i] */
  72 char *alpha_fprm_string;        /* -mfp-rounding-mode=[n|m|c|d] */
  73 char *alpha_fptm_string;        /* -mfp-trap-mode=[n|u|su|sui] */
  74 char *alpha_mlat_string;        /* -mmemory-latency= */
  75
  76 /* Save information from a "cmpxx" operation until the branch or scc is
  77    emitted.  */
  78
  79 rtx alpha_compare_op0, alpha_compare_op1;
  80 int alpha_compare_fp_p;
  81
  82 /* Save the name of the current function as used by the assembler.  This
  83    is used by the epilogue.  */
  84
  85 char *alpha_function_name;
  86
  87 /* Non-zero if inside of a function, because the Alpha asm can't
  88    handle .files inside of functions.  */
  89
  90 static int inside_function = FALSE;
  91
  92 /* Nonzero if the current function needs gp.  */
  93
  94 int alpha_function_needs_gp;
  95
  96 /* If non-null, this rtx holds the return address for the function.  */
  97
  98 static rtx alpha_return_addr_rtx;
  99
 100 /* The number of cycles of latency we should assume on memory reads.  */
 101
 102 int alpha_memory_latency = 3;
 103
 104 /* Declarations of static functions.  */
 105 static void alpha_set_memflags_1  PROTO((rtx, int, int, int));
 106 static rtx alpha_emit_set_const_1 PROTO((rtx, enum machine_mode,
 107                                          HOST_WIDE_INT, int));
 108 static void add_long_const      PROTO((FILE *, HOST_WIDE_INT, int, int, int));
 109
 110 /* Compute the size of the save area in the stack.  */
 111 #if OPEN_VMS
 112 static void alpha_sa_mask       PROTO((unsigned long *imaskP,
 113                                        unsigned long *fmaskP));
 114 #endif
 115 /* Get the number of args of a function in one of two ways.  */
 116 #ifdef OPEN_VMS
 117 #define NUM_ARGS current_function_args_info.num_args
 118 #else
 119 #define NUM_ARGS current_function_args_info
 120 #endif
 121
 122 #if OPEN_VMS
 123 #define REG_PV 27
 124 #define REG_RA 26
 125 #else
 126 #define REG_RA 26
 127 #endif
 128 \f
 129 /* Parse target option strings. */
 130
 131 void
 132 override_options ()
 133 {
 134   /* 971208 -- EV6 scheduling parameters are still secret, so don't even
 135      pretend and just schedule for an EV5 for now.  -- r~  */
 136   alpha_cpu
 137     = TARGET_CPU_DEFAULT & MASK_CPU_EV6 ? PROCESSOR_EV6
 138       : (TARGET_CPU_DEFAULT & MASK_CPU_EV5 ? PROCESSOR_EV5 : PROCESSOR_EV4);
 139
 140   if (alpha_cpu_string)
 141     {
 142       if (! strcmp (alpha_cpu_string, "ev4")
 143           || ! strcmp (alpha_cpu_string, "21064"))
 144         {
 145           alpha_cpu = PROCESSOR_EV4;
 146           target_flags &= ~ (MASK_BWX | MASK_CIX | MASK_MAX);
 147         }
 148       else if (! strcmp (alpha_cpu_string, "ev5")
 149                || ! strcmp (alpha_cpu_string, "21164"))
 150         {
 151           alpha_cpu = PROCESSOR_EV5;
 152           target_flags &= ~ (MASK_BWX | MASK_CIX | MASK_MAX);
 153         }
 154       else if (! strcmp (alpha_cpu_string, "ev56")
 155                || ! strcmp (alpha_cpu_string, "21164a"))
 156         {
 157           alpha_cpu = PROCESSOR_EV5;
 158           target_flags |= MASK_BWX;
 159           target_flags &= ~ (MASK_CIX | MASK_MAX);
 160         }
 161       else if (! strcmp (alpha_cpu_string, "pca56")
 162                || ! strcmp (alpha_cpu_string, "21164PC")
 163                || ! strcmp (alpha_cpu_string, "21164pc"))
 164         {
 165           alpha_cpu = PROCESSOR_EV5;
 166           target_flags |= MASK_BWX | MASK_MAX;
 167           target_flags &= ~ MASK_CIX;
 168         }
 169       else if (! strcmp (alpha_cpu_string, "ev6")
 170                || ! strcmp (alpha_cpu_string, "21264"))
 171         {
 172           alpha_cpu = PROCESSOR_EV6;
 173           target_flags |= MASK_BWX | MASK_CIX | MASK_MAX;
 174         }
 175       else
 176         error ("bad value `%s' for -mcpu switch", alpha_cpu_string);
 177     }
 178
 179   alpha_tp = ALPHA_TP_PROG;
 180   alpha_fprm = ALPHA_FPRM_NORM;
 181   alpha_fptm = ALPHA_FPTM_N;
 182
 183   if (TARGET_IEEE)
 184     {
 185       alpha_tp = ALPHA_TP_INSN;
 186       alpha_fptm = ALPHA_FPTM_SU;
 187     }
 188
 189   if (TARGET_IEEE_WITH_INEXACT)
 190     {
 191       alpha_tp = ALPHA_TP_INSN;
 192       alpha_fptm = ALPHA_FPTM_SUI;
 193     }
 194
 195   if (alpha_tp_string)
 196     {
 197       if (! strcmp (alpha_tp_string, "p"))
 198         alpha_tp = ALPHA_TP_PROG;
 199       else if (! strcmp (alpha_tp_string, "f"))
 200         alpha_tp = ALPHA_TP_FUNC;
 201       else if (! strcmp (alpha_tp_string, "i"))
 202         alpha_tp = ALPHA_TP_INSN;
 203       else
 204         error ("bad value `%s' for -mtrap-precision switch", alpha_tp_string);
 205     }
 206
 207   if (alpha_fprm_string)
 208     {
 209       if (! strcmp (alpha_fprm_string, "n"))
 210         alpha_fprm = ALPHA_FPRM_NORM;
 211       else if (! strcmp (alpha_fprm_string, "m"))
 212         alpha_fprm = ALPHA_FPRM_MINF;
 213       else if (! strcmp (alpha_fprm_string, "c"))
 214         alpha_fprm = ALPHA_FPRM_CHOP;
 215       else if (! strcmp (alpha_fprm_string,"d"))
 216         alpha_fprm = ALPHA_FPRM_DYN;
 217       else
 218         error ("bad value `%s' for -mfp-rounding-mode switch",
 219                alpha_fprm_string);
 220     }
 221
 222   if (alpha_fptm_string)
 223     {
 224       if (strcmp (alpha_fptm_string, "n") == 0)
 225         alpha_fptm = ALPHA_FPTM_N;
 226       else if (strcmp (alpha_fptm_string, "u") == 0)
 227         alpha_fptm = ALPHA_FPTM_U;
 228       else if (strcmp (alpha_fptm_string, "su") == 0)
 229         alpha_fptm = ALPHA_FPTM_SU;
 230       else if (strcmp (alpha_fptm_string, "sui") == 0)
 231         alpha_fptm = ALPHA_FPTM_SUI;
 232       else
 233         error ("bad value `%s' for -mfp-trap-mode switch", alpha_fptm_string);
 234     }
 235
 236   /* Do some sanity checks on the above option. */
 237
 238   if ((alpha_fptm == ALPHA_FPTM_SU || alpha_fptm == ALPHA_FPTM_SUI)
 239       && alpha_tp != ALPHA_TP_INSN)
 240     {
 241       warning ("fp software completion requires -mtrap-precision=i");
 242       alpha_tp = ALPHA_TP_INSN;
 243     }
 244
 245   if (TARGET_FLOAT_VAX)
 246     {
 247       if (alpha_fprm == ALPHA_FPRM_MINF || alpha_fprm == ALPHA_FPRM_DYN)
 248         {
 249           warning ("rounding mode not supported for VAX floats");
 250           alpha_fprm = ALPHA_FPRM_NORM;
 251         }
 252       if (alpha_fptm == ALPHA_FPTM_SUI)
 253         {
 254           warning ("trap mode not supported for VAX floats");
 255           alpha_fptm = ALPHA_FPTM_SU;
 256         }
 257     }
 258
 259   {
 260     char *end;
 261     int lat;
 262
 263     if (!alpha_mlat_string)
 264       alpha_mlat_string = "L1";
 265
 266     if (isdigit (alpha_mlat_string[0])
 267         && (lat = strtol (alpha_mlat_string, &end, 10), *end == '\0'))
 268       ;
 269     else if ((alpha_mlat_string[0] == 'L' || alpha_mlat_string[0] == 'l')
 270              && isdigit (alpha_mlat_string[1])
 271              && alpha_mlat_string[2] == '\0')
 272       {
 273         static int const cache_latency[][4] =
 274         {
 275           { 3, 30, -1 },        /* ev4 -- Bcache is a guess */
 276           { 2, 12, 38 },        /* ev5 -- Bcache from PC164 LMbench numbers */
 277           { 3, 13, -1 },        /* ev6 -- Ho hum, doesn't exist yet */
 278         };
 279
 280         lat = alpha_mlat_string[1] - '0';
 281         if (lat < 0 || lat > 3 || cache_latency[alpha_cpu][lat-1] == -1)
 282           {
 283             warning ("L%d cache latency unknown for %s",
 284                      lat, alpha_cpu_name[alpha_cpu]);
 285             lat = 3;
 286           }
 287         else
 288           lat = cache_latency[alpha_cpu][lat-1];
 289       }
 290     else if (! strcmp (alpha_mlat_string, "main"))
 291       {
 292         /* Most current memories have about 370ns latency.  This is
 293            a reasonable guess for a fast cpu.  */
 294         lat = 150;
 295       }
 296     else
 297       {
 298         warning ("bad value `%s' for -mmemory-latency", alpha_mlat_string);
 299         lat = 3;
 300       }
 301
 302     alpha_memory_latency = lat;
 303   }
 304 }
 305 \f
 306 /* Returns 1 if VALUE is a mask that contains full bytes of zero or ones.  */
 307
 308 int
 309 zap_mask (value)
 310      HOST_WIDE_INT value;
 311 {
 312   int i;
 313
 314   for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
 315        i++, value >>= 8)
 316     if ((value & 0xff) != 0 && (value & 0xff) != 0xff)
 317       return 0;
 318
 319   return 1;
 320 }
 321
 322 /* Returns 1 if OP is either the constant zero or a register.  If a
 323    register, it must be in the proper mode unless MODE is VOIDmode.  */
 324
 325 int
 326 reg_or_0_operand (op, mode)
 327       register rtx op;
 328       enum machine_mode mode;
 329 {
 330   return op == const0_rtx || register_operand (op, mode);
 331 }
 332
 333 /* Return 1 if OP is a constant in the range of 0-63 (for a shift) or
 334    any register.  */
 335
 336 int
 337 reg_or_6bit_operand (op, mode)
 338      register rtx op;
 339      enum machine_mode mode;
 340 {
 341   return ((GET_CODE (op) == CONST_INT
 342            && (unsigned HOST_WIDE_INT) INTVAL (op) < 64)
 343           || register_operand (op, mode));
 344 }
 345
 346
 347 /* Return 1 if OP is an 8-bit constant or any register.  */
 348
 349 int
 350 reg_or_8bit_operand (op, mode)
 351      register rtx op;
 352      enum machine_mode mode;
 353 {
 354   return ((GET_CODE (op) == CONST_INT
 355            && (unsigned HOST_WIDE_INT) INTVAL (op) < 0x100)
 356           || register_operand (op, mode));
 357 }
 358
 359 /* Return 1 if OP is an 8-bit constant.  */
 360
 361 int
 362 cint8_operand (op, mode)
 363      register rtx op;
 364      enum machine_mode mode;
 365 {
 366   return (GET_CODE (op) == CONST_INT
 367           && (unsigned HOST_WIDE_INT) INTVAL (op) < 0x100);
 368 }
 369
 370 /* Return 1 if the operand is a valid second operand to an add insn.  */
 371
 372 int
 373 add_operand (op, mode)
 374      register rtx op;
 375      enum machine_mode mode;
 376 {
 377   if (GET_CODE (op) == CONST_INT)
 378     return (CONST_OK_FOR_LETTER_P (INTVAL (op), 'K')
 379             || CONST_OK_FOR_LETTER_P (INTVAL (op), 'L')
 380             || CONST_OK_FOR_LETTER_P (INTVAL (op), 'O'));
 381
 382   return register_operand (op, mode);
 383 }
 384
 385 /* Return 1 if the operand is a valid second operand to a sign-extending
 386    add insn.  */
 387
 388 int
 389 sext_add_operand (op, mode)
 390      register rtx op;
 391      enum machine_mode mode;
 392 {
 393   if (GET_CODE (op) == CONST_INT)
 394     return ((unsigned HOST_WIDE_INT) INTVAL (op) < 255
 395             || (unsigned HOST_WIDE_INT) (- INTVAL (op)) < 255);
 396
 397   return register_operand (op, mode);
 398 }
 399
 400 /* Return 1 if OP is the constant 4 or 8.  */
 401
 402 int
 403 const48_operand (op, mode)
 404      register rtx op;
 405      enum machine_mode mode;
 406 {
 407   return (GET_CODE (op) == CONST_INT
 408           && (INTVAL (op) == 4 || INTVAL (op) == 8));
 409 }
 410
 411 /* Return 1 if OP is a valid first operand to an AND insn.  */
 412
 413 int
 414 and_operand (op, mode)
 415      register rtx op;
 416      enum machine_mode mode;
 417 {
 418   if (GET_CODE (op) == CONST_DOUBLE && GET_MODE (op) == VOIDmode)
 419     return (zap_mask (CONST_DOUBLE_LOW (op))
 420             && zap_mask (CONST_DOUBLE_HIGH (op)));
 421
 422   if (GET_CODE (op) == CONST_INT)
 423     return ((unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
 424             || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100
 425             || zap_mask (INTVAL (op)));
 426
 427   return register_operand (op, mode);
 428 }
 429
 430 /* Return 1 if OP is a valid first operand to an IOR or XOR insn.  */
 431
 432 int
 433 or_operand (op, mode)
 434      register rtx op;
 435      enum machine_mode mode;
 436 {
 437   if (GET_CODE (op) == CONST_INT)
 438     return ((unsigned HOST_WIDE_INT) INTVAL (op) < 0x100
 439             || (unsigned HOST_WIDE_INT) ~ INTVAL (op) < 0x100);
 440
 441   return register_operand (op, mode);
 442 }
 443
 444 /* Return 1 if OP is a constant that is the width, in bits, of an integral
 445    mode smaller than DImode.  */
 446
 447 int
 448 mode_width_operand (op, mode)
 449      register rtx op;
 450      enum machine_mode mode;
 451 {
 452   return (GET_CODE (op) == CONST_INT
 453           && (INTVAL (op) == 8 || INTVAL (op) == 16
 454               || INTVAL (op) == 32 || INTVAL (op) == 64));
 455 }
 456
 457 /* Return 1 if OP is a constant that is the width of an integral machine mode
 458    smaller than an integer.  */
 459
 460 int
 461 mode_mask_operand (op, mode)
 462      register rtx op;
 463      enum machine_mode mode;
 464 {
 465 #if HOST_BITS_PER_WIDE_INT == 32
 466   if (GET_CODE (op) == CONST_DOUBLE)
 467     return (CONST_DOUBLE_LOW (op) == -1
 468             && (CONST_DOUBLE_HIGH (op) == -1
 469                 || CONST_DOUBLE_HIGH (op) == 0));
 470 #else
 471   if (GET_CODE (op) == CONST_DOUBLE)
 472     return (CONST_DOUBLE_LOW (op) == -1 && CONST_DOUBLE_HIGH (op) == 0);
 473 #endif
 474
 475   return (GET_CODE (op) == CONST_INT
 476           && (INTVAL (op) == 0xff
 477               || INTVAL (op) == 0xffff
 478               || INTVAL (op) == 0xffffffff
 479 #if HOST_BITS_PER_WIDE_INT == 64
 480               || INTVAL (op) == 0xffffffffffffffff
 481 #endif
 482               ));
 483 }
 484
 485 /* Return 1 if OP is a multiple of 8 less than 64.  */
 486
 487 int
 488 mul8_operand (op, mode)
 489      register rtx op;
 490      enum machine_mode mode;
 491 {
 492   return (GET_CODE (op) == CONST_INT
 493           && (unsigned HOST_WIDE_INT) INTVAL (op) < 64
 494           && (INTVAL (op) & 7) == 0);
 495 }
 496
 497 /* Return 1 if OP is the constant zero in floating-point.  */
 498
 499 int
 500 fp0_operand (op, mode)
 501      register rtx op;
 502      enum machine_mode mode;
 503 {
 504   return (GET_MODE (op) == mode
 505           && GET_MODE_CLASS (mode) == MODE_FLOAT && op == CONST0_RTX (mode));
 506 }
 507
 508 /* Return 1 if OP is the floating-point constant zero or a register.  */
 509
 510 int
 511 reg_or_fp0_operand (op, mode)
 512      register rtx op;
 513      enum machine_mode mode;
 514 {
 515   return fp0_operand (op, mode) || register_operand (op, mode);
 516 }
 517
 518 /* Return 1 if OP is a register or a constant integer.  */
 519
 520
 521 int
 522 reg_or_cint_operand (op, mode)
 523     register rtx op;
 524     enum machine_mode mode;
 525 {
 526      return GET_CODE (op) == CONST_INT || register_operand (op, mode);
 527 }
 528
 529 /* Return 1 if OP is something that can be reloaded into a register;
 530    if it is a MEM, it need not be valid.  */
 531
 532 int
 533 some_operand (op, mode)
 534      register rtx op;
 535      enum machine_mode mode;
 536 {
 537   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 538     return 0;
 539
 540   switch (GET_CODE (op))
 541     {
 542     case REG:  case MEM:  case CONST_DOUBLE:
 543     case CONST_INT:  case LABEL_REF:  case SYMBOL_REF:  case CONST:
 544       return 1;
 545
 546     case SUBREG:
 547       return some_operand (SUBREG_REG (op), VOIDmode);
 548
 549     default:
 550       break;
 551     }
 552
 553   return 0;
 554 }
 555
 556 /* Return 1 if OP is a valid operand for the source of a move insn.  */
 557
 558 int
 559 input_operand (op, mode)
 560      register rtx op;
 561      enum machine_mode mode;
 562 {
 563   if (mode != VOIDmode && GET_MODE (op) != VOIDmode && mode != GET_MODE (op))
 564     return 0;
 565
 566   if (GET_MODE_CLASS (mode) == MODE_FLOAT && GET_MODE (op) != mode)
 567     return 0;
 568
 569   switch (GET_CODE (op))
 570     {
 571     case LABEL_REF:
 572     case SYMBOL_REF:
 573     case CONST:
 574         /* This handles both the Windows/NT and OSF cases.  */
 575       return mode == ptr_mode || mode == DImode;
 576
 577     case REG:
 578       return 1;
 579
 580     case SUBREG:
 581       if (register_operand (op, mode))
 582         return 1;
 583       /* ... fall through ... */
 584     case MEM:
 585       return ((TARGET_BWX || (mode != HImode && mode != QImode))
 586               && general_operand (op, mode));
 587
 588     case CONST_DOUBLE:
 589       return GET_MODE_CLASS (mode) == MODE_FLOAT && op == CONST0_RTX (mode);
 590
 591     case CONST_INT:
 592       return mode == QImode || mode == HImode || add_operand (op, mode);
 593
 594     default:
 595       break;
 596     }
 597
 598   return 0;
 599 }
 600
 601 /* Return 1 if OP is a SYMBOL_REF for a function known to be in this
 602    file.  */
 603
 604 int
 605 current_file_function_operand (op, mode)
 606      rtx op;
 607      enum machine_mode mode;
 608 {
 609   return (GET_CODE (op) == SYMBOL_REF
 610           && ! profile_flag && ! profile_block_flag
 611           && (SYMBOL_REF_FLAG (op)
 612               || op == XEXP (DECL_RTL (current_function_decl), 0)));
 613 }
 614
 615 /* Return 1 if OP is a valid operand for the MEM of a CALL insn.  */
 616
 617 int
 618 call_operand (op, mode)
 619      rtx op;
 620      enum machine_mode mode;
 621 {
 622   if (mode != Pmode)
 623     return 0;
 624
 625   return (GET_CODE (op) == SYMBOL_REF
 626           || (GET_CODE (op) == REG
 627               && (TARGET_OPEN_VMS || TARGET_WINDOWS_NT || REGNO (op) == 27)));
 628 }
 629
 630 /* Return 1 if OP is a valid Alpha comparison operator.  Here we know which
 631    comparisons are valid in which insn.  */
 632
 633 int
 634 alpha_comparison_operator (op, mode)
 635      register rtx op;
 636      enum machine_mode mode;
 637 {
 638   enum rtx_code code = GET_CODE (op);
 639
 640   if (mode != GET_MODE (op) || GET_RTX_CLASS (code) != '<')
 641     return 0;
 642
 643   return (code == EQ || code == LE || code == LT
 644           || (mode == DImode && (code == LEU || code == LTU)));
 645 }
 646
 647 /* Return 1 if OP is a valid Alpha swapped comparison operator.  */
 648
 649 int
 650 alpha_swapped_comparison_operator (op, mode)
 651      register rtx op;
 652      enum machine_mode mode;
 653 {
 654   enum rtx_code code = GET_CODE (op);
 655
 656   if (mode != GET_MODE (op) || GET_RTX_CLASS (code) != '<')
 657     return 0;
 658
 659   code = swap_condition (code);
 660   return (code == EQ || code == LE || code == LT
 661           || (mode == DImode && (code == LEU || code == LTU)));
 662 }
 663
 664 /* Return 1 if OP is a signed comparison operation.  */
 665
 666 int
 667 signed_comparison_operator (op, mode)
 668      register rtx op;
 669      enum machine_mode mode;
 670 {
 671   switch (GET_CODE (op))
 672     {
 673     case EQ:  case NE:  case LE:  case LT:  case GE:   case GT:
 674       return 1;
 675
 676     default:
 677       break;
 678     }
 679
 680   return 0;
 681 }
 682
 683 /* Return 1 if this is a divide or modulus operator.  */
 684
 685 int
 686 divmod_operator (op, mode)
 687      register rtx op;
 688      enum machine_mode mode;
 689 {
 690   switch (GET_CODE (op))
 691     {
 692     case DIV:  case MOD:  case UDIV:  case UMOD:
 693       return 1;
 694
 695     default:
 696       break;
 697     }
 698
 699   return 0;
 700 }
 701
 702 /* Return 1 if this memory address is a known aligned register plus
 703    a constant.  It must be a valid address.  This means that we can do
 704    this as an aligned reference plus some offset.
 705
 706    Take into account what reload will do.
 707
 708    We could say that out-of-range stack slots are alignable, but that would
 709    complicate get_aligned_mem and it isn't worth the trouble since few
 710    functions have large stack space.  */
 711
 712 int
 713 aligned_memory_operand (op, mode)
 714      register rtx op;
 715      enum machine_mode mode;
 716 {
 717   if (GET_CODE (op) == SUBREG)
 718     {
 719       if (GET_MODE (op) != mode)
 720         return 0;
 721       op = SUBREG_REG (op);
 722       mode = GET_MODE (op);
 723     }
 724
 725   if (reload_in_progress && GET_CODE (op) == REG
 726       && REGNO (op) >= FIRST_PSEUDO_REGISTER)
 727     op = reg_equiv_mem[REGNO (op)];
 728
 729   if (GET_CODE (op) != MEM || GET_MODE (op) != mode
 730       || ! memory_address_p (mode, XEXP (op, 0)))
 731     return 0;
 732
 733   op = XEXP (op, 0);
 734
 735   if (GET_CODE (op) == PLUS)
 736     op = XEXP (op, 0);
 737
 738   return (GET_CODE (op) == REG
 739           && REGNO_POINTER_ALIGN (REGNO (op)) >= 4);
 740 }
 741
 742 /* Similar, but return 1 if OP is a MEM which is not alignable.  */
 743
 744 int
 745 unaligned_memory_operand (op, mode)
 746      register rtx op;
 747      enum machine_mode mode;
 748 {
 749   if (GET_CODE (op) == SUBREG)
 750     {
 751       if (GET_MODE (op) != mode)
 752         return 0;
 753       op = SUBREG_REG (op);
 754       mode = GET_MODE (op);
 755     }
 756
 757   if (reload_in_progress && GET_CODE (op) == REG
 758       && REGNO (op) >= FIRST_PSEUDO_REGISTER)
 759     op = reg_equiv_mem[REGNO (op)];
 760
 761   if (GET_CODE (op) != MEM || GET_MODE (op) != mode)
 762     return 0;
 763
 764   op = XEXP (op, 0);
 765
 766   if (! memory_address_p (mode, op))
 767     return 1;
 768
 769   if (GET_CODE (op) == PLUS)
 770     op = XEXP (op, 0);
 771
 772   return (GET_CODE (op) != REG
 773           || REGNO_POINTER_ALIGN (REGNO (op)) < 4);
 774 }
 775
 776 /* Return 1 if OP is either a register or an unaligned memory location.  */
 777
 778 int
 779 reg_or_unaligned_mem_operand (op, mode)
 780      rtx op;
 781      enum machine_mode mode;
 782 {
 783   return register_operand (op, mode) || unaligned_memory_operand (op, mode);
 784 }
 785
 786 /* Return 1 if OP is any memory location.  During reload a pseudo matches.  */
 787
 788 int
 789 any_memory_operand (op, mode)
 790      register rtx op;
 791      enum machine_mode mode;
 792 {
 793   return (GET_CODE (op) == MEM
 794           || (GET_CODE (op) == SUBREG && GET_CODE (SUBREG_REG (op)) == REG)
 795           || (reload_in_progress && GET_CODE (op) == REG
 796               && REGNO (op) >= FIRST_PSEUDO_REGISTER)
 797           || (reload_in_progress && GET_CODE (op) == SUBREG
 798               && GET_CODE (SUBREG_REG (op)) == REG
 799               && REGNO (SUBREG_REG (op)) >= FIRST_PSEUDO_REGISTER));
 800 }
 801
 802 /* REF is an alignable memory location.  Place an aligned SImode
 803    reference into *PALIGNED_MEM and the number of bits to shift into
 804    *PBITNUM.  */
 805
 806 void
 807 get_aligned_mem (ref, paligned_mem, pbitnum)
 808      rtx ref;
 809      rtx *paligned_mem, *pbitnum;
 810 {
 811   rtx base;
 812   HOST_WIDE_INT offset = 0;
 813
 814   if (GET_CODE (ref) == SUBREG)
 815     {
 816       offset = SUBREG_WORD (ref) * UNITS_PER_WORD;
 817       if (BYTES_BIG_ENDIAN)
 818         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (ref)))
 819                    - MIN (UNITS_PER_WORD,
 820                           GET_MODE_SIZE (GET_MODE (SUBREG_REG (ref)))));
 821       ref = SUBREG_REG (ref);
 822     }
 823
 824   if (GET_CODE (ref) == REG)
 825     ref = reg_equiv_mem[REGNO (ref)];
 826
 827   if (reload_in_progress)
 828     base = find_replacement (&XEXP (ref, 0));
 829   else
 830     base = XEXP (ref, 0);
 831
 832   if (GET_CODE (base) == PLUS)
 833     offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
 834
 835   *paligned_mem = gen_rtx_MEM (SImode,
 836                            plus_constant (base, offset & ~3));
 837   MEM_IN_STRUCT_P (*paligned_mem) = MEM_IN_STRUCT_P (ref);
 838   MEM_VOLATILE_P (*paligned_mem) = MEM_VOLATILE_P (ref);
 839   RTX_UNCHANGING_P (*paligned_mem) = RTX_UNCHANGING_P (ref);
 840
 841   *pbitnum = GEN_INT ((offset & 3) * 8);
 842 }
 843
 844 /* Similar, but just get the address.  Handle the two reload cases.
 845    Add EXTRA_OFFSET to the address we return.  */
 846
 847 rtx
 848 get_unaligned_address (ref, extra_offset)
 849      rtx ref;
 850      int extra_offset;
 851 {
 852   rtx base;
 853   HOST_WIDE_INT offset = 0;
 854
 855   if (GET_CODE (ref) == SUBREG)
 856     {
 857       offset = SUBREG_WORD (ref) * UNITS_PER_WORD;
 858       if (BYTES_BIG_ENDIAN)
 859         offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (ref)))
 860                    - MIN (UNITS_PER_WORD,
 861                           GET_MODE_SIZE (GET_MODE (SUBREG_REG (ref)))));
 862       ref = SUBREG_REG (ref);
 863     }
 864
 865   if (GET_CODE (ref) == REG)
 866     ref = reg_equiv_mem[REGNO (ref)];
 867
 868   if (reload_in_progress)
 869     base = find_replacement (&XEXP (ref, 0));
 870   else
 871     base = XEXP (ref, 0);
 872
 873   if (GET_CODE (base) == PLUS)
 874     offset += INTVAL (XEXP (base, 1)), base = XEXP (base, 0);
 875
 876   return plus_constant (base, offset + extra_offset);
 877 }
 878 \f
 879 /* Subfunction of the following function.  Update the flags of any MEM
 880    found in part of X.  */
 881
 882 static void
 883 alpha_set_memflags_1 (x, in_struct_p, volatile_p, unchanging_p)
 884      rtx x;
 885      int in_struct_p, volatile_p, unchanging_p;
 886 {
 887   int i;
 888
 889   switch (GET_CODE (x))
 890     {
 891     case SEQUENCE:
 892     case PARALLEL:
 893       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
 894         alpha_set_memflags_1 (XVECEXP (x, 0, i), in_struct_p, volatile_p,
 895                               unchanging_p);
 896       break;
 897
 898     case INSN:
 899       alpha_set_memflags_1 (PATTERN (x), in_struct_p, volatile_p,
 900                             unchanging_p);
 901       break;
 902
 903     case SET:
 904       alpha_set_memflags_1 (SET_DEST (x), in_struct_p, volatile_p,
 905                             unchanging_p);
 906       alpha_set_memflags_1 (SET_SRC (x), in_struct_p, volatile_p,
 907                             unchanging_p);
 908       break;
 909
 910     case MEM:
 911       MEM_IN_STRUCT_P (x) = in_struct_p;
 912       MEM_VOLATILE_P (x) = volatile_p;
 913       RTX_UNCHANGING_P (x) = unchanging_p;
 914       break;
 915
 916     default:
 917       break;
 918     }
 919 }
 920
 921 /* Given INSN, which is either an INSN or a SEQUENCE generated to
 922    perform a memory operation, look for any MEMs in either a SET_DEST or
 923    a SET_SRC and copy the in-struct, unchanging, and volatile flags from
 924    REF into each of the MEMs found.  If REF is not a MEM, don't do
 925    anything.  */
 926
 927 void
 928 alpha_set_memflags (insn, ref)
 929      rtx insn;
 930      rtx ref;
 931 {
 932   /* Note that it is always safe to get these flags, though they won't
 933      be what we think if REF is not a MEM.  */
 934   int in_struct_p = MEM_IN_STRUCT_P (ref);
 935   int volatile_p = MEM_VOLATILE_P (ref);
 936   int unchanging_p = RTX_UNCHANGING_P (ref);
 937
 938   if (GET_CODE (ref) != MEM
 939       || (! in_struct_p && ! volatile_p && ! unchanging_p))
 940     return;
 941
 942   alpha_set_memflags_1 (insn, in_struct_p, volatile_p, unchanging_p);
 943 }
 944 \f
 945 /* Try to output insns to set TARGET equal to the constant C if it can be
 946    done in less than N insns.  Do all computations in MODE.  Returns the place
 947    where the output has been placed if it can be done and the insns have been
 948    emitted.  If it would take more than N insns, zero is returned and no
 949    insns and emitted.  */
 950
 951 rtx
 952 alpha_emit_set_const (target, mode, c, n)
 953      rtx target;
 954      enum machine_mode mode;
 955      HOST_WIDE_INT c;
 956      int n;
 957 {
 958   rtx pat;
 959   int i;
 960
 961   /* Try 1 insn, then 2, then up to N. */
 962   for (i = 1; i <= n; i++)
 963     if ((pat = alpha_emit_set_const_1 (target, mode, c, i)) != 0)
 964       return pat;
 965
 966   return 0;
 967 }
 968
 969 /* Internal routine for the above to check for N or below insns.  */
 970
 971 static rtx
 972 alpha_emit_set_const_1 (target, mode, c, n)
 973      rtx target;
 974      enum machine_mode mode;
 975      HOST_WIDE_INT c;
 976      int n;
 977 {
 978   HOST_WIDE_INT new = c;
 979   int i, bits;
 980   /* Use a pseudo if highly optimizing and still generating RTL.  */
 981   rtx subtarget
 982     = (flag_expensive_optimizations && rtx_equal_function_value_matters
 983        ? 0 : target);
 984   rtx temp;
 985
 986 #if HOST_BITS_PER_WIDE_INT == 64
 987   /* We are only called for SImode and DImode.  If this is SImode, ensure that
 988      we are sign extended to a full word.  This does not make any sense when
 989      cross-compiling on a narrow machine.  */
 990
 991   if (mode == SImode)
 992     c = (c & 0xffffffff) - 2 * (c & 0x80000000);
 993 #endif
 994
 995   /* If this is a sign-extended 32-bit constant, we can do this in at most
 996      three insns, so do it if we have enough insns left.  We always have
 997      a sign-extended 32-bit constant when compiling on a narrow machine.   */
 998
 999   if (HOST_BITS_PER_WIDE_INT != 64
1000       || c >> 31 == -1 || c >> 31 == 0)
1001     {
1002       HOST_WIDE_INT low = (c & 0xffff) - 2 * (c & 0x8000);
1003       HOST_WIDE_INT tmp1 = c - low;
1004       HOST_WIDE_INT high
1005         = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
1006       HOST_WIDE_INT extra = 0;
1007
1008       /* If HIGH will be interpreted as negative but the constant is
1009          positive, we must adjust it to do two ldha insns.  */
1010
1011       if ((high & 0x8000) != 0 && c >= 0)
1012         {
1013           extra = 0x4000;
1014           tmp1 -= 0x40000000;
1015           high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
1016         }
1017
1018       if (c == low || (low == 0 && extra == 0))
1019         {
1020           /* We used to use copy_to_suggested_reg (GEN_INT (c), target, mode)
1021              but that meant that we can't handle INT_MIN on 32-bit machines
1022              (like NT/Alpha), because we recurse indefinitely through
1023              emit_move_insn to gen_movdi.  So instead, since we know exactly
1024              what we want, create it explicitly.  */
1025
1026           if (target == NULL)
1027             target = gen_reg_rtx (mode);
1028           emit_insn (gen_rtx_SET (VOIDmode, target, GEN_INT (c)));
1029           return target;
1030         }
1031       else if (n >= 2 + (extra != 0))
1032         {
1033           temp = copy_to_suggested_reg (GEN_INT (low), subtarget, mode);
1034
1035           if (extra != 0)
1036             temp = expand_binop (mode, add_optab, temp, GEN_INT (extra << 16),
1037                                  subtarget, 0, OPTAB_WIDEN);
1038
1039           return expand_binop (mode, add_optab, temp, GEN_INT (high << 16),
1040                                target, 0, OPTAB_WIDEN);
1041         }
1042     }
1043
1044   /* If we couldn't do it that way, try some other methods.  But if we have
1045      no instructions left, don't bother.  Likewise, if this is SImode and
1046      we can't make pseudos, we can't do anything since the expand_binop
1047      and expand_unop calls will widen and try to make pseudos.  */
1048
1049   if (n == 1
1050       || (mode == SImode && ! rtx_equal_function_value_matters))
1051     return 0;
1052
1053 #if HOST_BITS_PER_WIDE_INT == 64
1054   /* First, see if can load a value into the target that is the same as the
1055      constant except that all bytes that are 0 are changed to be 0xff.  If we
1056      can, then we can do a ZAPNOT to obtain the desired constant.  */
1057
1058   for (i = 0; i < 64; i += 8)
1059     if ((new & ((HOST_WIDE_INT) 0xff << i)) == 0)
1060       new |= (HOST_WIDE_INT) 0xff << i;
1061
1062   /* We are only called for SImode and DImode.  If this is SImode, ensure that
1063      we are sign extended to a full word.  */
1064
1065   if (mode == SImode)
1066     new = (new & 0xffffffff) - 2 * (new & 0x80000000);
1067
1068   if (new != c
1069       && (temp = alpha_emit_set_const (subtarget, mode, new, n - 1)) != 0)
1070     return expand_binop (mode, and_optab, temp, GEN_INT (c | ~ new),
1071                          target, 0, OPTAB_WIDEN);
1072 #endif
1073
1074   /* Next, see if we can load a related constant and then shift and possibly
1075      negate it to get the constant we want.  Try this once each increasing
1076      numbers of insns.  */
1077
1078   for (i = 1; i < n; i++)
1079     {
1080       /* First try complementing.  */
1081       if ((temp = alpha_emit_set_const (subtarget, mode, ~ c, i)) != 0)
1082         return expand_unop (mode, one_cmpl_optab, temp, target, 0);
1083
1084       /* Next try to form a constant and do a left shift.  We can do this
1085          if some low-order bits are zero; the exact_log2 call below tells
1086          us that information.  The bits we are shifting out could be any
1087          value, but here we'll just try the 0- and sign-extended forms of
1088          the constant.  To try to increase the chance of having the same
1089          constant in more than one insn, start at the highest number of
1090          bits to shift, but try all possibilities in case a ZAPNOT will
1091          be useful.  */
1092
1093       if ((bits = exact_log2 (c & - c)) > 0)
1094         for (; bits > 0; bits--)
1095           if ((temp = (alpha_emit_set_const
1096                        (subtarget, mode,
1097                         (unsigned HOST_WIDE_INT) c >> bits, i))) != 0
1098               || ((temp = (alpha_emit_set_const
1099                           (subtarget, mode,
1100                            ((unsigned HOST_WIDE_INT) c) >> bits, i)))
1101                   != 0))
1102             return expand_binop (mode, ashl_optab, temp, GEN_INT (bits),
1103                                  target, 0, OPTAB_WIDEN);
1104
1105       /* Now try high-order zero bits.  Here we try the shifted-in bits as
1106          all zero and all ones.  Be careful to avoid shifting outside the
1107          mode and to avoid shifting outside the host wide int size.  */
1108       /* On narrow hosts, don't shift a 1 into the high bit, since we'll
1109          confuse the recursive call and set all of the high 32 bits.  */
1110
1111       if ((bits = (MIN (HOST_BITS_PER_WIDE_INT, GET_MODE_SIZE (mode) * 8)
1112                    - floor_log2 (c) - 1 - (HOST_BITS_PER_WIDE_INT < 64))) > 0)
1113         for (; bits > 0; bits--)
1114           if ((temp = alpha_emit_set_const (subtarget, mode,
1115                                             c << bits, i)) != 0
1116               || ((temp = (alpha_emit_set_const
1117                            (subtarget, mode,
1118                             ((c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1)),
1119                             i)))
1120                   != 0))
1121             return expand_binop (mode, lshr_optab, temp, GEN_INT (bits),
1122                                  target, 1, OPTAB_WIDEN);
1123
1124       /* Now try high-order 1 bits.  We get that with a sign-extension.
1125          But one bit isn't enough here.  Be careful to avoid shifting outside
1126          the mode and to avoid shifting outside the host wide int size. */
1127
1128       if ((bits = (MIN (HOST_BITS_PER_WIDE_INT, GET_MODE_SIZE (mode) * 8)
1129                    - floor_log2 (~ c) - 2)) > 0)
1130         for (; bits > 0; bits--)
1131           if ((temp = alpha_emit_set_const (subtarget, mode,
1132                                             c << bits, i)) != 0
1133               || ((temp = (alpha_emit_set_const
1134                            (subtarget, mode,
1135                             ((c << bits) | (((HOST_WIDE_INT) 1 << bits) - 1)),
1136                             i)))
1137                   != 0))
1138             return expand_binop (mode, ashr_optab, temp, GEN_INT (bits),
1139                                  target, 0, OPTAB_WIDEN);
1140     }
1141
1142   return 0;
1143 }
1144
1145 #if HOST_BITS_PER_WIDE_INT == 64
1146 /* Having failed to find a 3 insn sequence in alpha_emit_set_const,
1147    fall back to a straight forward decomposition.  We do this to avoid
1148    exponential run times encountered when looking for longer sequences
1149    with alpha_emit_set_const.  */
1150
1151 rtx
1152 alpha_emit_set_long_const (target, c)
1153      rtx target;
1154      HOST_WIDE_INT c;
1155 {
1156   /* Use a pseudo if highly optimizing and still generating RTL.  */
1157   rtx subtarget
1158     = (flag_expensive_optimizations && rtx_equal_function_value_matters
1159        ? 0 : target);
1160   HOST_WIDE_INT d1, d2, d3, d4;
1161   rtx r1, r2;
1162
1163   /* Decompose the entire word */
1164   d1 = ((c & 0xffff) ^ 0x8000) - 0x8000;
1165   c -= d1;
1166   d2 = ((c & 0xffffffff) ^ 0x80000000) - 0x80000000;
1167   c = (c - d2) >> 32;
1168   d3 = ((c & 0xffff) ^ 0x8000) - 0x8000;
1169   c -= d3;
1170   d4 = ((c & 0xffffffff) ^ 0x80000000) - 0x80000000;
1171
1172   if (c - d4 != 0)
1173     abort();
1174
1175   /* Construct the high word */
1176   if (d3 == 0)
1177     r1 = copy_to_suggested_reg (GEN_INT (d4), subtarget, DImode);
1178   else if (d4 == 0)
1179     r1 = copy_to_suggested_reg (GEN_INT (d3), subtarget, DImode);
1180   else
1181     r1 = expand_binop (DImode, add_optab, GEN_INT (d3), GEN_INT (d4),
1182                        subtarget, 0, OPTAB_WIDEN);
1183
1184   /* Shift it into place */
1185   r2 = expand_binop (DImode, ashl_optab, r1, GEN_INT (32),
1186                      subtarget, 0, OPTAB_WIDEN);
1187
1188   if (subtarget == 0 && d1 == d3 && d2 == d4)
1189     r1 = expand_binop (DImode, add_optab, r1, r2, subtarget, 0, OPTAB_WIDEN);
1190   else
1191     {
1192       r1 = r2;
1193
1194       /* Add in the low word */
1195       if (d2 != 0)
1196         r1 = expand_binop (DImode, add_optab, r1, GEN_INT (d2),
1197                            subtarget, 0, OPTAB_WIDEN);
1198       if (d1 != 0)
1199         r1 = expand_binop (DImode, add_optab, r1, GEN_INT (d1),
1200                            subtarget, 0, OPTAB_WIDEN);
1201     }
1202
1203   if (subtarget == 0)
1204     r1 = copy_to_suggested_reg(r1, target, DImode);
1205
1206   return r1;
1207 }
1208 #endif /* HOST_BITS_PER_WIDE_INT == 64 */
1209
1210 /* Rewrite a comparison against zero CMP of the form
1211    (CODE (cc0) (const_int 0)) so it can be written validly in
1212    a conditional move (if_then_else CMP ...).
1213    If both of the operands that set cc0 are non-zero we must emit
1214    an insn to perform the compare (it can't be done within
1215    the conditional move). */
1216 rtx
1217 alpha_emit_conditional_move (cmp, mode)
1218      rtx cmp;
1219      enum machine_mode mode;
1220 {
1221   enum rtx_code code = GET_CODE (cmp);
1222   enum rtx_code cmov_code = NE;
1223   rtx op0 = alpha_compare_op0;
1224   rtx op1 = alpha_compare_op1;
1225   enum machine_mode cmp_mode
1226     = (GET_MODE (op0) == VOIDmode ? DImode : GET_MODE (op0));
1227   enum machine_mode cmp_op_mode = alpha_compare_fp_p ? DFmode : DImode;
1228   rtx tem;
1229
1230   if (alpha_compare_fp_p != FLOAT_MODE_P (mode))
1231     return 0;
1232
1233   /* We may be able to use a conditional move directly.
1234      This avoids emitting spurious compares. */
1235   if (signed_comparison_operator (cmp, cmp_op_mode)
1236       && (op0 == CONST0_RTX (cmp_mode) || op1 == CONST0_RTX (cmp_mode)))
1237     return gen_rtx_fmt_ee (code, VOIDmode, op0, op1);
1238
1239   /* We can't put the comparison insides a conditional move;
1240      emit a compare instruction and put that inside the
1241      conditional move.  Make sure we emit only comparisons we have;
1242      swap or reverse as necessary.  */
1243
1244   switch (code)
1245     {
1246     case EQ:  case LE:  case LT:  case LEU:  case LTU:
1247       /* We have these compares: */
1248       break;
1249
1250     case NE:
1251       /* This must be reversed. */
1252       code = reverse_condition (code);
1253       cmov_code = EQ;
1254       break;
1255
1256     case GE:  case GT:  case GEU:  case GTU:
1257       /* These must be swapped.  Make sure the new first operand is in
1258          a register.  */
1259       code = swap_condition (code);
1260       tem = op0, op0 = op1, op1 = tem;
1261       op0 = force_reg (cmp_mode, op0);
1262       break;
1263
1264     default:
1265       abort ();
1266     }
1267
1268   tem = gen_reg_rtx (cmp_op_mode);
1269   emit_move_insn (tem, gen_rtx_fmt_ee (code, cmp_op_mode, op0, op1));
1270   return gen_rtx_fmt_ee (cmov_code, VOIDmode, tem, CONST0_RTX (cmp_op_mode));
1271 }
1272 \f
1273 /* Use ext[wlq][lh] as the Architecture Handbook describes for extracting
1274    unaligned data:
1275
1276            unsigned:                       signed:
1277    word:   ldq_u  r1,X(r11)                ldq_u  r1,X(r11)
1278            ldq_u  r2,X+1(r11)              ldq_u  r2,X+1(r11)
1279            lda    r3,X(r11)                lda    r3,X+2(r11)
1280            extwl  r1,r3,r1                 extql  r1,r3,r1
1281            extwh  r2,r3,r2                 extqh  r2,r3,r2
1282            or     r1.r2.r1                 or     r1,r2,r1
1283                                            sra    r1,48,r1
1284
1285    long:   ldq_u  r1,X(r11)                ldq_u  r1,X(r11)
1286            ldq_u  r2,X+3(r11)              ldq_u  r2,X+3(r11)
1287            lda    r3,X(r11)                lda    r3,X(r11)
1288            extll  r1,r3,r1                 extll  r1,r3,r1
1289            extlh  r2,r3,r2                 extlh  r2,r3,r2
1290            or     r1.r2.r1                 addl   r1,r2,r1
1291
1292    quad:   ldq_u  r1,X(r11)
1293            ldq_u  r2,X+7(r11)
1294            lda    r3,X(r11)
1295            extql  r1,r3,r1
1296            extqh  r2,r3,r2
1297            or     r1.r2.r1
1298 */
1299
1300 void
1301 alpha_expand_unaligned_load (tgt, mem, size, ofs, sign)
1302      rtx tgt, mem;
1303      HOST_WIDE_INT size, ofs;
1304      int sign;
1305 {
1306   rtx meml, memh, addr, extl, exth;
1307
1308   meml = gen_reg_rtx (DImode);
1309   memh = gen_reg_rtx (DImode);
1310   addr = gen_reg_rtx (DImode);
1311   extl = gen_reg_rtx (DImode);
1312   exth = gen_reg_rtx (DImode);
1313
1314   emit_move_insn (meml,
1315                   change_address (mem, DImode,
1316                                   gen_rtx_AND (DImode,
1317                                                plus_constant (XEXP (mem, 0),
1318                                                               ofs),
1319                                                GEN_INT (-8))));
1320
1321   emit_move_insn (memh,
1322                   change_address (mem, DImode,
1323                                   gen_rtx_AND (DImode,
1324                                                plus_constant (XEXP (mem, 0),
1325                                                               ofs + size - 1),
1326                                                GEN_INT (-8))));
1327
1328   if (sign && size == 2)
1329     {
1330       emit_move_insn (addr, plus_constant (XEXP (mem, 0), ofs+2));
1331
1332       emit_insn (gen_extxl (extl, meml, GEN_INT (64), addr));
1333       emit_insn (gen_extqh (exth, memh, addr));
1334
1335       expand_binop (DImode, ior_optab, extl, exth, addr, 1, OPTAB_WIDEN);
1336       expand_binop (DImode, ashr_optab, addr, GEN_INT (48), addr,
1337                     1, OPTAB_WIDEN);
1338       emit_move_insn (tgt, addr);
1339       return;
1340     }
1341
1342   emit_move_insn (addr, plus_constant (XEXP (mem, 0), ofs));
1343   emit_insn (gen_extxl (extl, meml, GEN_INT (size*8), addr));
1344   switch (size)
1345     {
1346     case 2:
1347       emit_insn (gen_extwh (exth, memh, addr));
1348       break;
1349
1350     case 4:
1351       emit_insn (gen_extlh (exth, memh, addr));
1352       break;
1353
1354     case 8:
1355       emit_insn (gen_extqh (exth, memh, addr));
1356       break;
1357     }
1358
1359   expand_binop (DImode, ior_optab, extl, exth, tgt, sign, OPTAB_WIDEN);
1360 }
1361
1362 /* Similarly, use ins and msk instructions to perform unaligned stores.  */
1363
1364 void
1365 alpha_expand_unaligned_store (dst, src, size, ofs)
1366      rtx dst, src;
1367      HOST_WIDE_INT size, ofs;
1368 {
1369   rtx dstl, dsth, addr, insl, insh, meml, memh;
1370
1371   dstl = gen_reg_rtx (DImode);
1372   dsth = gen_reg_rtx (DImode);
1373   insl = gen_reg_rtx (DImode);
1374   insh = gen_reg_rtx (DImode);
1375
1376   meml = change_address (dst, DImode,
1377                          gen_rtx_AND (DImode,
1378                                       plus_constant (XEXP (dst, 0), ofs),
1379                                       GEN_INT (-8)));
1380   memh = change_address (dst, DImode,
1381                          gen_rtx_AND (DImode,
1382                                       plus_constant (XEXP (dst, 0),
1383                                                      ofs+size-1),
1384                                       GEN_INT (-8)));
1385
1386   emit_move_insn (dsth, memh);
1387   emit_move_insn (dstl, meml);
1388   addr = copy_addr_to_reg (plus_constant (XEXP (dst, 0), ofs));
1389
1390   if (src != const0_rtx)
1391     {
1392       emit_insn (gen_insxh (insh, src, GEN_INT (size*8), addr));
1393
1394       switch (size)
1395         {
1396         case 2:
1397           emit_insn (gen_inswl (insl, gen_lowpart (HImode, src), addr));
1398           break;
1399         case 4:
1400           emit_insn (gen_insll (insl, gen_lowpart (SImode, src), addr));
1401           break;
1402         case 8:
1403           emit_insn (gen_insql (insl, src, addr));
1404           break;
1405         }
1406     }
1407
1408   emit_insn (gen_mskxh (dsth, dsth, GEN_INT (size*8), addr));
1409
1410   switch (size)
1411     {
1412     case 2:
1413       emit_insn (gen_mskxl (dstl, dstl, GEN_INT (0xffff), addr));
1414       break;
1415     case 4:
1416       emit_insn (gen_mskxl (dstl, dstl, GEN_INT (0xffffffff), addr));
1417       break;
1418     case 8:
1419       {
1420 #if HOST_BITS_PER_WIDE_INT == 32
1421         rtx msk = immed_double_const (0xffffffff, 0xffffffff, DImode);
1422 #else
1423         rtx msk = immed_double_const (0xffffffffffffffff, 0, DImode);
1424 #endif
1425         emit_insn (gen_mskxl (dstl, dstl, msk, addr));
1426       }
1427       break;
1428     }
1429
1430   if (src != const0_rtx)
1431     {
1432       expand_binop (DImode, ior_optab, insh, dsth, dsth, 0, OPTAB_WIDEN);
1433       expand_binop (DImode, ior_optab, insl, dstl, dstl, 0, OPTAB_WIDEN);
1434     }
1435
1436   /* Must store high before low for degenerate case of aligned.  */
1437   emit_move_insn (memh, dsth);
1438   emit_move_insn (meml, dstl);
1439 }
1440
1441 /* Load an integral number of consecutive unaligned quadwords.  */
1442
1443 #define MAX_MOVE_WORDS  4
1444
1445 static void
1446 alpha_expand_unaligned_load_words (data_regs, src_addr, words)
1447      rtx data_regs[MAX_MOVE_WORDS+1];
1448      rtx src_addr;
1449      HOST_WIDE_INT words;
1450 {
1451   rtx const im8 = GEN_INT (-8);
1452   rtx const i64 = GEN_INT (64);
1453   rtx ext_tmps[MAX_MOVE_WORDS];
1454   rtx src_reg, and_reg;
1455   HOST_WIDE_INT i;
1456
1457   /* Generate all the tmp registers we need.  */
1458   for (i = 0; i < words; ++i)
1459     ext_tmps[i] = gen_reg_rtx(DImode);
1460
1461   /* Load up all of the source data.  */
1462   for (i = 0; i < words; ++i)
1463     {
1464       emit_move_insn (data_regs[i],
1465                       change_address (src_addr, DImode,
1466                                       gen_rtx_AND (DImode,
1467                                                    plus_constant (XEXP(src_addr,0),
1468                                                                   8*i),
1469                                                    im8)));
1470     }
1471   emit_move_insn (data_regs[words],
1472                   change_address (src_addr, DImode,
1473                                   gen_rtx_AND (DImode,
1474                                                plus_constant (XEXP(src_addr,0),
1475                                                               8*words - 1),
1476                                                im8)));
1477
1478   /* Extract the half-word fragments.  Unfortunately DEC decided to make
1479      extxh with offset zero a noop instead of zeroing the register, so
1480      we must take care of that edge condition ourselves with cmov.  */
1481
1482   src_reg = copy_addr_to_reg (XEXP (src_addr, 0));
1483   and_reg = expand_binop (DImode, and_optab, src_reg, GEN_INT (7), NULL,
1484                           1, OPTAB_WIDEN);
1485   for (i = 0; i < words; ++i)
1486     {
1487       emit_insn (gen_extxl (data_regs[i], data_regs[i], i64, src_reg));
1488
1489       emit_insn (gen_extqh (ext_tmps[i], data_regs[i+1], src_reg));
1490       emit_insn (gen_rtx_SET (VOIDmode, ext_tmps[i],
1491                               gen_rtx_IF_THEN_ELSE (DImode,
1492                                                     gen_rtx_EQ (DImode, and_reg, const0_rtx),
1493                                                     const0_rtx, ext_tmps[i])));
1494     }
1495
1496   /* Merge the half-words into whole words.  */
1497   for (i = 0; i < words; ++i)
1498     {
1499       expand_binop (DImode, ior_optab, data_regs[i], ext_tmps[i],
1500                     data_regs[i], 1, OPTAB_WIDEN);
1501     }
1502 }
1503
1504 /* Store an integral number of consecutive unaligned quadwords.  DATA_REGS
1505    may be NULL to store zeros.  */
1506
1507 static void
1508 alpha_expand_unaligned_store_words (data_regs, dst_addr, words)
1509      rtx *data_regs;
1510      rtx dst_addr;
1511      HOST_WIDE_INT words;
1512 {
1513   rtx const im8 = GEN_INT (-8);
1514   rtx const i64 = GEN_INT (64);
1515 #if HOST_BITS_PER_WIDE_INT == 32
1516   rtx const im1 = immed_double_const (0xffffffff, 0xffffffff, DImode);
1517 #else
1518   rtx const im1 = immed_double_const (0xffffffffffffffff, 0, DImode);
1519 #endif
1520   rtx ins_tmps[MAX_MOVE_WORDS];
1521   rtx st_tmp_1, st_tmp_2, dst_reg;
1522   rtx st_addr_1, st_addr_2;
1523   HOST_WIDE_INT i;
1524
1525   /* Generate all the tmp registers we need.  */
1526   if (data_regs != NULL)
1527     for (i = 0; i < words; ++i)
1528       ins_tmps[i] = gen_reg_rtx(DImode);
1529   st_tmp_1 = gen_reg_rtx(DImode);
1530   st_tmp_2 = gen_reg_rtx(DImode);
1531
1532   st_addr_2 = change_address (dst_addr, DImode,
1533                               gen_rtx_AND (DImode,
1534                                            plus_constant (XEXP(dst_addr,0),
1535                                                           words*8 - 1),
1536                                        im8));
1537   st_addr_1 = change_address (dst_addr, DImode,
1538                               gen_rtx_AND (DImode,
1539                                            XEXP (dst_addr, 0),
1540                                            im8));
1541
1542   /* Load up the destination end bits.  */
1543   emit_move_insn (st_tmp_2, st_addr_2);
1544   emit_move_insn (st_tmp_1, st_addr_1);
1545
1546   /* Shift the input data into place.  */
1547   dst_reg = copy_addr_to_reg (XEXP (dst_addr, 0));
1548
1549   if (data_regs != NULL)
1550     {
1551       for (i = words-1; i >= 0; --i)
1552         {
1553           emit_insn (gen_insxh (ins_tmps[i], data_regs[i], i64, dst_reg));
1554           emit_insn (gen_insql (data_regs[i], data_regs[i], dst_reg));
1555         }
1556
1557       for (i = words-1; i > 0; --i)
1558         {
1559           expand_binop (DImode, ior_optab, data_regs[i], ins_tmps[i-1],
1560                         ins_tmps[i-1], 1, OPTAB_WIDEN);
1561         }
1562     }
1563
1564   /* Split and merge the ends with the destination data.  */
1565   emit_insn (gen_mskxh (st_tmp_2, st_tmp_2, i64, dst_reg));
1566   emit_insn (gen_mskxl (st_tmp_1, st_tmp_1, im1, dst_reg));
1567
1568   if (data_regs != NULL)
1569     {
1570       expand_binop (DImode, ior_optab, st_tmp_2, ins_tmps[words-1],
1571                     st_tmp_2, 1, OPTAB_WIDEN);
1572       expand_binop (DImode, ior_optab, st_tmp_1, data_regs[0],
1573                     st_tmp_1, 1, OPTAB_WIDEN);
1574     }
1575
1576   /* Store it all.  */
1577   emit_move_insn (st_addr_2, st_tmp_2);
1578   for (i = words-1; i > 0; --i)
1579     {
1580       emit_move_insn (change_address (dst_addr, DImode,
1581                                       gen_rtx_AND (DImode,
1582                                                    plus_constant(XEXP (dst_addr,0),
1583                                                                  i*8),
1584                                                im8)),
1585                       data_regs ? ins_tmps[i-1] : const0_rtx);
1586     }
1587   emit_move_insn (st_addr_1, st_tmp_1);
1588 }
1589
1590
1591 /* Expand string/block move operations.
1592
1593    operands[0] is the pointer to the destination.
1594    operands[1] is the pointer to the source.
1595    operands[2] is the number of bytes to move.
1596    operands[3] is the alignment.  */
1597
1598 int
1599 alpha_expand_block_move (operands)
1600      rtx operands[];
1601 {
1602   rtx bytes_rtx = operands[2];
1603   rtx align_rtx = operands[3];
1604   HOST_WIDE_INT bytes = INTVAL (bytes_rtx);
1605   HOST_WIDE_INT align = INTVAL (align_rtx);
1606   rtx orig_src  = operands[1];
1607   rtx orig_dst  = operands[0];
1608   rtx tmp = NULL_RTX;
1609   rtx data_regs[2*MAX_MOVE_WORDS];
1610   HOST_WIDE_INT i, words, ofs = 0;
1611
1612   if (bytes <= 0)
1613     return 1;
1614   if (bytes > MAX_MOVE_WORDS*8)
1615     return 0;
1616
1617   /* Ideally we would do nice things when noticing the addressof.  */
1618   if (GET_CODE (XEXP (orig_src, 0)) == ADDRESSOF)
1619     orig_src = copy_addr_to_reg (XEXP (orig_src, 0));
1620   if (GET_CODE (XEXP (orig_dst, 0)) == ADDRESSOF)
1621     orig_dst = copy_addr_to_reg (XEXP (orig_dst, 0));
1622
1623   /* Handle a block of contiguous words first.  */
1624
1625   if (align >= 8 && bytes >= 8)
1626     {
1627       words = bytes / 8;
1628
1629       /* Make some data registers. */
1630       for (i = 0; i < words; ++i)
1631         data_regs[i] = gen_reg_rtx(DImode);
1632
1633       /* Move in aligned hunks.  */
1634       for (i = 0; i < words; ++i)
1635         {
1636           emit_move_insn (data_regs[i],
1637                           change_address(orig_src, DImode,
1638                                          plus_constant (XEXP (orig_src, 0),
1639                                                         i*8)));
1640         }
1641       for (i = 0; i < words; ++i)
1642         {
1643           emit_move_insn (change_address(orig_dst, DImode,
1644                                          plus_constant (XEXP (orig_dst, 0),
1645                                                         i*8)),
1646                           data_regs[i]);
1647         }
1648
1649       bytes -= words * 8;
1650       ofs = words * 8;
1651     }
1652   if (align >= 4 && bytes >= 4)
1653     {
1654       words = bytes / 4;
1655
1656       /* Make some data registers. */
1657       for (i = 0; i < words; ++i)
1658         data_regs[i] = gen_reg_rtx(SImode);
1659
1660       /* Move in aligned hunks.  */
1661       for (i = 0; i < words; ++i)
1662         {
1663           emit_move_insn (data_regs[i],
1664                           change_address(orig_src, SImode,
1665                                          plus_constant (XEXP (orig_src, 0),
1666                                                         i*4)));
1667         }
1668       for (i = 0; i < words; ++i)
1669         {
1670           emit_move_insn (change_address(orig_dst, SImode,
1671                                          plus_constant (XEXP (orig_dst, 0),
1672                                                         i*4)),
1673                           data_regs[i]);
1674         }
1675
1676       bytes -= words * 4;
1677       ofs = words * 4;
1678     }
1679   if (bytes >= 16)
1680     {
1681       words = bytes / 8;
1682
1683       /* Make some data registers. */
1684       for (i = 0; i < words+1; ++i)
1685         data_regs[i] = gen_reg_rtx(DImode);
1686
1687       /* Move in unaligned hunks.  */
1688       alpha_expand_unaligned_load_words (data_regs, orig_src, words);
1689       alpha_expand_unaligned_store_words (data_regs, orig_dst, words);
1690
1691       bytes -= words * 8;
1692       ofs = words * 8;
1693     }
1694
1695   /* Next clean up any trailing pieces.  We know from the contiguous
1696      block move that there are no aligned SImode or DImode hunks left.  */
1697
1698   if (!TARGET_BWX && bytes >= 8)
1699     {
1700       tmp = gen_reg_rtx (DImode);
1701       alpha_expand_unaligned_load (tmp, orig_src, 8, ofs, 0);
1702       alpha_expand_unaligned_store (orig_dst, tmp, 8, ofs);
1703
1704       bytes -= 8;
1705       ofs += 8;
1706     }
1707   if (!TARGET_BWX && bytes >= 4)
1708     {
1709       tmp = gen_reg_rtx (DImode);
1710       alpha_expand_unaligned_load (tmp, orig_src, 4, ofs, 0);
1711       alpha_expand_unaligned_store (orig_dst, tmp, 4, ofs);
1712
1713       bytes -= 4;
1714       ofs += 4;
1715     }
1716   if (bytes >= 2)
1717     {
1718       if (align >= 2)
1719         {
1720           do {
1721             emit_move_insn (change_address (orig_dst, HImode,
1722                                             plus_constant (XEXP (orig_dst, 0),
1723                                                            ofs)),
1724                             change_address (orig_src, HImode,
1725                                             plus_constant (XEXP (orig_src, 0),
1726                                                            ofs)));
1727             bytes -= 2;
1728             ofs += 2;
1729           } while (bytes >= 2);
1730         }
1731       else if (!TARGET_BWX)
1732         {
1733           tmp = gen_reg_rtx (DImode);
1734           alpha_expand_unaligned_load (tmp, orig_src, 2, ofs, 0);
1735           alpha_expand_unaligned_store (orig_dst, tmp, 2, ofs);
1736           bytes -= 2;
1737           ofs += 2;
1738         }
1739     }
1740   while (bytes > 0)
1741     {
1742       emit_move_insn (change_address (orig_dst, QImode,
1743                                       plus_constant (XEXP (orig_dst, 0),
1744                                                      ofs)),
1745                       change_address (orig_src, QImode,
1746                                       plus_constant (XEXP (orig_src, 0),
1747                                                      ofs)));
1748       bytes -= 1;
1749       ofs += 1;
1750     }
1751
1752   return 1;
1753 }
1754
1755 int
1756 alpha_expand_block_clear (operands)
1757      rtx operands[];
1758 {
1759   rtx bytes_rtx = operands[1];
1760   rtx align_rtx = operands[2];
1761   HOST_WIDE_INT bytes = INTVAL (bytes_rtx);
1762   HOST_WIDE_INT align = INTVAL (align_rtx);
1763   rtx orig_dst  = operands[0];
1764   HOST_WIDE_INT i, words, ofs = 0;
1765
1766   if (bytes <= 0)
1767     return 1;
1768   if (bytes > MAX_MOVE_WORDS*8)
1769     return 0;
1770
1771   /* Handle a block of contiguous words first.  */
1772
1773   if (align >= 8 && bytes >= 8)
1774     {
1775       words = bytes / 8;
1776
1777       for (i = 0; i < words; ++i)
1778         {
1779           emit_move_insn (change_address(orig_dst, DImode,
1780                                          plus_constant (XEXP (orig_dst, 0),
1781                                                         i*8)),
1782                           const0_rtx);
1783         }
1784
1785       bytes -= words * 8;
1786       ofs = words * 8;
1787     }
1788   else if (align >= 4 && bytes >= 4)
1789     {
1790       words = bytes / 4;
1791
1792       for (i = 0; i < words; ++i)
1793         {
1794           emit_move_insn (change_address(orig_dst, SImode,
1795                                          plus_constant (XEXP (orig_dst, 0),
1796                                                         i*4)),
1797                           const0_rtx);
1798         }
1799
1800       bytes -= words * 4;
1801       ofs = words * 4;
1802     }
1803   else if (bytes >= 16)
1804     {
1805       words = bytes / 8;
1806
1807       alpha_expand_unaligned_store_words (NULL, orig_dst, words);
1808
1809       bytes -= words * 8;
1810       ofs = words * 8;
1811     }
1812
1813   /* Next clean up any trailing pieces.  We know from the contiguous
1814      block move that there are no aligned SImode or DImode hunks left.  */
1815
1816   if (!TARGET_BWX && bytes >= 8)
1817     {
1818       alpha_expand_unaligned_store (orig_dst, const0_rtx, 8, ofs);
1819       bytes -= 8;
1820       ofs += 8;
1821     }
1822   if (!TARGET_BWX && bytes >= 4)
1823     {
1824       alpha_expand_unaligned_store (orig_dst, const0_rtx, 4, ofs);
1825       bytes -= 4;
1826       ofs += 4;
1827     }
1828   if (bytes >= 2)
1829     {
1830       if (align >= 2)
1831         {
1832           do {
1833             emit_move_insn (change_address (orig_dst, HImode,
1834                                             plus_constant (XEXP (orig_dst, 0),
1835                                                            ofs)),
1836                             const0_rtx);
1837             bytes -= 2;
1838             ofs += 2;
1839           } while (bytes >= 2);
1840         }
1841       else if (!TARGET_BWX)
1842         {
1843           alpha_expand_unaligned_store (orig_dst, const0_rtx, 2, ofs);
1844           bytes -= 2;
1845           ofs += 2;
1846         }
1847     }
1848   while (bytes > 0)
1849     {
1850       emit_move_insn (change_address (orig_dst, QImode,
1851                                       plus_constant (XEXP (orig_dst, 0),
1852                                                      ofs)),
1853                       const0_rtx);
1854       bytes -= 1;
1855       ofs += 1;
1856     }
1857
1858   return 1;
1859 }
1860
1861 \f
1862 /* Adjust the cost of a scheduling dependency.  Return the new cost of
1863    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
1864
1865 int
1866 alpha_adjust_cost (insn, link, dep_insn, cost)
1867      rtx insn;
1868      rtx link;
1869      rtx dep_insn;
1870      int cost;
1871 {
1872   rtx set, set_src;
1873   enum attr_type insn_type, dep_insn_type;
1874
1875   /* If the dependence is an anti-dependence, there is no cost.  For an
1876      output dependence, there is sometimes a cost, but it doesn't seem
1877      worth handling those few cases.  */
1878
1879   if (REG_NOTE_KIND (link) != 0)
1880     return 0;
1881
1882   /* If we can't recognize the insns, we can't really do anything.  */
1883   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
1884     return cost;
1885
1886   insn_type = get_attr_type (insn);
1887   dep_insn_type = get_attr_type (dep_insn);
1888
1889   /* Bring in the user-defined memory latency.  */
1890   if (dep_insn_type == TYPE_ILD
1891       || dep_insn_type == TYPE_FLD
1892       || dep_insn_type == TYPE_LDSYM)
1893     cost += alpha_memory_latency-1;
1894
1895   switch (alpha_cpu)
1896     {
1897     case PROCESSOR_EV4:
1898       /* On EV4, if INSN is a store insn and DEP_INSN is setting the data
1899          being stored, we can sometimes lower the cost.  */
1900
1901       if ((insn_type == TYPE_IST || insn_type == TYPE_FST)
1902           && (set = single_set (dep_insn)) != 0
1903           && GET_CODE (PATTERN (insn)) == SET
1904           && rtx_equal_p (SET_DEST (set), SET_SRC (PATTERN (insn))))
1905         {
1906           switch (dep_insn_type)
1907             {
1908             case TYPE_ILD:
1909             case TYPE_FLD:
1910               /* No savings here.  */
1911               return cost;
1912
1913             case TYPE_IMUL:
1914               /* In these cases, we save one cycle.  */
1915               return cost - 1;
1916
1917             default:
1918               /* In all other cases, we save two cycles.  */
1919               return MAX (0, cost - 2);
1920             }
1921         }
1922
1923       /* Another case that needs adjustment is an arithmetic or logical
1924          operation.  It's cost is usually one cycle, but we default it to
1925          two in the MD file.  The only case that it is actually two is
1926          for the address in loads, stores, and jumps.  */
1927
1928       if (dep_insn_type == TYPE_IADD || dep_insn_type == TYPE_ILOG)
1929         {
1930           switch (insn_type)
1931             {
1932             case TYPE_ILD:
1933             case TYPE_IST:
1934             case TYPE_FLD:
1935             case TYPE_FST:
1936             case TYPE_JSR:
1937               return cost;
1938             default:
1939               return 1;
1940             }
1941         }
1942
1943       /* The final case is when a compare feeds into an integer branch;
1944          the cost is only one cycle in that case.  */
1945
1946       if (dep_insn_type == TYPE_ICMP && insn_type == TYPE_IBR)
1947         return 1;
1948       break;
1949
1950     case PROCESSOR_EV5:
1951       /* And the lord DEC saith:  "A special bypass provides an effective
1952          latency of 0 cycles for an ICMP or ILOG insn producing the test
1953          operand of an IBR or ICMOV insn." */
1954
1955       if ((dep_insn_type == TYPE_ICMP || dep_insn_type == TYPE_ILOG)
1956           && (set = single_set (dep_insn)) != 0)
1957         {
1958           /* A branch only has one input.  This must be it.  */
1959           if (insn_type == TYPE_IBR)
1960             return 0;
1961           /* A conditional move has three, make sure it is the test.  */
1962           if (insn_type == TYPE_ICMOV
1963               && GET_CODE (set_src = PATTERN (insn)) == SET
1964               && GET_CODE (set_src = SET_SRC (set_src)) == IF_THEN_ELSE
1965               && rtx_equal_p (SET_DEST (set), XEXP (set_src, 0)))
1966             return 0;
1967         }
1968
1969       /* "The multiplier is unable to receive data from IEU bypass paths.
1970          The instruction issues at the expected time, but its latency is
1971          increased by the time it takes for the input data to become
1972          available to the multiplier" -- which happens in pipeline stage
1973          six, when results are comitted to the register file.  */
1974
1975       if (insn_type == TYPE_IMUL)
1976         {
1977           switch (dep_insn_type)
1978             {
1979             /* These insns produce their results in pipeline stage five.  */
1980             case TYPE_ILD:
1981             case TYPE_ICMOV:
1982             case TYPE_IMUL:
1983             case TYPE_MVI:
1984               return cost + 1;
1985
1986             /* Other integer insns produce results in pipeline stage four.  */
1987             default:
1988               return cost + 2;
1989             }
1990         }
1991       break;
1992
1993     case PROCESSOR_EV6:
1994       /* There is additional latency to move the result of (most) FP
1995          operations anywhere but the FP register file.  */
1996
1997       if ((insn_type == TYPE_FST || insn_type == TYPE_FTOI)
1998           && (dep_insn_type == TYPE_FADD ||
1999               dep_insn_type == TYPE_FMUL ||
2000               dep_insn_type == TYPE_FCMOV))
2001         return cost + 2;
2002
2003       break;
2004     }
2005
2006   /* Otherwise, return the default cost. */
2007   return cost;
2008 }
2009 \f
2010 /* Functions to save and restore alpha_return_addr_rtx.  */
2011
2012 struct machine_function
2013 {
2014   rtx ra_rtx;
2015 };
2016
2017 static void
2018 alpha_save_machine_status (p)
2019      struct function *p;
2020 {
2021   struct machine_function *machine =
2022     (struct machine_function *) xmalloc (sizeof (struct machine_function));
2023
2024   p->machine = machine;
2025   machine->ra_rtx = alpha_return_addr_rtx;
2026 }
2027
2028 static void
2029 alpha_restore_machine_status (p)
2030      struct function *p;
2031 {
2032   struct machine_function *machine = p->machine;
2033
2034   alpha_return_addr_rtx = machine->ra_rtx;
2035
2036   free (machine);
2037   p->machine = (struct machine_function *)0;
2038 }
2039
2040 /* Do anything needed before RTL is emitted for each function.  */
2041
2042 void
2043 alpha_init_expanders ()
2044 {
2045   alpha_return_addr_rtx = NULL_RTX;
2046
2047   /* Arrange to save and restore machine status around nested functions.  */
2048   save_machine_status = alpha_save_machine_status;
2049   restore_machine_status = alpha_restore_machine_status;
2050 }
2051
2052 /* Start the ball rolling with RETURN_ADDR_RTX.  */
2053
2054 rtx
2055 alpha_return_addr (count, frame)
2056      int count;
2057      rtx frame;
2058 {
2059   rtx init, first;
2060
2061   if (count != 0)
2062     return const0_rtx;
2063
2064   if (alpha_return_addr_rtx)
2065     return alpha_return_addr_rtx;
2066
2067   /* No rtx yet.  Invent one, and initialize it from $26 in the prologue.  */
2068   alpha_return_addr_rtx = gen_reg_rtx (Pmode);
2069   init = gen_rtx_SET (Pmode, alpha_return_addr_rtx,
2070                       gen_rtx_REG (Pmode, REG_RA));
2071
2072   /* Emit the insn to the prologue with the other argument copies.  */
2073   push_topmost_sequence ();
2074   emit_insn_after (init, get_insns ());
2075   pop_topmost_sequence ();
2076
2077   return alpha_return_addr_rtx;
2078 }
2079
2080 static int
2081 alpha_ra_ever_killed ()
2082 {
2083   rtx i, ra;
2084
2085   if (!alpha_return_addr_rtx)
2086     return regs_ever_live[REG_RA];
2087
2088   return reg_set_between_p (gen_rtx_REG (Pmode, REG_RA),
2089                             get_insns(), NULL_RTX);
2090 }
2091
2092 \f
2093 /* Print an operand.  Recognize special options, documented below.  */
2094
2095 void
2096 print_operand (file, x, code)
2097     FILE *file;
2098     rtx x;
2099     char code;
2100 {
2101   int i;
2102
2103   switch (code)
2104     {
2105     case '&':
2106       /* Generates fp-rounding mode suffix: nothing for normal, 'c' for
2107          chopped, 'm' for minus-infinity, and 'd' for dynamic rounding
2108          mode.  alpha_fprm controls which suffix is generated.  */
2109       switch (alpha_fprm)
2110         {
2111         case ALPHA_FPRM_NORM:
2112           break;
2113         case ALPHA_FPRM_MINF:
2114           fputc ('m', file);
2115           break;
2116         case ALPHA_FPRM_CHOP:
2117           fputc ('c', file);
2118           break;
2119         case ALPHA_FPRM_DYN:
2120           fputc ('d', file);
2121           break;
2122         }
2123       break;
2124
2125     case '\'':
2126       /* Generates trap-mode suffix for instructions that accept the su
2127          suffix only (cmpt et al).  */
2128       if (alpha_tp == ALPHA_TP_INSN)
2129         fputs ("su", file);
2130       break;
2131
2132     case ')':
2133       /* Generates trap-mode suffix for instructions that accept the u, su,
2134          and sui suffix.  This is the bulk of the IEEE floating point
2135          instructions (addt et al).  */
2136       switch (alpha_fptm)
2137         {
2138         case ALPHA_FPTM_N:
2139           break;
2140         case ALPHA_FPTM_U:
2141           fputc ('u', file);
2142           break;
2143         case ALPHA_FPTM_SU:
2144           fputs ("su", file);
2145           break;
2146         case ALPHA_FPTM_SUI:
2147           fputs ("sui", file);
2148           break;
2149         }
2150       break;
2151
2152     case '+':
2153       /* Generates trap-mode suffix for instructions that accept the sui
2154          suffix (cvtqt and cvtqs).  */
2155       switch (alpha_fptm)
2156         {
2157         case ALPHA_FPTM_N: case ALPHA_FPTM_U:
2158         case ALPHA_FPTM_SU:     /* cvtqt/cvtqs can't cause underflow */
2159           break;
2160         case ALPHA_FPTM_SUI:
2161           fputs ("sui", file);
2162           break;
2163         }
2164       break;
2165
2166     case ',':
2167       /* Generates single precision instruction suffix.  */
2168       fprintf (file, "%c", (TARGET_FLOAT_VAX ? 'f' : 's'));
2169       break;
2170
2171     case '-':
2172       /* Generates double precision instruction suffix.  */
2173       fprintf (file, "%c", (TARGET_FLOAT_VAX ? 'g' : 't'));
2174       break;
2175
2176     case 'r':
2177       /* If this operand is the constant zero, write it as "$31".  */
2178       if (GET_CODE (x) == REG)
2179         fprintf (file, "%s", reg_names[REGNO (x)]);
2180       else if (x == CONST0_RTX (GET_MODE (x)))
2181         fprintf (file, "$31");
2182       else
2183         output_operand_lossage ("invalid %%r value");
2184
2185       break;
2186
2187     case 'R':
2188       /* Similar, but for floating-point.  */
2189       if (GET_CODE (x) == REG)
2190         fprintf (file, "%s", reg_names[REGNO (x)]);
2191       else if (x == CONST0_RTX (GET_MODE (x)))
2192         fprintf (file, "$f31");
2193       else
2194         output_operand_lossage ("invalid %%R value");
2195
2196       break;
2197
2198     case 'N':
2199       /* Write the 1's complement of a constant.  */
2200       if (GET_CODE (x) != CONST_INT)
2201         output_operand_lossage ("invalid %%N value");
2202
2203       fprintf (file, HOST_WIDE_INT_PRINT_DEC, ~ INTVAL (x));
2204       break;
2205
2206     case 'P':
2207       /* Write 1 << C, for a constant C.  */
2208       if (GET_CODE (x) != CONST_INT)
2209         output_operand_lossage ("invalid %%P value");
2210
2211       fprintf (file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) 1 << INTVAL (x));
2212       break;
2213
2214     case 'h':
2215       /* Write the high-order 16 bits of a constant, sign-extended.  */
2216       if (GET_CODE (x) != CONST_INT)
2217         output_operand_lossage ("invalid %%h value");
2218
2219       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) >> 16);
2220       break;
2221
2222     case 'L':
2223       /* Write the low-order 16 bits of a constant, sign-extended.  */
2224       if (GET_CODE (x) != CONST_INT)
2225         output_operand_lossage ("invalid %%L value");
2226
2227       fprintf (file, HOST_WIDE_INT_PRINT_DEC,
2228                (INTVAL (x) & 0xffff) - 2 * (INTVAL (x) & 0x8000));
2229       break;
2230
2231     case 'm':
2232       /* Write mask for ZAP insn.  */
2233       if (GET_CODE (x) == CONST_DOUBLE)
2234         {
2235           HOST_WIDE_INT mask = 0;
2236           HOST_WIDE_INT value;
2237
2238           value = CONST_DOUBLE_LOW (x);
2239           for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2240                i++, value >>= 8)
2241             if (value & 0xff)
2242               mask |= (1 << i);
2243
2244           value = CONST_DOUBLE_HIGH (x);
2245           for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2246                i++, value >>= 8)
2247             if (value & 0xff)
2248               mask |= (1 << (i + sizeof (int)));
2249
2250           fprintf (file, HOST_WIDE_INT_PRINT_DEC, mask & 0xff);
2251         }
2252
2253       else if (GET_CODE (x) == CONST_INT)
2254         {
2255           HOST_WIDE_INT mask = 0, value = INTVAL (x);
2256
2257           for (i = 0; i < 8; i++, value >>= 8)
2258             if (value & 0xff)
2259               mask |= (1 << i);
2260
2261           fprintf (file, HOST_WIDE_INT_PRINT_DEC, mask);
2262         }
2263       else
2264         output_operand_lossage ("invalid %%m value");
2265       break;
2266
2267     case 'M':
2268       /* 'b', 'w', 'l', or 'q' as the value of the constant.  */
2269       if (GET_CODE (x) != CONST_INT
2270           || (INTVAL (x) != 8 && INTVAL (x) != 16
2271               && INTVAL (x) != 32 && INTVAL (x) != 64))
2272         output_operand_lossage ("invalid %%M value");
2273
2274       fprintf (file, "%s",
2275                (INTVAL (x) == 8 ? "b"
2276                 : INTVAL (x) == 16 ? "w"
2277                 : INTVAL (x) == 32 ? "l"
2278                 : "q"));
2279       break;
2280
2281     case 'U':
2282       /* Similar, except do it from the mask.  */
2283       if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0xff)
2284         fprintf (file, "b");
2285       else if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0xffff)
2286         fprintf (file, "w");
2287       else if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0xffffffff)
2288         fprintf (file, "l");
2289 #if HOST_BITS_PER_WIDE_INT == 32
2290       else if (GET_CODE (x) == CONST_DOUBLE
2291                && CONST_DOUBLE_HIGH (x) == 0
2292                && CONST_DOUBLE_LOW (x) == -1)
2293         fprintf (file, "l");
2294       else if (GET_CODE (x) == CONST_DOUBLE
2295                && CONST_DOUBLE_HIGH (x) == -1
2296                && CONST_DOUBLE_LOW (x) == -1)
2297         fprintf (file, "q");
2298 #else
2299       else if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0xffffffffffffffff)
2300         fprintf (file, "q");
2301       else if (GET_CODE (x) == CONST_DOUBLE
2302                && CONST_DOUBLE_HIGH (x) == 0
2303                && CONST_DOUBLE_LOW (x) == -1)
2304         fprintf (file, "q");
2305 #endif
2306       else
2307         output_operand_lossage ("invalid %%U value");
2308       break;
2309
2310     case 's':
2311       /* Write the constant value divided by 8.  */
2312       if (GET_CODE (x) != CONST_INT
2313           && (unsigned HOST_WIDE_INT) INTVAL (x) >= 64
2314           && (INTVAL (x) & 7) != 8)
2315         output_operand_lossage ("invalid %%s value");
2316
2317       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) / 8);
2318       break;
2319
2320     case 'S':
2321       /* Same, except compute (64 - c) / 8 */
2322
2323       if (GET_CODE (x) != CONST_INT
2324           && (unsigned HOST_WIDE_INT) INTVAL (x) >= 64
2325           && (INTVAL (x) & 7) != 8)
2326         output_operand_lossage ("invalid %%s value");
2327
2328       fprintf (file, HOST_WIDE_INT_PRINT_DEC, (64 - INTVAL (x)) / 8);
2329       break;
2330
2331     case 'C': case 'D': case 'c': case 'd':
2332       /* Write out comparison name.  */
2333       {
2334         enum rtx_code c = GET_CODE (x);
2335
2336         if (GET_RTX_CLASS (c) != '<')
2337           output_operand_lossage ("invalid %%C value");
2338
2339         if (code == 'D')
2340           c = reverse_condition (c);
2341         else if (code == 'c')
2342           c = swap_condition (c);
2343         else if (code == 'd')
2344           c = swap_condition (reverse_condition (c));
2345
2346         if (c == LEU)
2347           fprintf (file, "ule");
2348         else if (c == LTU)
2349           fprintf (file, "ult");
2350         else
2351           fprintf (file, "%s", GET_RTX_NAME (c));
2352       }
2353       break;
2354
2355     case 'E':
2356       /* Write the divide or modulus operator.  */
2357       switch (GET_CODE (x))
2358         {
2359         case DIV:
2360           fprintf (file, "div%s", GET_MODE (x) == SImode ? "l" : "q");
2361           break;
2362         case UDIV:
2363           fprintf (file, "div%su", GET_MODE (x) == SImode ? "l" : "q");
2364           break;
2365         case MOD:
2366           fprintf (file, "rem%s", GET_MODE (x) == SImode ? "l" : "q");
2367           break;
2368         case UMOD:
2369           fprintf (file, "rem%su", GET_MODE (x) == SImode ? "l" : "q");
2370           break;
2371         default:
2372           output_operand_lossage ("invalid %%E value");
2373           break;
2374         }
2375       break;
2376
2377     case 'A':
2378       /* Write "_u" for unaligned access.  */
2379       if (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == AND)
2380         fprintf (file, "_u");
2381       break;
2382
2383     case 0:
2384       if (GET_CODE (x) == REG)
2385         fprintf (file, "%s", reg_names[REGNO (x)]);
2386       else if (GET_CODE (x) == MEM)
2387         output_address (XEXP (x, 0));
2388       else
2389         output_addr_const (file, x);
2390       break;
2391
2392     default:
2393       output_operand_lossage ("invalid %%xn code");
2394     }
2395 }
2396 \f
2397 /* Do what is necessary for `va_start'.  The argument is ignored;
2398    We look at the current function to determine if stdarg or varargs
2399    is used and fill in an initial va_list.  A pointer to this constructor
2400    is returned.  */
2401
2402 struct rtx_def *
2403 alpha_builtin_saveregs (arglist)
2404      tree arglist;
2405 {
2406   rtx block, addr, dest, argsize;
2407   tree fntype = TREE_TYPE (current_function_decl);
2408   int stdarg = (TYPE_ARG_TYPES (fntype) != 0
2409                 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
2410                     != void_type_node));
2411
2412   /* Compute the current position into the args, taking into account
2413      both registers and memory.  Both of these are already included in
2414      NUM_ARGS.  */
2415
2416   argsize = GEN_INT (NUM_ARGS * UNITS_PER_WORD);
2417
2418   /* For Unix, SETUP_INCOMING_VARARGS moves the starting address base up by 48,
2419      storing fp arg registers in the first 48 bytes, and the integer arg
2420      registers in the next 48 bytes.  This is only done, however, if any
2421      integer registers need to be stored.
2422
2423      If no integer registers need be stored, then we must subtract 48 in
2424      order to account for the integer arg registers which are counted in
2425      argsize above, but which are not actually stored on the stack.  */
2426
2427   if (TARGET_OPEN_VMS)
2428     addr = plus_constant (virtual_incoming_args_rtx,
2429                           NUM_ARGS <= 5 + stdarg
2430                           ? UNITS_PER_WORD : - 6 * UNITS_PER_WORD);
2431   else
2432     addr = (NUM_ARGS <= 5 + stdarg
2433             ? plus_constant (virtual_incoming_args_rtx,
2434                              6 * UNITS_PER_WORD)
2435             : plus_constant (virtual_incoming_args_rtx,
2436                              - (6 * UNITS_PER_WORD)));
2437
2438   /* For VMS, we include the argsize, while on Unix, it's handled as
2439      a separate field.  */
2440   if (TARGET_OPEN_VMS)
2441     addr = plus_constant (addr, INTVAL (argsize));
2442
2443   addr = force_operand (addr, NULL_RTX);
2444
2445 #ifdef POINTERS_EXTEND_UNSIGNED
2446   addr = convert_memory_address (ptr_mode, addr);
2447 #endif
2448
2449   if (TARGET_OPEN_VMS)
2450     return addr;
2451   else
2452     {
2453       /* Allocate the va_list constructor */
2454       block = assign_stack_local (BLKmode, 2 * UNITS_PER_WORD, BITS_PER_WORD);
2455       RTX_UNCHANGING_P (block) = 1;
2456       RTX_UNCHANGING_P (XEXP (block, 0)) = 1;
2457
2458       /* Store the address of the first integer register in the __base
2459          member.  */
2460
2461       dest = change_address (block, ptr_mode, XEXP (block, 0));
2462       emit_move_insn (dest, addr);
2463
2464       if (flag_check_memory_usage)
2465         emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
2466                            dest, ptr_mode,
2467                            GEN_INT (GET_MODE_SIZE (ptr_mode)),
2468                            TYPE_MODE (sizetype),
2469                            GEN_INT (MEMORY_USE_RW),
2470                            TYPE_MODE (integer_type_node));
2471
2472       /* Store the argsize as the __va_offset member.  */
2473       dest = change_address (block, TYPE_MODE (integer_type_node),
2474                              plus_constant (XEXP (block, 0),
2475                                             POINTER_SIZE/BITS_PER_UNIT));
2476       emit_move_insn (dest, argsize);
2477
2478       if (flag_check_memory_usage)
2479         emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
2480                            dest, ptr_mode,
2481                            GEN_INT (GET_MODE_SIZE
2482                                     (TYPE_MODE (integer_type_node))),
2483                            TYPE_MODE (sizetype),
2484                            GEN_INT (MEMORY_USE_RW),
2485                            TYPE_MODE (integer_type_node));
2486
2487       /* Return the address of the va_list constructor, but don't put it in a
2488          register.  Doing so would fail when not optimizing and produce worse
2489          code when optimizing.  */
2490       return XEXP (block, 0);
2491     }
2492 }
2493 \f
2494 /* This page contains routines that are used to determine what the function
2495    prologue and epilogue code will do and write them out.  */
2496
2497 /* Compute the size of the save area in the stack.  */
2498
2499 #if OPEN_VMS
2500
2501 /* These variables are used for communication between the following functions.
2502    They indicate various things about the current function being compiled
2503    that are used to tell what kind of prologue, epilogue and procedure
2504    descriptior to generate. */
2505
2506 /* Nonzero if we need a stack procedure.  */
2507 static int is_stack_procedure;
2508
2509 /* Register number (either FP or SP) that is used to unwind the frame.  */
2510 static int unwind_regno;
2511
2512 /* Register number used to save FP.  We need not have one for RA since
2513    we don't modify it for register procedures.  This is only defined
2514    for register frame procedures.  */
2515 static int save_fp_regno;
2516
2517 /* Register number used to reference objects off our PV.  */
2518 static int base_regno;
2519
2520 /*  Compute register masks for saved registers.  */
2521
2522 static void
2523 alpha_sa_mask (imaskP, fmaskP)
2524     unsigned long *imaskP;
2525     unsigned long *fmaskP;
2526 {
2527   unsigned long imask = 0;
2528   unsigned long fmask = 0;
2529   int i;
2530
2531   if (is_stack_procedure)
2532     imask |= (1L << HARD_FRAME_POINTER_REGNUM);
2533
2534   /* One for every register we have to save.  */
2535
2536   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2537     if (! fixed_regs[i] && ! call_used_regs[i]
2538         && regs_ever_live[i] && i != REG_RA)
2539       {
2540         if (i < 32)
2541           imask |= (1L << i);
2542         else
2543           fmask |= (1L << (i - 32));
2544       }
2545
2546   *imaskP = imask;
2547   *fmaskP = fmask;
2548
2549   return;
2550 }
2551
2552 int
2553 alpha_sa_size ()
2554 {
2555   int sa_size = 0;
2556   HOST_WIDE_INT stack_needed;
2557   int i;
2558
2559   /* One for every register we have to save.  */
2560
2561   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2562     if (! fixed_regs[i] && ! call_used_regs[i]
2563         && regs_ever_live[i] && i != REG_RA)
2564       sa_size++;
2565
2566   /* Start by assuming we can use a register procedure if we don't make any
2567      calls (REG_RA not used) or need to save any registers and a stack
2568      procedure if we do.  */
2569   is_stack_procedure = sa_size != 0 || alpha_ra_ever_killed ();
2570
2571   /* Decide whether to refer to objects off our PV via FP or PV.
2572      If we need need FP for something else or if we receive a nonlocal
2573      goto (which expects PV to contain the value), we must use PV.
2574      Otherwise, start by assuming we can use FP.  */
2575   base_regno = (frame_pointer_needed || current_function_has_nonlocal_label
2576                 || is_stack_procedure
2577                 || current_function_outgoing_args_size
2578                 ? REG_PV : HARD_FRAME_POINTER_REGNUM);
2579
2580   /* If we want to copy PV into FP, we need to find some register in which to
2581      save FP.  */
2582
2583   save_fp_regno = -1;
2584
2585   if (base_regno == HARD_FRAME_POINTER_REGNUM)
2586     for (i = 0; i < 32; i++)
2587       if (! fixed_regs[i] && call_used_regs[i] && ! regs_ever_live[i])
2588         save_fp_regno = i;
2589
2590   if (save_fp_regno == -1)
2591     base_regno = REG_PV, is_stack_procedure = 1;
2592
2593   /* Stack unwinding should be done via FP unless we use it for PV.  */
2594   unwind_regno
2595     = base_regno == REG_PV ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM;
2596
2597   /* If this is a stack procedure, allow space for saving FP and RA.  */
2598   if (is_stack_procedure)
2599     sa_size += 2;
2600
2601   return sa_size * 8;
2602 }
2603
2604 int
2605 alpha_pv_save_size ()
2606 {
2607   alpha_sa_size ();
2608   return is_stack_procedure ? 8 : 0;
2609 }
2610
2611 int
2612 alpha_using_fp ()
2613 {
2614   alpha_sa_size ();
2615   return unwind_regno == HARD_FRAME_POINTER_REGNUM;
2616 }
2617
2618 #else /* ! OPEN_VMS */
2619
2620 int
2621 alpha_sa_size ()
2622 {
2623   int size = 0;
2624   int i;
2625
2626   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2627     if (! fixed_regs[i] && ! call_used_regs[i]
2628         && regs_ever_live[i] && i != REG_RA)
2629       size++;
2630
2631   /* If some registers were saved but not reg 26, reg 26 must also
2632      be saved, so leave space for it.  */
2633   if (size != 0 || alpha_ra_ever_killed ())
2634     size++;
2635
2636   /* Our size must be even (multiple of 16 bytes).  */
2637   if (size & 1)
2638     size ++;
2639
2640   return size * 8;
2641 }
2642
2643 #endif /* ! OPEN_VMS */
2644
2645 /* Return 1 if this function can directly return via $26.  */
2646
2647 int
2648 direct_return ()
2649 {
2650   return (! TARGET_OPEN_VMS && reload_completed && alpha_sa_size () == 0
2651           && get_frame_size () == 0
2652           && current_function_outgoing_args_size == 0
2653           && current_function_pretend_args_size == 0);
2654 }
2655
2656 /* Write a version stamp.  Don't write anything if we are running as a
2657    cross-compiler.  Otherwise, use the versions in /usr/include/stamp.h.  */
2658
2659 #if !defined(CROSS_COMPILE) && !defined(_WIN32) && !defined(__linux__) && !defined(VMS)
2660 #include <stamp.h>
2661 #endif
2662
2663 void
2664 alpha_write_verstamp (file)
2665      FILE *file;
2666 {
2667 #ifdef MS_STAMP
2668   fprintf (file, "\t.verstamp %d %d\n", MS_STAMP, LS_STAMP);
2669 #endif
2670 }
2671 \f
2672 /* Write code to add constant C to register number IN_REG (possibly 31)
2673    and put the result into OUT_REG.  Use TEMP_REG as a scratch register;
2674    usually this will be OUT_REG, but should not be if OUT_REG is
2675    STACK_POINTER_REGNUM, since it must be updated in a single instruction.
2676    Write the code to FILE.  */
2677
2678 static void
2679 add_long_const (file, c, in_reg, out_reg, temp_reg)
2680      FILE *file;
2681      HOST_WIDE_INT c;
2682      int in_reg, out_reg, temp_reg;
2683 {
2684   HOST_WIDE_INT low = (c & 0xffff) - 2 * (c & 0x8000);
2685   HOST_WIDE_INT tmp1 = c - low;
2686   HOST_WIDE_INT high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
2687   HOST_WIDE_INT extra = 0;
2688
2689   /* We don't have code to write out constants larger than 32 bits.  */
2690 #if HOST_BITS_PER_LONG_INT == 64
2691   if ((unsigned HOST_WIDE_INT) c >> 32 != 0)
2692     abort ();
2693 #endif
2694
2695   /* If HIGH will be interpreted as negative, we must adjust it to do two
2696      ldha insns.  Note that we will never be building a negative constant
2697      here.  */
2698
2699   if (high & 0x8000)
2700     {
2701       extra = 0x4000;
2702       tmp1 -= 0x40000000;
2703       high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
2704     }
2705
2706   if (low != 0)
2707     {
2708       int result_reg = (extra == 0 && high == 0) ? out_reg : temp_reg;
2709
2710       if (low >= 0 && low < 255)
2711         fprintf (file, "\taddq $%d,%d,$%d\n", in_reg, low, result_reg);
2712       else
2713         fprintf (file, "\tlda $%d,%d($%d)\n", result_reg, low, in_reg);
2714
2715       in_reg = result_reg;
2716     }
2717
2718   if (extra)
2719     {
2720       int result_reg = (high == 0) ? out_reg : temp_reg;
2721
2722       fprintf (file, "\tldah $%d,%d($%d)\n", result_reg, extra, in_reg);
2723       in_reg = result_reg;
2724     }
2725
2726   if (high)
2727     fprintf (file, "\tldah $%d,%d($%d)\n", out_reg, high, in_reg);
2728 }
2729
2730 /* Write function prologue.  */
2731
2732 #if OPEN_VMS
2733
2734 /* On vms we have two kinds of functions:
2735
2736    - stack frame (PROC_STACK)
2737         these are 'normal' functions with local vars and which are
2738         calling other functions
2739    - register frame (PROC_REGISTER)
2740         keeps all data in registers, needs no stack
2741
2742    We must pass this to the assembler so it can generate the
2743    proper pdsc (procedure descriptor)
2744    This is done with the '.pdesc' command.
2745
2746    size is the stack size needed for local variables.  */
2747
2748 void
2749 output_prolog (file, size)
2750      FILE *file;
2751      HOST_WIDE_INT size;
2752 {
2753   unsigned long imask = 0;
2754   unsigned long fmask = 0;
2755   /* Stack space needed for pushing registers clobbered by us.  */
2756   HOST_WIDE_INT sa_size;
2757   /* Complete stack size needed.  */
2758   HOST_WIDE_INT frame_size;
2759   /* Offset from base reg to register save area.  */
2760   int rsa_offset = 8;
2761   /* Offset during register save.  */
2762   int reg_offset;
2763   /* Label for the procedure entry.  */
2764   char *entry_label = (char *) alloca (strlen (alpha_function_name) + 6);
2765   int i;
2766
2767   sa_size = alpha_sa_size ();
2768   frame_size
2769     = ALPHA_ROUND (sa_size
2770                    + (is_stack_procedure ? 8 : 0)
2771                    + size + current_function_pretend_args_size);
2772
2773   /* Issue function start and label.  */
2774   fprintf (file, "\t.ent ");
2775   assemble_name (file, alpha_function_name);
2776   fprintf (file, "\n");
2777   sprintf (entry_label, "$%s..en", alpha_function_name);
2778   ASM_OUTPUT_LABEL (file, entry_label);
2779   inside_function = TRUE;
2780
2781   fprintf (file, "\t.base $%d\n", base_regno);
2782
2783   /* Calculate register masks for clobbered registers.  */
2784
2785   if (is_stack_procedure)
2786     alpha_sa_mask (&imask, &fmask);
2787
2788   /* Adjust the stack by the frame size.  If the frame size is > 4096
2789      bytes, we need to be sure we probe somewhere in the first and last
2790      4096 bytes (we can probably get away without the latter test) and
2791      every 8192 bytes in between.  If the frame size is > 32768, we
2792      do this in a loop.  Otherwise, we generate the explicit probe
2793      instructions.
2794
2795      Note that we are only allowed to adjust sp once in the prologue.  */
2796
2797   if (frame_size < 32768)
2798     {
2799       if (frame_size > 4096)
2800         {
2801           int probed = 4096;
2802
2803           fprintf (file, "\tstq $31,-%d($30)\n", probed);
2804
2805           while (probed + 8192 < frame_size)
2806             fprintf (file, "\tstq $31,-%d($30)\n", probed += 8192);
2807
2808           /* We only have to do this probe if we aren't saving registers.  */
2809           if (sa_size == 0 && probed + 4096 < frame_size)
2810             fprintf (file, "\tstq $31,-%d($30)\n", frame_size);
2811         }
2812
2813       if (frame_size != 0)
2814           fprintf (file, "\tlda $30,-%d($30)\n", frame_size);
2815     }
2816   else
2817     {
2818       /* Here we generate code to set R4 to SP + 4096 and set R23 to the
2819          number of 8192 byte blocks to probe.  We then probe each block
2820          in the loop and then set SP to the proper location.  If the
2821          amount remaining is > 4096, we have to do one more probe if we
2822          are not saving any registers.  */
2823
2824       HOST_WIDE_INT blocks = (frame_size + 4096) / 8192;
2825       HOST_WIDE_INT leftover = frame_size + 4096 - blocks * 8192;
2826
2827       add_long_const (file, blocks, 31, 23, 23);
2828
2829       fprintf (file, "\tlda $22,4096($30)\n");
2830
2831       fputc ('$', file);
2832       assemble_name (file, alpha_function_name);
2833       fprintf (file, "..sc:\n");
2834
2835       fprintf (file, "\tstq $31,-8192($22)\n");
2836       fprintf (file, "\tsubq $23,1,$23\n");
2837       fprintf (file, "\tlda $22,-8192($22)\n");
2838
2839       fprintf (file, "\tbne $23,$");
2840       assemble_name (file, alpha_function_name);
2841       fprintf (file, "..sc\n");
2842
2843       if (leftover > 4096 && sa_size == 0)
2844         fprintf (file, "\tstq $31,-%d($22)\n", leftover);
2845
2846       fprintf (file, "\tlda $30,-%d($22)\n", leftover);
2847     }
2848
2849   if (is_stack_procedure)
2850     {
2851       int reg_offset = rsa_offset;
2852
2853       /* Store R26 (RA) first.  */
2854       fprintf (file, "\tstq $26,%d($30)\n", reg_offset);
2855       reg_offset += 8;
2856
2857       /* Store integer regs. according to mask.  */
2858       for (i = 0; i < 32; i++)
2859         if (imask & (1L<<i))
2860           {
2861             fprintf (file, "\tstq $%d,%d($30)\n", i, reg_offset);
2862             reg_offset += 8;
2863           }
2864
2865       /* Print the register mask and do floating-point saves.  */
2866
2867       if (imask)
2868         fprintf (file, "\t.mask 0x%x,0\n", imask);
2869
2870       for (i = 0; i < 32; i++)
2871         {
2872           if (fmask & (1L << i))
2873             {
2874               fprintf (file, "\tstt $f%d,%d($30)\n", i, reg_offset);
2875               reg_offset += 8;
2876             }
2877         }
2878
2879       /* Print the floating-point mask, if we've saved any fp register.  */
2880       if (fmask)
2881         fprintf (file, "\t.fmask 0x%x,0\n", fmask);
2882
2883       fprintf (file, "\tstq $27,0($30)\n");
2884     }
2885   else
2886     {
2887       fprintf (file, "\t.fp_save $%d\n", save_fp_regno);
2888       fprintf (file, "\tbis $%d,$%d,$%d\n", HARD_FRAME_POINTER_REGNUM,
2889                HARD_FRAME_POINTER_REGNUM, save_fp_regno);
2890     }
2891
2892   if (base_regno != REG_PV)
2893     fprintf (file, "\tbis $%d,$%d,$%d\n", REG_PV, REG_PV, base_regno);
2894
2895   if (unwind_regno == HARD_FRAME_POINTER_REGNUM)
2896     fprintf (file, "\tbis $%d,$%d,$%d\n", STACK_POINTER_REGNUM,
2897              STACK_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM);
2898
2899   /* Describe our frame.  */
2900   fprintf (file, "\t.frame $%d,%d,$26,%d\n",
2901            unwind_regno, frame_size, rsa_offset);
2902
2903   /* If we have to allocate space for outgoing args, do it now.  */
2904   if (current_function_outgoing_args_size != 0)
2905     fprintf (file, "\tlda $%d,%d($%d)\n", STACK_POINTER_REGNUM,
2906              - ALPHA_ROUND (current_function_outgoing_args_size),
2907              HARD_FRAME_POINTER_REGNUM);
2908
2909   fprintf (file, "\t.prologue\n");
2910
2911   link_section ();
2912   fprintf (file, "\t.align 3\n");
2913   ASM_OUTPUT_LABEL (file, alpha_function_name);
2914   fprintf (file, "\t.pdesc $");
2915   assemble_name (file, alpha_function_name);
2916   fprintf (file, "..en,%s\n", is_stack_procedure ? "stack" : "reg");
2917   alpha_need_linkage (alpha_function_name, 1);
2918   text_section ();
2919
2920   return;
2921 }
2922
2923 /* Write function epilogue.  */
2924
2925 void
2926 output_epilog (file, size)
2927      FILE *file;
2928      int size;
2929 {
2930   unsigned long imask = 0;
2931   unsigned long fmask = 0;
2932   /* Stack space needed for pushing registers clobbered by us.  */
2933   HOST_WIDE_INT sa_size = alpha_sa_size ();
2934   /* Complete stack size needed.  */
2935   HOST_WIDE_INT frame_size
2936     = ALPHA_ROUND (sa_size
2937                    + (is_stack_procedure ? 8 : 0)
2938                    + size + current_function_pretend_args_size);
2939   int i;
2940   rtx insn = get_last_insn ();
2941
2942   /* If the last insn was a BARRIER, we don't have to write anything except
2943      the .end pseudo-op.  */
2944
2945   if (GET_CODE (insn) == NOTE)
2946     insn = prev_nonnote_insn (insn);
2947
2948   if (insn == 0 || GET_CODE (insn) != BARRIER)
2949     {
2950       /* Restore clobbered registers, load FP last.  */
2951
2952       if (is_stack_procedure)
2953         {
2954           int rsa_offset = 8;
2955           int reg_offset;
2956           int fp_offset;
2957
2958           if (unwind_regno == HARD_FRAME_POINTER_REGNUM)
2959             fprintf (file, "\tbis $%d,$%d,$%d\n", HARD_FRAME_POINTER_REGNUM,
2960                      HARD_FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM);
2961
2962           alpha_sa_mask (&imask, &fmask);
2963
2964           /* Start reloading registers after RA.  */
2965           reg_offset = rsa_offset + 8;
2966
2967           for (i = 0; i < 32; i++)
2968             if (imask & (1L<<i))
2969               {
2970                 if (i == HARD_FRAME_POINTER_REGNUM)
2971                   fp_offset = reg_offset;
2972                 else
2973                   fprintf (file, "\tldq $%d,%d($30)\n",
2974                                   i, reg_offset);
2975                 reg_offset += 8;
2976               }
2977
2978           for (i = 0; i < 32; i++)
2979             if (fmask & (1L << i))
2980               {
2981                 fprintf (file, "\tldt $f%d,%d($30)\n", i, reg_offset);
2982                 reg_offset += 8;
2983               }
2984
2985           /* Restore R26 (RA).  */
2986           fprintf (file, "\tldq $26,%d($30)\n", rsa_offset);
2987
2988           /* Restore R29 (FP).  */
2989           fprintf (file, "\tldq $29,%d($30)\n", fp_offset);
2990         }
2991       else
2992         fprintf (file, "\tbis $%d,$%d,$%d\n", save_fp_regno, save_fp_regno,
2993                  HARD_FRAME_POINTER_REGNUM);
2994
2995       if (frame_size != 0)
2996         {
2997           if (frame_size < 32768)
2998             fprintf (file, "\tlda $30,%d($30)\n", frame_size);
2999           else
3000             {
3001               long high = frame_size >> 16;
3002               long low = frame_size & 0xffff;
3003               if (low & 0x8000)
3004                 {
3005                   high++;
3006                   low = -32768 + (low & 0x7fff);
3007                 }
3008               fprintf (file, "\tldah $2,%ld($31)\n", high);
3009               fprintf (file, "\tlda $2,%ld($2)\n", low);
3010               fprintf (file, "\taddq $30,$2,$30\n");
3011             }
3012         }
3013
3014       /* Finally return to the caller.  */
3015       fprintf (file, "\tret $31,($26),1\n");
3016     }
3017
3018   /* End the function.  */
3019   fprintf (file, "\t.end ");
3020   assemble_name (file,  alpha_function_name);
3021   fprintf (file, "\n");
3022   inside_function = FALSE;
3023
3024   /* Show that we know this function if it is called again.  */
3025   SYMBOL_REF_FLAG (XEXP (DECL_RTL (current_function_decl), 0)) = 1;
3026 }
3027
3028 int
3029 vms_valid_decl_attribute_p (decl, attributes, identifier, args)
3030      tree decl;
3031      tree attributes;
3032      tree identifier;
3033      tree args;
3034 {
3035   if (is_attribute_p ("overlaid", identifier))
3036     return (args == NULL_TREE);
3037   return 0;
3038 }
3039
3040 #else /* !OPEN_VMS */
3041
3042 static int
3043 alpha_does_function_need_gp ()
3044 {
3045   rtx insn;
3046
3047   /* We never need a GP for Windows/NT.  */
3048   if (TARGET_WINDOWS_NT)
3049     return 0;
3050
3051 #ifdef TARGET_PROFILING_NEEDS_GP
3052   if (profile_flag)
3053     return 1;
3054 #endif
3055
3056   /* If we need a GP (we have a LDSYM insn or a CALL_INSN), load it first.
3057      Even if we are a static function, we still need to do this in case
3058      our address is taken and passed to something like qsort.  */
3059
3060   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3061     if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
3062         && GET_CODE (PATTERN (insn)) != USE
3063         && GET_CODE (PATTERN (insn)) != CLOBBER)
3064       {
3065         enum attr_type type = get_attr_type (insn);
3066         if (type == TYPE_LDSYM || type == TYPE_JSR)
3067           return 1;
3068       }
3069
3070   return 0;
3071 }
3072
3073 void
3074 output_prolog (file, size)
3075      FILE *file;
3076      int size;
3077 {
3078   HOST_WIDE_INT out_args_size
3079     = ALPHA_ROUND (current_function_outgoing_args_size);
3080   HOST_WIDE_INT sa_size = alpha_sa_size ();
3081   HOST_WIDE_INT frame_size
3082     = (out_args_size + sa_size
3083        + ALPHA_ROUND (size + current_function_pretend_args_size));
3084   HOST_WIDE_INT reg_offset = out_args_size;
3085   HOST_WIDE_INT start_reg_offset = reg_offset;
3086   HOST_WIDE_INT actual_start_reg_offset = start_reg_offset;
3087   int int_reg_save_area_size = 0;
3088   unsigned reg_mask = 0;
3089   int i, sa_reg;
3090
3091   /* Ecoff can handle multiple .file directives, so put out file and lineno.
3092      We have to do that before the .ent directive as we cannot switch
3093      files within procedures with native ecoff because line numbers are
3094      linked to procedure descriptors.
3095      Outputting the lineno helps debugging of one line functions as they
3096      would otherwise get no line number at all. Please note that we would
3097      like to put out last_linenum from final.c, but it is not accessible.  */
3098
3099   if (write_symbols == SDB_DEBUG)
3100     {
3101       ASM_OUTPUT_SOURCE_FILENAME (file,
3102                                   DECL_SOURCE_FILE (current_function_decl));
3103       if (debug_info_level != DINFO_LEVEL_TERSE)
3104         ASM_OUTPUT_SOURCE_LINE (file,
3105                                 DECL_SOURCE_LINE (current_function_decl));
3106     }
3107
3108   /* The assembly language programmer's guide states that the second argument
3109      to the .ent directive, the lex_level, is ignored by the assembler,
3110      so we might as well omit it.  */
3111
3112   if (!flag_inhibit_size_directive)
3113     {
3114       fprintf (file, "\t.ent ");
3115       assemble_name (file, alpha_function_name);
3116       fprintf (file, "\n");
3117     }
3118   ASM_OUTPUT_LABEL (file, alpha_function_name);
3119   inside_function = TRUE;
3120
3121   if (TARGET_IEEE_CONFORMANT && !flag_inhibit_size_directive)
3122     /* Set flags in procedure descriptor to request IEEE-conformant
3123        math-library routines.  The value we set it to is PDSC_EXC_IEEE
3124        (/usr/include/pdsc.h). */
3125     fprintf (file, "\t.eflag 48\n");
3126
3127   /* Set up offsets to alpha virtual arg/local debugging pointer.  */
3128
3129   alpha_auto_offset = -frame_size + current_function_pretend_args_size;
3130   alpha_arg_offset = -frame_size + 48;
3131
3132   alpha_function_needs_gp = alpha_does_function_need_gp ();
3133
3134   if (TARGET_WINDOWS_NT == 0)
3135     {
3136       if (alpha_function_needs_gp)
3137         fprintf (file, "\tldgp $29,0($27)\n");
3138
3139       /* Put a label after the GP load so we can enter the function at it.  */
3140       fputc ('$', file);
3141       assemble_name (file, alpha_function_name);
3142       fprintf (file, "..ng:\n");
3143     }
3144
3145   /* Adjust the stack by the frame size.  If the frame size is > 4096
3146      bytes, we need to be sure we probe somewhere in the first and last
3147      4096 bytes (we can probably get away without the latter test) and
3148      every 8192 bytes in between.  If the frame size is > 32768, we
3149      do this in a loop.  Otherwise, we generate the explicit probe
3150      instructions.
3151
3152      Note that we are only allowed to adjust sp once in the prologue.  */
3153
3154   if (frame_size < 32768)
3155     {
3156       if (frame_size > 4096)
3157         {
3158           int probed = 4096;
3159
3160           fprintf (file, "\tstq $31,-%d($30)\n", probed);
3161
3162           while (probed + 8192 < frame_size)
3163             fprintf (file, "\tstq $31,-%d($30)\n", probed += 8192);
3164
3165           /* We only have to do this probe if we aren't saving registers.  */
3166           if (sa_size == 0 && probed + 4096 < frame_size)
3167             fprintf (file, "\tstq $31,-%d($30)\n", frame_size);
3168         }
3169
3170       if (frame_size != 0)
3171         fprintf (file, "\tlda $30,-%d($30)\n", frame_size);
3172     }
3173   else
3174     {
3175       /* Here we generate code to set R4 to SP + 4096 and set R5 to the
3176          number of 8192 byte blocks to probe.  We then probe each block
3177          in the loop and then set SP to the proper location.  If the
3178          amount remaining is > 4096, we have to do one more probe if we
3179          are not saving any registers.  */
3180
3181       HOST_WIDE_INT blocks = (frame_size + 4096) / 8192;
3182       HOST_WIDE_INT leftover = frame_size + 4096 - blocks * 8192;
3183
3184       add_long_const (file, blocks, 31, 5, 5);
3185
3186       fprintf (file, "\tlda $4,4096($30)\n");
3187
3188       fputc ('$', file);
3189       assemble_name (file, alpha_function_name);
3190       fprintf (file, "..sc:\n");
3191
3192       fprintf (file, "\tstq $31,-8192($4)\n");
3193       fprintf (file, "\tsubq $5,1,$5\n");
3194       fprintf (file, "\tlda $4,-8192($4)\n");
3195
3196       fprintf (file, "\tbne $5,$");
3197       assemble_name (file, alpha_function_name);
3198       fprintf (file, "..sc\n");
3199
3200       if (leftover > 4096 && sa_size == 0)
3201         fprintf (file, "\tstq $31,-%d($4)\n", leftover);
3202
3203       fprintf (file, "\tlda $30,-%d($4)\n", leftover);
3204     }
3205
3206   /* Describe our frame.  */
3207   if (!flag_inhibit_size_directive)
3208     {
3209       fprintf (file, "\t.frame $%d,%d,$26,%d\n",
3210                (frame_pointer_needed
3211                 ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM),
3212                frame_size, current_function_pretend_args_size);
3213     }
3214
3215   /* Cope with very large offsets to the register save area.  */
3216   sa_reg = 30;
3217   if (reg_offset + sa_size > 0x8000)
3218     {
3219       int low = ((reg_offset & 0xffff) ^ 0x8000) - 0x8000;
3220       if (low + sa_size <= 0x8000)
3221         {
3222           add_long_const (file, reg_offset - low, 30, 24, 24);
3223           reg_offset = low;
3224         }
3225       else
3226         {
3227           add_long_const (file, reg_offset, 30, 24, 24);
3228           reg_offset = 0;
3229         }
3230       sa_reg = 24;
3231     }
3232
3233   /* Save register RA if any other register needs to be saved.  */
3234   if (sa_size != 0)
3235     {
3236       reg_mask |= 1 << REG_RA;
3237       fprintf (file, "\tstq $26,%d($%d)\n", reg_offset, sa_reg);
3238       reg_offset += 8;
3239       int_reg_save_area_size += 8;
3240     }
3241
3242   /* Now save any other used integer registers required to be saved.  */
3243   for (i = 0; i < 32; i++)
3244     if (! fixed_regs[i] && ! call_used_regs[i]
3245         && regs_ever_live[i] && i != REG_RA)
3246       {
3247         reg_mask |= 1 << i;
3248         fprintf (file, "\tstq $%d,%d($%d)\n", i, reg_offset, sa_reg);
3249         reg_offset += 8;
3250         int_reg_save_area_size += 8;
3251       }
3252
3253   /* Print the register mask and do floating-point saves.  */
3254   if (reg_mask && !flag_inhibit_size_directive)
3255     fprintf (file, "\t.mask 0x%x,%d\n", reg_mask,
3256              actual_start_reg_offset - frame_size);
3257
3258   start_reg_offset = reg_offset;
3259   reg_mask = 0;
3260
3261   for (i = 0; i < 32; i++)
3262     if (! fixed_regs[i + 32] && ! call_used_regs[i + 32]
3263         && regs_ever_live[i + 32])
3264       {
3265         reg_mask |= 1 << i;
3266         fprintf (file, "\tstt $f%d,%d($%d)\n", i, reg_offset, sa_reg);
3267         reg_offset += 8;
3268       }
3269
3270   /* Print the floating-point mask, if we've saved any fp register.  */
3271   if (reg_mask && !flag_inhibit_size_directive)
3272     fprintf (file, "\t.fmask 0x%x,%d\n", reg_mask,
3273              actual_start_reg_offset - frame_size + int_reg_save_area_size);
3274
3275   /* If we need a frame pointer, set it from the stack pointer.  Note that
3276      this must always be the last instruction in the prologue.  */
3277   if (frame_pointer_needed)
3278     fprintf (file, "\tbis $30,$30,$15\n");
3279
3280   /* End the prologue and say if we used gp.  */
3281   if (!flag_inhibit_size_directive)
3282     fprintf (file, "\t.prologue %d\n", alpha_function_needs_gp);
3283 }
3284
3285 /* Write function epilogue.  */
3286
3287 void
3288 output_epilog (file, size)
3289      FILE *file;
3290      int size;
3291 {
3292   rtx insn = get_last_insn ();
3293   HOST_WIDE_INT out_args_size
3294     = ALPHA_ROUND (current_function_outgoing_args_size);
3295   HOST_WIDE_INT sa_size = alpha_sa_size ();
3296   HOST_WIDE_INT frame_size
3297     = (out_args_size + sa_size
3298        + ALPHA_ROUND (size + current_function_pretend_args_size));
3299   HOST_WIDE_INT reg_offset = out_args_size;
3300   HOST_WIDE_INT frame_size_from_reg_save = frame_size - reg_offset;
3301   int restore_fp
3302     = frame_pointer_needed && regs_ever_live[HARD_FRAME_POINTER_REGNUM];
3303   int i;
3304
3305   /* If the last insn was a BARRIER, we don't have to write anything except
3306      the .end pseudo-op.  */
3307   if (GET_CODE (insn) == NOTE)
3308     insn = prev_nonnote_insn (insn);
3309   if (insn == 0 || GET_CODE (insn) != BARRIER)
3310     {
3311       int fp_offset = 0;
3312       int sa_reg;
3313
3314       /* If we have a frame pointer, restore SP from it.  */
3315       if (frame_pointer_needed)
3316         fprintf (file, "\tbis $15,$15,$30\n");
3317
3318       /* Cope with large offsets to the register save area.  */
3319       sa_reg = 30;
3320       if (reg_offset + sa_size > 0x8000)
3321         {
3322           int low = ((reg_offset & 0xffff) ^ 0x8000) - 0x8000;
3323           if (low + sa_size <= 0x8000)
3324             {
3325               add_long_const (file, reg_offset - low, 30, 24, 24);
3326               reg_offset = low;
3327             }
3328           else
3329             {
3330               add_long_const (file, reg_offset, 30, 24, 24);
3331               reg_offset = 0;
3332             }
3333           sa_reg = 24;
3334         }
3335
3336       /* Restore all the registers, starting with the return address
3337          register.  */
3338       if (sa_size != 0)
3339         {
3340           fprintf (file, "\tldq $26,%d($%d)\n", reg_offset, sa_reg);
3341           reg_offset += 8;
3342         }
3343
3344       /* Now restore any other used integer registers that that we saved,
3345          except for FP if it is being used as FP, since it must be
3346          restored last.  */
3347
3348       for (i = 0; i < 32; i++)
3349         if (! fixed_regs[i] && ! call_used_regs[i] && regs_ever_live[i]
3350             && i != 26)
3351           {
3352             if (i == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed)
3353               fp_offset = reg_offset;
3354             else
3355               fprintf (file, "\tldq $%d,%d($%d)\n", i, reg_offset, sa_reg);
3356             reg_offset += 8;
3357           }
3358
3359       for (i = 0; i < 32; i++)
3360         if (! fixed_regs[i + 32] && ! call_used_regs[i + 32]
3361             && regs_ever_live[i + 32])
3362           {
3363             fprintf (file, "\tldt $f%d,%d($%d)\n", i, reg_offset, sa_reg);
3364             reg_offset += 8;
3365           }
3366
3367       /* If the stack size is large and we have a frame pointer, compute the
3368          size of the stack into a register because the old FP restore, stack
3369          pointer adjust, and return are required to be consecutive
3370          instructions.   */
3371       if (frame_size > 32767 && restore_fp)
3372         add_long_const (file, frame_size, 31, 1, 1);
3373
3374       /* If we needed a frame pointer and we have to restore it, do it
3375          now.  This must be done in one instruction immediately
3376          before the SP update.  */
3377       if (restore_fp && fp_offset)
3378         fprintf (file, "\tldq $15,%d($%d)\n", fp_offset, sa_reg);
3379
3380       /* Now update the stack pointer, if needed.  Only one instruction must
3381          modify the stack pointer.  It must be the last instruction in the
3382          sequence and must be an ADDQ or LDA instruction.  If the frame
3383          pointer was loaded above, we may only put one instruction here.  */
3384
3385       if (frame_size > 32768 && restore_fp)
3386         fprintf  (file, "\taddq $1,$30,$30\n");
3387       else
3388         add_long_const (file, frame_size, 30, 30, 1);
3389
3390       /* Finally return to the caller.  */
3391       fprintf (file, "\tret $31,($26),1\n");
3392     }
3393
3394   /* End the function.  */
3395   if (!flag_inhibit_size_directive)
3396     {
3397       fprintf (file, "\t.end ");
3398       assemble_name (file, alpha_function_name);
3399       fprintf (file, "\n");
3400     }
3401   inside_function = FALSE;
3402
3403   /* Show that we know this function if it is called again.  */
3404   SYMBOL_REF_FLAG (XEXP (DECL_RTL (current_function_decl), 0)) = 1;
3405 }
3406 #endif /* !OPEN_VMS */
3407 \f
3408 /* Debugging support.  */
3409
3410 #include "gstab.h"
3411
3412 /* Count the number of sdb related labels are generated (to find block
3413    start and end boundaries).  */
3414
3415 int sdb_label_count = 0;
3416
3417 /* Next label # for each statement.  */
3418
3419 static int sym_lineno = 0;
3420
3421 /* Count the number of .file directives, so that .loc is up to date.  */
3422
3423 static int num_source_filenames = 0;
3424
3425 /* Name of the file containing the current function.  */
3426
3427 static char *current_function_file = "";
3428
3429 /* Offsets to alpha virtual arg/local debugging pointers.  */
3430
3431 long alpha_arg_offset;
3432 long alpha_auto_offset;
3433 \f
3434 /* Emit a new filename to a stream.  */
3435
3436 void
3437 alpha_output_filename (stream, name)
3438      FILE *stream;
3439      char *name;
3440 {
3441   static int first_time = TRUE;
3442   char ltext_label_name[100];
3443
3444   if (first_time)
3445     {
3446       first_time = FALSE;
3447       ++num_source_filenames;
3448       current_function_file = name;
3449       fprintf (stream, "\t.file\t%d ", num_source_filenames);
3450       output_quoted_string (stream, name);
3451       fprintf (stream, "\n");
3452       if (!TARGET_GAS && write_symbols == DBX_DEBUG)
3453         fprintf (stream, "\t#@stabs\n");
3454     }
3455
3456   else if (write_symbols == DBX_DEBUG)
3457     {
3458       ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
3459       fprintf (stream, "%s ", ASM_STABS_OP);
3460       output_quoted_string (stream, name);
3461       fprintf (stream, ",%d,0,0,%s\n", N_SOL, &ltext_label_name[1]);
3462     }
3463
3464   else if (name != current_function_file
3465       && strcmp (name, current_function_file) != 0)
3466     {
3467       if (inside_function && ! TARGET_GAS)
3468         fprintf (stream, "\t#.file\t%d ", num_source_filenames);
3469       else
3470         {
3471           ++num_source_filenames;
3472           current_function_file = name;
3473           fprintf (stream, "\t.file\t%d ", num_source_filenames);
3474         }
3475
3476       output_quoted_string (stream, name);
3477       fprintf (stream, "\n");
3478     }
3479 }
3480 \f
3481 /* Emit a linenumber to a stream.  */
3482
3483 void
3484 alpha_output_lineno (stream, line)
3485      FILE *stream;
3486      int line;
3487 {
3488   if (write_symbols == DBX_DEBUG)
3489     {
3490       /* mips-tfile doesn't understand .stabd directives.  */
3491       ++sym_lineno;
3492       fprintf (stream, "$LM%d:\n\t%s %d,0,%d,$LM%d\n",
3493                sym_lineno, ASM_STABN_OP, N_SLINE, line, sym_lineno);
3494     }
3495   else
3496     fprintf (stream, "\n\t.loc\t%d %d\n", num_source_filenames, line);
3497 }
3498 \f
3499 /* Structure to show the current status of registers and memory.  */
3500
3501 struct shadow_summary
3502 {
3503   struct {
3504     unsigned long i     : 31;   /* Mask of int regs */
3505     unsigned long fp    : 31;   /* Mask of fp regs */
3506     unsigned long mem   :  1;   /* mem == imem | fpmem */
3507   } used, defd;
3508 };
3509
3510 /* Summary the effects of expression X on the machine.  Update SUM, a pointer
3511    to the summary structure.  SET is nonzero if the insn is setting the
3512    object, otherwise zero.  */
3513
3514 static void
3515 summarize_insn (x, sum, set)
3516      rtx x;
3517      struct shadow_summary *sum;
3518      int set;
3519 {
3520   char *format_ptr;
3521   int i, j;
3522
3523   if (x == 0)
3524     return;
3525
3526   switch (GET_CODE (x))
3527     {
3528       /* ??? Note that this case would be incorrect if the Alpha had a
3529          ZERO_EXTRACT in SET_DEST.  */
3530     case SET:
3531       summarize_insn (SET_SRC (x), sum, 0);
3532       summarize_insn (SET_DEST (x), sum, 1);
3533       break;
3534
3535     case CLOBBER:
3536       summarize_insn (XEXP (x, 0), sum, 1);
3537       break;
3538
3539     case USE:
3540       summarize_insn (XEXP (x, 0), sum, 0);
3541       break;
3542
3543     case ASM_OPERANDS:
3544       for (i = ASM_OPERANDS_INPUT_LENGTH (x) - 1; i >= 0; i--)
3545         summarize_insn (ASM_OPERANDS_INPUT (x, i), sum, 0);
3546       break;
3547
3548     case PARALLEL:
3549       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
3550         summarize_insn (XVECEXP (x, 0, i), sum, 0);
3551       break;
3552
3553     case SUBREG:
3554       x = SUBREG_REG (x);
3555       /* FALLTHRU */
3556
3557     case REG:
3558       {
3559         int regno = REGNO (x);
3560         unsigned long mask = 1UL << (regno % 32);
3561
3562         if (regno == 31 || regno == 63)
3563           break;
3564
3565         if (set)
3566           {
3567             if (regno < 32)
3568               sum->defd.i |= mask;
3569             else
3570               sum->defd.fp |= mask;
3571           }
3572         else
3573           {
3574             if (regno < 32)
3575               sum->used.i  |= mask;
3576             else
3577               sum->used.fp |= mask;
3578           }
3579         }
3580       break;
3581
3582     case MEM:
3583       if (set)
3584         sum->defd.mem = 1;
3585       else
3586         sum->used.mem = 1;
3587
3588       /* Find the regs used in memory address computation: */
3589       summarize_insn (XEXP (x, 0), sum, 0);
3590       break;
3591
3592     case CONST_INT:   case CONST_DOUBLE:
3593     case SYMBOL_REF:  case LABEL_REF:     case CONST:
3594       break;
3595
3596       /* Handle common unary and binary ops for efficiency.  */
3597     case COMPARE:  case PLUS:    case MINUS:   case MULT:      case DIV:
3598     case MOD:      case UDIV:    case UMOD:    case AND:       case IOR:
3599     case XOR:      case ASHIFT:  case ROTATE:  case ASHIFTRT:  case LSHIFTRT:
3600     case ROTATERT: case SMIN:    case SMAX:    case UMIN:      case UMAX:
3601     case NE:       case EQ:      case GE:      case GT:        case LE:
3602     case LT:       case GEU:     case GTU:     case LEU:       case LTU:
3603       summarize_insn (XEXP (x, 0), sum, 0);
3604       summarize_insn (XEXP (x, 1), sum, 0);
3605       break;
3606
3607     case NEG:  case NOT:  case SIGN_EXTEND:  case ZERO_EXTEND:
3608     case TRUNCATE:  case FLOAT_EXTEND:  case FLOAT_TRUNCATE:  case FLOAT:
3609     case FIX:  case UNSIGNED_FLOAT:  case UNSIGNED_FIX:  case ABS:
3610     case SQRT:  case FFS:
3611       summarize_insn (XEXP (x, 0), sum, 0);
3612       break;
3613
3614     default:
3615       format_ptr = GET_RTX_FORMAT (GET_CODE (x));
3616       for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
3617         switch (format_ptr[i])
3618           {
3619           case 'e':
3620             summarize_insn (XEXP (x, i), sum, 0);
3621             break;
3622
3623           case 'E':
3624             for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3625               summarize_insn (XVECEXP (x, i, j), sum, 0);
3626             break;
3627
3628           default:
3629             abort ();
3630           }
3631     }
3632 }
3633
3634 /* Ensure a sufficient number of `trapb' insns are in the code when the user
3635    requests code with a trap precision of functions or instructions.
3636
3637    In naive mode, when the user requests a trap-precision of "instruction", a
3638    trapb is needed after every instruction that may generate a trap (and after
3639    jsr/bsr instructions, because called functions may import a trap from the
3640    caller).  This ensures that the code is resumption safe but it is also slow.
3641
3642    When optimizations are turned on, we delay issuing a trapb as long as
3643    possible.  In this context, a trap shadow is the sequence of instructions
3644    that starts with a (potentially) trap generating instruction and extends to
3645    the next trapb or call_pal instruction (but GCC never generates call_pal by
3646    itself).  We can delay (and therefore sometimes omit) a trapb subject to the
3647    following conditions:
3648
3649    (a) On entry to the trap shadow, if any Alpha register or memory location
3650    contains a value that is used as an operand value by some instruction in
3651    the trap shadow (live on entry), then no instruction in the trap shadow
3652    may modify the register or memory location.
3653
3654    (b) Within the trap shadow, the computation of the base register for a
3655    memory load or store instruction may not involve using the result
3656    of an instruction that might generate an UNPREDICTABLE result.
3657
3658    (c) Within the trap shadow, no register may be used more than once as a
3659    destination register.  (This is to make life easier for the trap-handler.)
3660
3661    (d) The trap shadow may not include any branch instructions.  */
3662
3663 static void
3664 alpha_handle_trap_shadows (insns)
3665      rtx insns;
3666 {
3667   struct shadow_summary shadow;
3668   int trap_pending, exception_nesting;
3669   rtx i;
3670
3671   if (alpha_tp == ALPHA_TP_PROG && !flag_exceptions)
3672     return;
3673
3674   trap_pending = 0;
3675   exception_nesting = 0;
3676   shadow.used.i = 0;
3677   shadow.used.fp = 0;
3678   shadow.used.mem = 0;
3679   shadow.defd = shadow.used;
3680
3681   for (i = insns; i ; i = NEXT_INSN (i))
3682     {
3683       if (GET_CODE (i) == NOTE)
3684         {
3685           switch (NOTE_LINE_NUMBER (i))
3686             {
3687             case NOTE_INSN_EH_REGION_BEG:
3688               exception_nesting++;
3689               if (trap_pending)
3690                 goto close_shadow;
3691               break;
3692
3693             case NOTE_INSN_EH_REGION_END:
3694               exception_nesting--;
3695               if (trap_pending)
3696                 goto close_shadow;
3697               break;
3698
3699             case NOTE_INSN_EPILOGUE_BEG:
3700               if (trap_pending && alpha_tp >= ALPHA_TP_FUNC)
3701                 goto close_shadow;
3702               break;
3703             }
3704         }
3705       else if (trap_pending)
3706         {
3707           if (alpha_tp == ALPHA_TP_FUNC)
3708             {
3709               if (GET_CODE (i) == JUMP_INSN
3710                   && GET_CODE (PATTERN (i)) == RETURN)
3711                 goto close_shadow;
3712             }
3713           else if (alpha_tp == ALPHA_TP_INSN)
3714             {
3715               if (optimize > 0)
3716                 {
3717                   struct shadow_summary sum;
3718
3719                   sum.used.i = 0;
3720                   sum.used.fp = 0;
3721                   sum.used.mem = 0;
3722                   sum.defd = sum.used;
3723
3724                   switch (GET_CODE (i))
3725                     {
3726                     case INSN:
3727                       /* Annoyingly, get_attr_trap will abort on these.  */
3728                       if (GET_CODE (PATTERN (i)) == USE
3729                           || GET_CODE (PATTERN (i)) == CLOBBER)
3730                         break;
3731
3732                       summarize_insn (PATTERN (i), &sum, 0);
3733
3734                       if ((sum.defd.i & shadow.defd.i)
3735                           || (sum.defd.fp & shadow.defd.fp))
3736                         {
3737                           /* (c) would be violated */
3738                           goto close_shadow;
3739                         }
3740
3741                       /* Combine shadow with summary of current insn: */
3742                       shadow.used.i   |= sum.used.i;
3743                       shadow.used.fp  |= sum.used.fp;
3744                       shadow.used.mem |= sum.used.mem;
3745                       shadow.defd.i   |= sum.defd.i;
3746                       shadow.defd.fp  |= sum.defd.fp;
3747                       shadow.defd.mem |= sum.defd.mem;
3748
3749                       if ((sum.defd.i & shadow.used.i)
3750                           || (sum.defd.fp & shadow.used.fp)
3751                           || (sum.defd.mem & shadow.used.mem))
3752                         {
3753                           /* (a) would be violated (also takes care of (b))  */
3754                           if (get_attr_trap (i) == TRAP_YES
3755                               && ((sum.defd.i & sum.used.i)
3756                                   || (sum.defd.fp & sum.used.fp)))
3757                             abort ();
3758
3759                           goto close_shadow;
3760                         }
3761                       break;
3762
3763                     case JUMP_INSN:
3764                     case CALL_INSN:
3765                     case CODE_LABEL:
3766                       goto close_shadow;
3767
3768                     default:
3769                       abort ();
3770                     }
3771                 }
3772               else
3773                 {
3774                 close_shadow:
3775                   emit_insn_before (gen_trapb (), i);
3776                   trap_pending = 0;
3777                   shadow.used.i = 0;
3778                   shadow.used.fp = 0;
3779                   shadow.used.mem = 0;
3780                   shadow.defd = shadow.used;
3781                 }
3782             }
3783         }
3784
3785       if ((exception_nesting > 0 || alpha_tp >= ALPHA_TP_FUNC)
3786           && GET_CODE (i) == INSN
3787           && GET_CODE (PATTERN (i)) != USE
3788           && GET_CODE (PATTERN (i)) != CLOBBER
3789           && get_attr_trap (i) == TRAP_YES)
3790         {
3791           if (optimize && !trap_pending)
3792             summarize_insn (PATTERN (i), &shadow, 0);
3793           trap_pending = 1;
3794         }
3795     }
3796 }
3797
3798 /* Machine dependant reorg pass.  */
3799
3800 void
3801 alpha_reorg (insns)
3802      rtx insns;
3803 {
3804   alpha_handle_trap_shadows (insns);
3805 }
3806
3807 \f
3808 /* Check a floating-point value for validity for a particular machine mode.  */
3809
3810 static char *float_strings[] =
3811 {
3812   /* These are for FLOAT_VAX.  */
3813    "1.70141173319264430e+38", /* 2^127 (2^24 - 1) / 2^24 */
3814   "-1.70141173319264430e+38",
3815    "2.93873587705571877e-39", /* 2^-128 */
3816   "-2.93873587705571877e-39",
3817   /* These are for the default broken IEEE mode, which traps
3818      on infinity or denormal numbers.  */
3819    "3.402823466385288598117e+38", /* 2^128 (1 - 2^-24) */
3820   "-3.402823466385288598117e+38",
3821    "1.1754943508222875079687e-38", /* 2^-126 */
3822   "-1.1754943508222875079687e-38",
3823 };
3824
3825 static REAL_VALUE_TYPE float_values[8];
3826 static int inited_float_values = 0;
3827
3828 int
3829 check_float_value (mode, d, overflow)
3830      enum machine_mode mode;
3831      REAL_VALUE_TYPE *d;
3832      int overflow;
3833 {
3834
3835   if (TARGET_IEEE || TARGET_IEEE_CONFORMANT || TARGET_IEEE_WITH_INEXACT)
3836     return 0;
3837
3838   if (inited_float_values == 0)
3839     {
3840       int i;
3841       for (i = 0; i < 8; i++)
3842         float_values[i] = REAL_VALUE_ATOF (float_strings[i], DFmode);
3843
3844       inited_float_values = 1;
3845     }
3846
3847   if (mode == SFmode)
3848     {
3849       REAL_VALUE_TYPE r;
3850       REAL_VALUE_TYPE *fvptr;
3851
3852       if (TARGET_FLOAT_VAX)
3853         fvptr = &float_values[0];
3854       else
3855         fvptr = &float_values[4];
3856
3857       bcopy ((char *) d, (char *) &r, sizeof (REAL_VALUE_TYPE));
3858       if (REAL_VALUES_LESS (fvptr[0], r))
3859         {
3860           bcopy ((char *) &fvptr[0], (char *) d,
3861                  sizeof (REAL_VALUE_TYPE));
3862           return 1;
3863         }
3864       else if (REAL_VALUES_LESS (r, fvptr[1]))
3865         {
3866           bcopy ((char *) &fvptr[1], (char *) d,
3867                  sizeof (REAL_VALUE_TYPE));
3868           return 1;
3869         }
3870       else if (REAL_VALUES_LESS (dconst0, r)
3871                 && REAL_VALUES_LESS (r, fvptr[2]))
3872         {
3873           bcopy ((char *) &dconst0, (char *) d, sizeof (REAL_VALUE_TYPE));
3874           return 1;
3875         }
3876       else if (REAL_VALUES_LESS (r, dconst0)
3877                 && REAL_VALUES_LESS (fvptr[3], r))
3878         {
3879           bcopy ((char *) &dconst0, (char *) d, sizeof (REAL_VALUE_TYPE));
3880           return 1;
3881         }
3882     }
3883
3884   return 0;
3885 }
3886
3887 #if OPEN_VMS
3888
3889 /* Return the VMS argument type corresponding to MODE.  */
3890
3891 enum avms_arg_type
3892 alpha_arg_type (mode)
3893      enum machine_mode mode;
3894 {
3895   switch (mode)
3896     {
3897     case SFmode:
3898       return TARGET_FLOAT_VAX ? FF : FS;
3899     case DFmode:
3900       return TARGET_FLOAT_VAX ? FD : FT;
3901     default:
3902       return I64;
3903     }
3904 }
3905
3906 /* Return an rtx for an integer representing the VMS Argument Information
3907    register value.  */
3908
3909 struct rtx_def *
3910 alpha_arg_info_reg_val (cum)
3911      CUMULATIVE_ARGS cum;
3912 {
3913   unsigned HOST_WIDE_INT regval = cum.num_args;
3914   int i;
3915
3916   for (i = 0; i < 6; i++)
3917     regval |= ((int) cum.atypes[i]) << (i * 3 + 8);
3918
3919   return GEN_INT (regval);
3920 }
3921 \f
3922 /* Structure to collect function names for final output
3923    in link section.  */
3924
3925 enum links_kind {KIND_UNUSED, KIND_LOCAL, KIND_EXTERN};
3926
3927
3928 struct alpha_links {
3929   struct alpha_links *next;
3930   char *name;
3931   enum links_kind kind;
3932 };
3933
3934 static struct alpha_links *alpha_links_base = 0;
3935
3936 /* Make (or fake) .linkage entry for function call.
3937
3938    IS_LOCAL is 0 if name is used in call, 1 if name is used in definition.  */
3939
3940 void
3941 alpha_need_linkage (name, is_local)
3942     char *name;
3943     int is_local;
3944 {
3945   rtx x;
3946   struct alpha_links *lptr, *nptr;
3947
3948   if (name[0] == '*')
3949     name++;
3950
3951   /* Is this name already defined ?  */
3952
3953   for (lptr = alpha_links_base; lptr; lptr = lptr->next)
3954     if (strcmp (lptr->name, name) == 0)
3955       {
3956         if (is_local)
3957           {
3958             /* Defined here but external assumed.  */
3959             if (lptr->kind == KIND_EXTERN)
3960               lptr->kind = KIND_LOCAL;
3961           }
3962         else
3963           {
3964             /* Used here but unused assumed.  */
3965             if (lptr->kind == KIND_UNUSED)
3966               lptr->kind = KIND_LOCAL;
3967           }
3968         return;
3969       }
3970
3971   nptr = (struct alpha_links *) xmalloc (sizeof (struct alpha_links));
3972   nptr->next = alpha_links_base;
3973   nptr->name = xstrdup (name);
3974
3975   /* Assume external if no definition.  */
3976   nptr->kind = (is_local ? KIND_UNUSED : KIND_EXTERN);
3977
3978   /* Ensure we have an IDENTIFIER so assemble_name can mark is used.  */
3979   get_identifier (name);
3980
3981   alpha_links_base = nptr;
3982
3983   return;
3984 }
3985
3986
3987 void
3988 alpha_write_linkage (stream)
3989     FILE *stream;
3990 {
3991   struct alpha_links *lptr, *nptr;
3992
3993   readonly_section ();
3994
3995   fprintf (stream, "\t.align 3\n");
3996
3997   for (lptr = alpha_links_base; lptr; lptr = nptr)
3998     {
3999       nptr = lptr->next;
4000
4001       if (lptr->kind == KIND_UNUSED
4002           || ! TREE_SYMBOL_REFERENCED (get_identifier (lptr->name)))
4003         continue;
4004
4005       fprintf (stream, "$%s..lk:\n", lptr->name);
4006       if (lptr->kind == KIND_LOCAL)
4007         {
4008           /*  Local and used, build linkage pair.  */
4009           fprintf (stream, "\t.quad $%s..en\n", lptr->name);
4010           fprintf (stream, "\t.quad %s\n", lptr->name);
4011         }
4012       else
4013         /* External and used, request linkage pair.  */
4014         fprintf (stream, "\t.linkage %s\n", lptr->name);
4015     }
4016 }
4017
4018 #else
4019
4020 void
4021 alpha_need_linkage (name, is_local)
4022      char *name;
4023      int is_local;
4024 {
4025 }
4026
4027 #endif /* OPEN_VMS */
4028