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 #if HOST_BITS_PER_WIDE_INT == 64
 479               || INTVAL (op) == 0xffffffff
 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   /* Handle a block of contiguous words first.  */
1618
1619   if (align >= 8 && bytes >= 8)
1620     {
1621       words = bytes / 8;
1622
1623       /* Make some data registers. */
1624       for (i = 0; i < words; ++i)
1625         data_regs[i] = gen_reg_rtx(DImode);
1626
1627       /* Move in aligned hunks.  */
1628       for (i = 0; i < words; ++i)
1629         {
1630           emit_move_insn (data_regs[i],
1631                           change_address(orig_src, DImode,
1632                                          plus_constant (XEXP (orig_src, 0),
1633                                                         i*8)));
1634         }
1635       for (i = 0; i < words; ++i)
1636         {
1637           emit_move_insn (change_address(orig_dst, DImode,
1638                                          plus_constant (XEXP (orig_dst, 0),
1639                                                         i*8)),
1640                           data_regs[i]);
1641         }
1642
1643       bytes -= words * 8;
1644       ofs = words * 8;
1645     }
1646   if (align >= 4 && bytes >= 4)
1647     {
1648       words = bytes / 4;
1649
1650       /* Make some data registers. */
1651       for (i = 0; i < words; ++i)
1652         data_regs[i] = gen_reg_rtx(SImode);
1653
1654       /* Move in aligned hunks.  */
1655       for (i = 0; i < words; ++i)
1656         {
1657           emit_move_insn (data_regs[i],
1658                           change_address(orig_src, SImode,
1659                                          plus_constant (XEXP (orig_src, 0),
1660                                                         i*4)));
1661         }
1662       for (i = 0; i < words; ++i)
1663         {
1664           emit_move_insn (change_address(orig_dst, SImode,
1665                                          plus_constant (XEXP (orig_dst, 0),
1666                                                         i*4)),
1667                           data_regs[i]);
1668         }
1669
1670       bytes -= words * 4;
1671       ofs = words * 4;
1672     }
1673   if (bytes >= 16)
1674     {
1675       words = bytes / 8;
1676
1677       /* Make some data registers. */
1678       for (i = 0; i < words+1; ++i)
1679         data_regs[i] = gen_reg_rtx(DImode);
1680
1681       /* Move in unaligned hunks.  */
1682       alpha_expand_unaligned_load_words (data_regs, orig_src, words);
1683       alpha_expand_unaligned_store_words (data_regs, orig_dst, words);
1684
1685       bytes -= words * 8;
1686       ofs = words * 8;
1687     }
1688
1689   /* Next clean up any trailing pieces.  We know from the contiguous
1690      block move that there are no aligned SImode or DImode hunks left.  */
1691
1692   if (!TARGET_BWX && bytes >= 8)
1693     {
1694       tmp = gen_reg_rtx (DImode);
1695       alpha_expand_unaligned_load (tmp, orig_src, 8, ofs, 0);
1696       alpha_expand_unaligned_store (orig_dst, tmp, 8, ofs);
1697
1698       bytes -= 8;
1699       ofs += 8;
1700     }
1701   if (!TARGET_BWX && bytes >= 4)
1702     {
1703       tmp = gen_reg_rtx (DImode);
1704       alpha_expand_unaligned_load (tmp, orig_src, 4, ofs, 0);
1705       alpha_expand_unaligned_store (orig_dst, tmp, 4, ofs);
1706
1707       bytes -= 4;
1708       ofs += 4;
1709     }
1710   if (bytes >= 2)
1711     {
1712       if (align >= 2)
1713         {
1714           do {
1715             emit_move_insn (change_address (orig_dst, HImode,
1716                                             plus_constant (XEXP (orig_dst, 0),
1717                                                            ofs)),
1718                             change_address (orig_src, HImode,
1719                                             plus_constant (XEXP (orig_src, 0),
1720                                                            ofs)));
1721             bytes -= 2;
1722             ofs += 2;
1723           } while (bytes >= 2);
1724         }
1725       else if (!TARGET_BWX)
1726         {
1727           tmp = gen_reg_rtx (DImode);
1728           alpha_expand_unaligned_load (tmp, orig_src, 2, ofs, 0);
1729           alpha_expand_unaligned_store (orig_dst, tmp, 2, ofs);
1730           bytes -= 2;
1731           ofs += 2;
1732         }
1733     }
1734   while (bytes > 0)
1735     {
1736       emit_move_insn (change_address (orig_dst, QImode,
1737                                       plus_constant (XEXP (orig_dst, 0),
1738                                                      ofs)),
1739                       change_address (orig_src, QImode,
1740                                       plus_constant (XEXP (orig_src, 0),
1741                                                      ofs)));
1742       bytes -= 1;
1743       ofs += 1;
1744     }
1745
1746   return 1;
1747 }
1748
1749 int
1750 alpha_expand_block_clear (operands)
1751      rtx operands[];
1752 {
1753   rtx bytes_rtx = operands[1];
1754   rtx align_rtx = operands[2];
1755   HOST_WIDE_INT bytes = INTVAL (bytes_rtx);
1756   HOST_WIDE_INT align = INTVAL (align_rtx);
1757   rtx orig_dst  = operands[0];
1758   HOST_WIDE_INT i, words, ofs = 0;
1759
1760   if (bytes <= 0)
1761     return 1;
1762   if (bytes > MAX_MOVE_WORDS*8)
1763     return 0;
1764
1765   /* Handle a block of contiguous words first.  */
1766
1767   if (align >= 8 && bytes >= 8)
1768     {
1769       words = bytes / 8;
1770
1771       for (i = 0; i < words; ++i)
1772         {
1773           emit_move_insn (change_address(orig_dst, DImode,
1774                                          plus_constant (XEXP (orig_dst, 0),
1775                                                         i*8)),
1776                           const0_rtx);
1777         }
1778
1779       bytes -= words * 8;
1780       ofs = words * 8;
1781     }
1782   else if (align >= 4 && bytes >= 4)
1783     {
1784       words = bytes / 4;
1785
1786       for (i = 0; i < words; ++i)
1787         {
1788           emit_move_insn (change_address(orig_dst, SImode,
1789                                          plus_constant (XEXP (orig_dst, 0),
1790                                                         i*4)),
1791                           const0_rtx);
1792         }
1793
1794       bytes -= words * 4;
1795       ofs = words * 4;
1796     }
1797   else if (bytes >= 16)
1798     {
1799       words = bytes / 8;
1800
1801       alpha_expand_unaligned_store_words (NULL, orig_dst, words);
1802
1803       bytes -= words * 8;
1804       ofs = words * 8;
1805     }
1806
1807   /* Next clean up any trailing pieces.  We know from the contiguous
1808      block move that there are no aligned SImode or DImode hunks left.  */
1809
1810   if (!TARGET_BWX && bytes >= 8)
1811     {
1812       alpha_expand_unaligned_store (orig_dst, const0_rtx, 8, ofs);
1813       bytes -= 8;
1814       ofs += 8;
1815     }
1816   if (!TARGET_BWX && bytes >= 4)
1817     {
1818       alpha_expand_unaligned_store (orig_dst, const0_rtx, 4, ofs);
1819       bytes -= 4;
1820       ofs += 4;
1821     }
1822   if (bytes >= 2)
1823     {
1824       if (align >= 2)
1825         {
1826           do {
1827             emit_move_insn (change_address (orig_dst, HImode,
1828                                             plus_constant (XEXP (orig_dst, 0),
1829                                                            ofs)),
1830                             const0_rtx);
1831             bytes -= 2;
1832             ofs += 2;
1833           } while (bytes >= 2);
1834         }
1835       else if (!TARGET_BWX)
1836         {
1837           alpha_expand_unaligned_store (orig_dst, const0_rtx, 2, ofs);
1838           bytes -= 2;
1839           ofs += 2;
1840         }
1841     }
1842   while (bytes > 0)
1843     {
1844       emit_move_insn (change_address (orig_dst, QImode,
1845                                       plus_constant (XEXP (orig_dst, 0),
1846                                                      ofs)),
1847                       const0_rtx);
1848       bytes -= 1;
1849       ofs += 1;
1850     }
1851
1852   return 1;
1853 }
1854
1855 \f
1856 /* Adjust the cost of a scheduling dependency.  Return the new cost of
1857    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
1858
1859 int
1860 alpha_adjust_cost (insn, link, dep_insn, cost)
1861      rtx insn;
1862      rtx link;
1863      rtx dep_insn;
1864      int cost;
1865 {
1866   rtx set, set_src;
1867   enum attr_type insn_type, dep_insn_type;
1868
1869   /* If the dependence is an anti-dependence, there is no cost.  For an
1870      output dependence, there is sometimes a cost, but it doesn't seem
1871      worth handling those few cases.  */
1872
1873   if (REG_NOTE_KIND (link) != 0)
1874     return 0;
1875
1876   /* If we can't recognize the insns, we can't really do anything.  */
1877   if (recog_memoized (insn) < 0 || recog_memoized (dep_insn) < 0)
1878     return cost;
1879
1880   insn_type = get_attr_type (insn);
1881   dep_insn_type = get_attr_type (dep_insn);
1882
1883   /* Bring in the user-defined memory latency.  */
1884   if (dep_insn_type == TYPE_ILD
1885       || dep_insn_type == TYPE_FLD
1886       || dep_insn_type == TYPE_LDSYM)
1887     cost += alpha_memory_latency-1;
1888
1889   switch (alpha_cpu)
1890     {
1891     case PROCESSOR_EV4:
1892       /* On EV4, if INSN is a store insn and DEP_INSN is setting the data
1893          being stored, we can sometimes lower the cost.  */
1894
1895       if ((insn_type == TYPE_IST || insn_type == TYPE_FST)
1896           && (set = single_set (dep_insn)) != 0
1897           && GET_CODE (PATTERN (insn)) == SET
1898           && rtx_equal_p (SET_DEST (set), SET_SRC (PATTERN (insn))))
1899         {
1900           switch (dep_insn_type)
1901             {
1902             case TYPE_ILD:
1903             case TYPE_FLD:
1904               /* No savings here.  */
1905               return cost;
1906
1907             case TYPE_IMUL:
1908               /* In these cases, we save one cycle.  */
1909               return cost - 1;
1910
1911             default:
1912               /* In all other cases, we save two cycles.  */
1913               return MAX (0, cost - 2);
1914             }
1915         }
1916
1917       /* Another case that needs adjustment is an arithmetic or logical
1918          operation.  It's cost is usually one cycle, but we default it to
1919          two in the MD file.  The only case that it is actually two is
1920          for the address in loads, stores, and jumps.  */
1921
1922       if (dep_insn_type == TYPE_IADD || dep_insn_type == TYPE_ILOG)
1923         {
1924           switch (insn_type)
1925             {
1926             case TYPE_ILD:
1927             case TYPE_IST:
1928             case TYPE_FLD:
1929             case TYPE_FST:
1930             case TYPE_JSR:
1931               return cost;
1932             default:
1933               return 1;
1934             }
1935         }
1936
1937       /* The final case is when a compare feeds into an integer branch;
1938          the cost is only one cycle in that case.  */
1939
1940       if (dep_insn_type == TYPE_ICMP && insn_type == TYPE_IBR)
1941         return 1;
1942       break;
1943
1944     case PROCESSOR_EV5:
1945       /* And the lord DEC saith:  "A special bypass provides an effective
1946          latency of 0 cycles for an ICMP or ILOG insn producing the test
1947          operand of an IBR or ICMOV insn." */
1948
1949       if ((dep_insn_type == TYPE_ICMP || dep_insn_type == TYPE_ILOG)
1950           && (set = single_set (dep_insn)) != 0)
1951         {
1952           /* A branch only has one input.  This must be it.  */
1953           if (insn_type == TYPE_IBR)
1954             return 0;
1955           /* A conditional move has three, make sure it is the test.  */
1956           if (insn_type == TYPE_ICMOV
1957               && GET_CODE (set_src = PATTERN (insn)) == SET
1958               && GET_CODE (set_src = SET_SRC (set_src)) == IF_THEN_ELSE
1959               && rtx_equal_p (SET_DEST (set), XEXP (set_src, 0)))
1960             return 0;
1961         }
1962
1963       /* "The multiplier is unable to receive data from IEU bypass paths.
1964          The instruction issues at the expected time, but its latency is
1965          increased by the time it takes for the input data to become
1966          available to the multiplier" -- which happens in pipeline stage
1967          six, when results are comitted to the register file.  */
1968
1969       if (insn_type == TYPE_IMUL)
1970         {
1971           switch (dep_insn_type)
1972             {
1973             /* These insns produce their results in pipeline stage five.  */
1974             case TYPE_ILD:
1975             case TYPE_ICMOV:
1976             case TYPE_IMUL:
1977             case TYPE_MVI:
1978               return cost + 1;
1979
1980             /* Other integer insns produce results in pipeline stage four.  */
1981             default:
1982               return cost + 2;
1983             }
1984         }
1985       break;
1986
1987     case PROCESSOR_EV6:
1988       /* There is additional latency to move the result of (most) FP
1989          operations anywhere but the FP register file.  */
1990
1991       if ((insn_type == TYPE_FST || insn_type == TYPE_FTOI)
1992           && (dep_insn_type == TYPE_FADD ||
1993               dep_insn_type == TYPE_FMUL ||
1994               dep_insn_type == TYPE_FCMOV))
1995         return cost + 2;
1996
1997       break;
1998     }
1999
2000   /* Otherwise, return the default cost. */
2001   return cost;
2002 }
2003 \f
2004 /* Functions to save and restore alpha_return_addr_rtx.  */
2005
2006 struct machine_function
2007 {
2008   rtx ra_rtx;
2009 };
2010
2011 static void
2012 alpha_save_machine_status (p)
2013      struct function *p;
2014 {
2015   struct machine_function *machine =
2016     (struct machine_function *) xmalloc (sizeof (struct machine_function));
2017
2018   p->machine = machine;
2019   machine->ra_rtx = alpha_return_addr_rtx;
2020 }
2021
2022 static void
2023 alpha_restore_machine_status (p)
2024      struct function *p;
2025 {
2026   struct machine_function *machine = p->machine;
2027
2028   alpha_return_addr_rtx = machine->ra_rtx;
2029
2030   free (machine);
2031   p->machine = (struct machine_function *)0;
2032 }
2033
2034 /* Do anything needed before RTL is emitted for each function.  */
2035
2036 void
2037 alpha_init_expanders ()
2038 {
2039   alpha_return_addr_rtx = NULL_RTX;
2040
2041   /* Arrange to save and restore machine status around nested functions.  */
2042   save_machine_status = alpha_save_machine_status;
2043   restore_machine_status = alpha_restore_machine_status;
2044 }
2045
2046 /* Start the ball rolling with RETURN_ADDR_RTX.  */
2047
2048 rtx
2049 alpha_return_addr (count, frame)
2050      int count;
2051      rtx frame;
2052 {
2053   rtx init, first;
2054
2055   if (count != 0)
2056     return const0_rtx;
2057
2058   if (alpha_return_addr_rtx)
2059     return alpha_return_addr_rtx;
2060
2061   /* No rtx yet.  Invent one, and initialize it from $26 in the prologue.  */
2062   alpha_return_addr_rtx = gen_reg_rtx (Pmode);
2063   init = gen_rtx_SET (Pmode, alpha_return_addr_rtx,
2064                       gen_rtx_REG (Pmode, REG_RA));
2065
2066   /* Emit the insn to the prologue with the other argument copies.  */
2067   push_topmost_sequence ();
2068   emit_insn_after (init, get_insns ());
2069   pop_topmost_sequence ();
2070
2071   return alpha_return_addr_rtx;
2072 }
2073
2074 static int
2075 alpha_ra_ever_killed ()
2076 {
2077   rtx i, ra;
2078
2079   if (!alpha_return_addr_rtx)
2080     return regs_ever_live[REG_RA];
2081
2082   return reg_set_between_p (gen_rtx_REG (Pmode, REG_RA),
2083                             get_insns(), NULL_RTX);
2084 }
2085
2086 \f
2087 /* Print an operand.  Recognize special options, documented below.  */
2088
2089 void
2090 print_operand (file, x, code)
2091     FILE *file;
2092     rtx x;
2093     char code;
2094 {
2095   int i;
2096
2097   switch (code)
2098     {
2099     case '&':
2100       /* Generates fp-rounding mode suffix: nothing for normal, 'c' for
2101          chopped, 'm' for minus-infinity, and 'd' for dynamic rounding
2102          mode.  alpha_fprm controls which suffix is generated.  */
2103       switch (alpha_fprm)
2104         {
2105         case ALPHA_FPRM_NORM:
2106           break;
2107         case ALPHA_FPRM_MINF:
2108           fputc ('m', file);
2109           break;
2110         case ALPHA_FPRM_CHOP:
2111           fputc ('c', file);
2112           break;
2113         case ALPHA_FPRM_DYN:
2114           fputc ('d', file);
2115           break;
2116         }
2117       break;
2118
2119     case '\'':
2120       /* Generates trap-mode suffix for instructions that accept the su
2121          suffix only (cmpt et al).  */
2122       if (alpha_tp == ALPHA_TP_INSN)
2123         fputs ("su", file);
2124       break;
2125
2126     case ')':
2127       /* Generates trap-mode suffix for instructions that accept the u, su,
2128          and sui suffix.  This is the bulk of the IEEE floating point
2129          instructions (addt et al).  */
2130       switch (alpha_fptm)
2131         {
2132         case ALPHA_FPTM_N:
2133           break;
2134         case ALPHA_FPTM_U:
2135           fputc ('u', file);
2136           break;
2137         case ALPHA_FPTM_SU:
2138           fputs ("su", file);
2139           break;
2140         case ALPHA_FPTM_SUI:
2141           fputs ("sui", file);
2142           break;
2143         }
2144       break;
2145
2146     case '+':
2147       /* Generates trap-mode suffix for instructions that accept the sui
2148          suffix (cvtqt and cvtqs).  */
2149       switch (alpha_fptm)
2150         {
2151         case ALPHA_FPTM_N: case ALPHA_FPTM_U:
2152         case ALPHA_FPTM_SU:     /* cvtqt/cvtqs can't cause underflow */
2153           break;
2154         case ALPHA_FPTM_SUI:
2155           fputs ("sui", file);
2156           break;
2157         }
2158       break;
2159
2160     case ',':
2161       /* Generates single precision instruction suffix.  */
2162       fprintf (file, "%c", (TARGET_FLOAT_VAX ? 'f' : 's'));
2163       break;
2164
2165     case '-':
2166       /* Generates double precision instruction suffix.  */
2167       fprintf (file, "%c", (TARGET_FLOAT_VAX ? 'g' : 't'));
2168       break;
2169
2170     case 'r':
2171       /* If this operand is the constant zero, write it as "$31".  */
2172       if (GET_CODE (x) == REG)
2173         fprintf (file, "%s", reg_names[REGNO (x)]);
2174       else if (x == CONST0_RTX (GET_MODE (x)))
2175         fprintf (file, "$31");
2176       else
2177         output_operand_lossage ("invalid %%r value");
2178
2179       break;
2180
2181     case 'R':
2182       /* Similar, but for floating-point.  */
2183       if (GET_CODE (x) == REG)
2184         fprintf (file, "%s", reg_names[REGNO (x)]);
2185       else if (x == CONST0_RTX (GET_MODE (x)))
2186         fprintf (file, "$f31");
2187       else
2188         output_operand_lossage ("invalid %%R value");
2189
2190       break;
2191
2192     case 'N':
2193       /* Write the 1's complement of a constant.  */
2194       if (GET_CODE (x) != CONST_INT)
2195         output_operand_lossage ("invalid %%N value");
2196
2197       fprintf (file, HOST_WIDE_INT_PRINT_DEC, ~ INTVAL (x));
2198       break;
2199
2200     case 'P':
2201       /* Write 1 << C, for a constant C.  */
2202       if (GET_CODE (x) != CONST_INT)
2203         output_operand_lossage ("invalid %%P value");
2204
2205       fprintf (file, HOST_WIDE_INT_PRINT_DEC, (HOST_WIDE_INT) 1 << INTVAL (x));
2206       break;
2207
2208     case 'h':
2209       /* Write the high-order 16 bits of a constant, sign-extended.  */
2210       if (GET_CODE (x) != CONST_INT)
2211         output_operand_lossage ("invalid %%h value");
2212
2213       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) >> 16);
2214       break;
2215
2216     case 'L':
2217       /* Write the low-order 16 bits of a constant, sign-extended.  */
2218       if (GET_CODE (x) != CONST_INT)
2219         output_operand_lossage ("invalid %%L value");
2220
2221       fprintf (file, HOST_WIDE_INT_PRINT_DEC,
2222                (INTVAL (x) & 0xffff) - 2 * (INTVAL (x) & 0x8000));
2223       break;
2224
2225     case 'm':
2226       /* Write mask for ZAP insn.  */
2227       if (GET_CODE (x) == CONST_DOUBLE)
2228         {
2229           HOST_WIDE_INT mask = 0;
2230           HOST_WIDE_INT value;
2231
2232           value = CONST_DOUBLE_LOW (x);
2233           for (i = 0; i < HOST_BITS_PER_WIDE_INT / HOST_BITS_PER_CHAR;
2234                i++, value >>= 8)
2235             if (value & 0xff)
2236               mask |= (1 << i);
2237
2238           value = CONST_DOUBLE_HIGH (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 + sizeof (int)));
2243
2244           fprintf (file, HOST_WIDE_INT_PRINT_DEC, mask & 0xff);
2245         }
2246
2247       else if (GET_CODE (x) == CONST_INT)
2248         {
2249           HOST_WIDE_INT mask = 0, value = INTVAL (x);
2250
2251           for (i = 0; i < 8; i++, value >>= 8)
2252             if (value & 0xff)
2253               mask |= (1 << i);
2254
2255           fprintf (file, HOST_WIDE_INT_PRINT_DEC, mask);
2256         }
2257       else
2258         output_operand_lossage ("invalid %%m value");
2259       break;
2260
2261     case 'M':
2262       /* 'b', 'w', 'l', or 'q' as the value of the constant.  */
2263       if (GET_CODE (x) != CONST_INT
2264           || (INTVAL (x) != 8 && INTVAL (x) != 16
2265               && INTVAL (x) != 32 && INTVAL (x) != 64))
2266         output_operand_lossage ("invalid %%M value");
2267
2268       fprintf (file, "%s",
2269                (INTVAL (x) == 8 ? "b"
2270                 : INTVAL (x) == 16 ? "w"
2271                 : INTVAL (x) == 32 ? "l"
2272                 : "q"));
2273       break;
2274
2275     case 'U':
2276       /* Similar, except do it from the mask.  */
2277       if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0xff)
2278         fprintf (file, "b");
2279       else if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0xffff)
2280         fprintf (file, "w");
2281 #if HOST_BITS_PER_WIDE_INT == 32
2282       else if (GET_CODE (x) == CONST_DOUBLE
2283                && CONST_DOUBLE_HIGH (x) == 0
2284                && CONST_DOUBLE_LOW (x) == -1)
2285         fprintf (file, "l");
2286       else if (GET_CODE (x) == CONST_DOUBLE
2287                && CONST_DOUBLE_HIGH (x) == -1
2288                && CONST_DOUBLE_LOW (x) == -1)
2289         fprintf (file, "q");
2290 #else
2291       else if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0xffffffff)
2292         fprintf (file, "l");
2293       else if (GET_CODE (x) == CONST_INT && INTVAL (x) == 0xffffffffffffffff)
2294         fprintf (file, "q");
2295       else if (GET_CODE (x) == CONST_DOUBLE
2296                && CONST_DOUBLE_HIGH (x) == 0
2297                && CONST_DOUBLE_LOW (x) == -1)
2298         fprintf (file, "q");
2299 #endif
2300       else
2301         output_operand_lossage ("invalid %%U value");
2302       break;
2303
2304     case 's':
2305       /* Write the constant value divided by 8.  */
2306       if (GET_CODE (x) != CONST_INT
2307           && (unsigned HOST_WIDE_INT) INTVAL (x) >= 64
2308           && (INTVAL (x) & 7) != 8)
2309         output_operand_lossage ("invalid %%s value");
2310
2311       fprintf (file, HOST_WIDE_INT_PRINT_DEC, INTVAL (x) / 8);
2312       break;
2313
2314     case 'S':
2315       /* Same, except compute (64 - c) / 8 */
2316
2317       if (GET_CODE (x) != CONST_INT
2318           && (unsigned HOST_WIDE_INT) INTVAL (x) >= 64
2319           && (INTVAL (x) & 7) != 8)
2320         output_operand_lossage ("invalid %%s value");
2321
2322       fprintf (file, HOST_WIDE_INT_PRINT_DEC, (64 - INTVAL (x)) / 8);
2323       break;
2324
2325     case 'C': case 'D': case 'c': case 'd':
2326       /* Write out comparison name.  */
2327       {
2328         enum rtx_code c = GET_CODE (x);
2329
2330         if (GET_RTX_CLASS (c) != '<')
2331           output_operand_lossage ("invalid %%C value");
2332
2333         if (code == 'D')
2334           c = reverse_condition (c);
2335         else if (code == 'c')
2336           c = swap_condition (c);
2337         else if (code == 'd')
2338           c = swap_condition (reverse_condition (c));
2339
2340         if (c == LEU)
2341           fprintf (file, "ule");
2342         else if (c == LTU)
2343           fprintf (file, "ult");
2344         else
2345           fprintf (file, "%s", GET_RTX_NAME (c));
2346       }
2347       break;
2348
2349     case 'E':
2350       /* Write the divide or modulus operator.  */
2351       switch (GET_CODE (x))
2352         {
2353         case DIV:
2354           fprintf (file, "div%s", GET_MODE (x) == SImode ? "l" : "q");
2355           break;
2356         case UDIV:
2357           fprintf (file, "div%su", GET_MODE (x) == SImode ? "l" : "q");
2358           break;
2359         case MOD:
2360           fprintf (file, "rem%s", GET_MODE (x) == SImode ? "l" : "q");
2361           break;
2362         case UMOD:
2363           fprintf (file, "rem%su", GET_MODE (x) == SImode ? "l" : "q");
2364           break;
2365         default:
2366           output_operand_lossage ("invalid %%E value");
2367           break;
2368         }
2369       break;
2370
2371     case 'A':
2372       /* Write "_u" for unaligned access.  */
2373       if (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == AND)
2374         fprintf (file, "_u");
2375       break;
2376
2377     case 0:
2378       if (GET_CODE (x) == REG)
2379         fprintf (file, "%s", reg_names[REGNO (x)]);
2380       else if (GET_CODE (x) == MEM)
2381         output_address (XEXP (x, 0));
2382       else
2383         output_addr_const (file, x);
2384       break;
2385
2386     default:
2387       output_operand_lossage ("invalid %%xn code");
2388     }
2389 }
2390 \f
2391 /* Do what is necessary for `va_start'.  The argument is ignored;
2392    We look at the current function to determine if stdarg or varargs
2393    is used and fill in an initial va_list.  A pointer to this constructor
2394    is returned.  */
2395
2396 struct rtx_def *
2397 alpha_builtin_saveregs (arglist)
2398      tree arglist;
2399 {
2400   rtx block, addr, dest, argsize;
2401   tree fntype = TREE_TYPE (current_function_decl);
2402   int stdarg = (TYPE_ARG_TYPES (fntype) != 0
2403                 && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
2404                     != void_type_node));
2405
2406   /* Compute the current position into the args, taking into account
2407      both registers and memory.  Both of these are already included in
2408      NUM_ARGS.  */
2409
2410   argsize = GEN_INT (NUM_ARGS * UNITS_PER_WORD);
2411
2412   /* For Unix, SETUP_INCOMING_VARARGS moves the starting address base up by 48,
2413      storing fp arg registers in the first 48 bytes, and the integer arg
2414      registers in the next 48 bytes.  This is only done, however, if any
2415      integer registers need to be stored.
2416
2417      If no integer registers need be stored, then we must subtract 48 in
2418      order to account for the integer arg registers which are counted in
2419      argsize above, but which are not actually stored on the stack.  */
2420
2421   if (TARGET_OPEN_VMS)
2422     addr = plus_constant (virtual_incoming_args_rtx,
2423                           NUM_ARGS <= 5 + stdarg
2424                           ? UNITS_PER_WORD : - 6 * UNITS_PER_WORD);
2425   else
2426     addr = (NUM_ARGS <= 5 + stdarg
2427             ? plus_constant (virtual_incoming_args_rtx,
2428                              6 * UNITS_PER_WORD)
2429             : plus_constant (virtual_incoming_args_rtx,
2430                              - (6 * UNITS_PER_WORD)));
2431
2432   /* For VMS, we include the argsize, while on Unix, it's handled as
2433      a separate field.  */
2434   if (TARGET_OPEN_VMS)
2435     addr = plus_constant (addr, INTVAL (argsize));
2436
2437   addr = force_operand (addr, NULL_RTX);
2438
2439 #ifdef POINTERS_EXTEND_UNSIGNED
2440   addr = convert_memory_address (ptr_mode, addr);
2441 #endif
2442
2443   if (TARGET_OPEN_VMS)
2444     return addr;
2445   else
2446     {
2447       /* Allocate the va_list constructor */
2448       block = assign_stack_local (BLKmode, 2 * UNITS_PER_WORD, BITS_PER_WORD);
2449       RTX_UNCHANGING_P (block) = 1;
2450       RTX_UNCHANGING_P (XEXP (block, 0)) = 1;
2451
2452       /* Store the address of the first integer register in the __base
2453          member.  */
2454
2455       dest = change_address (block, ptr_mode, XEXP (block, 0));
2456       emit_move_insn (dest, addr);
2457
2458       if (flag_check_memory_usage)
2459         emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
2460                            dest, ptr_mode,
2461                            GEN_INT (GET_MODE_SIZE (ptr_mode)),
2462                            TYPE_MODE (sizetype),
2463                            GEN_INT (MEMORY_USE_RW),
2464                            TYPE_MODE (integer_type_node));
2465
2466       /* Store the argsize as the __va_offset member.  */
2467       dest = change_address (block, TYPE_MODE (integer_type_node),
2468                              plus_constant (XEXP (block, 0),
2469                                             POINTER_SIZE/BITS_PER_UNIT));
2470       emit_move_insn (dest, argsize);
2471
2472       if (flag_check_memory_usage)
2473         emit_library_call (chkr_set_right_libfunc, 1, VOIDmode, 3,
2474                            dest, ptr_mode,
2475                            GEN_INT (GET_MODE_SIZE
2476                                     (TYPE_MODE (integer_type_node))),
2477                            TYPE_MODE (sizetype),
2478                            GEN_INT (MEMORY_USE_RW),
2479                            TYPE_MODE (integer_type_node));
2480
2481       /* Return the address of the va_list constructor, but don't put it in a
2482          register.  Doing so would fail when not optimizing and produce worse
2483          code when optimizing.  */
2484       return XEXP (block, 0);
2485     }
2486 }
2487 \f
2488 /* This page contains routines that are used to determine what the function
2489    prologue and epilogue code will do and write them out.  */
2490
2491 /* Compute the size of the save area in the stack.  */
2492
2493 #if OPEN_VMS
2494
2495 /* These variables are used for communication between the following functions.
2496    They indicate various things about the current function being compiled
2497    that are used to tell what kind of prologue, epilogue and procedure
2498    descriptior to generate. */
2499
2500 /* Nonzero if we need a stack procedure.  */
2501 static int is_stack_procedure;
2502
2503 /* Register number (either FP or SP) that is used to unwind the frame.  */
2504 static int unwind_regno;
2505
2506 /* Register number used to save FP.  We need not have one for RA since
2507    we don't modify it for register procedures.  This is only defined
2508    for register frame procedures.  */
2509 static int save_fp_regno;
2510
2511 /* Register number used to reference objects off our PV.  */
2512 static int base_regno;
2513
2514 /*  Compute register masks for saved registers.  */
2515
2516 static void
2517 alpha_sa_mask (imaskP, fmaskP)
2518     unsigned long *imaskP;
2519     unsigned long *fmaskP;
2520 {
2521   unsigned long imask = 0;
2522   unsigned long fmask = 0;
2523   int i;
2524
2525   if (is_stack_procedure)
2526     imask |= (1L << HARD_FRAME_POINTER_REGNUM);
2527
2528   /* One for every register we have to save.  */
2529
2530   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2531     if (! fixed_regs[i] && ! call_used_regs[i]
2532         && regs_ever_live[i] && i != REG_RA)
2533       {
2534         if (i < 32)
2535           imask |= (1L << i);
2536         else
2537           fmask |= (1L << (i - 32));
2538       }
2539
2540   *imaskP = imask;
2541   *fmaskP = fmask;
2542
2543   return;
2544 }
2545
2546 int
2547 alpha_sa_size ()
2548 {
2549   int sa_size = 0;
2550   HOST_WIDE_INT stack_needed;
2551   int i;
2552
2553   /* One for every register we have to save.  */
2554
2555   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2556     if (! fixed_regs[i] && ! call_used_regs[i]
2557         && regs_ever_live[i] && i != REG_RA)
2558       sa_size++;
2559
2560   /* Start by assuming we can use a register procedure if we don't make any
2561      calls (REG_RA not used) or need to save any registers and a stack
2562      procedure if we do.  */
2563   is_stack_procedure = sa_size != 0 || alpha_ra_ever_killed ();
2564
2565   /* Decide whether to refer to objects off our PV via FP or PV.
2566      If we need need FP for something else or if we receive a nonlocal
2567      goto (which expects PV to contain the value), we must use PV.
2568      Otherwise, start by assuming we can use FP.  */
2569   base_regno = (frame_pointer_needed || current_function_has_nonlocal_label
2570                 || is_stack_procedure
2571                 || current_function_outgoing_args_size
2572                 ? REG_PV : HARD_FRAME_POINTER_REGNUM);
2573
2574   /* If we want to copy PV into FP, we need to find some register in which to
2575      save FP.  */
2576
2577   save_fp_regno = -1;
2578
2579   if (base_regno == HARD_FRAME_POINTER_REGNUM)
2580     for (i = 0; i < 32; i++)
2581       if (! fixed_regs[i] && call_used_regs[i] && ! regs_ever_live[i])
2582         save_fp_regno = i;
2583
2584   if (save_fp_regno == -1)
2585     base_regno = REG_PV, is_stack_procedure = 1;
2586
2587   /* Stack unwinding should be done via FP unless we use it for PV.  */
2588   unwind_regno
2589     = base_regno == REG_PV ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM;
2590
2591   /* If this is a stack procedure, allow space for saving FP and RA.  */
2592   if (is_stack_procedure)
2593     sa_size += 2;
2594
2595   return sa_size * 8;
2596 }
2597
2598 int
2599 alpha_pv_save_size ()
2600 {
2601   alpha_sa_size ();
2602   return is_stack_procedure ? 8 : 0;
2603 }
2604
2605 int
2606 alpha_using_fp ()
2607 {
2608   alpha_sa_size ();
2609   return unwind_regno == HARD_FRAME_POINTER_REGNUM;
2610 }
2611
2612 #else /* ! OPEN_VMS */
2613
2614 int
2615 alpha_sa_size ()
2616 {
2617   int size = 0;
2618   int i;
2619
2620   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
2621     if (! fixed_regs[i] && ! call_used_regs[i]
2622         && regs_ever_live[i] && i != REG_RA)
2623       size++;
2624
2625   /* If some registers were saved but not reg 26, reg 26 must also
2626      be saved, so leave space for it.  */
2627   if (size != 0 || alpha_ra_ever_killed ())
2628     size++;
2629
2630   /* Our size must be even (multiple of 16 bytes).  */
2631   if (size & 1)
2632     size ++;
2633
2634   return size * 8;
2635 }
2636
2637 #endif /* ! OPEN_VMS */
2638
2639 /* Return 1 if this function can directly return via $26.  */
2640
2641 int
2642 direct_return ()
2643 {
2644   return (! TARGET_OPEN_VMS && reload_completed && alpha_sa_size () == 0
2645           && get_frame_size () == 0
2646           && current_function_outgoing_args_size == 0
2647           && current_function_pretend_args_size == 0);
2648 }
2649
2650 /* Write a version stamp.  Don't write anything if we are running as a
2651    cross-compiler.  Otherwise, use the versions in /usr/include/stamp.h.  */
2652
2653 #if !defined(CROSS_COMPILE) && !defined(_WIN32) && !defined(__linux__) && !defined(VMS)
2654 #include <stamp.h>
2655 #endif
2656
2657 void
2658 alpha_write_verstamp (file)
2659      FILE *file;
2660 {
2661 #ifdef MS_STAMP
2662   fprintf (file, "\t.verstamp %d %d\n", MS_STAMP, LS_STAMP);
2663 #endif
2664 }
2665 \f
2666 /* Write code to add constant C to register number IN_REG (possibly 31)
2667    and put the result into OUT_REG.  Use TEMP_REG as a scratch register;
2668    usually this will be OUT_REG, but should not be if OUT_REG is
2669    STACK_POINTER_REGNUM, since it must be updated in a single instruction.
2670    Write the code to FILE.  */
2671
2672 static void
2673 add_long_const (file, c, in_reg, out_reg, temp_reg)
2674      FILE *file;
2675      HOST_WIDE_INT c;
2676      int in_reg, out_reg, temp_reg;
2677 {
2678   HOST_WIDE_INT low = (c & 0xffff) - 2 * (c & 0x8000);
2679   HOST_WIDE_INT tmp1 = c - low;
2680   HOST_WIDE_INT high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
2681   HOST_WIDE_INT extra = 0;
2682
2683   /* We don't have code to write out constants larger than 32 bits.  */
2684 #if HOST_BITS_PER_LONG_INT == 64
2685   if ((unsigned HOST_WIDE_INT) c >> 32 != 0)
2686     abort ();
2687 #endif
2688
2689   /* If HIGH will be interpreted as negative, we must adjust it to do two
2690      ldha insns.  Note that we will never be building a negative constant
2691      here.  */
2692
2693   if (high & 0x8000)
2694     {
2695       extra = 0x4000;
2696       tmp1 -= 0x40000000;
2697       high = ((tmp1 >> 16) & 0xffff) - 2 * ((tmp1 >> 16) & 0x8000);
2698     }
2699
2700   if (low != 0)
2701     {
2702       int result_reg = (extra == 0 && high == 0) ? out_reg : temp_reg;
2703
2704       if (low >= 0 && low < 255)
2705         fprintf (file, "\taddq $%d,%d,$%d\n", in_reg, low, result_reg);
2706       else
2707         fprintf (file, "\tlda $%d,%d($%d)\n", result_reg, low, in_reg);
2708
2709       in_reg = result_reg;
2710     }
2711
2712   if (extra)
2713     {
2714       int result_reg = (high == 0) ? out_reg : temp_reg;
2715
2716       fprintf (file, "\tldah $%d,%d($%d)\n", result_reg, extra, in_reg);
2717       in_reg = result_reg;
2718     }
2719
2720   if (high)
2721     fprintf (file, "\tldah $%d,%d($%d)\n", out_reg, high, in_reg);
2722 }
2723
2724 /* Write function prologue.  */
2725
2726 #if OPEN_VMS
2727
2728 /* On vms we have two kinds of functions:
2729
2730    - stack frame (PROC_STACK)
2731         these are 'normal' functions with local vars and which are
2732         calling other functions
2733    - register frame (PROC_REGISTER)
2734         keeps all data in registers, needs no stack
2735
2736    We must pass this to the assembler so it can generate the
2737    proper pdsc (procedure descriptor)
2738    This is done with the '.pdesc' command.
2739
2740    size is the stack size needed for local variables.  */
2741
2742 void
2743 output_prolog (file, size)
2744      FILE *file;
2745      HOST_WIDE_INT size;
2746 {
2747   unsigned long imask = 0;
2748   unsigned long fmask = 0;
2749   /* Stack space needed for pushing registers clobbered by us.  */
2750   HOST_WIDE_INT sa_size;
2751   /* Complete stack size needed.  */
2752   HOST_WIDE_INT frame_size;
2753   /* Offset from base reg to register save area.  */
2754   int rsa_offset = 8;
2755   /* Offset during register save.  */
2756   int reg_offset;
2757   /* Label for the procedure entry.  */
2758   char *entry_label = (char *) alloca (strlen (alpha_function_name) + 6);
2759   int i;
2760
2761   sa_size = alpha_sa_size ();
2762   frame_size
2763     = ALPHA_ROUND (sa_size
2764                    + (is_stack_procedure ? 8 : 0)
2765                    + size + current_function_pretend_args_size);
2766
2767   /* Issue function start and label.  */
2768   fprintf (file, "\t.ent ");
2769   assemble_name (file, alpha_function_name);
2770   fprintf (file, "\n");
2771   sprintf (entry_label, "$%s..en", alpha_function_name);
2772   ASM_OUTPUT_LABEL (file, entry_label);
2773   inside_function = TRUE;
2774
2775   fprintf (file, "\t.base $%d\n", base_regno);
2776
2777   /* Calculate register masks for clobbered registers.  */
2778
2779   if (is_stack_procedure)
2780     alpha_sa_mask (&imask, &fmask);
2781
2782   /* Adjust the stack by the frame size.  If the frame size is > 4096
2783      bytes, we need to be sure we probe somewhere in the first and last
2784      4096 bytes (we can probably get away without the latter test) and
2785      every 8192 bytes in between.  If the frame size is > 32768, we
2786      do this in a loop.  Otherwise, we generate the explicit probe
2787      instructions.
2788
2789      Note that we are only allowed to adjust sp once in the prologue.  */
2790
2791   if (frame_size < 32768)
2792     {
2793       if (frame_size > 4096)
2794         {
2795           int probed = 4096;
2796
2797           fprintf (file, "\tstq $31,-%d($30)\n", probed);
2798
2799           while (probed + 8192 < frame_size)
2800             fprintf (file, "\tstq $31,-%d($30)\n", probed += 8192);
2801
2802           /* We only have to do this probe if we aren't saving registers.  */
2803           if (sa_size == 0 && probed + 4096 < frame_size)
2804             fprintf (file, "\tstq $31,-%d($30)\n", frame_size);
2805         }
2806
2807       if (frame_size != 0)
2808           fprintf (file, "\tlda $30,-%d($30)\n", frame_size);
2809     }
2810   else
2811     {
2812       /* Here we generate code to set R4 to SP + 4096 and set R23 to the
2813          number of 8192 byte blocks to probe.  We then probe each block
2814          in the loop and then set SP to the proper location.  If the
2815          amount remaining is > 4096, we have to do one more probe if we
2816          are not saving any registers.  */
2817
2818       HOST_WIDE_INT blocks = (frame_size + 4096) / 8192;
2819       HOST_WIDE_INT leftover = frame_size + 4096 - blocks * 8192;
2820
2821       add_long_const (file, blocks, 31, 23, 23);
2822
2823       fprintf (file, "\tlda $22,4096($30)\n");
2824
2825       fputc ('$', file);
2826       assemble_name (file, alpha_function_name);
2827       fprintf (file, "..sc:\n");
2828
2829       fprintf (file, "\tstq $31,-8192($22)\n");
2830       fprintf (file, "\tsubq $23,1,$23\n");
2831       fprintf (file, "\tlda $22,-8192($22)\n");
2832
2833       fprintf (file, "\tbne $23,$");
2834       assemble_name (file, alpha_function_name);
2835       fprintf (file, "..sc\n");
2836
2837       if (leftover > 4096 && sa_size == 0)
2838         fprintf (file, "\tstq $31,-%d($22)\n", leftover);
2839
2840       fprintf (file, "\tlda $30,-%d($22)\n", leftover);
2841     }
2842
2843   if (is_stack_procedure)
2844     {
2845       int reg_offset = rsa_offset;
2846
2847       /* Store R26 (RA) first.  */
2848       fprintf (file, "\tstq $26,%d($30)\n", reg_offset);
2849       reg_offset += 8;
2850
2851       /* Store integer regs. according to mask.  */
2852       for (i = 0; i < 32; i++)
2853         if (imask & (1L<<i))
2854           {
2855             fprintf (file, "\tstq $%d,%d($30)\n", i, reg_offset);
2856             reg_offset += 8;
2857           }
2858
2859       /* Print the register mask and do floating-point saves.  */
2860
2861       if (imask)
2862         fprintf (file, "\t.mask 0x%x,0\n", imask);
2863
2864       for (i = 0; i < 32; i++)
2865         {
2866           if (fmask & (1L << i))
2867             {
2868               fprintf (file, "\tstt $f%d,%d($30)\n", i, reg_offset);
2869               reg_offset += 8;
2870             }
2871         }
2872
2873       /* Print the floating-point mask, if we've saved any fp register.  */
2874       if (fmask)
2875         fprintf (file, "\t.fmask 0x%x,0\n", fmask);
2876
2877       fprintf (file, "\tstq $27,0($30)\n");
2878     }
2879   else
2880     {
2881       fprintf (file, "\t.fp_save $%d\n", save_fp_regno);
2882       fprintf (file, "\tbis $%d,$%d,$%d\n", HARD_FRAME_POINTER_REGNUM,
2883                HARD_FRAME_POINTER_REGNUM, save_fp_regno);
2884     }
2885
2886   if (base_regno != REG_PV)
2887     fprintf (file, "\tbis $%d,$%d,$%d\n", REG_PV, REG_PV, base_regno);
2888
2889   if (unwind_regno == HARD_FRAME_POINTER_REGNUM)
2890     fprintf (file, "\tbis $%d,$%d,$%d\n", STACK_POINTER_REGNUM,
2891              STACK_POINTER_REGNUM, HARD_FRAME_POINTER_REGNUM);
2892
2893   /* Describe our frame.  */
2894   fprintf (file, "\t.frame $%d,%d,$26,%d\n",
2895            unwind_regno, frame_size, rsa_offset);
2896
2897   /* If we have to allocate space for outgoing args, do it now.  */
2898   if (current_function_outgoing_args_size != 0)
2899     fprintf (file, "\tlda $%d,%d($%d)\n", STACK_POINTER_REGNUM,
2900              - ALPHA_ROUND (current_function_outgoing_args_size),
2901              HARD_FRAME_POINTER_REGNUM);
2902
2903   fprintf (file, "\t.prologue\n");
2904
2905   link_section ();
2906   fprintf (file, "\t.align 3\n");
2907   ASM_OUTPUT_LABEL (file, alpha_function_name);
2908   fprintf (file, "\t.pdesc $");
2909   assemble_name (file, alpha_function_name);
2910   fprintf (file, "..en,%s\n", is_stack_procedure ? "stack" : "reg");
2911   alpha_need_linkage (alpha_function_name, 1);
2912   text_section ();
2913
2914   return;
2915 }
2916
2917 /* Write function epilogue.  */
2918
2919 void
2920 output_epilog (file, size)
2921      FILE *file;
2922      int size;
2923 {
2924   unsigned long imask = 0;
2925   unsigned long fmask = 0;
2926   /* Stack space needed for pushing registers clobbered by us.  */
2927   HOST_WIDE_INT sa_size = alpha_sa_size ();
2928   /* Complete stack size needed.  */
2929   HOST_WIDE_INT frame_size
2930     = ALPHA_ROUND (sa_size
2931                    + (is_stack_procedure ? 8 : 0)
2932                    + size + current_function_pretend_args_size);
2933   int i;
2934   rtx insn = get_last_insn ();
2935
2936   /* If the last insn was a BARRIER, we don't have to write anything except
2937      the .end pseudo-op.  */
2938
2939   if (GET_CODE (insn) == NOTE)
2940     insn = prev_nonnote_insn (insn);
2941
2942   if (insn == 0 || GET_CODE (insn) != BARRIER)
2943     {
2944       /* Restore clobbered registers, load FP last.  */
2945
2946       if (is_stack_procedure)
2947         {
2948           int rsa_offset = 8;
2949           int reg_offset;
2950           int fp_offset;
2951
2952           if (unwind_regno == HARD_FRAME_POINTER_REGNUM)
2953             fprintf (file, "\tbis $%d,$%d,$%d\n", HARD_FRAME_POINTER_REGNUM,
2954                      HARD_FRAME_POINTER_REGNUM, STACK_POINTER_REGNUM);
2955
2956           alpha_sa_mask (&imask, &fmask);
2957
2958           /* Start reloading registers after RA.  */
2959           reg_offset = rsa_offset + 8;
2960
2961           for (i = 0; i < 32; i++)
2962             if (imask & (1L<<i))
2963               {
2964                 if (i == HARD_FRAME_POINTER_REGNUM)
2965                   fp_offset = reg_offset;
2966                 else
2967                   fprintf (file, "\tldq $%d,%d($30)\n",
2968                                   i, reg_offset);
2969                 reg_offset += 8;
2970               }
2971
2972           for (i = 0; i < 32; i++)
2973             if (fmask & (1L << i))
2974               {
2975                 fprintf (file, "\tldt $f%d,%d($30)\n", i, reg_offset);
2976                 reg_offset += 8;
2977               }
2978
2979           /* Restore R26 (RA).  */
2980           fprintf (file, "\tldq $26,%d($30)\n", rsa_offset);
2981
2982           /* Restore R29 (FP).  */
2983           fprintf (file, "\tldq $29,%d($30)\n", fp_offset);
2984         }
2985       else
2986         fprintf (file, "\tbis $%d,$%d,$%d\n", save_fp_regno, save_fp_regno,
2987                  HARD_FRAME_POINTER_REGNUM);
2988
2989       if (frame_size != 0)
2990         {
2991           if (frame_size < 32768)
2992             fprintf (file, "\tlda $30,%d($30)\n", frame_size);
2993           else
2994             {
2995               long high = frame_size >> 16;
2996               long low = frame_size & 0xffff;
2997               if (low & 0x8000)
2998                 {
2999                   high++;
3000                   low = -32768 + (low & 0x7fff);
3001                 }
3002               fprintf (file, "\tldah $2,%ld($31)\n", high);
3003               fprintf (file, "\tlda $2,%ld($2)\n", low);
3004               fprintf (file, "\taddq $30,$2,$30\n");
3005             }
3006         }
3007
3008       /* Finally return to the caller.  */
3009       fprintf (file, "\tret $31,($26),1\n");
3010     }
3011
3012   /* End the function.  */
3013   fprintf (file, "\t.end ");
3014   assemble_name (file,  alpha_function_name);
3015   fprintf (file, "\n");
3016   inside_function = FALSE;
3017
3018   /* Show that we know this function if it is called again.  */
3019   SYMBOL_REF_FLAG (XEXP (DECL_RTL (current_function_decl), 0)) = 1;
3020 }
3021
3022 int
3023 vms_valid_decl_attribute_p (decl, attributes, identifier, args)
3024      tree decl;
3025      tree attributes;
3026      tree identifier;
3027      tree args;
3028 {
3029   if (is_attribute_p ("overlaid", identifier))
3030     return (args == NULL_TREE);
3031   return 0;
3032 }
3033
3034 #else /* !OPEN_VMS */
3035
3036 static int
3037 alpha_does_function_need_gp ()
3038 {
3039   rtx insn;
3040
3041   /* We never need a GP for Windows/NT.  */
3042   if (TARGET_WINDOWS_NT)
3043     return 0;
3044
3045 #ifdef TARGET_PROFILING_NEEDS_GP
3046   if (profile_flag)
3047     return 1;
3048 #endif
3049
3050   /* If we need a GP (we have a LDSYM insn or a CALL_INSN), load it first.
3051      Even if we are a static function, we still need to do this in case
3052      our address is taken and passed to something like qsort.  */
3053
3054   for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
3055     if (GET_RTX_CLASS (GET_CODE (insn)) == 'i'
3056         && GET_CODE (PATTERN (insn)) != USE
3057         && GET_CODE (PATTERN (insn)) != CLOBBER)
3058       {
3059         enum attr_type type = get_attr_type (insn);
3060         if (type == TYPE_LDSYM || type == TYPE_JSR)
3061           return 1;
3062       }
3063
3064   return 0;
3065 }
3066
3067 void
3068 output_prolog (file, size)
3069      FILE *file;
3070      int size;
3071 {
3072   HOST_WIDE_INT out_args_size
3073     = ALPHA_ROUND (current_function_outgoing_args_size);
3074   HOST_WIDE_INT sa_size = alpha_sa_size ();
3075   HOST_WIDE_INT frame_size
3076     = (out_args_size + sa_size
3077        + ALPHA_ROUND (size + current_function_pretend_args_size));
3078   HOST_WIDE_INT reg_offset = out_args_size;
3079   HOST_WIDE_INT start_reg_offset = reg_offset;
3080   HOST_WIDE_INT actual_start_reg_offset = start_reg_offset;
3081   int int_reg_save_area_size = 0;
3082   unsigned reg_mask = 0;
3083   int i, sa_reg;
3084
3085   /* Ecoff can handle multiple .file directives, so put out file and lineno.
3086      We have to do that before the .ent directive as we cannot switch
3087      files within procedures with native ecoff because line numbers are
3088      linked to procedure descriptors.
3089      Outputting the lineno helps debugging of one line functions as they
3090      would otherwise get no line number at all. Please note that we would
3091      like to put out last_linenum from final.c, but it is not accessible.  */
3092
3093   if (write_symbols == SDB_DEBUG)
3094     {
3095       ASM_OUTPUT_SOURCE_FILENAME (file,
3096                                   DECL_SOURCE_FILE (current_function_decl));
3097       if (debug_info_level != DINFO_LEVEL_TERSE)
3098         ASM_OUTPUT_SOURCE_LINE (file,
3099                                 DECL_SOURCE_LINE (current_function_decl));
3100     }
3101
3102   /* The assembly language programmer's guide states that the second argument
3103      to the .ent directive, the lex_level, is ignored by the assembler,
3104      so we might as well omit it.  */
3105
3106   if (!flag_inhibit_size_directive)
3107     {
3108       fprintf (file, "\t.ent ");
3109       assemble_name (file, alpha_function_name);
3110       fprintf (file, "\n");
3111     }
3112   ASM_OUTPUT_LABEL (file, alpha_function_name);
3113   inside_function = TRUE;
3114
3115   if (TARGET_IEEE_CONFORMANT && !flag_inhibit_size_directive)
3116     /* Set flags in procedure descriptor to request IEEE-conformant
3117        math-library routines.  The value we set it to is PDSC_EXC_IEEE
3118        (/usr/include/pdsc.h). */
3119     fprintf (file, "\t.eflag 48\n");
3120
3121   /* Set up offsets to alpha virtual arg/local debugging pointer.  */
3122
3123   alpha_auto_offset = -frame_size + current_function_pretend_args_size;
3124   alpha_arg_offset = -frame_size + 48;
3125
3126   alpha_function_needs_gp = alpha_does_function_need_gp ();
3127
3128   if (TARGET_WINDOWS_NT == 0)
3129     {
3130       if (alpha_function_needs_gp)
3131         fprintf (file, "\tldgp $29,0($27)\n");
3132
3133       /* Put a label after the GP load so we can enter the function at it.  */
3134       fputc ('$', file);
3135       assemble_name (file, alpha_function_name);
3136       fprintf (file, "..ng:\n");
3137     }
3138
3139   /* Adjust the stack by the frame size.  If the frame size is > 4096
3140      bytes, we need to be sure we probe somewhere in the first and last
3141      4096 bytes (we can probably get away without the latter test) and
3142      every 8192 bytes in between.  If the frame size is > 32768, we
3143      do this in a loop.  Otherwise, we generate the explicit probe
3144      instructions.
3145
3146      Note that we are only allowed to adjust sp once in the prologue.  */
3147
3148   if (frame_size < 32768)
3149     {
3150       if (frame_size > 4096)
3151         {
3152           int probed = 4096;
3153
3154           fprintf (file, "\tstq $31,-%d($30)\n", probed);
3155
3156           while (probed + 8192 < frame_size)
3157             fprintf (file, "\tstq $31,-%d($30)\n", probed += 8192);
3158
3159           /* We only have to do this probe if we aren't saving registers.  */
3160           if (sa_size == 0 && probed + 4096 < frame_size)
3161             fprintf (file, "\tstq $31,-%d($30)\n", frame_size);
3162         }
3163
3164       if (frame_size != 0)
3165         fprintf (file, "\tlda $30,-%d($30)\n", frame_size);
3166     }
3167   else
3168     {
3169       /* Here we generate code to set R4 to SP + 4096 and set R5 to the
3170          number of 8192 byte blocks to probe.  We then probe each block
3171          in the loop and then set SP to the proper location.  If the
3172          amount remaining is > 4096, we have to do one more probe if we
3173          are not saving any registers.  */
3174
3175       HOST_WIDE_INT blocks = (frame_size + 4096) / 8192;
3176       HOST_WIDE_INT leftover = frame_size + 4096 - blocks * 8192;
3177
3178       add_long_const (file, blocks, 31, 5, 5);
3179
3180       fprintf (file, "\tlda $4,4096($30)\n");
3181
3182       fputc ('$', file);
3183       assemble_name (file, alpha_function_name);
3184       fprintf (file, "..sc:\n");
3185
3186       fprintf (file, "\tstq $31,-8192($4)\n");
3187       fprintf (file, "\tsubq $5,1,$5\n");
3188       fprintf (file, "\tlda $4,-8192($4)\n");
3189
3190       fprintf (file, "\tbne $5,$");
3191       assemble_name (file, alpha_function_name);
3192       fprintf (file, "..sc\n");
3193
3194       if (leftover > 4096 && sa_size == 0)
3195         fprintf (file, "\tstq $31,-%d($4)\n", leftover);
3196
3197       fprintf (file, "\tlda $30,-%d($4)\n", leftover);
3198     }
3199
3200   /* Describe our frame.  */
3201   if (!flag_inhibit_size_directive)
3202     {
3203       fprintf (file, "\t.frame $%d,%d,$26,%d\n",
3204                (frame_pointer_needed
3205                 ? HARD_FRAME_POINTER_REGNUM : STACK_POINTER_REGNUM),
3206                frame_size, current_function_pretend_args_size);
3207     }
3208
3209   /* Cope with very large offsets to the register save area.  */
3210   sa_reg = 30;
3211   if (reg_offset + sa_size > 0x8000)
3212     {
3213       int low = ((reg_offset & 0xffff) ^ 0x8000) - 0x8000;
3214       if (low + sa_size <= 0x8000)
3215         {
3216           add_long_const (file, reg_offset - low, 30, 24, 24);
3217           reg_offset = low;
3218         }
3219       else
3220         {
3221           add_long_const (file, reg_offset, 30, 24, 24);
3222           reg_offset = 0;
3223         }
3224       sa_reg = 24;
3225     }
3226
3227   /* Save register RA if any other register needs to be saved.  */
3228   if (sa_size != 0)
3229     {
3230       reg_mask |= 1 << REG_RA;
3231       fprintf (file, "\tstq $26,%d($%d)\n", reg_offset, sa_reg);
3232       reg_offset += 8;
3233       int_reg_save_area_size += 8;
3234     }
3235
3236   /* Now save any other used integer registers required to be saved.  */
3237   for (i = 0; i < 32; i++)
3238     if (! fixed_regs[i] && ! call_used_regs[i]
3239         && regs_ever_live[i] && i != REG_RA)
3240       {
3241         reg_mask |= 1 << i;
3242         fprintf (file, "\tstq $%d,%d($%d)\n", i, reg_offset, sa_reg);
3243         reg_offset += 8;
3244         int_reg_save_area_size += 8;
3245       }
3246
3247   /* Print the register mask and do floating-point saves.  */
3248   if (reg_mask && !flag_inhibit_size_directive)
3249     fprintf (file, "\t.mask 0x%x,%d\n", reg_mask,
3250              actual_start_reg_offset - frame_size);
3251
3252   start_reg_offset = reg_offset;
3253   reg_mask = 0;
3254
3255   for (i = 0; i < 32; i++)
3256     if (! fixed_regs[i + 32] && ! call_used_regs[i + 32]
3257         && regs_ever_live[i + 32])
3258       {
3259         reg_mask |= 1 << i;
3260         fprintf (file, "\tstt $f%d,%d($%d)\n", i, reg_offset, sa_reg);
3261         reg_offset += 8;
3262       }
3263
3264   /* Print the floating-point mask, if we've saved any fp register.  */
3265   if (reg_mask && !flag_inhibit_size_directive)
3266     fprintf (file, "\t.fmask 0x%x,%d\n", reg_mask,
3267              actual_start_reg_offset - frame_size + int_reg_save_area_size);
3268
3269   /* If we need a frame pointer, set it from the stack pointer.  Note that
3270      this must always be the last instruction in the prologue.  */
3271   if (frame_pointer_needed)
3272     fprintf (file, "\tbis $30,$30,$15\n");
3273
3274   /* End the prologue and say if we used gp.  */
3275   if (!flag_inhibit_size_directive)
3276     fprintf (file, "\t.prologue %d\n", alpha_function_needs_gp);
3277 }
3278
3279 /* Write function epilogue.  */
3280
3281 void
3282 output_epilog (file, size)
3283      FILE *file;
3284      int size;
3285 {
3286   rtx insn = get_last_insn ();
3287   HOST_WIDE_INT out_args_size
3288     = ALPHA_ROUND (current_function_outgoing_args_size);
3289   HOST_WIDE_INT sa_size = alpha_sa_size ();
3290   HOST_WIDE_INT frame_size
3291     = (out_args_size + sa_size
3292        + ALPHA_ROUND (size + current_function_pretend_args_size));
3293   HOST_WIDE_INT reg_offset = out_args_size;
3294   HOST_WIDE_INT frame_size_from_reg_save = frame_size - reg_offset;
3295   int restore_fp
3296     = frame_pointer_needed && regs_ever_live[HARD_FRAME_POINTER_REGNUM];
3297   int i;
3298
3299   /* If the last insn was a BARRIER, we don't have to write anything except
3300      the .end pseudo-op.  */
3301   if (GET_CODE (insn) == NOTE)
3302     insn = prev_nonnote_insn (insn);
3303   if (insn == 0 || GET_CODE (insn) != BARRIER)
3304     {
3305       int fp_offset = 0;
3306       int sa_reg;
3307
3308       /* If we have a frame pointer, restore SP from it.  */
3309       if (frame_pointer_needed)
3310         fprintf (file, "\tbis $15,$15,$30\n");
3311
3312       /* Cope with large offsets to the register save area.  */
3313       sa_reg = 30;
3314       if (reg_offset + sa_size > 0x8000)
3315         {
3316           int low = ((reg_offset & 0xffff) ^ 0x8000) - 0x8000;
3317           if (low + sa_size <= 0x8000)
3318             {
3319               add_long_const (file, reg_offset - low, 30, 24, 24);
3320               reg_offset = low;
3321             }
3322           else
3323             {
3324               add_long_const (file, reg_offset, 30, 24, 24);
3325               reg_offset = 0;
3326             }
3327           sa_reg = 24;
3328         }
3329
3330       /* Restore all the registers, starting with the return address
3331          register.  */
3332       if (sa_size != 0)
3333         {
3334           fprintf (file, "\tldq $26,%d($%d)\n", reg_offset, sa_reg);
3335           reg_offset += 8;
3336         }
3337
3338       /* Now restore any other used integer registers that that we saved,
3339          except for FP if it is being used as FP, since it must be
3340          restored last.  */
3341
3342       for (i = 0; i < 32; i++)
3343         if (! fixed_regs[i] && ! call_used_regs[i] && regs_ever_live[i]
3344             && i != 26)
3345           {
3346             if (i == HARD_FRAME_POINTER_REGNUM && frame_pointer_needed)
3347               fp_offset = reg_offset;
3348             else
3349               fprintf (file, "\tldq $%d,%d($%d)\n", i, reg_offset, sa_reg);
3350             reg_offset += 8;
3351           }
3352
3353       for (i = 0; i < 32; i++)
3354         if (! fixed_regs[i + 32] && ! call_used_regs[i + 32]
3355             && regs_ever_live[i + 32])
3356           {
3357             fprintf (file, "\tldt $f%d,%d($%d)\n", i, reg_offset, sa_reg);
3358             reg_offset += 8;
3359           }
3360
3361       /* If the stack size is large and we have a frame pointer, compute the
3362          size of the stack into a register because the old FP restore, stack
3363          pointer adjust, and return are required to be consecutive
3364          instructions.   */
3365       if (frame_size > 32767 && restore_fp)
3366         add_long_const (file, frame_size, 31, 1, 1);
3367
3368       /* If we needed a frame pointer and we have to restore it, do it
3369          now.  This must be done in one instruction immediately
3370          before the SP update.  */
3371       if (restore_fp && fp_offset)
3372         fprintf (file, "\tldq $15,%d($%d)\n", fp_offset, sa_reg);
3373
3374       /* Now update the stack pointer, if needed.  Only one instruction must
3375          modify the stack pointer.  It must be the last instruction in the
3376          sequence and must be an ADDQ or LDA instruction.  If the frame
3377          pointer was loaded above, we may only put one instruction here.  */
3378
3379       if (frame_size > 32768 && restore_fp)
3380         fprintf  (file, "\taddq $1,$30,$30\n");
3381       else
3382         add_long_const (file, frame_size, 30, 30, 1);
3383
3384       /* Finally return to the caller.  */
3385       fprintf (file, "\tret $31,($26),1\n");
3386     }
3387
3388   /* End the function.  */
3389   if (!flag_inhibit_size_directive)
3390     {
3391       fprintf (file, "\t.end ");
3392       assemble_name (file, alpha_function_name);
3393       fprintf (file, "\n");
3394     }
3395   inside_function = FALSE;
3396
3397   /* Show that we know this function if it is called again.  */
3398   SYMBOL_REF_FLAG (XEXP (DECL_RTL (current_function_decl), 0)) = 1;
3399 }
3400 #endif /* !OPEN_VMS */
3401 \f
3402 /* Debugging support.  */
3403
3404 #include "gstab.h"
3405
3406 /* Count the number of sdb related labels are generated (to find block
3407    start and end boundaries).  */
3408
3409 int sdb_label_count = 0;
3410
3411 /* Next label # for each statement.  */
3412
3413 static int sym_lineno = 0;
3414
3415 /* Count the number of .file directives, so that .loc is up to date.  */
3416
3417 static int num_source_filenames = 0;
3418
3419 /* Name of the file containing the current function.  */
3420
3421 static char *current_function_file = "";
3422
3423 /* Offsets to alpha virtual arg/local debugging pointers.  */
3424
3425 long alpha_arg_offset;
3426 long alpha_auto_offset;
3427 \f
3428 /* Emit a new filename to a stream.  */
3429
3430 void
3431 alpha_output_filename (stream, name)
3432      FILE *stream;
3433      char *name;
3434 {
3435   static int first_time = TRUE;
3436   char ltext_label_name[100];
3437
3438   if (first_time)
3439     {
3440       first_time = FALSE;
3441       ++num_source_filenames;
3442       current_function_file = name;
3443       fprintf (stream, "\t.file\t%d ", num_source_filenames);
3444       output_quoted_string (stream, name);
3445       fprintf (stream, "\n");
3446       if (!TARGET_GAS && write_symbols == DBX_DEBUG)
3447         fprintf (stream, "\t#@stabs\n");
3448     }
3449
3450   else if (write_symbols == DBX_DEBUG)
3451     {
3452       ASM_GENERATE_INTERNAL_LABEL (ltext_label_name, "Ltext", 0);
3453       fprintf (stream, "%s ", ASM_STABS_OP);
3454       output_quoted_string (stream, name);
3455       fprintf (stream, ",%d,0,0,%s\n", N_SOL, &ltext_label_name[1]);
3456     }
3457
3458   else if (name != current_function_file
3459       && strcmp (name, current_function_file) != 0)
3460     {
3461       if (inside_function && ! TARGET_GAS)
3462         fprintf (stream, "\t#.file\t%d ", num_source_filenames);
3463       else
3464         {
3465           ++num_source_filenames;
3466           current_function_file = name;
3467           fprintf (stream, "\t.file\t%d ", num_source_filenames);
3468         }
3469
3470       output_quoted_string (stream, name);
3471       fprintf (stream, "\n");
3472     }
3473 }
3474 \f
3475 /* Emit a linenumber to a stream.  */
3476
3477 void
3478 alpha_output_lineno (stream, line)
3479      FILE *stream;
3480      int line;
3481 {
3482   if (write_symbols == DBX_DEBUG)
3483     {
3484       /* mips-tfile doesn't understand .stabd directives.  */
3485       ++sym_lineno;
3486       fprintf (stream, "$LM%d:\n\t%s %d,0,%d,$LM%d\n",
3487                sym_lineno, ASM_STABN_OP, N_SLINE, line, sym_lineno);
3488     }
3489   else
3490     fprintf (stream, "\n\t.loc\t%d %d\n", num_source_filenames, line);
3491 }
3492 \f
3493 /* Structure to show the current status of registers and memory.  */
3494
3495 struct shadow_summary
3496 {
3497   struct {
3498     unsigned long i     : 31;   /* Mask of int regs */
3499     unsigned long fp    : 31;   /* Mask of fp regs */
3500     unsigned long mem   :  1;   /* mem == imem | fpmem */
3501   } used, defd;
3502 };
3503
3504 /* Summary the effects of expression X on the machine.  Update SUM, a pointer
3505    to the summary structure.  SET is nonzero if the insn is setting the
3506    object, otherwise zero.  */
3507
3508 static void
3509 summarize_insn (x, sum, set)
3510      rtx x;
3511      struct shadow_summary *sum;
3512      int set;
3513 {
3514   char *format_ptr;
3515   int i, j;
3516
3517   if (x == 0)
3518     return;
3519
3520   switch (GET_CODE (x))
3521     {
3522       /* ??? Note that this case would be incorrect if the Alpha had a
3523          ZERO_EXTRACT in SET_DEST.  */
3524     case SET:
3525       summarize_insn (SET_SRC (x), sum, 0);
3526       summarize_insn (SET_DEST (x), sum, 1);
3527       break;
3528
3529     case CLOBBER:
3530       summarize_insn (XEXP (x, 0), sum, 1);
3531       break;
3532
3533     case USE:
3534       summarize_insn (XEXP (x, 0), sum, 0);
3535       break;
3536
3537     case ASM_OPERANDS:
3538       for (i = ASM_OPERANDS_INPUT_LENGTH (x) - 1; i >= 0; i--)
3539         summarize_insn (ASM_OPERANDS_INPUT (x, i), sum, 0);
3540       break;
3541
3542     case PARALLEL:
3543       for (i = XVECLEN (x, 0) - 1; i >= 0; i--)
3544         summarize_insn (XVECEXP (x, 0, i), sum, 0);
3545       break;
3546
3547     case SUBREG:
3548       x = SUBREG_REG (x);
3549       /* FALLTHRU */
3550
3551     case REG:
3552       {
3553         int regno = REGNO (x);
3554         unsigned long mask = 1UL << (regno % 32);
3555
3556         if (regno == 31 || regno == 63)
3557           break;
3558
3559         if (set)
3560           {
3561             if (regno < 32)
3562               sum->defd.i |= mask;
3563             else
3564               sum->defd.fp |= mask;
3565           }
3566         else
3567           {
3568             if (regno < 32)
3569               sum->used.i  |= mask;
3570             else
3571               sum->used.fp |= mask;
3572           }
3573         }
3574       break;
3575
3576     case MEM:
3577       if (set)
3578         sum->defd.mem = 1;
3579       else
3580         sum->used.mem = 1;
3581
3582       /* Find the regs used in memory address computation: */
3583       summarize_insn (XEXP (x, 0), sum, 0);
3584       break;
3585
3586     case CONST_INT:   case CONST_DOUBLE:
3587     case SYMBOL_REF:  case LABEL_REF:     case CONST:
3588       break;
3589
3590       /* Handle common unary and binary ops for efficiency.  */
3591     case COMPARE:  case PLUS:    case MINUS:   case MULT:      case DIV:
3592     case MOD:      case UDIV:    case UMOD:    case AND:       case IOR:
3593     case XOR:      case ASHIFT:  case ROTATE:  case ASHIFTRT:  case LSHIFTRT:
3594     case ROTATERT: case SMIN:    case SMAX:    case UMIN:      case UMAX:
3595     case NE:       case EQ:      case GE:      case GT:        case LE:
3596     case LT:       case GEU:     case GTU:     case LEU:       case LTU:
3597       summarize_insn (XEXP (x, 0), sum, 0);
3598       summarize_insn (XEXP (x, 1), sum, 0);
3599       break;
3600
3601     case NEG:  case NOT:  case SIGN_EXTEND:  case ZERO_EXTEND:
3602     case TRUNCATE:  case FLOAT_EXTEND:  case FLOAT_TRUNCATE:  case FLOAT:
3603     case FIX:  case UNSIGNED_FLOAT:  case UNSIGNED_FIX:  case ABS:
3604     case SQRT:  case FFS:
3605       summarize_insn (XEXP (x, 0), sum, 0);
3606       break;
3607
3608     default:
3609       format_ptr = GET_RTX_FORMAT (GET_CODE (x));
3610       for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
3611         switch (format_ptr[i])
3612           {
3613           case 'e':
3614             summarize_insn (XEXP (x, i), sum, 0);
3615             break;
3616
3617           case 'E':
3618             for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3619               summarize_insn (XVECEXP (x, i, j), sum, 0);
3620             break;
3621
3622           default:
3623             abort ();
3624           }
3625     }
3626 }
3627
3628 /* Ensure a sufficient number of `trapb' insns are in the code when the user
3629    requests code with a trap precision of functions or instructions.
3630
3631    In naive mode, when the user requests a trap-precision of "instruction", a
3632    trapb is needed after every instruction that may generate a trap (and after
3633    jsr/bsr instructions, because called functions may import a trap from the
3634    caller).  This ensures that the code is resumption safe but it is also slow.
3635
3636    When optimizations are turned on, we delay issuing a trapb as long as
3637    possible.  In this context, a trap shadow is the sequence of instructions
3638    that starts with a (potentially) trap generating instruction and extends to
3639    the next trapb or call_pal instruction (but GCC never generates call_pal by
3640    itself).  We can delay (and therefore sometimes omit) a trapb subject to the
3641    following conditions:
3642
3643    (a) On entry to the trap shadow, if any Alpha register or memory location
3644    contains a value that is used as an operand value by some instruction in
3645    the trap shadow (live on entry), then no instruction in the trap shadow
3646    may modify the register or memory location.
3647
3648    (b) Within the trap shadow, the computation of the base register for a
3649    memory load or store instruction may not involve using the result
3650    of an instruction that might generate an UNPREDICTABLE result.
3651
3652    (c) Within the trap shadow, no register may be used more than once as a
3653    destination register.  (This is to make life easier for the trap-handler.)
3654
3655    (d) The trap shadow may not include any branch instructions.  */
3656
3657 static void
3658 alpha_handle_trap_shadows (insns)
3659      rtx insns;
3660 {
3661   struct shadow_summary shadow;
3662   int trap_pending, exception_nesting;
3663   rtx i;
3664
3665   if (alpha_tp == ALPHA_TP_PROG && !flag_exceptions)
3666     return;
3667
3668   trap_pending = 0;
3669   exception_nesting = 0;
3670   shadow.used.i = 0;
3671   shadow.used.fp = 0;
3672   shadow.used.mem = 0;
3673   shadow.defd = shadow.used;
3674
3675   for (i = insns; i ; i = NEXT_INSN (i))
3676     {
3677       if (GET_CODE (i) == NOTE)
3678         {
3679           switch (NOTE_LINE_NUMBER (i))
3680             {
3681             case NOTE_INSN_EH_REGION_BEG:
3682               exception_nesting++;
3683               if (trap_pending)
3684                 goto close_shadow;
3685               break;
3686
3687             case NOTE_INSN_EH_REGION_END:
3688               exception_nesting--;
3689               if (trap_pending)
3690                 goto close_shadow;
3691               break;
3692
3693             case NOTE_INSN_EPILOGUE_BEG:
3694               if (trap_pending && alpha_tp >= ALPHA_TP_FUNC)
3695                 goto close_shadow;
3696               break;
3697             }
3698         }
3699       else if (trap_pending)
3700         {
3701           if (alpha_tp == ALPHA_TP_FUNC)
3702             {
3703               if (GET_CODE (i) == JUMP_INSN
3704                   && GET_CODE (PATTERN (i)) == RETURN)
3705                 goto close_shadow;
3706             }
3707           else if (alpha_tp == ALPHA_TP_INSN)
3708             {
3709               if (optimize > 0)
3710                 {
3711                   struct shadow_summary sum;
3712
3713                   sum.used.i = 0;
3714                   sum.used.fp = 0;
3715                   sum.used.mem = 0;
3716                   sum.defd = sum.used;
3717
3718                   switch (GET_CODE (i))
3719                     {
3720                     case INSN:
3721                       /* Annoyingly, get_attr_trap will abort on USE.  */
3722                       if (GET_CODE (PATTERN (i)) == USE)
3723                         break;
3724
3725                       summarize_insn (PATTERN (i), &sum, 0);
3726
3727                       if ((sum.defd.i & shadow.defd.i)
3728                           || (sum.defd.fp & shadow.defd.fp))
3729                         {
3730                           /* (c) would be violated */
3731                           goto close_shadow;
3732                         }
3733
3734                       /* Combine shadow with summary of current insn: */
3735                       shadow.used.i   |= sum.used.i;
3736                       shadow.used.fp  |= sum.used.fp;
3737                       shadow.used.mem |= sum.used.mem;
3738                       shadow.defd.i   |= sum.defd.i;
3739                       shadow.defd.fp  |= sum.defd.fp;
3740                       shadow.defd.mem |= sum.defd.mem;
3741
3742                       if ((sum.defd.i & shadow.used.i)
3743                           || (sum.defd.fp & shadow.used.fp)
3744                           || (sum.defd.mem & shadow.used.mem))
3745                         {
3746                           /* (a) would be violated (also takes care of (b))  */
3747                           if (get_attr_trap (i) == TRAP_YES
3748                               && ((sum.defd.i & sum.used.i)
3749                                   || (sum.defd.fp & sum.used.fp)))
3750                             abort ();
3751
3752                           goto close_shadow;
3753                         }
3754                       break;
3755
3756                     case JUMP_INSN:
3757                     case CALL_INSN:
3758                     case CODE_LABEL:
3759                       goto close_shadow;
3760
3761                     default:
3762                       abort ();
3763                     }
3764                 }
3765               else
3766                 {
3767                 close_shadow:
3768                   emit_insn_before (gen_trapb (), i);
3769                   trap_pending = 0;
3770                   shadow.used.i = 0;
3771                   shadow.used.fp = 0;
3772                   shadow.used.mem = 0;
3773                   shadow.defd = shadow.used;
3774                 }
3775             }
3776         }
3777
3778       if ((exception_nesting > 0 || alpha_tp >= ALPHA_TP_FUNC)
3779           && GET_CODE (i) == INSN
3780           && GET_CODE (PATTERN (i)) != USE
3781           && GET_CODE (PATTERN (i)) != CLOBBER
3782           && get_attr_trap (i) == TRAP_YES)
3783         {
3784           if (optimize && !trap_pending)
3785             summarize_insn (PATTERN (i), &shadow, 0);
3786           trap_pending = 1;
3787         }
3788     }
3789 }
3790
3791 /* Machine dependant reorg pass.  */
3792
3793 void
3794 alpha_reorg (insns)
3795      rtx insns;
3796 {
3797   alpha_handle_trap_shadows (insns);
3798 }
3799
3800 \f
3801 /* Check a floating-point value for validity for a particular machine mode.  */
3802
3803 static char *float_strings[] =
3804 {
3805   /* These are for FLOAT_VAX.  */
3806    "1.70141173319264430e+38", /* 2^127 (2^24 - 1) / 2^24 */
3807   "-1.70141173319264430e+38",
3808    "2.93873587705571877e-39", /* 2^-128 */
3809   "-2.93873587705571877e-39",
3810   /* These are for the default broken IEEE mode, which traps
3811      on infinity or denormal numbers.  */
3812    "3.402823466385288598117e+38", /* 2^128 (1 - 2^-24) */
3813   "-3.402823466385288598117e+38",
3814    "1.1754943508222875079687e-38", /* 2^-126 */
3815   "-1.1754943508222875079687e-38",
3816 };
3817
3818 static REAL_VALUE_TYPE float_values[8];
3819 static int inited_float_values = 0;
3820
3821 int
3822 check_float_value (mode, d, overflow)
3823      enum machine_mode mode;
3824      REAL_VALUE_TYPE *d;
3825      int overflow;
3826 {
3827
3828   if (TARGET_IEEE || TARGET_IEEE_CONFORMANT || TARGET_IEEE_WITH_INEXACT)
3829     return 0;
3830
3831   if (inited_float_values == 0)
3832     {
3833       int i;
3834       for (i = 0; i < 8; i++)
3835         float_values[i] = REAL_VALUE_ATOF (float_strings[i], DFmode);
3836
3837       inited_float_values = 1;
3838     }
3839
3840   if (mode == SFmode)
3841     {
3842       REAL_VALUE_TYPE r;
3843       REAL_VALUE_TYPE *fvptr;
3844
3845       if (TARGET_FLOAT_VAX)
3846         fvptr = &float_values[0];
3847       else
3848         fvptr = &float_values[4];
3849
3850       bcopy ((char *) d, (char *) &r, sizeof (REAL_VALUE_TYPE));
3851       if (REAL_VALUES_LESS (fvptr[0], r))
3852         {
3853           bcopy ((char *) &fvptr[0], (char *) d,
3854                  sizeof (REAL_VALUE_TYPE));
3855           return 1;
3856         }
3857       else if (REAL_VALUES_LESS (r, fvptr[1]))
3858         {
3859           bcopy ((char *) &fvptr[1], (char *) d,
3860                  sizeof (REAL_VALUE_TYPE));
3861           return 1;
3862         }
3863       else if (REAL_VALUES_LESS (dconst0, r)
3864                 && REAL_VALUES_LESS (r, fvptr[2]))
3865         {
3866           bcopy ((char *) &dconst0, (char *) d, sizeof (REAL_VALUE_TYPE));
3867           return 1;
3868         }
3869       else if (REAL_VALUES_LESS (r, dconst0)
3870                 && REAL_VALUES_LESS (fvptr[3], r))
3871         {
3872           bcopy ((char *) &dconst0, (char *) d, sizeof (REAL_VALUE_TYPE));
3873           return 1;
3874         }
3875     }
3876
3877   return 0;
3878 }
3879
3880 #if OPEN_VMS
3881
3882 /* Return the VMS argument type corresponding to MODE.  */
3883
3884 enum avms_arg_type
3885 alpha_arg_type (mode)
3886      enum machine_mode mode;
3887 {
3888   switch (mode)
3889     {
3890     case SFmode:
3891       return TARGET_FLOAT_VAX ? FF : FS;
3892     case DFmode:
3893       return TARGET_FLOAT_VAX ? FD : FT;
3894     default:
3895       return I64;
3896     }
3897 }
3898
3899 /* Return an rtx for an integer representing the VMS Argument Information
3900    register value.  */
3901
3902 struct rtx_def *
3903 alpha_arg_info_reg_val (cum)
3904      CUMULATIVE_ARGS cum;
3905 {
3906   unsigned HOST_WIDE_INT regval = cum.num_args;
3907   int i;
3908
3909   for (i = 0; i < 6; i++)
3910     regval |= ((int) cum.atypes[i]) << (i * 3 + 8);
3911
3912   return GEN_INT (regval);
3913 }
3914 \f
3915 /* Structure to collect function names for final output
3916    in link section.  */
3917
3918 enum links_kind {KIND_UNUSED, KIND_LOCAL, KIND_EXTERN};
3919
3920
3921 struct alpha_links {
3922   struct alpha_links *next;
3923   char *name;
3924   enum links_kind kind;
3925 };
3926
3927 static struct alpha_links *alpha_links_base = 0;
3928
3929 /* Make (or fake) .linkage entry for function call.
3930
3931    IS_LOCAL is 0 if name is used in call, 1 if name is used in definition.  */
3932
3933 void
3934 alpha_need_linkage (name, is_local)
3935     char *name;
3936     int is_local;
3937 {
3938   rtx x;
3939   struct alpha_links *lptr, *nptr;
3940
3941   if (name[0] == '*')
3942     name++;
3943
3944   /* Is this name already defined ?  */
3945
3946   for (lptr = alpha_links_base; lptr; lptr = lptr->next)
3947     if (strcmp (lptr->name, name) == 0)
3948       {
3949         if (is_local)
3950           {
3951             /* Defined here but external assumed.  */
3952             if (lptr->kind == KIND_EXTERN)
3953               lptr->kind = KIND_LOCAL;
3954           }
3955         else
3956           {
3957             /* Used here but unused assumed.  */
3958             if (lptr->kind == KIND_UNUSED)
3959               lptr->kind = KIND_LOCAL;
3960           }
3961         return;
3962       }
3963
3964   nptr = (struct alpha_links *) xmalloc (sizeof (struct alpha_links));
3965   nptr->next = alpha_links_base;
3966   nptr->name = xstrdup (name);
3967
3968   /* Assume external if no definition.  */
3969   nptr->kind = (is_local ? KIND_UNUSED : KIND_EXTERN);
3970
3971   /* Ensure we have an IDENTIFIER so assemble_name can mark is used.  */
3972   get_identifier (name);
3973
3974   alpha_links_base = nptr;
3975
3976   return;
3977 }
3978
3979
3980 void
3981 alpha_write_linkage (stream)
3982     FILE *stream;
3983 {
3984   struct alpha_links *lptr, *nptr;
3985
3986   readonly_section ();
3987
3988   fprintf (stream, "\t.align 3\n");
3989
3990   for (lptr = alpha_links_base; lptr; lptr = nptr)
3991     {
3992       nptr = lptr->next;
3993
3994       if (lptr->kind == KIND_UNUSED
3995           || ! TREE_SYMBOL_REFERENCED (get_identifier (lptr->name)))
3996         continue;
3997
3998       fprintf (stream, "$%s..lk:\n", lptr->name);
3999       if (lptr->kind == KIND_LOCAL)
4000         {
4001           /*  Local and used, build linkage pair.  */
4002           fprintf (stream, "\t.quad $%s..en\n", lptr->name);
4003           fprintf (stream, "\t.quad %s\n", lptr->name);
4004         }
4005       else
4006         /* External and used, request linkage pair.  */
4007         fprintf (stream, "\t.linkage %s\n", lptr->name);
4008     }
4009 }
4010
4011 #else
4012
4013 void
4014 alpha_need_linkage (name, is_local)
4015      char *name;
4016      int is_local;
4017 {
4018 }
4019
4020 #endif /* OPEN_VMS */
4021