gcc/config/pa/pa.c

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