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_som_asm_init_sections (void) ATTRIBUTE_UNUSED;
 111 static section *pa_select_section (tree, int, unsigned HOST_WIDE_INT)
 112      ATTRIBUTE_UNUSED;
 113 static void pa_encode_section_info (tree, rtx, int);
 114 static const char *pa_strip_name_encoding (const char *);
 115 static bool pa_function_ok_for_sibcall (tree, tree);
 116 static void pa_globalize_label (FILE *, const char *)
 117      ATTRIBUTE_UNUSED;
 118 static void pa_asm_output_mi_thunk (FILE *, tree, HOST_WIDE_INT,
 119                                     HOST_WIDE_INT, tree);
 120 #if !defined(USE_COLLECT2)
 121 static void pa_asm_out_constructor (rtx, int);
 122 static void pa_asm_out_destructor (rtx, int);
 123 #endif
 124 static void pa_init_builtins (void);
 125 static rtx hppa_builtin_saveregs (void);
 126 static tree hppa_gimplify_va_arg_expr (tree, tree, tree *, tree *);
 127 static bool pa_scalar_mode_supported_p (enum machine_mode);
 128 static bool pa_commutative_p (rtx x, int outer_code);
 129 static void copy_fp_args (rtx) ATTRIBUTE_UNUSED;
 130 static int length_fp_args (rtx) ATTRIBUTE_UNUSED;
 131 static inline void pa_file_start_level (void) ATTRIBUTE_UNUSED;
 132 static inline void pa_file_start_space (int) ATTRIBUTE_UNUSED;
 133 static inline void pa_file_start_file (int) ATTRIBUTE_UNUSED;
 134 static inline void pa_file_start_mcount (const char*) ATTRIBUTE_UNUSED;
 135 static void pa_elf_file_start (void) ATTRIBUTE_UNUSED;
 136 static void pa_som_file_start (void) ATTRIBUTE_UNUSED;
 137 static void pa_linux_file_start (void) ATTRIBUTE_UNUSED;
 138 static void pa_hpux64_gas_file_start (void) ATTRIBUTE_UNUSED;
 139 static void pa_hpux64_hpas_file_start (void) ATTRIBUTE_UNUSED;
 140 static void output_deferred_plabels (void);
 141 static void output_deferred_profile_counters (void) ATTRIBUTE_UNUSED;
 142 #ifdef ASM_OUTPUT_EXTERNAL_REAL
 143 static void pa_hpux_file_end (void);
 144 #endif
 145 #ifdef HPUX_LONG_DOUBLE_LIBRARY
 146 static void pa_hpux_init_libfuncs (void);
 147 #endif
 148 static rtx pa_struct_value_rtx (tree, int);
 149 static bool pa_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
 150                                   tree, bool);
 151 static int pa_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
 152                                  tree, bool);
 153 static struct machine_function * pa_init_machine_status (void);
 154 static enum reg_class pa_secondary_reload (bool, rtx, enum reg_class,
 155                                            enum machine_mode,
 156                                            secondary_reload_info *);
 157
 158
 159 /* The following extra sections are only used for SOM.  */
 160 static GTY(()) section *som_readonly_data_section;
 161 static GTY(()) section *som_one_only_readonly_data_section;
 162 static GTY(()) section *som_one_only_data_section;
 163
 164 /* Save the operands last given to a compare for use when we
 165    generate a scc or bcc insn.  */
 166 rtx hppa_compare_op0, hppa_compare_op1;
 167 enum cmp_type hppa_branch_type;
 168
 169 /* Which cpu we are scheduling for.  */
 170 enum processor_type pa_cpu = TARGET_SCHED_DEFAULT;
 171
 172 /* The UNIX standard to use for predefines and linking.  */
 173 int flag_pa_unix = TARGET_HPUX_11_11 ? 1998 : TARGET_HPUX_10_10 ? 1995 : 1993;
 174
 175 /* Counts for the number of callee-saved general and floating point
 176    registers which were saved by the current function's prologue.  */
 177 static int gr_saved, fr_saved;
 178
 179 static rtx find_addr_reg (rtx);
 180
 181 /* Keep track of the number of bytes we have output in the CODE subspace
 182    during this compilation so we'll know when to emit inline long-calls.  */
 183 unsigned long total_code_bytes;
 184
 185 /* The last address of the previous function plus the number of bytes in
 186    associated thunks that have been output.  This is used to determine if
 187    a thunk can use an IA-relative branch to reach its target function.  */
 188 static int last_address;
 189
 190 /* Variables to handle plabels that we discover are necessary at assembly
 191    output time.  They are output after the current function.  */
 192 struct deferred_plabel GTY(())
 193 {
 194   rtx internal_label;
 195   rtx symbol;
 196 };
 197 static GTY((length ("n_deferred_plabels"))) struct deferred_plabel *
 198   deferred_plabels;
 199 static size_t n_deferred_plabels = 0;
 200
 201 \f
 202 /* Initialize the GCC target structure.  */
 203
 204 #undef TARGET_ASM_ALIGNED_HI_OP
 205 #define TARGET_ASM_ALIGNED_HI_OP "\t.half\t"
 206 #undef TARGET_ASM_ALIGNED_SI_OP
 207 #define TARGET_ASM_ALIGNED_SI_OP "\t.word\t"
 208 #undef TARGET_ASM_ALIGNED_DI_OP
 209 #define TARGET_ASM_ALIGNED_DI_OP "\t.dword\t"
 210 #undef TARGET_ASM_UNALIGNED_HI_OP
 211 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
 212 #undef TARGET_ASM_UNALIGNED_SI_OP
 213 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
 214 #undef TARGET_ASM_UNALIGNED_DI_OP
 215 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
 216 #undef TARGET_ASM_INTEGER
 217 #define TARGET_ASM_INTEGER pa_assemble_integer
 218
 219 #undef TARGET_ASM_FUNCTION_PROLOGUE
 220 #define TARGET_ASM_FUNCTION_PROLOGUE pa_output_function_prologue
 221 #undef TARGET_ASM_FUNCTION_EPILOGUE
 222 #define TARGET_ASM_FUNCTION_EPILOGUE pa_output_function_epilogue
 223
 224 #undef TARGET_SCHED_ADJUST_COST
 225 #define TARGET_SCHED_ADJUST_COST pa_adjust_cost
 226 #undef TARGET_SCHED_ADJUST_PRIORITY
 227 #define TARGET_SCHED_ADJUST_PRIORITY pa_adjust_priority
 228 #undef TARGET_SCHED_ISSUE_RATE
 229 #define TARGET_SCHED_ISSUE_RATE pa_issue_rate
 230
 231 #undef TARGET_ENCODE_SECTION_INFO
 232 #define TARGET_ENCODE_SECTION_INFO pa_encode_section_info
 233 #undef TARGET_STRIP_NAME_ENCODING
 234 #define TARGET_STRIP_NAME_ENCODING pa_strip_name_encoding
 235
 236 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
 237 #define TARGET_FUNCTION_OK_FOR_SIBCALL pa_function_ok_for_sibcall
 238
 239 #undef TARGET_COMMUTATIVE_P
 240 #define TARGET_COMMUTATIVE_P pa_commutative_p
 241
 242 #undef TARGET_ASM_OUTPUT_MI_THUNK
 243 #define TARGET_ASM_OUTPUT_MI_THUNK pa_asm_output_mi_thunk
 244 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 245 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK default_can_output_mi_thunk_no_vcall
 246
 247 #undef TARGET_ASM_FILE_END
 248 #ifdef ASM_OUTPUT_EXTERNAL_REAL
 249 #define TARGET_ASM_FILE_END pa_hpux_file_end
 250 #else
 251 #define TARGET_ASM_FILE_END output_deferred_plabels
 252 #endif
 253
 254 #if !defined(USE_COLLECT2)
 255 #undef TARGET_ASM_CONSTRUCTOR
 256 #define TARGET_ASM_CONSTRUCTOR pa_asm_out_constructor
 257 #undef TARGET_ASM_DESTRUCTOR
 258 #define TARGET_ASM_DESTRUCTOR pa_asm_out_destructor
 259 #endif
 260
 261 #undef TARGET_DEFAULT_TARGET_FLAGS
 262 #define TARGET_DEFAULT_TARGET_FLAGS (TARGET_DEFAULT | TARGET_CPU_DEFAULT)
 263 #undef TARGET_HANDLE_OPTION
 264 #define TARGET_HANDLE_OPTION pa_handle_option
 265
 266 #undef TARGET_INIT_BUILTINS
 267 #define TARGET_INIT_BUILTINS pa_init_builtins
 268
 269 #undef TARGET_RTX_COSTS
 270 #define TARGET_RTX_COSTS hppa_rtx_costs
 271 #undef TARGET_ADDRESS_COST
 272 #define TARGET_ADDRESS_COST hppa_address_cost
 273
 274 #undef TARGET_MACHINE_DEPENDENT_REORG
 275 #define TARGET_MACHINE_DEPENDENT_REORG pa_reorg
 276
 277 #ifdef HPUX_LONG_DOUBLE_LIBRARY
 278 #undef TARGET_INIT_LIBFUNCS
 279 #define TARGET_INIT_LIBFUNCS pa_hpux_init_libfuncs
 280 #endif
 281
 282 #undef TARGET_PROMOTE_FUNCTION_RETURN
 283 #define TARGET_PROMOTE_FUNCTION_RETURN hook_bool_tree_true
 284 #undef TARGET_PROMOTE_PROTOTYPES
 285 #define TARGET_PROMOTE_PROTOTYPES hook_bool_tree_true
 286
 287 #undef TARGET_STRUCT_VALUE_RTX
 288 #define TARGET_STRUCT_VALUE_RTX pa_struct_value_rtx
 289 #undef TARGET_RETURN_IN_MEMORY
 290 #define TARGET_RETURN_IN_MEMORY pa_return_in_memory
 291 #undef TARGET_MUST_PASS_IN_STACK
 292 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
 293 #undef TARGET_PASS_BY_REFERENCE
 294 #define TARGET_PASS_BY_REFERENCE pa_pass_by_reference
 295 #undef TARGET_CALLEE_COPIES
 296 #define TARGET_CALLEE_COPIES hook_bool_CUMULATIVE_ARGS_mode_tree_bool_true
 297 #undef TARGET_ARG_PARTIAL_BYTES
 298 #define TARGET_ARG_PARTIAL_BYTES pa_arg_partial_bytes
 299
 300 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
 301 #define TARGET_EXPAND_BUILTIN_SAVEREGS hppa_builtin_saveregs
 302 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 303 #define TARGET_GIMPLIFY_VA_ARG_EXPR hppa_gimplify_va_arg_expr
 304
 305 #undef TARGET_SCALAR_MODE_SUPPORTED_P
 306 #define TARGET_SCALAR_MODE_SUPPORTED_P pa_scalar_mode_supported_p
 307
 308 #undef TARGET_CANNOT_FORCE_CONST_MEM
 309 #define TARGET_CANNOT_FORCE_CONST_MEM pa_tls_referenced_p
 310
 311 #undef TARGET_SECONDARY_RELOAD
 312 #define TARGET_SECONDARY_RELOAD pa_secondary_reload
 313
 314 struct gcc_target targetm = TARGET_INITIALIZER;
 315 \f
 316 /* Parse the -mfixed-range= option string.  */
 317
 318 static void
 319 fix_range (const char *const_str)
 320 {
 321   int i, first, last;
 322   char *str, *dash, *comma;
 323
 324   /* str must be of the form REG1'-'REG2{,REG1'-'REG} where REG1 and
 325      REG2 are either register names or register numbers.  The effect
 326      of this option is to mark the registers in the range from REG1 to
 327      REG2 as ``fixed'' so they won't be used by the compiler.  This is
 328      used, e.g., to ensure that kernel mode code doesn't use fr4-fr31.  */
 329
 330   i = strlen (const_str);
 331   str = (char *) alloca (i + 1);
 332   memcpy (str, const_str, i + 1);
 333
 334   while (1)
 335     {
 336       dash = strchr (str, '-');
 337       if (!dash)
 338         {
 339           warning (0, "value of -mfixed-range must have form REG1-REG2");
 340           return;
 341         }
 342       *dash = '\0';
 343
 344       comma = strchr (dash + 1, ',');
 345       if (comma)
 346         *comma = '\0';
 347
 348       first = decode_reg_name (str);
 349       if (first < 0)
 350         {
 351           warning (0, "unknown register name: %s", str);
 352           return;
 353         }
 354
 355       last = decode_reg_name (dash + 1);
 356       if (last < 0)
 357         {
 358           warning (0, "unknown register name: %s", dash + 1);
 359           return;
 360         }
 361
 362       *dash = '-';
 363
 364       if (first > last)
 365         {
 366           warning (0, "%s-%s is an empty range", str, dash + 1);
 367           return;
 368         }
 369
 370       for (i = first; i <= last; ++i)
 371         fixed_regs[i] = call_used_regs[i] = 1;
 372
 373       if (!comma)
 374         break;
 375
 376       *comma = ',';
 377       str = comma + 1;
 378     }
 379
 380   /* Check if all floating point registers have been fixed.  */
 381   for (i = FP_REG_FIRST; i <= FP_REG_LAST; i++)
 382     if (!fixed_regs[i])
 383       break;
 384
 385   if (i > FP_REG_LAST)
 386     target_flags |= MASK_DISABLE_FPREGS;
 387 }
 388
 389 /* Implement TARGET_HANDLE_OPTION.  */
 390
 391 static bool
 392 pa_handle_option (size_t code, const char *arg, int value ATTRIBUTE_UNUSED)
 393 {
 394   switch (code)
 395     {
 396     case OPT_mnosnake:
 397     case OPT_mpa_risc_1_0:
 398     case OPT_march_1_0:
 399       target_flags &= ~(MASK_PA_11 | MASK_PA_20);
 400       return true;
 401
 402     case OPT_msnake:
 403     case OPT_mpa_risc_1_1:
 404     case OPT_march_1_1:
 405       target_flags &= ~MASK_PA_20;
 406       target_flags |= MASK_PA_11;
 407       return true;
 408
 409     case OPT_mpa_risc_2_0:
 410     case OPT_march_2_0:
 411       target_flags |= MASK_PA_11 | MASK_PA_20;
 412       return true;
 413
 414     case OPT_mschedule_:
 415       if (strcmp (arg, "8000") == 0)
 416         pa_cpu = PROCESSOR_8000;
 417       else if (strcmp (arg, "7100") == 0)
 418         pa_cpu = PROCESSOR_7100;
 419       else if (strcmp (arg, "700") == 0)
 420         pa_cpu = PROCESSOR_700;
 421       else if (strcmp (arg, "7100LC") == 0)
 422         pa_cpu = PROCESSOR_7100LC;
 423       else if (strcmp (arg, "7200") == 0)
 424         pa_cpu = PROCESSOR_7200;
 425       else if (strcmp (arg, "7300") == 0)
 426         pa_cpu = PROCESSOR_7300;
 427       else
 428         return false;
 429       return true;
 430
 431     case OPT_mfixed_range_:
 432       fix_range (arg);
 433       return true;
 434
 435 #if TARGET_HPUX
 436     case OPT_munix_93:
 437       flag_pa_unix = 1993;
 438       return true;
 439 #endif
 440
 441 #if TARGET_HPUX_10_10
 442     case OPT_munix_95:
 443       flag_pa_unix = 1995;
 444       return true;
 445 #endif
 446
 447 #if TARGET_HPUX_11_11
 448     case OPT_munix_98:
 449       flag_pa_unix = 1998;
 450       return true;
 451 #endif
 452
 453     default:
 454       return true;
 455     }
 456 }
 457
 458 void
 459 override_options (void)
 460 {
 461   /* Unconditional branches in the delay slot are not compatible with dwarf2
 462      call frame information.  There is no benefit in using this optimization
 463      on PA8000 and later processors.  */
 464   if (pa_cpu >= PROCESSOR_8000
 465       || (! USING_SJLJ_EXCEPTIONS && flag_exceptions)
 466       || flag_unwind_tables)
 467     target_flags &= ~MASK_JUMP_IN_DELAY;
 468
 469   if (flag_pic && TARGET_PORTABLE_RUNTIME)
 470     {
 471       warning (0, "PIC code generation is not supported in the portable runtime model");
 472     }
 473
 474   if (flag_pic && TARGET_FAST_INDIRECT_CALLS)
 475    {
 476       warning (0, "PIC code generation is not compatible with fast indirect calls");
 477    }
 478
 479   if (! TARGET_GAS && write_symbols != NO_DEBUG)
 480     {
 481       warning (0, "-g is only supported when using GAS on this processor,");
 482       warning (0, "-g option disabled");
 483       write_symbols = NO_DEBUG;
 484     }
 485
 486   /* We only support the "big PIC" model now.  And we always generate PIC
 487      code when in 64bit mode.  */
 488   if (flag_pic == 1 || TARGET_64BIT)
 489     flag_pic = 2;
 490
 491   /* We can't guarantee that .dword is available for 32-bit targets.  */
 492   if (UNITS_PER_WORD == 4)
 493     targetm.asm_out.aligned_op.di = NULL;
 494
 495   /* The unaligned ops are only available when using GAS.  */
 496   if (!TARGET_GAS)
 497     {
 498       targetm.asm_out.unaligned_op.hi = NULL;
 499       targetm.asm_out.unaligned_op.si = NULL;
 500       targetm.asm_out.unaligned_op.di = NULL;
 501     }
 502
 503   init_machine_status = pa_init_machine_status;
 504 }
 505
 506 static void
 507 pa_init_builtins (void)
 508 {
 509 #ifdef DONT_HAVE_FPUTC_UNLOCKED
 510   built_in_decls[(int) BUILT_IN_FPUTC_UNLOCKED] =
 511     built_in_decls[(int) BUILT_IN_PUTC_UNLOCKED];
 512   implicit_built_in_decls[(int) BUILT_IN_FPUTC_UNLOCKED]
 513     = implicit_built_in_decls[(int) BUILT_IN_PUTC_UNLOCKED];
 514 #endif
 515 }
 516
 517 /* Function to init struct machine_function.
 518    This will be called, via a pointer variable,
 519    from push_function_context.  */
 520
 521 static struct machine_function *
 522 pa_init_machine_status (void)
 523 {
 524   return ggc_alloc_cleared (sizeof (machine_function));
 525 }
 526
 527 /* If FROM is a probable pointer register, mark TO as a probable
 528    pointer register with the same pointer alignment as FROM.  */
 529
 530 static void
 531 copy_reg_pointer (rtx to, rtx from)
 532 {
 533   if (REG_POINTER (from))
 534     mark_reg_pointer (to, REGNO_POINTER_ALIGN (REGNO (from)));
 535 }
 536
 537 /* Return 1 if X contains a symbolic expression.  We know these
 538    expressions will have one of a few well defined forms, so
 539    we need only check those forms.  */
 540 int
 541 symbolic_expression_p (rtx x)
 542 {
 543
 544   /* Strip off any HIGH.  */
 545   if (GET_CODE (x) == HIGH)
 546     x = XEXP (x, 0);
 547
 548   return (symbolic_operand (x, VOIDmode));
 549 }
 550
 551 /* Accept any constant that can be moved in one instruction into a
 552    general register.  */
 553 int
 554 cint_ok_for_move (HOST_WIDE_INT intval)
 555 {
 556   /* OK if ldo, ldil, or zdepi, can be used.  */
 557   return (CONST_OK_FOR_LETTER_P (intval, 'J')
 558           || CONST_OK_FOR_LETTER_P (intval, 'N')
 559           || CONST_OK_FOR_LETTER_P (intval, 'K'));
 560 }
 561 \f
 562 /* Return truth value of whether OP can be used as an operand in a
 563    adddi3 insn.  */
 564 int
 565 adddi3_operand (rtx op, enum machine_mode mode)
 566 {
 567   return (register_operand (op, mode)
 568           || (GET_CODE (op) == CONST_INT
 569               && (TARGET_64BIT ? INT_14_BITS (op) : INT_11_BITS (op))));
 570 }
 571
 572 /* True iff zdepi can be used to generate this CONST_INT.
 573    zdepi first sign extends a 5 bit signed number to a given field
 574    length, then places this field anywhere in a zero.  */
 575 int
 576 zdepi_cint_p (unsigned HOST_WIDE_INT x)
 577 {
 578   unsigned HOST_WIDE_INT lsb_mask, t;
 579
 580   /* This might not be obvious, but it's at least fast.
 581      This function is critical; we don't have the time loops would take.  */
 582   lsb_mask = x & -x;
 583   t = ((x >> 4) + lsb_mask) & ~(lsb_mask - 1);
 584   /* Return true iff t is a power of two.  */
 585   return ((t & (t - 1)) == 0);
 586 }
 587
 588 /* True iff depi or extru can be used to compute (reg & mask).
 589    Accept bit pattern like these:
 590    0....01....1
 591    1....10....0
 592    1..10..01..1  */
 593 int
 594 and_mask_p (unsigned HOST_WIDE_INT mask)
 595 {
 596   mask = ~mask;
 597   mask += mask & -mask;
 598   return (mask & (mask - 1)) == 0;
 599 }
 600
 601 /* True iff depi can be used to compute (reg | MASK).  */
 602 int
 603 ior_mask_p (unsigned HOST_WIDE_INT mask)
 604 {
 605   mask += mask & -mask;
 606   return (mask & (mask - 1)) == 0;
 607 }
 608 \f
 609 /* Legitimize PIC addresses.  If the address is already
 610    position-independent, we return ORIG.  Newly generated
 611    position-independent addresses go to REG.  If we need more
 612    than one register, we lose.  */
 613
 614 rtx
 615 legitimize_pic_address (rtx orig, enum machine_mode mode, rtx reg)
 616 {
 617   rtx pic_ref = orig;
 618
 619   gcc_assert (!PA_SYMBOL_REF_TLS_P (orig));
 620
 621   /* Labels need special handling.  */
 622   if (pic_label_operand (orig, mode))
 623     {
 624       /* We do not want to go through the movXX expanders here since that
 625          would create recursion.
 626
 627          Nor do we really want to call a generator for a named pattern
 628          since that requires multiple patterns if we want to support
 629          multiple word sizes.
 630
 631          So instead we just emit the raw set, which avoids the movXX
 632          expanders completely.  */
 633       mark_reg_pointer (reg, BITS_PER_UNIT);
 634       emit_insn (gen_rtx_SET (VOIDmode, reg, orig));
 635       current_function_uses_pic_offset_table = 1;
 636       return reg;
 637     }
 638   if (GET_CODE (orig) == SYMBOL_REF)
 639     {
 640       rtx insn, tmp_reg;
 641
 642       gcc_assert (reg);
 643
 644       /* Before reload, allocate a temporary register for the intermediate
 645          result.  This allows the sequence to be deleted when the final
 646          result is unused and the insns are trivially dead.  */
 647       tmp_reg = ((reload_in_progress || reload_completed)
 648                  ? reg : gen_reg_rtx (Pmode));
 649
 650       emit_move_insn (tmp_reg,
 651                       gen_rtx_PLUS (word_mode, pic_offset_table_rtx,
 652                                     gen_rtx_HIGH (word_mode, orig)));
 653       pic_ref
 654         = gen_const_mem (Pmode,
 655                          gen_rtx_LO_SUM (Pmode, tmp_reg,
 656                                          gen_rtx_UNSPEC (Pmode,
 657                                                          gen_rtvec (1, orig),
 658                                                          UNSPEC_DLTIND14R)));
 659
 660       current_function_uses_pic_offset_table = 1;
 661       mark_reg_pointer (reg, BITS_PER_UNIT);
 662       insn = emit_move_insn (reg, pic_ref);
 663
 664       /* Put a REG_EQUAL note on this insn, so that it can be optimized.  */
 665       REG_NOTES (insn) = gen_rtx_EXPR_LIST (REG_EQUAL, orig, REG_NOTES (insn));
 666
 667       return reg;
 668     }
 669   else if (GET_CODE (orig) == CONST)
 670     {
 671       rtx base;
 672
 673       if (GET_CODE (XEXP (orig, 0)) == PLUS
 674           && XEXP (XEXP (orig, 0), 0) == pic_offset_table_rtx)
 675         return orig;
 676
 677       gcc_assert (reg);
 678       gcc_assert (GET_CODE (XEXP (orig, 0)) == PLUS);
 679
 680       base = legitimize_pic_address (XEXP (XEXP (orig, 0), 0), Pmode, reg);
 681       orig = legitimize_pic_address (XEXP (XEXP (orig, 0), 1), Pmode,
 682                                      base == reg ? 0 : reg);
 683
 684       if (GET_CODE (orig) == CONST_INT)
 685         {
 686           if (INT_14_BITS (orig))
 687             return plus_constant (base, INTVAL (orig));
 688           orig = force_reg (Pmode, orig);
 689         }
 690       pic_ref = gen_rtx_PLUS (Pmode, base, orig);
 691       /* Likewise, should we set special REG_NOTEs here?  */
 692     }
 693
 694   return pic_ref;
 695 }
 696
 697 static GTY(()) rtx gen_tls_tga;
 698
 699 static rtx
 700 gen_tls_get_addr (void)
 701 {
 702   if (!gen_tls_tga)
 703     gen_tls_tga = init_one_libfunc ("__tls_get_addr");
 704   return gen_tls_tga;
 705 }
 706
 707 static rtx
 708 hppa_tls_call (rtx arg)
 709 {
 710   rtx ret;
 711
 712   ret = gen_reg_rtx (Pmode);
 713   emit_library_call_value (gen_tls_get_addr (), ret,
 714                            LCT_CONST, Pmode, 1, arg, Pmode);
 715
 716   return ret;
 717 }
 718
 719 static rtx
 720 legitimize_tls_address (rtx addr)
 721 {
 722   rtx ret, insn, tmp, t1, t2, tp;
 723   enum tls_model model = SYMBOL_REF_TLS_MODEL (addr);
 724
 725   switch (model)
 726     {
 727       case TLS_MODEL_GLOBAL_DYNAMIC:
 728         tmp = gen_reg_rtx (Pmode);
 729         emit_insn (gen_tgd_load (tmp, addr));
 730         ret = hppa_tls_call (tmp);
 731         break;
 732
 733       case TLS_MODEL_LOCAL_DYNAMIC:
 734         ret = gen_reg_rtx (Pmode);
 735         tmp = gen_reg_rtx (Pmode);
 736         start_sequence ();
 737         emit_insn (gen_tld_load (tmp, addr));
 738         t1 = hppa_tls_call (tmp);
 739         insn = get_insns ();
 740         end_sequence ();
 741         t2 = gen_reg_rtx (Pmode);
 742         emit_libcall_block (insn, t2, t1,
 743                             gen_rtx_UNSPEC (Pmode, gen_rtvec (1, const0_rtx),
 744                                             UNSPEC_TLSLDBASE));
 745         emit_insn (gen_tld_offset_load (ret, addr, t2));
 746         break;
 747
 748       case TLS_MODEL_INITIAL_EXEC:
 749         tp = gen_reg_rtx (Pmode);
 750         tmp = gen_reg_rtx (Pmode);
 751         ret = gen_reg_rtx (Pmode);
 752         emit_insn (gen_tp_load (tp));
 753         emit_insn (gen_tie_load (tmp, addr));
 754         emit_move_insn (ret, gen_rtx_PLUS (Pmode, tp, tmp));
 755         break;
 756
 757       case TLS_MODEL_LOCAL_EXEC:
 758         tp = gen_reg_rtx (Pmode);
 759         ret = gen_reg_rtx (Pmode);
 760         emit_insn (gen_tp_load (tp));
 761         emit_insn (gen_tle_load (ret, addr, tp));
 762         break;
 763
 764       default:
 765         gcc_unreachable ();
 766     }
 767
 768   return ret;
 769 }
 770
 771 /* Try machine-dependent ways of modifying an illegitimate address
 772    to be legitimate.  If we find one, return the new, valid address.
 773    This macro is used in only one place: `memory_address' in explow.c.
 774
 775    OLDX is the address as it was before break_out_memory_refs was called.
 776    In some cases it is useful to look at this to decide what needs to be done.
 777
 778    MODE and WIN are passed so that this macro can use
 779    GO_IF_LEGITIMATE_ADDRESS.
 780
 781    It is always safe for this macro to do nothing.  It exists to recognize
 782    opportunities to optimize the output.
 783
 784    For the PA, transform:
 785
 786         memory(X + <large int>)
 787
 788    into:
 789
 790         if (<large int> & mask) >= 16
 791           Y = (<large int> & ~mask) + mask + 1  Round up.
 792         else
 793           Y = (<large int> & ~mask)             Round down.
 794         Z = X + Y
 795         memory (Z + (<large int> - Y));
 796
 797    This is for CSE to find several similar references, and only use one Z.
 798
 799    X can either be a SYMBOL_REF or REG, but because combine cannot
 800    perform a 4->2 combination we do nothing for SYMBOL_REF + D where
 801    D will not fit in 14 bits.
 802
 803    MODE_FLOAT references allow displacements which fit in 5 bits, so use
 804    0x1f as the mask.
 805
 806    MODE_INT references allow displacements which fit in 14 bits, so use
 807    0x3fff as the mask.
 808
 809    This relies on the fact that most mode MODE_FLOAT references will use FP
 810    registers and most mode MODE_INT references will use integer registers.
 811    (In the rare case of an FP register used in an integer MODE, we depend
 812    on secondary reloads to clean things up.)
 813
 814
 815    It is also beneficial to handle (plus (mult (X) (Y)) (Z)) in a special
 816    manner if Y is 2, 4, or 8.  (allows more shadd insns and shifted indexed
 817    addressing modes to be used).
 818
 819    Put X and Z into registers.  Then put the entire expression into
 820    a register.  */
 821
 822 rtx
 823 hppa_legitimize_address (rtx x, rtx oldx ATTRIBUTE_UNUSED,
 824                          enum machine_mode mode)
 825 {
 826   rtx orig = x;
 827
 828   /* We need to canonicalize the order of operands in unscaled indexed
 829      addresses since the code that checks if an address is valid doesn't
 830      always try both orders.  */
 831   if (!TARGET_NO_SPACE_REGS
 832       && GET_CODE (x) == PLUS
 833       && GET_MODE (x) == Pmode
 834       && REG_P (XEXP (x, 0))
 835       && REG_P (XEXP (x, 1))
 836       && REG_POINTER (XEXP (x, 0))
 837       && !REG_POINTER (XEXP (x, 1)))
 838     return gen_rtx_PLUS (Pmode, XEXP (x, 1), XEXP (x, 0));
 839
 840   if (PA_SYMBOL_REF_TLS_P (x))
 841     return legitimize_tls_address (x);
 842   else if (flag_pic)
 843     return legitimize_pic_address (x, mode, gen_reg_rtx (Pmode));
 844
 845   /* Strip off CONST.  */
 846   if (GET_CODE (x) == CONST)
 847     x = XEXP (x, 0);
 848
 849   /* Special case.  Get the SYMBOL_REF into a register and use indexing.
 850      That should always be safe.  */
 851   if (GET_CODE (x) == PLUS
 852       && GET_CODE (XEXP (x, 0)) == REG
 853       && GET_CODE (XEXP (x, 1)) == SYMBOL_REF)
 854     {
 855       rtx reg = force_reg (Pmode, XEXP (x, 1));
 856       return force_reg (Pmode, gen_rtx_PLUS (Pmode, reg, XEXP (x, 0)));
 857     }
 858
 859   /* Note we must reject symbols which represent function addresses
 860      since the assembler/linker can't handle arithmetic on plabels.  */
 861   if (GET_CODE (x) == PLUS
 862       && GET_CODE (XEXP (x, 1)) == CONST_INT
 863       && ((GET_CODE (XEXP (x, 0)) == SYMBOL_REF
 864            && !FUNCTION_NAME_P (XSTR (XEXP (x, 0), 0)))
 865           || GET_CODE (XEXP (x, 0)) == REG))
 866     {
 867       rtx int_part, ptr_reg;
 868       int newoffset;
 869       int offset = INTVAL (XEXP (x, 1));
 870       int mask;
 871
 872       mask = (GET_MODE_CLASS (mode) == MODE_FLOAT
 873               ? (TARGET_PA_20 ? 0x3fff : 0x1f) : 0x3fff);
 874
 875       /* Choose which way to round the offset.  Round up if we
 876          are >= halfway to the next boundary.  */
 877       if ((offset & mask) >= ((mask + 1) / 2))
 878         newoffset = (offset & ~ mask) + mask + 1;
 879       else
 880         newoffset = (offset & ~ mask);
 881
 882       /* If the newoffset will not fit in 14 bits (ldo), then
 883          handling this would take 4 or 5 instructions (2 to load
 884          the SYMBOL_REF + 1 or 2 to load the newoffset + 1 to
 885          add the new offset and the SYMBOL_REF.)  Combine can
 886          not handle 4->2 or 5->2 combinations, so do not create
 887          them.  */
 888       if (! VAL_14_BITS_P (newoffset)
 889           && GET_CODE (XEXP (x, 0)) == SYMBOL_REF)
 890         {
 891           rtx const_part = plus_constant (XEXP (x, 0), newoffset);
 892           rtx tmp_reg
 893             = force_reg (Pmode,
 894                          gen_rtx_HIGH (Pmode, const_part));
 895           ptr_reg
 896             = force_reg (Pmode,
 897                          gen_rtx_LO_SUM (Pmode,
 898                                          tmp_reg, const_part));
 899         }
 900       else
 901         {
 902           if (! VAL_14_BITS_P (newoffset))
 903             int_part = force_reg (Pmode, GEN_INT (newoffset));
 904           else
 905             int_part = GEN_INT (newoffset);
 906
 907           ptr_reg = force_reg (Pmode,
 908                                gen_rtx_PLUS (Pmode,
 909                                              force_reg (Pmode, XEXP (x, 0)),
 910                                              int_part));
 911         }
 912       return plus_constant (ptr_reg, offset - newoffset);
 913     }
 914
 915   /* Handle (plus (mult (a) (shadd_constant)) (b)).  */
 916
 917   if (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 0)) == MULT
 918       && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
 919       && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1)))
 920       && (OBJECT_P (XEXP (x, 1))
 921           || GET_CODE (XEXP (x, 1)) == SUBREG)
 922       && GET_CODE (XEXP (x, 1)) != CONST)
 923     {
 924       int val = INTVAL (XEXP (XEXP (x, 0), 1));
 925       rtx reg1, reg2;
 926
 927       reg1 = XEXP (x, 1);
 928       if (GET_CODE (reg1) != REG)
 929         reg1 = force_reg (Pmode, force_operand (reg1, 0));
 930
 931       reg2 = XEXP (XEXP (x, 0), 0);
 932       if (GET_CODE (reg2) != REG)
 933         reg2 = force_reg (Pmode, force_operand (reg2, 0));
 934
 935       return force_reg (Pmode, gen_rtx_PLUS (Pmode,
 936                                              gen_rtx_MULT (Pmode,
 937                                                            reg2,
 938                                                            GEN_INT (val)),
 939                                              reg1));
 940     }
 941
 942   /* Similarly for (plus (plus (mult (a) (shadd_constant)) (b)) (c)).
 943
 944      Only do so for floating point modes since this is more speculative
 945      and we lose if it's an integer store.  */
 946   if (GET_CODE (x) == PLUS
 947       && GET_CODE (XEXP (x, 0)) == PLUS
 948       && GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
 949       && GET_CODE (XEXP (XEXP (XEXP (x, 0), 0), 1)) == CONST_INT
 950       && shadd_constant_p (INTVAL (XEXP (XEXP (XEXP (x, 0), 0), 1)))
 951       && (mode == SFmode || mode == DFmode))
 952     {
 953
 954       /* First, try and figure out what to use as a base register.  */
 955       rtx reg1, reg2, base, idx, orig_base;
 956
 957       reg1 = XEXP (XEXP (x, 0), 1);
 958       reg2 = XEXP (x, 1);
 959       base = NULL_RTX;
 960       idx = NULL_RTX;
 961
 962       /* Make sure they're both regs.  If one was a SYMBOL_REF [+ const],
 963          then emit_move_sequence will turn on REG_POINTER so we'll know
 964          it's a base register below.  */
 965       if (GET_CODE (reg1) != REG)
 966         reg1 = force_reg (Pmode, force_operand (reg1, 0));
 967
 968       if (GET_CODE (reg2) != REG)
 969         reg2 = force_reg (Pmode, force_operand (reg2, 0));
 970
 971       /* Figure out what the base and index are.  */
 972
 973       if (GET_CODE (reg1) == REG
 974           && REG_POINTER (reg1))
 975         {
 976           base = reg1;
 977           orig_base = XEXP (XEXP (x, 0), 1);
 978           idx = gen_rtx_PLUS (Pmode,
 979                               gen_rtx_MULT (Pmode,
 980                                             XEXP (XEXP (XEXP (x, 0), 0), 0),
 981                                             XEXP (XEXP (XEXP (x, 0), 0), 1)),
 982                               XEXP (x, 1));
 983         }
 984       else if (GET_CODE (reg2) == REG
 985                && REG_POINTER (reg2))
 986         {
 987           base = reg2;
 988           orig_base = XEXP (x, 1);
 989           idx = XEXP (x, 0);
 990         }
 991
 992       if (base == 0)
 993         return orig;
 994
 995       /* If the index adds a large constant, try to scale the
 996          constant so that it can be loaded with only one insn.  */
 997       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
 998           && VAL_14_BITS_P (INTVAL (XEXP (idx, 1))
 999                             / INTVAL (XEXP (XEXP (idx, 0), 1)))
1000           && INTVAL (XEXP (idx, 1)) % INTVAL (XEXP (XEXP (idx, 0), 1)) == 0)
1001         {
1002           /* Divide the CONST_INT by the scale factor, then add it to A.  */
1003           int val = INTVAL (XEXP (idx, 1));
1004
1005           val /= INTVAL (XEXP (XEXP (idx, 0), 1));
1006           reg1 = XEXP (XEXP (idx, 0), 0);
1007           if (GET_CODE (reg1) != REG)
1008             reg1 = force_reg (Pmode, force_operand (reg1, 0));
1009
1010           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, reg1, GEN_INT (val)));
1011
1012           /* We can now generate a simple scaled indexed address.  */
1013           return
1014             force_reg
1015               (Pmode, gen_rtx_PLUS (Pmode,
1016                                     gen_rtx_MULT (Pmode, reg1,
1017                                                   XEXP (XEXP (idx, 0), 1)),
1018                                     base));
1019         }
1020
1021       /* If B + C is still a valid base register, then add them.  */
1022       if (GET_CODE (XEXP (idx, 1)) == CONST_INT
1023           && INTVAL (XEXP (idx, 1)) <= 4096
1024           && INTVAL (XEXP (idx, 1)) >= -4096)
1025         {
1026           int val = INTVAL (XEXP (XEXP (idx, 0), 1));
1027           rtx reg1, reg2;
1028
1029           reg1 = force_reg (Pmode, gen_rtx_PLUS (Pmode, base, XEXP (idx, 1)));
1030
1031           reg2 = XEXP (XEXP (idx, 0), 0);
1032           if (GET_CODE (reg2) != CONST_INT)
1033             reg2 = force_reg (Pmode, force_operand (reg2, 0));
1034
1035           return force_reg (Pmode, gen_rtx_PLUS (Pmode,
1036                                                  gen_rtx_MULT (Pmode,
1037                                                                reg2,
1038                                                                GEN_INT (val)),
1039                                                  reg1));
1040         }
1041
1042       /* Get the index into a register, then add the base + index and
1043          return a register holding the result.  */
1044
1045       /* First get A into a register.  */
1046       reg1 = XEXP (XEXP (idx, 0), 0);
1047       if (GET_CODE (reg1) != REG)
1048         reg1 = force_reg (Pmode, force_operand (reg1, 0));
1049
1050       /* And get B into a register.  */
1051       reg2 = XEXP (idx, 1);
1052       if (GET_CODE (reg2) != REG)
1053         reg2 = force_reg (Pmode, force_operand (reg2, 0));
1054
1055       reg1 = force_reg (Pmode,
1056                         gen_rtx_PLUS (Pmode,
1057                                       gen_rtx_MULT (Pmode, reg1,
1058                                                     XEXP (XEXP (idx, 0), 1)),
1059                                       reg2));
1060
1061       /* Add the result to our base register and return.  */
1062       return force_reg (Pmode, gen_rtx_PLUS (Pmode, base, reg1));
1063
1064     }
1065
1066   /* Uh-oh.  We might have an address for x[n-100000].  This needs
1067      special handling to avoid creating an indexed memory address
1068      with x-100000 as the base.
1069
1070      If the constant part is small enough, then it's still safe because
1071      there is a guard page at the beginning and end of the data segment.
1072
1073      Scaled references are common enough that we want to try and rearrange the
1074      terms so that we can use indexing for these addresses too.  Only
1075      do the optimization for floatint point modes.  */
1076
1077   if (GET_CODE (x) == PLUS
1078       && symbolic_expression_p (XEXP (x, 1)))
1079     {
1080       /* Ugly.  We modify things here so that the address offset specified
1081          by the index expression is computed first, then added to x to form
1082          the entire address.  */
1083
1084       rtx regx1, regx2, regy1, regy2, y;
1085
1086       /* Strip off any CONST.  */
1087       y = XEXP (x, 1);
1088       if (GET_CODE (y) == CONST)
1089         y = XEXP (y, 0);
1090
1091       if (GET_CODE (y) == PLUS || GET_CODE (y) == MINUS)
1092         {
1093           /* See if this looks like
1094                 (plus (mult (reg) (shadd_const))
1095                       (const (plus (symbol_ref) (const_int))))
1096
1097              Where const_int is small.  In that case the const
1098              expression is a valid pointer for indexing.
1099
1100              If const_int is big, but can be divided evenly by shadd_const
1101              and added to (reg).  This allows more scaled indexed addresses.  */
1102           if (GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1103               && GET_CODE (XEXP (x, 0)) == MULT
1104               && GET_CODE (XEXP (y, 1)) == CONST_INT
1105               && INTVAL (XEXP (y, 1)) >= -4096
1106               && INTVAL (XEXP (y, 1)) <= 4095
1107               && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1108               && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1109             {
1110               int val = INTVAL (XEXP (XEXP (x, 0), 1));
1111               rtx reg1, reg2;
1112
1113               reg1 = XEXP (x, 1);
1114               if (GET_CODE (reg1) != REG)
1115                 reg1 = force_reg (Pmode, force_operand (reg1, 0));
1116
1117               reg2 = XEXP (XEXP (x, 0), 0);
1118               if (GET_CODE (reg2) != REG)
1119                 reg2 = force_reg (Pmode, force_operand (reg2, 0));
1120
1121               return force_reg (Pmode,
1122                                 gen_rtx_PLUS (Pmode,
1123                                               gen_rtx_MULT (Pmode,
1124                                                             reg2,
1125                                                             GEN_INT (val)),
1126                                               reg1));
1127             }
1128           else if ((mode == DFmode || mode == SFmode)
1129                    && GET_CODE (XEXP (y, 0)) == SYMBOL_REF
1130                    && GET_CODE (XEXP (x, 0)) == MULT
1131                    && GET_CODE (XEXP (y, 1)) == CONST_INT
1132                    && INTVAL (XEXP (y, 1)) % INTVAL (XEXP (XEXP (x, 0), 1)) == 0
1133                    && GET_CODE (XEXP (XEXP (x, 0), 1)) == CONST_INT
1134                    && shadd_constant_p (INTVAL (XEXP (XEXP (x, 0), 1))))
1135             {
1136               regx1
1137                 = force_reg (Pmode, GEN_INT (INTVAL (XEXP (y, 1))
1138                                              / INTVAL (XEXP (XEXP (x, 0), 1))));
1139               regx2 = XEXP (XEXP (x, 0), 0);
1140               if (GET_CODE (regx2) != REG)
1141                 regx2 = force_reg (Pmode, force_operand (regx2, 0));
1142               regx2 = force_reg (Pmode, gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1143                                                         regx2, regx1));
1144               return
1145                 force_reg (Pmode,
1146                            gen_rtx_PLUS (Pmode,
1147                                          gen_rtx_MULT (Pmode, regx2,
1148                                                        XEXP (XEXP (x, 0), 1)),
1149                                          force_reg (Pmode, XEXP (y, 0))));
1150             }
1151           else if (GET_CODE (XEXP (y, 1)) == CONST_INT
1152                    && INTVAL (XEXP (y, 1)) >= -4096
1153                    && INTVAL (XEXP (y, 1)) <= 4095)
1154             {
1155               /* This is safe because of the guard page at the
1156                  beginning and end of the data space.  Just
1157                  return the original address.  */
1158               return orig;
1159             }
1160           else
1161             {
1162               /* Doesn't look like one we can optimize.  */
1163               regx1 = force_reg (Pmode, force_operand (XEXP (x, 0), 0));
1164               regy1 = force_reg (Pmode, force_operand (XEXP (y, 0), 0));
1165               regy2 = force_reg (Pmode, force_operand (XEXP (y, 1), 0));
1166               regx1 = force_reg (Pmode,
1167                                  gen_rtx_fmt_ee (GET_CODE (y), Pmode,
1168                                                  regx1, regy2));
1169               return force_reg (Pmode, gen_rtx_PLUS (Pmode, regx1, regy1));
1170             }
1171         }
1172     }
1173
1174   return orig;
1175 }
1176
1177 /* For the HPPA, REG and REG+CONST is cost 0
1178    and addresses involving symbolic constants are cost 2.
1179
1180    PIC addresses are very expensive.
1181
1182    It is no coincidence that this has the same structure
1183    as GO_IF_LEGITIMATE_ADDRESS.  */
1184
1185 static int
1186 hppa_address_cost (rtx X)
1187 {
1188   switch (GET_CODE (X))
1189     {
1190     case REG:
1191     case PLUS:
1192     case LO_SUM:
1193       return 1;
1194     case HIGH:
1195       return 2;
1196     default:
1197       return 4;
1198     }
1199 }
1200
1201 /* Compute a (partial) cost for rtx X.  Return true if the complete
1202    cost has been computed, and false if subexpressions should be
1203    scanned.  In either case, *TOTAL contains the cost result.  */
1204
1205 static bool
1206 hppa_rtx_costs (rtx x, int code, int outer_code, int *total)
1207 {
1208   switch (code)
1209     {
1210     case CONST_INT:
1211       if (INTVAL (x) == 0)
1212         *total = 0;
1213       else if (INT_14_BITS (x))
1214         *total = 1;
1215       else
1216         *total = 2;
1217       return true;
1218
1219     case HIGH:
1220       *total = 2;
1221       return true;
1222
1223     case CONST:
1224     case LABEL_REF:
1225     case SYMBOL_REF:
1226       *total = 4;
1227       return true;
1228
1229     case CONST_DOUBLE:
1230       if ((x == CONST0_RTX (DFmode) || x == CONST0_RTX (SFmode))
1231           && outer_code != SET)
1232         *total = 0;
1233       else
1234         *total = 8;
1235       return true;
1236
1237     case MULT:
1238       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1239         *total = COSTS_N_INSNS (3);
1240       else if (TARGET_PA_11 && !TARGET_DISABLE_FPREGS && !TARGET_SOFT_FLOAT)
1241         *total = COSTS_N_INSNS (8);
1242       else
1243         *total = COSTS_N_INSNS (20);
1244       return true;
1245
1246     case DIV:
1247       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1248         {
1249           *total = COSTS_N_INSNS (14);
1250           return true;
1251         }
1252       /* FALLTHRU */
1253
1254     case UDIV:
1255     case MOD:
1256     case UMOD:
1257       *total = COSTS_N_INSNS (60);
1258       return true;
1259
1260     case PLUS: /* this includes shNadd insns */
1261     case MINUS:
1262       if (GET_MODE_CLASS (GET_MODE (x)) == MODE_FLOAT)
1263         *total = COSTS_N_INSNS (3);
1264       else
1265         *total = COSTS_N_INSNS (1);
1266       return true;
1267
1268     case ASHIFT:
1269     case ASHIFTRT:
1270     case LSHIFTRT:
1271       *total = COSTS_N_INSNS (1);
1272       return true;
1273
1274     default:
1275       return false;
1276     }
1277 }
1278
1279 /* Ensure mode of ORIG, a REG rtx, is MODE.  Returns either ORIG or a
1280    new rtx with the correct mode.  */
1281 static inline rtx
1282 force_mode (enum machine_mode mode, rtx orig)
1283 {
1284   if (mode == GET_MODE (orig))
1285     return orig;
1286
1287   gcc_assert (REGNO (orig) < FIRST_PSEUDO_REGISTER);
1288
1289   return gen_rtx_REG (mode, REGNO (orig));
1290 }
1291
1292 /* Return 1 if *X is a thread-local symbol.  */
1293
1294 static int
1295 pa_tls_symbol_ref_1 (rtx *x, void *data ATTRIBUTE_UNUSED)
1296 {
1297   return PA_SYMBOL_REF_TLS_P (*x);
1298 }
1299
1300 /* Return 1 if X contains a thread-local symbol.  */
1301
1302 bool
1303 pa_tls_referenced_p (rtx x)
1304 {
1305   if (!TARGET_HAVE_TLS)
1306     return false;
1307
1308   return for_each_rtx (&x, &pa_tls_symbol_ref_1, 0);
1309 }
1310
1311 /* Emit insns to move operands[1] into operands[0].
1312
1313    Return 1 if we have written out everything that needs to be done to
1314    do the move.  Otherwise, return 0 and the caller will emit the move
1315    normally.
1316
1317    Note SCRATCH_REG may not be in the proper mode depending on how it
1318    will be used.  This routine is responsible for creating a new copy
1319    of SCRATCH_REG in the proper mode.  */
1320
1321 int
1322 emit_move_sequence (rtx *operands, enum machine_mode mode, rtx scratch_reg)
1323 {
1324   register rtx operand0 = operands[0];
1325   register rtx operand1 = operands[1];
1326   register rtx tem;
1327
1328   /* We can only handle indexed addresses in the destination operand
1329      of floating point stores.  Thus, we need to break out indexed
1330      addresses from the destination operand.  */
1331   if (GET_CODE (operand0) == MEM && IS_INDEX_ADDR_P (XEXP (operand0, 0)))
1332     {
1333       /* This is only safe up to the beginning of life analysis.  */
1334       gcc_assert (!no_new_pseudos);
1335
1336       tem = copy_to_mode_reg (Pmode, XEXP (operand0, 0));
1337       operand0 = replace_equiv_address (operand0, tem);
1338     }
1339
1340   /* On targets with non-equivalent space registers, break out unscaled
1341      indexed addresses from the source operand before the final CSE.
1342      We have to do this because the REG_POINTER flag is not correctly
1343      carried through various optimization passes and CSE may substitute
1344      a pseudo without the pointer set for one with the pointer set.  As
1345      a result, we loose various opportunities to create insns with
1346      unscaled indexed addresses.  */
1347   if (!TARGET_NO_SPACE_REGS
1348       && !cse_not_expected
1349       && GET_CODE (operand1) == MEM
1350       && GET_CODE (XEXP (operand1, 0)) == PLUS
1351       && REG_P (XEXP (XEXP (operand1, 0), 0))
1352       && REG_P (XEXP (XEXP (operand1, 0), 1)))
1353     operand1
1354       = replace_equiv_address (operand1,
1355                                copy_to_mode_reg (Pmode, XEXP (operand1, 0)));
1356
1357   if (scratch_reg
1358       && reload_in_progress && GET_CODE (operand0) == REG
1359       && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
1360     operand0 = reg_equiv_mem[REGNO (operand0)];
1361   else if (scratch_reg
1362            && reload_in_progress && GET_CODE (operand0) == SUBREG
1363            && GET_CODE (SUBREG_REG (operand0)) == REG
1364            && REGNO (SUBREG_REG (operand0)) >= FIRST_PSEUDO_REGISTER)
1365     {
1366      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1367         the code which tracks sets/uses for delete_output_reload.  */
1368       rtx temp = gen_rtx_SUBREG (GET_MODE (operand0),
1369                                  reg_equiv_mem [REGNO (SUBREG_REG (operand0))],
1370                                  SUBREG_BYTE (operand0));
1371       operand0 = alter_subreg (&temp);
1372     }
1373
1374   if (scratch_reg
1375       && reload_in_progress && GET_CODE (operand1) == REG
1376       && REGNO (operand1) >= FIRST_PSEUDO_REGISTER)
1377     operand1 = reg_equiv_mem[REGNO (operand1)];
1378   else if (scratch_reg
1379            && reload_in_progress && GET_CODE (operand1) == SUBREG
1380            && GET_CODE (SUBREG_REG (operand1)) == REG
1381            && REGNO (SUBREG_REG (operand1)) >= FIRST_PSEUDO_REGISTER)
1382     {
1383      /* We must not alter SUBREG_BYTE (operand0) since that would confuse
1384         the code which tracks sets/uses for delete_output_reload.  */
1385       rtx temp = gen_rtx_SUBREG (GET_MODE (operand1),
1386                                  reg_equiv_mem [REGNO (SUBREG_REG (operand1))],
1387                                  SUBREG_BYTE (operand1));
1388       operand1 = alter_subreg (&temp);
1389     }
1390
1391   if (scratch_reg && reload_in_progress && GET_CODE (operand0) == MEM
1392       && ((tem = find_replacement (&XEXP (operand0, 0)))
1393           != XEXP (operand0, 0)))
1394     operand0 = replace_equiv_address (operand0, tem);
1395
1396   if (scratch_reg && reload_in_progress && GET_CODE (operand1) == MEM
1397       && ((tem = find_replacement (&XEXP (operand1, 0)))
1398           != XEXP (operand1, 0)))
1399     operand1 = replace_equiv_address (operand1, tem);
1400
1401   /* Handle secondary reloads for loads/stores of FP registers from
1402      REG+D addresses where D does not fit in 5 or 14 bits, including
1403      (subreg (mem (addr))) cases.  */
1404   if (scratch_reg
1405       && fp_reg_operand (operand0, mode)
1406       && ((GET_CODE (operand1) == MEM
1407            && !memory_address_p ((GET_MODE_SIZE (mode) == 4 ? SFmode : DFmode),
1408                                  XEXP (operand1, 0)))
1409           || ((GET_CODE (operand1) == SUBREG
1410                && GET_CODE (XEXP (operand1, 0)) == MEM
1411                && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1412                                       ? SFmode : DFmode),
1413                                      XEXP (XEXP (operand1, 0), 0))))))
1414     {
1415       if (GET_CODE (operand1) == SUBREG)
1416         operand1 = XEXP (operand1, 0);
1417
1418       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1419          it in WORD_MODE regardless of what mode it was originally given
1420          to us.  */
1421       scratch_reg = force_mode (word_mode, scratch_reg);
1422
1423       /* D might not fit in 14 bits either; for such cases load D into
1424          scratch reg.  */
1425       if (!memory_address_p (Pmode, XEXP (operand1, 0)))
1426         {
1427           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1428           emit_move_insn (scratch_reg,
1429                           gen_rtx_fmt_ee (GET_CODE (XEXP (operand1, 0)),
1430                                           Pmode,
1431                                           XEXP (XEXP (operand1, 0), 0),
1432                                           scratch_reg));
1433         }
1434       else
1435         emit_move_insn (scratch_reg, XEXP (operand1, 0));
1436       emit_insn (gen_rtx_SET (VOIDmode, operand0,
1437                               replace_equiv_address (operand1, scratch_reg)));
1438       return 1;
1439     }
1440   else if (scratch_reg
1441            && fp_reg_operand (operand1, mode)
1442            && ((GET_CODE (operand0) == MEM
1443                 && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1444                                         ? SFmode : DFmode),
1445                                        XEXP (operand0, 0)))
1446                || ((GET_CODE (operand0) == SUBREG)
1447                    && GET_CODE (XEXP (operand0, 0)) == MEM
1448                    && !memory_address_p ((GET_MODE_SIZE (mode) == 4
1449                                           ? SFmode : DFmode),
1450                                          XEXP (XEXP (operand0, 0), 0)))))
1451     {
1452       if (GET_CODE (operand0) == SUBREG)
1453         operand0 = XEXP (operand0, 0);
1454
1455       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1456          it in WORD_MODE regardless of what mode it was originally given
1457          to us.  */
1458       scratch_reg = force_mode (word_mode, scratch_reg);
1459
1460       /* D might not fit in 14 bits either; for such cases load D into
1461          scratch reg.  */
1462       if (!memory_address_p (Pmode, XEXP (operand0, 0)))
1463         {
1464           emit_move_insn (scratch_reg, XEXP (XEXP (operand0, 0), 1));
1465           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand0,
1466                                                                         0)),
1467                                                        Pmode,
1468                                                        XEXP (XEXP (operand0, 0),
1469                                                                    0),
1470                                                        scratch_reg));
1471         }
1472       else
1473         emit_move_insn (scratch_reg, XEXP (operand0, 0));
1474       emit_insn (gen_rtx_SET (VOIDmode,
1475                               replace_equiv_address (operand0, scratch_reg),
1476                               operand1));
1477       return 1;
1478     }
1479   /* Handle secondary reloads for loads of FP registers from constant
1480      expressions by forcing the constant into memory.
1481
1482      Use scratch_reg to hold the address of the memory location.
1483
1484      The proper fix is to change PREFERRED_RELOAD_CLASS to return
1485      NO_REGS when presented with a const_int and a register class
1486      containing only FP registers.  Doing so unfortunately creates
1487      more problems than it solves.   Fix this for 2.5.  */
1488   else if (scratch_reg
1489            && CONSTANT_P (operand1)
1490            && fp_reg_operand (operand0, mode))
1491     {
1492       rtx const_mem, xoperands[2];
1493
1494       /* SCRATCH_REG will hold an address and maybe the actual data.  We want
1495          it in WORD_MODE regardless of what mode it was originally given
1496          to us.  */
1497       scratch_reg = force_mode (word_mode, scratch_reg);
1498
1499       /* Force the constant into memory and put the address of the
1500          memory location into scratch_reg.  */
1501       const_mem = force_const_mem (mode, operand1);
1502       xoperands[0] = scratch_reg;
1503       xoperands[1] = XEXP (const_mem, 0);
1504       emit_move_sequence (xoperands, Pmode, 0);
1505
1506       /* Now load the destination register.  */
1507       emit_insn (gen_rtx_SET (mode, operand0,
1508                               replace_equiv_address (const_mem, scratch_reg)));
1509       return 1;
1510     }
1511   /* Handle secondary reloads for SAR.  These occur when trying to load
1512      the SAR from memory, FP register, or with a constant.  */
1513   else if (scratch_reg
1514            && GET_CODE (operand0) == REG
1515            && REGNO (operand0) < FIRST_PSEUDO_REGISTER
1516            && REGNO_REG_CLASS (REGNO (operand0)) == SHIFT_REGS
1517            && (GET_CODE (operand1) == MEM
1518                || GET_CODE (operand1) == CONST_INT
1519                || (GET_CODE (operand1) == REG
1520                    && FP_REG_CLASS_P (REGNO_REG_CLASS (REGNO (operand1))))))
1521     {
1522       /* D might not fit in 14 bits either; for such cases load D into
1523          scratch reg.  */
1524       if (GET_CODE (operand1) == MEM
1525           && !memory_address_p (Pmode, XEXP (operand1, 0)))
1526         {
1527           /* We are reloading the address into the scratch register, so we
1528              want to make sure the scratch register is a full register.  */
1529           scratch_reg = force_mode (word_mode, scratch_reg);
1530
1531           emit_move_insn (scratch_reg, XEXP (XEXP (operand1, 0), 1));
1532           emit_move_insn (scratch_reg, gen_rtx_fmt_ee (GET_CODE (XEXP (operand1,
1533                                                                         0)),
1534                                                        Pmode,
1535                                                        XEXP (XEXP (operand1, 0),
1536                                                        0),
1537                                                        scratch_reg));
1538
1539           /* Now we are going to load the scratch register from memory,
1540              we want to load it in the same width as the original MEM,
1541              which must be the same as the width of the ultimate destination,
1542              OPERAND0.  */
1543           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1544
1545           emit_move_insn (scratch_reg,
1546                           replace_equiv_address (operand1, scratch_reg));
1547         }
1548       else
1549         {
1550           /* We want to load the scratch register using the same mode as
1551              the ultimate destination.  */
1552           scratch_reg = force_mode (GET_MODE (operand0), scratch_reg);
1553
1554           emit_move_insn (scratch_reg, operand1);
1555         }
1556
1557       /* And emit the insn to set the ultimate destination.  We know that
1558          the scratch register has the same mode as the destination at this
1559          point.  */
1560       emit_move_insn (operand0, scratch_reg);
1561       return 1;
1562     }
1563   /* Handle the most common case: storing into a register.  */
1564   else if (register_operand (operand0, mode))
1565     {
1566       if (register_operand (operand1, mode)
1567           || (GET_CODE (operand1) == CONST_INT
1568               && cint_ok_for_move (INTVAL (operand1)))
1569           || (operand1 == CONST0_RTX (mode))
1570           || (GET_CODE (operand1) == HIGH
1571               && !symbolic_operand (XEXP (operand1, 0), VOIDmode))
1572           /* Only `general_operands' can come here, so MEM is ok.  */
1573           || GET_CODE (operand1) == MEM)
1574         {
1575           /* Various sets are created during RTL generation which don't
1576              have the REG_POINTER flag correctly set.  After the CSE pass,
1577              instruction recognition can fail if we don't consistently
1578              set this flag when performing register copies.  This should
1579              also improve the opportunities for creating insns that use
1580              unscaled indexing.  */
1581           if (REG_P (operand0) && REG_P (operand1))
1582             {
1583               if (REG_POINTER (operand1)
1584                   && !REG_POINTER (operand0)
1585                   && !HARD_REGISTER_P (operand0))
1586                 copy_reg_pointer (operand0, operand1);
1587               else if (REG_POINTER (operand0)
1588                        && !REG_POINTER (operand1)
1589                        && !HARD_REGISTER_P (operand1))
1590                 copy_reg_pointer (operand1, operand0);
1591             }
1592
1593           /* When MEMs are broken out, the REG_POINTER flag doesn't
1594              get set.  In some cases, we can set the REG_POINTER flag
1595              from the declaration for the MEM.  */
1596           if (REG_P (operand0)
1597               && GET_CODE (operand1) == MEM
1598               && !REG_POINTER (operand0))
1599             {
1600               tree decl = MEM_EXPR (operand1);
1601
1602               /* Set the register pointer flag and register alignment
1603                  if the declaration for this memory reference is a
1604                  pointer type.  Fortran indirect argument references
1605                  are ignored.  */
1606               if (decl
1607                   && !(flag_argument_noalias > 1
1608                        && TREE_CODE (decl) == INDIRECT_REF
1609                        && TREE_CODE (TREE_OPERAND (decl, 0)) == PARM_DECL))
1610                 {
1611                   tree type;
1612
1613                   /* If this is a COMPONENT_REF, use the FIELD_DECL from
1614                      tree operand 1.  */
1615                   if (TREE_CODE (decl) == COMPONENT_REF)
1616                     decl = TREE_OPERAND (decl, 1);
1617
1618                   type = TREE_TYPE (decl);
1619                   if (TREE_CODE (type) == ARRAY_TYPE)
1620                     type = get_inner_array_type (type);
1621
1622                   if (POINTER_TYPE_P (type))
1623                     {
1624                       int align;
1625
1626                       type = TREE_TYPE (type);
1627                       /* Using TYPE_ALIGN_OK is rather conservative as
1628                          only the ada frontend actually sets it.  */
1629                       align = (TYPE_ALIGN_OK (type) ? TYPE_ALIGN (type)
1630                                : BITS_PER_UNIT);
1631                       mark_reg_pointer (operand0, align);
1632                     }
1633                 }
1634             }
1635
1636           emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
1637           return 1;
1638         }
1639     }
1640   else if (GET_CODE (operand0) == MEM)
1641     {
1642       if (mode == DFmode && operand1 == CONST0_RTX (mode)
1643           && !(reload_in_progress || reload_completed))
1644         {
1645           rtx temp = gen_reg_rtx (DFmode);
1646
1647           emit_insn (gen_rtx_SET (VOIDmode, temp, operand1));
1648           emit_insn (gen_rtx_SET (VOIDmode, operand0, temp));
1649           return 1;
1650         }
1651       if (register_operand (operand1, mode) || operand1 == CONST0_RTX (mode))
1652         {
1653           /* Run this case quickly.  */
1654           emit_insn (gen_rtx_SET (VOIDmode, operand0, operand1));
1655           return 1;
1656         }
1657       if (! (reload_in_progress || reload_completed))
1658         {
1659           operands[0] = validize_mem (operand0);
1660           operands[1] = operand1 = force_reg (mode, operand1);
1661         }
1662     }
1663
1664   /* Simplify the source if we need to.
1665      Note we do have to handle function labels here, even though we do
1666      not consider them legitimate constants.  Loop optimizations can
1667      call the emit_move_xxx with one as a source.  */
1668   if ((GET_CODE (operand1) != HIGH && immediate_operand (operand1, mode))
1669       || function_label_operand (operand1, mode)
1670       || (GET_CODE (operand1) == HIGH
1671           && symbolic_operand (XEXP (operand1, 0), mode)))
1672     {
1673       int ishighonly = 0;
1674
1675       if (GET_CODE (operand1) == HIGH)
1676         {
1677           ishighonly = 1;
1678           operand1 = XEXP (operand1, 0);
1679         }
1680       if (symbolic_operand (operand1, mode))
1681         {
1682           /* Argh.  The assembler and linker can't handle arithmetic
1683              involving plabels.
1684
1685              So we force the plabel into memory, load operand0 from
1686              the memory location, then add in the constant part.  */
1687           if ((GET_CODE (operand1) == CONST
1688                && GET_CODE (XEXP (operand1, 0)) == PLUS
1689                && function_label_operand (XEXP (XEXP (operand1, 0), 0), Pmode))
1690               || function_label_operand (operand1, mode))
1691             {
1692               rtx temp, const_part;
1693
1694               /* Figure out what (if any) scratch register to use.  */
1695               if (reload_in_progress || reload_completed)
1696                 {
1697                   scratch_reg = scratch_reg ? scratch_reg : operand0;
1698                   /* SCRATCH_REG will hold an address and maybe the actual
1699                      data.  We want it in WORD_MODE regardless of what mode it
1700                      was originally given to us.  */
1701                   scratch_reg = force_mode (word_mode, scratch_reg);
1702                 }
1703               else if (flag_pic)
1704                 scratch_reg = gen_reg_rtx (Pmode);
1705
1706               if (GET_CODE (operand1) == CONST)
1707                 {
1708                   /* Save away the constant part of the expression.  */
1709                   const_part = XEXP (XEXP (operand1, 0), 1);
1710                   gcc_assert (GET_CODE (const_part) == CONST_INT);
1711
1712                   /* Force the function label into memory.  */
1713                   temp = force_const_mem (mode, XEXP (XEXP (operand1, 0), 0));
1714                 }
1715               else
1716                 {
1717                   /* No constant part.  */
1718                   const_part = NULL_RTX;
1719
1720                   /* Force the function label into memory.  */
1721                   temp = force_const_mem (mode, operand1);
1722                 }
1723
1724
1725               /* Get the address of the memory location.  PIC-ify it if
1726                  necessary.  */
1727               temp = XEXP (temp, 0);
1728               if (flag_pic)
1729                 temp = legitimize_pic_address (temp, mode, scratch_reg);
1730
1731               /* Put the address of the memory location into our destination
1732                  register.  */
1733               operands[1] = temp;
1734               emit_move_sequence (operands, mode, scratch_reg);
1735
1736               /* Now load from the memory location into our destination
1737                  register.  */
1738               operands[1] = gen_rtx_MEM (Pmode, operands[0]);
1739               emit_move_sequence (operands, mode, scratch_reg);
1740
1741               /* And add back in the constant part.  */
1742               if (const_part != NULL_RTX)
1743                 expand_inc (operand0, const_part);
1744
1745               return 1;
1746             }
1747
1748           if (flag_pic)
1749             {
1750               rtx temp;
1751
1752               if (reload_in_progress || reload_completed)
1753                 {
1754                   temp = scratch_reg ? scratch_reg : operand0;
1755                   /* TEMP will hold an address and maybe the actual
1756                      data.  We want it in WORD_MODE regardless of what mode it
1757                      was originally given to us.  */
1758                   temp = force_mode (word_mode, temp);
1759                 }
1760               else
1761                 temp = gen_reg_rtx (Pmode);
1762
1763               /* (const (plus (symbol) (const_int))) must be forced to
1764                  memory during/after reload if the const_int will not fit
1765                  in 14 bits.  */
1766               if (GET_CODE (operand1) == CONST
1767                        && GET_CODE (XEXP (operand1, 0)) == PLUS
1768                        && GET_CODE (XEXP (XEXP (operand1, 0), 1)) == CONST_INT
1769                        && !INT_14_BITS (XEXP (XEXP (operand1, 0), 1))
1770                        && (reload_completed || reload_in_progress)
1771                        && flag_pic)
1772                 {
1773                   rtx const_mem = force_const_mem (mode, operand1);
1774                   operands[1] = legitimize_pic_address (XEXP (const_mem, 0),
1775                                                         mode, temp);
1776                   operands[1] = replace_equiv_address (const_mem, operands[1]);
1777                   emit_move_sequence (operands, mode, temp);
1778                 }
1779               else
1780                 {
1781                   operands[1] = legitimize_pic_address (operand1, mode, temp);
1782                   if (REG_P (operand0) && REG_P (operands[1]))
1783                     copy_reg_pointer (operand0, operands[1]);
1784                   emit_insn (gen_rtx_SET (VOIDmode, operand0, operands[1]));
1785                 }
1786             }
1787           /* On the HPPA, references to data space are supposed to use dp,
1788              register 27, but showing it in the RTL inhibits various cse
1789              and loop optimizations.  */
1790           else
1791             {
1792               rtx temp, set;
1793
1794               if (reload_in_progress || reload_completed)
1795                 {
1796                   temp = scratch_reg ? scratch_reg : operand0;
1797                   /* TEMP will hold an address and maybe the actual
1798                      data.  We want it in WORD_MODE regardless of what mode it
1799                      was originally given to us.  */
1800                   temp = force_mode (word_mode, temp);
1801                 }
1802               else
1803                 temp = gen_reg_rtx (mode);
1804
1805               /* Loading a SYMBOL_REF into a register makes that register
1806                  safe to be used as the base in an indexed address.
1807
1808                  Don't mark hard registers though.  That loses.  */
1809               if (GET_CODE (operand0) == REG
1810                   && REGNO (operand0) >= FIRST_PSEUDO_REGISTER)
1811                 mark_reg_pointer (operand0, BITS_PER_UNIT);
1812               if (REGNO (temp) >= FIRST_PSEUDO_REGISTER)
1813                 mark_reg_pointer (temp, BITS_PER_UNIT);
1814
1815               if (ishighonly)
1816                 set = gen_rtx_SET (mode, operand0, temp);
1817               else
1818                 set = gen_rtx_SET (VOIDmode,
1819                                    operand0,
1820                                    gen_rtx_LO_SUM (mode, temp, operand1));
1821
1822               emit_insn (gen_rtx_SET (VOIDmode,
1823                                       temp,
1824                                       gen_rtx_HIGH (mode, operand1)));
1825               emit_insn (set);
1826
1827             }
1828           return 1;
1829         }
1830       else if (pa_tls_referenced_p (operand1))
1831         {
1832           rtx tmp = operand1;
1833           rtx addend = NULL;
1834
1835           if (GET_CODE (tmp) == CONST && GET_CODE (XEXP (tmp, 0)) == PLUS)
1836             {
1837               addend = XEXP (XEXP (tmp, 0), 1);
1838               tmp = XEXP (XEXP (tmp, 0), 0);
1839             }
1840
1841           gcc_assert (GET_CODE (tmp) == SYMBOL_REF);
1842           tmp = legitimize_tls_address (tmp);
1843           if (addend)
1844             {
1845               tmp = gen_rtx_PLUS (mode, tmp, addend);
1846               tmp = force_operand (tmp, operands[0]);
1847             }
1848           operands[1] = tmp;
1849         }
1850       else if (GET_CODE (operand1) != CONST_INT
1851                || !cint_ok_for_move (INTVAL (operand1)))
1852         {
1853           rtx insn, temp;
1854           rtx op1 = operand1;
1855           HOST_WIDE_INT value = 0;
1856           HOST_WIDE_INT insv = 0;
1857           int insert = 0;
1858
1859           if (GET_CODE (operand1) == CONST_INT)
1860             value = INTVAL (operand1);
1861
1862           if (TARGET_64BIT
1863               && GET_CODE (operand1) == CONST_INT
1864               && HOST_BITS_PER_WIDE_INT > 32
1865               && GET_MODE_BITSIZE (GET_MODE (operand0)) > 32)
1866             {
1867               HOST_WIDE_INT nval;
1868
1869               /* Extract the low order 32 bits of the value and sign extend.
1870                  If the new value is the same as the original value, we can
1871                  can use the original value as-is.  If the new value is
1872                  different, we use it and insert the most-significant 32-bits
1873                  of the original value into the final result.  */
1874               nval = ((value & (((HOST_WIDE_INT) 2 << 31) - 1))
1875                       ^ ((HOST_WIDE_INT) 1 << 31)) - ((HOST_WIDE_INT) 1 << 31);
1876               if (value != nval)
1877                 {
1878 #if HOST_BITS_PER_WIDE_INT > 32
1879                   insv = value >= 0 ? value >> 32 : ~(~value >> 32);
1880 #endif
1881                   insert = 1;
1882                   value = nval;
1883                   operand1 = GEN_INT (nval);
1884                 }
1885             }
1886
1887           if (reload_in_progress || reload_completed)
1888             temp = scratch_reg ? scratch_reg : operand0;
1889           else
1890             temp = gen_reg_rtx (mode);
1891
1892           /* We don't directly split DImode constants on 32-bit targets
1893              because PLUS uses an 11-bit immediate and the insn sequence
1894              generated is not as efficient as the one using HIGH/LO_SUM.  */
1895           if (GET_CODE (operand1) == CONST_INT
1896               && GET_MODE_BITSIZE (mode) <= HOST_BITS_PER_WIDE_INT
1897               && !insert)
1898             {
1899               /* Directly break constant into high and low parts.  This
1900                  provides better optimization opportunities because various
1901                  passes recognize constants split with PLUS but not LO_SUM.
1902                  We use a 14-bit signed low part except when the addition
1903                  of 0x4000 to the high part might change the sign of the
1904                  high part.  */
1905               HOST_WIDE_INT low = value & 0x3fff;
1906               HOST_WIDE_INT high = value & ~ 0x3fff;
1907
1908               if (low >= 0x2000)
1909                 {
1910                   if (high == 0x7fffc000 || (mode == HImode && high == 0x4000))
1911                     high += 0x2000;
1912                   else
1913                     high += 0x4000;
1914                 }
1915
1916               low = value - high;
1917
1918               emit_insn (gen_rtx_SET (VOIDmode, temp, GEN_INT (high)));
1919               operands[1] = gen_rtx_PLUS (mode, temp, GEN_INT (low));
1920             }
1921           else
1922             {
1923               emit_insn (gen_rtx_SET (VOIDmode, temp,
1924                                       gen_rtx_HIGH (mode, operand1)));
1925               operands[1] = gen_rtx_LO_SUM (mode, temp, operand1);
1926             }
1927
1928           insn = emit_move_insn (operands[0], operands[1]);
1929
1930           /* Now insert the most significant 32 bits of the value
1931              into the register.  When we don't have a second register
1932              available, it could take up to nine instructions to load
1933              a 64-bit integer constant.  Prior to reload, we force
1934              constants that would take more than three instructions
1935              to load to the constant pool.  During and after reload,
1936              we have to handle all possible values.  */
1937           if (insert)
1938             {
1939               /* Use a HIGH/LO_SUM/INSV sequence if we have a second
1940                  register and the value to be inserted is outside the
1941                  range that can be loaded with three depdi instructions.  */
1942               if (temp != operand0 && (insv >= 16384 || insv < -16384))
1943                 {
1944                   operand1 = GEN_INT (insv);
1945
1946                   emit_insn (gen_rtx_SET (VOIDmode, temp,
1947                                           gen_rtx_HIGH (mode, operand1)));
1948                   emit_move_insn (temp, gen_rtx_LO_SUM (mode, temp, operand1));
1949                   emit_insn (gen_insv (operand0, GEN_INT (32),
1950                                        const0_rtx, temp));
1951                 }
1952               else
1953                 {
1954                   int len = 5, pos = 27;
1955
1956                   /* Insert the bits using the depdi instruction.  */
1957                   while (pos >= 0)
1958                     {
1959                       HOST_WIDE_INT v5 = ((insv & 31) ^ 16) - 16;
1960                       HOST_WIDE_INT sign = v5 < 0;
1961
1962                       /* Left extend the insertion.  */
1963                       insv = (insv >= 0 ? insv >> len : ~(~insv >> len));
1964                       while (pos > 0 && (insv & 1) == sign)
1965                         {
1966                           insv = (insv >= 0 ? insv >> 1 : ~(~insv >> 1));
1967                           len += 1;
1968                           pos -= 1;
1969                         }
1970
1971                       emit_insn (gen_insv (operand0, GEN_INT (len),
1972                                            GEN_INT (pos), GEN_INT (v5)));
1973
1974                       len = pos > 0 && pos < 5 ? pos : 5;
1975                       pos -= len;
1976                     }
1977                 }
1978             }
1979
1980           REG_NOTES (insn)
1981             = gen_rtx_EXPR_LIST (REG_EQUAL, op1, REG_NOTES (insn));
1982
1983           return 1;
1984         }
1985     }
1986   /* Now have insn-emit do whatever it normally does.  */
1987   return 0;
1988 }
1989
1990 /* Examine EXP and return nonzero if it contains an ADDR_EXPR (meaning
1991    it will need a link/runtime reloc).  */
1992
1993 int
1994 reloc_needed (tree exp)
1995 {
1996   int reloc = 0;
1997
1998   switch (TREE_CODE (exp))
1999     {
2000     case ADDR_EXPR:
2001       return 1;
2002
2003     case PLUS_EXPR:
2004     case MINUS_EXPR:
2005       reloc = reloc_needed (TREE_OPERAND (exp, 0));
2006       reloc |= reloc_needed (TREE_OPERAND (exp, 1));
2007       break;
2008
2009     case NOP_EXPR:
2010     case CONVERT_EXPR:
2011     case NON_LVALUE_EXPR:
2012       reloc = reloc_needed (TREE_OPERAND (exp, 0));
2013       break;
2014
2015     case CONSTRUCTOR:
2016       {
2017         tree value;
2018         unsigned HOST_WIDE_INT ix;
2019
2020         FOR_EACH_CONSTRUCTOR_VALUE (CONSTRUCTOR_ELTS (exp), ix, value)
2021           if (value)
2022             reloc |= reloc_needed (value);
2023       }
2024       break;
2025
2026     case ERROR_MARK:
2027       break;
2028
2029     default:
2030       break;
2031     }
2032   return reloc;
2033 }
2034
2035 /* Does operand (which is a symbolic_operand) live in text space?
2036    If so, SYMBOL_REF_FLAG, which is set by pa_encode_section_info,
2037    will be true.  */
2038
2039 int
2040 read_only_operand (rtx operand, enum machine_mode mode ATTRIBUTE_UNUSED)
2041 {
2042   if (GET_CODE (operand) == CONST)
2043     operand = XEXP (XEXP (operand, 0), 0);
2044   if (flag_pic)
2045     {
2046       if (GET_CODE (operand) == SYMBOL_REF)
2047         return SYMBOL_REF_FLAG (operand) && !CONSTANT_POOL_ADDRESS_P (operand);
2048     }
2049   else
2050     {
2051       if (GET_CODE (operand) == SYMBOL_REF)
2052         return SYMBOL_REF_FLAG (operand) || CONSTANT_POOL_ADDRESS_P (operand);
2053     }
2054   return 1;
2055 }
2056
2057 \f
2058 /* Return the best assembler insn template
2059    for moving operands[1] into operands[0] as a fullword.  */
2060 const char *
2061 singlemove_string (rtx *operands)
2062 {
2063   HOST_WIDE_INT intval;
2064
2065   if (GET_CODE (operands[0]) == MEM)
2066     return "stw %r1,%0";
2067   if (GET_CODE (operands[1]) == MEM)
2068     return "ldw %1,%0";
2069   if (GET_CODE (operands[1]) == CONST_DOUBLE)
2070     {
2071       long i;
2072       REAL_VALUE_TYPE d;
2073
2074       gcc_assert (GET_MODE (operands[1]) == SFmode);
2075
2076       /* Translate the CONST_DOUBLE to a CONST_INT with the same target
2077          bit pattern.  */
2078       REAL_VALUE_FROM_CONST_DOUBLE (d, operands[1]);
2079       REAL_VALUE_TO_TARGET_SINGLE (d, i);
2080
2081       operands[1] = GEN_INT (i);
2082       /* Fall through to CONST_INT case.  */
2083     }
2084   if (GET_CODE (operands[1]) == CONST_INT)
2085     {
2086       intval = INTVAL (operands[1]);
2087
2088       if (VAL_14_BITS_P (intval))
2089         return "ldi %1,%0";
2090       else if ((intval & 0x7ff) == 0)
2091         return "ldil L'%1,%0";
2092       else if (zdepi_cint_p (intval))
2093         return "{zdepi %Z1,%0|depwi,z %Z1,%0}";
2094       else
2095         return "ldil L'%1,%0\n\tldo R'%1(%0),%0";
2096     }
2097   return "copy %1,%0";
2098 }
2099 \f
2100
2101 /* Compute position (in OP[1]) and width (in OP[2])
2102    useful for copying IMM to a register using the zdepi
2103    instructions.  Store the immediate value to insert in OP[0].  */
2104 static void
2105 compute_zdepwi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2106 {
2107   int lsb, len;
2108
2109   /* Find the least significant set bit in IMM.  */
2110   for (lsb = 0; lsb < 32; lsb++)
2111     {
2112       if ((imm & 1) != 0)
2113         break;
2114       imm >>= 1;
2115     }
2116
2117   /* Choose variants based on *sign* of the 5-bit field.  */
2118   if ((imm & 0x10) == 0)
2119     len = (lsb <= 28) ? 4 : 32 - lsb;
2120   else
2121     {
2122       /* Find the width of the bitstring in IMM.  */
2123       for (len = 5; len < 32; len++)
2124         {
2125           if ((imm & (1 << len)) == 0)
2126             break;
2127         }
2128
2129       /* Sign extend IMM as a 5-bit value.  */
2130       imm = (imm & 0xf) - 0x10;
2131     }
2132
2133   op[0] = imm;
2134   op[1] = 31 - lsb;
2135   op[2] = len;
2136 }
2137
2138 /* Compute position (in OP[1]) and width (in OP[2])
2139    useful for copying IMM to a register using the depdi,z
2140    instructions.  Store the immediate value to insert in OP[0].  */
2141 void
2142 compute_zdepdi_operands (unsigned HOST_WIDE_INT imm, unsigned *op)
2143 {
2144   HOST_WIDE_INT lsb, len;
2145
2146   /* Find the least significant set bit in IMM.  */
2147   for (lsb = 0; lsb < HOST_BITS_PER_WIDE_INT; lsb++)
2148     {
2149       if ((imm & 1) != 0)
2150         break;
2151       imm >>= 1;
2152     }
2153
2154   /* Choose variants based on *sign* of the 5-bit field.  */
2155   if ((imm & 0x10) == 0)
2156     len = ((lsb <= HOST_BITS_PER_WIDE_INT - 4)
2157            ? 4 : HOST_BITS_PER_WIDE_INT - lsb);
2158   else
2159     {
2160       /* Find the width of the bitstring in IMM.  */
2161       for (len = 5; len < HOST_BITS_PER_WIDE_INT; len++)
2162         {
2163           if ((imm & ((unsigned HOST_WIDE_INT) 1 << len)) == 0)
2164             break;
2165         }
2166
2167       /* Sign extend IMM as a 5-bit value.  */
2168       imm = (imm & 0xf) - 0x10;
2169     }
2170
2171   op[0] = imm;
2172   op[1] = 63 - lsb;
2173   op[2] = len;
2174 }
2175
2176 /* Output assembler code to perform a doubleword move insn
2177    with operands OPERANDS.  */
2178
2179 const char *
2180 output_move_double (rtx *operands)
2181 {
2182   enum { REGOP, OFFSOP, MEMOP, CNSTOP, RNDOP } optype0, optype1;
2183   rtx latehalf[2];
2184   rtx addreg0 = 0, addreg1 = 0;
2185
2186   /* First classify both operands.  */
2187
2188   if (REG_P (operands[0]))
2189     optype0 = REGOP;
2190   else if (offsettable_memref_p (operands[0]))
2191     optype0 = OFFSOP;
2192   else if (GET_CODE (operands[0]) == MEM)
2193     optype0 = MEMOP;
2194   else
2195     optype0 = RNDOP;
2196
2197   if (REG_P (operands[1]))
2198     optype1 = REGOP;
2199   else if (CONSTANT_P (operands[1]))
2200     optype1 = CNSTOP;
2201   else if (offsettable_memref_p (operands[1]))
2202     optype1 = OFFSOP;
2203   else if (GET_CODE (operands[1]) == MEM)
2204     optype1 = MEMOP;
2205   else
2206     optype1 = RNDOP;
2207
2208   /* Check for the cases that the operand constraints are not
2209      supposed to allow to happen.  */
2210   gcc_assert (optype0 == REGOP || optype1 == REGOP);
2211
2212    /* Handle auto decrementing and incrementing loads and stores
2213      specifically, since the structure of the function doesn't work
2214      for them without major modification.  Do it better when we learn
2215      this port about the general inc/dec addressing of PA.
2216      (This was written by tege.  Chide him if it doesn't work.)  */
2217
2218   if (optype0 == MEMOP)
2219     {
2220       /* We have to output the address syntax ourselves, since print_operand
2221          doesn't deal with the addresses we want to use.  Fix this later.  */
2222
2223       rtx addr = XEXP (operands[0], 0);
2224       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2225         {
2226           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2227
2228           operands[0] = XEXP (addr, 0);
2229           gcc_assert (GET_CODE (operands[1]) == REG
2230                       && GET_CODE (operands[0]) == REG);
2231
2232           gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
2233
2234           /* No overlap between high target register and address
2235              register.  (We do this in a non-obvious way to
2236              save a register file writeback)  */
2237           if (GET_CODE (addr) == POST_INC)
2238             return "{stws|stw},ma %1,8(%0)\n\tstw %R1,-4(%0)";
2239           return "{stws|stw},ma %1,-8(%0)\n\tstw %R1,12(%0)";
2240         }
2241       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2242         {
2243           rtx high_reg = gen_rtx_SUBREG (SImode, operands[1], 0);
2244
2245           operands[0] = XEXP (addr, 0);
2246           gcc_assert (GET_CODE (operands[1]) == REG
2247                       && GET_CODE (operands[0]) == REG);
2248
2249           gcc_assert (!reg_overlap_mentioned_p (high_reg, addr));
2250           /* No overlap between high target register and address
2251              register.  (We do this in a non-obvious way to save a
2252              register file writeback)  */
2253           if (GET_CODE (addr) == PRE_INC)
2254             return "{stws|stw},mb %1,8(%0)\n\tstw %R1,4(%0)";
2255           return "{stws|stw},mb %1,-8(%0)\n\tstw %R1,4(%0)";
2256         }
2257     }
2258   if (optype1 == MEMOP)
2259     {
2260       /* We have to output the address syntax ourselves, since print_operand
2261          doesn't deal with the addresses we want to use.  Fix this later.  */
2262
2263       rtx addr = XEXP (operands[1], 0);
2264       if (GET_CODE (addr) == POST_INC || GET_CODE (addr) == POST_DEC)
2265         {
2266           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2267
2268           operands[1] = XEXP (addr, 0);
2269           gcc_assert (GET_CODE (operands[0]) == REG
2270                       && GET_CODE (operands[1]) == REG);
2271
2272           if (!reg_overlap_mentioned_p (high_reg, addr))
2273             {
2274               /* No overlap between high target register and address
2275                  register.  (We do this in a non-obvious way to
2276                  save a register file writeback)  */
2277               if (GET_CODE (addr) == POST_INC)
2278                 return "{ldws|ldw},ma 8(%1),%0\n\tldw -4(%1),%R0";
2279               return "{ldws|ldw},ma -8(%1),%0\n\tldw 12(%1),%R0";
2280             }
2281           else
2282             {
2283               /* This is an undefined situation.  We should load into the
2284                  address register *and* update that register.  Probably
2285                  we don't need to handle this at all.  */
2286               if (GET_CODE (addr) == POST_INC)
2287                 return "ldw 4(%1),%R0\n\t{ldws|ldw},ma 8(%1),%0";
2288               return "ldw 4(%1),%R0\n\t{ldws|ldw},ma -8(%1),%0";
2289             }
2290         }
2291       else if (GET_CODE (addr) == PRE_INC || GET_CODE (addr) == PRE_DEC)
2292         {
2293           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2294
2295           operands[1] = XEXP (addr, 0);
2296           gcc_assert (GET_CODE (operands[0]) == REG
2297                       && GET_CODE (operands[1]) == REG);
2298
2299           if (!reg_overlap_mentioned_p (high_reg, addr))
2300             {
2301               /* No overlap between high target register and address
2302                  register.  (We do this in a non-obvious way to
2303                  save a register file writeback)  */
2304               if (GET_CODE (addr) == PRE_INC)
2305                 return "{ldws|ldw},mb 8(%1),%0\n\tldw 4(%1),%R0";
2306               return "{ldws|ldw},mb -8(%1),%0\n\tldw 4(%1),%R0";
2307             }
2308           else
2309             {
2310               /* This is an undefined situation.  We should load into the
2311                  address register *and* update that register.  Probably
2312                  we don't need to handle this at all.  */
2313               if (GET_CODE (addr) == PRE_INC)
2314                 return "ldw 12(%1),%R0\n\t{ldws|ldw},mb 8(%1),%0";
2315               return "ldw -4(%1),%R0\n\t{ldws|ldw},mb -8(%1),%0";
2316             }
2317         }
2318       else if (GET_CODE (addr) == PLUS
2319                && GET_CODE (XEXP (addr, 0)) == MULT)
2320         {
2321           rtx high_reg = gen_rtx_SUBREG (SImode, operands[0], 0);
2322
2323           if (!reg_overlap_mentioned_p (high_reg, addr))
2324             {
2325               rtx xoperands[3];
2326
2327               xoperands[0] = high_reg;
2328               xoperands[1] = XEXP (addr, 1);
2329               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2330               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2331               output_asm_insn ("{sh%O3addl %2,%1,%0|shladd,l %2,%O3,%1,%0}",
2332                                xoperands);
2333               return "ldw 4(%0),%R0\n\tldw 0(%0),%0";
2334             }
2335           else
2336             {
2337               rtx xoperands[3];
2338
2339               xoperands[0] = high_reg;
2340               xoperands[1] = XEXP (addr, 1);
2341               xoperands[2] = XEXP (XEXP (addr, 0), 0);
2342               xoperands[3] = XEXP (XEXP (addr, 0), 1);
2343               output_asm_insn ("{sh%O3addl %2,%1,%R0|shladd,l %2,%O3,%1,%R0}",
2344                                xoperands);
2345               return "ldw 0(%R0),%0\n\tldw 4(%R0),%R0";
2346             }
2347         }
2348     }
2349
2350   /* If an operand is an unoffsettable memory ref, find a register
2351      we can increment temporarily to make it refer to the second word.  */
2352
2353   if (optype0 == MEMOP)
2354     addreg0 = find_addr_reg (XEXP (operands[0], 0));
2355
2356   if (optype1 == MEMOP)
2357     addreg1 = find_addr_reg (XEXP (operands[1], 0));
2358
2359   /* Ok, we can do one word at a time.
2360      Normally we do the low-numbered word first.
2361
2362      In either case, set up in LATEHALF the operands to use
2363      for the high-numbered word and in some cases alter the
2364      operands in OPERANDS to be suitable for the low-numbered word.  */
2365
2366   if (optype0 == REGOP)
2367     latehalf[0] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2368   else if (optype0 == OFFSOP)
2369     latehalf[0] = adjust_address (operands[0], SImode, 4);
2370   else
2371     latehalf[0] = operands[0];
2372
2373   if (optype1 == REGOP)
2374     latehalf[1] = gen_rtx_REG (SImode, REGNO (operands[1]) + 1);
2375   else if (optype1 == OFFSOP)
2376     latehalf[1] = adjust_address (operands[1], SImode, 4);
2377   else if (optype1 == CNSTOP)
2378     split_double (operands[1], &operands[1], &latehalf[1]);
2379   else
2380     latehalf[1] = operands[1];
2381
2382   /* If the first move would clobber the source of the second one,
2383      do them in the other order.
2384
2385      This can happen in two cases:
2386
2387         mem -> register where the first half of the destination register
2388         is the same register used in the memory's address.  Reload
2389         can create such insns.
2390
2391         mem in this case will be either register indirect or register
2392         indirect plus a valid offset.
2393
2394         register -> register move where REGNO(dst) == REGNO(src + 1)
2395         someone (Tim/Tege?) claimed this can happen for parameter loads.
2396
2397      Handle mem -> register case first.  */
2398   if (optype0 == REGOP
2399       && (optype1 == MEMOP || optype1 == OFFSOP)
2400       && refers_to_regno_p (REGNO (operands[0]), REGNO (operands[0]) + 1,
2401                             operands[1], 0))
2402     {
2403       /* Do the late half first.  */
2404       if (addreg1)
2405         output_asm_insn ("ldo 4(%0),%0", &addreg1);
2406       output_asm_insn (singlemove_string (latehalf), latehalf);
2407
2408       /* Then clobber.  */
2409       if (addreg1)
2410         output_asm_insn ("ldo -4(%0),%0", &addreg1);
2411       return singlemove_string (operands);
2412     }
2413
2414   /* Now handle register -> register case.  */
2415   if (optype0 == REGOP && optype1 == REGOP
2416       && REGNO (operands[0]) == REGNO (operands[1]) + 1)
2417     {
2418       output_asm_insn (singlemove_string (latehalf), latehalf);
2419       return singlemove_string (operands);
2420     }
2421
2422   /* Normal case: do the two words, low-numbered first.  */
2423
2424   output_asm_insn (singlemove_string (operands), operands);
2425
2426   /* Make any unoffsettable addresses point at high-numbered word.  */
2427   if (addreg0)
2428     output_asm_insn ("ldo 4(%0),%0", &addreg0);
2429   if (addreg1)
2430     output_asm_insn ("ldo 4(%0),%0", &addreg1);
2431
2432   /* Do that word.  */
2433   output_asm_insn (singlemove_string (latehalf), latehalf);
2434
2435   /* Undo the adds we just did.  */
2436   if (addreg0)
2437     output_asm_insn ("ldo -4(%0),%0", &addreg0);
2438   if (addreg1)
2439     output_asm_insn ("ldo -4(%0),%0", &addreg1);
2440
2441   return "";
2442 }
2443 \f
2444 const char *
2445 output_fp_move_double (rtx *operands)
2446 {
2447   if (FP_REG_P (operands[0]))
2448     {
2449       if (FP_REG_P (operands[1])
2450           || operands[1] == CONST0_RTX (GET_MODE (operands[0])))
2451         output_asm_insn ("fcpy,dbl %f1,%0", operands);
2452       else
2453         output_asm_insn ("fldd%F1 %1,%0", operands);
2454     }
2455   else if (FP_REG_P (operands[1]))
2456     {
2457       output_asm_insn ("fstd%F0 %1,%0", operands);
2458     }
2459   else
2460     {
2461       rtx xoperands[2];
2462
2463       gcc_assert (operands[1] == CONST0_RTX (GET_MODE (operands[0])));
2464
2465       /* This is a pain.  You have to be prepared to deal with an
2466          arbitrary address here including pre/post increment/decrement.
2467
2468          so avoid this in the MD.  */
2469       gcc_assert (GET_CODE (operands[0]) == REG);
2470
2471       xoperands[1] = gen_rtx_REG (SImode, REGNO (operands[0]) + 1);
2472       xoperands[0] = operands[0];
2473       output_asm_insn ("copy %%r0,%0\n\tcopy %%r0,%1", xoperands);
2474     }
2475   return "";
2476 }
2477 \f
2478 /* Return a REG that occurs in ADDR with coefficient 1.
2479    ADDR can be effectively incremented by incrementing REG.  */
2480
2481 static rtx
2482 find_addr_reg (rtx addr)
2483 {
2484   while (GET_CODE (addr) == PLUS)
2485     {
2486       if (GET_CODE (XEXP (addr, 0)) == REG)
2487         addr = XEXP (addr, 0);
2488       else if (GET_CODE (XEXP (addr, 1)) == REG)
2489         addr = XEXP (addr, 1);
2490       else if (CONSTANT_P (XEXP (addr, 0)))
2491         addr = XEXP (addr, 1);
2492       else if (CONSTANT_P (XEXP (addr, 1)))
2493         addr = XEXP (addr, 0);
2494       else
2495         gcc_unreachable ();
2496     }
2497   gcc_assert (GET_CODE (addr) == REG);
2498   return addr;
2499 }
2500
2501 /* Emit code to perform a block move.
2502
2503    OPERANDS[0] is the destination pointer as a REG, clobbered.
2504    OPERANDS[1] is the source pointer as a REG, clobbered.
2505    OPERANDS[2] is a register for temporary storage.
2506    OPERANDS[3] is a register for temporary storage.
2507    OPERANDS[4] is the size as a CONST_INT
2508    OPERANDS[5] is the alignment safe to use, as a CONST_INT.
2509    OPERANDS[6] is another temporary register.  */
2510
2511 const char *
2512 output_block_move (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2513 {
2514   int align = INTVAL (operands[5]);
2515   unsigned long n_bytes = INTVAL (operands[4]);
2516
2517   /* We can't move more than a word at a time because the PA
2518      has no longer integer move insns.  (Could use fp mem ops?)  */
2519   if (align > (TARGET_64BIT ? 8 : 4))
2520     align = (TARGET_64BIT ? 8 : 4);
2521
2522   /* Note that we know each loop below will execute at least twice
2523      (else we would have open-coded the copy).  */
2524   switch (align)
2525     {
2526       case 8:
2527         /* Pre-adjust the loop counter.  */
2528         operands[4] = GEN_INT (n_bytes - 16);
2529         output_asm_insn ("ldi %4,%2", operands);
2530
2531         /* Copying loop.  */
2532         output_asm_insn ("ldd,ma 8(%1),%3", operands);
2533         output_asm_insn ("ldd,ma 8(%1),%6", operands);
2534         output_asm_insn ("std,ma %3,8(%0)", operands);
2535         output_asm_insn ("addib,>= -16,%2,.-12", operands);
2536         output_asm_insn ("std,ma %6,8(%0)", operands);
2537
2538         /* Handle the residual.  There could be up to 7 bytes of
2539            residual to copy!  */
2540         if (n_bytes % 16 != 0)
2541           {
2542             operands[4] = GEN_INT (n_bytes % 8);
2543             if (n_bytes % 16 >= 8)
2544               output_asm_insn ("ldd,ma 8(%1),%3", operands);
2545             if (n_bytes % 8 != 0)
2546               output_asm_insn ("ldd 0(%1),%6", operands);
2547             if (n_bytes % 16 >= 8)
2548               output_asm_insn ("std,ma %3,8(%0)", operands);
2549             if (n_bytes % 8 != 0)
2550               output_asm_insn ("stdby,e %6,%4(%0)", operands);
2551           }
2552         return "";
2553
2554       case 4:
2555         /* Pre-adjust the loop counter.  */
2556         operands[4] = GEN_INT (n_bytes - 8);
2557         output_asm_insn ("ldi %4,%2", operands);
2558
2559         /* Copying loop.  */
2560         output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2561         output_asm_insn ("{ldws|ldw},ma 4(%1),%6", operands);
2562         output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2563         output_asm_insn ("addib,>= -8,%2,.-12", operands);
2564         output_asm_insn ("{stws|stw},ma %6,4(%0)", operands);
2565
2566         /* Handle the residual.  There could be up to 7 bytes of
2567            residual to copy!  */
2568         if (n_bytes % 8 != 0)
2569           {
2570             operands[4] = GEN_INT (n_bytes % 4);
2571             if (n_bytes % 8 >= 4)
2572               output_asm_insn ("{ldws|ldw},ma 4(%1),%3", operands);
2573             if (n_bytes % 4 != 0)
2574               output_asm_insn ("ldw 0(%1),%6", operands);
2575             if (n_bytes % 8 >= 4)
2576               output_asm_insn ("{stws|stw},ma %3,4(%0)", operands);
2577             if (n_bytes % 4 != 0)
2578               output_asm_insn ("{stbys|stby},e %6,%4(%0)", operands);
2579           }
2580         return "";
2581
2582       case 2:
2583         /* Pre-adjust the loop counter.  */
2584         operands[4] = GEN_INT (n_bytes - 4);
2585         output_asm_insn ("ldi %4,%2", operands);
2586
2587         /* Copying loop.  */
2588         output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2589         output_asm_insn ("{ldhs|ldh},ma 2(%1),%6", operands);
2590         output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2591         output_asm_insn ("addib,>= -4,%2,.-12", operands);
2592         output_asm_insn ("{sths|sth},ma %6,2(%0)", operands);
2593
2594         /* Handle the residual.  */
2595         if (n_bytes % 4 != 0)
2596           {
2597             if (n_bytes % 4 >= 2)
2598               output_asm_insn ("{ldhs|ldh},ma 2(%1),%3", operands);
2599             if (n_bytes % 2 != 0)
2600               output_asm_insn ("ldb 0(%1),%6", operands);
2601             if (n_bytes % 4 >= 2)
2602               output_asm_insn ("{sths|sth},ma %3,2(%0)", operands);
2603             if (n_bytes % 2 != 0)
2604               output_asm_insn ("stb %6,0(%0)", operands);
2605           }
2606         return "";
2607
2608       case 1:
2609         /* Pre-adjust the loop counter.  */
2610         operands[4] = GEN_INT (n_bytes - 2);
2611         output_asm_insn ("ldi %4,%2", operands);
2612
2613         /* Copying loop.  */
2614         output_asm_insn ("{ldbs|ldb},ma 1(%1),%3", operands);
2615         output_asm_insn ("{ldbs|ldb},ma 1(%1),%6", operands);
2616         output_asm_insn ("{stbs|stb},ma %3,1(%0)", operands);
2617         output_asm_insn ("addib,>= -2,%2,.-12", operands);
2618         output_asm_insn ("{stbs|stb},ma %6,1(%0)", operands);
2619
2620         /* Handle the residual.  */
2621         if (n_bytes % 2 != 0)
2622           {
2623             output_asm_insn ("ldb 0(%1),%3", operands);
2624             output_asm_insn ("stb %3,0(%0)", operands);
2625           }
2626         return "";
2627
2628       default:
2629         gcc_unreachable ();
2630     }
2631 }
2632
2633 /* Count the number of insns necessary to handle this block move.
2634
2635    Basic structure is the same as emit_block_move, except that we
2636    count insns rather than emit them.  */
2637
2638 static int
2639 compute_movmem_length (rtx insn)
2640 {
2641   rtx pat = PATTERN (insn);
2642   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 7), 0));
2643   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 6), 0));
2644   unsigned int n_insns = 0;
2645
2646   /* We can't move more than four bytes at a time because the PA
2647      has no longer integer move insns.  (Could use fp mem ops?)  */
2648   if (align > (TARGET_64BIT ? 8 : 4))
2649     align = (TARGET_64BIT ? 8 : 4);
2650
2651   /* The basic copying loop.  */
2652   n_insns = 6;
2653
2654   /* Residuals.  */
2655   if (n_bytes % (2 * align) != 0)
2656     {
2657       if ((n_bytes % (2 * align)) >= align)
2658         n_insns += 2;
2659
2660       if ((n_bytes % align) != 0)
2661         n_insns += 2;
2662     }
2663
2664   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2665   return n_insns * 4;
2666 }
2667
2668 /* Emit code to perform a block clear.
2669
2670    OPERANDS[0] is the destination pointer as a REG, clobbered.
2671    OPERANDS[1] is a register for temporary storage.
2672    OPERANDS[2] is the size as a CONST_INT
2673    OPERANDS[3] is the alignment safe to use, as a CONST_INT.  */
2674
2675 const char *
2676 output_block_clear (rtx *operands, int size_is_constant ATTRIBUTE_UNUSED)
2677 {
2678   int align = INTVAL (operands[3]);
2679   unsigned long n_bytes = INTVAL (operands[2]);
2680
2681   /* We can't clear more than a word at a time because the PA
2682      has no longer integer move insns.  */
2683   if (align > (TARGET_64BIT ? 8 : 4))
2684     align = (TARGET_64BIT ? 8 : 4);
2685
2686   /* Note that we know each loop below will execute at least twice
2687      (else we would have open-coded the copy).  */
2688   switch (align)
2689     {
2690       case 8:
2691         /* Pre-adjust the loop counter.  */
2692         operands[2] = GEN_INT (n_bytes - 16);
2693         output_asm_insn ("ldi %2,%1", operands);
2694
2695         /* Loop.  */
2696         output_asm_insn ("std,ma %%r0,8(%0)", operands);
2697         output_asm_insn ("addib,>= -16,%1,.-4", operands);
2698         output_asm_insn ("std,ma %%r0,8(%0)", operands);
2699
2700         /* Handle the residual.  There could be up to 7 bytes of
2701            residual to copy!  */
2702         if (n_bytes % 16 != 0)
2703           {
2704             operands[2] = GEN_INT (n_bytes % 8);
2705             if (n_bytes % 16 >= 8)
2706               output_asm_insn ("std,ma %%r0,8(%0)", operands);
2707             if (n_bytes % 8 != 0)
2708               output_asm_insn ("stdby,e %%r0,%2(%0)", operands);
2709           }
2710         return "";
2711
2712       case 4:
2713         /* Pre-adjust the loop counter.  */
2714         operands[2] = GEN_INT (n_bytes - 8);
2715         output_asm_insn ("ldi %2,%1", operands);
2716
2717         /* Loop.  */
2718         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2719         output_asm_insn ("addib,>= -8,%1,.-4", operands);
2720         output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2721
2722         /* Handle the residual.  There could be up to 7 bytes of
2723            residual to copy!  */
2724         if (n_bytes % 8 != 0)
2725           {
2726             operands[2] = GEN_INT (n_bytes % 4);
2727             if (n_bytes % 8 >= 4)
2728               output_asm_insn ("{stws|stw},ma %%r0,4(%0)", operands);
2729             if (n_bytes % 4 != 0)
2730               output_asm_insn ("{stbys|stby},e %%r0,%2(%0)", operands);
2731           }
2732         return "";
2733
2734       case 2:
2735         /* Pre-adjust the loop counter.  */
2736         operands[2] = GEN_INT (n_bytes - 4);
2737         output_asm_insn ("ldi %2,%1", operands);
2738
2739         /* Loop.  */
2740         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2741         output_asm_insn ("addib,>= -4,%1,.-4", operands);
2742         output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2743
2744         /* Handle the residual.  */
2745         if (n_bytes % 4 != 0)
2746           {
2747             if (n_bytes % 4 >= 2)
2748               output_asm_insn ("{sths|sth},ma %%r0,2(%0)", operands);
2749             if (n_bytes % 2 != 0)
2750               output_asm_insn ("stb %%r0,0(%0)", operands);
2751           }
2752         return "";
2753
2754       case 1:
2755         /* Pre-adjust the loop counter.  */
2756         operands[2] = GEN_INT (n_bytes - 2);
2757         output_asm_insn ("ldi %2,%1", operands);
2758
2759         /* Loop.  */
2760         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
2761         output_asm_insn ("addib,>= -2,%1,.-4", operands);
2762         output_asm_insn ("{stbs|stb},ma %%r0,1(%0)", operands);
2763
2764         /* Handle the residual.  */
2765         if (n_bytes % 2 != 0)
2766           output_asm_insn ("stb %%r0,0(%0)", operands);
2767
2768         return "";
2769
2770       default:
2771         gcc_unreachable ();
2772     }
2773 }
2774
2775 /* Count the number of insns necessary to handle this block move.
2776
2777    Basic structure is the same as emit_block_move, except that we
2778    count insns rather than emit them.  */
2779
2780 static int
2781 compute_clrmem_length (rtx insn)
2782 {
2783   rtx pat = PATTERN (insn);
2784   unsigned int align = INTVAL (XEXP (XVECEXP (pat, 0, 4), 0));
2785   unsigned long n_bytes = INTVAL (XEXP (XVECEXP (pat, 0, 3), 0));
2786   unsigned int n_insns = 0;
2787
2788   /* We can't clear more than a word at a time because the PA
2789      has no longer integer move insns.  */
2790   if (align > (TARGET_64BIT ? 8 : 4))
2791     align = (TARGET_64BIT ? 8 : 4);
2792
2793   /* The basic loop.  */
2794   n_insns = 4;
2795
2796   /* Residuals.  */
2797   if (n_bytes % (2 * align) != 0)
2798     {
2799       if ((n_bytes % (2 * align)) >= align)
2800         n_insns++;
2801
2802       if ((n_bytes % align) != 0)
2803         n_insns++;
2804     }
2805
2806   /* Lengths are expressed in bytes now; each insn is 4 bytes.  */
2807   return n_insns * 4;
2808 }
2809 \f
2810
2811 const char *
2812 output_and (rtx *operands)
2813 {
2814   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
2815     {
2816       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2817       int ls0, ls1, ms0, p, len;
2818
2819       for (ls0 = 0; ls0 < 32; ls0++)
2820         if ((mask & (1 << ls0)) == 0)
2821           break;
2822
2823       for (ls1 = ls0; ls1 < 32; ls1++)
2824         if ((mask & (1 << ls1)) != 0)
2825           break;
2826
2827       for (ms0 = ls1; ms0 < 32; ms0++)
2828         if ((mask & (1 << ms0)) == 0)
2829           break;
2830
2831       gcc_assert (ms0 == 32);
2832
2833       if (ls1 == 32)
2834         {
2835           len = ls0;
2836
2837           gcc_assert (len);
2838
2839           operands[2] = GEN_INT (len);
2840           return "{extru|extrw,u} %1,31,%2,%0";
2841         }
2842       else
2843         {
2844           /* We could use this `depi' for the case above as well, but `depi'
2845              requires one more register file access than an `extru'.  */
2846
2847           p = 31 - ls0;
2848           len = ls1 - ls0;
2849
2850           operands[2] = GEN_INT (p);
2851           operands[3] = GEN_INT (len);
2852           return "{depi|depwi} 0,%2,%3,%0";
2853         }
2854     }
2855   else
2856     return "and %1,%2,%0";
2857 }
2858
2859 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
2860    storing the result in operands[0].  */
2861 const char *
2862 output_64bit_and (rtx *operands)
2863 {
2864   if (GET_CODE (operands[2]) == CONST_INT && INTVAL (operands[2]) != 0)
2865     {
2866       unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2867       int ls0, ls1, ms0, p, len;
2868
2869       for (ls0 = 0; ls0 < HOST_BITS_PER_WIDE_INT; ls0++)
2870         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls0)) == 0)
2871           break;
2872
2873       for (ls1 = ls0; ls1 < HOST_BITS_PER_WIDE_INT; ls1++)
2874         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ls1)) != 0)
2875           break;
2876
2877       for (ms0 = ls1; ms0 < HOST_BITS_PER_WIDE_INT; ms0++)
2878         if ((mask & ((unsigned HOST_WIDE_INT) 1 << ms0)) == 0)
2879           break;
2880
2881       gcc_assert (ms0 == HOST_BITS_PER_WIDE_INT);
2882
2883       if (ls1 == HOST_BITS_PER_WIDE_INT)
2884         {
2885           len = ls0;
2886
2887           gcc_assert (len);
2888
2889           operands[2] = GEN_INT (len);
2890           return "extrd,u %1,63,%2,%0";
2891         }
2892       else
2893         {
2894           /* We could use this `depi' for the case above as well, but `depi'
2895              requires one more register file access than an `extru'.  */
2896
2897           p = 63 - ls0;
2898           len = ls1 - ls0;
2899
2900           operands[2] = GEN_INT (p);
2901           operands[3] = GEN_INT (len);
2902           return "depdi 0,%2,%3,%0";
2903         }
2904     }
2905   else
2906     return "and %1,%2,%0";
2907 }
2908
2909 const char *
2910 output_ior (rtx *operands)
2911 {
2912   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2913   int bs0, bs1, p, len;
2914
2915   if (INTVAL (operands[2]) == 0)
2916     return "copy %1,%0";
2917
2918   for (bs0 = 0; bs0 < 32; bs0++)
2919     if ((mask & (1 << bs0)) != 0)
2920       break;
2921
2922   for (bs1 = bs0; bs1 < 32; bs1++)
2923     if ((mask & (1 << bs1)) == 0)
2924       break;
2925
2926   gcc_assert (bs1 == 32 || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
2927
2928   p = 31 - bs0;
2929   len = bs1 - bs0;
2930
2931   operands[2] = GEN_INT (p);
2932   operands[3] = GEN_INT (len);
2933   return "{depi|depwi} -1,%2,%3,%0";
2934 }
2935
2936 /* Return a string to perform a bitwise-and of operands[1] with operands[2]
2937    storing the result in operands[0].  */
2938 const char *
2939 output_64bit_ior (rtx *operands)
2940 {
2941   unsigned HOST_WIDE_INT mask = INTVAL (operands[2]);
2942   int bs0, bs1, p, len;
2943
2944   if (INTVAL (operands[2]) == 0)
2945     return "copy %1,%0";
2946
2947   for (bs0 = 0; bs0 < HOST_BITS_PER_WIDE_INT; bs0++)
2948     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs0)) != 0)
2949       break;
2950
2951   for (bs1 = bs0; bs1 < HOST_BITS_PER_WIDE_INT; bs1++)
2952     if ((mask & ((unsigned HOST_WIDE_INT) 1 << bs1)) == 0)
2953       break;
2954
2955   gcc_assert (bs1 == HOST_BITS_PER_WIDE_INT
2956               || ((unsigned HOST_WIDE_INT) 1 << bs1) > mask);
2957
2958   p = 63 - bs0;
2959   len = bs1 - bs0;
2960
2961   operands[2] = GEN_INT (p);
2962   operands[3] = GEN_INT (len);
2963   return "depdi -1,%2,%3,%0";
2964 }
2965 \f
2966 /* Target hook for assembling integer objects.  This code handles
2967    aligned SI and DI integers specially since function references
2968    must be preceded by P%.  */
2969
2970 static bool
2971 pa_assemble_integer (rtx x, unsigned int size, int aligned_p)
2972 {
2973   if (size == UNITS_PER_WORD
2974       && aligned_p
2975       && function_label_operand (x, VOIDmode))
2976     {
2977       fputs (size == 8? "\t.dword\tP%" : "\t.word\tP%", asm_out_file);
2978       output_addr_const (asm_out_file, x);
2979       fputc ('\n', asm_out_file);
2980       return true;
2981     }
2982   return default_assemble_integer (x, size, aligned_p);
2983 }
2984 \f
2985 /* Output an ascii string.  */
2986 void
2987 output_ascii (FILE *file, const char *p, int size)
2988 {
2989   int i;
2990   int chars_output;
2991   unsigned char partial_output[16];     /* Max space 4 chars can occupy.  */
2992
2993   /* The HP assembler can only take strings of 256 characters at one
2994      time.  This is a limitation on input line length, *not* the
2995      length of the string.  Sigh.  Even worse, it seems that the
2996      restriction is in number of input characters (see \xnn &
2997      \whatever).  So we have to do this very carefully.  */
2998
2999   fputs ("\t.STRING \"", file);
3000
3001   chars_output = 0;
3002   for (i = 0; i < size; i += 4)
3003     {
3004       int co = 0;
3005       int io = 0;
3006       for (io = 0, co = 0; io < MIN (4, size - i); io++)
3007         {
3008           register unsigned int c = (unsigned char) p[i + io];
3009
3010           if (c == '\"' || c == '\\')
3011             partial_output[co++] = '\\';
3012           if (c >= ' ' && c < 0177)
3013             partial_output[co++] = c;
3014           else
3015             {
3016               unsigned int hexd;
3017               partial_output[co++] = '\\';
3018               partial_output[co++] = 'x';
3019               hexd =  c  / 16 - 0 + '0';
3020               if (hexd > '9')
3021                 hexd -= '9' - 'a' + 1;
3022               partial_output[co++] = hexd;
3023               hexd =  c % 16 - 0 + '0';
3024               if (hexd > '9')
3025                 hexd -= '9' - 'a' + 1;
3026               partial_output[co++] = hexd;
3027             }
3028         }
3029       if (chars_output + co > 243)
3030         {
3031           fputs ("\"\n\t.STRING \"", file);
3032           chars_output = 0;
3033         }
3034       fwrite (partial_output, 1, (size_t) co, file);
3035       chars_output += co;
3036       co = 0;
3037     }
3038   fputs ("\"\n", file);
3039 }
3040
3041 /* Try to rewrite floating point comparisons & branches to avoid
3042    useless add,tr insns.
3043
3044    CHECK_NOTES is nonzero if we should examine REG_DEAD notes
3045    to see if FPCC is dead.  CHECK_NOTES is nonzero for the
3046    first attempt to remove useless add,tr insns.  It is zero
3047    for the second pass as reorg sometimes leaves bogus REG_DEAD
3048    notes lying around.
3049
3050    When CHECK_NOTES is zero we can only eliminate add,tr insns
3051    when there's a 1:1 correspondence between fcmp and ftest/fbranch
3052    instructions.  */
3053 static void
3054 remove_useless_addtr_insns (int check_notes)
3055 {
3056   rtx insn;
3057   static int pass = 0;
3058
3059   /* This is fairly cheap, so always run it when optimizing.  */
3060   if (optimize > 0)
3061     {
3062       int fcmp_count = 0;
3063       int fbranch_count = 0;
3064
3065       /* Walk all the insns in this function looking for fcmp & fbranch
3066          instructions.  Keep track of how many of each we find.  */
3067       for (insn = get_insns (); insn; insn = next_insn (insn))
3068         {
3069           rtx tmp;
3070
3071           /* Ignore anything that isn't an INSN or a JUMP_INSN.  */
3072           if (GET_CODE (insn) != INSN && GET_CODE (insn) != JUMP_INSN)
3073             continue;
3074
3075           tmp = PATTERN (insn);
3076
3077           /* It must be a set.  */
3078           if (GET_CODE (tmp) != SET)
3079             continue;
3080
3081           /* If the destination is CCFP, then we've found an fcmp insn.  */
3082           tmp = SET_DEST (tmp);
3083           if (GET_CODE (tmp) == REG && REGNO (tmp) == 0)
3084             {
3085               fcmp_count++;
3086               continue;
3087             }
3088
3089           tmp = PATTERN (insn);
3090           /* If this is an fbranch instruction, bump the fbranch counter.  */
3091           if (GET_CODE (tmp) == SET
3092               && SET_DEST (tmp) == pc_rtx
3093               && GET_CODE (SET_SRC (tmp)) == IF_THEN_ELSE
3094               && GET_CODE (XEXP (SET_SRC (tmp), 0)) == NE
3095               && GET_CODE (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == REG
3096               && REGNO (XEXP (XEXP (SET_SRC (tmp), 0), 0)) == 0)
3097             {
3098               fbranch_count++;
3099               continue;
3100             }
3101         }
3102
3103
3104       /* Find all floating point compare + branch insns.  If possible,
3105          reverse the comparison & the branch to avoid add,tr insns.  */
3106       for (insn = get_insns (); insn; insn = next_insn (insn))
3107         {
3108           rtx tmp, next;
3109
3110           /* Ignore anything that isn't an INSN.  */
3111           if (GET_CODE (insn) != INSN)
3112             continue;
3113
3114           tmp = PATTERN (insn);
3115
3116           /* It must be a set.  */
3117           if (GET_CODE (tmp) != SET)
3118             continue;
3119
3120           /* The destination must be CCFP, which is register zero.  */
3121           tmp = SET_DEST (tmp);
3122           if (GET_CODE (tmp) != REG || REGNO (tmp) != 0)
3123             continue;
3124
3125           /* INSN should be a set of CCFP.
3126
3127              See if the result of this insn is used in a reversed FP
3128              conditional branch.  If so, reverse our condition and
3129              the branch.  Doing so avoids useless add,tr insns.  */
3130           next = next_insn (insn);
3131           while (next)
3132             {
3133               /* Jumps, calls and labels stop our search.  */
3134               if (GET_CODE (next) == JUMP_INSN
3135                   || GET_CODE (next) == CALL_INSN
3136                   || GET_CODE (next) == CODE_LABEL)
3137                 break;
3138
3139               /* As does another fcmp insn.  */
3140               if (GET_CODE (next) == INSN
3141                   && GET_CODE (PATTERN (next)) == SET
3142                   && GET_CODE (SET_DEST (PATTERN (next))) == REG
3143                   && REGNO (SET_DEST (PATTERN (next))) == 0)
3144                 break;
3145
3146               next = next_insn (next);
3147             }
3148
3149           /* Is NEXT_INSN a branch?  */
3150           if (next
3151               && GET_CODE (next) == JUMP_INSN)
3152             {
3153               rtx pattern = PATTERN (next);
3154
3155               /* If it a reversed fp conditional branch (e.g. uses add,tr)
3156                  and CCFP dies, then reverse our conditional and the branch
3157                  to avoid the add,tr.  */
3158               if (GET_CODE (pattern) == SET
3159                   && SET_DEST (pattern) == pc_rtx
3160                   && GET_CODE (SET_SRC (pattern)) == IF_THEN_ELSE
3161                   && GET_CODE (XEXP (SET_SRC (pattern), 0)) == NE
3162                   && GET_CODE (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == REG
3163                   && REGNO (XEXP (XEXP (SET_SRC (pattern), 0), 0)) == 0
3164                   && GET_CODE (XEXP (SET_SRC (pattern), 1)) == PC
3165                   && (fcmp_count == fbranch_count
3166                       || (check_notes
3167                           && find_regno_note (next, REG_DEAD, 0))))
3168                 {
3169                   /* Reverse the branch.  */
3170                   tmp = XEXP (SET_SRC (pattern), 1);
3171                   XEXP (SET_SRC (pattern), 1) = XEXP (SET_SRC (pattern), 2);
3172                   XEXP (SET_SRC (pattern), 2) = tmp;
3173                   INSN_CODE (next) = -1;
3174
3175                   /* Reverse our condition.  */
3176                   tmp = PATTERN (insn);
3177                   PUT_CODE (XEXP (tmp, 1),
3178                             (reverse_condition_maybe_unordered
3179                              (GET_CODE (XEXP (tmp, 1)))));
3180                 }
3181             }
3182         }
3183     }
3184
3185   pass = !pass;
3186
3187 }
3188 \f
3189 /* You may have trouble believing this, but this is the 32 bit HP-PA
3190    stack layout.  Wow.
3191
3192    Offset               Contents
3193
3194    Variable arguments   (optional; any number may be allocated)
3195
3196    SP-(4*(N+9))         arg word N
3197         :                   :
3198       SP-56             arg word 5
3199       SP-52             arg word 4
3200
3201    Fixed arguments      (must be allocated; may remain unused)
3202
3203       SP-48             arg word 3
3204       SP-44             arg word 2
3205       SP-40             arg word 1
3206       SP-36             arg word 0
3207
3208    Frame Marker
3209
3210       SP-32             External Data Pointer (DP)
3211       SP-28             External sr4
3212       SP-24             External/stub RP (RP')
3213       SP-20             Current RP
3214       SP-16             Static Link
3215       SP-12             Clean up
3216       SP-8              Calling Stub RP (RP'')
3217       SP-4              Previous SP
3218
3219    Top of Frame
3220
3221       SP-0              Stack Pointer (points to next available address)
3222
3223 */
3224
3225 /* This function saves registers as follows.  Registers marked with ' are
3226    this function's registers (as opposed to the previous function's).
3227    If a frame_pointer isn't needed, r4 is saved as a general register;
3228    the space for the frame pointer is still allocated, though, to keep
3229    things simple.
3230
3231
3232    Top of Frame
3233
3234        SP (FP')         Previous FP
3235        SP + 4           Alignment filler (sigh)
3236        SP + 8           Space for locals reserved here.
3237        .
3238        .
3239        .
3240        SP + n           All call saved register used.
3241        .
3242        .
3243        .
3244        SP + o           All call saved fp registers used.
3245        .
3246        .
3247        .
3248        SP + p (SP')     points to next available address.
3249
3250 */
3251
3252 /* Global variables set by output_function_prologue().  */
3253 /* Size of frame.  Need to know this to emit return insns from
3254    leaf procedures.  */
3255 static HOST_WIDE_INT actual_fsize, local_fsize;
3256 static int save_fregs;
3257
3258 /* Emit RTL to store REG at the memory location specified by BASE+DISP.
3259    Handle case where DISP > 8k by using the add_high_const patterns.
3260
3261    Note in DISP > 8k case, we will leave the high part of the address
3262    in %r1.  There is code in expand_hppa_{prologue,epilogue} that knows this.*/
3263
3264 static void
3265 store_reg (int reg, HOST_WIDE_INT disp, int base)
3266 {
3267   rtx insn, dest, src, basereg;
3268
3269   src = gen_rtx_REG (word_mode, reg);
3270   basereg = gen_rtx_REG (Pmode, base);
3271   if (VAL_14_BITS_P (disp))
3272     {
3273       dest = gen_rtx_MEM (word_mode, plus_constant (basereg, disp));
3274       insn = emit_move_insn (dest, src);
3275     }
3276   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3277     {
3278       rtx delta = GEN_INT (disp);
3279       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3280
3281       emit_move_insn (tmpreg, delta);
3282       insn = emit_move_insn (tmpreg, gen_rtx_PLUS (Pmode, tmpreg, basereg));
3283       if (DO_FRAME_NOTES)
3284         {
3285           REG_NOTES (insn)
3286             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3287                 gen_rtx_SET (VOIDmode, tmpreg,
3288                              gen_rtx_PLUS (Pmode, basereg, delta)),
3289                 REG_NOTES (insn));
3290           RTX_FRAME_RELATED_P (insn) = 1;
3291         }
3292       dest = gen_rtx_MEM (word_mode, tmpreg);
3293       insn = emit_move_insn (dest, src);
3294     }
3295   else
3296     {
3297       rtx delta = GEN_INT (disp);
3298       rtx high = gen_rtx_PLUS (Pmode, basereg, gen_rtx_HIGH (Pmode, delta));
3299       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3300
3301       emit_move_insn (tmpreg, high);
3302       dest = gen_rtx_MEM (word_mode, gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3303       insn = emit_move_insn (dest, src);
3304       if (DO_FRAME_NOTES)
3305         {
3306           REG_NOTES (insn)
3307             = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3308                 gen_rtx_SET (VOIDmode,
3309                              gen_rtx_MEM (word_mode,
3310                                           gen_rtx_PLUS (word_mode, basereg,
3311                                                         delta)),
3312                              src),
3313                 REG_NOTES (insn));
3314         }
3315     }
3316
3317   if (DO_FRAME_NOTES)
3318     RTX_FRAME_RELATED_P (insn) = 1;
3319 }
3320
3321 /* Emit RTL to store REG at the memory location specified by BASE and then
3322    add MOD to BASE.  MOD must be <= 8k.  */
3323
3324 static void
3325 store_reg_modify (int base, int reg, HOST_WIDE_INT mod)
3326 {
3327   rtx insn, basereg, srcreg, delta;
3328
3329   gcc_assert (VAL_14_BITS_P (mod));
3330
3331   basereg = gen_rtx_REG (Pmode, base);
3332   srcreg = gen_rtx_REG (word_mode, reg);
3333   delta = GEN_INT (mod);
3334
3335   insn = emit_insn (gen_post_store (basereg, srcreg, delta));
3336   if (DO_FRAME_NOTES)
3337     {
3338       RTX_FRAME_RELATED_P (insn) = 1;
3339
3340       /* RTX_FRAME_RELATED_P must be set on each frame related set
3341          in a parallel with more than one element.  */
3342       RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 0)) = 1;
3343       RTX_FRAME_RELATED_P (XVECEXP (PATTERN (insn), 0, 1)) = 1;
3344     }
3345 }
3346
3347 /* Emit RTL to set REG to the value specified by BASE+DISP.  Handle case
3348    where DISP > 8k by using the add_high_const patterns.  NOTE indicates
3349    whether to add a frame note or not.
3350
3351    In the DISP > 8k case, we leave the high part of the address in %r1.
3352    There is code in expand_hppa_{prologue,epilogue} that knows about this.  */
3353
3354 static void
3355 set_reg_plus_d (int reg, int base, HOST_WIDE_INT disp, int note)
3356 {
3357   rtx insn;
3358
3359   if (VAL_14_BITS_P (disp))
3360     {
3361       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3362                              plus_constant (gen_rtx_REG (Pmode, base), disp));
3363     }
3364   else if (TARGET_64BIT && !VAL_32_BITS_P (disp))
3365     {
3366       rtx basereg = gen_rtx_REG (Pmode, base);
3367       rtx delta = GEN_INT (disp);
3368       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3369
3370       emit_move_insn (tmpreg, delta);
3371       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3372                              gen_rtx_PLUS (Pmode, tmpreg, basereg));
3373       if (DO_FRAME_NOTES)
3374         REG_NOTES (insn)
3375           = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR,
3376               gen_rtx_SET (VOIDmode, tmpreg,
3377                            gen_rtx_PLUS (Pmode, basereg, delta)),
3378               REG_NOTES (insn));
3379     }
3380   else
3381     {
3382       rtx basereg = gen_rtx_REG (Pmode, base);
3383       rtx delta = GEN_INT (disp);
3384       rtx tmpreg = gen_rtx_REG (Pmode, 1);
3385
3386       emit_move_insn (tmpreg,
3387                       gen_rtx_PLUS (Pmode, basereg,
3388                                     gen_rtx_HIGH (Pmode, delta)));
3389       insn = emit_move_insn (gen_rtx_REG (Pmode, reg),
3390                              gen_rtx_LO_SUM (Pmode, tmpreg, delta));
3391     }
3392
3393   if (DO_FRAME_NOTES && note)
3394     RTX_FRAME_RELATED_P (insn) = 1;
3395 }
3396
3397 HOST_WIDE_INT
3398 compute_frame_size (HOST_WIDE_INT size, int *fregs_live)
3399 {
3400   int freg_saved = 0;
3401   int i, j;
3402
3403   /* The code in hppa_expand_prologue and hppa_expand_epilogue must
3404      be consistent with the rounding and size calculation done here.
3405      Change them at the same time.  */
3406
3407   /* We do our own stack alignment.  First, round the size of the
3408      stack locals up to a word boundary.  */
3409   size = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3410
3411   /* Space for previous frame pointer + filler.  If any frame is
3412      allocated, we need to add in the STARTING_FRAME_OFFSET.  We
3413      waste some space here for the sake of HP compatibility.  The
3414      first slot is only used when the frame pointer is needed.  */
3415   if (size || frame_pointer_needed)
3416     size += STARTING_FRAME_OFFSET;
3417
3418   /* If the current function calls __builtin_eh_return, then we need
3419      to allocate stack space for registers that will hold data for
3420      the exception handler.  */
3421   if (DO_FRAME_NOTES && current_function_calls_eh_return)
3422     {
3423       unsigned int i;
3424
3425       for (i = 0; EH_RETURN_DATA_REGNO (i) != INVALID_REGNUM; ++i)
3426         continue;
3427       size += i * UNITS_PER_WORD;
3428     }
3429
3430   /* Account for space used by the callee general register saves.  */
3431   for (i = 18, j = frame_pointer_needed ? 4 : 3; i >= j; i--)
3432     if (regs_ever_live[i])
3433       size += UNITS_PER_WORD;
3434
3435   /* Account for space used by the callee floating point register saves.  */
3436   for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
3437     if (regs_ever_live[i]
3438         || (!TARGET_64BIT && regs_ever_live[i + 1]))
3439       {
3440         freg_saved = 1;
3441
3442         /* We always save both halves of the FP register, so always
3443            increment the frame size by 8 bytes.  */
3444         size += 8;
3445       }
3446
3447   /* If any of the floating registers are saved, account for the
3448      alignment needed for the floating point register save block.  */
3449   if (freg_saved)
3450     {
3451       size = (size + 7) & ~7;
3452       if (fregs_live)
3453         *fregs_live = 1;
3454     }
3455
3456   /* The various ABIs include space for the outgoing parameters in the
3457      size of the current function's stack frame.  We don't need to align
3458      for the outgoing arguments as their alignment is set by the final
3459      rounding for the frame as a whole.  */
3460   size += current_function_outgoing_args_size;
3461
3462   /* Allocate space for the fixed frame marker.  This space must be
3463      allocated for any function that makes calls or allocates
3464      stack space.  */
3465   if (!current_function_is_leaf || size)
3466     size += TARGET_64BIT ? 48 : 32;
3467
3468   /* Finally, round to the preferred stack boundary.  */
3469   return ((size + PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1)
3470           & ~(PREFERRED_STACK_BOUNDARY / BITS_PER_UNIT - 1));
3471 }
3472
3473 /* Generate the assembly code for function entry.  FILE is a stdio
3474    stream to output the code to.  SIZE is an int: how many units of
3475    temporary storage to allocate.
3476
3477    Refer to the array `regs_ever_live' to determine which registers to
3478    save; `regs_ever_live[I]' is nonzero if register number I is ever
3479    used in the function.  This function is responsible for knowing
3480    which registers should not be saved even if used.  */
3481
3482 /* On HP-PA, move-double insns between fpu and cpu need an 8-byte block
3483    of memory.  If any fpu reg is used in the function, we allocate
3484    such a block here, at the bottom of the frame, just in case it's needed.
3485
3486    If this function is a leaf procedure, then we may choose not
3487    to do a "save" insn.  The decision about whether or not
3488    to do this is made in regclass.c.  */
3489
3490 static void
3491 pa_output_function_prologue (FILE *file, HOST_WIDE_INT size ATTRIBUTE_UNUSED)
3492 {
3493   /* The function's label and associated .PROC must never be
3494      separated and must be output *after* any profiling declarations
3495      to avoid changing spaces/subspaces within a procedure.  */
3496   ASM_OUTPUT_LABEL (file, XSTR (XEXP (DECL_RTL (current_function_decl), 0), 0));
3497   fputs ("\t.PROC\n", file);
3498
3499   /* hppa_expand_prologue does the dirty work now.  We just need
3500      to output the assembler directives which denote the start
3501      of a function.  */
3502   fprintf (file, "\t.CALLINFO FRAME=" HOST_WIDE_INT_PRINT_DEC, actual_fsize);
3503   if (regs_ever_live[2])
3504     fputs (",CALLS,SAVE_RP", file);
3505   else
3506     fputs (",NO_CALLS", file);
3507
3508   /* The SAVE_SP flag is used to indicate that register %r3 is stored
3509      at the beginning of the frame and that it is used as the frame
3510      pointer for the frame.  We do this because our current frame
3511      layout doesn't conform to that specified in the HP runtime
3512      documentation and we need a way to indicate to programs such as
3513      GDB where %r3 is saved.  The SAVE_SP flag was chosen because it
3514      isn't used by HP compilers but is supported by the assembler.
3515      However, SAVE_SP is supposed to indicate that the previous stack
3516      pointer has been saved in the frame marker.  */
3517   if (frame_pointer_needed)
3518     fputs (",SAVE_SP", file);
3519
3520   /* Pass on information about the number of callee register saves
3521      performed in the prologue.
3522
3523      The compiler is supposed to pass the highest register number
3524      saved, the assembler then has to adjust that number before
3525      entering it into the unwind descriptor (to account for any
3526      caller saved registers with lower register numbers than the
3527      first callee saved register).  */
3528   if (gr_saved)
3529     fprintf (file, ",ENTRY_GR=%d", gr_saved + 2);
3530
3531   if (fr_saved)
3532     fprintf (file, ",ENTRY_FR=%d", fr_saved + 11);
3533
3534   fputs ("\n\t.ENTRY\n", file);
3535
3536   remove_useless_addtr_insns (0);
3537 }
3538
3539 void
3540 hppa_expand_prologue (void)
3541 {
3542   int merge_sp_adjust_with_store = 0;
3543   HOST_WIDE_INT size = get_frame_size ();
3544   HOST_WIDE_INT offset;
3545   int i;
3546   rtx insn, tmpreg;
3547
3548   gr_saved = 0;
3549   fr_saved = 0;
3550   save_fregs = 0;
3551
3552   /* Compute total size for frame pointer, filler, locals and rounding to
3553      the next word boundary.  Similar code appears in compute_frame_size
3554      and must be changed in tandem with this code.  */
3555   local_fsize = (size + UNITS_PER_WORD - 1) & ~(UNITS_PER_WORD - 1);
3556   if (local_fsize || frame_pointer_needed)
3557     local_fsize += STARTING_FRAME_OFFSET;
3558
3559   actual_fsize = compute_frame_size (size, &save_fregs);
3560
3561   /* Compute a few things we will use often.  */
3562   tmpreg = gen_rtx_REG (word_mode, 1);
3563
3564   /* Save RP first.  The calling conventions manual states RP will
3565      always be stored into the caller's frame at sp - 20 or sp - 16
3566      depending on which ABI is in use.  */
3567   if (regs_ever_live[2] || current_function_calls_eh_return)
3568     store_reg (2, TARGET_64BIT ? -16 : -20, STACK_POINTER_REGNUM);
3569
3570   /* Allocate the local frame and set up the frame pointer if needed.  */
3571   if (actual_fsize != 0)
3572     {
3573       if (frame_pointer_needed)
3574         {
3575           /* Copy the old frame pointer temporarily into %r1.  Set up the
3576              new stack pointer, then store away the saved old frame pointer
3577              into the stack at sp and at the same time update the stack
3578              pointer by actual_fsize bytes.  Two versions, first
3579              handles small (<8k) frames.  The second handles large (>=8k)
3580              frames.  */
3581           insn = emit_move_insn (tmpreg, frame_pointer_rtx);
3582           if (DO_FRAME_NOTES)
3583             RTX_FRAME_RELATED_P (insn) = 1;
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.  */
3937       in_section = NULL;
3938       cfun->machine->in_nsubspa = 2;
3939     }
3940
3941   if (INSN_ADDRESSES_SET_P ())
3942     {
3943       insn = get_last_nonnote_insn ();
3944       last_address += INSN_ADDRESSES (INSN_UID (insn));
3945       if (INSN_P (insn))
3946         last_address += insn_default_length (insn);
3947       last_address = ((last_address + FUNCTION_BOUNDARY / BITS_PER_UNIT - 1)
3948                       & ~(FUNCTION_BOUNDARY / BITS_PER_UNIT - 1));
3949     }
3950
3951   /* Finally, update the total number of code bytes output so far.  */
3952   update_total_code_bytes (last_address);
3953 }
3954
3955 void
3956 hppa_expand_epilogue (void)
3957 {
3958   rtx tmpreg;
3959   HOST_WIDE_INT offset;
3960   HOST_WIDE_INT ret_off = 0;
3961   int i;
3962   int merge_sp_adjust_with_load = 0;
3963
3964   /* We will use this often.  */
3965   tmpreg = gen_rtx_REG (word_mode, 1);
3966
3967   /* Try to restore RP early to avoid load/use interlocks when
3968      RP gets used in the return (bv) instruction.  This appears to still
3969      be necessary even when we schedule the prologue and epilogue.  */
3970   if (regs_ever_live [2] || current_function_calls_eh_return)
3971     {
3972       ret_off = TARGET_64BIT ? -16 : -20;
3973       if (frame_pointer_needed)
3974         {
3975           load_reg (2, ret_off, FRAME_POINTER_REGNUM);
3976           ret_off = 0;
3977         }
3978       else
3979         {
3980           /* No frame pointer, and stack is smaller than 8k.  */
3981           if (VAL_14_BITS_P (ret_off - actual_fsize))
3982             {
3983               load_reg (2, ret_off - actual_fsize, STACK_POINTER_REGNUM);
3984               ret_off = 0;
3985             }
3986         }
3987     }
3988
3989   /* General register restores.  */
3990   if (frame_pointer_needed)
3991     {
3992       offset = local_fsize;
3993
3994       /* If the current function calls __builtin_eh_return, then we need
3995          to restore the saved EH data registers.  */
3996       if (DO_FRAME_NOTES && current_function_calls_eh_return)
3997         {
3998           unsigned int i, regno;
3999
4000           for (i = 0; ; ++i)
4001             {
4002               regno = EH_RETURN_DATA_REGNO (i);
4003               if (regno == INVALID_REGNUM)
4004                 break;
4005
4006               load_reg (regno, offset, FRAME_POINTER_REGNUM);
4007               offset += UNITS_PER_WORD;
4008             }
4009         }
4010
4011       for (i = 18; i >= 4; i--)
4012         if (regs_ever_live[i] && ! call_used_regs[i])
4013           {
4014             load_reg (i, offset, FRAME_POINTER_REGNUM);
4015             offset += UNITS_PER_WORD;
4016           }
4017     }
4018   else
4019     {
4020       offset = local_fsize - actual_fsize;
4021
4022       /* If the current function calls __builtin_eh_return, then we need
4023          to restore the saved EH data registers.  */
4024       if (DO_FRAME_NOTES && current_function_calls_eh_return)
4025         {
4026           unsigned int i, regno;
4027
4028           for (i = 0; ; ++i)
4029             {
4030               regno = EH_RETURN_DATA_REGNO (i);
4031               if (regno == INVALID_REGNUM)
4032                 break;
4033
4034               /* Only for the first load.
4035                  merge_sp_adjust_with_load holds the register load
4036                  with which we will merge the sp adjustment.  */
4037               if (merge_sp_adjust_with_load == 0
4038                   && local_fsize == 0
4039                   && VAL_14_BITS_P (-actual_fsize))
4040                 merge_sp_adjust_with_load = regno;
4041               else
4042                 load_reg (regno, offset, STACK_POINTER_REGNUM);
4043               offset += UNITS_PER_WORD;
4044             }
4045         }
4046
4047       for (i = 18; i >= 3; i--)
4048         {
4049           if (regs_ever_live[i] && ! call_used_regs[i])
4050             {
4051               /* Only for the first load.
4052                  merge_sp_adjust_with_load holds the register load
4053                  with which we will merge the sp adjustment.  */
4054               if (merge_sp_adjust_with_load == 0
4055                   && local_fsize == 0
4056                   && VAL_14_BITS_P (-actual_fsize))
4057                 merge_sp_adjust_with_load = i;
4058               else
4059                 load_reg (i, offset, STACK_POINTER_REGNUM);
4060               offset += UNITS_PER_WORD;
4061             }
4062         }
4063     }
4064
4065   /* Align pointer properly (doubleword boundary).  */
4066   offset = (offset + 7) & ~7;
4067
4068   /* FP register restores.  */
4069   if (save_fregs)
4070     {
4071       /* Adjust the register to index off of.  */
4072       if (frame_pointer_needed)
4073         set_reg_plus_d (1, FRAME_POINTER_REGNUM, offset, 0);
4074       else
4075         set_reg_plus_d (1, STACK_POINTER_REGNUM, offset, 0);
4076
4077       /* Actually do the restores now.  */
4078       for (i = FP_SAVED_REG_LAST; i >= FP_SAVED_REG_FIRST; i -= FP_REG_STEP)
4079         if (regs_ever_live[i]
4080             || (! TARGET_64BIT && regs_ever_live[i + 1]))
4081           {
4082             rtx src = gen_rtx_MEM (DFmode, gen_rtx_POST_INC (DFmode, tmpreg));
4083             rtx dest = gen_rtx_REG (DFmode, i);
4084             emit_move_insn (dest, src);
4085           }
4086     }
4087
4088   /* Emit a blockage insn here to keep these insns from being moved to
4089      an earlier spot in the epilogue, or into the main instruction stream.
4090
4091      This is necessary as we must not cut the stack back before all the
4092      restores are finished.  */
4093   emit_insn (gen_blockage ());
4094
4095   /* Reset stack pointer (and possibly frame pointer).  The stack
4096      pointer is initially set to fp + 64 to avoid a race condition.  */
4097   if (frame_pointer_needed)
4098     {
4099       rtx delta = GEN_INT (-64);
4100
4101       set_reg_plus_d (STACK_POINTER_REGNUM, FRAME_POINTER_REGNUM, 64, 0);
4102       emit_insn (gen_pre_load (frame_pointer_rtx, stack_pointer_rtx, delta));
4103     }
4104   /* If we were deferring a callee register restore, do it now.  */
4105   else if (merge_sp_adjust_with_load)
4106     {
4107       rtx delta = GEN_INT (-actual_fsize);
4108       rtx dest = gen_rtx_REG (word_mode, merge_sp_adjust_with_load);
4109
4110       emit_insn (gen_pre_load (dest, stack_pointer_rtx, delta));
4111     }
4112   else if (actual_fsize != 0)
4113     set_reg_plus_d (STACK_POINTER_REGNUM, STACK_POINTER_REGNUM,
4114                     - actual_fsize, 0);
4115
4116   /* If we haven't restored %r2 yet (no frame pointer, and a stack
4117      frame greater than 8k), do so now.  */
4118   if (ret_off != 0)
4119     load_reg (2, ret_off, STACK_POINTER_REGNUM);
4120
4121   if (DO_FRAME_NOTES && current_function_calls_eh_return)
4122     {
4123       rtx sa = EH_RETURN_STACKADJ_RTX;
4124
4125       emit_insn (gen_blockage ());
4126       emit_insn (TARGET_64BIT
4127                  ? gen_subdi3 (stack_pointer_rtx, stack_pointer_rtx, sa)
4128                  : gen_subsi3 (stack_pointer_rtx, stack_pointer_rtx, sa));
4129     }
4130 }
4131
4132 rtx
4133 hppa_pic_save_rtx (void)
4134 {
4135   return get_hard_reg_initial_val (word_mode, PIC_OFFSET_TABLE_REGNUM);
4136 }
4137
4138 #ifndef NO_DEFERRED_PROFILE_COUNTERS
4139 #define NO_DEFERRED_PROFILE_COUNTERS 0
4140 #endif
4141
4142 /* Define heap vector type for funcdef numbers.  */
4143 DEF_VEC_I(int);
4144 DEF_VEC_ALLOC_I(int,heap);
4145
4146 /* Vector of funcdef numbers.  */
4147 static VEC(int,heap) *funcdef_nos;
4148
4149 /* Output deferred profile counters.  */
4150 static void
4151 output_deferred_profile_counters (void)
4152 {
4153   unsigned int i;
4154   int align, n;
4155
4156   if (VEC_empty (int, funcdef_nos))
4157    return;
4158
4159   switch_to_section (data_section);
4160   align = MIN (BIGGEST_ALIGNMENT, LONG_TYPE_SIZE);
4161   ASM_OUTPUT_ALIGN (asm_out_file, floor_log2 (align / BITS_PER_UNIT));
4162
4163   for (i = 0; VEC_iterate (int, funcdef_nos, i, n); i++)
4164     {
4165       targetm.asm_out.internal_label (asm_out_file, "LP", n);
4166       assemble_integer (const0_rtx, LONG_TYPE_SIZE / BITS_PER_UNIT, align, 1);
4167     }
4168
4169   VEC_free (int, heap, funcdef_nos);
4170 }
4171
4172 void
4173 hppa_profile_hook (int label_no)
4174 {
4175   /* We use SImode for the address of the function in both 32 and
4176      64-bit code to avoid having to provide DImode versions of the
4177      lcla2 and load_offset_label_address insn patterns.  */
4178   rtx reg = gen_reg_rtx (SImode);
4179   rtx label_rtx = gen_label_rtx ();
4180   rtx begin_label_rtx, call_insn;
4181   char begin_label_name[16];
4182
4183   ASM_GENERATE_INTERNAL_LABEL (begin_label_name, FUNC_BEGIN_PROLOG_LABEL,
4184                                label_no);
4185   begin_label_rtx = gen_rtx_SYMBOL_REF (SImode, ggc_strdup (begin_label_name));
4186
4187   if (TARGET_64BIT)
4188     emit_move_insn (arg_pointer_rtx,
4189                     gen_rtx_PLUS (word_mode, virtual_outgoing_args_rtx,
4190                                   GEN_INT (64)));
4191
4192   emit_move_insn (gen_rtx_REG (word_mode, 26), gen_rtx_REG (word_mode, 2));
4193
4194   /* The address of the function is loaded into %r25 with a instruction-
4195      relative sequence that avoids the use of relocations.  The sequence
4196      is split so that the load_offset_label_address instruction can
4197      occupy the delay slot of the call to _mcount.  */
4198   if (TARGET_PA_20)
4199     emit_insn (gen_lcla2 (reg, label_rtx));
4200   else
4201     emit_insn (gen_lcla1 (reg, label_rtx));
4202
4203   emit_insn (gen_load_offset_label_address (gen_rtx_REG (SImode, 25),
4204                                             reg, begin_label_rtx, label_rtx));
4205
4206 #if !NO_DEFERRED_PROFILE_COUNTERS
4207   {
4208     rtx count_label_rtx, addr, r24;
4209     char count_label_name[16];
4210
4211     VEC_safe_push (int, heap, funcdef_nos, label_no);
4212     ASM_GENERATE_INTERNAL_LABEL (count_label_name, "LP", label_no);
4213     count_label_rtx = gen_rtx_SYMBOL_REF (Pmode, ggc_strdup (count_label_name));
4214
4215     addr = force_reg (Pmode, count_label_rtx);
4216     r24 = gen_rtx_REG (Pmode, 24);
4217     emit_move_insn (r24, addr);
4218
4219     call_insn =
4220       emit_call_insn (gen_call (gen_rtx_MEM (Pmode,
4221                                              gen_rtx_SYMBOL_REF (Pmode,
4222                                                                  "_mcount")),
4223                                 GEN_INT (TARGET_64BIT ? 24 : 12)));
4224
4225     use_reg (&CALL_INSN_FUNCTION_USAGE (call_insn), r24);
4226   }
4227 #else
4228
4229   call_insn =
4230     emit_call_insn (gen_call (gen_rtx_MEM (Pmode,
4231                                            gen_rtx_SYMBOL_REF (Pmode,
4232                                                                "_mcount")),
4233                               GEN_INT (TARGET_64BIT ? 16 : 8)));
4234
4235 #endif
4236
4237   use_reg (&CALL_INSN_FUNCTION_USAGE (call_insn), gen_rtx_REG (SImode, 25));
4238   use_reg (&CALL_INSN_FUNCTION_USAGE (call_insn), gen_rtx_REG (SImode, 26));
4239
4240   /* Indicate the _mcount call cannot throw, nor will it execute a
4241      non-local goto.  */
4242   REG_NOTES (call_insn)
4243     = gen_rtx_EXPR_LIST (REG_EH_REGION, constm1_rtx, REG_NOTES (call_insn));
4244 }
4245
4246 /* Fetch the return address for the frame COUNT steps up from
4247    the current frame, after the prologue.  FRAMEADDR is the
4248    frame pointer of the COUNT frame.
4249
4250    We want to ignore any export stub remnants here.  To handle this,
4251    we examine the code at the return address, and if it is an export
4252    stub, we return a memory rtx for the stub return address stored
4253    at frame-24.
4254
4255    The value returned is used in two different ways:
4256
4257         1. To find a function's caller.
4258
4259         2. To change the return address for a function.
4260
4261    This function handles most instances of case 1; however, it will
4262    fail if there are two levels of stubs to execute on the return
4263    path.  The only way I believe that can happen is if the return value
4264    needs a parameter relocation, which never happens for C code.
4265
4266    This function handles most instances of case 2; however, it will
4267    fail if we did not originally have stub code on the return path
4268    but will need stub code on the new return path.  This can happen if
4269    the caller & callee are both in the main program, but the new
4270    return location is in a shared library.  */
4271
4272 rtx
4273 return_addr_rtx (int count, rtx frameaddr)
4274 {
4275   rtx label;
4276   rtx rp;
4277   rtx saved_rp;
4278   rtx ins;
4279
4280   if (count != 0)
4281     return NULL_RTX;
4282
4283   rp = get_hard_reg_initial_val (Pmode, 2);
4284
4285   if (TARGET_64BIT || TARGET_NO_SPACE_REGS)
4286     return rp;
4287
4288   saved_rp = gen_reg_rtx (Pmode);
4289   emit_move_insn (saved_rp, rp);
4290
4291   /* Get pointer to the instruction stream.  We have to mask out the
4292      privilege level from the two low order bits of the return address
4293      pointer here so that ins will point to the start of the first
4294      instruction that would have been executed if we returned.  */
4295   ins = copy_to_reg (gen_rtx_AND (Pmode, rp, MASK_RETURN_ADDR));
4296   label = gen_label_rtx ();
4297
4298   /* Check the instruction stream at the normal return address for the
4299      export stub:
4300
4301         0x4bc23fd1 | stub+8:   ldw -18(sr0,sp),rp
4302         0x004010a1 | stub+12:  ldsid (sr0,rp),r1
4303         0x00011820 | stub+16:  mtsp r1,sr0
4304         0xe0400002 | stub+20:  be,n 0(sr0,rp)
4305
4306      If it is an export stub, than our return address is really in
4307      -24[frameaddr].  */
4308
4309   emit_cmp_insn (gen_rtx_MEM (SImode, ins), GEN_INT (0x4bc23fd1), NE,
4310                  NULL_RTX, SImode, 1);
4311   emit_jump_insn (gen_bne (label));
4312
4313   emit_cmp_insn (gen_rtx_MEM (SImode, plus_constant (ins, 4)),
4314                  GEN_INT (0x004010a1), NE, NULL_RTX, SImode, 1);
4315   emit_jump_insn (gen_bne (label));
4316
4317   emit_cmp_insn (gen_rtx_MEM (SImode, plus_constant (ins, 8)),
4318                  GEN_INT (0x00011820), NE, NULL_RTX, SImode, 1);
4319   emit_jump_insn (gen_bne (label));
4320
4321   emit_cmp_insn (gen_rtx_MEM (SImode, plus_constant (ins, 12)),
4322                  GEN_INT (0xe0400002), NE, NULL_RTX, SImode, 1);
4323
4324   /* If there is no export stub then just use the value saved from
4325      the return pointer register.  */
4326
4327   emit_jump_insn (gen_bne (label));
4328
4329   /* Here we know that our return address points to an export
4330      stub.  We don't want to return the address of the export stub,
4331      but rather the return address of the export stub.  That return
4332      address is stored at -24[frameaddr].  */
4333
4334   emit_move_insn (saved_rp,
4335                   gen_rtx_MEM (Pmode,
4336                                memory_address (Pmode,
4337                                                plus_constant (frameaddr,
4338                                                               -24))));
4339
4340   emit_label (label);
4341   return saved_rp;
4342 }
4343
4344 /* This is only valid once reload has completed because it depends on
4345    knowing exactly how much (if any) frame there is and...
4346
4347    It's only valid if there is no frame marker to de-allocate and...
4348
4349    It's only valid if %r2 hasn't been saved into the caller's frame
4350    (we're not profiling and %r2 isn't live anywhere).  */
4351 int
4352 hppa_can_use_return_insn_p (void)
4353 {
4354   return (reload_completed
4355           && (compute_frame_size (get_frame_size (), 0) ? 0 : 1)
4356           && ! regs_ever_live[2]
4357           && ! frame_pointer_needed);
4358 }
4359
4360 void
4361 emit_bcond_fp (enum rtx_code code, rtx operand0)
4362 {
4363   emit_jump_insn (gen_rtx_SET (VOIDmode, pc_rtx,
4364                                gen_rtx_IF_THEN_ELSE (VOIDmode,
4365                                                      gen_rtx_fmt_ee (code,
4366                                                               VOIDmode,
4367                                                               gen_rtx_REG (CCFPmode, 0),
4368                                                               const0_rtx),
4369                                                      gen_rtx_LABEL_REF (VOIDmode, operand0),
4370                                                      pc_rtx)));
4371
4372 }
4373
4374 rtx
4375 gen_cmp_fp (enum rtx_code code, rtx operand0, rtx operand1)
4376 {
4377   return gen_rtx_SET (VOIDmode, gen_rtx_REG (CCFPmode, 0),
4378                       gen_rtx_fmt_ee (code, CCFPmode, operand0, operand1));
4379 }
4380
4381 /* Adjust the cost of a scheduling dependency.  Return the new cost of
4382    a dependency LINK or INSN on DEP_INSN.  COST is the current cost.  */
4383
4384 static int
4385 pa_adjust_cost (rtx insn, rtx link, rtx dep_insn, int cost)
4386 {
4387   enum attr_type attr_type;
4388
4389   /* Don't adjust costs for a pa8000 chip, also do not adjust any
4390      true dependencies as they are described with bypasses now.  */
4391   if (pa_cpu >= PROCESSOR_8000 || REG_NOTE_KIND (link) == 0)
4392     return cost;
4393
4394   if (! recog_memoized (insn))
4395     return 0;
4396
4397   attr_type = get_attr_type (insn);
4398
4399   switch (REG_NOTE_KIND (link))
4400     {
4401     case REG_DEP_ANTI:
4402       /* Anti dependency; DEP_INSN reads a register that INSN writes some
4403          cycles later.  */
4404
4405       if (attr_type == TYPE_FPLOAD)
4406         {
4407           rtx pat = PATTERN (insn);
4408           rtx dep_pat = PATTERN (dep_insn);
4409           if (GET_CODE (pat) == PARALLEL)
4410             {
4411               /* This happens for the fldXs,mb patterns.  */
4412               pat = XVECEXP (pat, 0, 0);
4413             }
4414           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
4415             /* If this happens, we have to extend this to schedule
4416                optimally.  Return 0 for now.  */
4417           return 0;
4418
4419           if (reg_mentioned_p (SET_DEST (pat), SET_SRC (dep_pat)))
4420             {
4421               if (! recog_memoized (dep_insn))
4422                 return 0;
4423               switch (get_attr_type (dep_insn))
4424                 {
4425                 case TYPE_FPALU:
4426                 case TYPE_FPMULSGL:
4427                 case TYPE_FPMULDBL:
4428                 case TYPE_FPDIVSGL:
4429                 case TYPE_FPDIVDBL:
4430                 case TYPE_FPSQRTSGL:
4431                 case TYPE_FPSQRTDBL:
4432                   /* A fpload can't be issued until one cycle before a
4433                      preceding arithmetic operation has finished if
4434                      the target of the fpload is any of the sources
4435                      (or destination) of the arithmetic operation.  */
4436                   return insn_default_latency (dep_insn) - 1;
4437
4438                 default:
4439                   return 0;
4440                 }
4441             }
4442         }
4443       else if (attr_type == TYPE_FPALU)
4444         {
4445           rtx pat = PATTERN (insn);
4446           rtx dep_pat = PATTERN (dep_insn);
4447           if (GET_CODE (pat) == PARALLEL)
4448             {
4449               /* This happens for the fldXs,mb patterns.  */
4450               pat = XVECEXP (pat, 0, 0);
4451             }
4452           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
4453             /* If this happens, we have to extend this to schedule
4454                optimally.  Return 0 for now.  */
4455           return 0;
4456
4457           if (reg_mentioned_p (SET_DEST (pat), SET_SRC (dep_pat)))
4458             {
4459               if (! recog_memoized (dep_insn))
4460                 return 0;
4461               switch (get_attr_type (dep_insn))
4462                 {
4463                 case TYPE_FPDIVSGL:
4464                 case TYPE_FPDIVDBL:
4465                 case TYPE_FPSQRTSGL:
4466                 case TYPE_FPSQRTDBL:
4467                   /* An ALU flop can't be issued until two cycles before a
4468                      preceding divide or sqrt operation has finished if
4469                      the target of the ALU flop is any of the sources
4470                      (or destination) of the divide or sqrt operation.  */
4471                   return insn_default_latency (dep_insn) - 2;
4472
4473                 default:
4474                   return 0;
4475                 }
4476             }
4477         }
4478
4479       /* For other anti dependencies, the cost is 0.  */
4480       return 0;
4481
4482     case REG_DEP_OUTPUT:
4483       /* Output dependency; DEP_INSN writes a register that INSN writes some
4484          cycles later.  */
4485       if (attr_type == TYPE_FPLOAD)
4486         {
4487           rtx pat = PATTERN (insn);
4488           rtx dep_pat = PATTERN (dep_insn);
4489           if (GET_CODE (pat) == PARALLEL)
4490             {
4491               /* This happens for the fldXs,mb patterns.  */
4492               pat = XVECEXP (pat, 0, 0);
4493             }
4494           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
4495             /* If this happens, we have to extend this to schedule
4496                optimally.  Return 0 for now.  */
4497           return 0;
4498
4499           if (reg_mentioned_p (SET_DEST (pat), SET_DEST (dep_pat)))
4500             {
4501               if (! recog_memoized (dep_insn))
4502                 return 0;
4503               switch (get_attr_type (dep_insn))
4504                 {
4505                 case TYPE_FPALU:
4506                 case TYPE_FPMULSGL:
4507                 case TYPE_FPMULDBL:
4508                 case TYPE_FPDIVSGL:
4509                 case TYPE_FPDIVDBL:
4510                 case TYPE_FPSQRTSGL:
4511                 case TYPE_FPSQRTDBL:
4512                   /* A fpload can't be issued until one cycle before a
4513                      preceding arithmetic operation has finished if
4514                      the target of the fpload is the destination of the
4515                      arithmetic operation.
4516
4517                      Exception: For PA7100LC, PA7200 and PA7300, the cost
4518                      is 3 cycles, unless they bundle together.   We also
4519                      pay the penalty if the second insn is a fpload.  */
4520                   return insn_default_latency (dep_insn) - 1;
4521
4522                 default:
4523                   return 0;
4524                 }
4525             }
4526         }
4527       else if (attr_type == TYPE_FPALU)
4528         {
4529           rtx pat = PATTERN (insn);
4530           rtx dep_pat = PATTERN (dep_insn);
4531           if (GET_CODE (pat) == PARALLEL)
4532             {
4533               /* This happens for the fldXs,mb patterns.  */
4534               pat = XVECEXP (pat, 0, 0);
4535             }
4536           if (GET_CODE (pat) != SET || GET_CODE (dep_pat) != SET)
4537             /* If this happens, we have to extend this to schedule
4538                optimally.  Return 0 for now.  */
4539           return 0;
4540
4541           if (reg_mentioned_p (SET_DEST (pat), SET_DEST (dep_pat)))
4542             {
4543               if (! recog_memoized (dep_insn))
4544                 return 0;
4545               switch (get_attr_type (dep_insn))
4546                 {
4547                 case TYPE_FPDIVSGL:
4548                 case TYPE_FPDIVDBL:
4549                 case TYPE_FPSQRTSGL:
4550                 case TYPE_FPSQRTDBL:
4551                   /* An ALU flop can't be issued until two cycles before a
4552                      preceding divide or sqrt operation has finished if
4553                      the target of the ALU flop is also the target of
4554                      the divide or sqrt operation.  */
4555                   return insn_default_latency (dep_insn) - 2;
4556
4557                 default:
4558                   return 0;
4559                 }
4560             }
4561         }
4562
4563       /* For other output dependencies, the cost is 0.  */
4564       return 0;
4565
4566     default:
4567       gcc_unreachable ();
4568     }
4569 }
4570
4571 /* Adjust scheduling priorities.  We use this to try and keep addil
4572    and the next use of %r1 close together.  */
4573 static int
4574 pa_adjust_priority (rtx insn, int priority)
4575 {
4576   rtx set = single_set (insn);
4577   rtx src, dest;
4578   if (set)
4579     {
4580       src = SET_SRC (set);
4581       dest = SET_DEST (set);
4582       if (GET_CODE (src) == LO_SUM
4583           && symbolic_operand (XEXP (src, 1), VOIDmode)
4584           && ! read_only_operand (XEXP (src, 1), VOIDmode))
4585         priority >>= 3;
4586
4587       else if (GET_CODE (src) == MEM
4588                && GET_CODE (XEXP (src, 0)) == LO_SUM
4589                && symbolic_operand (XEXP (XEXP (src, 0), 1), VOIDmode)
4590                && ! read_only_operand (XEXP (XEXP (src, 0), 1), VOIDmode))
4591         priority >>= 1;
4592
4593       else if (GET_CODE (dest) == MEM
4594                && GET_CODE (XEXP (dest, 0)) == LO_SUM
4595                && symbolic_operand (XEXP (XEXP (dest, 0), 1), VOIDmode)
4596                && ! read_only_operand (XEXP (XEXP (dest, 0), 1), VOIDmode))
4597         priority >>= 3;
4598     }
4599   return priority;
4600 }
4601
4602 /* The 700 can only issue a single insn at a time.
4603    The 7XXX processors can issue two insns at a time.
4604    The 8000 can issue 4 insns at a time.  */
4605 static int
4606 pa_issue_rate (void)
4607 {
4608   switch (pa_cpu)
4609     {
4610     case PROCESSOR_700:         return 1;
4611     case PROCESSOR_7100:        return 2;
4612     case PROCESSOR_7100LC:      return 2;
4613     case PROCESSOR_7200:        return 2;
4614     case PROCESSOR_7300:        return 2;
4615     case PROCESSOR_8000:        return 4;
4616
4617     default:
4618       gcc_unreachable ();
4619     }
4620 }
4621
4622
4623
4624 /* Return any length adjustment needed by INSN which already has its length
4625    computed as LENGTH.   Return zero if no adjustment is necessary.
4626
4627    For the PA: function calls, millicode calls, and backwards short
4628    conditional branches with unfilled delay slots need an adjustment by +1
4629    (to account for the NOP which will be inserted into the instruction stream).
4630
4631    Also compute the length of an inline block move here as it is too
4632    complicated to express as a length attribute in pa.md.  */
4633 int
4634 pa_adjust_insn_length (rtx insn, int length)
4635 {
4636   rtx pat = PATTERN (insn);
4637
4638   /* Jumps inside switch tables which have unfilled delay slots need
4639      adjustment.  */
4640   if (GET_CODE (insn) == JUMP_INSN
4641       && GET_CODE (pat) == PARALLEL
4642       && get_attr_type (insn) == TYPE_BTABLE_BRANCH)
4643     return 4;
4644   /* Millicode insn with an unfilled delay slot.  */
4645   else if (GET_CODE (insn) == INSN
4646            && GET_CODE (pat) != SEQUENCE
4647            && GET_CODE (pat) != USE
4648            && GET_CODE (pat) != CLOBBER
4649            && get_attr_type (insn) == TYPE_MILLI)
4650     return 4;
4651   /* Block move pattern.  */
4652   else if (GET_CODE (insn) == INSN
4653            && GET_CODE (pat) == PARALLEL
4654            && GET_CODE (XVECEXP (pat, 0, 0)) == SET
4655            && GET_CODE (XEXP (XVECEXP (pat, 0, 0), 0)) == MEM
4656            && GET_CODE (XEXP (XVECEXP (pat, 0, 0), 1)) == MEM
4657            && GET_MODE (XEXP (XVECEXP (pat, 0, 0), 0)) == BLKmode
4658            && GET_MODE (XEXP (XVECEXP (pat, 0, 0), 1)) == BLKmode)
4659     return compute_movmem_length (insn) - 4;
4660   /* Block clear pattern.  */
4661   else if (GET_CODE (insn) == INSN
4662            && GET_CODE (pat) == PARALLEL
4663            && GET_CODE (XVECEXP (pat, 0, 0)) == SET
4664            && GET_CODE (XEXP (XVECEXP (pat, 0, 0), 0)) == MEM
4665            && XEXP (XVECEXP (pat, 0, 0), 1) == const0_rtx
4666            && GET_MODE (XEXP (XVECEXP (pat, 0, 0), 0)) == BLKmode)
4667     return compute_clrmem_length (insn) - 4;
4668   /* Conditional branch with an unfilled delay slot.  */
4669   else if (GET_CODE (insn) == JUMP_INSN && ! simplejump_p (insn))
4670     {
4671       /* Adjust a short backwards conditional with an unfilled delay slot.  */
4672       if (GET_CODE (pat) == SET
4673           && length == 4
4674           && ! forward_branch_p (insn))
4675         return 4;
4676       else if (GET_CODE (pat) == PARALLEL
4677                && get_attr_type (insn) == TYPE_PARALLEL_BRANCH
4678                && length == 4)
4679         return 4;
4680       /* Adjust dbra insn with short backwards conditional branch with
4681          unfilled delay slot -- only for case where counter is in a
4682          general register register.  */
4683       else if (GET_CODE (pat) == PARALLEL
4684                && GET_CODE (XVECEXP (pat, 0, 1)) == SET
4685                && GET_CODE (XEXP (XVECEXP (pat, 0, 1), 0)) == REG
4686                && ! FP_REG_P (XEXP (XVECEXP (pat, 0, 1), 0))
4687                && length == 4
4688                && ! forward_branch_p (insn))
4689         return 4;
4690       else
4691         return 0;
4692     }
4693   return 0;
4694 }
4695
4696 /* Print operand X (an rtx) in assembler syntax to file FILE.
4697    CODE is a letter or dot (`z' in `%z0') or 0 if no letter was specified.
4698    For `%' followed by punctuation, CODE is the punctuation and X is null.  */
4699
4700 void
4701 print_operand (FILE *file, rtx x, int code)
4702 {
4703   switch (code)
4704     {
4705     case '#':
4706       /* Output a 'nop' if there's nothing for the delay slot.  */
4707       if (dbr_sequence_length () == 0)
4708         fputs ("\n\tnop", file);
4709       return;
4710     case '*':
4711       /* Output a nullification completer if there's nothing for the */
4712       /* delay slot or nullification is requested.  */
4713       if (dbr_sequence_length () == 0 ||
4714           (final_sequence &&
4715            INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))))
4716         fputs (",n", file);
4717       return;
4718     case 'R':
4719       /* Print out the second register name of a register pair.
4720          I.e., R (6) => 7.  */
4721       fputs (reg_names[REGNO (x) + 1], file);
4722       return;
4723     case 'r':
4724       /* A register or zero.  */
4725       if (x == const0_rtx
4726           || (x == CONST0_RTX (DFmode))
4727           || (x == CONST0_RTX (SFmode)))
4728         {
4729           fputs ("%r0", file);
4730           return;
4731         }
4732       else
4733         break;
4734     case 'f':
4735       /* A register or zero (floating point).  */
4736       if (x == const0_rtx
4737           || (x == CONST0_RTX (DFmode))
4738           || (x == CONST0_RTX (SFmode)))
4739         {
4740           fputs ("%fr0", file);
4741           return;
4742         }
4743       else
4744         break;
4745     case 'A':
4746       {
4747         rtx xoperands[2];
4748
4749         xoperands[0] = XEXP (XEXP (x, 0), 0);
4750         xoperands[1] = XVECEXP (XEXP (XEXP (x, 0), 1), 0, 0);
4751         output_global_address (file, xoperands[1], 0);
4752         fprintf (file, "(%s)", reg_names [REGNO (xoperands[0])]);
4753         return;
4754       }
4755
4756     case 'C':                   /* Plain (C)ondition */
4757     case 'X':
4758       switch (GET_CODE (x))
4759         {
4760         case EQ:
4761           fputs ("=", file);  break;
4762         case NE:
4763           fputs ("<>", file);  break;
4764         case GT:
4765           fputs (">", file);  break;
4766         case GE:
4767           fputs (">=", file);  break;
4768         case GEU:
4769           fputs (">>=", file);  break;
4770         case GTU:
4771           fputs (">>", file);  break;
4772         case LT:
4773           fputs ("<", file);  break;
4774         case LE:
4775           fputs ("<=", file);  break;
4776         case LEU:
4777           fputs ("<<=", file);  break;
4778         case LTU:
4779           fputs ("<<", file);  break;
4780         default:
4781           gcc_unreachable ();
4782         }
4783       return;
4784     case 'N':                   /* Condition, (N)egated */
4785       switch (GET_CODE (x))
4786         {
4787         case EQ:
4788           fputs ("<>", file);  break;
4789         case NE:
4790           fputs ("=", file);  break;
4791         case GT:
4792           fputs ("<=", file);  break;
4793         case GE:
4794           fputs ("<", file);  break;
4795         case GEU:
4796           fputs ("<<", file);  break;
4797         case GTU:
4798           fputs ("<<=", file);  break;
4799         case LT:
4800           fputs (">=", file);  break;
4801         case LE:
4802           fputs (">", file);  break;
4803         case LEU:
4804           fputs (">>", file);  break;
4805         case LTU:
4806           fputs (">>=", file);  break;
4807         default:
4808           gcc_unreachable ();
4809         }
4810       return;
4811     /* For floating point comparisons.  Note that the output
4812        predicates are the complement of the desired mode.  The
4813        conditions for GT, GE, LT, LE and LTGT cause an invalid
4814        operation exception if the result is unordered and this
4815        exception is enabled in the floating-point status register.  */
4816     case 'Y':
4817       switch (GET_CODE (x))
4818         {
4819         case EQ:
4820           fputs ("!=", file);  break;
4821         case NE:
4822           fputs ("=", file);  break;
4823         case GT:
4824           fputs ("!>", file);  break;
4825         case GE:
4826           fputs ("!>=", file);  break;
4827         case LT:
4828           fputs ("!<", file);  break;
4829         case LE:
4830           fputs ("!<=", file);  break;
4831         case LTGT:
4832           fputs ("!<>", file);  break;
4833         case UNLE:
4834           fputs ("!?<=", file);  break;
4835         case UNLT:
4836           fputs ("!?<", file);  break;
4837         case UNGE:
4838           fputs ("!?>=", file);  break;
4839         case UNGT:
4840           fputs ("!?>", file);  break;
4841         case UNEQ:
4842           fputs ("!?=", file);  break;
4843         case UNORDERED:
4844           fputs ("!?", file);  break;
4845         case ORDERED:
4846           fputs ("?", file);  break;
4847         default:
4848           gcc_unreachable ();
4849         }
4850       return;
4851     case 'S':                   /* Condition, operands are (S)wapped.  */
4852       switch (GET_CODE (x))
4853         {
4854         case EQ:
4855           fputs ("=", file);  break;
4856         case NE:
4857           fputs ("<>", file);  break;
4858         case GT:
4859           fputs ("<", file);  break;
4860         case GE:
4861           fputs ("<=", file);  break;
4862         case GEU:
4863           fputs ("<<=", file);  break;
4864         case GTU:
4865           fputs ("<<", file);  break;
4866         case LT:
4867           fputs (">", file);  break;
4868         case LE:
4869           fputs (">=", file);  break;
4870         case LEU:
4871           fputs (">>=", file);  break;
4872         case LTU:
4873           fputs (">>", file);  break;
4874         default:
4875           gcc_unreachable ();
4876         }
4877       return;
4878     case 'B':                   /* Condition, (B)oth swapped and negate.  */
4879       switch (GET_CODE (x))
4880         {
4881         case EQ:
4882           fputs ("<>", file);  break;
4883         case NE:
4884           fputs ("=", file);  break;
4885         case GT:
4886           fputs (">=", file);  break;
4887         case GE:
4888           fputs (">", file);  break;
4889         case GEU:
4890           fputs (">>", file);  break;
4891         case GTU:
4892           fputs (">>=", file);  break;
4893         case LT:
4894           fputs ("<=", file);  break;
4895         case LE:
4896           fputs ("<", file);  break;
4897         case LEU:
4898           fputs ("<<", file);  break;
4899         case LTU:
4900           fputs ("<<=", file);  break;
4901         default:
4902           gcc_unreachable ();
4903         }
4904       return;
4905     case 'k':
4906       gcc_assert (GET_CODE (x) == CONST_INT);
4907       fprintf (file, HOST_WIDE_INT_PRINT_DEC, ~INTVAL (x));
4908       return;
4909     case 'Q':
4910       gcc_assert (GET_CODE (x) == CONST_INT);
4911       fprintf (file, HOST_WIDE_INT_PRINT_DEC, 64 - (INTVAL (x) & 63));
4912       return;
4913     case 'L':
4914       gcc_assert (GET_CODE (x) == CONST_INT);
4915       fprintf (file, HOST_WIDE_INT_PRINT_DEC, 32 - (INTVAL (x) & 31));
4916       return;
4917     case 'O':
4918       gcc_assert (GET_CODE (x) == CONST_INT && exact_log2 (INTVAL (x)) >= 0);
4919       fprintf (file, "%d", exact_log2 (INTVAL (x)));
4920       return;
4921     case 'p':
4922       gcc_assert (GET_CODE (x) == CONST_INT);
4923       fprintf (file, HOST_WIDE_INT_PRINT_DEC, 63 - (INTVAL (x) & 63));
4924       return;
4925     case 'P':
4926       gcc_assert (GET_CODE (x) == CONST_INT);
4927       fprintf (file, HOST_WIDE_INT_PRINT_DEC, 31 - (INTVAL (x) & 31));
4928       return;
4929     case 'I':
4930       if (GET_CODE (x) == CONST_INT)
4931         fputs ("i", file);
4932       return;
4933     case 'M':
4934     case 'F':
4935       switch (GET_CODE (XEXP (x, 0)))
4936         {
4937         case PRE_DEC:
4938         case PRE_INC:
4939           if (ASSEMBLER_DIALECT == 0)
4940             fputs ("s,mb", file);
4941           else
4942             fputs (",mb", file);
4943           break;
4944         case POST_DEC:
4945         case POST_INC:
4946           if (ASSEMBLER_DIALECT == 0)
4947             fputs ("s,ma", file);
4948           else
4949             fputs (",ma", file);
4950           break;
4951         case PLUS:
4952           if (GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
4953               && GET_CODE (XEXP (XEXP (x, 0), 1)) == REG)
4954             {
4955               if (ASSEMBLER_DIALECT == 0)
4956                 fputs ("x", file);
4957             }
4958           else if (GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT
4959                    || GET_CODE (XEXP (XEXP (x, 0), 1)) == MULT)
4960             {
4961               if (ASSEMBLER_DIALECT == 0)
4962                 fputs ("x,s", file);
4963               else
4964                 fputs (",s", file);
4965             }
4966           else if (code == 'F' && ASSEMBLER_DIALECT == 0)
4967             fputs ("s", file);
4968           break;
4969         default:
4970           if (code == 'F' && ASSEMBLER_DIALECT == 0)
4971             fputs ("s", file);
4972           break;
4973         }
4974       return;
4975     case 'G':
4976       output_global_address (file, x, 0);
4977       return;
4978     case 'H':
4979       output_global_address (file, x, 1);
4980       return;
4981     case 0:                     /* Don't do anything special */
4982       break;
4983     case 'Z':
4984       {
4985         unsigned op[3];
4986         compute_zdepwi_operands (INTVAL (x), op);
4987         fprintf (file, "%d,%d,%d", op[0], op[1], op[2]);
4988         return;
4989       }
4990     case 'z':
4991       {
4992         unsigned op[3];
4993         compute_zdepdi_operands (INTVAL (x), op);
4994         fprintf (file, "%d,%d,%d", op[0], op[1], op[2]);
4995         return;
4996       }
4997     case 'c':
4998       /* We can get here from a .vtable_inherit due to our
4999          CONSTANT_ADDRESS_P rejecting perfectly good constant
5000          addresses.  */
5001       break;
5002     default:
5003       gcc_unreachable ();
5004     }
5005   if (GET_CODE (x) == REG)
5006     {
5007       fputs (reg_names [REGNO (x)], file);
5008       if (TARGET_64BIT && FP_REG_P (x) && GET_MODE_SIZE (GET_MODE (x)) <= 4)
5009         {
5010           fputs ("R", file);
5011           return;
5012         }
5013       if (FP_REG_P (x)
5014           && GET_MODE_SIZE (GET_MODE (x)) <= 4
5015           && (REGNO (x) & 1) == 0)
5016         fputs ("L", file);
5017     }
5018   else if (GET_CODE (x) == MEM)
5019     {
5020       int size = GET_MODE_SIZE (GET_MODE (x));
5021       rtx base = NULL_RTX;
5022       switch (GET_CODE (XEXP (x, 0)))
5023         {
5024         case PRE_DEC:
5025         case POST_DEC:
5026           base = XEXP (XEXP (x, 0), 0);
5027           fprintf (file, "-%d(%s)", size, reg_names [REGNO (base)]);
5028           break;
5029         case PRE_INC:
5030         case POST_INC:
5031           base = XEXP (XEXP (x, 0), 0);
5032           fprintf (file, "%d(%s)", size, reg_names [REGNO (base)]);
5033           break;
5034         case PLUS:
5035           if (GET_CODE (XEXP (XEXP (x, 0), 0)) == MULT)
5036             fprintf (file, "%s(%s)",
5037                      reg_names [REGNO (XEXP (XEXP (XEXP (x, 0), 0), 0))],
5038                      reg_names [REGNO (XEXP (XEXP (x, 0), 1))]);
5039           else if (GET_CODE (XEXP (XEXP (x, 0), 1)) == MULT)
5040             fprintf (file, "%s(%s)",
5041                      reg_names [REGNO (XEXP (XEXP (XEXP (x, 0), 1), 0))],
5042                      reg_names [REGNO (XEXP (XEXP (x, 0), 0))]);
5043           else if (GET_CODE (XEXP (XEXP (x, 0), 0)) == REG
5044                    && GET_CODE (XEXP (XEXP (x, 0), 1)) == REG)
5045             {
5046               /* Because the REG_POINTER flag can get lost during reload,
5047                  GO_IF_LEGITIMATE_ADDRESS canonicalizes the order of the
5048                  index and base registers in the combined move patterns.  */
5049               rtx base = XEXP (XEXP (x, 0), 1);
5050               rtx index = XEXP (XEXP (x, 0), 0);
5051
5052               fprintf (file, "%s(%s)",
5053                        reg_names [REGNO (index)], reg_names [REGNO (base)]);
5054             }
5055           else
5056             output_address (XEXP (x, 0));
5057           break;
5058         default:
5059           output_address (XEXP (x, 0));
5060           break;
5061         }
5062     }
5063   else
5064     output_addr_const (file, x);
5065 }
5066
5067 /* output a SYMBOL_REF or a CONST expression involving a SYMBOL_REF.  */
5068
5069 void
5070 output_global_address (FILE *file, rtx x, int round_constant)
5071 {
5072
5073   /* Imagine  (high (const (plus ...))).  */
5074   if (GET_CODE (x) == HIGH)
5075     x = XEXP (x, 0);
5076
5077   if (GET_CODE (x) == SYMBOL_REF && read_only_operand (x, VOIDmode))
5078     output_addr_const (file, x);
5079   else if (GET_CODE (x) == SYMBOL_REF && !flag_pic)
5080     {
5081       output_addr_const (file, x);
5082       fputs ("-$global$", file);
5083     }
5084   else if (GET_CODE (x) == CONST)
5085     {
5086       const char *sep = "";
5087       int offset = 0;           /* assembler wants -$global$ at end */
5088       rtx base = NULL_RTX;
5089
5090       switch (GET_CODE (XEXP (XEXP (x, 0), 0)))
5091         {
5092         case SYMBOL_REF:
5093           base = XEXP (XEXP (x, 0), 0);
5094           output_addr_const (file, base);
5095           break;
5096         case CONST_INT:
5097           offset = INTVAL (XEXP (XEXP (x, 0), 0));
5098           break;
5099         default:
5100           gcc_unreachable ();
5101         }
5102
5103       switch (GET_CODE (XEXP (XEXP (x, 0), 1)))
5104         {
5105         case SYMBOL_REF:
5106           base = XEXP (XEXP (x, 0), 1);
5107           output_addr_const (file, base);
5108           break;
5109         case CONST_INT:
5110           offset = INTVAL (XEXP (XEXP (x, 0), 1));
5111           break;
5112         default:
5113           gcc_unreachable ();
5114         }
5115
5116       /* How bogus.  The compiler is apparently responsible for
5117          rounding the constant if it uses an LR field selector.
5118
5119          The linker and/or assembler seem a better place since
5120          they have to do this kind of thing already.
5121
5122          If we fail to do this, HP's optimizing linker may eliminate
5123          an addil, but not update the ldw/stw/ldo instruction that
5124          uses the result of the addil.  */
5125       if (round_constant)
5126         offset = ((offset + 0x1000) & ~0x1fff);
5127
5128       switch (GET_CODE (XEXP (x, 0)))
5129         {
5130         case PLUS:
5131           if (offset < 0)
5132             {
5133               offset = -offset;
5134               sep = "-";
5135             }
5136           else
5137             sep = "+";
5138           break;
5139
5140         case MINUS:
5141           gcc_assert (GET_CODE (XEXP (XEXP (x, 0), 0)) == SYMBOL_REF);
5142           sep = "-";
5143           break;
5144
5145         default:
5146           gcc_unreachable ();
5147         }
5148
5149       if (!read_only_operand (base, VOIDmode) && !flag_pic)
5150         fputs ("-$global$", file);
5151       if (offset)
5152         fprintf (file, "%s%d", sep, offset);
5153     }
5154   else
5155     output_addr_const (file, x);
5156 }
5157
5158 /* Output boilerplate text to appear at the beginning of the file.
5159    There are several possible versions.  */
5160 #define aputs(x) fputs(x, asm_out_file)
5161 static inline void
5162 pa_file_start_level (void)
5163 {
5164   if (TARGET_64BIT)
5165     aputs ("\t.LEVEL 2.0w\n");
5166   else if (TARGET_PA_20)
5167     aputs ("\t.LEVEL 2.0\n");
5168   else if (TARGET_PA_11)
5169     aputs ("\t.LEVEL 1.1\n");
5170   else
5171     aputs ("\t.LEVEL 1.0\n");
5172 }
5173
5174 static inline void
5175 pa_file_start_space (int sortspace)
5176 {
5177   aputs ("\t.SPACE $PRIVATE$");
5178   if (sortspace)
5179     aputs (",SORT=16");
5180   aputs ("\n\t.SUBSPA $DATA$,QUAD=1,ALIGN=8,ACCESS=31"
5181          "\n\t.SUBSPA $BSS$,QUAD=1,ALIGN=8,ACCESS=31,ZERO,SORT=82"
5182          "\n\t.SPACE $TEXT$");
5183   if (sortspace)
5184     aputs (",SORT=8");
5185   aputs ("\n\t.SUBSPA $LIT$,QUAD=0,ALIGN=8,ACCESS=44"
5186          "\n\t.SUBSPA $CODE$,QUAD=0,ALIGN=8,ACCESS=44,CODE_ONLY\n");
5187 }
5188
5189 static inline void
5190 pa_file_start_file (int want_version)
5191 {
5192   if (write_symbols != NO_DEBUG)
5193     {
5194       output_file_directive (asm_out_file, main_input_filename);
5195       if (want_version)
5196         aputs ("\t.version\t\"01.01\"\n");
5197     }
5198 }
5199
5200 static inline void
5201 pa_file_start_mcount (const char *aswhat)
5202 {
5203   if (profile_flag)
5204     fprintf (asm_out_file, "\t.IMPORT _mcount,%s\n", aswhat);
5205 }
5206
5207 static void
5208 pa_elf_file_start (void)
5209 {
5210   pa_file_start_level ();
5211   pa_file_start_mcount ("ENTRY");
5212   pa_file_start_file (0);
5213 }
5214
5215 static void
5216 pa_som_file_start (void)
5217 {
5218   pa_file_start_level ();
5219   pa_file_start_space (0);
5220   aputs ("\t.IMPORT $global$,DATA\n"
5221          "\t.IMPORT $$dyncall,MILLICODE\n");
5222   pa_file_start_mcount ("CODE");
5223   pa_file_start_file (0);
5224 }
5225
5226 static void
5227 pa_linux_file_start (void)
5228 {
5229   pa_file_start_file (1);
5230   pa_file_start_level ();
5231   pa_file_start_mcount ("CODE");
5232 }
5233
5234 static void
5235 pa_hpux64_gas_file_start (void)
5236 {
5237   pa_file_start_level ();
5238 #ifdef ASM_OUTPUT_TYPE_DIRECTIVE
5239   if (profile_flag)
5240     ASM_OUTPUT_TYPE_DIRECTIVE (asm_out_file, "_mcount", "function");
5241 #endif
5242   pa_file_start_file (1);
5243 }
5244
5245 static void
5246 pa_hpux64_hpas_file_start (void)
5247 {
5248   pa_file_start_level ();
5249   pa_file_start_space (1);
5250   pa_file_start_mcount ("CODE");
5251   pa_file_start_file (0);
5252 }
5253 #undef aputs
5254
5255 /* Search the deferred plabel list for SYMBOL and return its internal
5256    label.  If an entry for SYMBOL is not found, a new entry is created.  */
5257
5258 rtx
5259 get_deferred_plabel (rtx symbol)
5260 {
5261   const char *fname = XSTR (symbol, 0);
5262   size_t i;
5263
5264   /* See if we have already put this function on the list of deferred
5265      plabels.  This list is generally small, so a liner search is not
5266      too ugly.  If it proves too slow replace it with something faster.  */
5267   for (i = 0; i < n_deferred_plabels; i++)
5268     if (strcmp (fname, XSTR (deferred_plabels[i].symbol, 0)) == 0)
5269       break;
5270
5271   /* If the deferred plabel list is empty, or this entry was not found
5272      on the list, create a new entry on the list.  */
5273   if (deferred_plabels == NULL || i == n_deferred_plabels)
5274     {
5275       tree id;
5276
5277       if (deferred_plabels == 0)
5278         deferred_plabels = (struct deferred_plabel *)
5279           ggc_alloc (sizeof (struct deferred_plabel));
5280       else
5281         deferred_plabels = (struct deferred_plabel *)
5282           ggc_realloc (deferred_plabels,
5283                        ((n_deferred_plabels + 1)
5284                         * sizeof (struct deferred_plabel)));
5285
5286       i = n_deferred_plabels++;
5287       deferred_plabels[i].internal_label = gen_label_rtx ();
5288       deferred_plabels[i].symbol = symbol;
5289
5290       /* Gross.  We have just implicitly taken the address of this
5291          function.  Mark it in the same manner as assemble_name.  */
5292       id = maybe_get_identifier (targetm.strip_name_encoding (fname));
5293       if (id)
5294         mark_referenced (id);
5295     }
5296
5297   return deferred_plabels[i].internal_label;
5298 }
5299
5300 static void
5301 output_deferred_plabels (void)
5302 {
5303   size_t i;
5304
5305   /* If we have some deferred plabels, then we need to switch into the
5306      data or readonly data section, and align it to a 4 byte boundary
5307      before outputting the deferred plabels.  */
5308   if (n_deferred_plabels)
5309     {
5310       switch_to_section (flag_pic ? data_section : readonly_data_section);
5311       ASM_OUTPUT_ALIGN (asm_out_file, TARGET_64BIT ? 3 : 2);
5312     }
5313
5314   /* Now output the deferred plabels.  */
5315   for (i = 0; i < n_deferred_plabels; i++)
5316     {
5317       (*targetm.asm_out.internal_label) (asm_out_file, "L",
5318                  CODE_LABEL_NUMBER (deferred_plabels[i].internal_label));
5319       assemble_integer (deferred_plabels[i].symbol,
5320                         TARGET_64BIT ? 8 : 4, TARGET_64BIT ? 64 : 32, 1);
5321     }
5322 }
5323
5324 #ifdef HPUX_LONG_DOUBLE_LIBRARY
5325 /* Initialize optabs to point to HPUX long double emulation routines.  */
5326 static void
5327 pa_hpux_init_libfuncs (void)
5328 {
5329   set_optab_libfunc (add_optab, TFmode, "_U_Qfadd");
5330   set_optab_libfunc (sub_optab, TFmode, "_U_Qfsub");
5331   set_optab_libfunc (smul_optab, TFmode, "_U_Qfmpy");
5332   set_optab_libfunc (sdiv_optab, TFmode, "_U_Qfdiv");
5333   set_optab_libfunc (smin_optab, TFmode, "_U_Qmin");
5334   set_optab_libfunc (smax_optab, TFmode, "_U_Qfmax");
5335   set_optab_libfunc (sqrt_optab, TFmode, "_U_Qfsqrt");
5336   set_optab_libfunc (abs_optab, TFmode, "_U_Qfabs");
5337   set_optab_libfunc (neg_optab, TFmode, "_U_Qfneg");
5338
5339   set_optab_libfunc (eq_optab, TFmode, "_U_Qfeq");
5340   set_optab_libfunc (ne_optab, TFmode, "_U_Qfne");
5341   set_optab_libfunc (gt_optab, TFmode, "_U_Qfgt");
5342   set_optab_libfunc (ge_optab, TFmode, "_U_Qfge");
5343   set_optab_libfunc (lt_optab, TFmode, "_U_Qflt");
5344   set_optab_libfunc (le_optab, TFmode, "_U_Qfle");
5345   set_optab_libfunc (unord_optab, TFmode, "_U_Qfunord");
5346
5347   set_conv_libfunc (sext_optab,   TFmode, SFmode, "_U_Qfcnvff_sgl_to_quad");
5348   set_conv_libfunc (sext_optab,   TFmode, DFmode, "_U_Qfcnvff_dbl_to_quad");
5349   set_conv_libfunc (trunc_optab,  SFmode, TFmode, "_U_Qfcnvff_quad_to_sgl");
5350   set_conv_libfunc (trunc_optab,  DFmode, TFmode, "_U_Qfcnvff_quad_to_dbl");
5351
5352   set_conv_libfunc (sfix_optab,   SImode, TFmode, TARGET_64BIT
5353                                                   ? "__U_Qfcnvfxt_quad_to_sgl"
5354                                                   : "_U_Qfcnvfxt_quad_to_sgl");
5355   set_conv_libfunc (sfix_optab,   DImode, TFmode, "_U_Qfcnvfxt_quad_to_dbl");
5356   set_conv_libfunc (ufix_optab,   SImode, TFmode, "_U_Qfcnvfxt_quad_to_usgl");
5357   set_conv_libfunc (ufix_optab,   DImode, TFmode, "_U_Qfcnvfxt_quad_to_udbl");
5358
5359   set_conv_libfunc (sfloat_optab, TFmode, SImode, "_U_Qfcnvxf_sgl_to_quad");
5360   set_conv_libfunc (sfloat_optab, TFmode, DImode, "_U_Qfcnvxf_dbl_to_quad");
5361   set_conv_libfunc (ufloat_optab, TFmode, SImode, "_U_Qfcnvxf_usgl_to_quad");
5362   set_conv_libfunc (ufloat_optab, TFmode, DImode, "_U_Qfcnvxf_udbl_to_quad");
5363 }
5364 #endif
5365
5366 /* HP's millicode routines mean something special to the assembler.
5367    Keep track of which ones we have used.  */
5368
5369 enum millicodes { remI, remU, divI, divU, mulI, end1000 };
5370 static void import_milli (enum millicodes);
5371 static char imported[(int) end1000];
5372 static const char * const milli_names[] = {"remI", "remU", "divI", "divU", "mulI"};
5373 static const char import_string[] = ".IMPORT $$....,MILLICODE";
5374 #define MILLI_START 10
5375
5376 static void
5377 import_milli (enum millicodes code)
5378 {
5379   char str[sizeof (import_string)];
5380
5381   if (!imported[(int) code])
5382     {
5383       imported[(int) code] = 1;
5384       strcpy (str, import_string);
5385       strncpy (str + MILLI_START, milli_names[(int) code], 4);
5386       output_asm_insn (str, 0);
5387     }
5388 }
5389
5390 /* The register constraints have put the operands and return value in
5391    the proper registers.  */
5392
5393 const char *
5394 output_mul_insn (int unsignedp ATTRIBUTE_UNUSED, rtx insn)
5395 {
5396   import_milli (mulI);
5397   return output_millicode_call (insn, gen_rtx_SYMBOL_REF (Pmode, "$$mulI"));
5398 }
5399
5400 /* Emit the rtl for doing a division by a constant.  */
5401
5402 /* Do magic division millicodes exist for this value? */
5403 const int magic_milli[]= {0, 0, 0, 1, 0, 1, 1, 1, 0, 1, 1, 0, 1, 0, 1, 1};
5404
5405 /* We'll use an array to keep track of the magic millicodes and
5406    whether or not we've used them already. [n][0] is signed, [n][1] is
5407    unsigned.  */
5408
5409 static int div_milli[16][2];
5410
5411 int
5412 emit_hpdiv_const (rtx *operands, int unsignedp)
5413 {
5414   if (GET_CODE (operands[2]) == CONST_INT
5415       && INTVAL (operands[2]) > 0
5416       && INTVAL (operands[2]) < 16
5417       && magic_milli[INTVAL (operands[2])])
5418     {
5419       rtx ret = gen_rtx_REG (SImode, TARGET_64BIT ? 2 : 31);
5420
5421       emit_move_insn (gen_rtx_REG (SImode, 26), operands[1]);
5422       emit
5423         (gen_rtx_PARALLEL
5424          (VOIDmode,
5425           gen_rtvec (6, gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, 29),
5426                                      gen_rtx_fmt_ee (unsignedp ? UDIV : DIV,
5427                                                      SImode,
5428                                                      gen_rtx_REG (SImode, 26),
5429                                                      operands[2])),
5430                      gen_rtx_CLOBBER (VOIDmode, operands[4]),
5431                      gen_rtx_CLOBBER (VOIDmode, operands[3]),
5432                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, 26)),
5433                      gen_rtx_CLOBBER (VOIDmode, gen_rtx_REG (SImode, 25)),
5434                      gen_rtx_CLOBBER (VOIDmode, ret))));
5435       emit_move_insn (operands[0], gen_rtx_REG (SImode, 29));
5436       return 1;
5437     }
5438   return 0;
5439 }
5440
5441 const char *
5442 output_div_insn (rtx *operands, int unsignedp, rtx insn)
5443 {
5444   int divisor;
5445
5446   /* If the divisor is a constant, try to use one of the special
5447      opcodes .*/
5448   if (GET_CODE (operands[0]) == CONST_INT)
5449     {
5450       static char buf[100];
5451       divisor = INTVAL (operands[0]);
5452       if (!div_milli[divisor][unsignedp])
5453         {
5454           div_milli[divisor][unsignedp] = 1;
5455           if (unsignedp)
5456             output_asm_insn (".IMPORT $$divU_%0,MILLICODE", operands);
5457           else
5458             output_asm_insn (".IMPORT $$divI_%0,MILLICODE", operands);
5459         }
5460       if (unsignedp)
5461         {
5462           sprintf (buf, "$$divU_" HOST_WIDE_INT_PRINT_DEC,
5463                    INTVAL (operands[0]));
5464           return output_millicode_call (insn,
5465                                         gen_rtx_SYMBOL_REF (SImode, buf));
5466         }
5467       else
5468         {
5469           sprintf (buf, "$$divI_" HOST_WIDE_INT_PRINT_DEC,
5470                    INTVAL (operands[0]));
5471           return output_millicode_call (insn,
5472                                         gen_rtx_SYMBOL_REF (SImode, buf));
5473         }
5474     }
5475   /* Divisor isn't a special constant.  */
5476   else
5477     {
5478       if (unsignedp)
5479         {
5480           import_milli (divU);
5481           return output_millicode_call (insn,
5482                                         gen_rtx_SYMBOL_REF (SImode, "$$divU"));
5483         }
5484       else
5485         {
5486           import_milli (divI);
5487           return output_millicode_call (insn,
5488                                         gen_rtx_SYMBOL_REF (SImode, "$$divI"));
5489         }
5490     }
5491 }
5492
5493 /* Output a $$rem millicode to do mod.  */
5494
5495 const char *
5496 output_mod_insn (int unsignedp, rtx insn)
5497 {
5498   if (unsignedp)
5499     {
5500       import_milli (remU);
5501       return output_millicode_call (insn,
5502                                     gen_rtx_SYMBOL_REF (SImode, "$$remU"));
5503     }
5504   else
5505     {
5506       import_milli (remI);
5507       return output_millicode_call (insn,
5508                                     gen_rtx_SYMBOL_REF (SImode, "$$remI"));
5509     }
5510 }
5511
5512 void
5513 output_arg_descriptor (rtx call_insn)
5514 {
5515   const char *arg_regs[4];
5516   enum machine_mode arg_mode;
5517   rtx link;
5518   int i, output_flag = 0;
5519   int regno;
5520
5521   /* We neither need nor want argument location descriptors for the
5522      64bit runtime environment or the ELF32 environment.  */
5523   if (TARGET_64BIT || TARGET_ELF32)
5524     return;
5525
5526   for (i = 0; i < 4; i++)
5527     arg_regs[i] = 0;
5528
5529   /* Specify explicitly that no argument relocations should take place
5530      if using the portable runtime calling conventions.  */
5531   if (TARGET_PORTABLE_RUNTIME)
5532     {
5533       fputs ("\t.CALL ARGW0=NO,ARGW1=NO,ARGW2=NO,ARGW3=NO,RETVAL=NO\n",
5534              asm_out_file);
5535       return;
5536     }
5537
5538   gcc_assert (GET_CODE (call_insn) == CALL_INSN);
5539   for (link = CALL_INSN_FUNCTION_USAGE (call_insn);
5540        link; link = XEXP (link, 1))
5541     {
5542       rtx use = XEXP (link, 0);
5543
5544       if (! (GET_CODE (use) == USE
5545              && GET_CODE (XEXP (use, 0)) == REG
5546              && FUNCTION_ARG_REGNO_P (REGNO (XEXP (use, 0)))))
5547         continue;
5548
5549       arg_mode = GET_MODE (XEXP (use, 0));
5550       regno = REGNO (XEXP (use, 0));
5551       if (regno >= 23 && regno <= 26)
5552         {
5553           arg_regs[26 - regno] = "GR";
5554           if (arg_mode == DImode)
5555             arg_regs[25 - regno] = "GR";
5556         }
5557       else if (regno >= 32 && regno <= 39)
5558         {
5559           if (arg_mode == SFmode)
5560             arg_regs[(regno - 32) / 2] = "FR";
5561           else
5562             {
5563 #ifndef HP_FP_ARG_DESCRIPTOR_REVERSED
5564               arg_regs[(regno - 34) / 2] = "FR";
5565               arg_regs[(regno - 34) / 2 + 1] = "FU";
5566 #else
5567               arg_regs[(regno - 34) / 2] = "FU";
5568               arg_regs[(regno - 34) / 2 + 1] = "FR";
5569 #endif
5570             }
5571         }
5572     }
5573   fputs ("\t.CALL ", asm_out_file);
5574   for (i = 0; i < 4; i++)
5575     {
5576       if (arg_regs[i])
5577         {
5578           if (output_flag++)
5579             fputc (',', asm_out_file);
5580           fprintf (asm_out_file, "ARGW%d=%s", i, arg_regs[i]);
5581         }
5582     }
5583   fputc ('\n', asm_out_file);
5584 }
5585 \f
5586 static enum reg_class
5587 pa_secondary_reload (bool in_p, rtx x, enum reg_class class,
5588                      enum machine_mode mode, secondary_reload_info *sri)
5589 {
5590   int is_symbolic, regno;
5591
5592   /* Handle the easy stuff first.  */
5593   if (class == R1_REGS)
5594     return NO_REGS;
5595
5596   if (REG_P (x))
5597     {
5598       regno = REGNO (x);
5599       if (class == BASE_REG_CLASS && regno < FIRST_PSEUDO_REGISTER)
5600         return NO_REGS;
5601     }
5602   else
5603     regno = -1;
5604
5605   /* If we have something like (mem (mem (...)), we can safely assume the
5606      inner MEM will end up in a general register after reloading, so there's
5607      no need for a secondary reload.  */
5608   if (GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) == MEM)
5609     return NO_REGS;
5610
5611   /* Trying to load a constant into a FP register during PIC code
5612      generation requires %r1 as a scratch register.  */
5613   if (flag_pic
5614       && GET_MODE_CLASS (mode) == MODE_INT
5615       && FP_REG_CLASS_P (class)
5616       && (GET_CODE (x) == CONST_INT || GET_CODE (x) == CONST_DOUBLE))
5617     {
5618       gcc_assert (mode == SImode || mode == DImode);
5619       sri->icode = (mode == SImode ? CODE_FOR_reload_insi_r1
5620                     : CODE_FOR_reload_indi_r1);
5621       return NO_REGS;
5622     }
5623
5624   /* Profiling showed the PA port spends about 1.3% of its compilation
5625      time in true_regnum from calls inside pa_secondary_reload_class.  */
5626   if (regno >= FIRST_PSEUDO_REGISTER || GET_CODE (x) == SUBREG)
5627     regno = true_regnum (x);
5628
5629   /* Handle out of range displacement for integer mode loads/stores of
5630      FP registers.  */
5631   if (((regno >= FIRST_PSEUDO_REGISTER || regno == -1)
5632        && GET_MODE_CLASS (mode) == MODE_INT
5633        && FP_REG_CLASS_P (class))
5634       || (class == SHIFT_REGS && (regno <= 0 || regno >= 32)))
5635     {
5636       sri->icode = in_p ? reload_in_optab[mode] : reload_out_optab[mode];
5637       return NO_REGS;
5638     }
5639
5640   /* A SAR<->FP register copy requires a secondary register (GPR) as
5641      well as secondary memory.  */
5642   if (regno >= 0 && regno < FIRST_PSEUDO_REGISTER
5643       && ((REGNO_REG_CLASS (regno) == SHIFT_REGS && FP_REG_CLASS_P (class))
5644           || (class == SHIFT_REGS
5645               && FP_REG_CLASS_P (REGNO_REG_CLASS (regno)))))
5646     {
5647       sri->icode = in_p ? reload_in_optab[mode] : reload_out_optab[mode];
5648       return NO_REGS;
5649     }
5650
5651   /* Secondary reloads of symbolic operands require %r1 as a scratch
5652      register when we're generating PIC code and the operand isn't
5653      readonly.  */
5654   if (GET_CODE (x) == HIGH)
5655     x = XEXP (x, 0);
5656
5657   /* Profiling has showed GCC spends about 2.6% of its compilation
5658      time in symbolic_operand from calls inside pa_secondary_reload_class.
5659      So, we use an inline copy to avoid useless work.  */
5660   switch (GET_CODE (x))
5661     {
5662       rtx op;
5663
5664       case SYMBOL_REF:
5665         is_symbolic = !SYMBOL_REF_TLS_MODEL (x);
5666         break;
5667       case LABEL_REF:
5668         is_symbolic = 1;
5669         break;
5670       case CONST:
5671         op = XEXP (x, 0);
5672         is_symbolic = (((GET_CODE (XEXP (op, 0)) == SYMBOL_REF
5673                          && !SYMBOL_REF_TLS_MODEL (XEXP (op, 0)))
5674                         || GET_CODE (XEXP (op, 0)) == LABEL_REF)
5675                        && GET_CODE (XEXP (op, 1)) == CONST_INT);
5676         break;
5677       default:
5678         is_symbolic = 0;
5679         break;
5680     }
5681
5682   if (is_symbolic && (flag_pic || !read_only_operand (x, VOIDmode)))
5683     {
5684       gcc_assert (mode == SImode || mode == DImode);
5685       sri->icode = (mode == SImode ? CODE_FOR_reload_insi_r1
5686                     : CODE_FOR_reload_indi_r1);
5687     }
5688
5689   return NO_REGS;
5690 }
5691
5692 /* In the 32-bit runtime, arguments larger than eight bytes are passed
5693    by invisible reference.  As a GCC extension, we also pass anything
5694    with a zero or variable size by reference.
5695
5696    The 64-bit runtime does not describe passing any types by invisible
5697    reference.  The internals of GCC can't currently handle passing
5698    empty structures, and zero or variable length arrays when they are
5699    not passed entirely on the stack or by reference.  Thus, as a GCC
5700    extension, we pass these types by reference.  The HP compiler doesn't
5701    support these types, so hopefully there shouldn't be any compatibility
5702    issues.  This may have to be revisited when HP releases a C99 compiler
5703    or updates the ABI.  */
5704
5705 static bool
5706 pa_pass_by_reference (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED,
5707                       enum machine_mode mode, tree type,
5708                       bool named ATTRIBUTE_UNUSED)
5709 {
5710   HOST_WIDE_INT size;
5711
5712   if (type)
5713     size = int_size_in_bytes (type);
5714   else
5715     size = GET_MODE_SIZE (mode);
5716
5717   if (TARGET_64BIT)
5718     return size <= 0;
5719   else
5720     return size <= 0 || size > 8;
5721 }
5722
5723 enum direction
5724 function_arg_padding (enum machine_mode mode, tree type)
5725 {
5726   if (mode == BLKmode
5727       || (TARGET_64BIT && type && AGGREGATE_TYPE_P (type)))
5728     {
5729       /* Return none if justification is not required.  */
5730       if (type
5731           && TREE_CODE (TYPE_SIZE (type)) == INTEGER_CST
5732           && (int_size_in_bytes (type) * BITS_PER_UNIT) % PARM_BOUNDARY == 0)
5733         return none;
5734
5735       /* The directions set here are ignored when a BLKmode argument larger
5736          than a word is placed in a register.  Different code is used for
5737          the stack and registers.  This makes it difficult to have a
5738          consistent data representation for both the stack and registers.
5739          For both runtimes, the justification and padding for arguments on
5740          the stack and in registers should be identical.  */
5741       if (TARGET_64BIT)
5742         /* The 64-bit runtime specifies left justification for aggregates.  */
5743         return upward;
5744       else
5745         /* The 32-bit runtime architecture specifies right justification.
5746            When the argument is passed on the stack, the argument is padded
5747            with garbage on the left.  The HP compiler pads with zeros.  */
5748         return downward;
5749     }
5750
5751   if (GET_MODE_BITSIZE (mode) < PARM_BOUNDARY)
5752     return downward;
5753   else
5754     return none;
5755 }
5756
5757 \f
5758 /* Do what is necessary for `va_start'.  We look at the current function
5759    to determine if stdargs or varargs is used and fill in an initial
5760    va_list.  A pointer to this constructor is returned.  */
5761
5762 static rtx
5763 hppa_builtin_saveregs (void)
5764 {
5765   rtx offset, dest;
5766   tree fntype = TREE_TYPE (current_function_decl);
5767   int argadj = ((!(TYPE_ARG_TYPES (fntype) != 0
5768                    && (TREE_VALUE (tree_last (TYPE_ARG_TYPES (fntype)))
5769                        != void_type_node)))
5770                 ? UNITS_PER_WORD : 0);
5771
5772   if (argadj)
5773     offset = plus_constant (current_function_arg_offset_rtx, argadj);
5774   else
5775     offset = current_function_arg_offset_rtx;
5776
5777   if (TARGET_64BIT)
5778     {
5779       int i, off;
5780
5781       /* Adjust for varargs/stdarg differences.  */
5782       if (argadj)
5783         offset = plus_constant (current_function_arg_offset_rtx, -argadj);
5784       else
5785         offset = current_function_arg_offset_rtx;
5786
5787       /* We need to save %r26 .. %r19 inclusive starting at offset -64
5788          from the incoming arg pointer and growing to larger addresses.  */
5789       for (i = 26, off = -64; i >= 19; i--, off += 8)
5790         emit_move_insn (gen_rtx_MEM (word_mode,
5791                                      plus_constant (arg_pointer_rtx, off)),
5792                         gen_rtx_REG (word_mode, i));
5793
5794       /* The incoming args pointer points just beyond the flushback area;
5795          normally this is not a serious concern.  However, when we are doing
5796          varargs/stdargs we want to make the arg pointer point to the start
5797          of the incoming argument area.  */
5798       emit_move_insn (virtual_incoming_args_rtx,
5799                       plus_constant (arg_pointer_rtx, -64));
5800
5801       /* Now return a pointer to the first anonymous argument.  */
5802       return copy_to_reg (expand_binop (Pmode, add_optab,
5803                                         virtual_incoming_args_rtx,
5804                                         offset, 0, 0, OPTAB_LIB_WIDEN));
5805     }
5806
5807   /* Store general registers on the stack.  */
5808   dest = gen_rtx_MEM (BLKmode,
5809                       plus_constant (current_function_internal_arg_pointer,
5810                                      -16));
5811   set_mem_alias_set (dest, get_varargs_alias_set ());
5812   set_mem_align (dest, BITS_PER_WORD);
5813   move_block_from_reg (23, dest, 4);
5814
5815   /* move_block_from_reg will emit code to store the argument registers
5816      individually as scalar stores.
5817
5818      However, other insns may later load from the same addresses for
5819      a structure load (passing a struct to a varargs routine).
5820
5821      The alias code assumes that such aliasing can never happen, so we
5822      have to keep memory referencing insns from moving up beyond the
5823      last argument register store.  So we emit a blockage insn here.  */
5824   emit_insn (gen_blockage ());
5825
5826   return copy_to_reg (expand_binop (Pmode, add_optab,
5827                                     current_function_internal_arg_pointer,
5828                                     offset, 0, 0, OPTAB_LIB_WIDEN));
5829 }
5830
5831 void
5832 hppa_va_start (tree valist, rtx nextarg)
5833 {
5834   nextarg = expand_builtin_saveregs ();
5835   std_expand_builtin_va_start (valist, nextarg);
5836 }
5837
5838 static tree
5839 hppa_gimplify_va_arg_expr (tree valist, tree type, tree *pre_p, tree *post_p)
5840 {
5841   if (TARGET_64BIT)
5842     {
5843       /* Args grow upward.  We can use the generic routines.  */
5844       return std_gimplify_va_arg_expr (valist, type, pre_p, post_p);
5845     }
5846   else /* !TARGET_64BIT */
5847     {
5848       tree ptr = build_pointer_type (type);
5849       tree valist_type;
5850       tree t, u;
5851       unsigned int size, ofs;
5852       bool indirect;
5853
5854       indirect = pass_by_reference (NULL, TYPE_MODE (type), type, 0);
5855       if (indirect)
5856         {
5857           type = ptr;
5858           ptr = build_pointer_type (type);
5859         }
5860       size = int_size_in_bytes (type);
5861       valist_type = TREE_TYPE (valist);
5862
5863       /* Args grow down.  Not handled by generic routines.  */
5864
5865       u = fold_convert (valist_type, size_in_bytes (type));
5866       t = build2 (MINUS_EXPR, valist_type, valist, u);
5867
5868       /* Copied from va-pa.h, but we probably don't need to align to
5869          word size, since we generate and preserve that invariant.  */
5870       u = build_int_cst (valist_type, (size > 4 ? -8 : -4));
5871       t = build2 (BIT_AND_EXPR, valist_type, t, u);
5872
5873       t = build2 (MODIFY_EXPR, valist_type, valist, t);
5874
5875       ofs = (8 - size) % 4;
5876       if (ofs != 0)
5877         {
5878           u = fold_convert (valist_type, size_int (ofs));
5879           t = build2 (PLUS_EXPR, valist_type, t, u);
5880         }
5881
5882       t = fold_convert (ptr, t);
5883       t = build_va_arg_indirect_ref (t);
5884
5885       if (indirect)
5886         t = build_va_arg_indirect_ref (t);
5887
5888       return t;
5889     }
5890 }
5891
5892 /* True if MODE is valid for the target.  By "valid", we mean able to
5893    be manipulated in non-trivial ways.  In particular, this means all
5894    the arithmetic is supported.
5895
5896    Currently, TImode is not valid as the HP 64-bit runtime documentation
5897    doesn't document the alignment and calling conventions for this type.
5898    Thus, we return false when PRECISION is 2 * BITS_PER_WORD and
5899    2 * BITS_PER_WORD isn't equal LONG_LONG_TYPE_SIZE.  */
5900
5901 static bool
5902 pa_scalar_mode_supported_p (enum machine_mode mode)
5903 {
5904   int precision = GET_MODE_PRECISION (mode);
5905
5906   switch (GET_MODE_CLASS (mode))
5907     {
5908     case MODE_PARTIAL_INT:
5909     case MODE_INT:
5910       if (precision == CHAR_TYPE_SIZE)
5911         return true;
5912       if (precision == SHORT_TYPE_SIZE)
5913         return true;
5914       if (precision == INT_TYPE_SIZE)
5915         return true;
5916       if (precision == LONG_TYPE_SIZE)
5917         return true;
5918       if (precision == LONG_LONG_TYPE_SIZE)
5919         return true;
5920       return false;
5921
5922     case MODE_FLOAT:
5923       if (precision == FLOAT_TYPE_SIZE)
5924         return true;
5925       if (precision == DOUBLE_TYPE_SIZE)
5926         return true;
5927       if (precision == LONG_DOUBLE_TYPE_SIZE)
5928         return true;
5929       return false;
5930
5931     case MODE_DECIMAL_FLOAT:
5932       return false;
5933
5934     default:
5935       gcc_unreachable ();
5936     }
5937 }
5938
5939 /* This routine handles all the normal conditional branch sequences we
5940    might need to generate.  It handles compare immediate vs compare
5941    register, nullification of delay slots, varying length branches,
5942    negated branches, and all combinations of the above.  It returns the
5943    output appropriate to emit the branch corresponding to all given
5944    parameters.  */
5945
5946 const char *
5947 output_cbranch (rtx *operands, int nullify, int length, int negated, rtx insn)
5948 {
5949   static char buf[100];
5950   int useskip = 0;
5951   rtx xoperands[5];
5952
5953   /* A conditional branch to the following instruction (e.g. the delay slot)
5954      is asking for a disaster.  This can happen when not optimizing and
5955      when jump optimization fails.
5956
5957      While it is usually safe to emit nothing, this can fail if the
5958      preceding instruction is a nullified branch with an empty delay
5959      slot and the same branch target as this branch.  We could check
5960      for this but jump optimization should eliminate nop jumps.  It
5961      is always safe to emit a nop.  */
5962   if (next_real_insn (JUMP_LABEL (insn)) == next_real_insn (insn))
5963     return "nop";
5964
5965   /* The doubleword form of the cmpib instruction doesn't have the LEU
5966      and GTU conditions while the cmpb instruction does.  Since we accept
5967      zero for cmpb, we must ensure that we use cmpb for the comparison.  */
5968   if (GET_MODE (operands[1]) == DImode && operands[2] == const0_rtx)
5969     operands[2] = gen_rtx_REG (DImode, 0);
5970   if (GET_MODE (operands[2]) == DImode && operands[1] == const0_rtx)
5971     operands[1] = gen_rtx_REG (DImode, 0);
5972
5973   /* If this is a long branch with its delay slot unfilled, set `nullify'
5974      as it can nullify the delay slot and save a nop.  */
5975   if (length == 8 && dbr_sequence_length () == 0)
5976     nullify = 1;
5977
5978   /* If this is a short forward conditional branch which did not get
5979      its delay slot filled, the delay slot can still be nullified.  */
5980   if (! nullify && length == 4 && dbr_sequence_length () == 0)
5981     nullify = forward_branch_p (insn);
5982
5983   /* A forward branch over a single nullified insn can be done with a
5984      comclr instruction.  This avoids a single cycle penalty due to
5985      mis-predicted branch if we fall through (branch not taken).  */
5986   if (length == 4
5987       && next_real_insn (insn) != 0
5988       && get_attr_length (next_real_insn (insn)) == 4
5989       && JUMP_LABEL (insn) == next_nonnote_insn (next_real_insn (insn))
5990       && nullify)
5991     useskip = 1;
5992
5993   switch (length)
5994     {
5995       /* All short conditional branches except backwards with an unfilled
5996          delay slot.  */
5997       case 4:
5998         if (useskip)
5999           strcpy (buf, "{com%I2clr,|cmp%I2clr,}");
6000         else
6001           strcpy (buf, "{com%I2b,|cmp%I2b,}");
6002         if (GET_MODE (operands[1]) == DImode)
6003           strcat (buf, "*");
6004         if (negated)
6005           strcat (buf, "%B3");
6006         else
6007           strcat (buf, "%S3");
6008         if (useskip)
6009           strcat (buf, " %2,%r1,%%r0");
6010         else if (nullify)
6011           strcat (buf, ",n %2,%r1,%0");
6012         else
6013           strcat (buf, " %2,%r1,%0");
6014         break;
6015
6016      /* All long conditionals.  Note a short backward branch with an
6017         unfilled delay slot is treated just like a long backward branch
6018         with an unfilled delay slot.  */
6019       case 8:
6020         /* Handle weird backwards branch with a filled delay slot
6021            with is nullified.  */
6022         if (dbr_sequence_length () != 0
6023             && ! forward_branch_p (insn)
6024             && nullify)
6025           {
6026             strcpy (buf, "{com%I2b,|cmp%I2b,}");
6027             if (GET_MODE (operands[1]) == DImode)
6028               strcat (buf, "*");
6029             if (negated)
6030               strcat (buf, "%S3");
6031             else
6032               strcat (buf, "%B3");
6033             strcat (buf, ",n %2,%r1,.+12\n\tb %0");
6034           }
6035         /* Handle short backwards branch with an unfilled delay slot.
6036            Using a comb;nop rather than comiclr;bl saves 1 cycle for both
6037            taken and untaken branches.  */
6038         else if (dbr_sequence_length () == 0
6039                  && ! forward_branch_p (insn)
6040                  && INSN_ADDRESSES_SET_P ()
6041                  && VAL_14_BITS_P (INSN_ADDRESSES (INSN_UID (JUMP_LABEL (insn)))
6042                                     - INSN_ADDRESSES (INSN_UID (insn)) - 8))
6043           {
6044             strcpy (buf, "{com%I2b,|cmp%I2b,}");
6045             if (GET_MODE (operands[1]) == DImode)
6046               strcat (buf, "*");
6047             if (negated)
6048               strcat (buf, "%B3 %2,%r1,%0%#");
6049             else
6050               strcat (buf, "%S3 %2,%r1,%0%#");
6051           }
6052         else
6053           {
6054             strcpy (buf, "{com%I2clr,|cmp%I2clr,}");
6055             if (GET_MODE (operands[1]) == DImode)
6056               strcat (buf, "*");
6057             if (negated)
6058               strcat (buf, "%S3");
6059             else
6060               strcat (buf, "%B3");
6061             if (nullify)
6062               strcat (buf, " %2,%r1,%%r0\n\tb,n %0");
6063             else
6064               strcat (buf, " %2,%r1,%%r0\n\tb %0");
6065           }
6066         break;
6067
6068       case 20:
6069       case 28:
6070         xoperands[0] = operands[0];
6071         xoperands[1] = operands[1];
6072         xoperands[2] = operands[2];
6073         xoperands[3] = operands[3];
6074
6075         /* The reversed conditional branch must branch over one additional
6076            instruction if the delay slot is filled.  If the delay slot
6077            is empty, the instruction after the reversed condition branch
6078            must be nullified.  */
6079         nullify = dbr_sequence_length () == 0;
6080         xoperands[4] = nullify ? GEN_INT (length) : GEN_INT (length + 4);
6081
6082         /* Create a reversed conditional branch which branches around
6083            the following insns.  */
6084         if (GET_MODE (operands[1]) != DImode)
6085           {
6086             if (nullify)
6087               {
6088                 if (negated)
6089                   strcpy (buf,
6090                     "{com%I2b,%S3,n %2,%r1,.+%4|cmp%I2b,%S3,n %2,%r1,.+%4}");
6091                 else
6092                   strcpy (buf,
6093                     "{com%I2b,%B3,n %2,%r1,.+%4|cmp%I2b,%B3,n %2,%r1,.+%4}");
6094               }
6095             else
6096               {
6097                 if (negated)
6098                   strcpy (buf,
6099                     "{com%I2b,%S3 %2,%r1,.+%4|cmp%I2b,%S3 %2,%r1,.+%4}");
6100                 else
6101                   strcpy (buf,
6102                     "{com%I2b,%B3 %2,%r1,.+%4|cmp%I2b,%B3 %2,%r1,.+%4}");
6103               }
6104           }
6105         else
6106           {
6107             if (nullify)
6108               {
6109                 if (negated)
6110                   strcpy (buf,
6111                     "{com%I2b,*%S3,n %2,%r1,.+%4|cmp%I2b,*%S3,n %2,%r1,.+%4}");
6112                 else
6113                   strcpy (buf,
6114                     "{com%I2b,*%B3,n %2,%r1,.+%4|cmp%I2b,*%B3,n %2,%r1,.+%4}");
6115               }
6116             else
6117               {
6118                 if (negated)
6119                   strcpy (buf,
6120                     "{com%I2b,*%S3 %2,%r1,.+%4|cmp%I2b,*%S3 %2,%r1,.+%4}");
6121                 else
6122                   strcpy (buf,
6123                     "{com%I2b,*%B3 %2,%r1,.+%4|cmp%I2b,*%B3 %2,%r1,.+%4}");
6124               }
6125           }
6126
6127         output_asm_insn (buf, xoperands);
6128         return output_lbranch (operands[0], insn);
6129
6130       default:
6131         gcc_unreachable ();
6132     }
6133   return buf;
6134 }
6135
6136 /* This routine handles long unconditional branches that exceed the
6137    maximum range of a simple branch instruction.  */
6138
6139 const char *
6140 output_lbranch (rtx dest, rtx insn)
6141 {
6142   rtx xoperands[2];
6143
6144   xoperands[0] = dest;
6145
6146   /* First, free up the delay slot.  */
6147   if (dbr_sequence_length () != 0)
6148     {
6149       /* We can't handle a jump in the delay slot.  */
6150       gcc_assert (GET_CODE (NEXT_INSN (insn)) != JUMP_INSN);
6151
6152       final_scan_insn (NEXT_INSN (insn), asm_out_file,
6153                        optimize, 0, NULL);
6154
6155       /* Now delete the delay insn.  */
6156       PUT_CODE (NEXT_INSN (insn), NOTE);
6157       NOTE_LINE_NUMBER (NEXT_INSN (insn)) = NOTE_INSN_DELETED;
6158       NOTE_SOURCE_FILE (NEXT_INSN (insn)) = 0;
6159     }
6160
6161   /* Output an insn to save %r1.  The runtime documentation doesn't
6162      specify whether the "Clean Up" slot in the callers frame can
6163      be clobbered by the callee.  It isn't copied by HP's builtin
6164      alloca, so this suggests that it can be clobbered if necessary.
6165      The "Static Link" location is copied by HP builtin alloca, so
6166      we avoid using it.  Using the cleanup slot might be a problem
6167      if we have to interoperate with languages that pass cleanup
6168      information.  However, it should be possible to handle these
6169      situations with GCC's asm feature.
6170
6171      The "Current RP" slot is reserved for the called procedure, so
6172      we try to use it when we don't have a frame of our own.  It's
6173      rather unlikely that we won't have a frame when we need to emit
6174      a very long branch.
6175
6176      Really the way to go long term is a register scavenger; goto
6177      the target of the jump and find a register which we can use
6178      as a scratch to hold the value in %r1.  Then, we wouldn't have
6179      to free up the delay slot or clobber a slot that may be needed
6180      for other purposes.  */
6181   if (TARGET_64BIT)
6182     {
6183       if (actual_fsize == 0 && !regs_ever_live[2])
6184         /* Use the return pointer slot in the frame marker.  */
6185         output_asm_insn ("std %%r1,-16(%%r30)", xoperands);
6186       else
6187         /* Use the slot at -40 in the frame marker since HP builtin
6188            alloca doesn't copy it.  */
6189         output_asm_insn ("std %%r1,-40(%%r30)", xoperands);
6190     }
6191   else
6192     {
6193       if (actual_fsize == 0 && !regs_ever_live[2])
6194         /* Use the return pointer slot in the frame marker.  */
6195         output_asm_insn ("stw %%r1,-20(%%r30)", xoperands);
6196       else
6197         /* Use the "Clean Up" slot in the frame marker.  In GCC,
6198            the only other use of this location is for copying a
6199            floating point double argument from a floating-point
6200            register to two general registers.  The copy is done
6201            as an "atomic" operation when outputting a call, so it
6202            won't interfere with our using the location here.  */
6203         output_asm_insn ("stw %%r1,-12(%%r30)", xoperands);
6204     }
6205
6206   if (TARGET_PORTABLE_RUNTIME)
6207     {
6208       output_asm_insn ("ldil L'%0,%%r1", xoperands);
6209       output_asm_insn ("ldo R'%0(%%r1),%%r1", xoperands);
6210       output_asm_insn ("bv %%r0(%%r1)", xoperands);
6211     }
6212   else if (flag_pic)
6213     {
6214       output_asm_insn ("{bl|b,l} .+8,%%r1", xoperands);
6215       if (TARGET_SOM || !TARGET_GAS)
6216         {
6217           xoperands[1] = gen_label_rtx ();
6218           output_asm_insn ("addil L'%l0-%l1,%%r1", xoperands);
6219           (*targetm.asm_out.internal_label) (asm_out_file, "L",
6220                                              CODE_LABEL_NUMBER (xoperands[1]));
6221           output_asm_insn ("ldo R'%l0-%l1(%%r1),%%r1", xoperands);
6222         }
6223       else
6224         {
6225           output_asm_insn ("addil L'%l0-$PIC_pcrel$0+4,%%r1", xoperands);
6226           output_asm_insn ("ldo R'%l0-$PIC_pcrel$0+8(%%r1),%%r1", xoperands);
6227         }
6228       output_asm_insn ("bv %%r0(%%r1)", xoperands);
6229     }
6230   else
6231     /* Now output a very long branch to the original target.  */
6232     output_asm_insn ("ldil L'%l0,%%r1\n\tbe R'%l0(%%sr4,%%r1)", xoperands);
6233
6234   /* Now restore the value of %r1 in the delay slot.  */
6235   if (TARGET_64BIT)
6236     {
6237       if (actual_fsize == 0 && !regs_ever_live[2])
6238         return "ldd -16(%%r30),%%r1";
6239       else
6240         return "ldd -40(%%r30),%%r1";
6241     }
6242   else
6243     {
6244       if (actual_fsize == 0 && !regs_ever_live[2])
6245         return "ldw -20(%%r30),%%r1";
6246       else
6247         return "ldw -12(%%r30),%%r1";
6248     }
6249 }
6250
6251 /* This routine handles all the branch-on-bit conditional branch sequences we
6252    might need to generate.  It handles nullification of delay slots,
6253    varying length branches, negated branches and all combinations of the
6254    above.  it returns the appropriate output template to emit the branch.  */
6255
6256 const char *
6257 output_bb (rtx *operands ATTRIBUTE_UNUSED, int nullify, int length,
6258            int negated, rtx insn, int which)
6259 {
6260   static char buf[100];
6261   int useskip = 0;
6262
6263   /* A conditional branch to the following instruction (e.g. the delay slot) is
6264      asking for a disaster.  I do not think this can happen as this pattern
6265      is only used when optimizing; jump optimization should eliminate the
6266      jump.  But be prepared just in case.  */
6267
6268   if (next_real_insn (JUMP_LABEL (insn)) == next_real_insn (insn))
6269     return "nop";
6270
6271   /* If this is a long branch with its delay slot unfilled, set `nullify'
6272      as it can nullify the delay slot and save a nop.  */
6273   if (length == 8 && dbr_sequence_length () == 0)
6274     nullify = 1;
6275
6276   /* If this is a short forward conditional branch which did not get
6277      its delay slot filled, the delay slot can still be nullified.  */
6278   if (! nullify && length == 4 && dbr_sequence_length () == 0)
6279     nullify = forward_branch_p (insn);
6280
6281   /* A forward branch over a single nullified insn can be done with a
6282      extrs instruction.  This avoids a single cycle penalty due to
6283      mis-predicted branch if we fall through (branch not taken).  */
6284
6285   if (length == 4
6286       && next_real_insn (insn) != 0
6287       && get_attr_length (next_real_insn (insn)) == 4
6288       && JUMP_LABEL (insn) == next_nonnote_insn (next_real_insn (insn))
6289       && nullify)
6290     useskip = 1;
6291
6292   switch (length)
6293     {
6294
6295       /* All short conditional branches except backwards with an unfilled
6296          delay slot.  */
6297       case 4:
6298         if (useskip)
6299           strcpy (buf, "{extrs,|extrw,s,}");
6300         else
6301           strcpy (buf, "bb,");
6302         if (useskip && GET_MODE (operands[0]) == DImode)
6303           strcpy (buf, "extrd,s,*");
6304         else if (GET_MODE (operands[0]) == DImode)
6305           strcpy (buf, "bb,*");
6306         if ((which == 0 && negated)
6307              || (which == 1 && ! negated))
6308           strcat (buf, ">=");
6309         else
6310           strcat (buf, "<");
6311         if (useskip)
6312           strcat (buf, " %0,%1,1,%%r0");
6313         else if (nullify && negated)
6314           strcat (buf, ",n %0,%1,%3");
6315         else if (nullify && ! negated)
6316           strcat (buf, ",n %0,%1,%2");
6317         else if (! nullify && negated)
6318           strcat (buf, "%0,%1,%3");
6319         else if (! nullify && ! negated)
6320           strcat (buf, " %0,%1,%2");
6321         break;
6322
6323      /* All long conditionals.  Note a short backward branch with an
6324         unfilled delay slot is treated just like a long backward branch
6325         with an unfilled delay slot.  */
6326       case 8:
6327         /* Handle weird backwards branch with a filled delay slot
6328            with is nullified.  */
6329         if (dbr_sequence_length () != 0
6330             && ! forward_branch_p (insn)
6331             && nullify)
6332           {
6333             strcpy (buf, "bb,");
6334             if (GET_MODE (operands[0]) == DImode)
6335               strcat (buf, "*");
6336             if ((which == 0 && negated)
6337                 || (which == 1 && ! negated))
6338               strcat (buf, "<");
6339             else
6340               strcat (buf, ">=");
6341             if (negated)
6342               strcat (buf, ",n %0,%1,.+12\n\tb %3");
6343             else
6344               strcat (buf, ",n %0,%1,.+12\n\tb %2");
6345           }
6346         /* Handle short backwards branch with an unfilled delay slot.
6347            Using a bb;nop rather than extrs;bl saves 1 cycle for both
6348            taken and untaken branches.  */
6349         else if (dbr_sequence_length () == 0
6350                  && ! forward_branch_p (insn)
6351                  && INSN_ADDRESSES_SET_P ()
6352                  && VAL_14_BITS_P (INSN_ADDRESSES (INSN_UID (JUMP_LABEL (insn)))
6353                                     - INSN_ADDRESSES (INSN_UID (insn)) - 8))
6354           {
6355             strcpy (buf, "bb,");
6356             if (GET_MODE (operands[0]) == DImode)
6357               strcat (buf, "*");
6358             if ((which == 0 && negated)
6359                 || (which == 1 && ! negated))
6360               strcat (buf, ">=");
6361             else
6362               strcat (buf, "<");
6363             if (negated)
6364               strcat (buf, " %0,%1,%3%#");
6365             else
6366               strcat (buf, " %0,%1,%2%#");
6367           }
6368         else
6369           {
6370             strcpy (buf, "{extrs,|extrw,s,}");
6371             if (GET_MODE (operands[0]) == DImode)
6372               strcpy (buf, "extrd,s,*");
6373             if ((which == 0 && negated)
6374                 || (which == 1 && ! negated))
6375               strcat (buf, "<");
6376             else
6377               strcat (buf, ">=");
6378             if (nullify && negated)
6379               strcat (buf, " %0,%1,1,%%r0\n\tb,n %3");
6380             else if (nullify && ! negated)
6381               strcat (buf, " %0,%1,1,%%r0\n\tb,n %2");
6382             else if (negated)
6383               strcat (buf, " %0,%1,1,%%r0\n\tb %3");
6384             else
6385               strcat (buf, " %0,%1,1,%%r0\n\tb %2");
6386           }
6387         break;
6388
6389       default:
6390         gcc_unreachable ();
6391     }
6392   return buf;
6393 }
6394
6395 /* This routine handles all the branch-on-variable-bit conditional branch
6396    sequences we might need to generate.  It handles nullification of delay
6397    slots, varying length branches, negated branches and all combinations
6398    of the above.  it returns the appropriate output template to emit the
6399    branch.  */
6400
6401 const char *
6402 output_bvb (rtx *operands ATTRIBUTE_UNUSED, int nullify, int length,
6403             int negated, rtx insn, int which)
6404 {
6405   static char buf[100];
6406   int useskip = 0;
6407
6408   /* A conditional branch to the following instruction (e.g. the delay slot) is
6409      asking for a disaster.  I do not think this can happen as this pattern
6410      is only used when optimizing; jump optimization should eliminate the
6411      jump.  But be prepared just in case.  */
6412
6413   if (next_real_insn (JUMP_LABEL (insn)) == next_real_insn (insn))
6414     return "nop";
6415
6416   /* If this is a long branch with its delay slot unfilled, set `nullify'
6417      as it can nullify the delay slot and save a nop.  */
6418   if (length == 8 && dbr_sequence_length () == 0)
6419     nullify = 1;
6420
6421   /* If this is a short forward conditional branch which did not get
6422      its delay slot filled, the delay slot can still be nullified.  */
6423   if (! nullify && length == 4 && dbr_sequence_length () == 0)
6424     nullify = forward_branch_p (insn);
6425
6426   /* A forward branch over a single nullified insn can be done with a
6427      extrs instruction.  This avoids a single cycle penalty due to
6428      mis-predicted branch if we fall through (branch not taken).  */
6429
6430   if (length == 4
6431       && next_real_insn (insn) != 0
6432       && get_attr_length (next_real_insn (insn)) == 4
6433       && JUMP_LABEL (insn) == next_nonnote_insn (next_real_insn (insn))
6434       && nullify)
6435     useskip = 1;
6436
6437   switch (length)
6438     {
6439
6440       /* All short conditional branches except backwards with an unfilled
6441          delay slot.  */
6442       case 4:
6443         if (useskip)
6444           strcpy (buf, "{vextrs,|extrw,s,}");
6445         else
6446           strcpy (buf, "{bvb,|bb,}");
6447         if (useskip && GET_MODE (operands[0]) == DImode)
6448           strcpy (buf, "extrd,s,*");
6449         else if (GET_MODE (operands[0]) == DImode)
6450           strcpy (buf, "bb,*");
6451         if ((which == 0 && negated)
6452              || (which == 1 && ! negated))
6453           strcat (buf, ">=");
6454         else
6455           strcat (buf, "<");
6456         if (useskip)
6457           strcat (buf, "{ %0,1,%%r0| %0,%%sar,1,%%r0}");
6458         else if (nullify && negated)
6459           strcat (buf, "{,n %0,%3|,n %0,%%sar,%3}");
6460         else if (nullify && ! negated)
6461           strcat (buf, "{,n %0,%2|,n %0,%%sar,%2}");
6462         else if (! nullify && negated)
6463           strcat (buf, "{%0,%3|%0,%%sar,%3}");
6464         else if (! nullify && ! negated)
6465           strcat (buf, "{ %0,%2| %0,%%sar,%2}");
6466         break;
6467
6468      /* All long conditionals.  Note a short backward branch with an
6469         unfilled delay slot is treated just like a long backward branch
6470         with an unfilled delay slot.  */
6471       case 8:
6472         /* Handle weird backwards branch with a filled delay slot
6473            with is nullified.  */
6474         if (dbr_sequence_length () != 0
6475             && ! forward_branch_p (insn)
6476             && nullify)
6477           {
6478             strcpy (buf, "{bvb,|bb,}");
6479             if (GET_MODE (operands[0]) == DImode)
6480               strcat (buf, "*");
6481             if ((which == 0 && negated)
6482                 || (which == 1 && ! negated))
6483               strcat (buf, "<");
6484             else
6485               strcat (buf, ">=");
6486             if (negated)
6487               strcat (buf, "{,n %0,.+12\n\tb %3|,n %0,%%sar,.+12\n\tb %3}");
6488             else
6489               strcat (buf, "{,n %0,.+12\n\tb %2|,n %0,%%sar,.+12\n\tb %2}");
6490           }
6491         /* Handle short backwards branch with an unfilled delay slot.
6492            Using a bb;nop rather than extrs;bl saves 1 cycle for both
6493            taken and untaken branches.  */
6494         else if (dbr_sequence_length () == 0
6495                  && ! forward_branch_p (insn)
6496                  && INSN_ADDRESSES_SET_P ()
6497                  && VAL_14_BITS_P (INSN_ADDRESSES (INSN_UID (JUMP_LABEL (insn)))
6498                                     - INSN_ADDRESSES (INSN_UID (insn)) - 8))
6499           {
6500             strcpy (buf, "{bvb,|bb,}");
6501             if (GET_MODE (operands[0]) == DImode)
6502               strcat (buf, "*");
6503             if ((which == 0 && negated)
6504                 || (which == 1 && ! negated))
6505               strcat (buf, ">=");
6506             else
6507               strcat (buf, "<");
6508             if (negated)
6509               strcat (buf, "{ %0,%3%#| %0,%%sar,%3%#}");
6510             else
6511               strcat (buf, "{ %0,%2%#| %0,%%sar,%2%#}");
6512           }
6513         else
6514           {
6515             strcpy (buf, "{vextrs,|extrw,s,}");
6516             if (GET_MODE (operands[0]) == DImode)
6517               strcpy (buf, "extrd,s,*");
6518             if ((which == 0 && negated)
6519                 || (which == 1 && ! negated))
6520               strcat (buf, "<");
6521             else
6522               strcat (buf, ">=");
6523             if (nullify && negated)
6524               strcat (buf, "{ %0,1,%%r0\n\tb,n %3| %0,%%sar,1,%%r0\n\tb,n %3}");
6525             else if (nullify && ! negated)
6526               strcat (buf, "{ %0,1,%%r0\n\tb,n %2| %0,%%sar,1,%%r0\n\tb,n %2}");
6527             else if (negated)
6528               strcat (buf, "{ %0,1,%%r0\n\tb %3| %0,%%sar,1,%%r0\n\tb %3}");
6529             else
6530               strcat (buf, "{ %0,1,%%r0\n\tb %2| %0,%%sar,1,%%r0\n\tb %2}");
6531           }
6532         break;
6533
6534       default:
6535         gcc_unreachable ();
6536     }
6537   return buf;
6538 }
6539
6540 /* Return the output template for emitting a dbra type insn.
6541
6542    Note it may perform some output operations on its own before
6543    returning the final output string.  */
6544 const char *
6545 output_dbra (rtx *operands, rtx insn, int which_alternative)
6546 {
6547
6548   /* A conditional branch to the following instruction (e.g. the delay slot) is
6549      asking for a disaster.  Be prepared!  */
6550
6551   if (next_real_insn (JUMP_LABEL (insn)) == next_real_insn (insn))
6552     {
6553       if (which_alternative == 0)
6554         return "ldo %1(%0),%0";
6555       else if (which_alternative == 1)
6556         {
6557           output_asm_insn ("{fstws|fstw} %0,-16(%%r30)", operands);
6558           output_asm_insn ("ldw -16(%%r30),%4", operands);
6559           output_asm_insn ("ldo %1(%4),%4\n\tstw %4,-16(%%r30)", operands);
6560           return "{fldws|fldw} -16(%%r30),%0";
6561         }
6562       else
6563         {
6564           output_asm_insn ("ldw %0,%4", operands);
6565           return "ldo %1(%4),%4\n\tstw %4,%0";
6566         }
6567     }
6568
6569   if (which_alternative == 0)
6570     {
6571       int nullify = INSN_ANNULLED_BRANCH_P (insn);
6572       int length = get_attr_length (insn);
6573
6574       /* If this is a long branch with its delay slot unfilled, set `nullify'
6575          as it can nullify the delay slot and save a nop.  */
6576       if (length == 8 && dbr_sequence_length () == 0)
6577         nullify = 1;
6578
6579       /* If this is a short forward conditional branch which did not get
6580          its delay slot filled, the delay slot can still be nullified.  */
6581       if (! nullify && length == 4 && dbr_sequence_length () == 0)
6582         nullify = forward_branch_p (insn);
6583
6584       switch (length)
6585         {
6586         case 4:
6587           if (nullify)
6588             return "addib,%C2,n %1,%0,%3";
6589           else
6590             return "addib,%C2 %1,%0,%3";
6591
6592         case 8:
6593           /* Handle weird backwards branch with a fulled delay slot
6594              which is nullified.  */
6595           if (dbr_sequence_length () != 0
6596               && ! forward_branch_p (insn)
6597               && nullify)
6598             return "addib,%N2,n %1,%0,.+12\n\tb %3";
6599           /* Handle short backwards branch with an unfilled delay slot.
6600              Using a addb;nop rather than addi;bl saves 1 cycle for both
6601              taken and untaken branches.  */
6602           else if (dbr_sequence_length () == 0
6603                    && ! forward_branch_p (insn)
6604                    && INSN_ADDRESSES_SET_P ()
6605                    && VAL_14_BITS_P (INSN_ADDRESSES (INSN_UID (JUMP_LABEL (insn)))
6606                                       - INSN_ADDRESSES (INSN_UID (insn)) - 8))
6607               return "addib,%C2 %1,%0,%3%#";
6608
6609           /* Handle normal cases.  */
6610           if (nullify)
6611             return "addi,%N2 %1,%0,%0\n\tb,n %3";
6612           else
6613             return "addi,%N2 %1,%0,%0\n\tb %3";
6614
6615         default:
6616           gcc_unreachable ();
6617         }
6618
6619     }
6620   /* Deal with gross reload from FP register case.  */
6621   else if (which_alternative == 1)
6622     {
6623       /* Move loop counter from FP register to MEM then into a GR,
6624          increment the GR, store the GR into MEM, and finally reload
6625          the FP register from MEM from within the branch's delay slot.  */
6626       output_asm_insn ("{fstws|fstw} %0,-16(%%r30)\n\tldw -16(%%r30),%4",
6627                        operands);
6628       output_asm_insn ("ldo %1(%4),%4\n\tstw %4,-16(%%r30)", operands);
6629       if (get_attr_length (insn) == 24)
6630         return "{comb|cmpb},%S2 %%r0,%4,%3\n\t{fldws|fldw} -16(%%r30),%0";
6631       else
6632         return "{comclr|cmpclr},%B2 %%r0,%4,%%r0\n\tb %3\n\t{fldws|fldw} -16(%%r30),%0";
6633     }
6634   /* Deal with gross reload from memory case.  */
6635   else
6636     {
6637       /* Reload loop counter from memory, the store back to memory
6638          happens in the branch's delay slot.  */
6639       output_asm_insn ("ldw %0,%4", operands);
6640       if (get_attr_length (insn) == 12)
6641         return "addib,%C2 %1,%4,%3\n\tstw %4,%0";
6642       else
6643         return "addi,%N2 %1,%4,%4\n\tb %3\n\tstw %4,%0";
6644     }
6645 }
6646
6647 /* Return the output template for emitting a dbra type insn.
6648
6649    Note it may perform some output operations on its own before
6650    returning the final output string.  */
6651 const char *
6652 output_movb (rtx *operands, rtx insn, int which_alternative,
6653              int reverse_comparison)
6654 {
6655
6656   /* A conditional branch to the following instruction (e.g. the delay slot) is
6657      asking for a disaster.  Be prepared!  */
6658
6659   if (next_real_insn (JUMP_LABEL (insn)) == next_real_insn (insn))
6660     {
6661       if (which_alternative == 0)
6662         return "copy %1,%0";
6663       else if (which_alternative == 1)
6664         {
6665           output_asm_insn ("stw %1,-16(%%r30)", operands);
6666           return "{fldws|fldw} -16(%%r30),%0";
6667         }
6668       else if (which_alternative == 2)
6669         return "stw %1,%0";
6670       else
6671         return "mtsar %r1";
6672     }
6673
6674   /* Support the second variant.  */
6675   if (reverse_comparison)
6676     PUT_CODE (operands[2], reverse_condition (GET_CODE (operands[2])));
6677
6678   if (which_alternative == 0)
6679     {
6680       int nullify = INSN_ANNULLED_BRANCH_P (insn);
6681       int length = get_attr_length (insn);
6682
6683       /* If this is a long branch with its delay slot unfilled, set `nullify'
6684          as it can nullify the delay slot and save a nop.  */
6685       if (length == 8 && dbr_sequence_length () == 0)
6686         nullify = 1;
6687
6688       /* If this is a short forward conditional branch which did not get
6689          its delay slot filled, the delay slot can still be nullified.  */
6690       if (! nullify && length == 4 && dbr_sequence_length () == 0)
6691         nullify = forward_branch_p (insn);
6692
6693       switch (length)
6694         {
6695         case 4:
6696           if (nullify)
6697             return "movb,%C2,n %1,%0,%3";
6698           else
6699             return "movb,%C2 %1,%0,%3";
6700
6701         case 8:
6702           /* Handle weird backwards branch with a filled delay slot
6703              which is nullified.  */
6704           if (dbr_sequence_length () != 0
6705               && ! forward_branch_p (insn)
6706               && nullify)
6707             return "movb,%N2,n %1,%0,.+12\n\tb %3";
6708
6709           /* Handle short backwards branch with an unfilled delay slot.
6710              Using a movb;nop rather than or;bl saves 1 cycle for both
6711              taken and untaken branches.  */
6712           else if (dbr_sequence_length () == 0
6713                    && ! forward_branch_p (insn)
6714                    && INSN_ADDRESSES_SET_P ()
6715                    && VAL_14_BITS_P (INSN_ADDRESSES (INSN_UID (JUMP_LABEL (insn)))
6716                                       - INSN_ADDRESSES (INSN_UID (insn)) - 8))
6717             return "movb,%C2 %1,%0,%3%#";
6718           /* Handle normal cases.  */
6719           if (nullify)
6720             return "or,%N2 %1,%%r0,%0\n\tb,n %3";
6721           else
6722             return "or,%N2 %1,%%r0,%0\n\tb %3";
6723
6724         default:
6725           gcc_unreachable ();
6726         }
6727     }
6728   /* Deal with gross reload from FP register case.  */
6729   else if (which_alternative == 1)
6730     {
6731       /* Move loop counter from FP register to MEM then into a GR,
6732          increment the GR, store the GR into MEM, and finally reload
6733          the FP register from MEM from within the branch's delay slot.  */
6734       output_asm_insn ("stw %1,-16(%%r30)", operands);
6735       if (get_attr_length (insn) == 12)
6736         return "{comb|cmpb},%S2 %%r0,%1,%3\n\t{fldws|fldw} -16(%%r30),%0";
6737       else
6738         return "{comclr|cmpclr},%B2 %%r0,%1,%%r0\n\tb %3\n\t{fldws|fldw} -16(%%r30),%0";
6739     }
6740   /* Deal with gross reload from memory case.  */
6741   else if (which_alternative == 2)
6742     {
6743       /* Reload loop counter from memory, the store back to memory
6744          happens in the branch's delay slot.  */
6745       if (get_attr_length (insn) == 8)
6746         return "{comb|cmpb},%S2 %%r0,%1,%3\n\tstw %1,%0";
6747       else
6748         return "{comclr|cmpclr},%B2 %%r0,%1,%%r0\n\tb %3\n\tstw %1,%0";
6749     }
6750   /* Handle SAR as a destination.  */
6751   else
6752     {
6753       if (get_attr_length (insn) == 8)
6754         return "{comb|cmpb},%S2 %%r0,%1,%3\n\tmtsar %r1";
6755       else
6756         return "{comclr|cmpclr},%B2 %%r0,%1,%%r0\n\tb %3\n\tmtsar %r1";
6757     }
6758 }
6759
6760 /* Copy any FP arguments in INSN into integer registers.  */
6761 static void
6762 copy_fp_args (rtx insn)
6763 {
6764   rtx link;
6765   rtx xoperands[2];
6766
6767   for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
6768     {
6769       int arg_mode, regno;
6770       rtx use = XEXP (link, 0);
6771
6772       if (! (GET_CODE (use) == USE
6773           && GET_CODE (XEXP (use, 0)) == REG
6774           && FUNCTION_ARG_REGNO_P (REGNO (XEXP (use, 0)))))
6775         continue;
6776
6777       arg_mode = GET_MODE (XEXP (use, 0));
6778       regno = REGNO (XEXP (use, 0));
6779
6780       /* Is it a floating point register?  */
6781       if (regno >= 32 && regno <= 39)
6782         {
6783           /* Copy the FP register into an integer register via memory.  */
6784           if (arg_mode == SFmode)
6785             {
6786               xoperands[0] = XEXP (use, 0);
6787               xoperands[1] = gen_rtx_REG (SImode, 26 - (regno - 32) / 2);
6788               output_asm_insn ("{fstws|fstw} %0,-16(%%sr0,%%r30)", xoperands);
6789               output_asm_insn ("ldw -16(%%sr0,%%r30),%1", xoperands);
6790             }
6791           else
6792             {
6793               xoperands[0] = XEXP (use, 0);
6794               xoperands[1] = gen_rtx_REG (DImode, 25 - (regno - 34) / 2);
6795               output_asm_insn ("{fstds|fstd} %0,-16(%%sr0,%%r30)", xoperands);
6796               output_asm_insn ("ldw -12(%%sr0,%%r30),%R1", xoperands);
6797               output_asm_insn ("ldw -16(%%sr0,%%r30),%1", xoperands);
6798             }
6799         }
6800     }
6801 }
6802
6803 /* Compute length of the FP argument copy sequence for INSN.  */
6804 static int
6805 length_fp_args (rtx insn)
6806 {
6807   int length = 0;
6808   rtx link;
6809
6810   for (link = CALL_INSN_FUNCTION_USAGE (insn); link; link = XEXP (link, 1))
6811     {
6812       int arg_mode, regno;
6813       rtx use = XEXP (link, 0);
6814
6815       if (! (GET_CODE (use) == USE
6816           && GET_CODE (XEXP (use, 0)) == REG
6817           && FUNCTION_ARG_REGNO_P (REGNO (XEXP (use, 0)))))
6818         continue;
6819
6820       arg_mode = GET_MODE (XEXP (use, 0));
6821       regno = REGNO (XEXP (use, 0));
6822
6823       /* Is it a floating point register?  */
6824       if (regno >= 32 && regno <= 39)
6825         {
6826           if (arg_mode == SFmode)
6827             length += 8;
6828           else
6829             length += 12;
6830         }
6831     }
6832
6833   return length;
6834 }
6835
6836 /* Return the attribute length for the millicode call instruction INSN.
6837    The length must match the code generated by output_millicode_call.
6838    We include the delay slot in the returned length as it is better to
6839    over estimate the length than to under estimate it.  */
6840
6841 int
6842 attr_length_millicode_call (rtx insn)
6843 {
6844   unsigned long distance = -1;
6845   unsigned long total = IN_NAMED_SECTION_P (cfun->decl) ? 0 : total_code_bytes;
6846
6847   if (INSN_ADDRESSES_SET_P ())
6848     {
6849       distance = (total + insn_current_reference_address (insn));
6850       if (distance < total)
6851         distance = -1;
6852     }
6853
6854   if (TARGET_64BIT)
6855     {
6856       if (!TARGET_LONG_CALLS && distance < 7600000)
6857         return 8;
6858
6859       return 20;
6860     }
6861   else if (TARGET_PORTABLE_RUNTIME)
6862     return 24;
6863   else
6864     {
6865       if (!TARGET_LONG_CALLS && distance < 240000)
6866         return 8;
6867
6868       if (TARGET_LONG_ABS_CALL && !flag_pic)
6869         return 12;
6870
6871       return 24;
6872     }
6873 }
6874
6875 /* INSN is a function call.  It may have an unconditional jump
6876    in its delay slot.
6877
6878    CALL_DEST is the routine we are calling.  */
6879
6880 const char *
6881 output_millicode_call (rtx insn, rtx call_dest)
6882 {
6883   int attr_length = get_attr_length (insn);
6884   int seq_length = dbr_sequence_length ();
6885   int distance;
6886   rtx seq_insn;
6887   rtx xoperands[3];
6888
6889   xoperands[0] = call_dest;
6890   xoperands[2] = gen_rtx_REG (Pmode, TARGET_64BIT ? 2 : 31);
6891
6892   /* Handle the common case where we are sure that the branch will
6893      reach the beginning of the $CODE$ subspace.  The within reach
6894      form of the $$sh_func_adrs call has a length of 28.  Because
6895      it has an attribute type of multi, it never has a nonzero
6896      sequence length.  The length of the $$sh_func_adrs is the same
6897      as certain out of reach PIC calls to other routines.  */
6898   if (!TARGET_LONG_CALLS
6899       && ((seq_length == 0
6900            && (attr_length == 12
6901                || (attr_length == 28 && get_attr_type (insn) == TYPE_MULTI)))
6902           || (seq_length != 0 && attr_length == 8)))
6903     {
6904       output_asm_insn ("{bl|b,l} %0,%2", xoperands);
6905     }
6906   else
6907     {
6908       if (TARGET_64BIT)
6909         {
6910           /* It might seem that one insn could be saved by accessing
6911              the millicode function using the linkage table.  However,
6912              this doesn't work in shared libraries and other dynamically
6913              loaded objects.  Using a pc-relative sequence also avoids
6914              problems related to the implicit use of the gp register.  */
6915           output_asm_insn ("b,l .+8,%%r1", xoperands);
6916
6917           if (TARGET_GAS)
6918             {
6919               output_asm_insn ("addil L'%0-$PIC_pcrel$0+4,%%r1", xoperands);
6920               output_asm_insn ("ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r1", xoperands);
6921             }
6922           else
6923             {
6924               xoperands[1] = gen_label_rtx ();
6925               output_asm_insn ("addil L'%0-%l1,%%r1", xoperands);
6926               (*targetm.asm_out.internal_label) (asm_out_file, "L",
6927                                          CODE_LABEL_NUMBER (xoperands[1]));
6928               output_asm_insn ("ldo R'%0-%l1(%%r1),%%r1", xoperands);
6929             }
6930
6931           output_asm_insn ("bve,l (%%r1),%%r2", xoperands);
6932         }
6933       else if (TARGET_PORTABLE_RUNTIME)
6934         {
6935           /* Pure portable runtime doesn't allow be/ble; we also don't
6936              have PIC support in the assembler/linker, so this sequence
6937              is needed.  */
6938
6939           /* Get the address of our target into %r1.  */
6940           output_asm_insn ("ldil L'%0,%%r1", xoperands);
6941           output_asm_insn ("ldo R'%0(%%r1),%%r1", xoperands);
6942
6943           /* Get our return address into %r31.  */
6944           output_asm_insn ("{bl|b,l} .+8,%%r31", xoperands);
6945           output_asm_insn ("addi 8,%%r31,%%r31", xoperands);
6946
6947           /* Jump to our target address in %r1.  */
6948           output_asm_insn ("bv %%r0(%%r1)", xoperands);
6949         }
6950       else if (!flag_pic)
6951         {
6952           output_asm_insn ("ldil L'%0,%%r1", xoperands);
6953           if (TARGET_PA_20)
6954             output_asm_insn ("be,l R'%0(%%sr4,%%r1),%%sr0,%%r31", xoperands);
6955           else
6956             output_asm_insn ("ble R'%0(%%sr4,%%r1)", xoperands);
6957         }
6958       else
6959         {
6960           output_asm_insn ("{bl|b,l} .+8,%%r1", xoperands);
6961           output_asm_insn ("addi 16,%%r1,%%r31", xoperands);
6962
6963           if (TARGET_SOM || !TARGET_GAS)
6964             {
6965               /* The HP assembler can generate relocations for the
6966                  difference of two symbols.  GAS can do this for a
6967                  millicode symbol but not an arbitrary external
6968                  symbol when generating SOM output.  */
6969               xoperands[1] = gen_label_rtx ();
6970               (*targetm.asm_out.internal_label) (asm_out_file, "L",
6971                                          CODE_LABEL_NUMBER (xoperands[1]));
6972               output_asm_insn ("addil L'%0-%l1,%%r1", xoperands);
6973               output_asm_insn ("ldo R'%0-%l1(%%r1),%%r1", xoperands);
6974             }
6975           else
6976             {
6977               output_asm_insn ("addil L'%0-$PIC_pcrel$0+8,%%r1", xoperands);
6978               output_asm_insn ("ldo R'%0-$PIC_pcrel$0+12(%%r1),%%r1",
6979                                xoperands);
6980             }
6981
6982           /* Jump to our target address in %r1.  */
6983           output_asm_insn ("bv %%r0(%%r1)", xoperands);
6984         }
6985     }
6986
6987   if (seq_length == 0)
6988     output_asm_insn ("nop", xoperands);
6989
6990   /* We are done if there isn't a jump in the delay slot.  */
6991   if (seq_length == 0 || GET_CODE (NEXT_INSN (insn)) != JUMP_INSN)
6992     return "";
6993
6994   /* This call has an unconditional jump in its delay slot.  */
6995   xoperands[0] = XEXP (PATTERN (NEXT_INSN (insn)), 1);
6996
6997   /* See if the return address can be adjusted.  Use the containing
6998      sequence insn's address.  */
6999   if (INSN_ADDRESSES_SET_P ())
7000     {
7001       seq_insn = NEXT_INSN (PREV_INSN (XVECEXP (final_sequence, 0, 0)));
7002       distance = (INSN_ADDRESSES (INSN_UID (JUMP_LABEL (NEXT_INSN (insn))))
7003                   - INSN_ADDRESSES (INSN_UID (seq_insn)) - 8);
7004
7005       if (VAL_14_BITS_P (distance))
7006         {
7007           xoperands[1] = gen_label_rtx ();
7008           output_asm_insn ("ldo %0-%1(%2),%2", xoperands);
7009           (*targetm.asm_out.internal_label) (asm_out_file, "L",
7010                                              CODE_LABEL_NUMBER (xoperands[1]));
7011         }
7012       else
7013         /* ??? This branch may not reach its target.  */
7014         output_asm_insn ("nop\n\tb,n %0", xoperands);
7015     }
7016   else
7017     /* ??? This branch may not reach its target.  */
7018     output_asm_insn ("nop\n\tb,n %0", xoperands);
7019
7020   /* Delete the jump.  */
7021   PUT_CODE (NEXT_INSN (insn), NOTE);
7022   NOTE_LINE_NUMBER (NEXT_INSN (insn)) = NOTE_INSN_DELETED;
7023   NOTE_SOURCE_FILE (NEXT_INSN (insn)) = 0;
7024
7025   return "";
7026 }
7027
7028 /* Return the attribute length of the call instruction INSN.  The SIBCALL
7029    flag indicates whether INSN is a regular call or a sibling call.  The
7030    length returned must be longer than the code actually generated by
7031    output_call.  Since branch shortening is done before delay branch
7032    sequencing, there is no way to determine whether or not the delay
7033    slot will be filled during branch shortening.  Even when the delay
7034    slot is filled, we may have to add a nop if the delay slot contains
7035    a branch that can't reach its target.  Thus, we always have to include
7036    the delay slot in the length estimate.  This used to be done in
7037    pa_adjust_insn_length but we do it here now as some sequences always
7038    fill the delay slot and we can save four bytes in the estimate for
7039    these sequences.  */
7040
7041 int
7042 attr_length_call (rtx insn, int sibcall)
7043 {
7044   int local_call;
7045   rtx call_dest;
7046   tree call_decl;
7047   int length = 0;
7048   rtx pat = PATTERN (insn);
7049   unsigned long distance = -1;
7050
7051   if (INSN_ADDRESSES_SET_P ())
7052     {
7053       unsigned long total;
7054
7055       total = IN_NAMED_SECTION_P (cfun->decl) ? 0 : total_code_bytes;
7056       distance = (total + insn_current_reference_address (insn));
7057       if (distance < total)
7058         distance = -1;
7059     }
7060
7061   /* Determine if this is a local call.  */
7062   if (GET_CODE (XVECEXP (pat, 0, 0)) == CALL)
7063     call_dest = XEXP (XEXP (XVECEXP (pat, 0, 0), 0), 0);
7064   else
7065     call_dest = XEXP (XEXP (XEXP (XVECEXP (pat, 0, 0), 1), 0), 0);
7066
7067   call_decl = SYMBOL_REF_DECL (call_dest);
7068   local_call = call_decl && (*targetm.binds_local_p) (call_decl);
7069
7070   /* pc-relative branch.  */
7071   if (!TARGET_LONG_CALLS
7072       && ((TARGET_PA_20 && !sibcall && distance < 7600000)
7073           || distance < 240000))
7074     length += 8;
7075
7076   /* 64-bit plabel sequence.  */
7077   else if (TARGET_64BIT && !local_call)
7078     length += sibcall ? 28 : 24;
7079
7080   /* non-pic long absolute branch sequence.  */
7081   else if ((TARGET_LONG_ABS_CALL || local_call) && !flag_pic)
7082     length += 12;
7083
7084   /* long pc-relative branch sequence.  */
7085   else if ((TARGET_SOM && TARGET_LONG_PIC_SDIFF_CALL)
7086            || (TARGET_64BIT && !TARGET_GAS)
7087            || (TARGET_GAS && (TARGET_LONG_PIC_PCREL_CALL || local_call)))
7088     {
7089       length += 20;
7090
7091       if (!TARGET_PA_20 && !TARGET_NO_SPACE_REGS)
7092         length += 8;
7093     }
7094
7095   /* 32-bit plabel sequence.  */
7096   else
7097     {
7098       length += 32;
7099
7100       if (TARGET_SOM)
7101         length += length_fp_args (insn);
7102
7103       if (flag_pic)
7104         length += 4;
7105
7106       if (!TARGET_PA_20)
7107         {
7108           if (!sibcall)
7109             length += 8;
7110
7111           if (!TARGET_NO_SPACE_REGS)
7112             length += 8;
7113         }
7114     }
7115
7116   return length;
7117 }
7118
7119 /* INSN is a function call.  It may have an unconditional jump
7120    in its delay slot.
7121
7122    CALL_DEST is the routine we are calling.  */
7123
7124 const char *
7125 output_call (rtx insn, rtx call_dest, int sibcall)
7126 {
7127   int delay_insn_deleted = 0;
7128   int delay_slot_filled = 0;
7129   int seq_length = dbr_sequence_length ();
7130   tree call_decl = SYMBOL_REF_DECL (call_dest);
7131   int local_call = call_decl && (*targetm.binds_local_p) (call_decl);
7132   rtx xoperands[2];
7133
7134   xoperands[0] = call_dest;
7135
7136   /* Handle the common case where we're sure that the branch will reach
7137      the beginning of the "$CODE$" subspace.  This is the beginning of
7138      the current function if we are in a named section.  */
7139   if (!TARGET_LONG_CALLS && attr_length_call (insn, sibcall) == 8)
7140     {
7141       xoperands[1] = gen_rtx_REG (word_mode, sibcall ? 0 : 2);
7142       output_asm_insn ("{bl|b,l} %0,%1", xoperands);
7143     }
7144   else
7145     {
7146       if (TARGET_64BIT && !local_call)
7147         {
7148           /* ??? As far as I can tell, the HP linker doesn't support the
7149              long pc-relative sequence described in the 64-bit runtime
7150              architecture.  So, we use a slightly longer indirect call.  */
7151           xoperands[0] = get_deferred_plabel (call_dest);
7152           xoperands[1] = gen_label_rtx ();
7153
7154           /* If this isn't a sibcall, we put the load of %r27 into the
7155              delay slot.  We can't do this in a sibcall as we don't
7156              have a second call-clobbered scratch register available.  */
7157           if (seq_length != 0
7158               && GET_CODE (NEXT_INSN (insn)) != JUMP_INSN
7159               && !sibcall)
7160             {
7161               final_scan_insn (NEXT_INSN (insn), asm_out_file,
7162                                optimize, 0, NULL);
7163
7164               /* Now delete the delay insn.  */
7165               PUT_CODE (NEXT_INSN (insn), NOTE);
7166               NOTE_LINE_NUMBER (NEXT_INSN (insn)) = NOTE_INSN_DELETED;
7167               NOTE_SOURCE_FILE (NEXT_INSN (insn)) = 0;
7168               delay_insn_deleted = 1;
7169             }
7170
7171           output_asm_insn ("addil LT'%0,%%r27", xoperands);
7172           output_asm_insn ("ldd RT'%0(%%r1),%%r1", xoperands);
7173           output_asm_insn ("ldd 0(%%r1),%%r1", xoperands);
7174
7175           if (sibcall)
7176             {
7177               output_asm_insn ("ldd 24(%%r1),%%r27", xoperands);
7178               output_asm_insn ("ldd 16(%%r1),%%r1", xoperands);
7179               output_asm_insn ("bve (%%r1)", xoperands);
7180             }
7181           else
7182             {
7183               output_asm_insn ("ldd 16(%%r1),%%r2", xoperands);
7184               output_asm_insn ("bve,l (%%r2),%%r2", xoperands);
7185               output_asm_insn ("ldd 24(%%r1),%%r27", xoperands);
7186               delay_slot_filled = 1;
7187             }
7188         }
7189       else
7190         {
7191           int indirect_call = 0;
7192
7193           /* Emit a long call.  There are several different sequences
7194              of increasing length and complexity.  In most cases,
7195              they don't allow an instruction in the delay slot.  */
7196           if (!((TARGET_LONG_ABS_CALL || local_call) && !flag_pic)
7197               && !(TARGET_SOM && TARGET_LONG_PIC_SDIFF_CALL)
7198               && !(TARGET_GAS && (TARGET_LONG_PIC_PCREL_CALL || local_call))
7199               && !TARGET_64BIT)
7200             indirect_call = 1;
7201
7202           if (seq_length != 0
7203               && GET_CODE (NEXT_INSN (insn)) != JUMP_INSN
7204               && !sibcall
7205               && (!TARGET_PA_20 || indirect_call))
7206             {
7207               /* A non-jump insn in the delay slot.  By definition we can
7208                  emit this insn before the call (and in fact before argument
7209                  relocating.  */
7210               final_scan_insn (NEXT_INSN (insn), asm_out_file, optimize, 0,
7211                                NULL);
7212
7213               /* Now delete the delay insn.  */
7214               PUT_CODE (NEXT_INSN (insn), NOTE);
7215               NOTE_LINE_NUMBER (NEXT_INSN (insn)) = NOTE_INSN_DELETED;
7216               NOTE_SOURCE_FILE (NEXT_INSN (insn)) = 0;
7217               delay_insn_deleted = 1;
7218             }
7219
7220           if ((TARGET_LONG_ABS_CALL || local_call) && !flag_pic)
7221             {
7222               /* This is the best sequence for making long calls in
7223                  non-pic code.  Unfortunately, GNU ld doesn't provide
7224                  the stub needed for external calls, and GAS's support
7225                  for this with the SOM linker is buggy.  It is safe
7226                  to use this for local calls.  */
7227               output_asm_insn ("ldil L'%0,%%r1", xoperands);
7228               if (sibcall)
7229                 output_asm_insn ("be R'%0(%%sr4,%%r1)", xoperands);
7230               else
7231                 {
7232                   if (TARGET_PA_20)
7233                     output_asm_insn ("be,l R'%0(%%sr4,%%r1),%%sr0,%%r31",
7234                                      xoperands);
7235                   else
7236                     output_asm_insn ("ble R'%0(%%sr4,%%r1)", xoperands);
7237
7238                   output_asm_insn ("copy %%r31,%%r2", xoperands);
7239                   delay_slot_filled = 1;
7240                 }
7241             }
7242           else
7243             {
7244               if ((TARGET_SOM && TARGET_LONG_PIC_SDIFF_CALL)
7245                   || (TARGET_64BIT && !TARGET_GAS))
7246                 {
7247                   /* The HP assembler and linker can handle relocations
7248                      for the difference of two symbols.  GAS and the HP
7249                      linker can't do this when one of the symbols is
7250                      external.  */
7251                   xoperands[1] = gen_label_rtx ();
7252                   output_asm_insn ("{bl|b,l} .+8,%%r1", xoperands);
7253                   output_asm_insn ("addil L'%0-%l1,%%r1", xoperands);
7254                   (*targetm.asm_out.internal_label) (asm_out_file, "L",
7255                                              CODE_LABEL_NUMBER (xoperands[1]));
7256                   output_asm_insn ("ldo R'%0-%l1(%%r1),%%r1", xoperands);
7257                 }
7258               else if (TARGET_GAS && (TARGET_LONG_PIC_PCREL_CALL || local_call))
7259                 {
7260                   /*  GAS currently can't generate the relocations that
7261                       are needed for the SOM linker under HP-UX using this
7262                       sequence.  The GNU linker doesn't generate the stubs
7263                       that are needed for external calls on TARGET_ELF32
7264                       with this sequence.  For now, we have to use a
7265                       longer plabel sequence when using GAS.  */
7266                   output_asm_insn ("{bl|b,l} .+8,%%r1", xoperands);
7267                   output_asm_insn ("addil L'%0-$PIC_pcrel$0+4,%%r1",
7268                                    xoperands);
7269                   output_asm_insn ("ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r1",
7270                                    xoperands);
7271                 }
7272               else
7273                 {
7274                   /* Emit a long plabel-based call sequence.  This is
7275                      essentially an inline implementation of $$dyncall.
7276                      We don't actually try to call $$dyncall as this is
7277                      as difficult as calling the function itself.  */
7278                   xoperands[0] = get_deferred_plabel (call_dest);
7279                   xoperands[1] = gen_label_rtx ();
7280
7281                   /* Since the call is indirect, FP arguments in registers
7282                      need to be copied to the general registers.  Then, the
7283                      argument relocation stub will copy them back.  */
7284                   if (TARGET_SOM)
7285                     copy_fp_args (insn);
7286
7287                   if (flag_pic)
7288                     {
7289                       output_asm_insn ("addil LT'%0,%%r19", xoperands);
7290                       output_asm_insn ("ldw RT'%0(%%r1),%%r1", xoperands);
7291                       output_asm_insn ("ldw 0(%%r1),%%r1", xoperands);
7292                     }
7293                   else
7294                     {
7295                       output_asm_insn ("addil LR'%0-$global$,%%r27",
7296                                        xoperands);
7297                       output_asm_insn ("ldw RR'%0-$global$(%%r1),%%r1",
7298                                        xoperands);
7299                     }
7300
7301                   output_asm_insn ("bb,>=,n %%r1,30,.+16", xoperands);
7302                   output_asm_insn ("depi 0,31,2,%%r1", xoperands);
7303                   output_asm_insn ("ldw 4(%%sr0,%%r1),%%r19", xoperands);
7304                   output_asm_insn ("ldw 0(%%sr0,%%r1),%%r1", xoperands);
7305
7306                   if (!sibcall && !TARGET_PA_20)
7307                     {
7308                       output_asm_insn ("{bl|b,l} .+8,%%r2", xoperands);
7309                       if (TARGET_NO_SPACE_REGS)
7310                         output_asm_insn ("addi 8,%%r2,%%r2", xoperands);
7311                       else
7312                         output_asm_insn ("addi 16,%%r2,%%r2", xoperands);
7313                     }
7314                 }
7315
7316               if (TARGET_PA_20)
7317                 {
7318                   if (sibcall)
7319                     output_asm_insn ("bve (%%r1)", xoperands);
7320                   else
7321                     {
7322                       if (indirect_call)
7323                         {
7324                           output_asm_insn ("bve,l (%%r1),%%r2", xoperands);
7325                           output_asm_insn ("stw %%r2,-24(%%sp)", xoperands);
7326                           delay_slot_filled = 1;
7327                         }
7328                       else
7329                         output_asm_insn ("bve,l (%%r1),%%r2", xoperands);
7330                     }
7331                 }
7332               else
7333                 {
7334                   if (!TARGET_NO_SPACE_REGS)
7335                     output_asm_insn ("ldsid (%%r1),%%r31\n\tmtsp %%r31,%%sr0",
7336                                      xoperands);
7337
7338                   if (sibcall)
7339                     {
7340                       if (TARGET_NO_SPACE_REGS)
7341                         output_asm_insn ("be 0(%%sr4,%%r1)", xoperands);
7342                       else
7343                         output_asm_insn ("be 0(%%sr0,%%r1)", xoperands);
7344                     }
7345                   else
7346                     {
7347                       if (TARGET_NO_SPACE_REGS)
7348                         output_asm_insn ("ble 0(%%sr4,%%r1)", xoperands);
7349                       else
7350                         output_asm_insn ("ble 0(%%sr0,%%r1)", xoperands);
7351
7352                       if (indirect_call)
7353                         output_asm_insn ("stw %%r31,-24(%%sp)", xoperands);
7354                       else
7355                         output_asm_insn ("copy %%r31,%%r2", xoperands);
7356                       delay_slot_filled = 1;
7357                     }
7358                 }
7359             }
7360         }
7361     }
7362
7363   if (!delay_slot_filled && (seq_length == 0 || delay_insn_deleted))
7364     output_asm_insn ("nop", xoperands);
7365
7366   /* We are done if there isn't a jump in the delay slot.  */
7367   if (seq_length == 0
7368       || delay_insn_deleted
7369       || GET_CODE (NEXT_INSN (insn)) != JUMP_INSN)
7370     return "";
7371
7372   /* A sibcall should never have a branch in the delay slot.  */
7373   gcc_assert (!sibcall);
7374
7375   /* This call has an unconditional jump in its delay slot.  */
7376   xoperands[0] = XEXP (PATTERN (NEXT_INSN (insn)), 1);
7377
7378   if (!delay_slot_filled && INSN_ADDRESSES_SET_P ())
7379     {
7380       /* See if the return address can be adjusted.  Use the containing
7381          sequence insn's address.  */
7382       rtx seq_insn = NEXT_INSN (PREV_INSN (XVECEXP (final_sequence, 0, 0)));
7383       int distance = (INSN_ADDRESSES (INSN_UID (JUMP_LABEL (NEXT_INSN (insn))))
7384                       - INSN_ADDRESSES (INSN_UID (seq_insn)) - 8);
7385
7386       if (VAL_14_BITS_P (distance))
7387         {
7388           xoperands[1] = gen_label_rtx ();
7389           output_asm_insn ("ldo %0-%1(%%r2),%%r2", xoperands);
7390           (*targetm.asm_out.internal_label) (asm_out_file, "L",
7391                                              CODE_LABEL_NUMBER (xoperands[1]));
7392         }
7393       else
7394         output_asm_insn ("nop\n\tb,n %0", xoperands);
7395     }
7396   else
7397     output_asm_insn ("b,n %0", xoperands);
7398
7399   /* Delete the jump.  */
7400   PUT_CODE (NEXT_INSN (insn), NOTE);
7401   NOTE_LINE_NUMBER (NEXT_INSN (insn)) = NOTE_INSN_DELETED;
7402   NOTE_SOURCE_FILE (NEXT_INSN (insn)) = 0;
7403
7404   return "";
7405 }
7406
7407 /* Return the attribute length of the indirect call instruction INSN.
7408    The length must match the code generated by output_indirect call.
7409    The returned length includes the delay slot.  Currently, the delay
7410    slot of an indirect call sequence is not exposed and it is used by
7411    the sequence itself.  */
7412
7413 int
7414 attr_length_indirect_call (rtx insn)
7415 {
7416   unsigned long distance = -1;
7417   unsigned long total = IN_NAMED_SECTION_P (cfun->decl) ? 0 : total_code_bytes;
7418
7419   if (INSN_ADDRESSES_SET_P ())
7420     {
7421       distance = (total + insn_current_reference_address (insn));
7422       if (distance < total)
7423         distance = -1;
7424     }
7425
7426   if (TARGET_64BIT)
7427     return 12;
7428
7429   if (TARGET_FAST_INDIRECT_CALLS
7430       || (!TARGET_PORTABLE_RUNTIME
7431           && ((TARGET_PA_20 && distance < 7600000) || distance < 240000)))
7432     return 8;
7433
7434   if (flag_pic)
7435     return 24;
7436
7437   if (TARGET_PORTABLE_RUNTIME)
7438     return 20;
7439
7440   /* Out of reach, can use ble.  */
7441   return 12;
7442 }
7443
7444 const char *
7445 output_indirect_call (rtx insn, rtx call_dest)
7446 {
7447   rtx xoperands[1];
7448
7449   if (TARGET_64BIT)
7450     {
7451       xoperands[0] = call_dest;
7452       output_asm_insn ("ldd 16(%0),%%r2", xoperands);
7453       output_asm_insn ("bve,l (%%r2),%%r2\n\tldd 24(%0),%%r27", xoperands);
7454       return "";
7455     }
7456
7457   /* First the special case for kernels, level 0 systems, etc.  */
7458   if (TARGET_FAST_INDIRECT_CALLS)
7459     return "ble 0(%%sr4,%%r22)\n\tcopy %%r31,%%r2";
7460
7461   /* Now the normal case -- we can reach $$dyncall directly or
7462      we're sure that we can get there via a long-branch stub.
7463
7464      No need to check target flags as the length uniquely identifies
7465      the remaining cases.  */
7466   if (attr_length_indirect_call (insn) == 8)
7467     {
7468       /* The HP linker substitutes a BLE for millicode calls using
7469          the short PIC PCREL form.  Thus, we must use %r31 as the
7470          link register when generating PA 1.x code.  */
7471       if (TARGET_PA_20)
7472         return ".CALL\tARGW0=GR\n\tb,l $$dyncall,%%r2\n\tcopy %%r2,%%r31";
7473       else
7474         return ".CALL\tARGW0=GR\n\tbl $$dyncall,%%r31\n\tcopy %%r31,%%r2";
7475     }
7476
7477   /* Long millicode call, but we are not generating PIC or portable runtime
7478      code.  */
7479   if (attr_length_indirect_call (insn) == 12)
7480     return ".CALL\tARGW0=GR\n\tldil L'$$dyncall,%%r2\n\tble R'$$dyncall(%%sr4,%%r2)\n\tcopy %%r31,%%r2";
7481
7482   /* Long millicode call for portable runtime.  */
7483   if (attr_length_indirect_call (insn) == 20)
7484     return "ldil L'$$dyncall,%%r31\n\tldo R'$$dyncall(%%r31),%%r31\n\tblr %%r0,%%r2\n\tbv,n %%r0(%%r31)\n\tnop";
7485
7486   /* We need a long PIC call to $$dyncall.  */
7487   xoperands[0] = NULL_RTX;
7488   output_asm_insn ("{bl|b,l} .+8,%%r1", xoperands);
7489   if (TARGET_SOM || !TARGET_GAS)
7490     {
7491       xoperands[0] = gen_label_rtx ();
7492       output_asm_insn ("addil L'$$dyncall-%0,%%r1", xoperands);
7493       (*targetm.asm_out.internal_label) (asm_out_file, "L",
7494                                          CODE_LABEL_NUMBER (xoperands[0]));
7495       output_asm_insn ("ldo R'$$dyncall-%0(%%r1),%%r1", xoperands);
7496     }
7497   else
7498     {
7499       output_asm_insn ("addil L'$$dyncall-$PIC_pcrel$0+4,%%r1", xoperands);
7500       output_asm_insn ("ldo R'$$dyncall-$PIC_pcrel$0+8(%%r1),%%r1",
7501                        xoperands);
7502     }
7503   output_asm_insn ("blr %%r0,%%r2", xoperands);
7504   output_asm_insn ("bv,n %%r0(%%r1)\n\tnop", xoperands);
7505   return "";
7506 }
7507
7508 /* Return the total length of the save and restore instructions needed for
7509    the data linkage table pointer (i.e., the PIC register) across the call
7510    instruction INSN.  No-return calls do not require a save and restore.
7511    In addition, we may be able to avoid the save and restore for calls
7512    within the same translation unit.  */
7513
7514 int
7515 attr_length_save_restore_dltp (rtx insn)
7516 {
7517   if (find_reg_note (insn, REG_NORETURN, NULL_RTX))
7518     return 0;
7519
7520   return 8;
7521 }
7522
7523 /* In HPUX 8.0's shared library scheme, special relocations are needed
7524    for function labels if they might be passed to a function
7525    in a shared library (because shared libraries don't live in code
7526    space), and special magic is needed to construct their address.  */
7527
7528 void
7529 hppa_encode_label (rtx sym)
7530 {
7531   const char *str = XSTR (sym, 0);
7532   int len = strlen (str) + 1;
7533   char *newstr, *p;
7534
7535   p = newstr = alloca (len + 1);
7536   *p++ = '@';
7537   strcpy (p, str);
7538
7539   XSTR (sym, 0) = ggc_alloc_string (newstr, len);
7540 }
7541
7542 static void
7543 pa_encode_section_info (tree decl, rtx rtl, int first)
7544 {
7545   default_encode_section_info (decl, rtl, first);
7546
7547   if (first && TEXT_SPACE_P (decl))
7548     {
7549       SYMBOL_REF_FLAG (XEXP (rtl, 0)) = 1;
7550       if (TREE_CODE (decl) == FUNCTION_DECL)
7551         hppa_encode_label (XEXP (rtl, 0));
7552     }
7553 }
7554
7555 /* This is sort of inverse to pa_encode_section_info.  */
7556
7557 static const char *
7558 pa_strip_name_encoding (const char *str)
7559 {
7560   str += (*str == '@');
7561   str += (*str == '*');
7562   return str;
7563 }
7564
7565 int
7566 function_label_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
7567 {
7568   return GET_CODE (op) == SYMBOL_REF && FUNCTION_NAME_P (XSTR (op, 0));
7569 }
7570
7571 /* Returns 1 if OP is a function label involved in a simple addition
7572    with a constant.  Used to keep certain patterns from matching
7573    during instruction combination.  */
7574 int
7575 is_function_label_plus_const (rtx op)
7576 {
7577   /* Strip off any CONST.  */
7578   if (GET_CODE (op) == CONST)
7579     op = XEXP (op, 0);
7580
7581   return (GET_CODE (op) == PLUS
7582           && function_label_operand (XEXP (op, 0), Pmode)
7583           && GET_CODE (XEXP (op, 1)) == CONST_INT);
7584 }
7585
7586 /* Output assembly code for a thunk to FUNCTION.  */
7587
7588 static void
7589 pa_asm_output_mi_thunk (FILE *file, tree thunk_fndecl, HOST_WIDE_INT delta,
7590                         HOST_WIDE_INT vcall_offset ATTRIBUTE_UNUSED,
7591                         tree function)
7592 {
7593   static unsigned int current_thunk_number;
7594   int val_14 = VAL_14_BITS_P (delta);
7595   int nbytes = 0;
7596   char label[16];
7597   rtx xoperands[4];
7598
7599   xoperands[0] = XEXP (DECL_RTL (function), 0);
7600   xoperands[1] = XEXP (DECL_RTL (thunk_fndecl), 0);
7601   xoperands[2] = GEN_INT (delta);
7602
7603   ASM_OUTPUT_LABEL (file, XSTR (xoperands[1], 0));
7604   fprintf (file, "\t.PROC\n\t.CALLINFO FRAME=0,NO_CALLS\n\t.ENTRY\n");
7605
7606   /* Output the thunk.  We know that the function is in the same
7607      translation unit (i.e., the same space) as the thunk, and that
7608      thunks are output after their method.  Thus, we don't need an
7609      external branch to reach the function.  With SOM and GAS,
7610      functions and thunks are effectively in different sections.
7611      Thus, we can always use a IA-relative branch and the linker
7612      will add a long branch stub if necessary.
7613
7614      However, we have to be careful when generating PIC code on the
7615      SOM port to ensure that the sequence does not transfer to an
7616      import stub for the target function as this could clobber the
7617      return value saved at SP-24.  This would also apply to the
7618      32-bit linux port if the multi-space model is implemented.  */
7619   if ((!TARGET_LONG_CALLS && TARGET_SOM && !TARGET_PORTABLE_RUNTIME
7620        && !(flag_pic && TREE_PUBLIC (function))
7621        && (TARGET_GAS || last_address < 262132))
7622       || (!TARGET_LONG_CALLS && !TARGET_SOM && !TARGET_PORTABLE_RUNTIME
7623           && ((targetm.have_named_sections
7624                && DECL_SECTION_NAME (thunk_fndecl) != NULL
7625                /* The GNU 64-bit linker has rather poor stub management.
7626                   So, we use a long branch from thunks that aren't in
7627                   the same section as the target function.  */
7628                && ((!TARGET_64BIT
7629                     && (DECL_SECTION_NAME (thunk_fndecl)
7630                         != DECL_SECTION_NAME (function)))
7631                    || ((DECL_SECTION_NAME (thunk_fndecl)
7632                         == DECL_SECTION_NAME (function))
7633                        && last_address < 262132)))
7634               || (!targetm.have_named_sections && last_address < 262132))))
7635     {
7636       if (!val_14)
7637         output_asm_insn ("addil L'%2,%%r26", xoperands);
7638
7639       output_asm_insn ("b %0", xoperands);
7640
7641       if (val_14)
7642         {
7643           output_asm_insn ("ldo %2(%%r26),%%r26", xoperands);
7644           nbytes += 8;
7645         }
7646       else
7647         {
7648           output_asm_insn ("ldo R'%2(%%r1),%%r26", xoperands);
7649           nbytes += 12;
7650         }
7651     }
7652   else if (TARGET_64BIT)
7653     {
7654       /* We only have one call-clobbered scratch register, so we can't
7655          make use of the delay slot if delta doesn't fit in 14 bits.  */
7656       if (!val_14)
7657         {
7658           output_asm_insn ("addil L'%2,%%r26", xoperands);
7659           output_asm_insn ("ldo R'%2(%%r1),%%r26", xoperands);
7660         }
7661
7662       output_asm_insn ("b,l .+8,%%r1", xoperands);
7663
7664       if (TARGET_GAS)
7665         {
7666           output_asm_insn ("addil L'%0-$PIC_pcrel$0+4,%%r1", xoperands);
7667           output_asm_insn ("ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r1", xoperands);
7668         }
7669       else
7670         {
7671           xoperands[3] = GEN_INT (val_14 ? 8 : 16);
7672           output_asm_insn ("addil L'%0-%1-%3,%%r1", xoperands);
7673         }
7674
7675       if (val_14)
7676         {
7677           output_asm_insn ("bv %%r0(%%r1)", xoperands);
7678           output_asm_insn ("ldo %2(%%r26),%%r26", xoperands);
7679           nbytes += 20;
7680         }
7681       else
7682         {
7683           output_asm_insn ("bv,n %%r0(%%r1)", xoperands);
7684           nbytes += 24;
7685         }
7686     }
7687   else if (TARGET_PORTABLE_RUNTIME)
7688     {
7689       output_asm_insn ("ldil L'%0,%%r1", xoperands);
7690       output_asm_insn ("ldo R'%0(%%r1),%%r22", xoperands);
7691
7692       if (!val_14)
7693         output_asm_insn ("addil L'%2,%%r26", xoperands);
7694
7695       output_asm_insn ("bv %%r0(%%r22)", xoperands);
7696
7697       if (val_14)
7698         {
7699           output_asm_insn ("ldo %2(%%r26),%%r26", xoperands);
7700           nbytes += 16;
7701         }
7702       else
7703         {
7704           output_asm_insn ("ldo R'%2(%%r1),%%r26", xoperands);
7705           nbytes += 20;
7706         }
7707     }
7708   else if (TARGET_SOM && flag_pic && TREE_PUBLIC (function))
7709     {
7710       /* The function is accessible from outside this module.  The only
7711          way to avoid an import stub between the thunk and function is to
7712          call the function directly with an indirect sequence similar to
7713          that used by $$dyncall.  This is possible because $$dyncall acts
7714          as the import stub in an indirect call.  */
7715       ASM_GENERATE_INTERNAL_LABEL (label, "LTHN", current_thunk_number);
7716       xoperands[3] = gen_rtx_SYMBOL_REF (Pmode, label);
7717       output_asm_insn ("addil LT'%3,%%r19", xoperands);
7718       output_asm_insn ("ldw RT'%3(%%r1),%%r22", xoperands);
7719       output_asm_insn ("ldw 0(%%sr0,%%r22),%%r22", xoperands);
7720       output_asm_insn ("bb,>=,n %%r22,30,.+16", xoperands);
7721       output_asm_insn ("depi 0,31,2,%%r22", xoperands);
7722       output_asm_insn ("ldw 4(%%sr0,%%r22),%%r19", xoperands);
7723       output_asm_insn ("ldw 0(%%sr0,%%r22),%%r22", xoperands);
7724
7725       if (!val_14)
7726         {
7727           output_asm_insn ("addil L'%2,%%r26", xoperands);
7728           nbytes += 4;
7729         }
7730
7731       if (TARGET_PA_20)
7732         {
7733           output_asm_insn ("bve (%%r22)", xoperands);
7734           nbytes += 36;
7735         }
7736       else if (TARGET_NO_SPACE_REGS)
7737         {
7738           output_asm_insn ("be 0(%%sr4,%%r22)", xoperands);
7739           nbytes += 36;
7740         }
7741       else
7742         {
7743           output_asm_insn ("ldsid (%%sr0,%%r22),%%r21", xoperands);
7744           output_asm_insn ("mtsp %%r21,%%sr0", xoperands);
7745           output_asm_insn ("be 0(%%sr0,%%r22)", xoperands);
7746           nbytes += 44;
7747         }
7748
7749       if (val_14)
7750         output_asm_insn ("ldo %2(%%r26),%%r26", xoperands);
7751       else
7752         output_asm_insn ("ldo R'%2(%%r1),%%r26", xoperands);
7753     }
7754   else if (flag_pic)
7755     {
7756       output_asm_insn ("{bl|b,l} .+8,%%r1", xoperands);
7757
7758       if (TARGET_SOM || !TARGET_GAS)
7759         {
7760           output_asm_insn ("addil L'%0-%1-8,%%r1", xoperands);
7761           output_asm_insn ("ldo R'%0-%1-8(%%r1),%%r22", xoperands);
7762         }
7763       else
7764         {
7765           output_asm_insn ("addil L'%0-$PIC_pcrel$0+4,%%r1", xoperands);
7766           output_asm_insn ("ldo R'%0-$PIC_pcrel$0+8(%%r1),%%r22", xoperands);
7767         }
7768
7769       if (!val_14)
7770         output_asm_insn ("addil L'%2,%%r26", xoperands);
7771
7772       output_asm_insn ("bv %%r0(%%r22)", xoperands);
7773
7774       if (val_14)
7775         {
7776           output_asm_insn ("ldo %2(%%r26),%%r26", xoperands);
7777           nbytes += 20;
7778         }
7779       else
7780         {
7781           output_asm_insn ("ldo R'%2(%%r1),%%r26", xoperands);
7782           nbytes += 24;
7783         }
7784     }
7785   else
7786     {
7787       if (!val_14)
7788         output_asm_insn ("addil L'%2,%%r26", xoperands);
7789
7790       output_asm_insn ("ldil L'%0,%%r22", xoperands);
7791       output_asm_insn ("be R'%0(%%sr4,%%r22)", xoperands);
7792
7793       if (val_14)
7794         {
7795           output_asm_insn ("ldo %2(%%r26),%%r26", xoperands);
7796           nbytes += 12;
7797         }
7798       else
7799         {
7800           output_asm_insn ("ldo R'%2(%%r1),%%r26", xoperands);
7801           nbytes += 16;
7802         }
7803     }
7804
7805   fprintf (file, "\t.EXIT\n\t.PROCEND\n");
7806
7807   if (TARGET_SOM && TARGET_GAS)
7808     {
7809       /* We done with this subspace except possibly for some additional
7810          debug information.  Forget that we are in this subspace to ensure
7811          that the next function is output in its own subspace.  */
7812       in_section = NULL;
7813       cfun->machine->in_nsubspa = 2;
7814     }
7815
7816   if (TARGET_SOM && flag_pic && TREE_PUBLIC (function))
7817     {
7818       switch_to_section (data_section);
7819       output_asm_insn (".align 4", xoperands);
7820       ASM_OUTPUT_LABEL (file, label);
7821       output_asm_insn (".word P'%0", xoperands);
7822     }
7823
7824   current_thunk_number++;
7825   nbytes = ((nbytes + FUNCTION_BOUNDARY / BITS_PER_UNIT - 1)
7826             & ~(FUNCTION_BOUNDARY / BITS_PER_UNIT - 1));
7827   last_address += nbytes;
7828   update_total_code_bytes (nbytes);
7829 }
7830
7831 /* Only direct calls to static functions are allowed to be sibling (tail)
7832    call optimized.
7833
7834    This restriction is necessary because some linker generated stubs will
7835    store return pointers into rp' in some cases which might clobber a
7836    live value already in rp'.
7837
7838    In a sibcall the current function and the target function share stack
7839    space.  Thus if the path to the current function and the path to the
7840    target function save a value in rp', they save the value into the
7841    same stack slot, which has undesirable consequences.
7842
7843    Because of the deferred binding nature of shared libraries any function
7844    with external scope could be in a different load module and thus require
7845    rp' to be saved when calling that function.  So sibcall optimizations
7846    can only be safe for static function.
7847
7848    Note that GCC never needs return value relocations, so we don't have to
7849    worry about static calls with return value relocations (which require
7850    saving rp').
7851
7852    It is safe to perform a sibcall optimization when the target function
7853    will never return.  */
7854 static bool
7855 pa_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
7856 {
7857   if (TARGET_PORTABLE_RUNTIME)
7858     return false;
7859
7860   /* Sibcalls are ok for TARGET_ELF32 as along as the linker is used in
7861      single subspace mode and the call is not indirect.  As far as I know,
7862      there is no operating system support for the multiple subspace mode.
7863      It might be possible to support indirect calls if we didn't use
7864      $$dyncall (see the indirect sequence generated in output_call).  */
7865   if (TARGET_ELF32)
7866     return (decl != NULL_TREE);
7867
7868   /* Sibcalls are not ok because the arg pointer register is not a fixed
7869      register.  This prevents the sibcall optimization from occurring.  In
7870      addition, there are problems with stub placement using GNU ld.  This
7871      is because a normal sibcall branch uses a 17-bit relocation while
7872      a regular call branch uses a 22-bit relocation.  As a result, more
7873      care needs to be taken in the placement of long-branch stubs.  */
7874   if (TARGET_64BIT)
7875     return false;
7876
7877   /* Sibcalls are only ok within a translation unit.  */
7878   return (decl && !TREE_PUBLIC (decl));
7879 }
7880
7881 /* ??? Addition is not commutative on the PA due to the weird implicit
7882    space register selection rules for memory addresses.  Therefore, we
7883    don't consider a + b == b + a, as this might be inside a MEM.  */
7884 static bool
7885 pa_commutative_p (rtx x, int outer_code)
7886 {
7887   return (COMMUTATIVE_P (x)
7888           && (TARGET_NO_SPACE_REGS
7889               || (outer_code != UNKNOWN && outer_code != MEM)
7890               || GET_CODE (x) != PLUS));
7891 }
7892
7893 /* Returns 1 if the 6 operands specified in OPERANDS are suitable for
7894    use in fmpyadd instructions.  */
7895 int
7896 fmpyaddoperands (rtx *operands)
7897 {
7898   enum machine_mode mode = GET_MODE (operands[0]);
7899
7900   /* Must be a floating point mode.  */
7901   if (mode != SFmode && mode != DFmode)
7902     return 0;
7903
7904   /* All modes must be the same.  */
7905   if (! (mode == GET_MODE (operands[1])
7906          && mode == GET_MODE (operands[2])
7907          && mode == GET_MODE (operands[3])
7908          && mode == GET_MODE (operands[4])
7909          && mode == GET_MODE (operands[5])))
7910     return 0;
7911
7912   /* All operands must be registers.  */
7913   if (! (GET_CODE (operands[1]) == REG
7914          && GET_CODE (operands[2]) == REG
7915          && GET_CODE (operands[3]) == REG
7916          && GET_CODE (operands[4]) == REG
7917          && GET_CODE (operands[5]) == REG))
7918     return 0;
7919
7920   /* Only 2 real operands to the addition.  One of the input operands must
7921      be the same as the output operand.  */
7922   if (! rtx_equal_p (operands[3], operands[4])
7923       && ! rtx_equal_p (operands[3], operands[5]))
7924     return 0;
7925
7926   /* Inout operand of add cannot conflict with any operands from multiply.  */
7927   if (rtx_equal_p (operands[3], operands[0])
7928      || rtx_equal_p (operands[3], operands[1])
7929      || rtx_equal_p (operands[3], operands[2]))
7930     return 0;
7931
7932   /* multiply cannot feed into addition operands.  */
7933   if (rtx_equal_p (operands[4], operands[0])
7934       || rtx_equal_p (operands[5], operands[0]))
7935     return 0;
7936
7937   /* SFmode limits the registers to the upper 32 of the 32bit FP regs.  */
7938   if (mode == SFmode
7939       && (REGNO_REG_CLASS (REGNO (operands[0])) != FPUPPER_REGS
7940           || REGNO_REG_CLASS (REGNO (operands[1])) != FPUPPER_REGS
7941           || REGNO_REG_CLASS (REGNO (operands[2])) != FPUPPER_REGS
7942           || REGNO_REG_CLASS (REGNO (operands[3])) != FPUPPER_REGS
7943           || REGNO_REG_CLASS (REGNO (operands[4])) != FPUPPER_REGS
7944           || REGNO_REG_CLASS (REGNO (operands[5])) != FPUPPER_REGS))
7945     return 0;
7946
7947   /* Passed.  Operands are suitable for fmpyadd.  */
7948   return 1;
7949 }
7950
7951 #if !defined(USE_COLLECT2)
7952 static void
7953 pa_asm_out_constructor (rtx symbol, int priority)
7954 {
7955   if (!function_label_operand (symbol, VOIDmode))
7956     hppa_encode_label (symbol);
7957
7958 #ifdef CTORS_SECTION_ASM_OP
7959   default_ctor_section_asm_out_constructor (symbol, priority);
7960 #else
7961 # ifdef TARGET_ASM_NAMED_SECTION
7962   default_named_section_asm_out_constructor (symbol, priority);
7963 # else
7964   default_stabs_asm_out_constructor (symbol, priority);
7965 # endif
7966 #endif
7967 }
7968
7969 static void
7970 pa_asm_out_destructor (rtx symbol, int priority)
7971 {
7972   if (!function_label_operand (symbol, VOIDmode))
7973     hppa_encode_label (symbol);
7974
7975 #ifdef DTORS_SECTION_ASM_OP
7976   default_dtor_section_asm_out_destructor (symbol, priority);
7977 #else
7978 # ifdef TARGET_ASM_NAMED_SECTION
7979   default_named_section_asm_out_destructor (symbol, priority);
7980 # else
7981   default_stabs_asm_out_destructor (symbol, priority);
7982 # endif
7983 #endif
7984 }
7985 #endif
7986
7987 /* This function places uninitialized global data in the bss section.
7988    The ASM_OUTPUT_ALIGNED_BSS macro needs to be defined to call this
7989    function on the SOM port to prevent uninitialized global data from
7990    being placed in the data section.  */
7991
7992 void
7993 pa_asm_output_aligned_bss (FILE *stream,
7994                            const char *name,
7995                            unsigned HOST_WIDE_INT size,
7996                            unsigned int align)
7997 {
7998   switch_to_section (bss_section);
7999   fprintf (stream, "\t.align %u\n", align / BITS_PER_UNIT);
8000
8001 #ifdef ASM_OUTPUT_TYPE_DIRECTIVE
8002   ASM_OUTPUT_TYPE_DIRECTIVE (stream, name, "object");
8003 #endif
8004
8005 #ifdef ASM_OUTPUT_SIZE_DIRECTIVE
8006   ASM_OUTPUT_SIZE_DIRECTIVE (stream, name, size);
8007 #endif
8008
8009   fprintf (stream, "\t.align %u\n", align / BITS_PER_UNIT);
8010   ASM_OUTPUT_LABEL (stream, name);
8011   fprintf (stream, "\t.block "HOST_WIDE_INT_PRINT_UNSIGNED"\n", size);
8012 }
8013
8014 /* Both the HP and GNU assemblers under HP-UX provide a .comm directive
8015    that doesn't allow the alignment of global common storage to be directly
8016    specified.  The SOM linker aligns common storage based on the rounded
8017    value of the NUM_BYTES parameter in the .comm directive.  It's not
8018    possible to use the .align directive as it doesn't affect the alignment
8019    of the label associated with a .comm directive.  */
8020
8021 void
8022 pa_asm_output_aligned_common (FILE *stream,
8023                               const char *name,
8024                               unsigned HOST_WIDE_INT size,
8025                               unsigned int align)
8026 {
8027   unsigned int max_common_align;
8028
8029   max_common_align = TARGET_64BIT ? 128 : (size >= 4096 ? 256 : 64);
8030   if (align > max_common_align)
8031     {
8032       warning (0, "alignment (%u) for %s exceeds maximum alignment "
8033                "for global common data.  Using %u",
8034                align / BITS_PER_UNIT, name, max_common_align / BITS_PER_UNIT);
8035       align = max_common_align;
8036     }
8037
8038   switch_to_section (bss_section);
8039
8040   assemble_name (stream, name);
8041   fprintf (stream, "\t.comm "HOST_WIDE_INT_PRINT_UNSIGNED"\n",
8042            MAX (size, align / BITS_PER_UNIT));
8043 }
8044
8045 /* We can't use .comm for local common storage as the SOM linker effectively
8046    treats the symbol as universal and uses the same storage for local symbols
8047    with the same name in different object files.  The .block directive
8048    reserves an uninitialized block of storage.  However, it's not common
8049    storage.  Fortunately, GCC never requests common storage with the same
8050    name in any given translation unit.  */
8051
8052 void
8053 pa_asm_output_aligned_local (FILE *stream,
8054                              const char *name,
8055                              unsigned HOST_WIDE_INT size,
8056                              unsigned int align)
8057 {
8058   switch_to_section (bss_section);
8059   fprintf (stream, "\t.align %u\n", align / BITS_PER_UNIT);
8060
8061 #ifdef LOCAL_ASM_OP
8062   fprintf (stream, "%s", LOCAL_ASM_OP);
8063   assemble_name (stream, name);
8064   fprintf (stream, "\n");
8065 #endif
8066
8067   ASM_OUTPUT_LABEL (stream, name);
8068   fprintf (stream, "\t.block "HOST_WIDE_INT_PRINT_UNSIGNED"\n", size);
8069 }
8070
8071 /* Returns 1 if the 6 operands specified in OPERANDS are suitable for
8072    use in fmpysub instructions.  */
8073 int
8074 fmpysuboperands (rtx *operands)
8075 {
8076   enum machine_mode mode = GET_MODE (operands[0]);
8077
8078   /* Must be a floating point mode.  */
8079   if (mode != SFmode && mode != DFmode)
8080     return 0;
8081
8082   /* All modes must be the same.  */
8083   if (! (mode == GET_MODE (operands[1])
8084          && mode == GET_MODE (operands[2])
8085          && mode == GET_MODE (operands[3])
8086          && mode == GET_MODE (operands[4])
8087          && mode == GET_MODE (operands[5])))
8088     return 0;
8089
8090   /* All operands must be registers.  */
8091   if (! (GET_CODE (operands[1]) == REG
8092          && GET_CODE (operands[2]) == REG
8093          && GET_CODE (operands[3]) == REG
8094          && GET_CODE (operands[4]) == REG
8095          && GET_CODE (operands[5]) == REG))
8096     return 0;
8097
8098   /* Only 2 real operands to the subtraction.  Subtraction is not a commutative
8099      operation, so operands[4] must be the same as operand[3].  */
8100   if (! rtx_equal_p (operands[3], operands[4]))
8101     return 0;
8102
8103   /* multiply cannot feed into subtraction.  */
8104   if (rtx_equal_p (operands[5], operands[0]))
8105     return 0;
8106
8107   /* Inout operand of sub cannot conflict with any operands from multiply.  */
8108   if (rtx_equal_p (operands[3], operands[0])
8109      || rtx_equal_p (operands[3], operands[1])
8110      || rtx_equal_p (operands[3], operands[2]))
8111     return 0;
8112
8113   /* SFmode limits the registers to the upper 32 of the 32bit FP regs.  */
8114   if (mode == SFmode
8115       && (REGNO_REG_CLASS (REGNO (operands[0])) != FPUPPER_REGS
8116           || REGNO_REG_CLASS (REGNO (operands[1])) != FPUPPER_REGS
8117           || REGNO_REG_CLASS (REGNO (operands[2])) != FPUPPER_REGS
8118           || REGNO_REG_CLASS (REGNO (operands[3])) != FPUPPER_REGS
8119           || REGNO_REG_CLASS (REGNO (operands[4])) != FPUPPER_REGS
8120           || REGNO_REG_CLASS (REGNO (operands[5])) != FPUPPER_REGS))
8121     return 0;
8122
8123   /* Passed.  Operands are suitable for fmpysub.  */
8124   return 1;
8125 }
8126
8127 /* Return 1 if the given constant is 2, 4, or 8.  These are the valid
8128    constants for shadd instructions.  */
8129 int
8130 shadd_constant_p (int val)
8131 {
8132   if (val == 2 || val == 4 || val == 8)
8133     return 1;
8134   else
8135     return 0;
8136 }
8137
8138 /* Return 1 if OP is valid as a base or index register in a
8139    REG+REG address.  */
8140
8141 int
8142 borx_reg_operand (rtx op, enum machine_mode mode)
8143 {
8144   if (GET_CODE (op) != REG)
8145     return 0;
8146
8147   /* We must reject virtual registers as the only expressions that
8148      can be instantiated are REG and REG+CONST.  */
8149   if (op == virtual_incoming_args_rtx
8150       || op == virtual_stack_vars_rtx
8151       || op == virtual_stack_dynamic_rtx
8152       || op == virtual_outgoing_args_rtx
8153       || op == virtual_cfa_rtx)
8154     return 0;
8155
8156   /* While it's always safe to index off the frame pointer, it's not
8157      profitable to do so when the frame pointer is being eliminated.  */
8158   if (!reload_completed
8159       && flag_omit_frame_pointer
8160       && !current_function_calls_alloca
8161       && op == frame_pointer_rtx)
8162     return 0;
8163
8164   return register_operand (op, mode);
8165 }
8166
8167 /* Return 1 if this operand is anything other than a hard register.  */
8168
8169 int
8170 non_hard_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
8171 {
8172   return ! (GET_CODE (op) == REG && REGNO (op) < FIRST_PSEUDO_REGISTER);
8173 }
8174
8175 /* Return 1 if INSN branches forward.  Should be using insn_addresses
8176    to avoid walking through all the insns...  */
8177 static int
8178 forward_branch_p (rtx insn)
8179 {
8180   rtx label = JUMP_LABEL (insn);
8181
8182   while (insn)
8183     {
8184       if (insn == label)
8185         break;
8186       else
8187         insn = NEXT_INSN (insn);
8188     }
8189
8190   return (insn == label);
8191 }
8192
8193 /* Return 1 if OP is an equality comparison, else return 0.  */
8194 int
8195 eq_neq_comparison_operator (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
8196 {
8197   return (GET_CODE (op) == EQ || GET_CODE (op) == NE);
8198 }
8199
8200 /* Return 1 if INSN is in the delay slot of a call instruction.  */
8201 int
8202 jump_in_call_delay (rtx insn)
8203 {
8204
8205   if (GET_CODE (insn) != JUMP_INSN)
8206     return 0;
8207
8208   if (PREV_INSN (insn)
8209       && PREV_INSN (PREV_INSN (insn))
8210       && GET_CODE (next_real_insn (PREV_INSN (PREV_INSN (insn)))) == INSN)
8211     {
8212       rtx test_insn = next_real_insn (PREV_INSN (PREV_INSN (insn)));
8213
8214       return (GET_CODE (PATTERN (test_insn)) == SEQUENCE
8215               && XVECEXP (PATTERN (test_insn), 0, 1) == insn);
8216
8217     }
8218   else
8219     return 0;
8220 }
8221
8222 /* Output an unconditional move and branch insn.  */
8223
8224 const char *
8225 output_parallel_movb (rtx *operands, int length)
8226 {
8227   /* These are the cases in which we win.  */
8228   if (length == 4)
8229     return "mov%I1b,tr %1,%0,%2";
8230
8231   /* None of these cases wins, but they don't lose either.  */
8232   if (dbr_sequence_length () == 0)
8233     {
8234       /* Nothing in the delay slot, fake it by putting the combined
8235          insn (the copy or add) in the delay slot of a bl.  */
8236       if (GET_CODE (operands[1]) == CONST_INT)
8237         return "b %2\n\tldi %1,%0";
8238       else
8239         return "b %2\n\tcopy %1,%0";
8240     }
8241   else
8242     {
8243       /* Something in the delay slot, but we've got a long branch.  */
8244       if (GET_CODE (operands[1]) == CONST_INT)
8245         return "ldi %1,%0\n\tb %2";
8246       else
8247         return "copy %1,%0\n\tb %2";
8248     }
8249 }
8250
8251 /* Output an unconditional add and branch insn.  */
8252
8253 const char *
8254 output_parallel_addb (rtx *operands, int length)
8255 {
8256   /* To make life easy we want operand0 to be the shared input/output
8257      operand and operand1 to be the readonly operand.  */
8258   if (operands[0] == operands[1])
8259     operands[1] = operands[2];
8260
8261   /* These are the cases in which we win.  */
8262   if (length == 4)
8263     return "add%I1b,tr %1,%0,%3";
8264
8265   /* None of these cases win, but they don't lose either.  */
8266   if (dbr_sequence_length () == 0)
8267     {
8268       /* Nothing in the delay slot, fake it by putting the combined
8269          insn (the copy or add) in the delay slot of a bl.  */
8270       return "b %3\n\tadd%I1 %1,%0,%0";
8271     }
8272   else
8273     {
8274       /* Something in the delay slot, but we've got a long branch.  */
8275       return "add%I1 %1,%0,%0\n\tb %3";
8276     }
8277 }
8278
8279 /* Return nonzero if INSN (a jump insn) immediately follows a call
8280    to a named function.  This is used to avoid filling the delay slot
8281    of the jump since it can usually be eliminated by modifying RP in
8282    the delay slot of the call.  */
8283
8284 int
8285 following_call (rtx insn)
8286 {
8287   if (! TARGET_JUMP_IN_DELAY)
8288     return 0;
8289
8290   /* Find the previous real insn, skipping NOTEs.  */
8291   insn = PREV_INSN (insn);
8292   while (insn && GET_CODE (insn) == NOTE)
8293     insn = PREV_INSN (insn);
8294
8295   /* Check for CALL_INSNs and millicode calls.  */
8296   if (insn
8297       && ((GET_CODE (insn) == CALL_INSN
8298            && get_attr_type (insn) != TYPE_DYNCALL)
8299           || (GET_CODE (insn) == INSN
8300               && GET_CODE (PATTERN (insn)) != SEQUENCE
8301               && GET_CODE (PATTERN (insn)) != USE
8302               && GET_CODE (PATTERN (insn)) != CLOBBER
8303               && get_attr_type (insn) == TYPE_MILLI)))
8304     return 1;
8305
8306   return 0;
8307 }
8308
8309 /* We use this hook to perform a PA specific optimization which is difficult
8310    to do in earlier passes.
8311
8312    We want the delay slots of branches within jump tables to be filled.
8313    None of the compiler passes at the moment even has the notion that a
8314    PA jump table doesn't contain addresses, but instead contains actual
8315    instructions!
8316
8317    Because we actually jump into the table, the addresses of each entry
8318    must stay constant in relation to the beginning of the table (which
8319    itself must stay constant relative to the instruction to jump into
8320    it).  I don't believe we can guarantee earlier passes of the compiler
8321    will adhere to those rules.
8322
8323    So, late in the compilation process we find all the jump tables, and
8324    expand them into real code -- e.g. each entry in the jump table vector
8325    will get an appropriate label followed by a jump to the final target.
8326
8327    Reorg and the final jump pass can then optimize these branches and
8328    fill their delay slots.  We end up with smaller, more efficient code.
8329
8330    The jump instructions within the table are special; we must be able
8331    to identify them during assembly output (if the jumps don't get filled
8332    we need to emit a nop rather than nullifying the delay slot)).  We
8333    identify jumps in switch tables by using insns with the attribute
8334    type TYPE_BTABLE_BRANCH.
8335
8336    We also surround the jump table itself with BEGIN_BRTAB and END_BRTAB
8337    insns.  This serves two purposes, first it prevents jump.c from
8338    noticing that the last N entries in the table jump to the instruction
8339    immediately after the table and deleting the jumps.  Second, those
8340    insns mark where we should emit .begin_brtab and .end_brtab directives
8341    when using GAS (allows for better link time optimizations).  */
8342
8343 static void
8344 pa_reorg (void)
8345 {
8346   rtx insn;
8347
8348   remove_useless_addtr_insns (1);
8349
8350   if (pa_cpu < PROCESSOR_8000)
8351     pa_combine_instructions ();
8352
8353
8354   /* This is fairly cheap, so always run it if optimizing.  */
8355   if (optimize > 0 && !TARGET_BIG_SWITCH)
8356     {
8357       /* Find and explode all ADDR_VEC or ADDR_DIFF_VEC insns.  */
8358       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
8359         {
8360           rtx pattern, tmp, location, label;
8361           unsigned int length, i;
8362
8363           /* Find an ADDR_VEC or ADDR_DIFF_VEC insn to explode.  */
8364           if (GET_CODE (insn) != JUMP_INSN
8365               || (GET_CODE (PATTERN (insn)) != ADDR_VEC
8366                   && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC))
8367             continue;
8368
8369           /* Emit marker for the beginning of the branch table.  */
8370           emit_insn_before (gen_begin_brtab (), insn);
8371
8372           pattern = PATTERN (insn);
8373           location = PREV_INSN (insn);
8374           length = XVECLEN (pattern, GET_CODE (pattern) == ADDR_DIFF_VEC);
8375
8376           for (i = 0; i < length; i++)
8377             {
8378               /* Emit a label before each jump to keep jump.c from
8379                  removing this code.  */
8380               tmp = gen_label_rtx ();
8381               LABEL_NUSES (tmp) = 1;
8382               emit_label_after (tmp, location);
8383               location = NEXT_INSN (location);
8384
8385               if (GET_CODE (pattern) == ADDR_VEC)
8386                 label = XEXP (XVECEXP (pattern, 0, i), 0);
8387               else
8388                 label = XEXP (XVECEXP (pattern, 1, i), 0);
8389
8390               tmp = gen_short_jump (label);
8391
8392               /* Emit the jump itself.  */
8393               tmp = emit_jump_insn_after (tmp, location);
8394               JUMP_LABEL (tmp) = label;
8395               LABEL_NUSES (label)++;
8396               location = NEXT_INSN (location);
8397
8398               /* Emit a BARRIER after the jump.  */
8399               emit_barrier_after (location);
8400               location = NEXT_INSN (location);
8401             }
8402
8403           /* Emit marker for the end of the branch table.  */
8404           emit_insn_before (gen_end_brtab (), location);
8405           location = NEXT_INSN (location);
8406           emit_barrier_after (location);
8407
8408           /* Delete the ADDR_VEC or ADDR_DIFF_VEC.  */
8409           delete_insn (insn);
8410         }
8411     }
8412   else
8413     {
8414       /* Still need brtab marker insns.  FIXME: the presence of these
8415          markers disables output of the branch table to readonly memory,
8416          and any alignment directives that might be needed.  Possibly,
8417          the begin_brtab insn should be output before the label for the
8418          table.  This doesn't matter at the moment since the tables are
8419          always output in the text section.  */
8420       for (insn = get_insns (); insn; insn = NEXT_INSN (insn))
8421         {
8422           /* Find an ADDR_VEC insn.  */
8423           if (GET_CODE (insn) != JUMP_INSN
8424               || (GET_CODE (PATTERN (insn)) != ADDR_VEC
8425                   && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC))
8426             continue;
8427
8428           /* Now generate markers for the beginning and end of the
8429              branch table.  */
8430           emit_insn_before (gen_begin_brtab (), insn);
8431           emit_insn_after (gen_end_brtab (), insn);
8432         }
8433     }
8434 }
8435
8436 /* The PA has a number of odd instructions which can perform multiple
8437    tasks at once.  On first generation PA machines (PA1.0 and PA1.1)
8438    it may be profitable to combine two instructions into one instruction
8439    with two outputs.  It's not profitable PA2.0 machines because the
8440    two outputs would take two slots in the reorder buffers.
8441
8442    This routine finds instructions which can be combined and combines
8443    them.  We only support some of the potential combinations, and we
8444    only try common ways to find suitable instructions.
8445
8446       * addb can add two registers or a register and a small integer
8447       and jump to a nearby (+-8k) location.  Normally the jump to the
8448       nearby location is conditional on the result of the add, but by
8449       using the "true" condition we can make the jump unconditional.
8450       Thus addb can perform two independent operations in one insn.
8451
8452       * movb is similar to addb in that it can perform a reg->reg
8453       or small immediate->reg copy and jump to a nearby (+-8k location).
8454
8455       * fmpyadd and fmpysub can perform a FP multiply and either an
8456       FP add or FP sub if the operands of the multiply and add/sub are
8457       independent (there are other minor restrictions).  Note both
8458       the fmpy and fadd/fsub can in theory move to better spots according
8459       to data dependencies, but for now we require the fmpy stay at a
8460       fixed location.
8461
8462       * Many of the memory operations can perform pre & post updates
8463       of index registers.  GCC's pre/post increment/decrement addressing
8464       is far too simple to take advantage of all the possibilities.  This
8465       pass may not be suitable since those insns may not be independent.
8466
8467       * comclr can compare two ints or an int and a register, nullify
8468       the following instruction and zero some other register.  This
8469       is more difficult to use as it's harder to find an insn which
8470       will generate a comclr than finding something like an unconditional
8471       branch.  (conditional moves & long branches create comclr insns).
8472
8473       * Most arithmetic operations can conditionally skip the next
8474       instruction.  They can be viewed as "perform this operation
8475       and conditionally jump to this nearby location" (where nearby
8476       is an insns away).  These are difficult to use due to the
8477       branch length restrictions.  */
8478
8479 static void
8480 pa_combine_instructions (void)
8481 {
8482   rtx anchor, new;
8483
8484   /* This can get expensive since the basic algorithm is on the
8485      order of O(n^2) (or worse).  Only do it for -O2 or higher
8486      levels of optimization.  */
8487   if (optimize < 2)
8488     return;
8489
8490   /* Walk down the list of insns looking for "anchor" insns which
8491      may be combined with "floating" insns.  As the name implies,
8492      "anchor" instructions don't move, while "floating" insns may
8493      move around.  */
8494   new = gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2, NULL_RTX, NULL_RTX));
8495   new = make_insn_raw (new);
8496
8497   for (anchor = get_insns (); anchor; anchor = NEXT_INSN (anchor))
8498     {
8499       enum attr_pa_combine_type anchor_attr;
8500       enum attr_pa_combine_type floater_attr;
8501
8502       /* We only care about INSNs, JUMP_INSNs, and CALL_INSNs.
8503          Also ignore any special USE insns.  */
8504       if ((GET_CODE (anchor) != INSN
8505           && GET_CODE (anchor) != JUMP_INSN
8506           && GET_CODE (anchor) != CALL_INSN)
8507           || GET_CODE (PATTERN (anchor)) == USE
8508           || GET_CODE (PATTERN (anchor)) == CLOBBER
8509           || GET_CODE (PATTERN (anchor)) == ADDR_VEC
8510           || GET_CODE (PATTERN (anchor)) == ADDR_DIFF_VEC)
8511         continue;
8512
8513       anchor_attr = get_attr_pa_combine_type (anchor);
8514       /* See if anchor is an insn suitable for combination.  */
8515       if (anchor_attr == PA_COMBINE_TYPE_FMPY
8516           || anchor_attr == PA_COMBINE_TYPE_FADDSUB
8517           || (anchor_attr == PA_COMBINE_TYPE_UNCOND_BRANCH
8518               && ! forward_branch_p (anchor)))
8519         {
8520           rtx floater;
8521
8522           for (floater = PREV_INSN (anchor);
8523                floater;
8524                floater = PREV_INSN (floater))
8525             {
8526               if (GET_CODE (floater) == NOTE
8527                   || (GET_CODE (floater) == INSN
8528                       && (GET_CODE (PATTERN (floater)) == USE
8529                           || GET_CODE (PATTERN (floater)) == CLOBBER)))
8530                 continue;
8531
8532               /* Anything except a regular INSN will stop our search.  */
8533               if (GET_CODE (floater) != INSN
8534                   || GET_CODE (PATTERN (floater)) == ADDR_VEC
8535                   || GET_CODE (PATTERN (floater)) == ADDR_DIFF_VEC)
8536                 {
8537                   floater = NULL_RTX;
8538                   break;
8539                 }
8540
8541               /* See if FLOATER is suitable for combination with the
8542                  anchor.  */
8543               floater_attr = get_attr_pa_combine_type (floater);
8544               if ((anchor_attr == PA_COMBINE_TYPE_FMPY
8545                    && floater_attr == PA_COMBINE_TYPE_FADDSUB)
8546                   || (anchor_attr == PA_COMBINE_TYPE_FADDSUB
8547                       && floater_attr == PA_COMBINE_TYPE_FMPY))
8548                 {
8549                   /* If ANCHOR and FLOATER can be combined, then we're
8550                      done with this pass.  */
8551                   if (pa_can_combine_p (new, anchor, floater, 0,
8552                                         SET_DEST (PATTERN (floater)),
8553                                         XEXP (SET_SRC (PATTERN (floater)), 0),
8554                                         XEXP (SET_SRC (PATTERN (floater)), 1)))
8555                     break;
8556                 }
8557
8558               else if (anchor_attr == PA_COMBINE_TYPE_UNCOND_BRANCH
8559                        && floater_attr == PA_COMBINE_TYPE_ADDMOVE)
8560                 {
8561                   if (GET_CODE (SET_SRC (PATTERN (floater))) == PLUS)
8562                     {
8563                       if (pa_can_combine_p (new, anchor, floater, 0,
8564                                             SET_DEST (PATTERN (floater)),
8565                                         XEXP (SET_SRC (PATTERN (floater)), 0),
8566                                         XEXP (SET_SRC (PATTERN (floater)), 1)))
8567                         break;
8568                     }
8569                   else
8570                     {
8571                       if (pa_can_combine_p (new, anchor, floater, 0,
8572                                             SET_DEST (PATTERN (floater)),
8573                                             SET_SRC (PATTERN (floater)),
8574                                             SET_SRC (PATTERN (floater))))
8575                         break;
8576                     }
8577                 }
8578             }
8579
8580           /* If we didn't find anything on the backwards scan try forwards.  */
8581           if (!floater
8582               && (anchor_attr == PA_COMBINE_TYPE_FMPY
8583                   || anchor_attr == PA_COMBINE_TYPE_FADDSUB))
8584             {
8585               for (floater = anchor; floater; floater = NEXT_INSN (floater))
8586                 {
8587                   if (GET_CODE (floater) == NOTE
8588                       || (GET_CODE (floater) == INSN
8589                           && (GET_CODE (PATTERN (floater)) == USE
8590                               || GET_CODE (PATTERN (floater)) == CLOBBER)))
8591
8592                     continue;
8593
8594                   /* Anything except a regular INSN will stop our search.  */
8595                   if (GET_CODE (floater) != INSN
8596                       || GET_CODE (PATTERN (floater)) == ADDR_VEC
8597                       || GET_CODE (PATTERN (floater)) == ADDR_DIFF_VEC)
8598                     {
8599                       floater = NULL_RTX;
8600                       break;
8601                     }
8602
8603                   /* See if FLOATER is suitable for combination with the
8604                      anchor.  */
8605                   floater_attr = get_attr_pa_combine_type (floater);
8606                   if ((anchor_attr == PA_COMBINE_TYPE_FMPY
8607                        && floater_attr == PA_COMBINE_TYPE_FADDSUB)
8608                       || (anchor_attr == PA_COMBINE_TYPE_FADDSUB
8609                           && floater_attr == PA_COMBINE_TYPE_FMPY))
8610                     {
8611                       /* If ANCHOR and FLOATER can be combined, then we're
8612                          done with this pass.  */
8613                       if (pa_can_combine_p (new, anchor, floater, 1,
8614                                             SET_DEST (PATTERN (floater)),
8615                                             XEXP (SET_SRC (PATTERN (floater)),
8616                                                   0),
8617                                             XEXP (SET_SRC (PATTERN (floater)),
8618                                                   1)))
8619                         break;
8620                     }
8621                 }
8622             }
8623
8624           /* FLOATER will be nonzero if we found a suitable floating
8625              insn for combination with ANCHOR.  */
8626           if (floater
8627               && (anchor_attr == PA_COMBINE_TYPE_FADDSUB
8628                   || anchor_attr == PA_COMBINE_TYPE_FMPY))
8629             {
8630               /* Emit the new instruction and delete the old anchor.  */
8631               emit_insn_before (gen_rtx_PARALLEL
8632                                 (VOIDmode,
8633                                  gen_rtvec (2, PATTERN (anchor),
8634                                             PATTERN (floater))),
8635                                 anchor);
8636
8637               PUT_CODE (anchor, NOTE);
8638               NOTE_LINE_NUMBER (anchor) = NOTE_INSN_DELETED;
8639               NOTE_SOURCE_FILE (anchor) = 0;
8640
8641               /* Emit a special USE insn for FLOATER, then delete
8642                  the floating insn.  */
8643               emit_insn_before (gen_rtx_USE (VOIDmode, floater), floater);
8644               delete_insn (floater);
8645
8646               continue;
8647             }
8648           else if (floater
8649                    && anchor_attr == PA_COMBINE_TYPE_UNCOND_BRANCH)
8650             {
8651               rtx temp;
8652               /* Emit the new_jump instruction and delete the old anchor.  */
8653               temp
8654                 = emit_jump_insn_before (gen_rtx_PARALLEL
8655                                          (VOIDmode,
8656                                           gen_rtvec (2, PATTERN (anchor),
8657                                                      PATTERN (floater))),
8658                                          anchor);
8659
8660               JUMP_LABEL (temp) = JUMP_LABEL (anchor);
8661               PUT_CODE (anchor, NOTE);
8662               NOTE_LINE_NUMBER (anchor) = NOTE_INSN_DELETED;
8663               NOTE_SOURCE_FILE (anchor) = 0;
8664
8665               /* Emit a special USE insn for FLOATER, then delete
8666                  the floating insn.  */
8667               emit_insn_before (gen_rtx_USE (VOIDmode, floater), floater);
8668               delete_insn (floater);
8669               continue;
8670             }
8671         }
8672     }
8673 }
8674
8675 static int
8676 pa_can_combine_p (rtx new, rtx anchor, rtx floater, int reversed, rtx dest,
8677                   rtx src1, rtx src2)
8678 {
8679   int insn_code_number;
8680   rtx start, end;
8681
8682   /* Create a PARALLEL with the patterns of ANCHOR and
8683      FLOATER, try to recognize it, then test constraints
8684      for the resulting pattern.
8685
8686      If the pattern doesn't match or the constraints
8687      aren't met keep searching for a suitable floater
8688      insn.  */
8689   XVECEXP (PATTERN (new), 0, 0) = PATTERN (anchor);
8690   XVECEXP (PATTERN (new), 0, 1) = PATTERN (floater);
8691   INSN_CODE (new) = -1;
8692   insn_code_number = recog_memoized (new);
8693   if (insn_code_number < 0
8694       || (extract_insn (new), ! constrain_operands (1)))
8695     return 0;
8696
8697   if (reversed)
8698     {
8699       start = anchor;
8700       end = floater;
8701     }
8702   else
8703     {
8704       start = floater;
8705       end = anchor;
8706     }
8707
8708   /* There's up to three operands to consider.  One
8709      output and two inputs.
8710
8711      The output must not be used between FLOATER & ANCHOR
8712      exclusive.  The inputs must not be set between
8713      FLOATER and ANCHOR exclusive.  */
8714
8715   if (reg_used_between_p (dest, start, end))
8716     return 0;
8717
8718   if (reg_set_between_p (src1, start, end))
8719     return 0;
8720
8721   if (reg_set_between_p (src2, start, end))
8722     return 0;
8723
8724   /* If we get here, then everything is good.  */
8725   return 1;
8726 }
8727
8728 /* Return nonzero if references for INSN are delayed.
8729
8730    Millicode insns are actually function calls with some special
8731    constraints on arguments and register usage.
8732
8733    Millicode calls always expect their arguments in the integer argument
8734    registers, and always return their result in %r29 (ret1).  They
8735    are expected to clobber their arguments, %r1, %r29, and the return
8736    pointer which is %r31 on 32-bit and %r2 on 64-bit, and nothing else.
8737
8738    This function tells reorg that the references to arguments and
8739    millicode calls do not appear to happen until after the millicode call.
8740    This allows reorg to put insns which set the argument registers into the
8741    delay slot of the millicode call -- thus they act more like traditional
8742    CALL_INSNs.
8743
8744    Note we cannot consider side effects of the insn to be delayed because
8745    the branch and link insn will clobber the return pointer.  If we happened
8746    to use the return pointer in the delay slot of the call, then we lose.
8747
8748    get_attr_type will try to recognize the given insn, so make sure to
8749    filter out things it will not accept -- SEQUENCE, USE and CLOBBER insns
8750    in particular.  */
8751 int
8752 insn_refs_are_delayed (rtx insn)
8753 {
8754   return ((GET_CODE (insn) == INSN
8755            && GET_CODE (PATTERN (insn)) != SEQUENCE
8756            && GET_CODE (PATTERN (insn)) != USE
8757            && GET_CODE (PATTERN (insn)) != CLOBBER
8758            && get_attr_type (insn) == TYPE_MILLI));
8759 }
8760
8761 /* On the HP-PA the value is found in register(s) 28(-29), unless
8762    the mode is SF or DF. Then the value is returned in fr4 (32).
8763
8764    This must perform the same promotions as PROMOTE_MODE, else
8765    TARGET_PROMOTE_FUNCTION_RETURN will not work correctly.
8766
8767    Small structures must be returned in a PARALLEL on PA64 in order
8768    to match the HP Compiler ABI.  */
8769
8770 rtx
8771 function_value (tree valtype, tree func ATTRIBUTE_UNUSED)
8772 {
8773   enum machine_mode valmode;
8774
8775   if (AGGREGATE_TYPE_P (valtype))
8776     {
8777       if (TARGET_64BIT)
8778         {
8779           /* Aggregates with a size less than or equal to 128 bits are
8780              returned in GR 28(-29).  They are left justified.  The pad
8781              bits are undefined.  Larger aggregates are returned in
8782              memory.  */
8783           rtx loc[2];
8784           int i, offset = 0;
8785           int ub = int_size_in_bytes (valtype) <= UNITS_PER_WORD ? 1 : 2;
8786
8787           for (i = 0; i < ub; i++)
8788             {
8789               loc[i] = gen_rtx_EXPR_LIST (VOIDmode,
8790                                           gen_rtx_REG (DImode, 28 + i),
8791                                           GEN_INT (offset));
8792               offset += 8;
8793             }
8794
8795           return gen_rtx_PARALLEL (BLKmode, gen_rtvec_v (ub, loc));
8796         }
8797       else if (int_size_in_bytes (valtype) > UNITS_PER_WORD)
8798         {
8799           /* Aggregates 5 to 8 bytes in size are returned in general
8800              registers r28-r29 in the same manner as other non
8801              floating-point objects.  The data is right-justified and
8802              zero-extended to 64 bits.  This is opposite to the normal
8803              justification used on big endian targets and requires
8804              special treatment.  */
8805           rtx loc = gen_rtx_EXPR_LIST (VOIDmode,
8806                                        gen_rtx_REG (DImode, 28), const0_rtx);
8807           return gen_rtx_PARALLEL (BLKmode, gen_rtvec (1, loc));
8808         }
8809     }
8810
8811   if ((INTEGRAL_TYPE_P (valtype)
8812        && TYPE_PRECISION (valtype) < BITS_PER_WORD)
8813       || POINTER_TYPE_P (valtype))
8814     valmode = word_mode;
8815   else
8816     valmode = TYPE_MODE (valtype);
8817
8818   if (TREE_CODE (valtype) == REAL_TYPE
8819       && !AGGREGATE_TYPE_P (valtype)
8820       && TYPE_MODE (valtype) != TFmode
8821       && !TARGET_SOFT_FLOAT)
8822     return gen_rtx_REG (valmode, 32);
8823
8824   return gen_rtx_REG (valmode, 28);
8825 }
8826
8827 /* Return the location of a parameter that is passed in a register or NULL
8828    if the parameter has any component that is passed in memory.
8829
8830    This is new code and will be pushed to into the net sources after
8831    further testing.
8832
8833    ??? We might want to restructure this so that it looks more like other
8834    ports.  */
8835 rtx
8836 function_arg (CUMULATIVE_ARGS *cum, enum machine_mode mode, tree type,
8837               int named ATTRIBUTE_UNUSED)
8838 {
8839   int max_arg_words = (TARGET_64BIT ? 8 : 4);
8840   int alignment = 0;
8841   int arg_size;
8842   int fpr_reg_base;
8843   int gpr_reg_base;
8844   rtx retval;
8845
8846   if (mode == VOIDmode)
8847     return NULL_RTX;
8848
8849   arg_size = FUNCTION_ARG_SIZE (mode, type);
8850
8851   /* If this arg would be passed partially or totally on the stack, then
8852      this routine should return zero.  pa_arg_partial_bytes will
8853      handle arguments which are split between regs and stack slots if
8854      the ABI mandates split arguments.  */
8855   if (! TARGET_64BIT)
8856     {
8857       /* The 32-bit ABI does not split arguments.  */
8858       if (cum->words + arg_size > max_arg_words)
8859         return NULL_RTX;
8860     }
8861   else
8862     {
8863       if (arg_size > 1)
8864         alignment = cum->words & 1;
8865       if (cum->words + alignment >= max_arg_words)
8866         return NULL_RTX;
8867     }
8868
8869   /* The 32bit ABIs and the 64bit ABIs are rather different,
8870      particularly in their handling of FP registers.  We might
8871      be able to cleverly share code between them, but I'm not
8872      going to bother in the hope that splitting them up results
8873      in code that is more easily understood.  */
8874
8875   if (TARGET_64BIT)
8876     {
8877       /* Advance the base registers to their current locations.
8878
8879          Remember, gprs grow towards smaller register numbers while
8880          fprs grow to higher register numbers.  Also remember that
8881          although FP regs are 32-bit addressable, we pretend that
8882          the registers are 64-bits wide.  */
8883       gpr_reg_base = 26 - cum->words;
8884       fpr_reg_base = 32 + cum->words;
8885
8886       /* Arguments wider than one word and small aggregates need special
8887          treatment.  */
8888       if (arg_size > 1
8889           || mode == BLKmode
8890           || (type && AGGREGATE_TYPE_P (type)))
8891         {
8892           /* Double-extended precision (80-bit), quad-precision (128-bit)
8893              and aggregates including complex numbers are aligned on
8894              128-bit boundaries.  The first eight 64-bit argument slots
8895              are associated one-to-one, with general registers r26
8896              through r19, and also with floating-point registers fr4
8897              through fr11.  Arguments larger than one word are always
8898              passed in general registers.
8899
8900              Using a PARALLEL with a word mode register results in left
8901              justified data on a big-endian target.  */
8902
8903           rtx loc[8];
8904           int i, offset = 0, ub = arg_size;
8905
8906           /* Align the base register.  */
8907           gpr_reg_base -= alignment;
8908
8909           ub = MIN (ub, max_arg_words - cum->words - alignment);
8910           for (i = 0; i < ub; i++)
8911             {
8912               loc[i] = gen_rtx_EXPR_LIST (VOIDmode,
8913                                           gen_rtx_REG (DImode, gpr_reg_base),
8914                                           GEN_INT (offset));
8915               gpr_reg_base -= 1;
8916               offset += 8;
8917             }
8918
8919           return gen_rtx_PARALLEL (mode, gen_rtvec_v (ub, loc));
8920         }
8921      }
8922   else
8923     {
8924       /* If the argument is larger than a word, then we know precisely
8925          which registers we must use.  */
8926       if (arg_size > 1)
8927         {
8928           if (cum->words)
8929             {
8930               gpr_reg_base = 23;
8931               fpr_reg_base = 38;
8932             }
8933           else
8934             {
8935               gpr_reg_base = 25;
8936               fpr_reg_base = 34;
8937             }
8938
8939           /* Structures 5 to 8 bytes in size are passed in the general
8940              registers in the same manner as other non floating-point
8941              objects.  The data is right-justified and zero-extended
8942              to 64 bits.  This is opposite to the normal justification
8943              used on big endian targets and requires special treatment.
8944              We now define BLOCK_REG_PADDING to pad these objects.  */
8945           if (mode == BLKmode || (type && AGGREGATE_TYPE_P (type)))
8946             {
8947               rtx loc = gen_rtx_EXPR_LIST (VOIDmode,
8948                                            gen_rtx_REG (DImode, gpr_reg_base),
8949                                            const0_rtx);
8950               return gen_rtx_PARALLEL (BLKmode, gen_rtvec (1, loc));
8951             }
8952         }
8953       else
8954         {
8955            /* We have a single word (32 bits).  A simple computation
8956               will get us the register #s we need.  */
8957            gpr_reg_base = 26 - cum->words;
8958            fpr_reg_base = 32 + 2 * cum->words;
8959         }
8960     }
8961
8962   /* Determine if the argument needs to be passed in both general and
8963      floating point registers.  */
8964   if (((TARGET_PORTABLE_RUNTIME || TARGET_64BIT || TARGET_ELF32)
8965        /* If we are doing soft-float with portable runtime, then there
8966           is no need to worry about FP regs.  */
8967        && !TARGET_SOFT_FLOAT
8968        /* The parameter must be some kind of float, else we can just
8969           pass it in integer registers.  */
8970        && FLOAT_MODE_P (mode)
8971        /* The target function must not have a prototype.  */
8972        && cum->nargs_prototype <= 0
8973        /* libcalls do not need to pass items in both FP and general
8974           registers.  */
8975        && type != NULL_TREE
8976        /* All this hair applies to "outgoing" args only.  This includes
8977           sibcall arguments setup with FUNCTION_INCOMING_ARG.  */
8978        && !cum->incoming)
8979       /* Also pass outgoing floating arguments in both registers in indirect
8980          calls with the 32 bit ABI and the HP assembler since there is no
8981          way to the specify argument locations in static functions.  */
8982       || (!TARGET_64BIT
8983           && !TARGET_GAS
8984           && !cum->incoming
8985           && cum->indirect
8986           && FLOAT_MODE_P (mode)))
8987     {
8988       retval
8989         = gen_rtx_PARALLEL
8990             (mode,
8991              gen_rtvec (2,
8992                         gen_rtx_EXPR_LIST (VOIDmode,
8993                                            gen_rtx_REG (mode, fpr_reg_base),
8994                                            const0_rtx),
8995                         gen_rtx_EXPR_LIST (VOIDmode,
8996                                            gen_rtx_REG (mode, gpr_reg_base),
8997                                            const0_rtx)));
8998     }
8999   else
9000     {
9001       /* See if we should pass this parameter in a general register.  */
9002       if (TARGET_SOFT_FLOAT
9003           /* Indirect calls in the normal 32bit ABI require all arguments
9004              to be passed in general registers.  */
9005           || (!TARGET_PORTABLE_RUNTIME
9006               && !TARGET_64BIT
9007               && !TARGET_ELF32
9008               && cum->indirect)
9009           /* If the parameter is not a floating point parameter, then
9010              it belongs in GPRs.  */
9011           || !FLOAT_MODE_P (mode)
9012           /* Structure with single SFmode field belongs in GPR.  */
9013           || (type && AGGREGATE_TYPE_P (type)))
9014         retval = gen_rtx_REG (mode, gpr_reg_base);
9015       else
9016         retval = gen_rtx_REG (mode, fpr_reg_base);
9017     }
9018   return retval;
9019 }
9020
9021
9022 /* If this arg would be passed totally in registers or totally on the stack,
9023    then this routine should return zero.  */
9024
9025 static int
9026 pa_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
9027                       tree type, bool named ATTRIBUTE_UNUSED)
9028 {
9029   unsigned int max_arg_words = 8;
9030   unsigned int offset = 0;
9031
9032   if (!TARGET_64BIT)
9033     return 0;
9034
9035   if (FUNCTION_ARG_SIZE (mode, type) > 1 && (cum->words & 1))
9036     offset = 1;
9037
9038   if (cum->words + offset + FUNCTION_ARG_SIZE (mode, type) <= max_arg_words)
9039     /* Arg fits fully into registers.  */
9040     return 0;
9041   else if (cum->words + offset >= max_arg_words)
9042     /* Arg fully on the stack.  */
9043     return 0;
9044   else
9045     /* Arg is split.  */
9046     return (max_arg_words - cum->words - offset) * UNITS_PER_WORD;
9047 }
9048
9049
9050 /* A get_unnamed_section callback for switching to the text section.
9051
9052    This function is only used with SOM.  Because we don't support
9053    named subspaces, we can only create a new subspace or switch back
9054    to the default text subspace.  */
9055
9056 static void
9057 som_output_text_section_asm_op (const void *data ATTRIBUTE_UNUSED)
9058 {
9059   gcc_assert (TARGET_SOM);
9060   if (TARGET_GAS)
9061     {
9062       if (cfun && !cfun->machine->in_nsubspa)
9063         {
9064           /* We only want to emit a .nsubspa directive once at the
9065              start of the function.  */
9066           cfun->machine->in_nsubspa = 1;
9067
9068           /* Create a new subspace for the text.  This provides
9069              better stub placement and one-only functions.  */
9070           if (cfun->decl
9071               && DECL_ONE_ONLY (cfun->decl)
9072               && !DECL_WEAK (cfun->decl))
9073             {
9074               output_section_asm_op ("\t.SPACE $TEXT$\n"
9075                                      "\t.NSUBSPA $CODE$,QUAD=0,ALIGN=8,"
9076                                      "ACCESS=44,SORT=24,COMDAT");
9077               return;
9078             }
9079         }
9080       else
9081         {
9082           /* There isn't a current function or the body of the current
9083              function has been completed.  So, we are changing to the
9084              text section to output debugging information.  Thus, we
9085              need to forget that we are in the text section so that
9086              varasm.c will call us when text_section is selected again.  */
9087           gcc_assert (!cfun || cfun->machine->in_nsubspa == 2);
9088           in_section = NULL;
9089         }
9090       output_section_asm_op ("\t.SPACE $TEXT$\n\t.NSUBSPA $CODE$");
9091       return;
9092     }
9093   output_section_asm_op ("\t.SPACE $TEXT$\n\t.SUBSPA $CODE$");
9094 }
9095
9096 /* A get_unnamed_section callback for switching to comdat data
9097    sections.  This function is only used with SOM.  */
9098
9099 static void
9100 som_output_comdat_data_section_asm_op (const void *data)
9101 {
9102   in_section = NULL;
9103   output_section_asm_op (data);
9104 }
9105
9106 /* Implement TARGET_ASM_INITIALIZE_SECTIONS  */
9107
9108 static void
9109 pa_som_asm_init_sections (void)
9110 {
9111   text_section
9112     = get_unnamed_section (0, som_output_text_section_asm_op, NULL);
9113
9114   /* SOM puts readonly data in the default $LIT$ subspace when PIC code
9115      is not being generated.  */
9116   som_readonly_data_section
9117     = get_unnamed_section (0, output_section_asm_op,
9118                            "\t.SPACE $TEXT$\n\t.SUBSPA $LIT$");
9119
9120   /* When secondary definitions are not supported, SOM makes readonly
9121      data one-only by creating a new $LIT$ subspace in $TEXT$ with
9122      the comdat flag.  */
9123   som_one_only_readonly_data_section
9124     = get_unnamed_section (0, som_output_comdat_data_section_asm_op,
9125                            "\t.SPACE $TEXT$\n"
9126                            "\t.NSUBSPA $LIT$,QUAD=0,ALIGN=8,"
9127                            "ACCESS=0x2c,SORT=16,COMDAT");
9128
9129
9130   /* When secondary definitions are not supported, SOM makes data one-only
9131      by creating a new $DATA$ subspace in $PRIVATE$ with the comdat flag.  */
9132   som_one_only_data_section
9133     = get_unnamed_section (SECTION_WRITE,
9134                            som_output_comdat_data_section_asm_op,
9135                            "\t.SPACE $PRIVATE$\n"
9136                            "\t.NSUBSPA $DATA$,QUAD=1,ALIGN=8,"
9137                            "ACCESS=31,SORT=24,COMDAT");
9138
9139   /* FIXME: HPUX ld generates incorrect GOT entries for "T" fixups
9140      which reference data within the $TEXT$ space (for example constant
9141      strings in the $LIT$ subspace).
9142
9143      The assemblers (GAS and HP as) both have problems with handling
9144      the difference of two symbols which is the other correct way to
9145      reference constant data during PIC code generation.
9146
9147      So, there's no way to reference constant data which is in the
9148      $TEXT$ space during PIC generation.  Instead place all constant
9149      data into the $PRIVATE$ subspace (this reduces sharing, but it
9150      works correctly).  */
9151   readonly_data_section = flag_pic ? data_section : som_readonly_data_section;
9152
9153   /* We must not have a reference to an external symbol defined in a
9154      shared library in a readonly section, else the SOM linker will
9155      complain.
9156
9157      So, we force exception information into the data section.  */
9158   exception_section = data_section;
9159 }
9160
9161 /* On hpux10, the linker will give an error if we have a reference
9162    in the read-only data section to a symbol defined in a shared
9163    library.  Therefore, expressions that might require a reloc can
9164    not be placed in the read-only data section.  */
9165
9166 static section *
9167 pa_select_section (tree exp, int reloc,
9168                    unsigned HOST_WIDE_INT align ATTRIBUTE_UNUSED)
9169 {
9170   if (TREE_CODE (exp) == VAR_DECL
9171       && TREE_READONLY (exp)
9172       && !TREE_THIS_VOLATILE (exp)
9173       && DECL_INITIAL (exp)
9174       && (DECL_INITIAL (exp) == error_mark_node
9175           || TREE_CONSTANT (DECL_INITIAL (exp)))
9176       && !reloc)
9177     {
9178       if (TARGET_SOM
9179           && DECL_ONE_ONLY (exp)
9180           && !DECL_WEAK (exp))
9181         return som_one_only_readonly_data_section;
9182       else
9183         return readonly_data_section;
9184     }
9185   else if (CONSTANT_CLASS_P (exp) && !reloc)
9186     return readonly_data_section;
9187   else if (TARGET_SOM
9188            && TREE_CODE (exp) == VAR_DECL
9189            && DECL_ONE_ONLY (exp)
9190            && !DECL_WEAK (exp))
9191     return som_one_only_data_section;
9192   else
9193     return data_section;
9194 }
9195
9196 static void
9197 pa_globalize_label (FILE *stream, const char *name)
9198 {
9199   /* We only handle DATA objects here, functions are globalized in
9200      ASM_DECLARE_FUNCTION_NAME.  */
9201   if (! FUNCTION_NAME_P (name))
9202   {
9203     fputs ("\t.EXPORT ", stream);
9204     assemble_name (stream, name);
9205     fputs (",DATA\n", stream);
9206   }
9207 }
9208
9209 /* Worker function for TARGET_STRUCT_VALUE_RTX.  */
9210
9211 static rtx
9212 pa_struct_value_rtx (tree fntype ATTRIBUTE_UNUSED,
9213                      int incoming ATTRIBUTE_UNUSED)
9214 {
9215   return gen_rtx_REG (Pmode, PA_STRUCT_VALUE_REGNUM);
9216 }
9217
9218 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
9219
9220 bool
9221 pa_return_in_memory (tree type, tree fntype ATTRIBUTE_UNUSED)
9222 {
9223   /* SOM ABI says that objects larger than 64 bits are returned in memory.
9224      PA64 ABI says that objects larger than 128 bits are returned in memory.
9225      Note, int_size_in_bytes can return -1 if the size of the object is
9226      variable or larger than the maximum value that can be expressed as
9227      a HOST_WIDE_INT.   It can also return zero for an empty type.  The
9228      simplest way to handle variable and empty types is to pass them in
9229      memory.  This avoids problems in defining the boundaries of argument
9230      slots, allocating registers, etc.  */
9231   return (int_size_in_bytes (type) > (TARGET_64BIT ? 16 : 8)
9232           || int_size_in_bytes (type) <= 0);
9233 }
9234
9235 /* Structure to hold declaration and name of external symbols that are
9236    emitted by GCC.  We generate a vector of these symbols and output them
9237    at the end of the file if and only if SYMBOL_REF_REFERENCED_P is true.
9238    This avoids putting out names that are never really used.  */
9239
9240 typedef struct extern_symbol GTY(())
9241 {
9242   tree decl;
9243   const char *name;
9244 } extern_symbol;
9245
9246 /* Define gc'd vector type for extern_symbol.  */
9247 DEF_VEC_O(extern_symbol);
9248 DEF_VEC_ALLOC_O(extern_symbol,gc);
9249
9250 /* Vector of extern_symbol pointers.  */
9251 static GTY(()) VEC(extern_symbol,gc) *extern_symbols;
9252
9253 #ifdef ASM_OUTPUT_EXTERNAL_REAL
9254 /* Mark DECL (name NAME) as an external reference (assembler output
9255    file FILE).  This saves the names to output at the end of the file
9256    if actually referenced.  */
9257
9258 void
9259 pa_hpux_asm_output_external (FILE *file, tree decl, const char *name)
9260 {
9261   extern_symbol * p = VEC_safe_push (extern_symbol, gc, extern_symbols, NULL);
9262
9263   gcc_assert (file == asm_out_file);
9264   p->decl = decl;
9265   p->name = name;
9266 }
9267
9268 /* Output text required at the end of an assembler file.
9269    This includes deferred plabels and .import directives for
9270    all external symbols that were actually referenced.  */
9271
9272 static void
9273 pa_hpux_file_end (void)
9274 {
9275   unsigned int i;
9276   extern_symbol *p;
9277
9278   if (!NO_DEFERRED_PROFILE_COUNTERS)
9279     output_deferred_profile_counters ();
9280
9281   output_deferred_plabels ();
9282
9283   for (i = 0; VEC_iterate (extern_symbol, extern_symbols, i, p); i++)
9284     {
9285       tree decl = p->decl;
9286
9287       if (!TREE_ASM_WRITTEN (decl)
9288           && SYMBOL_REF_REFERENCED_P (XEXP (DECL_RTL (decl), 0)))
9289         ASM_OUTPUT_EXTERNAL_REAL (asm_out_file, decl, p->name);
9290     }
9291
9292   VEC_free (extern_symbol, gc, extern_symbols);
9293 }
9294 #endif
9295
9296 #include "gt-pa.h"