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