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