gcc/config/pa/pa.c

   1 /* Subroutines for insn-output.c for HPPA.
   2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001,
   3    2002, 2003, 2004, 2005 Free Software Foundation, Inc.
   4    Contributed by Tim Moore (moore@cs.utah.edu), based on sparc.c
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify
   9 it under the terms of the GNU General Public License as published by
  10 the Free Software Foundation; either version 2, or (at your option)
  11 any later version.
  12
  13 GCC is distributed in the hope that it will be useful,
  14 but WITHOUT ANY WARRANTY; without even the implied warranty of
  15 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  16 GNU General Public License for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING.  If not, write to
  20 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  21 Boston, MA 02110-1301, USA.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "rtl.h"
  28 #include "regs.h"
  29 #include "hard-reg-set.h"
  30 #include "real.h"
  31 #include "insn-config.h"
  32 #include "conditions.h"
  33 #include "insn-attr.h"
  34 #include "flags.h"
  35 #include "tree.h"
  36 #include "output.h"
  37 #include "except.h"
  38 #include "expr.h"
  39 #include "optabs.h"
  40 #include "reload.h"
  41 #include "integrate.h"
  42 #include "function.h"
  43 #include "toplev.h"
  44 #include "ggc.h"
  45 #include "recog.h"
  46 #include "predict.h"
  47 #include "tm_p.h"
  48 #include "target.h"
  49 #include "target-def.h"
  50
  51 /* Return nonzero if there is a bypass for the output of
  52    OUT_INSN and the fp store IN_INSN.  */
  53 int
  54 hppa_fpstore_bypass_p (rtx out_insn, rtx in_insn)
  55 {
  56   enum machine_mode store_mode;
  57   enum machine_mode other_mode;
  58   rtx set;
  59
  60   if (recog_memoized (in_insn) < 0
  61       || get_attr_type (in_insn) != TYPE_FPSTORE
  62       || recog_memoized (out_insn) < 0)
  63     return 0;
  64
  65   store_mode = GET_MODE (SET_SRC (PATTERN (in_insn)));
  66
  67   set = single_set (out_insn);
  68   if (!set)
  69     return 0;
  70
  71   other_mode = GET_MODE (SET_SRC (set));
  72
  73   return (GET_MODE_SIZE (store_mode) == GET_MODE_SIZE (other_mode));
  74 }
  75
  76
  77 #ifndef DO_FRAME_NOTES
  78 #ifdef INCOMING_RETURN_ADDR_RTX
  79 #define DO_FRAME_NOTES 1
  80 #else
  81 #define DO_FRAME_NOTES 0
  82 #endif
  83 #endif
  84
  85 static void copy_reg_pointer (rtx, rtx);
  86 static void fix_range (const char *);
  87 static bool pa_handle_option (size_t, const char *, int);
  88 static int hppa_address_cost (rtx);
  89 static bool hppa_rtx_costs (rtx, int, int, int *);
  90 static inline rtx force_mode (enum machine_mode, rtx);
  91 static void pa_reorg (void);
  92 static void pa_combine_instructions (void);
  93 static int pa_can_combine_p (rtx, rtx, rtx, int, rtx, rtx, rtx);
  94 static int forward_branch_p (rtx);
  95 static void compute_zdepwi_operands (unsigned HOST_WIDE_INT, unsigned *);
  96 static int compute_movmem_length (rtx);
  97 static int compute_clrmem_length (rtx);
  98 static bool pa_assemble_integer (rtx, unsigned int, int);
  99 static void remove_useless_addtr_insns (int);
 100 static void store_reg (int, HOST_WIDE_INT, int);
 101 static void store_reg_modify (int, int, HOST_WIDE_INT);
 102 static void load_reg (int, HOST_WIDE_INT, int);
 103 static void set_reg_plus_d (int, int, HOST_WIDE_INT, int);
 104 static void pa_output_function_prologue (FILE *, HOST_WIDE_INT);
 105 static void update_total_code_bytes (int);
 106 static void pa_output_function_epilogue (FILE *, HOST_WIDE_INT);
 107 static int pa_adjust_cost (rtx, rtx, rtx, int);
 108 static int pa_adjust_priority (rtx, int);
 109 static int pa_issue_rate (void);
 110 static void pa_select_section (tree, int, unsigned HOST_WIDE_INT)
 111      ATTRIBUTE_UNUSED;
 112 static void pa_encode_section_info (tree, rtx, int);
 113 static const char *pa_strip_name_encoding (const char *);
 114 static bool pa_function_ok_for_sibcall (tree, tree);
 115 static void pa_globalize_label (FILE *, const char *)
 116      ATTRIBUTE_UNUSED;
 117 static void pa_asm_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
 118                                     HOST_WIDE_INT, tree);
 119 #if !defined(USE_COLLECT2)
 120 static void pa_asm_out_constructor (rtx, int);
 121 static void pa_asm_out_destructor (rtx, int);
 122 #endif
 123 static void pa_init_builtins (void);
 124 static rtx hppa_builtin_saveregs (void);
 125 static tree hppa_gimplify_va_arg_expr (tree, tree, tree *, tree *);
 126 static bool pa_scalar_mode_supported_p (enum machine_mode);
 127 static void copy_fp_args (rtx) ATTRIBUTE_UNUSED;
 128 static int length_fp_args (rtx) ATTRIBUTE_UNUSED;
 129 static struct deferred_plabel *get_plabel (rtx) ATTRIBUTE_UNUSED;
 130 static inline void pa_file_start_level (void) ATTRIBUTE_UNUSED;
 131 static inline void pa_file_start_space (int) ATTRIBUTE_UNUSED;
 132 static inline void pa_file_start_file (int) ATTRIBUTE_UNUSED;
 133 static inline void pa_file_start_mcount (const char*) ATTRIBUTE_UNUSED;
 134 static void pa_elf_file_start (void) ATTRIBUTE_UNUSED;
 135 static void pa_som_file_start (void) ATTRIBUTE_UNUSED;
 136 static void pa_linux_file_start (void) ATTRIBUTE_UNUSED;
 137 static void pa_hpux64_gas_file_start (void) ATTRIBUTE_UNUSED;
 138 static void pa_hpux64_hpas_file_start (void) ATTRIBUTE_UNUSED;
 139 static void output_deferred_plabels (void);
 140 #ifdef ASM_OUTPUT_EXTERNAL_REAL
 141 static void pa_hpux_file_end (void);
 142 #endif
 143 #ifdef HPUX_LONG_DOUBLE_LIBRARY
 144 static void pa_hpux_init_libfuncs (void);
 145 #endif
 146 static rtx pa_struct_value_rtx (tree, int);
 147 static bool pa_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
 148                                   tree, bool);
 149 static int pa_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
 150                                  tree, bool);
 151 static struct machine_function * pa_init_machine_status (void);
 152
 153
 154 /* Save the operands last given to a compare for use when we
 155    generate a scc or bcc insn.  */
 156 rtx hppa_compare_op0, hppa_compare_op1;
 157 enum cmp_type hppa_branch_type;
 158
 159 /* Which cpu we are scheduling for.  */
 160 enum processor_type pa_cpu = TARGET_SCHED_DEFAULT;
 161
 162 /* The UNIX standard to use for predefines and linking.  */
 163 int flag_pa_unix = TARGET_HPUX_11_11 ? 1998 : TARGET_HPUX_10_10 ? 1995 : 1993;
 164
 165 /* Counts for the number of callee-saved general and floating point
 166    registers which were saved by the current function's prologue.  */
 167 static int gr_saved, fr_saved;
 168
 169 static rtx find_addr_reg (rtx);
 170
 171 /* Keep track of the number of bytes we have output in the CODE subspace
 172    during this compilation so we'll know when to emit inline long-calls.  */
 173 unsigned long total_code_bytes;
 174
 175 /* The last address of the previous function plus the number of bytes in
 176    associated thunks that have been output.  This is used to determine if
 177    a thunk can use an IA-relative branch to reach its target function.  */
 178 static int last_address;
 179
 180 /* Variables to handle plabels that we discover are necessary at assembly
 181    output time.  They are output after the current function.  */
 182 struct deferred_plabel GTY(())
 183 {
 184   rtx internal_label;
 185   rtx symbol;
 186 };
 187 static GTY((length ("n_deferred_plabels"))) struct deferred_plabel *
 188   deferred_plabels;
 189 static size_t n_deferred_plabels = 0;
 190
 191 \f
 192 /* Initialize the GCC target structure.  */
 193
 194 #undef TARGET_ASM_ALIGNED_HI_OP
 195 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
 196 #undef TARGET_ASM_ALIGNED_SI_OP
 197 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
 198 #undef TARGET_ASM_ALIGNED_DI_OP
 199 #define TARGET_ASM_ALIGNED_DI_OP "\t.dword\t"
 200 #undef TARGET_ASM_UNALIGNED_HI_OP
 201 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
 202 #undef TARGET_ASM_UNALIGNED_SI_OP
 203 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
 204 #undef TARGET_ASM_UNALIGNED_DI_OP
 205 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
 206 #undef TARGET_ASM_INTEGER
 207 #define TARGET_ASM_INTEGER pa_assemble_integer
 208
 209 #undef TARGET_ASM_FUNCTION_PROLOGUE
 210 #define TARGET_ASM_FUNCTION_PROLOGUE pa_output_function_prologue
 211 #undef TARGET_ASM_FUNCTION_EPILOGUE
 212 #define TARGET_ASM_FUNCTION_EPILOGUE pa_output_function_epilogue
 213
 214 #undef TARGET_SCHED_ADJUST_COST
 215 #define TARGET_SCHED_ADJUST_COST pa_adjust_cost
 216 #undef TARGET_SCHED_ADJUST_PRIORITY
 217 #define TARGET_SCHED_ADJUST_PRIORITY pa_adjust_priority
 218 #undef TARGET_SCHED_ISSUE_RATE
 219 #define TARGET_SCHED_ISSUE_RATE pa_issue_rate
 220
 221 #undef TARGET_ENCODE_SECTION_INFO
 222 #define TARGET_ENCODE_SECTION_INFO pa_encode_section_info
 223 #undef TARGET_STRIP_NAME_ENCODING
 224 #define TARGET_STRIP_NAME_ENCODING pa_strip_name_encoding
 225
 226 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
 227 #define TARGET_FUNCTION_OK_FOR_SIBCALL pa_function_ok_for_sibcall
 228
 229 #undef TARGET_ASM_OUTPUT_MI_THUNK
 230 #define TARGET_ASM_OUTPUT_MI_THUNK pa_asm_output_mi_thunk
 231 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 232 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
 233
 234 #undef TARGET_ASM_FILE_END
 235 #ifdef ASM_OUTPUT_EXTERNAL_REAL
 236 #define TARGET_ASM_FILE_END pa_hpux_file_end
 237 #else
 238 #define TARGET_ASM_FILE_END output_deferred_plabels
 239 #endif
 240
 241 #if !defined(USE_COLLECT2)
 242 #undef TARGET_ASM_CONSTRUCTOR
 243 #define TARGET_ASM_CONSTRUCTOR pa_asm_out_constructor
 244 #undef TARGET_ASM_DESTRUCTOR
 245 #define TARGET_ASM_DESTRUCTOR pa_asm_out_destructor
 246 #endif
 247
 248 #undef TARGET_DEFAULT_TARGET_FLAGS
 249 #define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | TARGET_CPU_DEFAULT)
 250 #undef TARGET_HANDLE_OPTION
 251 #define TARGET_HANDLE_OPTION pa_handle_option
 252
 253 #undef TARGET_INIT_BUILTINS
 254 #define TARGET_INIT_BUILTINS pa_init_builtins
 255
 256 #undef TARGET_RTX_COSTS
 257 #define TARGET_RTX_COSTS hppa_rtx_costs
 258 #undef TARGET_ADDRESS_COST
 259 #define TARGET_ADDRESS_COST hppa_address_cost
 260
 261 #undef TARGET_MACHINE_DEPENDENT_REORG
 262 #define TARGET_MACHINE_DEPENDENT_REORG pa_reorg
 263
 264 #ifdef HPUX_LONG_DOUBLE_LIBRARY
 265 #undef TARGET_INIT_LIBFUNCS
 266 #define TARGET_INIT_LIBFUNCS pa_hpux_init_libfuncs
 267 #endif
 268
 269 #undef TARGET_PROMOTE_FUNCTION_RETURN
 270 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
 271 #undef TARGET_PROMOTE_PROTOTYPES
 272 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
 273
 274 #undef TARGET_STRUCT_VALUE_RTX
 275 #define TARGET_STRUCT_VALUE_RTX pa_struct_value_rtx
 276 #undef TARGET_RETURN_IN_MEMORY
 277 #define TARGET_RETURN_IN_MEMORY pa_return_in_memory
 278 #undef TARGET_MUST_PASS_IN_STACK
 279 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
 280 #undef TARGET_PASS_BY_REFERENCE
 281 #define TARGET_PASS_BY_REFERENCE pa_pass_by_reference
 282 #undef TARGET_CALLEE_COPIES
 283 #define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true
 284 #undef TARGET_ARG_PARTIAL_BYTES
 285 #define TARGET_ARG_PARTIAL_BYTES pa_arg_partial_bytes
 286
 287 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
 288 #define TARGET_EXPAND_BUILTIN_SAVEREGS hppa_builtin_saveregs
 289 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 290 #define TARGET_GIMPLIFY_VA_ARG_EXPR hppa_gimplify_va_arg_expr
 291
 292 #undef TARGET_SCALAR_MODE_SUPPORTED_P
 293 #define TARGET_SCALAR_MODE_SUPPORTED_P pa_scalar_mode_supported_p
 294
 295 #undef TARGET_CANNOT_FORCE_CONST_MEM
 296 #define TARGET_CANNOT_FORCE_CONST_MEM pa_tls_referenced_p
 297
 298 struct gcc_target targetm = TARGET_INITIALIZER;
 299 \f
 300 /* Parse the -mfixed-range= option string.  */
 301
 302 static void
 303 fix_range (const char *const_str)
 304 {
 305   int i, first, last;
 306   char *str, *dash, *comma;
 307
 308   /* str must be of the form REG1'-'REG2{,REG1'-'REG} where REG1 and
 309      REG2 are either register names or register numbers.  The effect
 310      of this option is to mark the registers in the range from REG1 to
 311      REG2 as ``fixed'' so they won't be used by the compiler.  This is
 312      used, e.g., to ensure that kernel mode code doesn't use fr4-fr31.  */
 313
 314   i = strlen (const_str);
 315   str = (char *) alloca (i + 1);
 316   memcpy (str, const_str, i + 1);
 317
 318   while (1)
 319     {
 320       dash = strchr (str, '-');
 321       if (!dash)
 322         {
 323           warning (0, "value of -mfixed-range must have form REG1-REG2");
 324           return;
 325         }
 326       *dash = '\0';
 327
 328       comma = strchr (dash + 1, ',');
 329       if (comma)
 330         *comma = '\0';
 331
 332       first = decode_reg_name (str);
 333       if (first < 0)
 334         {
 335           warning (0, "unknown register name: %s", str);
 336           return;
 337         }
 338
 339       last = decode_reg_name (dash + 1);
 340       if (last < 0)
 341         {
 342           warning (0, "unknown register name: %s", dash + 1);
 343           return;
 344         }
 345
 346       *dash = '-';
 347
 348       if (first > last)
 349         {
 350           warning (0, "%s-%s is an empty range", str, dash + 1);
 351           return;
 352         }
 353
 354       for (i = first; i <= last; ++i)
 355         fixed_regs[i] = call_used_regs[i] = 1;
 356
 357       if (!comma)
 358         break;
 359
 360       *comma = ',';
 361       str = comma + 1;
 362     }
 363
 364   /* Check if all floating point registers have been fixed.  */
 365   for (i = FP_REG_FIRST; i <= FP_REG_LAST; i++)
 366     if (!fixed_regs[i])
 367       break;
 368
 369   if (i > FP_REG_LAST)
 370     target_flags |= MASK_DISABLE_FPREGS;
 371 }
 372
 373 /* Implement TARGET_HANDLE_OPTION.  */
 374
 375 static bool
 376 pa_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
 377 {
 378   switch (code)
 379     {
 380     case OPT_mnosnake:
 381     case OPT_mpa_risc_1_0:
 382     case OPT_march_1_0:
 383       target_flags &= ~(MASK_PA_11 | MASK_PA_20);
 384       return true;
 385
 386     case OPT_msnake:
 387     case OPT_mpa_risc_1_1:
 388     case OPT_march_1_1:
 389       target_flags &= ~MASK_PA_20;
 390       target_flags |= MASK_PA_11;
 391       return true;
 392
 393     case OPT_mpa_risc_2_0:
 394     case OPT_march_2_0:
 395       target_flags |= MASK_PA_11 | MASK_PA_20;
 396       return true;
 397
 398     case OPT_mschedule_:
 399       if (strcmp (arg, "8000") == 0)
 400         pa_cpu = PROCESSOR_8000;
 401       else if (strcmp (arg, "7100") == 0)
 402         pa_cpu = PROCESSOR_7100;
 403       else if (strcmp (arg, "700") == 0)
 404         pa_cpu = PROCESSOR_700;
 405       else if (strcmp (arg, "7100LC") == 0)
 406         pa_cpu = PROCESSOR_7100LC;
 407       else if (strcmp (arg, "7200") == 0)
 408         pa_cpu = PROCESSOR_7200;
 409       else if (strcmp (arg, "7300") == 0)
 410         pa_cpu = PROCESSOR_7300;
 411       else
 412         return false;
 413       return true;
 414
 415     case OPT_mfixed_range_:
 416       fix_range (arg);
 417       return true;
 418
 419 #if TARGET_HPUX
 420     case OPT_munix_93:
 421       flag_pa_unix = 1993;
 422       return true;
 423 #endif
 424
 425 #if TARGET_HPUX_10_10
 426     case OPT_munix_95:
 427       flag_pa_unix = 1995;
 428       return true;
 429 #endif
 430
 431 #if TARGET_HPUX_11_11
 432     case OPT_munix_98:
 433       flag_pa_unix = 1998;
 434       return true;
 435 #endif
 436
 437     default:
 438       return true;
 439     }
 440 }
 441
 442 void
 443 override_options (void)
 444 {
 445   /* Unconditional branches in the delay slot are not compatible with dwarf2
 446      call frame information.  There is no benefit in using this optimization
 447      on PA8000 and later processors.  */
 448   if (pa_cpu >= PROCESSOR_8000
 449       || (! USING_SJLJ_EXCEPTIONS && flag_exceptions)
 450       || flag_unwind_tables)
 451     target_flags &= ~MASK_JUMP_IN_DELAY;
 452
 453   if (flag_pic && TARGET_PORTABLE_RUNTIME)
 454     {
 455       warning (0, "PIC code generation is not supported in the portable runtime model");
 456     }
 457
 458   if (flag_pic && TARGET_FAST_INDIRECT_CALLS)
 459    {
 460       warning (0, "PIC code generation is not compatible with fast indirect calls");
 461    }
 462
 463   if (! TARGET_GAS && write_symbols != NO_DEBUG)
 464     {
 465       warning (0, "-g is only supported when using GAS on this processor,");
 466       warning (0, "-g option disabled");
 467       write_symbols = NO_DEBUG;
 468     }
 469
 470   /* We only support the "big PIC" model now.  And we always generate PIC
 471      code when in 64bit mode.  */
 472   if (flag_pic == 1 || TARGET_64BIT)
 473     flag_pic = 2;
 474
 475   /* We can't guarantee that .dword is available for 32-bit targets.  */
 476   if (UNITS_PER_WORD == 4)
 477     targetm.asm_out.aligned_op.di = NULL;
 478
 479   /* The unaligned ops are only available when using GAS.  */
 480   if (!TARGET_GAS)
 481     {
 482       targetm.asm_out.unaligned_op.hi = NULL;
 483       targetm.asm_out.unaligned_op.si = NULL;
 484       targetm.asm_out.unaligned_op.di = NULL;
 485     }
 486
 487   init_machine_status = pa_init_machine_status;
 488 }
 489
 490 static void
 491 pa_init_builtins (void)
 492 {
 493 #ifdef DONT_HAVE_FPUTC_UNLOCKED
 494   built_in_decls[(int) BUILT_IN_FPUTC_UNLOCKED] = NULL_TREE;
 495   implicit_built_in_decls[(int) BUILT_IN_FPUTC_UNLOCKED] = NULL_TREE;
 496 #endif
 497 }
 498
 499 /* Function to init struct machine_function.
 500    This will be called, via a pointer variable,
 501    from push_function_context.  */
 502
 503 static struct machine_function *
 504 pa_init_machine_status (void)
 505 {
 506   return ggc_alloc_cleared (sizeof (machine_function));
 507 }
 508
 509 /* If FROM is a probable pointer register, mark TO as a probable
 510    pointer register with the same pointer alignment as FROM.  */
 511
 512 static void
 513 copy_reg_pointer (rtx to, rtx from)
 514 {
 515   if (REG_POINTER (from))
 516     mark_reg_pointer (to, REGNO_POINTER_ALIGN (REGNO (from)));
 517 }
 518
 519 /* Return 1 if X contains a symbolic expression.  We know these
 520    expressions will have one of a few well defined forms, so
 521    we need only check those forms.  */
 522 int
 523 symbolic_expression_p (rtx x)
 524 {
 525
 526   /* Strip off any HIGH.  */
 527   if (GET_CODE (x) == HIGH)
 528     x = XEXP (x, 0);
 529
 530   return (symbolic_operand (x, VOIDmode));
 531 }
 532
 533 /* Accept any constant that can be moved in one instruction into a
 534    general register.  */
 535 int
 536 cint_ok_for_move (HOST_WIDE_INT intval)
 537 {
 538   /* OK if ldo, ldil, or zdepi, can be used.  */
 539   return (CONST_OK_FOR_LETTER_P (intval, 'J')
 540           || CONST_OK_FOR_LETTER_P (intval, 'N')
 541           || CONST_OK_FOR_LETTER_P (intval, 'K'));
 542 }
 543 \f
 544 /* Return truth value of whether OP can be used as an operand in a
 545    adddi3 insn.  */
 546 int
 547 adddi3_operand (rtx op, enum machine_mode mode)
 548 {
 549   return (register_operand (op, mode)
 550           || (GET_CODE (op) == CONST_INT
 551               && (TARGET_64BIT ? INT_14_BITS (op) : INT_11_BITS (op))));
 552 }
 553
 554 /* True iff zdepi can be used to generate this CONST_INT.
 555    zdepi first sign extends a 5 bit signed number to a given field
 556    length, then places this field anywhere in a zero.  */
 557 int
 558 zdepi_cint_p (unsigned HOST_WIDE_INT x)
 559 {
 560   unsigned HOST_WIDE_INT lsb_mask, t;
 561
 562   /* This might not be obvious, but it's at least fast.
 563      This function is critical; we don't have the time loops would take.  */
 564   lsb_mask = x & -x;
 565   t = ((x >> 4) + lsb_mask) & ~(lsb_mask - 1);
 566   /* Return true iff t is a power of two.  */
 567   return ((t & (t - 1)) == 0);
 568 }
 569
 570 /* True iff depi or extru can be used to compute (reg & mask).
 571    Accept bit pattern like these:
 572    0....01....1
 573    1....10....0
 574    1..10..01..1  */
 575 int
 576 and_mask_p (unsigned HOST_WIDE_INT mask)
 577 {
 578   mask = ~mask;
 579   mask += mask & -mask;
 580   return (mask & (mask - 1)) == 0;
 581 }
 582
 583 /* True iff depi can be used to compute (reg | MASK).  */
 584 int
 585 ior_mask_p (unsigned HOST_WIDE_INT mask)
 586 {
 587   mask += mask & -mask;
 588   return (mask & (mask - 1)) == 0;
 589 }
 590 \f
 591 /* Legitimize PIC addresses.  If the address is already
 592    position-independent, we return ORIG.  Newly generated
 593    position-independent addresses go to REG.  If we need more
 594    than one register, we lose.  */
 595
 596 rtx
 597 legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
 598 {
 599   rtx pic_ref = orig;
 600
 601   gcc_assert (!PA_SYMBOL_REF_TLS_P (orig));
 602
 603   /* Labels need special handling.  */
 604   if (pic_label_operand (orig, mode))
 605     {
 606       /* We do not want to go through the movXX expanders here since that
 607          would create recursion.
 608
 609          Nor do we really want to call a generator for a named pattern
 610          since that requires multiple patterns if we want to support
 611          multiple word sizes.
 612
 613          So instead we just emit the raw set, which avoids the movXX
 614          expanders completely.  */
 615       mark_reg_pointer (reg, BITS_PER_UNIT);
 616       emit_insn (gen_rtx_SET (VOIDmode, reg, orig));
 617       current_function_uses_pic_offset_table = 1;
 618       return reg;
 619     }
 620   if (GET_CODE (orig) == SYMBOL_REF)
 621     {
 622       rtx insn, tmp_reg;
 623
 624       gcc_assert (reg);
 625
 626       /* Before reload, allocate a temporary register for the intermediate
 627          result.  This allows the sequence to be deleted when the final
 628          result is unused and the insns are trivially dead.  */
 629       tmp_reg = ((reload_in_progress || reload_completed)
 630                  ? reg : gen_reg_rtx (Pmode));
 631
 632       emit_move_insn (tmp_reg,
 633                       gen_rtx_PLUS (word_mode, pic_offset_table_rtx,
 634                                     gen_rtx_HIGH (word_mode, orig)));
 635       pic_ref
 636         = gen_const_mem (Pmode,
 637                          gen_rtx_LO_SUM (Pmode, tmp_reg,
 638                                          gen_rtx_UNSPEC (Pmode,
 639                                                          gen_rtvec (1, orig),
 640                                                          UNSPEC_DLTIND14R)));
 641
 642       current_function_uses_pic_offset_table = 1;
 643       mark_reg_pointer (reg, BITS_PER_UNIT);
 644       insn = emit_move_insn (reg, pic_ref);
 645
 646       /* Put a REG_EQUAL note on this insn, so that it can be optimized.  */
 647       REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, orig, REG_NOTES (insn));
 648
 649       return reg;
 650     }
 651   else if (GET_CODE (orig) == CONST)
 652     {
 653       rtx base;
 654
 655       if (GET_CODE (XEXP (orig, 0)) == PLUS
 656           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
 657         return orig;
 658
 659       gcc_assert (reg);
 660       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
 661
 662       base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
 663       orig = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
 664                                      base == reg ? 0 : reg);
 665
 666       if (GET_CODE (orig) == CONST_INT)
 667         {
 668           if (INT_14_BITS (orig))
 669             return plus_constant (base, INTVAL (orig));
 670           orig = force_reg (Pmode, orig);
 671         }
 672       pic_ref = gen_rtx_PLUS (Pmode, base, orig);
 673       /* Likewise, should we set special REG_NOTEs here?  */
 674     }
 675
 676   return pic_ref;
 677 }
 678
 679 static GTY(()) rtx gen_tls_tga;
 680
 681 static rtx
 682 gen_tls_get_addr (void)
 683 {
 684   if (!gen_tls_tga)
 685     gen_tls_tga = init_one_libfunc ("__tls_get_addr");
 686   return gen_tls_tga;
 687 }
 688
 689 static rtx
 690 hppa_tls_call (rtx arg)
 691 {
 692   rtx ret;
 693
 694   ret = gen_reg_rtx (Pmode);
 695   emit_library_call_value (gen_tls_get_addr (), ret,
 696                            LCT_CONST, Pmode, 1, arg, Pmode);
 697
 698   return ret;
 699 }
 700
 701 static rtx
 702 legitimize_tls_address (rtx addr)
 703 {
 704   rtx ret, insn, tmp, t1, t2, tp;
 705   enum tls_model model = SYMBOL_REF_TLS_MODEL (addr);
 706
 707   switch (model)
 708     {
 709       case TLS_MODEL_GLOBAL_DYNAMIC:
 710         tmp = gen_reg_rtx (Pmode);
 711         emit_insn (gen_tgd_load (tmp, addr));
 712         ret = hppa_tls_call (tmp);
 713         break;
 714
 715       case TLS_MODEL_LOCAL_DYNAMIC:
 716         ret = gen_reg_rtx (Pmode);
 717         tmp = gen_reg_rtx (Pmode);
 718         start_sequence ();
 719         emit_insn (gen_tld_load (tmp, addr));
 720         t1 = hppa_tls_call (tmp);
 721         insn = get_insns ();
 722         end_sequence ();
 723         t2 = gen_reg_rtx (Pmode);
 724         emit_libcall_block (insn, t2, t1,
 725                             gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
 726                                             UNSPEC_TLSLDBASE));
 727         emit_insn (gen_tld_offset_load (ret, addr, t2));
 728         break;
 729
 730       case TLS_MODEL_INITIAL_EXEC:
 731         tp = gen_reg_rtx (Pmode);
 732         tmp = gen_reg_rtx (Pmode);
 733         ret = gen_reg_rtx (Pmode);
 734         emit_insn (gen_tp_load (tp));
 735         emit_insn (gen_tie_load (tmp, addr));
 736         emit_move_insn (ret, gen_rtx_PLUS (Pmode, tp, tmp));
 737         break;
 738
 739       case TLS_MODEL_LOCAL_EXEC:
 740         tp = gen_reg_rtx (Pmode);
 741         ret = gen_reg_rtx (Pmode);
 742         emit_insn (gen_tp_load (tp));
 743         emit_insn (gen_tle_load (ret, addr, tp));
 744         break;
 745
 746       default:
 747         gcc_unreachable ();
 748     }
 749
 750   return ret;
 751 }
 752
 753 /* Try machine-dependent ways of modifying an illegitimate address
 754    to be legitimate.  If we find one, return the new, valid address.
 755    This macro is used in only one place: `memory_address' in explow.c.
 756
 757    OLDX is the address as it was before break_out_memory_refs was called.
 758    In some cases it is useful to look at this to decide what needs to be done.
 759
 760    MODE and WIN are passed so that this macro can use
 761    GO_IF_LEGITIMATE_ADDRESS.
 762
 763    It is always safe for this macro to do nothing.  It exists to recognize
 764    opportunities to optimize the output.
 765
 766    For the PA, transform:
 767
 768         memory(X + <large int>)
 769
 770    into:
 771
 772         if (<large int> & mask) >= 16
 773           Y = (<large int> & ~mask) + mask + 1  Round up.
 774         else
 775           Y = (<large int> & ~mask)             Round down.
 776         Z = X + Y
 777         memory (Z + (<large int> - Y));
 778
 779    This is for CSE to find several similar references, and only use one Z.
 780
 781    X can either be a SYMBOL_REF or REG, but because combine cannot
 782    perform a 4->2 combination we do nothing for SYMBOL_REF + D where
 783    D will not fit in 14 bits.
 784
 785    MODE_FLOAT references allow displacements which fit in 5 bits, so use
 786    0x1f as the mask.
 787
 788    MODE_INT references allow displacements which fit in 14 bits, so use
 789    0x3fff as the mask.
 790
 791    This relies on the fact that most mode MODE_FLOAT references will use FP
 792    registers and most mode MODE_INT references will use integer registers.
 793    (In the rare case of an FP register used in an integer MODE, we depend
 794    on secondary reloads to clean things up.)
 795
 796
 797    It is also beneficial to handle (plus (mult (X) (Y)) (Z)) in a special
 798    manner if Y is 2, 4, or 8.  (allows more shadd insns and shifted indexed
 799    addressing modes to be used).
 800
 801    Put X and Z into registers.  Then put the entire expression into
 802    a register.  */
 803
 804 rtx
 805 hppa_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
 806                          enum machine_mode mode)
 807 {
 808   rtx orig = x;
 809
 810   /* We need to canonicalize the order of operands in unscaled indexed
 811      addresses since the code that checks if an address is valid doesn't
 812      always try both orders.  */
 813   if (!TARGET_NO_SPACE_REGS
 814       && GET_CODE (x) == PLUS
 815       && GET_MODE (x) == Pmode
 816       && REG_P (XEXP (x, 0))
 817       && REG_P (XEXP (x, 1))
 818       && REG_POINTER (XEXP (x, 0))
 819       && !REG_POINTER (XEXP (x, 1)))
 820     return gen_rtx_PLUS (Pmode, XEXP (x, 1), XEXP (x, 0));
 821
 822   if (PA_SYMBOL_REF_TLS_P (x))
 823     return legitimize_tls_address (x);
 824   else if (flag_pic)
 825     return legitimize_pic_address (x, mode, gen_reg_rtx (Pmode));
 826
 827   /* Strip off CONST.  */
 828   if (GET_CODE (x) == CONST)
 829     x = XEXP (x, 0);
 830
 831   /* Special case.  Get the SYMBOL_REF into a register and use indexing.
 832      That should always be safe.  */
 833   if (GET_CODE (x) == PLUS
 834       && GET_CODE (XEXP (x, 0)) == REG
 835       && GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
 836     {
 837       rtx reg = force_reg (Pmode, XEXP (x, 1));
 838       return force_reg (Pmode, gen_rtx_PLUS (Pmode, reg, XEXP (x, 0)));
 839     }
 840
 841   /* Note we must reject symbols which represent function addresses
 842      since the assembler/linker can't handle arithmetic on plabels.  */
 843   if (GET_CODE (x) == PLUS
 844       && GET_CODE (XEXP (x, 1)) == CONST_INT
 845       && ((GET_CODE (XEXP (x, 0)) == SYMBOL_REF
 846            && !FUNCTION_NAME_P (XSTR (XEXP (x, 0), 0)))
 847           || GET_CODE (XEXP (x, 0)) == REG))
 848     {
 849       rtx int_part, ptr_reg;
 850       int newoffset;
 851       int offset = INTVAL (XEXP (x, 1));
 852       int mask;
 853
 854       mask = (GET_MODE_CLASS (mode) == MODE_FLOAT
 855               ? (TARGET_PA_20 ? 0x3fff : 0x1f) : 0x3fff);
 856
 857       /* Choose which way to round the offset.  Round up if we
 858          are >= halfway to the next boundary.  */
 859       if ((offset & mask) >= ((mask + 1) / 2))
 860         newoffset = (offset & ~ mask) + mask + 1;
 861       else
 862         newoffset = (offset & ~ mask);
 863
 864       /* If the newoffset will not fit in 14 bits (ldo), then
 865          handling this would take 4 or 5 instructions (2 to load
 866          the SYMBOL_REF + 1 or 2 to load the newoffset + 1 to
 867          add the new offset and the SYMBOL_REF.)  Combine can
 868          not handle 4->2 or 5->2 combinations, so do not create
 869          them.  */
 870       if (! VAL_14_BITS_P (newoffset)
 871           && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
 872         {
 873           rtx const_part = plus_constant (XEXP (x, 0), newoffset);
 874           rtx tmp_reg
 875             = force_reg (Pmode,
 876                          gen_rtx_HIGH (Pmode, const_part));
 877           ptr_reg
 878             = force_reg (Pmode,
 879                          gen_rtx_LO_SUM (Pmode,
 880                                          tmp_reg, const_part));
 881         }
 882       else
 883         {
 884           if (! VAL_14_BITS_P (newoffset))
 885             int_part = force_reg (Pmode, GEN_INT (newoffset));
 886           else
 887             int_part = GEN_INT (newoffset);
 888
 889           ptr_reg = force_reg (Pmode,
 890                                gen_rtx_PLUS (Pmode,
 891                                              force_reg (Pmode, XEXP (x, 0)),
 892                                              int_part));
 893         }
 894       return plus_constant (ptr_reg, offset - newoffset);
 895     }
 896
 897   /* Handle (plus (mult (a) (shadd_constant)) (b)).  */
 898
 899   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT
 900       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
 901       && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1)))
 902       && (OBJECT_P (XEXP (x, 1))
 903           || GET_CODE (XEXP (x, 1)) == SUBREG)
 904       && GET_CODE (XEXP (x, 1)) != CONST)
 905     {
 906       int val = INTVAL (XEXP (XEXP (x, 0), 1));
 907       rtx reg1, reg2;
 908
 909       reg1 = XEXP (x, 1);
 910       if (GET_CODE (reg1) != REG)
 911         reg1 = force_reg (Pmode, force_operand (reg1, 0));
 912
 913       reg2 = XEXP (XEXP (x, 0), 0);
 914       if (GET_CODE (reg2) != REG)
 915         reg2 = force_reg (Pmode, force_operand (reg2, 0));
 916
 917       return force_reg (Pmode, gen_rtx_PLUS (Pmode,
 918                                              gen_rtx_MULT (Pmode,
 919                                                            reg2,
 920                                                            GEN_INT (val)),
 921                                              reg1));
 922     }
 923
 924   /* Similarly for (plus (plus (mult (a) (shadd_constant)) (b)) (c)).
 925
 926      Only do so for floating point modes since this is more speculative
 927      and we lose if it's an integer store.  */
 928   if (GET_CODE (x) == PLUS
 929       && GET_CODE (XEXP (x, 0)) == PLUS
 930       && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
 931       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
 932       && shadd_constant_p (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1)))
 933       && (mode == SFmode || mode == DFmode))
 934     {
 935
 936       /* First, try and figure out what to use as a base register.  */
 937       rtx reg1, reg2, base, idx, orig_base;
 938
 939       reg1 = XEXP (XEXP (x, 0), 1);
 940       reg2 = XEXP (x, 1);
 941       base = NULL_RTX;
 942       idx = NULL_RTX;
 943
 944       /* Make sure they're both regs.  If one was a SYMBOL_REF [+ const],
 945          then emit_move_sequence will turn on REG_POINTER so we'll know
 946          it's a base register below.  */
 947       if (GET_CODE (reg1) != REG)
 948         reg1 = force_reg (Pmode, force_operand (reg1, 0));
 949
 950       if (GET_CODE (reg2) != REG)
 951         reg2 = force_reg (Pmode, force_operand (reg2, 0));
 952
 953       /* Figure out what the base and index are.  */
 954
 955       if (GET_CODE (reg1) == REG
 956           && REG_POINTER (reg1))
 957         {
 958           base = reg1;
 959           orig_base = XEXP (XEXP (x, 0), 1);
 960           idx = gen_rtx_PLUS (Pmode,
 961                               gen_rtx_MULT (Pmode,
 962                                             XEXP (XEXP (XEXP (x, 0), 0), 0),
 963                                             XEXP (XEXP (XEXP (x, 0), 0), 1)),
 964                               XEXP (x, 1));
 965         }
 966       else if (GET_CODE (reg2) == REG
 967                && REG_POINTER (reg2))
 968         {
 969           base = reg2;
 970           orig_base = XEXP (x, 1);
 971           idx = XEXP (x, 0);
 972         }
 973
 974       if (base == 0)
 975         return orig;
 976
 977       /* If the index adds a large constant, try to scale the
 978          constant so that it can be loaded with only one insn.  */
 979       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
 980           && VAL_14_BITS_P (INTVAL (XEXP (idx, 1))
 981                             / INTVAL (XEXP (XEXP (idx, 0), 1)))
 982           && INTVAL (XEXP (idx, 1)) % INTVAL (XEXP (XEXP (idx, 0), 1)) == 0)
 983         {
 984           /* Divide the CONST_INT by the scale factor, then add it to A.  */
 985           int val = INTVAL (XEXP (idx, 1));
 986
 987           val /= INTVAL (XEXP (XEXP (idx, 0), 1));
 988           reg1 = XEXP (XEXP (idx, 0), 0);
 989           if (GET_CODE (reg1) != REG)
 990             reg1 = force_reg (Pmode, force_operand (reg1, 0));
 991
 992           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, reg1, GEN_INT (val)));
 993
 994           /* We can now generate a simple scaled indexed address.  */
 995           return
 996             force_reg
 997               (Pmode, gen_rtx_PLUS (Pmode,
 998                                     gen_rtx_MULT (Pmode, reg1,
 999                                                   XEXP (XEXP (idx, 0), 1)),
1000                                     base));
1001         }
1002
1003       /* If B + C is still a valid base register, then add them.  */
1004       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
1005           && INTVAL (XEXP (idx, 1)) <= 4096
1006           && INTVAL (XEXP (idx, 1)) >= -4096)
1007         {
1008           int val = INTVAL (XEXP (XEXP (idx, 0), 1));
1009           rtx reg1, reg2;
1010
1011           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, XEXP (idx, 1)));
1012
1013           reg2 = XEXP (XEXP (idx, 0), 0);
1014           if (GET_CODE (reg2) != CONST_INT)
1015             reg2 = force_reg (Pmode, force_operand (reg2, 0));
1016
1017           return force_reg (Pmode, gen_rtx_PLUS (Pmode,
1018                                                  gen_rtx_MULT (Pmode,
1019                                                                reg2,
1020                                                                GEN_INT (val)),
1021                                                  reg1));
1022         }
1023
1024       /* Get the index into a register, then add the base + index and
1025          return a register holding the result.  */
1026
1027       /* First get A into a register.  */
1028       reg1 = XEXP (XEXP (idx, 0), 0);
1029       if (GET_CODE (reg1) != REG)
1030         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1031
1032       /* And get B into a register.  */
1033       reg2 = XEXP (idx, 1);
1034       if (GET_CODE (reg2) != REG)
1035         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1036
1037       reg1 = force_reg (Pmode,
1038                         gen_rtx_PLUS (Pmode,
1039                                       gen_rtx_MULT (Pmode, reg1,
1040                                                     XEXP (XEXP (idx, 0), 1)),
1041                                       reg2));
1042
1043       /* Add the result to our base register and return.  */
1044       return force_reg (Pmode, gen_rtx_PLUS (Pmode, base, reg1));
1045
1046     }
1047
1048   /* Uh-oh.  We might have an address for x[n-100000].  This needs
1049      special handling to avoid creating an indexed memory address
1050      with x-100000 as the base.
1051
1052      If the constant part is small enough, then it's still safe because
1053      there is a guard page at the beginning and end of the data segment.
1054
1055      Scaled references are common enough that we want to try and rearrange the
1056      terms so that we can use indexing for these addresses too.  Only
1057      do the optimization for floatint point modes.  */
1058
1059   if (GET_CODE (x) == PLUS
1060       && symbolic_expression_p (XEXP (x, 1)))
1061     {
1062       /* Ugly.  We modify things here so that the address offset specified
1063          by the index expression is computed first, then added to x to form
1064          the entire address.  */
1065
1066       rtx regx1, regx2, regy1, regy2, y;
1067
1068       /* Strip off any CONST.  */
1069       y = XEXP (x, 1);
1070       if (GET_CODE (y) == CONST)
1071         y = XEXP (y, 0);
1072
1073       if (GET_CODE (y) == PLUS || GET_CODE (y) == MINUS)
1074         {
1075           /* See if this looks like
1076                 (plus (mult (reg) (shadd_const))
1077                       (const (plus (symbol_ref) (const_int))))
1078
1079              Where const_int is small.  In that case the const
1080              expression is a valid pointer for indexing.
1081
1082              If const_int is big, but can be divided evenly by shadd_const
1083              and added to (reg).  This allows more scaled indexed addresses.  */
1084           if (GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1085               && GET_CODE (XEXP (x, 0)) == MULT
1086               && GET_CODE (XEXP (y, 1)) == CONST_INT
1087               && INTVAL (XEXP (y, 1)) >= -4096
1088               && INTVAL (XEXP (y, 1)) <= 4095
1089               && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1090               && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1091             {
1092               int val = INTVAL (XEXP (XEXP (x, 0), 1));
1093               rtx reg1, reg2;
1094
1095               reg1 = XEXP (x, 1);
1096               if (GET_CODE (reg1) != REG)
1097                 reg1 = force_reg (Pmode, force_operand (reg1, 0));
1098
1099               reg2 = XEXP (XEXP (x, 0), 0);
1100               if (GET_CODE (reg2) != REG)
1101                 reg2 = force_reg (Pmode, force_operand (reg2, 0));
1102
1103               return force_reg (Pmode,
1104                                 gen_rtx_PLUS (Pmode,
1105                                               gen_rtx_MULT (Pmode,
1106                                                             reg2,
1107                                                             GEN_INT (val)),
1108                                               reg1));
1109             }
1110           else if ((mode == DFmode || mode == SFmode)
1111                    && GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1112                    && GET_CODE (XEXP (x, 0)) == MULT
1113                    && GET_CODE (XEXP (y, 1)) == CONST_INT
1114                    && INTVAL (XEXP (y, 1)) % INTVAL (XEXP (XEXP (x, 0), 1)) == 0
1115                    && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1116                    && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1117             {
1118               regx1
1119                 = force_reg (Pmode, GEN_INT (INTVAL (XEXP (y, 1))
1120                                              / INTVAL (XEXP (XEXP (x, 0), 1))));
1121               regx2 = XEXP (XEXP (x, 0), 0);
1122               if (GET_CODE (regx2) != REG)
1123                 regx2 = force_reg (Pmode, force_operand (regx2, 0));
1124               regx2 = force_reg (Pmode, gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1125                                                         regx2, regx1));
1126               return
1127                 force_reg (Pmode,
1128                            gen_rtx_PLUS (Pmode,
1129                                          gen_rtx_MULT (Pmode, regx2,
1130                                                        XEXP (XEXP (x, 0), 1)),
1131                                          force_reg (Pmode, XEXP (y, 0))));
1132             }
1133           else if (GET_CODE (XEXP (y, 1)) == CONST_INT
1134                    && INTVAL (XEXP (y, 1)) >= -4096
1135                    && INTVAL (XEXP (y, 1)) <= 4095)
1136             {
1137               /* This is safe because of the guard page at the
1138                  beginning and end of the data space.  Just
1139                  return the original address.  */
1140               return orig;
1141             }
1142           else
1143             {
1144               /* Doesn't look like one we can optimize.  */
1145               regx1 = force_reg (Pmode, force_operand (XEXP (x, 0), 0));
1146               regy1 = force_reg (Pmode, force_operand (XEXP (y, 0), 0));
1147               regy2 = force_reg (Pmode, force_operand (XEXP (y, 1), 0));
1148               regx1 = force_reg (Pmode,
1149                                  gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1150                                                  regx1, regy2));
1151               return force_reg (Pmode, gen_rtx_PLUS (Pmode, regx1, regy1));
1152             }
1153         }
1154     }
1155
1156   return orig;
1157 }
1158
1159 /* For the HPPA, REG and REG+CONST is cost 0
1160    and addresses involving symbolic constants are cost 2.
1161
1162    PIC addresses are very expensive.
1163
1164    It is no coincidence that this has the same structure
1165    as GO_IF_LEGITIMATE_ADDRESS.  */
1166
1167 static int
1168 hppa_address_cost (rtx X)
1169 {
1170   switch (GET_CODE (X))
1171     {
1172     case REG:
1173     case PLUS:
1174     case LO_SUM:
1175       return 1;
1176     case HIGH:
1177       return 2;
1178     default:
1179       return 4;
1180     }
1181 }
1182
1183 /* Compute a (partial) cost for rtx X.  Return true if the complete
1184    cost has been computed, and false if subexpressions should be
1185    scanned.  In either case, *TOTAL contains the cost result.  */
1186
1187 static bool
1188 hppa_rtx_costs (rtx x, int code, int outer_code, int *total)
1189 {
1190   switch (code)
1191     {
1192     case CONST_INT:
1193       if (INTVAL (x) == 0)
1194         *total = 0;
1195       else if (INT_14_BITS (x))
1196         *total = 1;
1197       else
1198         *total = 2;
1199       return true;
1200
1201     case HIGH:
1202       *total = 2;
1203       return true;
1204
1205     case CONST:
1206     case LABEL_REF:
1207     case SYMBOL_REF:
1208       *total = 4;
1209       return true;
1210
1211     case CONST_DOUBLE:
1212       if ((x == CONST0_RTX (DFmode) || x == CONST0_RTX (SFmode))
1213           && outer_code != SET)
1214         *total = 0;
1215       else
1216         *total = 8;
1217       return true;
1218
1219     case MULT:
1220       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1221         *total = COSTS_N_INSNS (3);
1222       else if (TARGET_PA_11 && !TARGET_DISABLE_FPREGS && !TARGET_SOFT_FLOAT)
1223         *total = COSTS_N_INSNS (8);
1224       else
1225         *total = COSTS_N_INSNS (20);
1226       return true;
1227
1228     case DIV:
1229       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1230         {
1231           *total = COSTS_N_INSNS (14);
1232           return true;
1233         }
1234       /* FALLTHRU */
1235
1236     case UDIV:
1237     case MOD:
1238     case UMOD:
1239       *total = COSTS_N_INSNS (60);
1240       return true;
1241
1242     case PLUS: /* this includes shNadd insns */
1243     case MINUS:
1244       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1245         *total = COSTS_N_INSNS (3);
1246       else
1247         *total = COSTS_N_INSNS (1);
1248       return true;
1249
1250     case ASHIFT:
1251     case ASHIFTRT:
1252     case LSHIFTRT:
1253       *total = COSTS_N_INSNS (1);
1254       return true;
1255
1256     default:
1257       return false;
1258     }
1259 }
1260
1261 /* Ensure mode of ORIG, a REG rtx, is MODE.  Returns either ORIG or a
1262    new rtx with the correct mode.  */
1263 static inline rtx
1264 force_mode (enum machine_mode mode, rtx orig)
1265 {
1266   if (mode == GET_MODE (orig))
1267     return orig;
1268
1269   gcc_assert (REGNO (orig) < FIRST_PSEUDO_REGISTER);
1270
1271   return gen_rtx_REG (mode, REGNO (orig));
1272 }
1273
1274 /* Return 1 if *X is a thread-local symbol.  */
1275
1276 static int
1277 pa_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
1278 {
1279   return PA_SYMBOL_REF_TLS_P (*x);
1280 }
1281
1282 /* Return 1 if X contains a thread-local symbol.  */
1283
1284 bool
1285 pa_tls_referenced_p (rtx x)
1286 {
1287   if (!TARGET_HAVE_TLS)
1288     return false;
1289
1290   return for_each_rtx (&x, &pa_tls_symbol_ref_1, 0);
1291 }
1292
1293 /* Emit insns to move operands[1] into operands[0].
1294
1295    Return 1 if we have written out everything that needs to be done to
1296    do the move.  Otherwise, return 0 and the caller will emit the move
1297    normally.
1298
1299    Note SCRATCH_REG may not be in the proper mode depending on how it
1300    will be used.  This routine is responsible for creating a new copy
1301    of SCRATCH_REG in the proper mode.  */
1302
1303 int
1304 emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
1305 {
1306   register rtx operand0 = operands[0];
1307   register rtx operand1 = operands[1];
1308   register rtx tem;
1309
1310   /* We can only handle indexed addresses in the destination operand
1311      of floating point stores.  Thus, we need to break out indexed
1312      addresses from the destination operand.  */
1313   if (GET_CODE (operand0) == MEM && IS_INDEX_ADDR_P (XEXP (operand0, 0)))
1314     {
1315       /* This is only safe up to the beginning of life analysis.  */
1316       gcc_assert (!no_new_pseudos);
1317
1318       tem = copy_to_mode_reg (Pmode, XEXP (operand0, 0));
1319       operand0 = replace_equiv_address (operand0, tem);
1320     }
1321
1322   /* On targets with non-equivalent space registers, break out unscaled
1323      indexed addresses from the source operand before the final CSE.
1324      We have to do this because the REG_POINTER flag is not correctly
1325      carried through various optimization passes and CSE may substitute
1326      a pseudo without the pointer set for one with the pointer set.  As
1327      a result, we loose various opportunities to create insns with
1328      unscaled indexed addresses.  */
1329   if (!TARGET_NO_SPACE_REGS
1330       && !cse_not_expected
1331       && GET_CODE (operand1) == MEM
1332       && GET_CODE (XEXP (operand1, 0)) == PLUS
1333       && REG_P (XEXP (XEXP (operand1, 0), 0))
1334       && REG_P (XEXP (XEXP (operand1, 0), 1)))
1335     operand1
1336       = replace_equiv_address (operand1,
1337                                copy_to_mode_reg (Pmode, XEXP (operand1, 0)));
1338
1339   if (scratch_reg
1340       && reload_in_progress && GET_CODE (operand0) == REG
1341       && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
1342     operand0 = reg_equiv_mem[REGNO (operand0)];
1343   else if (scratch_reg
1344            && reload_in_progress && GET_CODE (operand0) == SUBREG
1345            && GET_CODE (SUBREG_REG (operand0)) == REG
1346            && REGNO (SUBREG_REG (operand0)) >= FIRST_PSEUDO_REGISTER)
1347     {
1348      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1349         the code which tracks sets/uses for delete_output_reload.  */
1350       rtx temp = gen_rtx_SUBREG (GET_MODE (operand0),
1351                                  reg_equiv_mem [REGNO (SUBREG_REG (operand0))],
1352                                  SUBREG_BYTE (operand0));
1353       operand0 = alter_subreg (&temp);
1354     }
1355
1356   if (scratch_reg
1357       && reload_in_progress && GET_CODE (operand1) == REG
1358       && REGNO (operand1) >= FIRST_PSEUDO_REGISTER)
1359     operand1 = reg_equiv_mem[REGNO (operand1)];
1360   else if (scratch_reg
1361            && reload_in_progress && GET_CODE (operand1) == SUBREG
1362            && GET_CODE (SUBREG_REG (operand1)) == REG
1363            && REGNO (SUBREG_REG (operand1)) >= FIRST_PSEUDO_REGISTER)
1364     {
1365      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1366         the code which tracks sets/uses for delete_output_reload.  */
1367       rtx temp = gen_rtx_SUBREG (GET_MODE (operand1),
1368                                  reg_equiv_mem [REGNO (SUBREG_REG (operand1))],
1369                                  SUBREG_BYTE (operand1));
1370       operand1 = alter_subreg (&temp);
1371     }
1372
1373   if (scratch_reg && reload_in_progress && GET_CODE (operand0) == MEM
1374       && ((tem = find_replacement (&XEXP (operand0, 0)))
1375           != XEXP (operand0, 0)))
1376     operand0 = gen_rtx_MEM (GET_MODE (operand0), tem);
1377
1378   if (scratch_reg && reload_in_progress && GET_CODE (operand1) == MEM
1379       && ((tem = find_replacement (&XEXP (operand1, 0)))
1380           != XEXP (operand1, 0)))
1381     operand1 = gen_rtx_MEM (GET_MODE (operand1), tem);
1382
1383   /* Handle secondary reloads for loads/stores of FP registers from
1384      REG+D addresses where D does not fit in 5 or 14 bits, including
1385      (subreg (mem (addr))) cases.  */
1386   if (scratch_reg
1387       && fp_reg_operand (operand0, mode)
1388       && ((GET_CODE (operand1) == MEM
1389            && !memory_address_p ((GET_MODE_SIZE (mode) == 4 ? SFmode : DFmode),
1390                                  XEXP (operand1, 0)))
1391           || ((GET_CODE (operand1) == SUBREG
1392                && GET_CODE (XEXP (operand1, 0)) == MEM
1393                && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1394                                       ? SFmode : DFmode),
1395                                      XEXP (XEXP (operand1, 0), 0))))))
1396     {
1397       if (GET_CODE (operand1) == SUBREG)
1398         operand1 = XEXP (operand1, 0);
1399
1400       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1401          it in WORD_MODE regardless of what mode it was originally given
1402          to us.  */
1403       scratch_reg = force_mode (word_mode, scratch_reg);
1404
1405       /* D might not fit in 14 bits either; for such cases load D into
1406          scratch reg.  */
1407       if (!memory_address_p (Pmode, XEXP (operand1, 0)))
1408         {
1409           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1410           emit_move_insn (scratch_reg,
1411                           gen_rtx_fmt_ee (GET_CODE (XEXP (operand1, 0)),
1412                                           Pmode,
1413                                           XEXP (XEXP (operand1, 0), 0),
1414                                           scratch_reg));
1415         }
1416       else
1417         emit_move_insn (scratch_reg, XEXP (operand1, 0));
1418       emit_insn (gen_rtx_SET (VOIDmode, operand0,
1419                               gen_rtx_MEM (mode, scratch_reg)));
1420       return 1;
1421     }
1422   else if (scratch_reg
1423            && fp_reg_operand (operand1, mode)
1424            && ((GET_CODE (operand0) == MEM
1425                 && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1426                                         ? SFmode : DFmode),
1427                                        XEXP (operand0, 0)))
1428                || ((GET_CODE (operand0) == SUBREG)
1429                    && GET_CODE (XEXP (operand0, 0)) == MEM
1430                    && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1431                                           ? SFmode : DFmode),
1432                                          XEXP (XEXP (operand0, 0), 0)))))
1433     {
1434       if (GET_CODE (operand0) == SUBREG)
1435         operand0 = XEXP (operand0, 0);
1436
1437       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1438          it in WORD_MODE regardless of what mode it was originally given
1439          to us.  */
1440       scratch_reg = force_mode (word_mode, scratch_reg);
1441
1442       /* D might not fit in 14 bits either; for such cases load D into
1443          scratch reg.  */
1444       if (!memory_address_p (Pmode, XEXP (operand0, 0)))
1445         {
1446           emit_move_insn (scratch_reg, XEXP (XEXP (operand0, 0), 1));
1447           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand0,
1448                                                                         0)),
1449                                                        Pmode,
1450                                                        XEXP (XEXP (operand0, 0),
1451                                                                    0),
1452                                                        scratch_reg));
1453         }
1454       else
1455         emit_move_insn (scratch_reg, XEXP (operand0, 0));
1456       emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_MEM (mode, scratch_reg),
1457                               operand1));
1458       return 1;
1459     }
1460   /* Handle secondary reloads for loads of FP registers from constant
1461      expressions by forcing the constant into memory.
1462
1463      Use scratch_reg to hold the address of the memory location.
1464
1465      The proper fix is to change PREFERRED_RELOAD_CLASS to return
1466      NO_REGS when presented with a const_int and a register class
1467      containing only FP registers.  Doing so unfortunately creates
1468      more problems than it solves.   Fix this for 2.5.  */
1469   else if (scratch_reg
1470            && CONSTANT_P (operand1)
1471            && fp_reg_operand (operand0, mode))
1472     {
1473       rtx xoperands[2];
1474
1475       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1476          it in WORD_MODE regardless of what mode it was originally given
1477          to us.  */
1478       scratch_reg = force_mode (word_mode, scratch_reg);
1479
1480       /* Force the constant into memory and put the address of the
1481          memory location into scratch_reg.  */
1482       xoperands[0] = scratch_reg;
1483       xoperands[1] = XEXP (force_const_mem (mode, operand1), 0);
1484       emit_move_sequence (xoperands, Pmode, 0);
1485
1486       /* Now load the destination register.  */
1487       emit_insn (gen_rtx_SET (mode, operand0,
1488                               gen_rtx_MEM (mode, scratch_reg)));
1489       return 1;
1490     }
1491   /* Handle secondary reloads for SAR.  These occur when trying to load
1492      the SAR from memory, FP register, or with a constant.  */
1493   else if (scratch_reg
1494            && GET_CODE (operand0) == REG
1495            && REGNO (operand0) < FIRST_PSEUDO_REGISTER
1496            && REGNO_REG_CLASS (REGNO (operand0)) == SHIFT_REGS
1497            && (GET_CODE (operand1) == MEM
1498                || GET_CODE (operand1) == CONST_INT
1499                || (GET_CODE (operand1) == REG
1500                    && FP_REG_CLASS_P (REGNO_REG_CLASS (REGNO (operand1))))))
1501     {
1502       /* D might not fit in 14 bits either; for such cases load D into
1503          scratch reg.  */
1504       if (GET_CODE (operand1) == MEM
1505           && !memory_address_p (Pmode, XEXP (operand1, 0)))
1506         {
1507           /* We are reloading the address into the scratch register, so we
1508              want to make sure the scratch register is a full register.  */
1509           scratch_reg = force_mode (word_mode, scratch_reg);
1510
1511           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1512           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand1,
1513                                                                         0)),
1514                                                        Pmode,
1515                                                        XEXP (XEXP (operand1, 0),
1516                                                        0),
1517                                                        scratch_reg));
1518
1519           /* Now we are going to load the scratch register from memory,
1520              we want to load it in the same width as the original MEM,
1521              which must be the same as the width of the ultimate destination,
1522              OPERAND0.  */
1523           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1524
1525           emit_move_insn (scratch_reg, gen_rtx_MEM (GET_MODE (operand0),
1526                                                     scratch_reg));
1527         }
1528       else
1529         {
1530           /* We want to load the scratch register using the same mode as
1531              the ultimate destination.  */
1532           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1533
1534           emit_move_insn (scratch_reg, operand1);
1535         }
1536
1537       /* And emit the insn to set the ultimate destination.  We know that
1538          the scratch register has the same mode as the destination at this
1539          point.  */
1540       emit_move_insn (operand0, scratch_reg);
1541       return 1;
1542     }
1543   /* Handle the most common case: storing into a register.  */
1544   else if (register_operand (operand0, mode))
1545     {
1546       if (register_operand (operand1, mode)
1547           || (GET_CODE (operand1) == CONST_INT
1548               && cint_ok_for_move (INTVAL (operand1)))
1549           || (operand1 == CONST0_RTX (mode))
1550           || (GET_CODE (operand1) == HIGH
1551               && !symbolic_operand (XEXP (operand1, 0), VOIDmode))
1552           /* Only `general_operands' can come here, so MEM is ok.  */
1553           || GET_CODE (operand1) == MEM)
1554         {
1555           /* Various sets are created during RTL generation which don't
1556              have the REG_POINTER flag correctly set.  After the CSE pass,
1557              instruction recognition can fail if we don't consistently
1558              set this flag when performing register copies.  This should
1559              also improve the opportunities for creating insns that use
1560              unscaled indexing.  */
1561           if (REG_P (operand0) && REG_P (operand1))
1562             {
1563               if (REG_POINTER (operand1)
1564                   && !REG_POINTER (operand0)
1565                   && !HARD_REGISTER_P (operand0))
1566                 copy_reg_pointer (operand0, operand1);
1567               else if (REG_POINTER (operand0)
1568                        && !REG_POINTER (operand1)
1569                        && !HARD_REGISTER_P (operand1))
1570                 copy_reg_pointer (operand1, operand0);
1571             }
1572
1573           /* When MEMs are broken out, the REG_POINTER flag doesn't
1574              get set.  In some cases, we can set the REG_POINTER flag
1575              from the declaration for the MEM.  */
1576           if (REG_P (operand0)
1577               && GET_CODE (operand1) == MEM
1578               && !REG_POINTER (operand0))
1579             {
1580               tree decl = MEM_EXPR (operand1);
1581
1582               /* Set the register pointer flag and register alignment
1583                  if the declaration for this memory reference is a
1584                  pointer type.  Fortran indirect argument references
1585                  are ignored.  */
1586               if (decl
1587                   && !(flag_argument_noalias > 1
1588                        && TREE_CODE (decl) == INDIRECT_REF
1589                        && TREE_CODE (TREE_OPERAND (decl, 0)) == PARM_DECL))
1590                 {
1591                   tree type;
1592
1593                   /* If this is a COMPONENT_REF, use the FIELD_DECL from
1594                      tree operand 1.  */
1595                   if (TREE_CODE (decl) == COMPONENT_REF)
1596                     decl = TREE_OPERAND (decl, 1);
1597
1598                   type = TREE_TYPE (decl);
1599                   if (TREE_CODE (type) == ARRAY_TYPE)
1600                     type = get_inner_array_type (type);
1601
1602                   if (POINTER_TYPE_P (type))
1603                     {
1604                       int align;
1605
1606                       type = TREE_TYPE (type);
1607                       /* Using TYPE_ALIGN_OK is rather conservative as
1608                          only the ada frontend actually sets it.  */
1609                       align = (TYPE_ALIGN_OK (type) ? TYPE_ALIGN (type)
1610                                : BITS_PER_UNIT);
1611                       mark_reg_pointer (operand0, align);
1612                     }
1613                 }
1614             }
1615
1616           emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
1617           return 1;
1618         }
1619     }
1620   else if (GET_CODE (operand0) == MEM)
1621     {
1622       if (mode == DFmode && operand1 == CONST0_RTX (mode)
1623           && !(reload_in_progress || reload_completed))
1624         {
1625           rtx temp = gen_reg_rtx (DFmode);
1626
1627           emit_insn (gen_rtx_SET (VOIDmode, temp, operand1));
1628           emit_insn (gen_rtx_SET (VOIDmode, operand0, temp));
1629           return 1;
1630         }
1631       if (register_operand (operand1, mode) || operand1 == CONST0_RTX (mode))
1632         {
1633           /* Run this case quickly.  */
1634           emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
1635           return 1;
1636         }
1637       if (! (reload_in_progress || reload_completed))
1638         {
1639           operands[0] = validize_mem (operand0);
1640           operands[1] = operand1 = force_reg (mode, operand1);
1641         }
1642     }
1643
1644   /* Simplify the source if we need to.
1645      Note we do have to handle function labels here, even though we do
1646      not consider them legitimate constants.  Loop optimizations can
1647      call the emit_move_xxx with one as a source.  */
1648   if ((GET_CODE (operand1) != HIGH && immediate_operand (operand1, mode))
1649       || function_label_operand (operand1, mode)
1650       || (GET_CODE (operand1) == HIGH
1651           && symbolic_operand (XEXP (operand1, 0), mode)))
1652     {
1653       int ishighonly = 0;
1654
1655       if (GET_CODE (operand1) == HIGH)
1656         {
1657           ishighonly = 1;
1658           operand1 = XEXP (operand1, 0);
1659         }
1660       if (symbolic_operand (operand1, mode))
1661         {
1662           /* Argh.  The assembler and linker can't handle arithmetic
1663              involving plabels.
1664
1665              So we force the plabel into memory, load operand0 from
1666              the memory location, then add in the constant part.  */
1667           if ((GET_CODE (operand1) == CONST
1668                && GET_CODE (XEXP (operand1, 0)) == PLUS
1669                && function_label_operand (XEXP (XEXP (operand1, 0), 0), Pmode))
1670               || function_label_operand (operand1, mode))
1671             {
1672               rtx temp, const_part;
1673
1674               /* Figure out what (if any) scratch register to use.  */
1675               if (reload_in_progress || reload_completed)
1676                 {
1677                   scratch_reg = scratch_reg ? scratch_reg : operand0;
1678                   /* SCRATCH_REG will hold an address and maybe the actual
1679                      data.  We want it in WORD_MODE regardless of what mode it
1680                      was originally given to us.  */
1681                   scratch_reg = force_mode (word_mode, scratch_reg);
1682                 }
1683               else if (flag_pic)
1684                 scratch_reg = gen_reg_rtx (Pmode);
1685
1686               if (GET_CODE (operand1) == CONST)
1687                 {
1688                   /* Save away the constant part of the expression.  */
1689                   const_part = XEXP (XEXP (operand1, 0), 1);
1690                   gcc_assert (GET_CODE (const_part) == CONST_INT);
1691
1692                   /* Force the function label into memory.  */
1693                   temp = force_const_mem (mode, XEXP (XEXP (operand1, 0), 0));
1694                 }
1695               else
1696                 {
1697                   /* No constant part.  */
1698                   const_part = NULL_RTX;
1699
1700                   /* Force the function label into memory.  */
1701                   temp = force_const_mem (mode, operand1);
1702                 }
1703
1704
1705               /* Get the address of the memory location.  PIC-ify it if
1706                  necessary.  */
1707               temp = XEXP (temp, 0);
1708               if (flag_pic)
1709                 temp = legitimize_pic_address (temp, mode, scratch_reg);
1710
1711               /* Put the address of the memory location into our destination
1712                  register.  */
1713               operands[1] = temp;
1714               emit_move_sequence (operands, mode, scratch_reg);
1715
1716               /* Now load from the memory location into our destination
1717                  register.  */
1718               operands[1] = gen_rtx_MEM (Pmode, operands[0]);
1719               emit_move_sequence (operands, mode, scratch_reg);
1720
1721               /* And add back in the constant part.  */
1722               if (const_part != NULL_RTX)
1723                 expand_inc (operand0, const_part);
1724
1725               return 1;
1726             }
1727
1728           if (flag_pic)
1729             {
1730               rtx temp;
1731
1732               if (reload_in_progress || reload_completed)
1733                 {
1734                   temp = scratch_reg ? scratch_reg : operand0;
1735                   /* TEMP will hold an address and maybe the actual
1736                      data.  We want it in WORD_MODE regardless of what mode it
1737                      was originally given to us.  */
1738                   temp = force_mode (word_mode, temp);
1739                 }
1740               else
1741                 temp = gen_reg_rtx (Pmode);
1742
1743               /* (const (plus (symbol) (const_int))) must be forced to
1744                  memory during/after reload if the const_int will not fit
1745                  in 14 bits.  */
1746               if (GET_CODE (operand1) == CONST
1747                        && GET_CODE (XEXP (operand1, 0)) == PLUS
1748                        && GET_CODE (XEXP (XEXP (operand1, 0), 1)) == CONST_INT
1749                        && !INT_14_BITS (XEXP (XEXP (operand1, 0), 1))
1750                        && (reload_completed || reload_in_progress)
1751                        && flag_pic)
1752                 {
1753                   operands[1] = force_const_mem (mode, operand1);
1754                   operands[1] = legitimize_pic_address (XEXP (operands[1], 0),
1755                                                         mode, temp);
1756                   operands[1] = gen_rtx_MEM (mode, operands[1]);
1757                   emit_move_sequence (operands, mode, temp);
1758                 }
1759               else
1760                 {
1761                   operands[1] = legitimize_pic_address (operand1, mode, temp);
1762                   if (REG_P (operand0) && REG_P (operands[1]))
1763                     copy_reg_pointer (operand0, operands[1]);
1764                   emit_insn (gen_rtx_SET (VOIDmode, operand0, operands[1]));
1765                 }
1766             }
1767           /* On the HPPA, references to data space are supposed to use dp,
1768              register 27, but showing it in the RTL inhibits various cse
1769              and loop optimizations.  */
1770           else
1771             {
1772               rtx temp, set;
1773
1774               if (reload_in_progress || reload_completed)
1775                 {
1776                   temp = scratch_reg ? scratch_reg : operand0;
1777                   /* TEMP will hold an address and maybe the actual
1778                      data.  We want it in WORD_MODE regardless of what mode it
1779                      was originally given to us.  */
1780                   temp = force_mode (word_mode, temp);
1781                 }
1782               else
1783                 temp = gen_reg_rtx (mode);
1784
1785               /* Loading a SYMBOL_REF into a register makes that register
1786                  safe to be used as the base in an indexed address.
1787
1788                  Don't mark hard registers though.  That loses.  */
1789               if (GET_CODE (operand0) == REG
1790                   && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
1791                 mark_reg_pointer (operand0, BITS_PER_UNIT);
1792               if (REGNO (temp) >= FIRST_PSEUDO_REGISTER)
1793                 mark_reg_pointer (temp, BITS_PER_UNIT);
1794
1795               if (ishighonly)
1796                 set = gen_rtx_SET (mode, operand0, temp);
1797               else
1798                 set = gen_rtx_SET (VOIDmode,
1799                                    operand0,
1800                                    gen_rtx_LO_SUM (mode, temp, operand1));
1801
1802               emit_insn (gen_rtx_SET (VOIDmode,
1803                                       temp,
1804                                       gen_rtx_HIGH (mode, operand1)));
1805               emit_insn (set);
1806
1807             }
1808           return 1;
1809         }
1810       else if (pa_tls_referenced_p (operand1))
1811         {
1812           rtx tmp = operand1;
1813           rtx addend = NULL;
1814
1815           if (GET_CODE (tmp) == CONST && GET_CODE (XEXP (tmp, 0)) == PLUS)
1816             {
1817               addend = XEXP (XEXP (tmp, 0), 1);
1818               tmp = XEXP (XEXP (tmp, 0), 0);
1819             }
1820
1821           gcc_assert (GET_CODE (tmp) == SYMBOL_REF);
1822           tmp = legitimize_tls_address (tmp);
1823           if (addend)
1824             {
1825               tmp = gen_rtx_PLUS (mode, tmp, addend);
1826               tmp = force_operand (tmp, operands[0]);
1827             }
1828           operands[1] = tmp;
1829         }
1830       else if (GET_CODE (operand1) != CONST_INT
1831                || !cint_ok_for_move (INTVAL (operand1)))
1832         {
1833           rtx insn, temp;
1834           rtx op1 = operand1;
1835           HOST_WIDE_INT value = 0;
1836           HOST_WIDE_INT insv = 0;
1837           int insert = 0;
1838
1839           if (GET_CODE (operand1) == CONST_INT)
1840             value = INTVAL (operand1);
1841
1842           if (TARGET_64BIT
1843               && GET_CODE (operand1) == CONST_INT
1844               && HOST_BITS_PER_WIDE_INT > 32
1845               && GET_MODE_BITSIZE (GET_MODE (operand0)) > 32)
1846             {
1847               HOST_WIDE_INT nval;
1848
1849               /* Extract the low order 32 bits of the value and sign extend.
1850                  If the new value is the same as the original value, we can
1851                  can use the original value as-is.  If the new value is
1852                  different, we use it and insert the most-significant 32-bits
1853                  of the original value into the final result.  */
1854               nval = ((value & (((HOST_WIDE_INT) 2 << 31) - 1))
1855                       ^ ((HOST_WIDE_INT) 1 << 31)) - ((HOST_WIDE_INT) 1 << 31);
1856               if (value != nval)
1857                 {
1858 #if HOST_BITS_PER_WIDE_INT > 32
1859                   insv = value >= 0 ? value >> 32 : ~(~value >> 32);
1860 #endif
1861                   insert = 1;
1862                   value = nval;
1863                   operand1 = GEN_INT (nval);
1864                 }
1865             }
1866
1867           if (reload_in_progress || reload_completed)
1868             temp = scratch_reg ? scratch_reg : operand0;
1869           else
1870             temp = gen_reg_rtx (mode);
1871
1872           /* We don't directly split DImode constants on 32-bit targets
1873              because PLUS uses an 11-bit immediate and the insn sequence
1874              generated is not as efficient as the one using HIGH/LO_SUM.  */
1875           if (GET_CODE (operand1) == CONST_INT
1876               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1877               && !insert)
1878             {
1879               /* Directly break constant into high and low parts.  This
1880                  provides better optimization opportunities because various
1881                  passes recognize constants split with PLUS but not LO_SUM.
1882                  We use a 14-bit signed low part except when the addition
1883                  of 0x4000 to the high part might change the sign of the
1884                  high part.  */
1885               HOST_WIDE_INT low = value & 0x3fff;
1886               HOST_WIDE_INT high = value & ~ 0x3fff;
1887
1888               if (low >= 0x2000)
1889                 {
1890                   if (high == 0x7fffc000 || (mode == HImode && high == 0x4000))
1891                     high += 0x2000;
1892                   else
1893                     high += 0x4000;
1894                 }
1895
1896               low = value - high;
1897
1898               emit_insn (gen_rtx_SET (VOIDmode, temp, GEN_INT (high)));
1899               operands[1] = gen_rtx_PLUS (mode, temp, GEN_INT (low));
1900             }
1901           else
1902             {
1903               emit_insn (gen_rtx_SET (VOIDmode, temp,
1904                                       gen_rtx_HIGH (mode, operand1)));
1905               operands[1] = gen_rtx_LO_SUM (mode, temp, operand1);
1906             }
1907
1908           insn = emit_move_insn (operands[0], operands[1]);
1909
1910           /* Now insert the most significant 32 bits of the value
1911              into the register.  When we don't have a second register
1912              available, it could take up to nine instructions to load
1913              a 64-bit integer constant.  Prior to reload, we force
1914              constants that would take more than three instructions
1915              to load to the constant pool.  During and after reload,
1916              we have to handle all possible values.  */
1917           if (insert)
1918             {
1919               /* Use a HIGH/LO_SUM/INSV sequence if we have a second
1920                  register and the value to be inserted is outside the
1921                  range that can be loaded with three depdi instructions.  */
1922               if (temp != operand0 && (insv >= 16384 || insv < -16384))
1923                 {
1924                   operand1 = GEN_INT (insv);
1925
1926                   emit_insn (gen_rtx_SET (VOIDmode, temp,
1927                                           gen_rtx_HIGH (mode, operand1)));
1928                   emit_move_insn (temp, gen_rtx_LO_SUM (mode, temp, operand1));
1929                   emit_insn (gen_insv (operand0, GEN_INT (32),
1930                                        const0_rtx, temp));
1931                 }
1932               else
1933                 {
1934                   int len = 5, pos = 27;
1935
1936                   /* Insert the bits using the depdi instruction.  */
1937                   while (pos >= 0)
1938                     {
1939                       HOST_WIDE_INT v5 = ((insv & 31) ^ 16) - 16;
1940                       HOST_WIDE_INT sign = v5 < 0;
1941
1942                       /* Left extend the insertion.  */
1943                       insv = (insv >= 0 ? insv >> len : ~(~insv >> len));
1944                       while (pos > 0 && (insv & 1) == sign)
1945                         {
1946                           insv = (insv >= 0 ? insv >> 1 : ~(~insv >> 1));
1947                           len += 1;
1948                           pos -= 1;
1949                         }
1950
1951                       emit_insn (gen_insv (operand0, GEN_INT (len),
1952                                            GEN_INT (pos), GEN_INT (v5)));
1953
1954                       len = pos > 0 && pos < 5 ? pos : 5;
1955                       pos -= len;
1956                     }
1957                 }
1958             }
1959
1960           REG_NOTES (insn)
1961             = gen_rtx_EXPR_LIST (REG_EQUAL, op1, REG_NOTES (insn));
1962
1963           return 1;
1964         }
1965     }
1966   /* Now have insn-emit do whatever it normally does.  */
1967   return 0;
1968 }
1969
1970 /* Examine EXP and return nonzero if it contains an ADDR_EXPR (meaning
1971    it will need a link/runtime reloc).  */
1972
1973 int
1974 reloc_needed (tree exp)
1975 {
1976   int reloc = 0;
1977
1978   switch (TREE_CODE (exp))
1979     {
1980     case ADDR_EXPR:
1981       return 1;
1982
1983     case PLUS_EXPR:
1984     case MINUS_EXPR:
1985       reloc = reloc_needed (TREE_OPERAND (exp, 0));
1986       reloc |= reloc_needed (TREE_OPERAND (exp, 1));
1987       break;
1988
1989     case NOP_EXPR:
1990     case CONVERT_EXPR:
1991     case NON_LVALUE_EXPR:
1992       reloc = reloc_needed (TREE_OPERAND (exp, 0));
1993       break;
1994
1995     case CONSTRUCTOR:
1996       {
1997         register tree link;
1998         for (link = CONSTRUCTOR_ELTS (exp); link; link = TREE_CHAIN (link))
1999           if (TREE_VALUE (link) != 0)
2000             reloc |= reloc_needed (TREE_VALUE (link));
2001       }
2002       break;
2003
2004     case ERROR_MARK:
2005       break;
2006
2007     default:
2008       break;
2009     }
2010   return reloc;
2011 }
2012
2013 /* Does operand (which is a symbolic_operand) live in text space?
2014    If so, SYMBOL_REF_FLAG, which is set by pa_encode_section_info,
2015    will be true.  */
2016
2017 int
2018 read_only_operand (rtx operand, enum machine_mode mode ATTRIBUTE_UNUSED)
2019 {
2020   if (GET_CODE (operand) == CONST)
2021     operand = XEXP (XEXP (operand, 0), 0);
2022   if (flag_pic)
2023     {
2024       if (GET_CODE (operand) == SYMBOL_REF)
2025         return SYMBOL_REF_FLAG (operand) && !CONSTANT_POOL_ADDRESS_P (operand);
2026     }
2027   else
2028     {
2029       if (GET_CODE (operand) == SYMBOL_REF)
2030         return SYMBOL_REF_FLAG (operand) || CONSTANT_POOL_ADDRESS_P (operand);
2031     }
2032   return 1;
2033 }
2034
2035 \f
2036 /* Return the best assembler insn template
2037    for moving operands[1] into operands[0] as a fullword.  */
2038 const char *
2039 singlemove_string (rtx *operands)
2040 {
2041   HOST_WIDE_INT intval;
2042
2043   if (GET_CODE (operands[0]) == MEM)
2044     return "stw %r1,%0";
2045   if (GET_CODE (operands[1]) == MEM)
2046     return "ldw %1,%0";
2047   if (GET_CODE (operands[1]) == CONST_DOUBLE)
2048     {
2049       long i;
2050       REAL_VALUE_TYPE d;
2051
2052       gcc_assert (GET_MODE (operands[1]) == SFmode);
2053
2054       /* Translate the CONST_DOUBLE to a CONST_INT with the same target
2055          bit pattern.  */
2056       REAL_VALUE_FROM_CONST_DOUBLE (d, operands[1]);
2057       REAL_VALUE_TO_TARGET_SINGLE (d, i);
2058
2059       operands[1] = GEN_INT (i);
2060       /* Fall through to CONST_INT case.  */
2061     }
2062   if (GET_CODE (operands[1]) == CONST_INT)
2063     {
2064       intval = INTVAL (operands[1]);
2065
2066       if (VAL_14_BITS_P (intval))
2067         return "ldi %1,%0";
2068       else if ((intval & 0x7ff) == 0)
2069         return "ldil L'%1,%0";
2070       else if (zdepi_cint_p (intval))
2071         return "{zdepi %Z1,%0|depwi,z %Z1,%0}";
2072       else
2073         return "ldil L'%1,%0\n\tldo R'%1(%0),%0";
2074     }
2075   return "copy %1,%0";
2076 }
2077 \f
2078
2079 /* Compute position (in OP[1]) and width (in OP[2])
2080    useful for copying IMM to a register using the zdepi
2081    instructions.  Store the immediate value to insert in OP[0].  */
2082 static void
2083 compute_zdepwi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2084 {
2085   int lsb, len;
2086
2087   /* Find the least significant set bit in IMM.  */
2088   for (lsb = 0; lsb < 32; lsb++)
2089     {
2090       if ((imm & 1) != 0)
2091         break;
2092       imm >>= 1;
2093     }
2094
2095   /* Choose variants based on *sign* of the 5-bit field.  */
2096   if ((imm & 0x10) == 0)
2097     len = (lsb <= 28) ? 4 : 32 - lsb;
2098   else
2099     {
2100       /* Find the width of the bitstring in IMM.  */
2101       for (len = 5; len < 32; len++)
2102         {
2103           if ((imm & (1 << len)) == 0)
2104             break;
2105         }
2106
2107       /* Sign extend IMM as a 5-bit value.  */
2108       imm = (imm & 0xf) - 0x10;
2109     }
2110
2111   op[0] = imm;
2112   op[1] = 31 - lsb;
2113   op[2] = len;
2114 }
2115
2116 /* Compute position (in OP[1]) and width (in OP[2])
2117    useful for copying IMM to a register using the depdi,z
2118    instructions.  Store the immediate value to insert in OP[0].  */
2119 void
2120 compute_zdepdi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2121 {
2122   HOST_WIDE_INT lsb, len;
2123
2124   /* Find the least significant set bit in IMM.  */
2125   for (lsb = 0; lsb < HOST_BITS_PER_WIDE_INT; lsb++)
2126     {
2127       if ((imm & 1) != 0)
2128         break;
2129       imm >>= 1;
2130     }
2131
2132   /* Choose variants based on *sign* of the 5-bit field.  */
2133   if ((imm & 0x10) == 0)
2134     len = ((lsb <= HOST_BITS_PER_WIDE_INT - 4)
2135            ? 4 : HOST_BITS_PER_WIDE_INT - lsb);
2136   else
2137     {
2138       /* Find the width of the bitstring in IMM.  */
2139       for (len = 5; len < HOST_BITS_PER_WIDE_INT; len++)
2140         {
2141           if ((imm & ((unsigned HOST_WIDE_INT) 1 << len)) == 0)
2142             break;
2143         }
2144
2145       /* Sign extend IMM as a 5-bit value.  */
2146       imm = (imm & 0xf) - 0x10;
2147     }
2148
2149   op[0] = imm;
2150   op[1] = 63 - lsb;
2151   op[2] = len;
2152 }
2153
2154 /* Output assembler code to perform a doubleword move insn
2155    with operands OPERANDS.  */
2156
2157 const char *
2158 output_move_double (rtx *operands)
2159 {
2160   enum { REGOP, OFFSOP, MEMOP, CNSTOP, RNDOP } optype0, optype1;
2161   rtx latehalf[2];
2162   rtx addreg0 = 0, addreg1 = 0;
2163
2164   /* First classify both operands.  */
2165
2166   if (REG_P (operands[0]))
2167     optype0 = REGOP;
2168   else if (offsettable_memref_p (operands[0]))
2169     optype0 = OFFSOP;
2170   else if (GET_CODE (operands[0]) == MEM)
2171     optype0 = MEMOP;
2172   else
2173     optype0 = RNDOP;
2174
2175   if (REG_P (operands[1]))
2176     optype1 = REGOP;
2177   else if (CONSTANT_P (operands[1]))
2178     optype1 = CNSTOP;
2179   else if (offsettable_memref_p (operands[1]))
2180     optype1 = OFFSOP;
2181   else if (GET_CODE (operands[1]) == MEM)
2182     optype1 = MEMOP;
2183   else
2184     optype1 = RNDOP;
2185
2186   /* Check for the cases that the operand constraints are not
2187      supposed to allow to happen.  */
2188   gcc_assert (optype0 == REGOP || optype1 == REGOP);
2189
2190    /* Handle auto decrementing and incrementing loads and stores
2191      specifically, since the structure of the function doesn't work
2192      for them without major modification.  Do it better when we learn
2193      this port about the general inc/dec addressing of PA.
2194      (This was written by tege.  Chide him if it doesn't work.)  */
2195
2196   if (optype0 == MEMOP)
2197     {
2198       /* We have to output the address syntax ourselves, since print_operand
2199          doesn't deal with the addresses we want to use.  Fix this later.  */
2200
2201       rtx addr = XEXP (operands[0], 0);
2202       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2203         {
2204           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2205
2206           operands[0] = XEXP (addr, 0);
2207           gcc_assert (GET_CODE (operands[1]) == REG
2208                       && GET_CODE (operands[0]) == REG);
2209
2210           gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
2211
2212           /* No overlap between high target register and address
2213              register.  (We do this in a non-obvious way to
2214              save a register file writeback)  */
2215           if (GET_CODE (addr) == POST_INC)
2216             return "{stws|stw},ma %1,8(%0)\n\tstw %R1,-4(%0)";
2217           return "{stws|stw},ma %1,-8(%0)\n\tstw %R1,12(%0)";
2218         }
2219       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2220         {
2221           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2222
2223           operands[0] = XEXP (addr, 0);
2224           gcc_assert (GET_CODE (operands[1]) == REG
2225                       && GET_CODE (operands[0]) == REG);
2226
2227           gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
2228           /* No overlap between high target register and address
2229              register.  (We do this in a non-obvious way to save a
2230              register file writeback)  */
2231           if (GET_CODE (addr) == PRE_INC)
2232             return "{stws|stw},mb %1,8(%0)\n\tstw %R1,4(%0)";
2233           return "{stws|stw},mb %1,-8(%0)\n\tstw %R1,4(%0)";
2234         }
2235     }
2236   if (optype1 == MEMOP)
2237     {
2238       /* We have to output the address syntax ourselves, since print_operand
2239          doesn't deal with the addresses we want to use.  Fix this later.  */
2240
2241       rtx addr = XEXP (operands[1], 0);
2242       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2243         {
2244           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2245
2246           operands[1] = XEXP (addr, 0);
2247           gcc_assert (GET_CODE (operands[0]) == REG
2248                       && GET_CODE (operands[1]) == REG);
2249
2250           if (!reg_overlap_mentioned_p (high_reg, addr))
2251             {
2252               /* No overlap between high target register and address
2253                  register.  (We do this in a non-obvious way to
2254                  save a register file writeback)  */
2255               if (GET_CODE (addr) == POST_INC)
2256                 return "{ldws|ldw},ma 8(%1),%0\n\tldw -4(%1),%R0";
2257               return "{ldws|ldw},ma -8(%1),%0\n\tldw 12(%1),%R0";
2258             }
2259           else
2260             {
2261               /* This is an undefined situation.  We should load into the
2262                  address register *and* update that register.  Probably
2263                  we don't need to handle this at all.  */
2264               if (GET_CODE (addr) == POST_INC)
2265                 return "ldw 4(%1),%R0\n\t{ldws|ldw},ma 8(%1),%0";
2266               return "ldw 4(%1),%R0\n\t{ldws|ldw},ma -8(%1),%0";
2267             }
2268         }
2269       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2270         {
2271           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2272
2273           operands[1] = XEXP (addr, 0);
2274           gcc_assert (GET_CODE (operands[0]) == REG
2275                       && GET_CODE (operands[1]) == REG);
2276
2277           if (!reg_overlap_mentioned_p (high_reg, addr))
2278             {
2279               /* No overlap between high target register and address
2280                  register.  (We do this in a non-obvious way to
2281                  save a register file writeback)  */
2282               if (GET_CODE (addr) == PRE_INC)
2283                 return "{ldws|ldw},mb 8(%1),%0\n\tldw 4(%1),%R0";
2284               return "{ldws|ldw},mb -8(%1),%0\n\tldw 4(%1),%R0";
2285             }
2286           else
2287             {
2288               /* This is an undefined situation.  We should load into the
2289                  address register *and* update that register.  Probably
2290                  we don't need to handle this at all.  */
2291               if (GET_CODE (addr) == PRE_INC)
2292                 return "ldw 12(%1),%R0\n\t{ldws|ldw},mb 8(%1),%0";
2293               return "ldw -4(%1),%R0\n\t{ldws|ldw},mb -8(%1),%0";
2294             }
2295         }
2296       else if (GET_CODE (addr) == PLUS
2297                && GET_CODE (XEXP (addr, 0)) == MULT)
2298         {
2299           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2300
2301           if (!reg_overlap_mentioned_p (high_reg, addr))
2302             {
2303               rtx xoperands[3];
2304
2305               xoperands[0] = high_reg;
2306               xoperands[1] = XEXP (addr, 1);
2307               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2308               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2309               output_asm_insn ("{sh%O3addl %2,%1,%0|shladd,l %2,%O3,%1,%0}",
2310                                xoperands);
2311               return "ldw 4(%0),%R0\n\tldw 0(%0),%0";
2312             }
2313           else
2314             {
2315               rtx xoperands[3];
2316
2317               xoperands[0] = high_reg;
2318               xoperands[1] = XEXP (addr, 1);
2319               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2320               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2321               output_asm_insn ("{sh%O3addl %2,%1,%R0|shladd,l %2,%O3,%1,%R0}",
2322                                xoperands);
2323               return "ldw 0(%R0),%0\n\tldw 4(%R0),%R0";
2324             }
2325         }
2326     }
2327
2328   /* If an operand is an unoffsettable memory ref, find a register
2329      we can increment temporarily to make it refer to the second word.  */
2330
2331   if (optype0 == MEMOP)
2332     addreg0 = find_addr_reg (XEXP (operands[0], 0));
2333
2334   if (optype1 == MEMOP)
2335     addreg1 = find_addr_reg (XEXP (operands[1], 0));
2336
2337   /* Ok, we can do one word at a time.
2338      Normally we do the low-numbered word first.
2339
2340      In either case, set up in LATEHALF the operands to use
2341      for the high-numbered word and in some cases alter the
2342      operands in OPERANDS to be suitable for the low-numbered word.  */
2343
2344   if (optype0 == REGOP)
2345     latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2346   else if (optype0 == OFFSOP)
2347     latehalf[0] = adjust_address (operands[0], SImode, 4);
2348   else
2349     latehalf[0] = operands[0];
2350
2351   if (optype1 == REGOP)
2352     latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2353   else if (optype1 == OFFSOP)
2354     latehalf[1] = adjust_address (operands[1], SImode, 4);
2355   else if (optype1 == CNSTOP)
2356     split_double (operands[1], &operands[1], &latehalf[1]);
2357   else
2358     latehalf[1] = operands[1];
2359
2360   /* If the first move would clobber the source of the second one,
2361      do them in the other order.
2362
2363      This can happen in two cases:
2364
2365         mem -> register where the first half of the destination register
2366         is the same register used in the memory's address.  Reload
2367         can create such insns.
2368
2369         mem in this case will be either register indirect or register
2370         indirect plus a valid offset.
2371
2372         register -> register move where REGNO(dst) == REGNO(src + 1)
2373         someone (Tim/Tege?) claimed this can happen for parameter loads.
2374
2375      Handle mem -> register case first.  */
2376   if (optype0 == REGOP
2377       && (optype1 == MEMOP || optype1 == OFFSOP)
2378       && refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
2379                             operands[1], 0))
2380     {
2381       /* Do the late half first.  */
2382       if (addreg1)
2383         output_asm_insn ("ldo 4(%0),%0", &addreg1);
2384       output_asm_insn (singlemove_string (latehalf), latehalf);
2385
2386       /* Then clobber.  */
2387       if (addreg1)
2388         output_asm_insn ("ldo -4(%0),%0", &addreg1);
2389       return singlemove_string (operands);
2390     }
2391
2392   /* Now handle register -> register case.  */
2393   if (optype0 == REGOP && optype1 == REGOP
2394       && REGNO (operands[0]) == REGNO (operands[1]) + 1)
2395     {
2396       output_asm_insn (singlemove_string (latehalf), latehalf);
2397       return singlemove_string (operands);
2398     }
2399
2400   /* Normal case: do the two words, low-numbered first.  */
2401
2402   output_asm_insn (singlemove_string (operands), operands);
2403
2404   /* Make any unoffsettable addresses point at high-numbered word.  */
2405   if (addreg0)
2406     output_asm_insn ("ldo 4(%0),%0", &addreg0);
2407   if (addreg1)
2408     output_asm_insn ("ldo 4(%0),%0", &addreg1);
2409
2410   /* Do that word.  */
2411   output_asm_insn (singlemove_string (latehalf), latehalf);
2412
2413   /* Undo the adds we just did.  */
2414   if (addreg0)
2415     output_asm_insn ("ldo -4(%0),%0", &addreg0);
2416   if (addreg1)
2417     output_asm_insn ("ldo -4(%0),%0", &addreg1);
2418
2419   return "";
2420 }
2421 \f
2422 const char *
2423 output_fp_move_double (rtx *operands)
2424 {
2425   if (FP_REG_P (operands[0]))
2426     {
2427       if (FP_REG_P (operands[1])
2428           || operands[1] == CONST0_RTX (GET_MODE (operands[0])))
2429         output_asm_insn ("fcpy,dbl %f1,%0", operands);
2430       else
2431         output_asm_insn ("fldd%F1 %1,%0", operands);
2432     }
2433   else if (FP_REG_P (operands[1]))
2434     {
2435       output_asm_insn ("fstd%F0 %1,%0", operands);
2436     }
2437   else
2438     {
2439       rtx xoperands[2];
2440
2441       gcc_assert (operands[1] == CONST0_RTX (GET_MODE (operands[0])));
2442
2443       /* This is a pain.  You have to be prepared to deal with an
2444          arbitrary address here including pre/post increment/decrement.
2445
2446          so avoid this in the MD.  */
2447       gcc_assert (GET_CODE (operands[0]) == REG);
2448
2449       xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2450       xoperands[0] = operands[0];
2451       output_asm_insn ("copy %%r0,%0\n\tcopy %%r0,%1", xoperands);
2452     }
2453   return "";
2454 }
2455 \f
2456 /* Return a REG that occurs in ADDR with coefficient 1.
2457    ADDR can be effectively incremented by incrementing REG.  */
2458
2459 static rtx
2460 find_addr_reg (rtx addr)
2461 {
2462   while (GET_CODE (addr) == PLUS)
2463     {
2464       if (GET_CODE (XEXP (addr, 0)) == REG)
2465         addr = XEXP (addr, 0);
2466       else if (GET_CODE (XEXP (addr, 1)) == REG)
2467         addr = XEXP (addr, 1);
2468       else if (CONSTANT_P (XEXP (addr, 0)))
2469         addr = XEXP (addr, 1);
2470       else if (CONSTANT_P (XEXP (addr, 1)))
2471         addr = XEXP (addr, 0);
2472       else
2473         gcc_unreachable ();
2474     }
2475   gcc_assert (GET_CODE (addr) == REG);
2476   return addr;
2477 }
2478
2479 /* Emit code to perform a block move.
2480
2481    OPERANDS[0] is the destination pointer as a REG, clobbered.
2482    OPERANDS[1] is the source pointer as a REG, clobbered.
2483    OPERANDS[2] is a register for temporary storage.
2484    OPERANDS[3] is a register for temporary storage.
2485    OPERANDS[4] is the size as a CONST_INT
2486    OPERANDS[5] is the alignment safe to use, as a CONST_INT.
2487    OPERANDS[6] is another temporary register.  */
2488
2489 const char *
2490 output_block_move (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2491 {
2492   int align = INTVAL (operands[5]);
2493   unsigned long n_bytes = INTVAL (operands[4]);
2494
2495   /* We can't move more than a word at a time because the PA
2496      has no longer integer move insns.  (Could use fp mem ops?)  */
2497   if (align > (TARGET_64BIT ? 8 : 4))
2498     align = (TARGET_64BIT ? 8 : 4);
2499
2500   /* Note that we know each loop below will execute at least twice
2501      (else we would have open-coded the copy).  */
2502   switch (align)
2503     {
2504       case 8:
2505         /* Pre-adjust the loop counter.  */
2506         operands[4] = GEN_INT (n_bytes - 16);
2507         output_asm_insn ("ldi %4,%2", operands);
2508
2509         /* Copying loop.  */
2510         output_asm_insn ("ldd,ma 8(%1),%3", operands);
2511         output_asm_insn ("ldd,ma 8(%1),%6", operands);
2512         output_asm_insn ("std,ma %3,8(%0)", operands);
2513         output_asm_insn ("addib,>= -16,%2,.-12", operands);
2514         output_asm_insn ("std,ma %6,8(%0)", operands);
2515
2516         /* Handle the residual.  There could be up to 7 bytes of
2517            residual to copy!  */
2518         if (n_bytes % 16 != 0)
2519           {
2520             operands[4] = GEN_INT (n_bytes % 8);
2521             if (n_bytes % 16 >= 8)
2522               output_asm_insn ("ldd,ma 8(%1),%3", operands);
2523             if (n_bytes % 8 != 0)
2524               output_asm_insn ("ldd 0(%1),%6", operands);
2525             if (n_bytes % 16 >= 8)
2526               output_asm_insn ("std,ma %3,8(%0)", operands);
2527             if (n_bytes % 8 != 0)
2528               output_asm_insn ("stdby,e %6,%4(%0)", operands);
2529           }
2530         return "";
2531
2532       case 4:
2533         /* Pre-adjust the loop counter.  */
2534         operands[4] = GEN_INT (n_bytes - 8);
2535         output_asm_insn ("ldi %4,%2", operands);
2536
2537         /* Copying loop.  */
2538         output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2539         output_asm_insn ("{ldws|ldw},ma 4(%1),%6", operands);
2540         output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2541         output_asm_insn ("addib,>= -8,%2,.-12", operands);
2542         output_asm_insn ("{stws|stw},ma %6,4(%0)", operands);
2543
2544         /* Handle the residual.  There could be up to 7 bytes of
2545            residual to copy!  */
2546         if (n_bytes % 8 != 0)
2547           {
2548             operands[4] = GEN_INT (n_bytes % 4);
2549             if (n_bytes % 8 >= 4)
2550               output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2551             if (n_bytes % 4 != 0)
2552               output_asm_insn ("ldw 0(%1),%6", operands);
2553             if (n_bytes % 8 >= 4)
2554               output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2555             if (n_bytes % 4 != 0)
2556               output_asm_insn ("{stbys|stby},e %6,%4(%0)", operands);
2557           }
2558         return "";
2559
2560       case 2:
2561         /* Pre-adjust the loop counter.  */
2562         operands[4] = GEN_INT (n_bytes - 4);
2563         output_asm_insn ("ldi %4,%2", operands);
2564
2565         /* Copying loop.  */
2566         output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2567         output_asm_insn ("{ldhs|ldh},ma 2(%1),%6", operands);
2568         output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2569         output_asm_insn ("addib,>= -4,%2,.-12", operands);
2570         output_asm_insn ("{sths|sth},ma %6,2(%0)", operands);
2571
2572         /* Handle the residual.  */
2573         if (n_bytes % 4 != 0)
2574           {
2575             if (n_bytes % 4 >= 2)
2576               output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2577             if (n_bytes % 2 != 0)
2578               output_asm_insn ("ldb 0(%1),%6", operands);
2579             if (n_bytes % 4 >= 2)
2580               output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2581             if (n_bytes % 2 != 0)
2582               output_asm_insn ("stb %6,0(%0)", operands);
2583           }
2584         return "";
2585
2586       case 1:
2587         /* Pre-adjust the loop counter.  */
2588         operands[4] = GEN_INT (n_bytes - 2);
2589         output_asm_insn ("ldi %4,%2", operands);
2590
2591         /* Copying loop.  */
2592         output_asm_insn ("{ldbs|ldb},ma 1(%1),%3", operands);
2593         output_asm_insn ("{ldbs|ldb},ma 1(%1),%6", operands);
2594         output_asm_insn ("{stbs|stb},ma %3,1(%0)", operands);
2595         output_asm_insn ("addib,>= -2,%2,.-12", operands);
2596         output_asm_insn ("{stbs|stb},ma %6,1(%0)", operands);
2597
2598         /* Handle the residual.  */
2599         if (n_bytes % 2 != 0)
2600           {
2601             output_asm_insn ("ldb 0(%1),%3", operands);
2602             output_asm_insn ("stb %3,0(%0)", operands);
2603           }
2604         return "";
2605
2606       default:
2607         gcc_unreachable ();
2608     }
2609 }
2610
2611 /* Count the number of insns necessary to handle this block move.
2612
2613    Basic structure is the same as emit_block_move, except that we
2614    count insns rather than emit them.  */
2615
2616 static int
2617 compute_movmem_length (rtx insn)
2618 {
2619   rtx pat = PATTERN (insn);
2620   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 7), 0));
2621   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 6), 0));
2622   unsigned int n_insns = 0;
2623
2624   /* We can't move more than four bytes at a time because the PA
2625      has no longer integer move insns.  (Could use fp mem ops?)  */
2626   if (align > (TARGET_64BIT ? 8 : 4))
2627     align = (TARGET_64BIT ? 8 : 4);
2628
2629   /* The basic copying loop.  */
2630   n_insns = 6;
2631
2632   /* Residuals.  */
2633   if (n_bytes % (2 * align) != 0)
2634     {
2635       if ((n_bytes % (2 * align)) >= align)
2636         n_insns += 2;
2637
2638       if ((n_bytes % align) != 0)
2639         n_insns += 2;
2640     }
2641
2642   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2643   return n_insns * 4;
2644 }
2645
2646 /* Emit code to perform a block clear.
2647
2648    OPERANDS[0] is the destination pointer as a REG, clobbered.
2649    OPERANDS[1] is a register for temporary storage.
2650    OPERANDS[2] is the size as a CONST_INT
2651    OPERANDS[3] is the alignment safe to use, as a CONST_INT.  */
2652
2653 const char *
2654 output_block_clear (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2655 {
2656   int align = INTVAL (operands[3]);
2657   unsigned long n_bytes = INTVAL (operands[2]);
2658
2659   /* We can't clear more than a word at a time because the PA
2660      has no longer integer move insns.  */
2661   if (align > (TARGET_64BIT ? 8 : 4))
2662     align = (TARGET_64BIT ? 8 : 4);
2663
2664   /* Note that we know each loop below will execute at least twice
2665      (else we would have open-coded the copy).  */
2666   switch (align)
2667     {
2668       case 8:
2669         /* Pre-adjust the loop counter.  */
2670         operands[2] = GEN_INT (n_bytes - 16);
2671         output_asm_insn ("ldi %2,%1", operands);
2672
2673         /* Loop.  */
2674         output_asm_insn ("std,ma %%r0,8(%0)", operands);
2675         output_asm_insn ("addib,>= -16,%1,.-4", operands);
2676         output_asm_insn ("std,ma %%r0,8(%0)", operands);
2677
2678         /* Handle the residual.  There could be up to 7 bytes of
2679            residual to copy!  */
2680         if (n_bytes % 16 != 0)
2681           {
2682             operands[2] = GEN_INT (n_bytes % 8);
2683             if (n_bytes % 16 >= 8)
2684               output_asm_insn ("std,ma %%r0,8(%0)", operands);
2685             if (n_bytes % 8 != 0)
2686               output_asm_insn ("stdby,e %%r0,%2(%0)", operands);
2687           }
2688         return "";
2689
2690       case 4:
2691         /* Pre-adjust the loop counter.  */
2692         operands[2] = GEN_INT (n_bytes - 8);
2693         output_asm_insn ("ldi %2,%1", operands);
2694
2695         /* Loop.  */
2696         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2697         output_asm_insn ("addib,>= -8,%1,.-4", operands);
2698         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2699
2700         /* Handle the residual.  There could be up to 7 bytes of
2701            residual to copy!  */
2702         if (n_bytes % 8 != 0)
2703           {
2704             operands[2] = GEN_INT (n_bytes % 4);
2705             if (n_bytes % 8 >= 4)
2706               output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2707             if (n_bytes % 4 != 0)
2708               output_asm_insn ("{stbys|stby},e %%r0,%2(%0)", operands);
2709           }
2710         return "";
2711
2712       case 2:
2713         /* Pre-adjust the loop counter.  */
2714         operands[2] = GEN_INT (n_bytes - 4);
2715         output_asm_insn ("ldi %2,%1", operands);
2716
2717         /* Loop.  */
2718         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2719         output_asm_insn ("addib,>= -4,%1,.-4", operands);
2720         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2721
2722         /* Handle the residual.  */
2723         if (n_bytes % 4 != 0)
2724           {
2725             if (n_bytes % 4 >= 2)
2726               output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2727             if (n_bytes % 2 != 0)
2728               output_asm_insn ("stb %%r0,0(%0)", operands);
2729           }
2730         return "";
2731
2732       case 1:
2733         /* Pre-adjust the loop counter.  */
2734         operands[2] = GEN_INT (n_bytes - 2);
2735         output_asm_insn ("ldi %2,%1", operands);
2736
2737         /* Loop.  */
2738         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
2739         output_asm_insn ("addib,>= -2,%1,.-4", operands);
2740         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
2741
2742         /* Handle the residual.  */
2743         if (n_bytes % 2 != 0)
2744           output_asm_insn ("stb %%r0,0(%0)", operands);
2745
2746         return "";
2747
2748       default:
2749         gcc_unreachable ();
2750     }
2751 }
2752
2753 /* Count the number of insns necessary to handle this block move.
2754
2755    Basic structure is the same as emit_block_move, except that we
2756    count insns rather than emit them.  */
2757
2758 static int
2759 compute_clrmem_length (rtx insn)
2760 {
2761   rtx pat = PATTERN (insn);
2762   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 4), 0));
2763   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 3), 0));
2764   unsigned int n_insns = 0;
2765
2766   /* We can't clear more than a word at a time because the PA
2767      has no longer integer move insns.  */
2768   if (align > (TARGET_64BIT ? 8 : 4))
2769     align = (TARGET_64BIT ? 8 : 4);
2770
2771   /* The basic loop.  */
2772   n_insns = 4;
2773
2774   /* Residuals.  */
2775   if (n_bytes % (2 * align) != 0)
2776     {
2777       if ((n_bytes % (2 * align)) >= align)
2778         n_insns++;
2779
2780       if ((n_bytes % align) != 0)
2781         n_insns++;
2782     }
2783
2784   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2785   return n_insns * 4;
2786 }
2787 \f
2788
2789 const char *
2790 output_and (rtx *operands)
2791 {
2792   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
2793     {
2794       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2795       int ls0, ls1, ms0, p, len;
2796
2797       for (ls0 = 0; ls0 < 32; ls0++)
2798         if ((mask & (1 << ls0)) == 0)
2799           break;
2800
2801       for (ls1 = ls0; ls1 < 32; ls1++)
2802         if ((mask & (1 << ls1)) != 0)
2803           break;
2804
2805       for (ms0 = ls1; ms0 < 32; ms0++)
2806         if ((mask & (1 << ms0)) == 0)
2807           break;
2808
2809       gcc_assert (ms0 == 32);
2810
2811       if (ls1 == 32)
2812         {
2813           len = ls0;
2814
2815           gcc_assert (len);
2816
2817           operands[2] = GEN_INT (len);
2818           return "{extru|extrw,u} %1,31,%2,%0";
2819         }
2820       else
2821         {
2822           /* We could use this `depi' for the case above as well, but `depi'
2823              requires one more register file access than an `extru'.  */
2824
2825           p = 31 - ls0;
2826           len = ls1 - ls0;
2827
2828           operands[2] = GEN_INT (p);
2829           operands[3] = GEN_INT (len);
2830           return "{depi|depwi} 0,%2,%3,%0";
2831         }
2832     }
2833   else
2834     return "and %1,%2,%0";
2835 }
2836
2837 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
2838    storing the result in operands[0].  */
2839 const char *
2840 output_64bit_and (rtx *operands)
2841 {
2842   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
2843     {
2844       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2845       int ls0, ls1, ms0, p, len;
2846
2847       for (ls0 = 0; ls0 < HOST_BITS_PER_WIDE_INT; ls0++)
2848         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls0)) == 0)
2849           break;
2850
2851       for (ls1 = ls0; ls1 < HOST_BITS_PER_WIDE_INT; ls1++)
2852         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls1)) != 0)
2853           break;
2854
2855       for (ms0 = ls1; ms0 < HOST_BITS_PER_WIDE_INT; ms0++)
2856         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ms0)) == 0)
2857           break;
2858
2859       gcc_assert (ms0 == HOST_BITS_PER_WIDE_INT);
2860
2861       if (ls1 == HOST_BITS_PER_WIDE_INT)
2862         {
2863           len = ls0;
2864
2865           gcc_assert (len);
2866
2867           operands[2] = GEN_INT (len);
2868           return "extrd,u %1,63,%2,%0";
2869         }
2870       else
2871         {
2872           /* We could use this `depi' for the case above as well, but `depi'
2873              requires one more register file access than an `extru'.  */
2874
2875           p = 63 - ls0;
2876           len = ls1 - ls0;
2877
2878           operands[2] = GEN_INT (p);
2879           operands[3] = GEN_INT (len);
2880           return "depdi 0,%2,%3,%0";
2881         }
2882     }
2883   else
2884     return "and %1,%2,%0";
2885 }
2886
2887 const char *
2888 output_ior (rtx *operands)
2889 {
2890   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2891   int bs0, bs1, p, len;
2892
2893   if (INTVAL (operands[2]) == 0)
2894     return "copy %1,%0";
2895
2896   for (bs0 = 0; bs0 < 32; bs0++)
2897     if ((mask & (1 << bs0)) != 0)
2898       break;
2899
2900   for (bs1 = bs0; bs1 < 32; bs1++)
2901     if ((mask & (1 << bs1)) == 0)
2902       break;
2903
2904   gcc_assert (bs1 == 32 || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
2905
2906   p = 31 - bs0;
2907   len = bs1 - bs0;
2908
2909   operands[2] = GEN_INT (p);
2910   operands[3] = GEN_INT (len);
2911   return "{depi|depwi} -1,%2,%3,%0";
2912 }
2913
2914 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
2915    storing the result in operands[0].  */
2916 const char *
2917 output_64bit_ior (rtx *operands)
2918 {
2919   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2920   int bs0, bs1, p, len;
2921
2922   if (INTVAL (operands[2]) == 0)
2923     return "copy %1,%0";
2924
2925   for (bs0 = 0; bs0 < HOST_BITS_PER_WIDE_INT; bs0++)
2926     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs0)) != 0)
2927       break;
2928
2929   for (bs1 = bs0; bs1 < HOST_BITS_PER_WIDE_INT; bs1++)
2930     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs1)) == 0)
2931       break;
2932
2933   gcc_assert (bs1 == HOST_BITS_PER_WIDE_INT
2934               || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
2935
2936   p = 63 - bs0;
2937   len = bs1 - bs0;
2938
2939   operands[2] = GEN_INT (p);
2940   operands[3] = GEN_INT (len);
2941   return "depdi -1,%2,%3,%0";
2942 }
2943 \f
2944 /* Target hook for assembling integer objects.  This code handles
2945    aligned SI and DI integers specially since function references
2946    must be preceded by P%.  */
2947
2948 static bool
2949 pa_assemble_integer (rtx x, unsigned int size, int aligned_p)
2950 {
2951   if (size == UNITS_PER_WORD
2952       && aligned_p
2953       && function_label_operand (x, VOIDmode))
2954     {
2955       fputs (size == 8? "\t.dword\tP%" : "\t.word\tP%", asm_out_file);
2956       output_addr_const (asm_out_file, x);
2957       fputc ('\n', asm_out_file);
2958       return true;
2959     }
2960   return default_assemble_integer (x, size, aligned_p);
2961 }
2962 \f
2963 /* Output an ascii string.  */
2964 void
2965 output_ascii (FILE *file, const char *p, int size)
2966 {
2967   int i;
2968   int chars_output;
2969   unsigned char partial_output[16];     /* Max space 4 chars can occupy.  */
2970
2971   /* The HP assembler can only take strings of 256 characters at one
2972      time.  This is a limitation on input line length, *not* the
2973      length of the string.  Sigh.  Even worse, it seems that the
2974      restriction is in number of input characters (see \xnn &
2975      \whatever).  So we have to do this very carefully.  */
2976
2977   fputs ("\t.STRING \"", file);
2978
2979   chars_output = 0;
2980   for (i = 0; i < size; i += 4)
2981     {
2982       int co = 0;
2983       int io = 0;
2984       for (io = 0, co = 0; io < MIN (4, size - i); io++)
2985         {
2986           register unsigned int c = (unsigned char) p[i + io];
2987
2988           if (c == '\"' || c == '\\')
2989             partial_output[co++] = '\\';
2990           if (c >= ' ' && c < 0177)
2991             partial_output[co++] = c;
2992           else
2993             {
2994               unsigned int hexd;
2995               partial_output[co++] = '\\';
2996               partial_output[co++] = 'x';
2997               hexd =  c  / 16 - 0 + '0';
2998               if (hexd > '9')
2999                 hexd -= '9' - 'a' + 1;
3000               partial_output[co++] = hexd;
3001               hexd =  c % 16 - 0 + '0';
3002               if (hexd > '9')
3003                 hexd -= '9' - 'a' + 1;
3004               partial_output[co++] = hexd;
3005             }
3006         }
3007       if (chars_output + co > 243)
3008         {
3009           fputs ("\"\n\t.STRING \"", file);
3010           chars_output = 0;
3011         }
3012       fwrite (partial_output, 1, (size_t) co, file);
3013       chars_output += co;
3014       co = 0;
3015     }
3016   fputs ("\"\n", file);
3017 }
3018
3019 /* Try to rewrite floating point comparisons & branches to avoid
3020    useless add,tr insns.
3021
3022    CHECK_NOTES is nonzero if we should examine REG_DEAD notes
3023    to see if FPCC is dead.  CHECK_NOTES is nonzero for the
3024    first attempt to remove useless add,tr insns.  It is zero
3025    for the second pass as reorg sometimes leaves bogus REG_DEAD
3026    notes lying around.
3027
3028    When CHECK_NOTES is zero we can only eliminate add,tr insns
3029    when there's a 1:1 correspondence between fcmp and ftest/fbranch
3030    instructions.  */
3031 static void
3032 remove_useless_addtr_insns (int check_notes)
3033 {
3034   rtx insn;
3035   static int pass = 0;
3036
3037   /* This is fairly cheap, so always run it when optimizing.  */
3038   if (optimize > 0)
3039     {
3040       int fcmp_count = 0;
3041       int fbranch_count = 0;
3042
3043       /* Walk all the insns in this function looking for fcmp & fbranch
3044          instructions.  Keep track of how many of each we find.  */
3045       for (insn = get_insns (); insn; insn = next_insn (insn))
3046         {
3047           rtx tmp;
3048
3049           /* Ignore anything that isn't an INSN or a JUMP_INSN.  */
3050           if (GET_CODE (insn) != INSN && GET_CODE (insn) != JUMP_INSN)
3051             continue;
3052
3053           tmp = PATTERN (insn);
3054
3055           /* It must be a set.  */
3056           if (GET_CODE (tmp) != SET)
3057             continue;
3058
3059           /* If the destination is CCFP, then we've found an fcmp insn.  */
3060           tmp = SET_DEST (tmp);
3061           if (GET_CODE (tmp) == REG && REGNO (tmp) == 0)
3062             {
3063               fcmp_count++;
3064               continue;
3065             }
3066
3067           tmp = PATTERN (insn);
3068           /* If this is an fbranch instruction, bump the fbranch counter.  */
3069           if (GET_CODE (tmp) == SET
3070               && SET_DEST (tmp) == pc_rtx
3071               && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
3072               && GET_CODE (XEXP (SET_SRC (tmp), 0)) == NE
3073               && GET_CODE (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == REG
3074               && REGNO (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == 0)
3075             {
3076               fbranch_count++;
3077               continue;
3078             }
3079         }
3080
3081
3082       /* Find all floating point compare + branch insns.  If possible,
3083          reverse the comparison & the branch to avoid add,tr insns.  */
3084       for (insn = get_insns (); insn; insn = next_insn (insn))
3085         {
3086           rtx tmp, next;
3087
3088           /* Ignore anything that isn't an INSN.  */
3089           if (GET_CODE (insn) != INSN)
3090             continue;
3091
3092           tmp = PATTERN (insn);
3093
3094           /* It must be a set.  */
3095           if (GET_CODE (tmp) != SET)
3096             continue;
3097
3098           /* The destination must be CCFP, which is register zero.  */
3099           tmp = SET_DEST (tmp);
3100           if (GET_CODE (tmp) != REG || REGNO (tmp) != 0)
3101             continue;
3102
3103           /* INSN should be a set of CCFP.
3104
3105              See if the result of this insn is used in a reversed FP
3106              conditional branch.  If so, reverse our condition and
3107              the branch.  Doing so avoids useless add,tr insns.  */
3108           next = next_insn (insn);
3109           while (next)
3110             {
3111               /* Jumps, calls and labels stop our search.  */
3112               if (GET_CODE (next) == JUMP_INSN
3113                   || GET_CODE (next) == CALL_INSN
3114                   || GET_CODE (next) == CODE_LABEL)
3115                 break;
3116
3117               /* As does another fcmp insn.  */
3118               if (GET_CODE (next) == INSN
3119                   && GET_CODE (PATTERN (next)) == SET
3120                   && GET_CODE (SET_DEST (PATTERN (next))) == REG
3121                   && REGNO (SET_DEST (PATTERN (next))) == 0)
3122                 break;
3123
3124               next = next_insn (next);
3125             }
3126
3127           /* Is NEXT_INSN a branch?  */
3128           if (next
3129               && GET_CODE (next) == JUMP_INSN)
3130             {
3131               rtx pattern = PATTERN (next);
3132
3133               /* If it a reversed fp conditional branch (e.g. uses add,tr)
3134                  and CCFP dies, then reverse our conditional and the branch
3135                  to avoid the add,tr.  */
3136               if (GET_CODE (pattern) == SET
3137                   && SET_DEST (pattern) == pc_rtx
3138                   && GET_CODE (SET_SRC (pattern)) == IF_THEN_ELSE
3139                   && GET_CODE (XEXP (SET_SRC (pattern), 0)) == NE
3140                   && GET_CODE (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == REG
3141                   && REGNO (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == 0
3142                   && GET_CODE (XEXP (SET_SRC (pattern), 1)) == PC
3143                   && (fcmp_count == fbranch_count
3144                       || (check_notes
3145                           && find_regno_note (next, REG_DEAD, 0))))
3146                 {
3147                   /* Reverse the branch.  */
3148                   tmp = XEXP (SET_SRC (pattern), 1);
3149                   XEXP (SET_SRC (pattern), 1) = XEXP (SET_SRC (pattern), 2);
3150                   XEXP (SET_SRC (pattern), 2) = tmp;
3151                   INSN_CODE (next) = -1;
3152
3153                   /* Reverse our condition.  */
3154                   tmp = PATTERN (insn);
3155                   PUT_CODE (XEXP (tmp, 1),
3156                             (reverse_condition_maybe_unordered
3157                              (GET_CODE (XEXP (tmp, 1)))));
3158                 }
3159             }
3160         }
3161     }
3162
3163   pass = !pass;
3164
3165 }
3166 \f
3167 /* You may have trouble believing this, but this is the 32 bit HP-PA
3168    stack layout.  Wow.
3169
3170    Offset               Contents
3171
3172    Variable arguments   (optional; any number may be allocated)
3173
3174    SP-(4*(N+9))         arg word N
3175         :                   :
3176       SP-56             arg word 5
3177       SP-52             arg word 4
3178
3179    Fixed arguments      (must be allocated; may remain unused)
3180
3181       SP-48             arg word 3
3182       SP-44             arg word 2
3183       SP-40             arg word 1
3184       SP-36             arg word 0
3185
3186    Frame Marker
3187
3188       SP-32             External Data Pointer (DP)
3189       SP-28             External sr4
3190       SP-24             External/stub RP (RP')
3191       SP-20             Current RP
3192       SP-16             Static Link
3193       SP-12             Clean up
3194       SP-8              Calling Stub RP (RP'')
3195       SP-4              Previous SP
3196
3197    Top of Frame
3198
3199       SP-0              Stack Pointer (points to next available address)
3200
3201 */
3202
3203 /* This function saves registers as follows.  Registers marked with ' are
3204    this function's registers (as opposed to the previous function's).
3205    If a frame_pointer isn't needed, r4 is saved as a general register;
3206    the space for the frame pointer is still allocated, though, to keep
3207    things simple.
3208
3209
3210    Top of Frame
3211
3212        SP (FP')         Previous FP
3213        SP + 4           Alignment filler (sigh)
3214        SP + 8           Space for locals reserved here.
3215        .
3216        .
3217        .
3218        SP + n           All call saved register used.
3219        .
3220        .
3221        .
3222        SP + o           All call saved fp registers used.
3223        .
3224        .
3225        .
3226        SP + p (SP')     points to next available address.
3227
3228 */
3229
3230 /* Global variables set by output_function_prologue().  */
3231 /* Size of frame.  Need to know this to emit return insns from
3232    leaf procedures.  */
3233 static HOST_WIDE_INT actual_fsize, local_fsize;
3234 static int save_fregs;
3235
3236 /* Emit RTL to store REG at the memory location specified by BASE+DISP.
3237    Handle case where DISP > 8k by using the add_high_const patterns.
3238
3239    Note in DISP > 8k case, we will leave the high part of the address
3240    in %r1.  There is code in expand_hppa_{prologue,epilogue} that knows this.*/
3241
3242 static void
3243 store_reg (int reg, HOST_WIDE_INT disp, int base)
3244 {
3245   rtx insn, dest, src, basereg;
3246
3247   src = gen_rtx_REG (word_mode, reg);
3248   basereg = gen_rtx_REG (Pmode, base);
3249   if (VAL_14_BITS_P (disp))
3250     {
3251       dest = gen_rtx_MEM (word_mode, plus_constant (basereg, disp));
3252       insn = emit_move_insn (dest, src);
3253     }
3254   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3255     {
3256       rtx delta = GEN_INT (disp);
3257       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3258
3259       emit_move_insn (tmpreg, delta);
3260       emit_move_insn (tmpreg, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3261       dest = gen_rtx_MEM (word_mode, tmpreg);
3262       insn = emit_move_insn (dest, src);
3263       if (DO_FRAME_NOTES)
3264         {
3265           REG_NOTES (insn)
3266             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3267                 gen_rtx_SET (VOIDmode,
3268                              gen_rtx_MEM (word_mode,
3269                                           gen_rtx_PLUS (word_mode, basereg,
3270                                                         delta)),
3271                              src),
3272                 REG_NOTES (insn));
3273         }
3274     }
3275   else
3276     {
3277       rtx delta = GEN_INT (disp);
3278       rtx high = gen_rtx_PLUS (Pmode, basereg, gen_rtx_HIGH (Pmode, delta));
3279       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3280
3281       emit_move_insn (tmpreg, high);
3282       dest = gen_rtx_MEM (word_mode, gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3283       insn = emit_move_insn (dest, src);
3284       if (DO_FRAME_NOTES)
3285         {
3286           REG_NOTES (insn)
3287             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3288                 gen_rtx_SET (VOIDmode,
3289                              gen_rtx_MEM (word_mode,
3290                                           gen_rtx_PLUS (word_mode, basereg,
3291                                                         delta)),
3292                              src),
3293                 REG_NOTES (insn));
3294         }
3295     }
3296
3297   if (DO_FRAME_NOTES)
3298     RTX_FRAME_RELATED_P (insn) = 1;
3299 }
3300
3301 /* Emit RTL to store REG at the memory location specified by BASE and then
3302    add MOD to BASE.  MOD must be <= 8k.  */
3303
3304 static void
3305 store_reg_modify (int base, int reg, HOST_WIDE_INT mod)
3306 {
3307   rtx insn, basereg, srcreg, delta;
3308
3309   gcc_assert (VAL_14_BITS_P (mod));
3310
3311   basereg = gen_rtx_REG (Pmode, base);
3312   srcreg = gen_rtx_REG (word_mode, reg);
3313   delta = GEN_INT (mod);
3314
3315   insn = emit_insn (gen_post_store (basereg, srcreg, delta));
3316   if (DO_FRAME_NOTES)
3317     {
3318       RTX_FRAME_RELATED_P (insn) = 1;
3319
3320       /* RTX_FRAME_RELATED_P must be set on each frame related set
3321          in a parallel with more than one element.  Don't set
3322          RTX_FRAME_RELATED_P in the first set if reg is temporary
3323          register 1. The effect of this operation is recorded in
3324          the initial copy.  */
3325       if (reg != 1)
3326         {
3327           RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 0)) = 1;
3328           RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 1)) = 1;
3329         }
3330       else
3331         {
3332           /* The first element of a PARALLEL is always processed if it is
3333              a SET.  Thus, we need an expression list for this case.  */
3334           REG_NOTES (insn)
3335             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3336                 gen_rtx_SET (VOIDmode, basereg,
3337                              gen_rtx_PLUS (word_mode, basereg, delta)),
3338                 REG_NOTES (insn));
3339         }
3340     }
3341 }
3342
3343 /* Emit RTL to set REG to the value specified by BASE+DISP.  Handle case
3344    where DISP > 8k by using the add_high_const patterns.  NOTE indicates
3345    whether to add a frame note or not.
3346
3347    In the DISP > 8k case, we leave the high part of the address in %r1.
3348    There is code in expand_hppa_{prologue,epilogue} that knows about this.  */
3349
3350 static void
3351 set_reg_plus_d (int reg, int base, HOST_WIDE_INT disp, int note)
3352 {
3353   rtx insn;
3354
3355   if (VAL_14_BITS_P (disp))
3356     {
3357       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3358                              plus_constant (gen_rtx_REG (Pmode, base), disp));
3359     }
3360   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3361     {
3362       rtx basereg = gen_rtx_REG (Pmode, base);
3363       rtx delta = GEN_INT (disp);
3364       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3365
3366       emit_move_insn (tmpreg, delta);
3367       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3368                              gen_rtx_PLUS (Pmode, tmpreg, basereg));
3369     }
3370   else
3371     {
3372       rtx basereg = gen_rtx_REG (Pmode, base);
3373       rtx delta = GEN_INT (disp);
3374       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3375
3376       emit_move_insn (tmpreg,
3377                       gen_rtx_PLUS (Pmode, basereg,
3378                                     gen_rtx_HIGH (Pmode, delta)));
3379       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3380                              gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3381     }
3382
3383   if (DO_FRAME_NOTES && note)
3384     RTX_FRAME_RELATED_P (insn) = 1;
3385 }
3386
3387 HOST_WIDE_INT
3388 compute_frame_size (HOST_WIDE_INT size, int *fregs_live)
3389 {
3390   int freg_saved = 0;
3391   int i, j;
3392
3393   /* The code in hppa_expand_prologue and hppa_expand_epilogue must
3394      be consistent with the rounding and size calculation done here.
3395      Change them at the same time.  */
3396
3397   /* We do our own stack alignment.  First, round the size of the
3398      stack locals up to a word boundary.  */
3399   size = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3400
3401   /* Space for previous frame pointer + filler.  If any frame is
3402      allocated, we need to add in the STARTING_FRAME_OFFSET.  We
3403      waste some space here for the sake of HP compatibility.  The
3404      first slot is only used when the frame pointer is needed.  */
3405   if (size || frame_pointer_needed)
3406     size += STARTING_FRAME_OFFSET;
3407
3408   /* If the current function calls __builtin_eh_return, then we need
3409      to allocate stack space for registers that will hold data for
3410      the exception handler.  */
3411   if (DO_FRAME_NOTES && current_function_calls_eh_return)
3412     {
3413       unsigned int i;
3414
3415       for (i = 0; EH_RETURN_DATA_REGNO (i) != INVALID_REGNUM; ++i)
3416         continue;
3417       size += i * UNITS_PER_WORD;
3418     }
3419
3420   /* Account for space used by the callee general register saves.  */
3421   for (i = 18, j = frame_pointer_needed ? 4 : 3; i >= j; i--)
3422     if (regs_ever_live[i])
3423       size += UNITS_PER_WORD;
3424
3425   /* Account for space used by the callee floating point register saves.  */
3426   for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
3427     if (regs_ever_live[i]
3428         || (!TARGET_64BIT && regs_ever_live[i + 1]))
3429       {
3430         freg_saved = 1;
3431
3432         /* We always save both halves of the FP register, so always
3433            increment the frame size by 8 bytes.  */
3434         size += 8;
3435       }
3436
3437   /* If any of the floating registers are saved, account for the
3438      alignment needed for the floating point register save block.  */
3439   if (freg_saved)
3440     {
3441       size = (size + 7) & ~7;
3442       if (fregs_live)
3443         *fregs_live = 1;
3444     }
3445
3446   /* The various ABIs include space for the outgoing parameters in the
3447      size of the current function's stack frame.  We don't need to align
3448      for the outgoing arguments as their alignment is set by the final
3449      rounding for the frame as a whole.  */
3450   size += current_function_outgoing_args_size;
3451
3452   /* Allocate space for the fixed frame marker.  This space must be
3453      allocated for any function that makes calls or allocates
3454      stack space.  */
3455   if (!current_function_is_leaf || size)
3456     size += TARGET_64BIT ? 48 : 32;
3457
3458   /* Finally, round to the preferred stack boundary.  */
3459   return ((size + PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)
3460           & ~(PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1));
3461 }
3462
3463 /* Generate the assembly code for function entry.  FILE is a stdio
3464    stream to output the code to.  SIZE is an int: how many units of
3465    temporary storage to allocate.
3466
3467    Refer to the array `regs_ever_live' to determine which registers to
3468    save; `regs_ever_live[I]' is nonzero if register number I is ever
3469    used in the function.  This function is responsible for knowing
3470    which registers should not be saved even if used.  */
3471
3472 /* On HP-PA, move-double insns between fpu and cpu need an 8-byte block
3473    of memory.  If any fpu reg is used in the function, we allocate
3474    such a block here, at the bottom of the frame, just in case it's needed.
3475
3476    If this function is a leaf procedure, then we may choose not
3477    to do a "save" insn.  The decision about whether or not
3478    to do this is made in regclass.c.  */
3479
3480 static void
3481 pa_output_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3482 {
3483   /* The function's label and associated .PROC must never be
3484      separated and must be output *after* any profiling declarations
3485      to avoid changing spaces/subspaces within a procedure.  */
3486   ASM_OUTPUT_LABEL (file, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
3487   fputs ("\t.PROC\n", file);
3488
3489   /* hppa_expand_prologue does the dirty work now.  We just need
3490      to output the assembler directives which denote the start
3491      of a function.  */
3492   fprintf (file, "\t.CALLINFO FRAME=" HOST_WIDE_INT_PRINT_DEC, actual_fsize);
3493   if (regs_ever_live[2])
3494     fputs (",CALLS,SAVE_RP", file);
3495   else
3496     fputs (",NO_CALLS", file);
3497
3498   /* The SAVE_SP flag is used to indicate that register %r3 is stored
3499      at the beginning of the frame and that it is used as the frame
3500      pointer for the frame.  We do this because our current frame
3501      layout doesn't conform to that specified in the the HP runtime
3502      documentation and we need a way to indicate to programs such as
3503      GDB where %r3 is saved.  The SAVE_SP flag was chosen because it
3504      isn't used by HP compilers but is supported by the assembler.
3505      However, SAVE_SP is supposed to indicate that the previous stack
3506      pointer has been saved in the frame marker.  */
3507   if (frame_pointer_needed)
3508     fputs (",SAVE_SP", file);
3509
3510   /* Pass on information about the number of callee register saves
3511      performed in the prologue.
3512
3513      The compiler is supposed to pass the highest register number
3514      saved, the assembler then has to adjust that number before
3515      entering it into the unwind descriptor (to account for any
3516      caller saved registers with lower register numbers than the
3517      first callee saved register).  */
3518   if (gr_saved)
3519     fprintf (file, ",ENTRY_GR=%d", gr_saved + 2);
3520
3521   if (fr_saved)
3522     fprintf (file, ",ENTRY_FR=%d", fr_saved + 11);
3523
3524   fputs ("\n\t.ENTRY\n", file);
3525
3526   remove_useless_addtr_insns (0);
3527 }
3528
3529 void
3530 hppa_expand_prologue (void)
3531 {
3532   int merge_sp_adjust_with_store = 0;
3533   HOST_WIDE_INT size = get_frame_size ();
3534   HOST_WIDE_INT offset;
3535   int i;
3536   rtx insn, tmpreg;
3537
3538   gr_saved = 0;
3539   fr_saved = 0;
3540   save_fregs = 0;
3541
3542   /* Compute total size for frame pointer, filler, locals and rounding to
3543      the next word boundary.  Similar code appears in compute_frame_size
3544      and must be changed in tandem with this code.  */
3545   local_fsize = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3546   if (local_fsize || frame_pointer_needed)
3547     local_fsize += STARTING_FRAME_OFFSET;
3548
3549   actual_fsize = compute_frame_size (size, &save_fregs);
3550
3551   /* Compute a few things we will use often.  */
3552   tmpreg = gen_rtx_REG (word_mode, 1);
3553
3554   /* Save RP first.  The calling conventions manual states RP will
3555      always be stored into the caller's frame at sp - 20 or sp - 16
3556      depending on which ABI is in use.  */
3557   if (regs_ever_live[2] || current_function_calls_eh_return)
3558     store_reg (2, TARGET_64BIT ? -16 : -20, STACK_POINTER_REGNUM);
3559
3560   /* Allocate the local frame and set up the frame pointer if needed.  */
3561   if (actual_fsize != 0)
3562     {
3563       if (frame_pointer_needed)
3564         {
3565           /* Copy the old frame pointer temporarily into %r1.  Set up the
3566              new stack pointer, then store away the saved old frame pointer
3567              into the stack at sp and at the same time update the stack
3568              pointer by actual_fsize bytes.  Two versions, first
3569              handles small (<8k) frames.  The second handles large (>=8k)
3570              frames.  */
3571           insn = emit_move_insn (tmpreg, frame_pointer_rtx);
3572           if (DO_FRAME_NOTES)
3573             {
3574               /* We need to record the frame pointer save here since the
3575                  new frame pointer is set in the following insn.  */
3576               RTX_FRAME_RELATED_P (insn) = 1;
3577               REG_NOTES (insn)
3578                 = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3579                     gen_rtx_SET (VOIDmode,
3580                                  gen_rtx_MEM (word_mode, stack_pointer_rtx),
3581                                  frame_pointer_rtx),
3582                     REG_NOTES (insn));
3583             }
3584
3585           insn = emit_move_insn (frame_pointer_rtx, stack_pointer_rtx);
3586           if (DO_FRAME_NOTES)
3587             RTX_FRAME_RELATED_P (insn) = 1;
3588
3589           if (VAL_14_BITS_P (actual_fsize))
3590             store_reg_modify (STACK_POINTER_REGNUM, 1, actual_fsize);
3591           else
3592             {
3593               /* It is incorrect to store the saved frame pointer at *sp,
3594                  then increment sp (writes beyond the current stack boundary).
3595
3596                  So instead use stwm to store at *sp and post-increment the
3597                  stack pointer as an atomic operation.  Then increment sp to
3598                  finish allocating the new frame.  */
3599               HOST_WIDE_INT adjust1 = 8192 - 64;
3600               HOST_WIDE_INT adjust2 = actual_fsize - adjust1;
3601
3602               store_reg_modify (STACK_POINTER_REGNUM, 1, adjust1);
3603               set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3604                               adjust2, 1);
3605             }
3606
3607           /* We set SAVE_SP in frames that need a frame pointer.  Thus,
3608              we need to store the previous stack pointer (frame pointer)
3609              into the frame marker on targets that use the HP unwind
3610              library.  This allows the HP unwind library to be used to
3611              unwind GCC frames.  However, we are not fully compatible
3612              with the HP library because our frame layout differs from
3613              that specified in the HP runtime specification.
3614
3615              We don't want a frame note on this instruction as the frame
3616              marker moves during dynamic stack allocation.
3617
3618              This instruction also serves as a blockage to prevent
3619              register spills from being scheduled before the stack
3620              pointer is raised.  This is necessary as we store
3621              registers using the frame pointer as a base register,
3622              and the frame pointer is set before sp is raised.  */
3623           if (TARGET_HPUX_UNWIND_LIBRARY)
3624             {
3625               rtx addr = gen_rtx_PLUS (word_mode, stack_pointer_rtx,
3626                                        GEN_INT (TARGET_64BIT ? -8 : -4));
3627
3628               emit_move_insn (gen_rtx_MEM (word_mode, addr),
3629                               frame_pointer_rtx);
3630             }
3631           else
3632             emit_insn (gen_blockage ());
3633         }
3634       /* no frame pointer needed.  */
3635       else
3636         {
3637           /* In some cases we can perform the first callee register save
3638              and allocating the stack frame at the same time.   If so, just
3639              make a note of it and defer allocating the frame until saving
3640              the callee registers.  */
3641           if (VAL_14_BITS_P (actual_fsize) && local_fsize == 0)
3642             merge_sp_adjust_with_store = 1;
3643           /* Can not optimize.  Adjust the stack frame by actual_fsize
3644              bytes.  */
3645           else
3646             set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3647                             actual_fsize, 1);
3648         }
3649     }
3650
3651   /* Normal register save.
3652
3653      Do not save the frame pointer in the frame_pointer_needed case.  It
3654      was done earlier.  */
3655   if (frame_pointer_needed)
3656     {
3657       offset = local_fsize;
3658
3659       /* Saving the EH return data registers in the frame is the simplest
3660          way to get the frame unwind information emitted.  We put them
3661          just before the general registers.  */
3662       if (DO_FRAME_NOTES && current_function_calls_eh_return)
3663         {
3664           unsigned int i, regno;
3665
3666           for (i = 0; ; ++i)
3667             {
3668               regno = EH_RETURN_DATA_REGNO (i);
3669               if (regno == INVALID_REGNUM)
3670                 break;
3671
3672               store_reg (regno, offset, FRAME_POINTER_REGNUM);
3673               offset += UNITS_PER_WORD;
3674             }
3675         }
3676
3677       for (i = 18; i >= 4; i--)
3678         if (regs_ever_live[i] && ! call_used_regs[i])
3679           {
3680             store_reg (i, offset, FRAME_POINTER_REGNUM);
3681             offset += UNITS_PER_WORD;
3682             gr_saved++;
3683           }
3684       /* Account for %r3 which is saved in a special place.  */
3685       gr_saved++;
3686     }
3687   /* No frame pointer needed.  */
3688   else
3689     {
3690       offset = local_fsize - actual_fsize;
3691
3692       /* Saving the EH return data registers in the frame is the simplest
3693          way to get the frame unwind information emitted.  */
3694       if (DO_FRAME_NOTES && current_function_calls_eh_return)
3695         {
3696           unsigned int i, regno;
3697
3698           for (i = 0; ; ++i)
3699             {
3700               regno = EH_RETURN_DATA_REGNO (i);
3701               if (regno == INVALID_REGNUM)
3702                 break;
3703
3704               /* If merge_sp_adjust_with_store is nonzero, then we can
3705                  optimize the first save.  */
3706               if (merge_sp_adjust_with_store)
3707                 {
3708                   store_reg_modify (STACK_POINTER_REGNUM, regno, -offset);
3709                   merge_sp_adjust_with_store = 0;
3710                 }
3711               else
3712                 store_reg (regno, offset, STACK_POINTER_REGNUM);
3713               offset += UNITS_PER_WORD;
3714             }
3715         }
3716
3717       for (i = 18; i >= 3; i--)
3718         if (regs_ever_live[i] && ! call_used_regs[i])
3719           {
3720             /* If merge_sp_adjust_with_store is nonzero, then we can
3721                optimize the first GR save.  */
3722             if (merge_sp_adjust_with_store)
3723               {
3724                 store_reg_modify (STACK_POINTER_REGNUM, i, -offset);
3725                 merge_sp_adjust_with_store = 0;
3726               }
3727             else
3728               store_reg (i, offset, STACK_POINTER_REGNUM);
3729             offset += UNITS_PER_WORD;
3730             gr_saved++;
3731           }
3732
3733       /* If we wanted to merge the SP adjustment with a GR save, but we never
3734          did any GR saves, then just emit the adjustment here.  */
3735       if (merge_sp_adjust_with_store)
3736         set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
3737                         actual_fsize, 1);
3738     }
3739
3740   /* The hppa calling conventions say that %r19, the pic offset
3741      register, is saved at sp - 32 (in this function's frame)
3742      when generating PIC code.  FIXME:  What is the correct thing
3743      to do for functions which make no calls and allocate no
3744      frame?  Do we need to allocate a frame, or can we just omit
3745      the save?   For now we'll just omit the save.
3746
3747      We don't want a note on this insn as the frame marker can
3748      move if there is a dynamic stack allocation.  */
3749   if (flag_pic && actual_fsize != 0 && !TARGET_64BIT)
3750     {
3751       rtx addr = gen_rtx_PLUS (word_mode, stack_pointer_rtx, GEN_INT (-32));
3752
3753       emit_move_insn (gen_rtx_MEM (word_mode, addr), pic_offset_table_rtx);
3754
3755     }
3756
3757   /* Align pointer properly (doubleword boundary).  */
3758   offset = (offset + 7) & ~7;
3759
3760   /* Floating point register store.  */
3761   if (save_fregs)
3762     {
3763       rtx base;
3764
3765       /* First get the frame or stack pointer to the start of the FP register
3766          save area.  */
3767       if (frame_pointer_needed)
3768         {
3769           set_reg_plus_d (1, FRAME_POINTER_REGNUM, offset, 0);
3770           base = frame_pointer_rtx;
3771         }
3772       else
3773         {
3774           set_reg_plus_d (1, STACK_POINTER_REGNUM, offset, 0);
3775           base = stack_pointer_rtx;
3776         }
3777
3778       /* Now actually save the FP registers.  */
3779       for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
3780         {
3781           if (regs_ever_live[i]
3782               || (! TARGET_64BIT && regs_ever_live[i + 1]))
3783             {
3784               rtx addr, insn, reg;
3785               addr = gen_rtx_MEM (DFmode, gen_rtx_POST_INC (DFmode, tmpreg));
3786               reg = gen_rtx_REG (DFmode, i);
3787               insn = emit_move_insn (addr, reg);
3788               if (DO_FRAME_NOTES)
3789                 {
3790                   RTX_FRAME_RELATED_P (insn) = 1;
3791                   if (TARGET_64BIT)
3792                     {
3793                       rtx mem = gen_rtx_MEM (DFmode,
3794                                              plus_constant (base, offset));
3795                       REG_NOTES (insn)
3796                         = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3797                                              gen_rtx_SET (VOIDmode, mem, reg),
3798                                              REG_NOTES (insn));
3799                     }
3800                   else
3801                     {
3802                       rtx meml = gen_rtx_MEM (SFmode,
3803                                               plus_constant (base, offset));
3804                       rtx memr = gen_rtx_MEM (SFmode,
3805                                               plus_constant (base, offset + 4));
3806                       rtx regl = gen_rtx_REG (SFmode, i);
3807                       rtx regr = gen_rtx_REG (SFmode, i + 1);
3808                       rtx setl = gen_rtx_SET (VOIDmode, meml, regl);
3809                       rtx setr = gen_rtx_SET (VOIDmode, memr, regr);
3810                       rtvec vec;
3811
3812                       RTX_FRAME_RELATED_P (setl) = 1;
3813                       RTX_FRAME_RELATED_P (setr) = 1;
3814                       vec = gen_rtvec (2, setl, setr);
3815                       REG_NOTES (insn)
3816                         = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3817                                              gen_rtx_SEQUENCE (VOIDmode, vec),
3818                                              REG_NOTES (insn));
3819                     }
3820                 }
3821               offset += GET_MODE_SIZE (DFmode);
3822               fr_saved++;
3823             }
3824         }
3825     }
3826 }
3827
3828 /* Emit RTL to load REG from the memory location specified by BASE+DISP.
3829    Handle case where DISP > 8k by using the add_high_const patterns.  */
3830
3831 static void
3832 load_reg (int reg, HOST_WIDE_INT disp, int base)
3833 {
3834   rtx dest = gen_rtx_REG (word_mode, reg);
3835   rtx basereg = gen_rtx_REG (Pmode, base);
3836   rtx src;
3837
3838   if (VAL_14_BITS_P (disp))
3839     src = gen_rtx_MEM (word_mode, plus_constant (basereg, disp));
3840   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3841     {
3842       rtx delta = GEN_INT (disp);
3843       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3844
3845       emit_move_insn (tmpreg, delta);
3846       if (TARGET_DISABLE_INDEXING)
3847         {
3848           emit_move_insn (tmpreg, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3849           src = gen_rtx_MEM (word_mode, tmpreg);
3850         }
3851       else
3852         src = gen_rtx_MEM (word_mode, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3853     }
3854   else
3855     {
3856       rtx delta = GEN_INT (disp);
3857       rtx high = gen_rtx_PLUS (Pmode, basereg, gen_rtx_HIGH (Pmode, delta));
3858       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3859
3860       emit_move_insn (tmpreg, high);
3861       src = gen_rtx_MEM (word_mode, gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3862     }
3863
3864   emit_move_insn (dest, src);
3865 }
3866
3867 /* Update the total code bytes output to the text section.  */
3868
3869 static void
3870 update_total_code_bytes (int nbytes)
3871 {
3872   if ((TARGET_PORTABLE_RUNTIME || !TARGET_GAS || !TARGET_SOM)
3873       && !IN_NAMED_SECTION_P (cfun->decl))
3874     {
3875       if (INSN_ADDRESSES_SET_P ())
3876         {
3877           unsigned long old_total = total_code_bytes;
3878
3879           total_code_bytes += nbytes;
3880
3881           /* Be prepared to handle overflows.  */
3882           if (old_total > total_code_bytes)
3883             total_code_bytes = -1;
3884         }
3885       else
3886         total_code_bytes = -1;
3887     }
3888 }
3889
3890 /* This function generates the assembly code for function exit.
3891    Args are as for output_function_prologue ().
3892
3893    The function epilogue should not depend on the current stack
3894    pointer!  It should use the frame pointer only.  This is mandatory
3895    because of alloca; we also take advantage of it to omit stack
3896    adjustments before returning.  */
3897
3898 static void
3899 pa_output_function_epilogue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3900 {
3901   rtx insn = get_last_insn ();
3902
3903   last_address = 0;
3904
3905   /* hppa_expand_epilogue does the dirty work now.  We just need
3906      to output the assembler directives which denote the end
3907      of a function.
3908
3909      To make debuggers happy, emit a nop if the epilogue was completely
3910      eliminated due to a volatile call as the last insn in the
3911      current function.  That way the return address (in %r2) will
3912      always point to a valid instruction in the current function.  */
3913
3914   /* Get the last real insn.  */
3915   if (GET_CODE (insn) == NOTE)
3916     insn = prev_real_insn (insn);
3917
3918   /* If it is a sequence, then look inside.  */
3919   if (insn && GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
3920     insn = XVECEXP (PATTERN (insn), 0, 0);
3921
3922   /* If insn is a CALL_INSN, then it must be a call to a volatile
3923      function (otherwise there would be epilogue insns).  */
3924   if (insn && GET_CODE (insn) == CALL_INSN)
3925     {
3926       fputs ("\tnop\n", file);
3927       last_address += 4;
3928     }
3929
3930   fputs ("\t.EXIT\n\t.PROCEND\n", file);
3931
3932   if (TARGET_SOM && TARGET_GAS)
3933     {
3934       /* We done with this subspace except possibly for some additional
3935          debug information.  Forget that we are in this subspace to ensure
3936          that the next function is output in its own subspace.  */