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