gcc/config/sh/sh.c

   1 /* Output routines for GCC for Renesas / SuperH SH.
   2    Copyright (C) 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001, 2002,
   3    2003, 2004, 2005, 2006, 2007, 2008, 2009 Free Software Foundation, Inc.
   4    Contributed by Steve Chamberlain (sac@cygnus.com).
   5    Improved by Jim Wilson (wilson@cygnus.com).
   6
   7 This file is part of GCC.
   8
   9 GCC is free software; you can redistribute it and/or modify
  10 it under the terms of the GNU General Public License as published by
  11 the Free Software Foundation; either version 3, or (at your option)
  12 any later version.
  13
  14 GCC is distributed in the hope that it will be useful,
  15 but WITHOUT ANY WARRANTY; without even the implied warranty of
  16 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  17 GNU General Public License for more details.
  18
  19 You should have received a copy of the GNU General Public License
  20 along with GCC; see the file COPYING3.  If not see
  21 <http://www.gnu.org/licenses/>.  */
  22
  23 #include "config.h"
  24 #include "system.h"
  25 #include "coretypes.h"
  26 #include "tm.h"
  27 #include "insn-config.h"
  28 #include "rtl.h"
  29 #include "tree.h"
  30 #include "flags.h"
  31 #include "expr.h"
  32 #include "optabs.h"
  33 #include "function.h"
  34 #include "regs.h"
  35 #include "hard-reg-set.h"
  36 #include "output.h"
  37 #include "insn-attr.h"
  38 #include "toplev.h"
  39 #include "recog.h"
  40 #include "integrate.h"
  41 #include "dwarf2.h"
  42 #include "tm_p.h"
  43 #include "target.h"
  44 #include "target-def.h"
  45 #include "real.h"
  46 #include "langhooks.h"
  47 #include "basic-block.h"
  48 #include "df.h"
  49 #include "cfglayout.h"
  50 #include "intl.h"
  51 #include "sched-int.h"
  52 #include "params.h"
  53 #include "ggc.h"
  54 #include "gimple.h"
  55 #include "cfgloop.h"
  56 #include "alloc-pool.h"
  57 #include "tm-constrs.h"
  58
  59
  60 int code_for_indirect_jump_scratch = CODE_FOR_indirect_jump_scratch;
  61
  62 #define MSW (TARGET_LITTLE_ENDIAN ? 1 : 0)
  63 #define LSW (TARGET_LITTLE_ENDIAN ? 0 : 1)
  64
  65 /* These are some macros to abstract register modes.  */
  66 #define CONST_OK_FOR_ADD(size) \
  67   (TARGET_SHMEDIA ? CONST_OK_FOR_I10 (size) : CONST_OK_FOR_I08 (size))
  68 #define GEN_MOV (*(TARGET_SHMEDIA64 ? gen_movdi : gen_movsi))
  69 #define GEN_ADD3 (*(TARGET_SHMEDIA64 ? gen_adddi3 : gen_addsi3))
  70 #define GEN_SUB3 (*(TARGET_SHMEDIA64 ? gen_subdi3 : gen_subsi3))
  71
  72 /* Used to simplify the logic below.  Find the attributes wherever
  73    they may be.  */
  74 #define SH_ATTRIBUTES(decl) \
  75   (TYPE_P (decl)) ? TYPE_ATTRIBUTES (decl) \
  76                   : DECL_ATTRIBUTES (decl) \
  77                   ? (DECL_ATTRIBUTES (decl)) \
  78                   : TYPE_ATTRIBUTES (TREE_TYPE (decl))
  79
  80 /* Set to 1 by expand_prologue() when the function is an interrupt handler.  */
  81 int current_function_interrupt;
  82
  83 tree sh_deferred_function_attributes;
  84 tree *sh_deferred_function_attributes_tail = &sh_deferred_function_attributes;
  85
  86 /* Global variables for machine-dependent things.  */
  87
  88 /* Which cpu are we scheduling for.  */
  89 enum processor_type sh_cpu;
  90
  91 /* Definitions used in ready queue reordering for first scheduling pass.  */
  92
  93 /* Reg weights arrays for modes SFmode and SImode, indexed by insn LUID.  */
  94 static short *regmode_weight[2];
  95
  96 /* Total SFmode and SImode weights of scheduled insns.  */
  97 static int curr_regmode_pressure[2];
  98
  99 /* Number of r0 life regions.  */
 100 static int r0_life_regions;
 101
 102 /* If true, skip cycles for Q -> R movement.  */
 103 static int skip_cycles = 0;
 104
 105 /* Cached value of can_issue_more. This is cached in sh_variable_issue hook
 106    and returned from sh_reorder2.  */
 107 static short cached_can_issue_more;
 108
 109 /* Provides the class number of the smallest class containing
 110    reg number.  */
 111
 112 enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER] =
 113 {
 114   R0_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 115   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 116   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 117   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 118   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 119   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 120   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 121   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 122   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 123   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 124   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 125   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 126   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 127   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 128   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 129   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 130   FP0_REGS,FP_REGS, FP_REGS, FP_REGS,
 131   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 132   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 133   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 134   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 135   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 136   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 137   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 138   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 139   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 140   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 141   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 142   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 143   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 144   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 145   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 146   TARGET_REGS, TARGET_REGS, TARGET_REGS, TARGET_REGS,
 147   TARGET_REGS, TARGET_REGS, TARGET_REGS, TARGET_REGS,
 148   DF_REGS, DF_REGS, DF_REGS, DF_REGS,
 149   DF_REGS, DF_REGS, DF_REGS, DF_REGS,
 150   NO_REGS, GENERAL_REGS, PR_REGS, T_REGS,
 151   MAC_REGS, MAC_REGS, FPUL_REGS, FPSCR_REGS,
 152   GENERAL_REGS, GENERAL_REGS,
 153 };
 154
 155 char sh_register_names[FIRST_PSEUDO_REGISTER] \
 156   [MAX_REGISTER_NAME_LENGTH + 1] = SH_REGISTER_NAMES_INITIALIZER;
 157
 158 char sh_additional_register_names[ADDREGNAMES_SIZE] \
 159   [MAX_ADDITIONAL_REGISTER_NAME_LENGTH + 1]
 160   = SH_ADDITIONAL_REGISTER_NAMES_INITIALIZER;
 161
 162 int assembler_dialect;
 163
 164 static bool shmedia_space_reserved_for_target_registers;
 165
 166 static bool sh_handle_option (size_t, const char *, int);
 167 static void split_branches (rtx);
 168 static int branch_dest (rtx);
 169 static void force_into (rtx, rtx);
 170 static void print_slot (rtx);
 171 static rtx add_constant (rtx, enum machine_mode, rtx);
 172 static void dump_table (rtx, rtx);
 173 static int hi_const (rtx);
 174 static int broken_move (rtx);
 175 static int mova_p (rtx);
 176 static rtx find_barrier (int, rtx, rtx);
 177 static int noncall_uses_reg (rtx, rtx, rtx *);
 178 static rtx gen_block_redirect (rtx, int, int);
 179 static void sh_reorg (void);
 180 static void output_stack_adjust (int, rtx, int, HARD_REG_SET *);
 181 static rtx frame_insn (rtx);
 182 static rtx push (int);
 183 static void pop (int);
 184 static void push_regs (HARD_REG_SET *, int);
 185 static int calc_live_regs (HARD_REG_SET *);
 186 static HOST_WIDE_INT rounded_frame_size (int);
 187 static rtx mark_constant_pool_use (rtx);
 188 EXPORTED_CONST struct attribute_spec sh_attribute_table[];
 189 static tree sh_handle_interrupt_handler_attribute (tree *, tree, tree, int, bool *);
 190 static tree sh_handle_resbank_handler_attribute (tree *, tree,
 191                                                  tree, int, bool *);
 192 static tree sh2a_handle_function_vector_handler_attribute (tree *, tree,
 193                                                            tree, int, bool *);
 194 static tree sh_handle_sp_switch_attribute (tree *, tree, tree, int, bool *);
 195 static tree sh_handle_trap_exit_attribute (tree *, tree, tree, int, bool *);
 196 static tree sh_handle_renesas_attribute (tree *, tree, tree, int, bool *);
 197 static void sh_output_function_epilogue (FILE *, HOST_WIDE_INT);
 198 static void sh_insert_attributes (tree, tree *);
 199 static const char *sh_check_pch_target_flags (int);
 200 static int sh_adjust_cost (rtx, rtx, rtx, int);
 201 static int sh_issue_rate (void);
 202 static int sh_dfa_new_cycle (FILE *, int, rtx, int, int, int *sort_p);
 203 static short find_set_regmode_weight (rtx, enum machine_mode);
 204 static short find_insn_regmode_weight (rtx, enum machine_mode);
 205 static void find_regmode_weight (basic_block, enum machine_mode);
 206 static int find_r0_life_regions (basic_block);
 207 static void  sh_md_init_global (FILE *, int, int);
 208 static void  sh_md_finish_global (FILE *, int);
 209 static int rank_for_reorder (const void *, const void *);
 210 static void swap_reorder (rtx *, int);
 211 static void ready_reorder (rtx *, int);
 212 static short high_pressure (enum machine_mode);
 213 static int sh_reorder (FILE *, int, rtx *, int *, int);
 214 static int sh_reorder2 (FILE *, int, rtx *, int *, int);
 215 static void sh_md_init (FILE *, int, int);
 216 static int sh_variable_issue (FILE *, int, rtx, int);
 217
 218 static bool sh_function_ok_for_sibcall (tree, tree);
 219
 220 static bool sh_cannot_modify_jumps_p (void);
 221 static enum reg_class sh_target_reg_class (void);
 222 static bool sh_optimize_target_register_callee_saved (bool);
 223 static bool sh_ms_bitfield_layout_p (const_tree);
 224
 225 static void sh_init_builtins (void);
 226 static void sh_media_init_builtins (void);
 227 static rtx sh_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
 228 static void sh_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);
 229 static void sh_file_start (void);
 230 static int flow_dependent_p (rtx, rtx);
 231 static void flow_dependent_p_1 (rtx, const_rtx, void *);
 232 static int shiftcosts (rtx);
 233 static int andcosts (rtx);
 234 static int addsubcosts (rtx);
 235 static int multcosts (rtx);
 236 static bool unspec_caller_rtx_p (rtx);
 237 static bool sh_cannot_copy_insn_p (rtx);
 238 static bool sh_rtx_costs (rtx, int, int, int *, bool);
 239 static int sh_address_cost (rtx, bool);
 240 static int sh_pr_n_sets (void);
 241 static rtx sh_allocate_initial_value (rtx);
 242 static bool sh_legitimate_address_p (enum machine_mode, rtx, bool);
 243 static rtx sh_legitimize_address (rtx, rtx, enum machine_mode);
 244 static int shmedia_target_regs_stack_space (HARD_REG_SET *);
 245 static int shmedia_reserve_space_for_target_registers_p (int, HARD_REG_SET *);
 246 static int shmedia_target_regs_stack_adjust (HARD_REG_SET *);
 247 static int scavenge_reg (HARD_REG_SET *s);
 248 struct save_schedule_s;
 249 static struct save_entry_s *sh5_schedule_saves (HARD_REG_SET *,
 250                                                 struct save_schedule_s *, int);
 251
 252 static rtx sh_struct_value_rtx (tree, int);
 253 static bool sh_return_in_memory (const_tree, const_tree);
 254 static rtx sh_builtin_saveregs (void);
 255 static void sh_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode, tree, int *, int);
 256 static bool sh_strict_argument_naming (CUMULATIVE_ARGS *);
 257 static bool sh_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *);
 258 static tree sh_build_builtin_va_list (void);
 259 static void sh_va_start (tree, rtx);
 260 static tree sh_gimplify_va_arg_expr (tree, tree, gimple_seq *, gimple_seq *);
 261 static bool sh_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
 262                                   const_tree, bool);
 263 static bool sh_callee_copies (CUMULATIVE_ARGS *, enum machine_mode,
 264                               const_tree, bool);
 265 static int sh_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
 266                                  tree, bool);
 267 static bool sh_scalar_mode_supported_p (enum machine_mode);
 268 static int sh_dwarf_calling_convention (const_tree);
 269 static void sh_encode_section_info (tree, rtx, int);
 270 static int sh2a_function_vector_p (tree);
 271
 272 \f
 273 /* Initialize the GCC target structure.  */
 274 #undef TARGET_ATTRIBUTE_TABLE
 275 #define TARGET_ATTRIBUTE_TABLE sh_attribute_table
 276
 277 /* The next two are used for debug info when compiling with -gdwarf.  */
 278 #undef TARGET_ASM_UNALIGNED_HI_OP
 279 #define TARGET_ASM_UNALIGNED_HI_OP "\t.uaword\t"
 280 #undef TARGET_ASM_UNALIGNED_SI_OP
 281 #define TARGET_ASM_UNALIGNED_SI_OP "\t.ualong\t"
 282
 283 /* These are NULLed out on non-SH5 in OVERRIDE_OPTIONS.  */
 284 #undef TARGET_ASM_UNALIGNED_DI_OP
 285 #define TARGET_ASM_UNALIGNED_DI_OP "\t.uaquad\t"
 286 #undef TARGET_ASM_ALIGNED_DI_OP
 287 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
 288
 289 #undef TARGET_ASM_FUNCTION_EPILOGUE
 290 #define TARGET_ASM_FUNCTION_EPILOGUE sh_output_function_epilogue
 291
 292 #undef TARGET_ASM_OUTPUT_MI_THUNK
 293 #define TARGET_ASM_OUTPUT_MI_THUNK sh_output_mi_thunk
 294
 295 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 296 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_const_tree_hwi_hwi_const_tree_true
 297
 298 #undef TARGET_ASM_FILE_START
 299 #define TARGET_ASM_FILE_START sh_file_start
 300 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
 301 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
 302
 303 #undef TARGET_DEFAULT_TARGET_FLAGS
 304 #define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 305 #undef TARGET_HANDLE_OPTION
 306 #define TARGET_HANDLE_OPTION sh_handle_option
 307
 308 #undef TARGET_INSERT_ATTRIBUTES
 309 #define TARGET_INSERT_ATTRIBUTES sh_insert_attributes
 310
 311 #undef TARGET_SCHED_ADJUST_COST
 312 #define TARGET_SCHED_ADJUST_COST sh_adjust_cost
 313
 314 #undef TARGET_SCHED_ISSUE_RATE
 315 #define TARGET_SCHED_ISSUE_RATE sh_issue_rate
 316
 317 /* The next 5 hooks have been implemented for reenabling sched1.  With the
 318    help of these macros we are limiting the movement of insns in sched1 to
 319    reduce the register pressure.  The overall idea is to keep count of SImode
 320    and SFmode regs required by already scheduled insns. When these counts
 321    cross some threshold values; give priority to insns that free registers.
 322    The insn that frees registers is most likely to be the insn with lowest
 323    LUID (original insn order); but such an insn might be there in the stalled
 324    queue (Q) instead of the ready queue (R).  To solve this, we skip cycles
 325    upto a max of 8 cycles so that such insns may move from Q -> R.
 326
 327    The description of the hooks are as below:
 328
 329    TARGET_SCHED_INIT_GLOBAL: Added a new target hook in the generic
 330    scheduler; it is called inside the sched_init function just after
 331    find_insn_reg_weights function call. It is used to calculate the SImode
 332    and SFmode weights of insns of basic blocks; much similar to what
 333    find_insn_reg_weights does.
 334    TARGET_SCHED_FINISH_GLOBAL: Corresponding cleanup hook.
 335
 336    TARGET_SCHED_DFA_NEW_CYCLE: Skip cycles if high register pressure is
 337    indicated by TARGET_SCHED_REORDER2; doing this may move insns from
 338    (Q)->(R).
 339
 340    TARGET_SCHED_REORDER: If the register pressure for SImode or SFmode is
 341    high; reorder the ready queue so that the insn with lowest LUID will be
 342    issued next.
 343
 344    TARGET_SCHED_REORDER2: If the register pressure is high, indicate to
 345    TARGET_SCHED_DFA_NEW_CYCLE to skip cycles.
 346
 347    TARGET_SCHED_VARIABLE_ISSUE: Cache the value of can_issue_more so that it
 348    can be returned from TARGET_SCHED_REORDER2.
 349
 350    TARGET_SCHED_INIT: Reset the register pressure counting variables.  */
 351
 352 #undef TARGET_SCHED_DFA_NEW_CYCLE
 353 #define TARGET_SCHED_DFA_NEW_CYCLE sh_dfa_new_cycle
 354
 355 #undef TARGET_SCHED_INIT_GLOBAL
 356 #define TARGET_SCHED_INIT_GLOBAL sh_md_init_global
 357
 358 #undef TARGET_SCHED_FINISH_GLOBAL
 359 #define TARGET_SCHED_FINISH_GLOBAL sh_md_finish_global
 360
 361 #undef TARGET_SCHED_VARIABLE_ISSUE
 362 #define TARGET_SCHED_VARIABLE_ISSUE sh_variable_issue
 363
 364 #undef TARGET_SCHED_REORDER
 365 #define TARGET_SCHED_REORDER sh_reorder
 366
 367 #undef TARGET_SCHED_REORDER2
 368 #define TARGET_SCHED_REORDER2 sh_reorder2
 369
 370 #undef TARGET_SCHED_INIT
 371 #define TARGET_SCHED_INIT sh_md_init
 372
 373 #undef TARGET_LEGITIMIZE_ADDRESS
 374 #define TARGET_LEGITIMIZE_ADDRESS sh_legitimize_address
 375
 376 #undef TARGET_CANNOT_MODIFY_JUMPS_P
 377 #define TARGET_CANNOT_MODIFY_JUMPS_P sh_cannot_modify_jumps_p
 378 #undef TARGET_BRANCH_TARGET_REGISTER_CLASS
 379 #define TARGET_BRANCH_TARGET_REGISTER_CLASS sh_target_reg_class
 380 #undef TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED
 381 #define TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED \
 382  sh_optimize_target_register_callee_saved
 383
 384 #undef TARGET_MS_BITFIELD_LAYOUT_P
 385 #define TARGET_MS_BITFIELD_LAYOUT_P sh_ms_bitfield_layout_p
 386
 387 #undef TARGET_INIT_BUILTINS
 388 #define TARGET_INIT_BUILTINS sh_init_builtins
 389 #undef TARGET_EXPAND_BUILTIN
 390 #define TARGET_EXPAND_BUILTIN sh_expand_builtin
 391
 392 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
 393 #define TARGET_FUNCTION_OK_FOR_SIBCALL sh_function_ok_for_sibcall
 394
 395 #undef TARGET_CANNOT_COPY_INSN_P
 396 #define TARGET_CANNOT_COPY_INSN_P sh_cannot_copy_insn_p
 397 #undef TARGET_RTX_COSTS
 398 #define TARGET_RTX_COSTS sh_rtx_costs
 399 #undef TARGET_ADDRESS_COST
 400 #define TARGET_ADDRESS_COST sh_address_cost
 401 #undef TARGET_ALLOCATE_INITIAL_VALUE
 402 #define TARGET_ALLOCATE_INITIAL_VALUE sh_allocate_initial_value
 403
 404 #undef TARGET_MACHINE_DEPENDENT_REORG
 405 #define TARGET_MACHINE_DEPENDENT_REORG sh_reorg
 406
 407 #undef TARGET_DWARF_REGISTER_SPAN
 408 #define TARGET_DWARF_REGISTER_SPAN sh_dwarf_register_span
 409
 410 #ifdef HAVE_AS_TLS
 411 #undef TARGET_HAVE_TLS
 412 #define TARGET_HAVE_TLS true
 413 #endif
 414
 415 #undef TARGET_PROMOTE_PROTOTYPES
 416 #define TARGET_PROMOTE_PROTOTYPES sh_promote_prototypes
 417 #undef TARGET_PROMOTE_FUNCTION_ARGS
 418 #define TARGET_PROMOTE_FUNCTION_ARGS sh_promote_prototypes
 419 #undef TARGET_PROMOTE_FUNCTION_RETURN
 420 #define TARGET_PROMOTE_FUNCTION_RETURN sh_promote_prototypes
 421
 422 #undef TARGET_STRUCT_VALUE_RTX
 423 #define TARGET_STRUCT_VALUE_RTX sh_struct_value_rtx
 424 #undef TARGET_RETURN_IN_MEMORY
 425 #define TARGET_RETURN_IN_MEMORY sh_return_in_memory
 426
 427 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
 428 #define TARGET_EXPAND_BUILTIN_SAVEREGS sh_builtin_saveregs
 429 #undef TARGET_SETUP_INCOMING_VARARGS
 430 #define TARGET_SETUP_INCOMING_VARARGS sh_setup_incoming_varargs
 431 #undef TARGET_STRICT_ARGUMENT_NAMING
 432 #define TARGET_STRICT_ARGUMENT_NAMING sh_strict_argument_naming
 433 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
 434 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED sh_pretend_outgoing_varargs_named
 435 #undef TARGET_MUST_PASS_IN_STACK
 436 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
 437 #undef TARGET_PASS_BY_REFERENCE
 438 #define TARGET_PASS_BY_REFERENCE sh_pass_by_reference
 439 #undef TARGET_CALLEE_COPIES
 440 #define TARGET_CALLEE_COPIES sh_callee_copies
 441 #undef TARGET_ARG_PARTIAL_BYTES
 442 #define TARGET_ARG_PARTIAL_BYTES sh_arg_partial_bytes
 443
 444 #undef TARGET_BUILD_BUILTIN_VA_LIST
 445 #define TARGET_BUILD_BUILTIN_VA_LIST sh_build_builtin_va_list
 446 #undef TARGET_EXPAND_BUILTIN_VA_START
 447 #define TARGET_EXPAND_BUILTIN_VA_START sh_va_start
 448 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 449 #define TARGET_GIMPLIFY_VA_ARG_EXPR sh_gimplify_va_arg_expr
 450
 451 #undef TARGET_SCALAR_MODE_SUPPORTED_P
 452 #define TARGET_SCALAR_MODE_SUPPORTED_P sh_scalar_mode_supported_p
 453 #undef TARGET_VECTOR_MODE_SUPPORTED_P
 454 #define TARGET_VECTOR_MODE_SUPPORTED_P sh_vector_mode_supported_p
 455
 456 #undef TARGET_CHECK_PCH_TARGET_FLAGS
 457 #define TARGET_CHECK_PCH_TARGET_FLAGS sh_check_pch_target_flags
 458
 459 #undef TARGET_DWARF_CALLING_CONVENTION
 460 #define TARGET_DWARF_CALLING_CONVENTION sh_dwarf_calling_convention
 461
 462 /* Return regmode weight for insn.  */
 463 #define INSN_REGMODE_WEIGHT(INSN, MODE)  regmode_weight[((MODE) == SImode) ? 0 : 1][INSN_UID (INSN)]
 464
 465 /* Return current register pressure for regmode.  */
 466 #define CURR_REGMODE_PRESSURE(MODE)     curr_regmode_pressure[((MODE) == SImode) ? 0 : 1]
 467
 468 #undef  TARGET_ENCODE_SECTION_INFO
 469 #define TARGET_ENCODE_SECTION_INFO      sh_encode_section_info
 470
 471 #ifdef SYMBIAN
 472
 473 #undef  TARGET_ENCODE_SECTION_INFO
 474 #define TARGET_ENCODE_SECTION_INFO      sh_symbian_encode_section_info
 475 #undef  TARGET_STRIP_NAME_ENCODING
 476 #define TARGET_STRIP_NAME_ENCODING      sh_symbian_strip_name_encoding
 477 #undef  TARGET_CXX_IMPORT_EXPORT_CLASS
 478 #define TARGET_CXX_IMPORT_EXPORT_CLASS  symbian_import_export_class
 479
 480 #endif /* SYMBIAN */
 481
 482 #undef TARGET_SECONDARY_RELOAD
 483 #define TARGET_SECONDARY_RELOAD sh_secondary_reload
 484
 485 #undef TARGET_LEGITIMATE_ADDRESS_P
 486 #define TARGET_LEGITIMATE_ADDRESS_P     sh_legitimate_address_p
 487
 488 /* Machine-specific symbol_ref flags.  */
 489 #define SYMBOL_FLAG_FUNCVEC_FUNCTION    (SYMBOL_FLAG_MACH_DEP << 0)
 490
 491 struct gcc_target targetm = TARGET_INITIALIZER;
 492 \f
 493 /* Implement TARGET_HANDLE_OPTION.  */
 494
 495 static bool
 496 sh_handle_option (size_t code, const char *arg ATTRIBUTE_UNUSED,
 497                   int value ATTRIBUTE_UNUSED)
 498 {
 499   switch (code)
 500     {
 501     case OPT_m1:
 502       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH1;
 503       return true;
 504
 505     case OPT_m2:
 506       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2;
 507       return true;
 508
 509     case OPT_m2a:
 510       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2A;
 511       return true;
 512
 513     case OPT_m2a_nofpu:
 514       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2A_NOFPU;
 515       return true;
 516
 517     case OPT_m2a_single:
 518       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2A_SINGLE;
 519       return true;
 520
 521     case OPT_m2a_single_only:
 522       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2A_SINGLE_ONLY;
 523       return true;
 524
 525     case OPT_m2e:
 526       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2E;
 527       return true;
 528
 529     case OPT_m3:
 530       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH3;
 531       return true;
 532
 533     case OPT_m3e:
 534       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH3E;
 535       return true;
 536
 537     case OPT_m4:
 538     case OPT_m4_100:
 539     case OPT_m4_200:
 540     case OPT_m4_300:
 541       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4;
 542       return true;
 543
 544     case OPT_m4_nofpu:
 545     case OPT_m4_100_nofpu:
 546     case OPT_m4_200_nofpu:
 547     case OPT_m4_300_nofpu:
 548     case OPT_m4_340:
 549     case OPT_m4_400:
 550     case OPT_m4_500:
 551       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4_NOFPU;
 552       return true;
 553
 554     case OPT_m4_single:
 555     case OPT_m4_100_single:
 556     case OPT_m4_200_single:
 557     case OPT_m4_300_single:
 558       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4_SINGLE;
 559       return true;
 560
 561     case OPT_m4_single_only:
 562     case OPT_m4_100_single_only:
 563     case OPT_m4_200_single_only:
 564     case OPT_m4_300_single_only:
 565       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4_SINGLE_ONLY;
 566       return true;
 567
 568     case OPT_m4a:
 569       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4A;
 570       return true;
 571
 572     case OPT_m4a_nofpu:
 573     case OPT_m4al:
 574       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4A_NOFPU;
 575       return true;
 576
 577     case OPT_m4a_single:
 578       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4A_SINGLE;
 579       return true;
 580
 581     case OPT_m4a_single_only:
 582       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4A_SINGLE_ONLY;
 583       return true;
 584
 585     case OPT_m5_32media:
 586       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_32MEDIA;
 587       return true;
 588
 589     case OPT_m5_32media_nofpu:
 590       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_32MEDIA_NOFPU;
 591       return true;
 592
 593     case OPT_m5_64media:
 594       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_64MEDIA;
 595       return true;
 596
 597     case OPT_m5_64media_nofpu:
 598       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_64MEDIA_NOFPU;
 599       return true;
 600
 601     case OPT_m5_compact:
 602       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_COMPACT;
 603       return true;
 604
 605     case OPT_m5_compact_nofpu:
 606       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_COMPACT_NOFPU;
 607       return true;
 608
 609     default:
 610       return true;
 611     }
 612 }
 613 \f
 614 /* Set default optimization options.  */
 615 void
 616 sh_optimization_options (int level ATTRIBUTE_UNUSED, int size ATTRIBUTE_UNUSED)
 617 {
 618   if (level)
 619     {
 620       flag_omit_frame_pointer = 2;
 621       if (!size)
 622         sh_div_str = "inv:minlat";
 623     }
 624   if (size)
 625     {
 626       target_flags |= MASK_SMALLCODE;
 627       sh_div_str = SH_DIV_STR_FOR_SIZE ;
 628     }
 629   else
 630     TARGET_CBRANCHDI4 = 1;
 631   /* We can't meaningfully test TARGET_SHMEDIA here, because -m options
 632      haven't been parsed yet, hence we'd read only the default.
 633      sh_target_reg_class will return NO_REGS if this is not SHMEDIA, so
 634      it's OK to always set flag_branch_target_load_optimize.  */
 635   if (level > 1)
 636     {
 637       flag_branch_target_load_optimize = 1;
 638       if (!size)
 639         target_flags |= MASK_SAVE_ALL_TARGET_REGS;
 640     }
 641   /* Likewise, we can't meaningfully test TARGET_SH2E / TARGET_IEEE
 642      here, so leave it to OVERRIDE_OPTIONS to set
 643     flag_finite_math_only.  We set it to 2 here so we know if the user
 644     explicitly requested this to be on or off.  */
 645   flag_finite_math_only = 2;
 646   /* If flag_schedule_insns is 1, we set it to 2 here so we know if
 647      the user explicitly requested this to be on or off.  */
 648   if (flag_schedule_insns > 0)
 649     flag_schedule_insns = 2;
 650
 651   set_param_value ("simultaneous-prefetches", 2);
 652 }
 653
 654 /* Implement OVERRIDE_OPTIONS macro.  Validate and override various
 655    options, and do some machine dependent initialization.  */
 656 void
 657 sh_override_options (void)
 658 {
 659   int regno;
 660
 661   SUBTARGET_OVERRIDE_OPTIONS;
 662   if (flag_finite_math_only == 2)
 663     flag_finite_math_only
 664       = !flag_signaling_nans && TARGET_SH2E && ! TARGET_IEEE;
 665   if (TARGET_SH2E && !flag_finite_math_only)
 666     target_flags |= MASK_IEEE;
 667   sh_cpu = PROCESSOR_SH1;
 668   assembler_dialect = 0;
 669   if (TARGET_SH2)
 670     sh_cpu = PROCESSOR_SH2;
 671   if (TARGET_SH2E)
 672     sh_cpu = PROCESSOR_SH2E;
 673   if (TARGET_SH2A)
 674     {
 675       sh_cpu = PROCESSOR_SH2A;
 676       if (TARGET_SH2A_DOUBLE)
 677         target_flags |= MASK_FMOVD;
 678     }
 679   if (TARGET_SH3)
 680     sh_cpu = PROCESSOR_SH3;
 681   if (TARGET_SH3E)
 682     sh_cpu = PROCESSOR_SH3E;
 683   if (TARGET_SH4)
 684     {
 685       assembler_dialect = 1;
 686       sh_cpu = PROCESSOR_SH4;
 687     }
 688   if (TARGET_SH4A_ARCH)
 689     {
 690       assembler_dialect = 1;
 691       sh_cpu = PROCESSOR_SH4A;
 692     }
 693   if (TARGET_SH5)
 694     {
 695       sh_cpu = PROCESSOR_SH5;
 696       target_flags |= MASK_ALIGN_DOUBLE;
 697       if (TARGET_SHMEDIA_FPU)
 698         target_flags |= MASK_FMOVD;
 699       if (TARGET_SHMEDIA)
 700         {
 701           /* There are no delay slots on SHmedia.  */
 702           flag_delayed_branch = 0;
 703           /* Relaxation isn't yet supported for SHmedia */
 704           target_flags &= ~MASK_RELAX;
 705           /* After reload, if conversion does little good but can cause
 706              ICEs:
 707              - find_if_block doesn't do anything for SH because we don't
 708                have conditional execution patterns.  (We use conditional
 709                move patterns, which are handled differently, and only
 710                before reload).
 711              - find_cond_trap doesn't do anything for the SH because we
 712                don't have conditional traps.
 713              - find_if_case_1 uses redirect_edge_and_branch_force in
 714                the only path that does an optimization, and this causes
 715                an ICE when branch targets are in registers.
 716              - find_if_case_2 doesn't do anything for the SHmedia after
 717                reload except when it can redirect a tablejump - and
 718                that's rather rare.  */
 719           flag_if_conversion2 = 0;
 720           if (! strcmp (sh_div_str, "call"))
 721             sh_div_strategy = SH_DIV_CALL;
 722           else if (! strcmp (sh_div_str, "call2"))
 723             sh_div_strategy = SH_DIV_CALL2;
 724           if (! strcmp (sh_div_str, "fp") && TARGET_FPU_ANY)
 725             sh_div_strategy = SH_DIV_FP;
 726           else if (! strcmp (sh_div_str, "inv"))
 727             sh_div_strategy = SH_DIV_INV;
 728           else if (! strcmp (sh_div_str, "inv:minlat"))
 729             sh_div_strategy = SH_DIV_INV_MINLAT;
 730           else if (! strcmp (sh_div_str, "inv20u"))
 731             sh_div_strategy = SH_DIV_INV20U;
 732           else if (! strcmp (sh_div_str, "inv20l"))
 733             sh_div_strategy = SH_DIV_INV20L;
 734           else if (! strcmp (sh_div_str, "inv:call2"))
 735             sh_div_strategy = SH_DIV_INV_CALL2;
 736           else if (! strcmp (sh_div_str, "inv:call"))
 737             sh_div_strategy = SH_DIV_INV_CALL;
 738           else if (! strcmp (sh_div_str, "inv:fp"))
 739             {
 740               if (TARGET_FPU_ANY)
 741                 sh_div_strategy = SH_DIV_INV_FP;
 742               else
 743                 sh_div_strategy = SH_DIV_INV;
 744             }
 745           TARGET_CBRANCHDI4 = 0;
 746           /* Assembler CFI isn't yet fully supported for SHmedia.  */
 747           flag_dwarf2_cfi_asm = 0;
 748         }
 749     }
 750   else
 751     {
 752        /* Only the sh64-elf assembler fully supports .quad properly.  */
 753        targetm.asm_out.aligned_op.di = NULL;
 754        targetm.asm_out.unaligned_op.di = NULL;
 755     }
 756   if (TARGET_SH1)
 757     {
 758       if (! strcmp (sh_div_str, "call-div1"))
 759         sh_div_strategy = SH_DIV_CALL_DIV1;
 760       else if (! strcmp (sh_div_str, "call-fp")
 761                && (TARGET_FPU_DOUBLE
 762                    || (TARGET_HARD_SH4 && TARGET_SH2E)
 763                    || (TARGET_SHCOMPACT && TARGET_FPU_ANY)))
 764         sh_div_strategy = SH_DIV_CALL_FP;
 765       else if (! strcmp (sh_div_str, "call-table") && TARGET_SH2)
 766         sh_div_strategy = SH_DIV_CALL_TABLE;
 767       else
 768         /* Pick one that makes most sense for the target in general.
 769            It is not much good to use different functions depending
 770            on -Os, since then we'll end up with two different functions
 771            when some of the code is compiled for size, and some for
 772            speed.  */
 773
 774         /* SH4 tends to emphasize speed.  */
 775         if (TARGET_HARD_SH4)
 776           sh_div_strategy = SH_DIV_CALL_TABLE;
 777         /* These have their own way of doing things.  */
 778         else if (TARGET_SH2A)
 779           sh_div_strategy = SH_DIV_INTRINSIC;
 780         /* ??? Should we use the integer SHmedia function instead?  */
 781         else if (TARGET_SHCOMPACT && TARGET_FPU_ANY)
 782           sh_div_strategy = SH_DIV_CALL_FP;
 783         /* SH1 .. SH3 cores often go into small-footprint systems, so
 784            default to the smallest implementation available.  */
 785         else if (TARGET_SH2)    /* ??? EXPERIMENTAL */
 786           sh_div_strategy = SH_DIV_CALL_TABLE;
 787         else
 788           sh_div_strategy = SH_DIV_CALL_DIV1;
 789     }
 790   if (!TARGET_SH1)
 791     TARGET_PRETEND_CMOVE = 0;
 792   if (sh_divsi3_libfunc[0])
 793     ; /* User supplied - leave it alone.  */
 794   else if (TARGET_DIVIDE_CALL_FP)
 795     sh_divsi3_libfunc = "__sdivsi3_i4";
 796   else if (TARGET_DIVIDE_CALL_TABLE)
 797     sh_divsi3_libfunc = "__sdivsi3_i4i";
 798   else if (TARGET_SH5)
 799     sh_divsi3_libfunc = "__sdivsi3_1";
 800   else
 801     sh_divsi3_libfunc = "__sdivsi3";
 802   if (sh_branch_cost == -1)
 803     sh_branch_cost
 804       = TARGET_SH5 ? 1 : ! TARGET_SH2 || TARGET_HARD_SH4 ? 2 : 1;
 805
 806   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 807     if (! VALID_REGISTER_P (regno))
 808       sh_register_names[regno][0] = '\0';
 809
 810   for (regno = 0; regno < ADDREGNAMES_SIZE; regno++)
 811     if (! VALID_REGISTER_P (ADDREGNAMES_REGNO (regno)))
 812       sh_additional_register_names[regno][0] = '\0';
 813
 814   if (flag_omit_frame_pointer == 2)
 815    {
 816      /* The debugging information is sufficient,
 817         but gdb doesn't implement this yet */
 818      if (0)
 819       flag_omit_frame_pointer
 820         = (PREFERRED_DEBUGGING_TYPE == DWARF2_DEBUG);
 821      else
 822       flag_omit_frame_pointer = 0;
 823    }
 824
 825   if ((flag_pic && ! TARGET_PREFERGOT)
 826       || (TARGET_SHMEDIA && !TARGET_PT_FIXED))
 827     flag_no_function_cse = 1;
 828
 829   if (SMALL_REGISTER_CLASSES)
 830     {
 831       /* Never run scheduling before reload, since that can
 832          break global alloc, and generates slower code anyway due
 833          to the pressure on R0.  */
 834       /* Enable sched1 for SH4 if the user explicitly requests.
 835          When sched1 is enabled, the ready queue will be reordered by
 836          the target hooks if pressure is high.  We can not do this for
 837          PIC, SH3 and lower as they give spill failures for R0.  */
 838       if (!TARGET_HARD_SH4 || flag_pic)
 839         flag_schedule_insns = 0;
 840       /* ??? Current exception handling places basic block boundaries
 841          after call_insns.  It causes the high pressure on R0 and gives
 842          spill failures for R0 in reload.  See PR 22553 and the thread
 843          on gcc-patches
 844          <http://gcc.gnu.org/ml/gcc-patches/2005-10/msg00816.html>.  */
 845       else if (flag_exceptions)
 846         {
 847           if (flag_schedule_insns == 1)
 848             warning (0, "ignoring -fschedule-insns because of exception handling bug");
 849           flag_schedule_insns = 0;
 850         }
 851       else if (flag_schedule_insns == 2)
 852         flag_schedule_insns = 0;
 853     }
 854
 855   if (align_loops == 0)
 856     align_loops =  1 << (TARGET_SH5 ? 3 : 2);
 857   if (align_jumps == 0)
 858     align_jumps = 1 << CACHE_LOG;
 859   else if (align_jumps < (TARGET_SHMEDIA ? 4 : 2))
 860     align_jumps = TARGET_SHMEDIA ? 4 : 2;
 861
 862   /* Allocation boundary (in *bytes*) for the code of a function.
 863      SH1: 32 bit alignment is faster, because instructions are always
 864      fetched as a pair from a longword boundary.
 865      SH2 .. SH5 : align to cache line start.  */
 866   if (align_functions == 0)
 867     align_functions
 868       = TARGET_SMALLCODE ? FUNCTION_BOUNDARY/8 : (1 << CACHE_LOG);
 869   /* The linker relaxation code breaks when a function contains
 870      alignments that are larger than that at the start of a
 871      compilation unit.  */
 872   if (TARGET_RELAX)
 873     {
 874       int min_align
 875         = align_loops > align_jumps ? align_loops : align_jumps;
 876
 877       /* Also take possible .long constants / mova tables int account.  */
 878       if (min_align < 4)
 879         min_align = 4;
 880       if (align_functions < min_align)
 881         align_functions = min_align;
 882     }
 883
 884   if (sh_fixed_range_str)
 885     sh_fix_range (sh_fixed_range_str);
 886 }
 887 \f
 888 /* Print the operand address in x to the stream.  */
 889
 890 void
 891 print_operand_address (FILE *stream, rtx x)
 892 {
 893   switch (GET_CODE (x))
 894     {
 895     case REG:
 896     case SUBREG:
 897       fprintf (stream, "@%s", reg_names[true_regnum (x)]);
 898       break;
 899
 900     case PLUS:
 901       {
 902         rtx base = XEXP (x, 0);
 903         rtx index = XEXP (x, 1);
 904
 905         switch (GET_CODE (index))
 906           {
 907           case CONST_INT:
 908             fprintf (stream, "@(%d,%s)", (int) INTVAL (index),
 909                      reg_names[true_regnum (base)]);
 910             break;
 911
 912           case REG:
 913           case SUBREG:
 914             {
 915               int base_num = true_regnum (base);
 916               int index_num = true_regnum (index);
 917
 918               fprintf (stream, "@(r0,%s)",
 919                        reg_names[MAX (base_num, index_num)]);
 920               break;
 921             }
 922
 923           default:
 924             gcc_unreachable ();
 925           }
 926       }
 927       break;
 928
 929     case PRE_DEC:
 930       fprintf (stream, "@-%s", reg_names[true_regnum (XEXP (x, 0))]);
 931       break;
 932
 933     case POST_INC:
 934       fprintf (stream, "@%s+", reg_names[true_regnum (XEXP (x, 0))]);
 935       break;
 936
 937     default:
 938       x = mark_constant_pool_use (x);
 939       output_addr_const (stream, x);
 940       break;
 941     }
 942 }
 943
 944 /* Print operand x (an rtx) in assembler syntax to file stream
 945    according to modifier code.
 946
 947    '.'  print a .s if insn needs delay slot
 948    ','  print LOCAL_LABEL_PREFIX
 949    '@'  print trap, rte or rts depending upon pragma interruptness
 950    '#'  output a nop if there is nothing to put in the delay slot
 951    '''  print likelihood suffix (/u for unlikely).
 952    '>'  print branch target if -fverbose-asm
 953    'O'  print a constant without the #
 954    'R'  print the LSW of a dp value - changes if in little endian
 955    'S'  print the MSW of a dp value - changes if in little endian
 956    'T'  print the next word of a dp value - same as 'R' in big endian mode.
 957    'M'  SHMEDIA: print an `x' if `m' will print `base,index'.
 958         otherwise: print .b / .w / .l / .s / .d suffix if operand is a MEM.
 959    'N'  print 'r63' if the operand is (const_int 0).
 960    'd'  print a V2SF reg as dN instead of fpN.
 961    'm'  print a pair `base,offset' or `base,index', for LD and ST.
 962    'U'  Likewise for {LD,ST}{HI,LO}.
 963    'V'  print the position of a single bit set.
 964    'W'  print the position of a single bit cleared.
 965    't'  print a memory address which is a register.
 966    'u'  prints the lowest 16 bits of CONST_INT, as an unsigned value.
 967    'o'  output an operator.  */
 968
 969 void
 970 print_operand (FILE *stream, rtx x, int code)
 971 {
 972   int regno;
 973   enum machine_mode mode;
 974
 975   switch (code)
 976     {
 977       tree trapa_attr;
 978
 979     case '.':
 980       if (final_sequence
 981           && ! INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
 982           && get_attr_length (XVECEXP (final_sequence, 0, 1)))
 983         fprintf (stream, ASSEMBLER_DIALECT ? "/s" : ".s");
 984       break;
 985     case ',':
 986       fprintf (stream, "%s", LOCAL_LABEL_PREFIX);
 987       break;
 988     case '@':
 989       trapa_attr = lookup_attribute ("trap_exit",
 990                                       DECL_ATTRIBUTES (current_function_decl));
 991       if (trapa_attr)
 992         fprintf (stream, "trapa #%ld",
 993                  (long) TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (trapa_attr))));
 994       else if (sh_cfun_interrupt_handler_p ())
 995         {
 996           if (sh_cfun_resbank_handler_p ())
 997             fprintf (stream, "resbank\n");
 998           fprintf (stream, "rte");
 999         }
1000       else
1001         fprintf (stream, "rts");
1002       break;
1003     case '#':
1004       /* Output a nop if there's nothing in the delay slot.  */
1005       if (dbr_sequence_length () == 0)
1006         fprintf (stream, "\n\tnop");
1007       break;
1008     case '\'':
1009       {
1010         rtx note = find_reg_note (current_output_insn, REG_BR_PROB, 0);
1011
1012         if (note && INTVAL (XEXP (note, 0)) * 2 < REG_BR_PROB_BASE)
1013           fputs ("/u", stream);
1014         break;
1015       }
1016     case '>':
1017       if (flag_verbose_asm && JUMP_LABEL (current_output_insn))
1018         {
1019           fputs ("\t! target: ", stream);
1020           output_addr_const (stream, JUMP_LABEL (current_output_insn));
1021         }
1022       break;
1023     case 'O':
1024       x = mark_constant_pool_use (x);
1025       output_addr_const (stream, x);
1026       break;
1027     /* N.B.: %R / %S / %T adjust memory addresses by four.
1028        For SHMEDIA, that means they can be used to access the first and
1029        second 32 bit part of a 64 bit (or larger) value that
1030        might be held in floating point registers or memory.
1031        While they can be used to access 64 bit parts of a larger value
1032        held in general purpose registers, that won't work with memory -
1033        neither for fp registers, since the frxx names are used.  */
1034     case 'R':
1035       if (REG_P (x) || GET_CODE (x) == SUBREG)
1036         {
1037           regno = true_regnum (x);
1038           regno += FP_REGISTER_P (regno) ? 1 : LSW;
1039           fputs (reg_names[regno], (stream));
1040         }
1041       else if (MEM_P (x))
1042         {
1043           x = adjust_address (x, SImode, 4 * LSW);
1044           print_operand_address (stream, XEXP (x, 0));
1045         }
1046       else
1047         {
1048           rtx sub = NULL_RTX;
1049
1050           mode = GET_MODE (x);
1051           if (mode == VOIDmode)
1052             mode = DImode;
1053           if (GET_MODE_SIZE (mode) >= 8)
1054             sub = simplify_subreg (SImode, x, mode, 4 * LSW);
1055           if (sub)
1056             print_operand (stream, sub, 0);
1057           else
1058             output_operand_lossage ("invalid operand to %%R");
1059         }
1060       break;
1061     case 'S':
1062       if (REG_P (x) || GET_CODE (x) == SUBREG)
1063         {
1064           regno = true_regnum (x);
1065           regno += FP_REGISTER_P (regno) ? 0 : MSW;
1066           fputs (reg_names[regno], (stream));
1067         }
1068       else if (MEM_P (x))
1069         {
1070           x = adjust_address (x, SImode, 4 * MSW);
1071           print_operand_address (stream, XEXP (x, 0));
1072         }
1073       else
1074         {
1075           rtx sub = NULL_RTX;
1076
1077           mode = GET_MODE (x);
1078           if (mode == VOIDmode)
1079             mode = DImode;
1080           if (GET_MODE_SIZE (mode) >= 8)
1081             sub = simplify_subreg (SImode, x, mode, 4 * MSW);
1082           if (sub)
1083             print_operand (stream, sub, 0);
1084           else
1085             output_operand_lossage ("invalid operand to %%S");
1086         }
1087       break;
1088     case 'T':
1089       /* Next word of a double.  */
1090       switch (GET_CODE (x))
1091         {
1092         case REG:
1093           fputs (reg_names[REGNO (x) + 1], (stream));
1094           break;
1095         case MEM:
1096           if (GET_CODE (XEXP (x, 0)) != PRE_DEC
1097               && GET_CODE (XEXP (x, 0)) != POST_INC)
1098             x = adjust_address (x, SImode, 4);
1099           print_operand_address (stream, XEXP (x, 0));
1100           break;
1101         default:
1102           break;
1103         }
1104       break;
1105
1106     case 't':
1107       gcc_assert (MEM_P (x));
1108       x = XEXP (x, 0);
1109       switch (GET_CODE (x))
1110         {
1111         case REG:
1112         case SUBREG:
1113           print_operand (stream, x, 0);
1114           break;
1115         default:
1116           break;
1117         }
1118       break;
1119
1120     case 'o':
1121       switch (GET_CODE (x))
1122         {
1123         case PLUS:  fputs ("add", stream); break;
1124         case MINUS: fputs ("sub", stream); break;
1125         case MULT:  fputs ("mul", stream); break;
1126         case DIV:   fputs ("div", stream); break;
1127         case EQ:    fputs ("eq",  stream); break;
1128         case NE:    fputs ("ne",  stream); break;
1129         case GT:  case LT:  fputs ("gt",  stream); break;
1130         case GE:  case LE:  fputs ("ge",  stream); break;
1131         case GTU: case LTU: fputs ("gtu", stream); break;
1132         case GEU: case LEU: fputs ("geu", stream); break;
1133         default:
1134           break;
1135         }
1136       break;
1137     case 'M':
1138       if (TARGET_SHMEDIA)
1139         {
1140           if (MEM_P (x)
1141               && GET_CODE (XEXP (x, 0)) == PLUS
1142               && (REG_P (XEXP (XEXP (x, 0), 1))
1143                   || GET_CODE (XEXP (XEXP (x, 0), 1)) == SUBREG))
1144             fputc ('x', stream);
1145         }
1146       else
1147         {
1148           if (MEM_P (x))
1149             {
1150               switch (GET_MODE (x))
1151                 {
1152                 case QImode: fputs (".b", stream); break;
1153                 case HImode: fputs (".w", stream); break;
1154                 case SImode: fputs (".l", stream); break;
1155                 case SFmode: fputs (".s", stream); break;
1156                 case DFmode: fputs (".d", stream); break;
1157                 default: gcc_unreachable ();
1158                 }
1159             }
1160         }
1161       break;
1162
1163     case 'm':
1164       gcc_assert (MEM_P (x));
1165       x = XEXP (x, 0);
1166       /* Fall through.  */
1167     case 'U':
1168       switch (GET_CODE (x))
1169         {
1170         case REG:
1171         case SUBREG:
1172           print_operand (stream, x, 0);
1173           fputs (", 0", stream);
1174           break;
1175
1176         case PLUS:
1177           print_operand (stream, XEXP (x, 0), 0);
1178           fputs (", ", stream);
1179           print_operand (stream, XEXP (x, 1), 0);
1180           break;
1181
1182         default:
1183           gcc_unreachable ();
1184         }
1185       break;
1186
1187     case 'V':
1188       {
1189         int num = exact_log2 (INTVAL (x));
1190         gcc_assert (num >= 0);
1191         fprintf (stream, "#%d", num);
1192       }
1193       break;
1194
1195     case 'W':
1196       {
1197         int num = exact_log2 (~INTVAL (x));
1198         gcc_assert (num >= 0);
1199         fprintf (stream, "#%d", num);
1200       }
1201       break;
1202
1203     case 'd':
1204       gcc_assert (REG_P (x) && GET_MODE (x) == V2SFmode);
1205
1206       fprintf ((stream), "d%s", reg_names[REGNO (x)] + 1);
1207       break;
1208
1209     case 'N':
1210       if (x == CONST0_RTX (GET_MODE (x)))
1211         {
1212           fprintf ((stream), "r63");
1213           break;
1214         }
1215       goto default_output;
1216     case 'u':
1217       if (CONST_INT_P (x))
1218         {
1219           fprintf ((stream), "%u", (unsigned) INTVAL (x) & (0x10000 - 1));
1220           break;
1221         }
1222       /* Fall through.  */
1223
1224     default_output:
1225     default:
1226       regno = 0;
1227       mode = GET_MODE (x);
1228
1229       switch (GET_CODE (x))
1230         {
1231         case TRUNCATE:
1232           {
1233             rtx inner = XEXP (x, 0);
1234             int offset = 0;
1235             enum machine_mode inner_mode;
1236
1237             /* We might see SUBREGs with vector mode registers inside.  */
1238             if (GET_CODE (inner) == SUBREG
1239                 && (GET_MODE_SIZE (GET_MODE (inner))
1240                     == GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner))))
1241                 && subreg_lowpart_p (inner))
1242               inner = SUBREG_REG (inner);
1243             if (CONST_INT_P (inner))
1244               {
1245                 x = GEN_INT (trunc_int_for_mode (INTVAL (inner), GET_MODE (x)));
1246                 goto default_output;
1247               }
1248             inner_mode = GET_MODE (inner);
1249             if (GET_CODE (inner) == SUBREG
1250                 && (GET_MODE_SIZE (GET_MODE (inner))
1251                     < GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner))))
1252                 && REG_P (SUBREG_REG (inner)))
1253               {
1254                 offset = subreg_regno_offset (REGNO (SUBREG_REG (inner)),
1255                                               GET_MODE (SUBREG_REG (inner)),
1256                                               SUBREG_BYTE (inner),
1257                                               GET_MODE (inner));
1258                 inner = SUBREG_REG (inner);
1259               }
1260             if (!REG_P (inner) || GET_MODE_SIZE (inner_mode) > 8)
1261               abort ();
1262             /* Floating point register pairs are always big endian;
1263                general purpose registers are 64 bit wide.  */
1264             regno = REGNO (inner);
1265             regno = (HARD_REGNO_NREGS (regno, inner_mode)
1266                      - HARD_REGNO_NREGS (regno, mode))
1267                      + offset;
1268             x = inner;
1269             goto reg;
1270           }
1271         case SIGN_EXTEND:
1272           x = XEXP (x, 0);
1273           goto reg;
1274           /* FIXME: We need this on SHmedia32 because reload generates
1275              some sign-extended HI or QI loads into DImode registers
1276              but, because Pmode is SImode, the address ends up with a
1277              subreg:SI of the DImode register.  Maybe reload should be
1278              fixed so as to apply alter_subreg to such loads?  */
1279         case IF_THEN_ELSE:
1280           gcc_assert (trapping_target_operand (x, VOIDmode));
1281           x = XEXP (XEXP (x, 2), 0);
1282           goto default_output;
1283         case SUBREG:
1284           gcc_assert (SUBREG_BYTE (x) == 0
1285                       && REG_P (SUBREG_REG (x)));
1286
1287           x = SUBREG_REG (x);
1288           /* Fall through.  */
1289
1290         reg:
1291         case REG:
1292           regno += REGNO (x);
1293           if (FP_REGISTER_P (regno)
1294               && mode == V16SFmode)
1295             fprintf ((stream), "mtrx%s", reg_names[regno] + 2);
1296           else if (FP_REGISTER_P (REGNO (x))
1297                    && mode == V4SFmode)
1298             fprintf ((stream), "fv%s", reg_names[regno] + 2);
1299           else if (REG_P (x)
1300                    && mode == V2SFmode)
1301             fprintf ((stream), "fp%s", reg_names[regno] + 2);
1302           else if (FP_REGISTER_P (REGNO (x))
1303                    && GET_MODE_SIZE (mode) > 4)
1304             fprintf ((stream), "d%s", reg_names[regno] + 1);
1305           else
1306             fputs (reg_names[regno], (stream));
1307           break;
1308
1309         case MEM:
1310           output_address (XEXP (x, 0));
1311           break;
1312
1313         default:
1314           if (TARGET_SH1)
1315             fputc ('#', stream);
1316           output_addr_const (stream, x);
1317           break;
1318         }
1319       break;
1320     }
1321 }
1322 \f
1323
1324 /* Encode symbol attributes of a SYMBOL_REF into its
1325    SYMBOL_REF_FLAGS.  */
1326 static void
1327 sh_encode_section_info (tree decl, rtx rtl, int first)
1328 {
1329   default_encode_section_info (decl, rtl, first);
1330
1331   if (TREE_CODE (decl) == FUNCTION_DECL
1332       && sh2a_function_vector_p (decl) && TARGET_SH2A)
1333     SYMBOL_REF_FLAGS (XEXP (rtl, 0)) |= SYMBOL_FLAG_FUNCVEC_FUNCTION;
1334 }
1335
1336 /* Like force_operand, but guarantees that VALUE ends up in TARGET.  */
1337 static void
1338 force_into (rtx value, rtx target)
1339 {
1340   value = force_operand (value, target);
1341   if (! rtx_equal_p (value, target))
1342     emit_insn (gen_move_insn (target, value));
1343 }
1344
1345 /* Emit code to perform a block move.  Choose the best method.
1346
1347    OPERANDS[0] is the destination.
1348    OPERANDS[1] is the source.
1349    OPERANDS[2] is the size.
1350    OPERANDS[3] is the alignment safe to use.  */
1351
1352 int
1353 expand_block_move (rtx *operands)
1354 {
1355   int align = INTVAL (operands[3]);
1356   int constp = (CONST_INT_P (operands[2]));
1357   int bytes = (constp ? INTVAL (operands[2]) : 0);
1358
1359   if (! constp)
1360     return 0;
1361
1362   /* If we could use mov.l to move words and dest is word-aligned, we
1363      can use movua.l for loads and still generate a relatively short
1364      and efficient sequence.  */
1365   if (TARGET_SH4A_ARCH && align < 4
1366       && MEM_ALIGN (operands[0]) >= 32
1367       && can_move_by_pieces (bytes, 32))
1368     {
1369       rtx dest = copy_rtx (operands[0]);
1370       rtx src = copy_rtx (operands[1]);
1371       /* We could use different pseudos for each copied word, but
1372          since movua can only load into r0, it's kind of
1373          pointless.  */
1374       rtx temp = gen_reg_rtx (SImode);
1375       rtx src_addr = copy_addr_to_reg (XEXP (src, 0));
1376       int copied = 0;
1377
1378       while (copied + 4 <= bytes)
1379         {
1380           rtx to = adjust_address (dest, SImode, copied);
1381           rtx from = adjust_automodify_address (src, BLKmode,
1382                                                 src_addr, copied);
1383
1384           set_mem_size (from, GEN_INT (4));
1385           emit_insn (gen_movua (temp, from));
1386           emit_move_insn (src_addr, plus_constant (src_addr, 4));
1387           emit_move_insn (to, temp);
1388           copied += 4;
1389         }
1390
1391       if (copied < bytes)
1392         move_by_pieces (adjust_address (dest, BLKmode, copied),
1393                         adjust_automodify_address (src, BLKmode,
1394                                                    src_addr, copied),
1395                         bytes - copied, align, 0);
1396
1397       return 1;
1398     }
1399
1400   /* If it isn't a constant number of bytes, or if it doesn't have 4 byte
1401      alignment, or if it isn't a multiple of 4 bytes, then fail.  */
1402   if (align < 4 || (bytes % 4 != 0))
1403     return 0;
1404
1405   if (TARGET_HARD_SH4)
1406     {
1407       if (bytes < 12)
1408         return 0;
1409       else if (bytes == 12)
1410         {
1411           rtx func_addr_rtx = gen_reg_rtx (Pmode);
1412           rtx r4 = gen_rtx_REG (SImode, 4);
1413           rtx r5 = gen_rtx_REG (SImode, 5);
1414
1415           function_symbol (func_addr_rtx, "__movmemSI12_i4", SFUNC_STATIC);
1416           force_into (XEXP (operands[0], 0), r4);
1417           force_into (XEXP (operands[1], 0), r5);
1418           emit_insn (gen_block_move_real_i4 (func_addr_rtx));
1419           return 1;
1420         }
1421       else if (! TARGET_SMALLCODE)
1422         {
1423           const char *entry_name;
1424           rtx func_addr_rtx = gen_reg_rtx (Pmode);
1425           int dwords;
1426           rtx r4 = gen_rtx_REG (SImode, 4);
1427           rtx r5 = gen_rtx_REG (SImode, 5);
1428           rtx r6 = gen_rtx_REG (SImode, 6);
1429
1430           entry_name = (bytes & 4 ? "__movmem_i4_odd" : "__movmem_i4_even");
1431           function_symbol (func_addr_rtx, entry_name, SFUNC_STATIC);
1432           force_into (XEXP (operands[0], 0), r4);
1433           force_into (XEXP (operands[1], 0), r5);
1434
1435           dwords = bytes >> 3;
1436           emit_insn (gen_move_insn (r6, GEN_INT (dwords - 1)));
1437           emit_insn (gen_block_lump_real_i4 (func_addr_rtx));
1438           return 1;
1439         }
1440       else
1441         return 0;
1442     }
1443   if (bytes < 64)
1444     {
1445       char entry[30];
1446       rtx func_addr_rtx = gen_reg_rtx (Pmode);
1447       rtx r4 = gen_rtx_REG (SImode, 4);
1448       rtx r5 = gen_rtx_REG (SImode, 5);
1449
1450       sprintf (entry, "__movmemSI%d", bytes);
1451       function_symbol (func_addr_rtx, entry, SFUNC_STATIC);
1452       force_into (XEXP (operands[0], 0), r4);
1453       force_into (XEXP (operands[1], 0), r5);
1454       emit_insn (gen_block_move_real (func_addr_rtx));
1455       return 1;
1456     }
1457
1458   /* This is the same number of bytes as a memcpy call, but to a different
1459      less common function name, so this will occasionally use more space.  */
1460   if (! TARGET_SMALLCODE)
1461     {
1462       rtx func_addr_rtx = gen_reg_rtx (Pmode);
1463       int final_switch, while_loop;
1464       rtx r4 = gen_rtx_REG (SImode, 4);
1465       rtx r5 = gen_rtx_REG (SImode, 5);
1466       rtx r6 = gen_rtx_REG (SImode, 6);
1467
1468       function_symbol (func_addr_rtx, "__movmem", SFUNC_STATIC);
1469       force_into (XEXP (operands[0], 0), r4);
1470       force_into (XEXP (operands[1], 0), r5);
1471
1472       /* r6 controls the size of the move.  16 is decremented from it
1473          for each 64 bytes moved.  Then the negative bit left over is used
1474          as an index into a list of move instructions.  e.g., a 72 byte move
1475          would be set up with size(r6) = 14, for one iteration through the
1476          big while loop, and a switch of -2 for the last part.  */
1477
1478       final_switch = 16 - ((bytes / 4) % 16);
1479       while_loop = ((bytes / 4) / 16 - 1) * 16;
1480       emit_insn (gen_move_insn (r6, GEN_INT (while_loop + final_switch)));
1481       emit_insn (gen_block_lump_real (func_addr_rtx));
1482       return 1;
1483     }
1484
1485   return 0;
1486 }
1487
1488 /* Prepare operands for a move define_expand; specifically, one of the
1489    operands must be in a register.  */
1490
1491 int
1492 prepare_move_operands (rtx operands[], enum machine_mode mode)
1493 {
1494   if ((mode == SImode || mode == DImode)
1495       && flag_pic
1496       && ! ((mode == Pmode || mode == ptr_mode)
1497             && tls_symbolic_operand (operands[1], Pmode) != TLS_MODEL_NONE))
1498     {
1499       rtx temp;
1500       if (SYMBOLIC_CONST_P (operands[1]))
1501         {
1502           if (MEM_P (operands[0]))
1503             operands[1] = force_reg (Pmode, operands[1]);
1504           else if (TARGET_SHMEDIA
1505                    && GET_CODE (operands[1]) == LABEL_REF
1506                    && target_reg_operand (operands[0], mode))
1507             /* It's ok.  */;
1508           else
1509             {
1510               temp = (!can_create_pseudo_p ()
1511                       ? operands[0]
1512                       : gen_reg_rtx (Pmode));
1513               operands[1] = legitimize_pic_address (operands[1], mode, temp);
1514             }
1515         }
1516       else if (GET_CODE (operands[1]) == CONST
1517                && GET_CODE (XEXP (operands[1], 0)) == PLUS
1518                && SYMBOLIC_CONST_P (XEXP (XEXP (operands[1], 0), 0)))
1519         {
1520           temp = !can_create_pseudo_p () ? operands[0] : gen_reg_rtx (Pmode);
1521           temp = legitimize_pic_address (XEXP (XEXP (operands[1], 0), 0),
1522                                          mode, temp);
1523           operands[1] = expand_binop (mode, add_optab, temp,
1524                                       XEXP (XEXP (operands[1], 0), 1),
1525                                       (!can_create_pseudo_p ()
1526                                        ? temp
1527                                        : gen_reg_rtx (Pmode)),
1528                                       0, OPTAB_LIB_WIDEN);
1529         }
1530     }
1531
1532   if (! reload_in_progress && ! reload_completed)
1533     {
1534       /* Copy the source to a register if both operands aren't registers.  */
1535       if (! register_operand (operands[0], mode)
1536           && ! sh_register_operand (operands[1], mode))
1537         operands[1] = copy_to_mode_reg (mode, operands[1]);
1538
1539       if (MEM_P (operands[0]) && ! memory_operand (operands[0], mode))
1540         {
1541           /* This is like change_address_1 (operands[0], mode, 0, 1) ,
1542              except that we can't use that function because it is static.  */
1543           rtx new_rtx = change_address (operands[0], mode, 0);
1544           MEM_COPY_ATTRIBUTES (new_rtx, operands[0]);
1545           operands[0] = new_rtx;
1546         }
1547
1548       /* This case can happen while generating code to move the result
1549          of a library call to the target.  Reject `st r0,@(rX,rY)' because
1550          reload will fail to find a spill register for rX, since r0 is already
1551          being used for the source.  */
1552       else if (TARGET_SH1
1553                && refers_to_regno_p (R0_REG, R0_REG + 1, operands[1], (rtx *)0)
1554                && MEM_P (operands[0])
1555                && GET_CODE (XEXP (operands[0], 0)) == PLUS
1556                && REG_P (XEXP (XEXP (operands[0], 0), 1)))
1557         operands[1] = copy_to_mode_reg (mode, operands[1]);
1558     }
1559
1560   if (mode == Pmode || mode == ptr_mode)
1561     {
1562       rtx op0, op1, opc;
1563       enum tls_model tls_kind;
1564
1565       op0 = operands[0];
1566       op1 = operands[1];
1567       if (GET_CODE (op1) == CONST
1568           && GET_CODE (XEXP (op1, 0)) == PLUS
1569           && (tls_symbolic_operand (XEXP (XEXP (op1, 0), 0), Pmode)
1570               != TLS_MODEL_NONE))
1571         {
1572           opc = XEXP (XEXP (op1, 0), 1);
1573           op1 = XEXP (XEXP (op1, 0), 0);
1574         }
1575       else
1576         opc = NULL_RTX;
1577
1578       if ((tls_kind = tls_symbolic_operand (op1, Pmode)) != TLS_MODEL_NONE)
1579         {
1580           rtx tga_op1, tga_ret, tmp, tmp2;
1581
1582           switch (tls_kind)
1583             {
1584             case TLS_MODEL_GLOBAL_DYNAMIC:
1585               tga_ret = gen_rtx_REG (Pmode, R0_REG);
1586               emit_call_insn (gen_tls_global_dynamic (tga_ret, op1));
1587               op1 = tga_ret;
1588               break;
1589
1590             case TLS_MODEL_LOCAL_DYNAMIC:
1591               tga_ret = gen_rtx_REG (Pmode, R0_REG);
1592               emit_call_insn (gen_tls_local_dynamic (tga_ret, op1));
1593
1594               tmp = gen_reg_rtx (Pmode);
1595               emit_move_insn (tmp, tga_ret);
1596
1597               if (register_operand (op0, Pmode))
1598                 tmp2 = op0;
1599               else
1600                 tmp2 = gen_reg_rtx (Pmode);
1601
1602               emit_insn (gen_symDTPOFF2reg (tmp2, op1, tmp));
1603               op1 = tmp2;
1604               break;
1605
1606             case TLS_MODEL_INITIAL_EXEC:
1607               if (! flag_pic)
1608                 {
1609                   /* Don't schedule insns for getting GOT address when
1610                      the first scheduling is enabled, to avoid spill
1611                      failures for R0.  */
1612                   if (flag_schedule_insns)
1613                     emit_insn (gen_blockage ());
1614                   emit_insn (gen_GOTaddr2picreg ());
1615                   emit_use (gen_rtx_REG (SImode, PIC_REG));
1616                   if (flag_schedule_insns)
1617                     emit_insn (gen_blockage ());
1618                 }
1619               tga_op1 = !can_create_pseudo_p () ? op0 : gen_reg_rtx (Pmode);
1620               tmp = gen_sym2GOTTPOFF (op1);
1621               emit_insn (gen_tls_initial_exec (tga_op1, tmp));
1622               op1 = tga_op1;
1623               break;
1624
1625             case TLS_MODEL_LOCAL_EXEC:
1626               tmp2 = gen_reg_rtx (Pmode);
1627               emit_insn (gen_load_gbr (tmp2));
1628               tmp = gen_reg_rtx (Pmode);
1629               emit_insn (gen_symTPOFF2reg (tmp, op1));
1630
1631               if (register_operand (op0, Pmode))
1632                 op1 = op0;
1633               else
1634                 op1 = gen_reg_rtx (Pmode);
1635
1636               emit_insn (gen_addsi3 (op1, tmp, tmp2));
1637               break;
1638
1639             default:
1640               gcc_unreachable ();
1641             }
1642           if (opc)
1643             emit_insn (gen_addsi3 (op1, op1, force_reg (SImode, opc)));
1644           operands[1] = op1;
1645         }
1646     }
1647
1648   return 0;
1649 }
1650
1651 enum rtx_code
1652 prepare_cbranch_operands (rtx *operands, enum machine_mode mode,
1653                           enum rtx_code comparison)
1654 {
1655   rtx op1;
1656   rtx scratch = NULL_RTX;
1657
1658   if (comparison == LAST_AND_UNUSED_RTX_CODE)
1659     comparison = GET_CODE (operands[0]);
1660   else
1661     scratch = operands[4];
1662   if (CONST_INT_P (operands[1])
1663       && !CONST_INT_P (operands[2]))
1664     {
1665       rtx tmp = operands[1];
1666
1667       operands[1] = operands[2];
1668       operands[2] = tmp;
1669       comparison = swap_condition (comparison);
1670     }
1671   if (CONST_INT_P (operands[2]))
1672     {
1673       HOST_WIDE_INT val = INTVAL (operands[2]);
1674       if ((val == -1 || val == -0x81)
1675           && (comparison == GT || comparison == LE))
1676         {
1677           comparison = (comparison == GT) ? GE : LT;
1678           operands[2] = gen_int_mode (val + 1, mode);
1679         }
1680       else if ((val == 1 || val == 0x80)
1681                && (comparison == GE || comparison == LT))
1682         {
1683           comparison = (comparison == GE) ? GT : LE;
1684           operands[2] = gen_int_mode (val - 1, mode);
1685         }
1686       else if (val == 1 && (comparison == GEU || comparison == LTU))
1687         {
1688           comparison = (comparison == GEU) ? NE : EQ;
1689           operands[2] = CONST0_RTX (mode);
1690         }
1691       else if (val == 0x80 && (comparison == GEU || comparison == LTU))
1692         {
1693           comparison = (comparison == GEU) ? GTU : LEU;
1694           operands[2] = gen_int_mode (val - 1, mode);
1695         }
1696       else if (val == 0 && (comparison == GTU || comparison == LEU))
1697         comparison = (comparison == GTU) ? NE : EQ;
1698       else if (mode == SImode
1699                && ((val == 0x7fffffff
1700                     && (comparison == GTU || comparison == LEU))
1701                    || ((unsigned HOST_WIDE_INT) val
1702                         == (unsigned HOST_WIDE_INT) 0x7fffffff + 1
1703                        && (comparison == GEU || comparison == LTU))))
1704         {
1705           comparison = (comparison == GTU || comparison == GEU) ? LT : GE;
1706           operands[2] = CONST0_RTX (mode);
1707         }
1708     }
1709   op1 = operands[1];
1710   if (can_create_pseudo_p ())
1711     operands[1] = force_reg (mode, op1);
1712   /* When we are handling DImode comparisons, we want to keep constants so
1713      that we can optimize the component comparisons; however, memory loads
1714      are better issued as a whole so that they can be scheduled well.
1715      SImode equality comparisons allow I08 constants, but only when they
1716      compare r0.  Hence, if operands[1] has to be loaded from somewhere else
1717      into a register, that register might as well be r0, and we allow the
1718      constant.  If it is already in a register, this is likely to be
1719      allocated to a different hard register, thus we load the constant into
1720      a register unless it is zero.  */
1721   if (!REG_P (operands[2])
1722       && (!CONST_INT_P (operands[2])
1723           || (mode == SImode && operands[2] != CONST0_RTX (SImode)
1724               && ((comparison != EQ && comparison != NE)
1725                   || (REG_P (op1) && REGNO (op1) != R0_REG)
1726                   || !satisfies_constraint_I08 (operands[2])))))
1727     {
1728       if (scratch && GET_MODE (scratch) == mode)
1729         {
1730           emit_move_insn (scratch, operands[2]);
1731           operands[2] = scratch;
1732         }
1733       else if (can_create_pseudo_p ())
1734         operands[2] = force_reg (mode, operands[2]);
1735     }
1736   return comparison;
1737 }
1738
1739 void
1740 expand_cbranchsi4 (rtx *operands, enum rtx_code comparison, int probability)
1741 {
1742   rtx (*branch_expander) (rtx) = gen_branch_true;
1743   rtx jump;
1744
1745   comparison = prepare_cbranch_operands (operands, SImode, comparison);
1746   switch (comparison)
1747     {
1748     case NE: case LT: case LE: case LTU: case LEU:
1749       comparison = reverse_condition (comparison);
1750       branch_expander = gen_branch_false;
1751     default: ;
1752     }
1753   emit_insn (gen_rtx_SET (VOIDmode, gen_rtx_REG (SImode, T_REG),
1754                           gen_rtx_fmt_ee (comparison, SImode,
1755                                           operands[1], operands[2])));
1756   jump = emit_jump_insn (branch_expander (operands[3]));
1757   if (probability >= 0)
1758     add_reg_note (jump, REG_BR_PROB, GEN_INT (probability));
1759
1760 }
1761
1762 /* ??? How should we distribute probabilities when more than one branch
1763    is generated.  So far we only have soem ad-hoc observations:
1764    - If the operands are random, they are likely to differ in both parts.
1765    - If comparing items in a hash chain, the operands are random or equal;
1766      operation should be EQ or NE.
1767    - If items are searched in an ordered tree from the root, we can expect
1768      the highpart to be unequal about half of the time; operation should be
1769      an inequality comparison, operands non-constant, and overall probability
1770      about 50%.  Likewise for quicksort.
1771    - Range checks will be often made against constants.  Even if we assume for
1772      simplicity an even distribution of the non-constant operand over a
1773      sub-range here, the same probability could be generated with differently
1774      wide sub-ranges - as long as the ratio of the part of the subrange that
1775      is before the threshold to the part that comes after the threshold stays
1776      the same.  Thus, we can't really tell anything here;
1777      assuming random distribution is at least simple.
1778  */
1779
1780 bool
1781 expand_cbranchdi4 (rtx *operands, enum rtx_code comparison)
1782 {
1783   enum rtx_code msw_taken, msw_skip, lsw_taken;
1784   rtx skip_label = NULL_RTX;
1785   rtx op1h, op1l, op2h, op2l;
1786   int num_branches;
1787   int prob, rev_prob;
1788   int msw_taken_prob = -1, msw_skip_prob = -1, lsw_taken_prob = -1;
1789   rtx scratch = operands[4];
1790
1791   comparison = prepare_cbranch_operands (operands, DImode, comparison);
1792   op1h = gen_highpart_mode (SImode, DImode, operands[1]);
1793   op2h = gen_highpart_mode (SImode, DImode, operands[2]);
1794   op1l = gen_lowpart (SImode, operands[1]);
1795   op2l = gen_lowpart (SImode, operands[2]);
1796   msw_taken = msw_skip = lsw_taken = LAST_AND_UNUSED_RTX_CODE;
1797   prob = split_branch_probability;
1798   rev_prob = REG_BR_PROB_BASE - prob;
1799   switch (comparison)
1800     {
1801     /* ??? Should we use the cmpeqdi_t pattern for equality comparisons?
1802        That costs 1 cycle more when the first branch can be predicted taken,
1803        but saves us mispredicts because only one branch needs prediction.
1804        It also enables generating the cmpeqdi_t-1 pattern.  */
1805     case EQ:
1806       if (TARGET_CMPEQDI_T)
1807         {
1808           emit_insn (gen_cmpeqdi_t (operands[1], operands[2]));
1809           emit_jump_insn (gen_branch_true (operands[3]));
1810           return true;
1811         }
1812       msw_skip = NE;
1813       lsw_taken = EQ;
1814       if (prob >= 0)
1815         {
1816           /* If we had more precision, we'd use rev_prob - (rev_prob >> 32) .
1817            */
1818           msw_skip_prob = rev_prob;
1819           if (REG_BR_PROB_BASE <= 65535)
1820             lsw_taken_prob = prob ? REG_BR_PROB_BASE : 0;
1821           else
1822             {
1823               gcc_assert (HOST_BITS_PER_WIDEST_INT >= 64);
1824               lsw_taken_prob
1825                 = (prob
1826                    ? (REG_BR_PROB_BASE
1827                       - ((HOST_WIDEST_INT) REG_BR_PROB_BASE * rev_prob
1828                          / ((HOST_WIDEST_INT) prob << 32)))
1829                    : 0);
1830             }
1831         }
1832       break;
1833     case NE:
1834       if (TARGET_CMPEQDI_T)
1835         {
1836           emit_insn (gen_cmpeqdi_t (operands[1], operands[2]));
1837           emit_jump_insn (gen_branch_false (operands[3]));
1838           return true;
1839         }
1840       msw_taken = NE;
1841       msw_taken_prob = prob;
1842       lsw_taken = NE;
1843       lsw_taken_prob = 0;
1844       break;
1845     case GTU: case GT:
1846       msw_taken = comparison;
1847       if (CONST_INT_P (op2l) && INTVAL (op2l) == -1)
1848         break;
1849       if (comparison != GTU || op2h != CONST0_RTX (SImode))
1850         msw_skip = swap_condition (msw_taken);
1851       lsw_taken = GTU;
1852       break;
1853     case GEU: case GE:
1854       if (op2l == CONST0_RTX (SImode))
1855         msw_taken = comparison;
1856       else
1857         {
1858           msw_taken = comparison == GE ? GT : GTU;
1859           msw_skip = swap_condition (msw_taken);
1860           lsw_taken = GEU;
1861         }
1862       break;
1863     case LTU: case LT:
1864       msw_taken = comparison;
1865       if (op2l == CONST0_RTX (SImode))
1866         break;
1867       msw_skip = swap_condition (msw_taken);
1868       lsw_taken = LTU;
1869       break;
1870     case LEU: case LE:
1871       if (CONST_INT_P (op2l) && INTVAL (op2l) == -1)
1872         msw_taken = comparison;
1873       else
1874         {
1875           lsw_taken = LEU;
1876           if (comparison == LE)
1877             msw_taken = LT;
1878           else if (op2h != CONST0_RTX (SImode))
1879             msw_taken = LTU;
1880           else
1881             break;
1882           msw_skip = swap_condition (msw_taken);
1883         }
1884       break;
1885     default: return false;
1886     }
1887   num_branches = ((msw_taken != LAST_AND_UNUSED_RTX_CODE)
1888                   + (msw_skip != LAST_AND_UNUSED_RTX_CODE)
1889                   + (lsw_taken != LAST_AND_UNUSED_RTX_CODE));
1890   if (comparison != EQ && comparison != NE && num_branches > 1)
1891     {
1892       if (!CONSTANT_P (operands[2])
1893           && prob >= (int) (REG_BR_PROB_BASE * 3 / 8U)
1894           && prob <= (int) (REG_BR_PROB_BASE * 5 / 8U))
1895         {
1896           msw_taken_prob = prob / 2U;
1897           msw_skip_prob
1898             = REG_BR_PROB_BASE * rev_prob / (REG_BR_PROB_BASE + rev_prob);
1899           lsw_taken_prob = prob;
1900         }
1901       else
1902         {
1903           msw_taken_prob = prob;
1904           msw_skip_prob = REG_BR_PROB_BASE;
1905           /* ??? If we have a constant op2h, should we use that when
1906              calculating lsw_taken_prob?  */
1907           lsw_taken_prob = prob;
1908         }
1909     }
1910   operands[1] = op1h;
1911   operands[2] = op2h;
1912   operands[4] = NULL_RTX;
1913   if (reload_completed
1914       && ! arith_reg_or_0_operand (op2h, SImode)
1915       && (true_regnum (op1h) || (comparison != EQ && comparison != NE))
1916       && (msw_taken != LAST_AND_UNUSED_RTX_CODE
1917           || msw_skip != LAST_AND_UNUSED_RTX_CODE))
1918     {
1919       emit_move_insn (scratch, operands[2]);
1920       operands[2] = scratch;
1921     }
1922   if (msw_taken != LAST_AND_UNUSED_RTX_CODE)
1923     expand_cbranchsi4 (operands, msw_taken, msw_taken_prob);
1924   if (msw_skip != LAST_AND_UNUSED_RTX_CODE)
1925     {
1926       rtx taken_label = operands[3];
1927
1928       /* Operands were possibly modified, but msw_skip doesn't expect this.
1929          Always use the original ones.  */
1930       if (msw_taken != LAST_AND_UNUSED_RTX_CODE)
1931         {
1932           operands[1] = op1h;
1933           operands[2] = op2h;
1934         }
1935
1936       operands[3] = skip_label = gen_label_rtx ();
1937       expand_cbranchsi4 (operands, msw_skip, msw_skip_prob);
1938       operands[3] = taken_label;
1939     }
1940   operands[1] = op1l;
1941   operands[2] = op2l;
1942   if (lsw_taken != LAST_AND_UNUSED_RTX_CODE)
1943     {
1944       if (reload_completed
1945           && ! arith_reg_or_0_operand (op2l, SImode)
1946           && (true_regnum (op1l) || (lsw_taken != EQ && lsw_taken != NE)))
1947         {
1948           emit_move_insn (scratch, operands[2]);
1949           operands[2] = scratch;
1950         }
1951       expand_cbranchsi4 (operands, lsw_taken, lsw_taken_prob);
1952     }
1953   if (msw_skip != LAST_AND_UNUSED_RTX_CODE)
1954     emit_label (skip_label);
1955   return true;
1956 }
1957
1958 /* Emit INSN, possibly in a PARALLEL with an USE of fpscr for SH4.  */
1959
1960 static void
1961 sh_emit_set_t_insn (rtx insn, enum machine_mode mode)
1962 {
1963   if ((TARGET_SH4 || TARGET_SH2A) && GET_MODE_CLASS (mode) == MODE_FLOAT)
1964     {
1965       insn = gen_rtx_PARALLEL (VOIDmode,
1966                        gen_rtvec (2, insn,
1967                                   gen_rtx_USE (VOIDmode, get_fpscr_rtx ())));
1968       (mode == SFmode ? emit_sf_insn : emit_df_insn) (insn);
1969     }
1970   else
1971     emit_insn (insn);
1972 }
1973
1974 /* Prepare the operands for an scc instruction; make sure that the
1975    compare has been done and the result is in T_REG.  */
1976 void
1977 sh_emit_scc_to_t (enum rtx_code code, rtx op0, rtx op1)
1978 {
1979   rtx t_reg = gen_rtx_REG (SImode, T_REG);
1980   enum rtx_code oldcode = code;
1981   enum machine_mode mode;
1982
1983   /* First need a compare insn.  */
1984   switch (code)
1985     {
1986     case NE:
1987       /* It isn't possible to handle this case.  */
1988       gcc_unreachable ();
1989     case LT:
1990       code = GT;
1991       break;
1992     case LE:
1993       code = GE;
1994       break;
1995     case LTU:
1996       code = GTU;
1997       break;
1998     case LEU:
1999       code = GEU;
2000       break;
2001     default:
2002       break;
2003     }
2004   if (code != oldcode)
2005     {
2006       rtx tmp = op0;
2007       op0 = op1;
2008       op1 = tmp;
2009     }
2010
2011   mode = GET_MODE (op0);
2012   if (mode == VOIDmode)
2013     mode = GET_MODE (op1);
2014
2015   op0 = force_reg (mode, op0);
2016   if ((code != EQ && code != NE
2017        && (op1 != const0_rtx
2018            || code == GTU  || code == GEU || code == LTU || code == LEU))
2019       || (mode == DImode && op1 != const0_rtx)
2020       || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
2021     op1 = force_reg (mode, op1);
2022
2023   sh_emit_set_t_insn (gen_rtx_SET (VOIDmode, t_reg,
2024                                    gen_rtx_fmt_ee (code, SImode, op0, op1)),
2025                       mode);
2026 }
2027
2028 rtx
2029 sh_emit_cheap_store_flag (enum machine_mode mode, enum rtx_code code,
2030                           rtx op0, rtx op1)
2031 {
2032   rtx target = gen_reg_rtx (SImode);
2033   rtx tmp;
2034
2035   gcc_assert (TARGET_SHMEDIA);
2036   switch (code)
2037     {
2038     case EQ:
2039     case GT:
2040     case LT:
2041     case UNORDERED:
2042     case GTU:
2043     case LTU:
2044       tmp = gen_rtx_fmt_ee (code, SImode, op0, op1);
2045       emit_insn (gen_cstore4_media (target, tmp, op0, op1));
2046       code = NE;
2047       break;
2048
2049     case NE:
2050     case GE:
2051     case LE:
2052     case ORDERED:
2053     case GEU:
2054     case LEU:
2055       tmp = gen_rtx_fmt_ee (reverse_condition (code), mode, op0, op1);
2056       emit_insn (gen_cstore4_media (target, tmp, op0, op1));
2057       code = EQ;
2058       break;
2059
2060     case UNEQ:
2061     case UNGE:
2062     case UNGT:
2063     case UNLE:
2064     case UNLT:
2065     case LTGT:
2066       return NULL_RTX;
2067
2068     default:
2069       gcc_unreachable ();
2070     }
2071
2072   if (mode == DImode)
2073     {
2074       rtx t2 = gen_reg_rtx (DImode);
2075       emit_insn (gen_extendsidi2 (t2, target));
2076       target = t2;
2077     }
2078
2079   return gen_rtx_fmt_ee (code, VOIDmode, target, const0_rtx);
2080 }
2081
2082 /* Called from the md file, set up the operands of a compare instruction.  */
2083
2084 void
2085 sh_emit_compare_and_branch (rtx *operands, enum machine_mode mode)
2086 {
2087   enum rtx_code code = GET_CODE (operands[0]);
2088   enum rtx_code branch_code;
2089   rtx op0 = operands[1];
2090   rtx op1 = operands[2];
2091   rtx insn, tem;
2092   bool need_ccmpeq = false;
2093
2094   if (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT)
2095     {
2096       op0 = force_reg (mode, op0);
2097       op1 = force_reg (mode, op1);
2098     }
2099   else
2100     {
2101       if (code != EQ || mode == DImode)
2102         {
2103           /* Force args into regs, since we can't use constants here.  */
2104           op0 = force_reg (mode, op0);
2105           if (op1 != const0_rtx || code == GTU  || code == GEU)
2106             op1 = force_reg (mode, op1);
2107         }
2108     }
2109
2110   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
2111     {
2112       if (code == LT
2113           || (code == LE && TARGET_IEEE && TARGET_SH2E)
2114           || (code == GE && !(TARGET_IEEE && TARGET_SH2E)))
2115         {
2116           tem = op0, op0 = op1, op1 = tem;
2117           code = swap_condition (code);
2118         }
2119
2120       /* GE becomes fcmp/gt+fcmp/eq, for SH2E and TARGET_IEEE only.  */
2121       if (code == GE)
2122         {
2123           gcc_assert (TARGET_IEEE && TARGET_SH2E);
2124           need_ccmpeq = true;
2125           code = GT;
2126         }
2127
2128       /* Now we can have EQ, NE, GT, LE.  NE and LE are then transformed
2129          to EQ/GT respectively.  */
2130       gcc_assert (code == EQ || code == GT || code == NE || code == LE);
2131     }
2132
2133   switch (code)
2134     {
2135     case EQ:
2136     case GT:
2137     case GE:
2138     case GTU:
2139     case GEU:
2140       branch_code = code;
2141       break;
2142     case NE:
2143     case LT:
2144     case LE:
2145     case LTU:
2146     case LEU:
2147       branch_code = reverse_condition (code);
2148       break;
2149     default:
2150       gcc_unreachable ();
2151     }
2152
2153   insn = gen_rtx_SET (VOIDmode,
2154                       gen_rtx_REG (SImode, T_REG),
2155                       gen_rtx_fmt_ee (branch_code, SImode, op0, op1));
2156
2157   sh_emit_set_t_insn (insn, mode);
2158   if (need_ccmpeq)
2159     sh_emit_set_t_insn (gen_ieee_ccmpeqsf_t (op0, op1), mode);
2160
2161   if (branch_code == code)
2162     emit_jump_insn (gen_branch_true (operands[3]));
2163   else
2164     emit_jump_insn (gen_branch_false (operands[3]));
2165 }
2166
2167 void
2168 sh_emit_compare_and_set (rtx *operands, enum machine_mode mode)
2169 {
2170   enum rtx_code code = GET_CODE (operands[1]);
2171   rtx op0 = operands[2];
2172   rtx op1 = operands[3];
2173   rtx lab = NULL_RTX;
2174   bool invert = false;
2175   rtx tem;
2176
2177   op0 = force_reg (mode, op0);
2178   if ((code != EQ && code != NE
2179        && (op1 != const0_rtx
2180            || code == GTU  || code == GEU || code == LTU || code == LEU))
2181       || (mode == DImode && op1 != const0_rtx)
2182       || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
2183     op1 = force_reg (mode, op1);
2184
2185   if (GET_MODE_CLASS (mode) == MODE_FLOAT)
2186     {
2187       if (code == LT || code == LE)
2188         {
2189           code = swap_condition (code);
2190           tem = op0, op0 = op1, op1 = tem;
2191         }
2192       if (code == GE)
2193         {
2194           if (TARGET_IEEE)
2195             {
2196               lab = gen_label_rtx ();
2197               sh_emit_scc_to_t (EQ, op0, op1);
2198               emit_jump_insn (gen_branch_true (lab));
2199               code = GT;
2200            }
2201           else
2202             {
2203               code = LT;
2204               invert = true;
2205             }
2206         }
2207     }
2208
2209   if (code == NE)
2210     {
2211       code = EQ;
2212       invert = true;
2213     }
2214
2215   sh_emit_scc_to_t (code, op0, op1);
2216   if (lab)
2217     emit_label (lab);
2218   if (invert)
2219     emit_insn (gen_movnegt (operands[0]));
2220   else
2221     emit_move_insn (operands[0], gen_rtx_REG (SImode, T_REG));
2222 }
2223 \f
2224 /* Functions to output assembly code.  */
2225
2226 /* Return a sequence of instructions to perform DI or DF move.
2227
2228    Since the SH cannot move a DI or DF in one instruction, we have
2229    to take care when we see overlapping source and dest registers.  */
2230
2231 const char *
2232 output_movedouble (rtx insn ATTRIBUTE_UNUSED, rtx operands[],
2233                    enum machine_mode mode)
2234 {
2235   rtx dst = operands[0];
2236   rtx src = operands[1];
2237
2238   if (MEM_P (dst)
2239       && GET_CODE (XEXP (dst, 0)) == PRE_DEC)
2240     return "mov.l       %T1,%0\n\tmov.l %1,%0";
2241
2242   if (register_operand (dst, mode)
2243       && register_operand (src, mode))
2244     {
2245       if (REGNO (src) == MACH_REG)
2246         return "sts     mach,%S0\n\tsts macl,%R0";
2247
2248       /* When mov.d r1,r2 do r2->r3 then r1->r2;
2249          when mov.d r1,r0 do r1->r0 then r2->r1.  */
2250
2251       if (REGNO (src) + 1 == REGNO (dst))
2252         return "mov     %T1,%T0\n\tmov  %1,%0";
2253       else
2254         return "mov     %1,%0\n\tmov    %T1,%T0";
2255     }
2256   else if (CONST_INT_P (src))
2257     {
2258       if (INTVAL (src) < 0)
2259         output_asm_insn ("mov   #-1,%S0", operands);
2260       else
2261         output_asm_insn ("mov   #0,%S0", operands);
2262
2263       return "mov       %1,%R0";
2264     }
2265   else if (MEM_P (src))
2266     {
2267       int ptrreg = -1;
2268       int dreg = REGNO (dst);
2269       rtx inside = XEXP (src, 0);
2270
2271       switch (GET_CODE (inside))
2272         {
2273         case REG:
2274           ptrreg = REGNO (inside);
2275           break;
2276
2277         case SUBREG:
2278           ptrreg = subreg_regno (inside);
2279           break;
2280
2281         case PLUS:
2282           ptrreg = REGNO (XEXP (inside, 0));
2283           /* ??? A r0+REG address shouldn't be possible here, because it isn't
2284              an offsettable address.  Unfortunately, offsettable addresses use
2285              QImode to check the offset, and a QImode offsettable address
2286              requires r0 for the other operand, which is not currently
2287              supported, so we can't use the 'o' constraint.
2288              Thus we must check for and handle r0+REG addresses here.
2289              We punt for now, since this is likely very rare.  */
2290           gcc_assert (!REG_P (XEXP (inside, 1)));
2291           break;
2292
2293         case LABEL_REF:
2294           return "mov.l %1,%0\n\tmov.l  %1+4,%T0";
2295         case POST_INC:
2296           return "mov.l %1,%0\n\tmov.l  %1,%T0";
2297         default:
2298           gcc_unreachable ();
2299         }
2300
2301       /* Work out the safe way to copy.  Copy into the second half first.  */
2302       if (dreg == ptrreg)
2303         return "mov.l   %T1,%T0\n\tmov.l        %1,%0";
2304     }
2305
2306   return "mov.l %1,%0\n\tmov.l  %T1,%T0";
2307 }
2308
2309 /* Print an instruction which would have gone into a delay slot after
2310    another instruction, but couldn't because the other instruction expanded
2311    into a sequence where putting the slot insn at the end wouldn't work.  */
2312
2313 static void
2314 print_slot (rtx insn)
2315 {
2316   final_scan_insn (XVECEXP (insn, 0, 1), asm_out_file, optimize, 1, NULL);
2317
2318   INSN_DELETED_P (XVECEXP (insn, 0, 1)) = 1;
2319 }
2320
2321 const char *
2322 output_far_jump (rtx insn, rtx op)
2323 {
2324   struct { rtx lab, reg, op; } this_jmp;
2325   rtx braf_base_lab = NULL_RTX;
2326   const char *jump;
2327   int far;
2328   int offset = branch_dest (insn) - INSN_ADDRESSES (INSN_UID (insn));
2329   rtx prev;
2330
2331   this_jmp.lab = gen_label_rtx ();
2332
2333   if (TARGET_SH2
2334       && offset >= -32764
2335       && offset - get_attr_length (insn) <= 32766)
2336     {
2337       far = 0;
2338       jump = "mov.w     %O0,%1; braf    %1";
2339     }
2340   else
2341     {
2342       far = 1;
2343       if (flag_pic)
2344         {
2345           if (TARGET_SH2)
2346             jump = "mov.l       %O0,%1; braf    %1";
2347           else
2348             jump = "mov.l       r0,@-r15; mova  %O0,r0; mov.l   @r0,%1; add     r0,%1; mov.l    @r15+,r0; jmp   @%1";
2349         }
2350       else
2351         jump = "mov.l   %O0,%1; jmp     @%1";
2352     }
2353   /* If we have a scratch register available, use it.  */
2354   if (NONJUMP_INSN_P ((prev = prev_nonnote_insn (insn)))
2355       && INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch)
2356     {
2357       this_jmp.reg = SET_DEST (XVECEXP (PATTERN (prev), 0, 0));
2358       if (REGNO (this_jmp.reg) == R0_REG && flag_pic && ! TARGET_SH2)
2359         jump = "mov.l   r1,@-r15; mova  %O0,r0; mov.l   @r0,r1; add     r1,r0; mov.l    @r15+,r1; jmp   @%1";
2360       output_asm_insn (jump, &this_jmp.lab);
2361       if (dbr_sequence_length ())
2362         print_slot (final_sequence);
2363       else
2364         output_asm_insn ("nop", 0);
2365     }
2366   else
2367     {
2368       /* Output the delay slot insn first if any.  */
2369       if (dbr_sequence_length ())
2370         print_slot (final_sequence);
2371
2372       this_jmp.reg = gen_rtx_REG (SImode, 13);
2373       /* We must keep the stack aligned to 8-byte boundaries on SH5.
2374          Fortunately, MACL is fixed and call-clobbered, and we never
2375          need its value across jumps, so save r13 in it instead of in
2376          the stack.  */
2377       if (TARGET_SH5)
2378         output_asm_insn ("lds   r13, macl", 0);
2379       else
2380         output_asm_insn ("mov.l r13,@-r15", 0);
2381       output_asm_insn (jump, &this_jmp.lab);
2382       if (TARGET_SH5)
2383         output_asm_insn ("sts   macl, r13", 0);
2384       else
2385         output_asm_insn ("mov.l @r15+,r13", 0);
2386     }
2387   if (far && flag_pic && TARGET_SH2)
2388     {
2389       braf_base_lab = gen_label_rtx ();
2390       (*targetm.asm_out.internal_label) (asm_out_file, "L",
2391                                  CODE_LABEL_NUMBER (braf_base_lab));
2392     }
2393   if (far)
2394     output_asm_insn (".align    2", 0);
2395   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (this_jmp.lab));
2396   this_jmp.op = op;
2397   if (far && flag_pic)
2398     {
2399       if (TARGET_SH2)
2400         this_jmp.lab = braf_base_lab;
2401       output_asm_insn (".long   %O2-%O0", &this_jmp.lab);
2402     }
2403   else
2404     output_asm_insn (far ? ".long       %O2" : ".word %O2-%O0", &this_jmp.lab);
2405   return "";
2406 }
2407
2408 /* Local label counter, used for constants in the pool and inside
2409    pattern branches.  */
2410
2411 static int lf = 100;
2412
2413 /* Output code for ordinary branches.  */
2414
2415 const char *
2416 output_branch (int logic, rtx insn, rtx *operands)
2417 {
2418   switch (get_attr_length (insn))
2419     {
2420     case 6:
2421       /* This can happen if filling the delay slot has caused a forward
2422          branch to exceed its range (we could reverse it, but only
2423          when we know we won't overextend other branches; this should
2424          best be handled by relaxation).
2425          It can also happen when other condbranches hoist delay slot insn
2426          from their destination, thus leading to code size increase.
2427          But the branch will still be in the range -4092..+4098 bytes.  */
2428
2429       if (! TARGET_RELAX)
2430         {
2431           int label = lf++;
2432           /* The call to print_slot will clobber the operands.  */
2433           rtx op0 = operands[0];
2434
2435           /* If the instruction in the delay slot is annulled (true), then
2436              there is no delay slot where we can put it now.  The only safe
2437              place for it is after the label.  final will do that by default.  */
2438
2439           if (final_sequence
2440               && ! INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
2441               && get_attr_length (XVECEXP (final_sequence, 0, 1)))
2442             {
2443               asm_fprintf (asm_out_file, "\tb%s%ss\t%LLF%d\n", logic ? "f" : "t",
2444                            ASSEMBLER_DIALECT ? "/" : ".", label);
2445               print_slot (final_sequence);
2446             }
2447           else
2448             asm_fprintf (asm_out_file, "\tb%s\t%LLF%d\n", logic ? "f" : "t", label);
2449
2450           output_asm_insn ("bra\t%l0", &op0);
2451           fprintf (asm_out_file, "\tnop\n");
2452           (*targetm.asm_out.internal_label) (asm_out_file, "LF", label);
2453
2454           return "";
2455         }
2456       /* When relaxing, handle this like a short branch.  The linker
2457          will fix it up if it still doesn't fit after relaxation.  */
2458     case 2:
2459       return logic ? "bt%.\t%l0" : "bf%.\t%l0";
2460
2461       /* These are for SH2e, in which we have to account for the
2462          extra nop because of the hardware bug in annulled branches.  */
2463     case 8:
2464       if (! TARGET_RELAX)
2465         {
2466           int label = lf++;
2467
2468           gcc_assert (!final_sequence
2469                       || !(INSN_ANNULLED_BRANCH_P
2470                            (XVECEXP (final_sequence, 0, 0))));
2471           asm_fprintf (asm_out_file, "b%s%ss\t%LLF%d\n",
2472                        logic ? "f" : "t",
2473                        ASSEMBLER_DIALECT ? "/" : ".", label);
2474           fprintf (asm_out_file, "\tnop\n");
2475           output_asm_insn ("bra\t%l0", operands);
2476           fprintf (asm_out_file, "\tnop\n");
2477           (*targetm.asm_out.internal_label) (asm_out_file, "LF", label);
2478
2479           return "";
2480         }
2481       /* When relaxing, fall through.  */
2482     case 4:
2483       {
2484         char buffer[10];
2485
2486         sprintf (buffer, "b%s%ss\t%%l0",
2487                  logic ? "t" : "f",
2488                  ASSEMBLER_DIALECT ? "/" : ".");
2489         output_asm_insn (buffer, &operands[0]);
2490         return "nop";
2491       }
2492
2493     default:
2494       /* There should be no longer branches now - that would
2495          indicate that something has destroyed the branches set
2496          up in machine_dependent_reorg.  */
2497       gcc_unreachable ();
2498     }
2499 }
2500
2501 /* Output a code sequence for INSN using TEMPL with OPERANDS; but before,
2502    fill in operands 9 as a label to the successor insn.
2503    We try to use jump threading where possible.
2504    IF CODE matches the comparison in the IF_THEN_ELSE of a following jump,
2505    we assume the jump is taken.  I.e. EQ means follow jmp and bf, NE means
2506    follow jmp and bt, if the address is in range.  */
2507 const char *
2508 output_branchy_insn (enum rtx_code code, const char *templ,
2509                      rtx insn, rtx *operands)
2510 {
2511   rtx next_insn = NEXT_INSN (insn);
2512
2513   if (next_insn && JUMP_P (next_insn) && condjump_p (next_insn))
2514     {
2515       rtx src = SET_SRC (PATTERN (next_insn));
2516       if (GET_CODE (src) == IF_THEN_ELSE && GET_CODE (XEXP (src, 0)) != code)
2517         {
2518           /* Following branch not taken */
2519           operands[9] = gen_label_rtx ();
2520           emit_label_after (operands[9], next_insn);
2521           INSN_ADDRESSES_NEW (operands[9],
2522                               INSN_ADDRESSES (INSN_UID (next_insn))
2523                               + get_attr_length (next_insn));
2524           return templ;
2525         }
2526       else
2527         {
2528           int offset = (branch_dest (next_insn)
2529                         - INSN_ADDRESSES (INSN_UID (next_insn)) + 4);
2530           if (offset >= -252 && offset <= 258)
2531             {
2532               if (GET_CODE (src) == IF_THEN_ELSE)
2533                 /* branch_true */
2534                 src = XEXP (src, 1);
2535               operands[9] = src;
2536               return templ;
2537             }
2538         }
2539     }
2540   operands[9] = gen_label_rtx ();
2541   emit_label_after (operands[9], insn);
2542   INSN_ADDRESSES_NEW (operands[9],
2543                       INSN_ADDRESSES (INSN_UID (insn))
2544                       + get_attr_length (insn));
2545   return templ;
2546 }
2547
2548 const char *
2549 output_ieee_ccmpeq (rtx insn, rtx *operands)
2550 {
2551   return output_branchy_insn (NE, "bt\t%l9\n\tfcmp/eq\t%1,%0",
2552                               insn, operands);
2553 }
2554 \f
2555 /* Output the start of the assembler file.  */
2556
2557 static void
2558 sh_file_start (void)
2559 {
2560   default_file_start ();
2561
2562 #ifdef SYMBIAN
2563   /* Declare the .directive section before it is used.  */
2564   fputs ("\t.section .directive, \"SM\", @progbits, 1\n", asm_out_file);
2565   fputs ("\t.asciz \"#<SYMEDIT>#\\n\"\n", asm_out_file);
2566 #endif
2567
2568   if (TARGET_ELF)
2569     /* We need to show the text section with the proper
2570        attributes as in TEXT_SECTION_ASM_OP, before dwarf2out
2571        emits it without attributes in TEXT_SECTION_ASM_OP, else GAS
2572        will complain.  We can teach GAS specifically about the
2573        default attributes for our choice of text section, but
2574        then we would have to change GAS again if/when we change
2575        the text section name.  */
2576     fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
2577   else
2578     /* Switch to the data section so that the coffsem symbol
2579        isn't in the text section.  */
2580     switch_to_section (data_section);
2581
2582   if (TARGET_LITTLE_ENDIAN)
2583     fputs ("\t.little\n", asm_out_file);
2584
2585   if (!TARGET_ELF)
2586     {
2587       if (TARGET_SHCOMPACT)
2588         fputs ("\t.mode\tSHcompact\n", asm_out_file);
2589       else if (TARGET_SHMEDIA)
2590         fprintf (asm_out_file, "\t.mode\tSHmedia\n\t.abi\t%i\n",
2591                  TARGET_SHMEDIA64 ? 64 : 32);
2592     }
2593 }
2594 \f
2595 /* Check if PAT includes UNSPEC_CALLER unspec pattern.  */
2596
2597 static bool
2598 unspec_caller_rtx_p (rtx pat)
2599 {
2600   rtx base, offset;
2601   int i;
2602
2603   split_const (pat, &base, &offset);
2604   if (GET_CODE (base) == UNSPEC)
2605     {
2606       if (XINT (base, 1) == UNSPEC_CALLER)
2607         return true;
2608       for (i = 0; i < XVECLEN (base, 0); i++)
2609         if (unspec_caller_rtx_p (XVECEXP (base, 0, i)))
2610           return true;
2611     }
2612   return false;
2613 }
2614
2615 /* Indicate that INSN cannot be duplicated.  This is true for insn
2616    that generates a unique label.  */
2617
2618 static bool
2619 sh_cannot_copy_insn_p (rtx insn)
2620 {
2621   rtx pat;
2622
2623   if (!reload_completed || !flag_pic)
2624     return false;
2625
2626   if (!NONJUMP_INSN_P (insn))
2627     return false;
2628   if (asm_noperands (insn) >= 0)
2629     return false;
2630
2631   pat = PATTERN (insn);
2632   if (GET_CODE (pat) != SET)
2633     return false;
2634   pat = SET_SRC (pat);
2635
2636   if (unspec_caller_rtx_p (pat))
2637     return true;
2638
2639   return false;
2640 }
2641 \f
2642 /* Actual number of instructions used to make a shift by N.  */
2643 static const char ashiftrt_insns[] =
2644   { 0,1,2,3,4,5,8,8,8,8,8,8,8,8,8,8,2,3,4,5,8,8,8,8,8,8,8,8,8,8,8,2};
2645
2646 /* Left shift and logical right shift are the same.  */
2647 static const char shift_insns[]    =
2648   { 0,1,1,2,2,3,3,4,1,2,2,3,3,4,3,3,1,2,2,3,3,4,3,3,2,3,3,4,4,4,3,3};
2649
2650 /* Individual shift amounts needed to get the above length sequences.
2651    One bit right shifts clobber the T bit, so when possible, put one bit
2652    shifts in the middle of the sequence, so the ends are eligible for
2653    branch delay slots.  */
2654 static const short shift_amounts[32][5] = {
2655   {0}, {1}, {2}, {2, 1},
2656   {2, 2}, {2, 1, 2}, {2, 2, 2}, {2, 2, 1, 2},
2657   {8}, {8, 1}, {8, 2}, {8, 1, 2},
2658   {8, 2, 2}, {8, 2, 1, 2}, {8, -2, 8}, {8, -1, 8},
2659   {16}, {16, 1}, {16, 2}, {16, 1, 2},
2660   {16, 2, 2}, {16, 2, 1, 2}, {16, -2, 8}, {16, -1, 8},
2661   {16, 8}, {16, 1, 8}, {16, 8, 2}, {16, 8, 1, 2},
2662   {16, 8, 2, 2}, {16, -1, -2, 16}, {16, -2, 16}, {16, -1, 16}};
2663
2664 /* Likewise, but for shift amounts < 16, up to three highmost bits
2665    might be clobbered.  This is typically used when combined with some
2666    kind of sign or zero extension.  */
2667
2668 static const char ext_shift_insns[]    =
2669   { 0,1,1,2,2,3,2,2,1,2,2,3,3,3,2,2,1,2,2,3,3,4,3,3,2,3,3,4,4,4,3,3};
2670
2671 static const short ext_shift_amounts[32][4] = {
2672   {0}, {1}, {2}, {2, 1},
2673   {2, 2}, {2, 1, 2}, {8, -2}, {8, -1},
2674   {8}, {8, 1}, {8, 2}, {8, 1, 2},
2675   {8, 2, 2}, {16, -2, -1}, {16, -2}, {16, -1},
2676   {16}, {16, 1}, {16, 2}, {16, 1, 2},
2677   {16, 2, 2}, {16, 2, 1, 2}, {16, -2, 8}, {16, -1, 8},
2678   {16, 8}, {16, 1, 8}, {16, 8, 2}, {16, 8, 1, 2},
2679   {16, 8, 2, 2}, {16, -1, -2, 16}, {16, -2, 16}, {16, -1, 16}};
2680
2681 /* Assuming we have a value that has been sign-extended by at least one bit,
2682    can we use the ext_shift_amounts with the last shift turned to an arithmetic shift
2683    to shift it by N without data loss, and quicker than by other means?  */
2684 #define EXT_SHIFT_SIGNED(n) (((n) | 8) == 15)
2685
2686 /* This is used in length attributes in sh.md to help compute the length
2687    of arbitrary constant shift instructions.  */
2688
2689 int
2690 shift_insns_rtx (rtx insn)
2691 {
2692   rtx set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
2693   int shift_count = INTVAL (XEXP (set_src, 1)) & 31;
2694   enum rtx_code shift_code = GET_CODE (set_src);
2695
2696   switch (shift_code)
2697     {
2698     case ASHIFTRT:
2699       return ashiftrt_insns[shift_count];
2700     case LSHIFTRT:
2701     case ASHIFT:
2702       return shift_insns[shift_count];
2703     default:
2704       gcc_unreachable ();
2705     }
2706 }
2707
2708 /* Return the cost of a shift.  */
2709
2710 static inline int
2711 shiftcosts (rtx x)
2712 {
2713   int value;
2714
2715   if (TARGET_SHMEDIA)
2716     return 1;
2717
2718   if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
2719     {
2720       if (GET_MODE (x) == DImode
2721           && CONST_INT_P (XEXP (x, 1))
2722           && INTVAL (XEXP (x, 1)) == 1)
2723         return 2;
2724
2725       /* Everything else is invalid, because there is no pattern for it.  */
2726       return MAX_COST;
2727     }
2728   /* If shift by a non constant, then this will be expensive.  */
2729   if (!CONST_INT_P (XEXP (x, 1)))
2730     return SH_DYNAMIC_SHIFT_COST;
2731
2732   /* Otherwise, return the true cost in instructions.  Cope with out of range
2733      shift counts more or less arbitrarily.  */
2734   value = INTVAL (XEXP (x, 1)) & 31;
2735
2736   if (GET_CODE (x) == ASHIFTRT)
2737     {
2738       int cost = ashiftrt_insns[value];
2739       /* If SH3, then we put the constant in a reg and use shad.  */
2740       if (cost > 1 + SH_DYNAMIC_SHIFT_COST)
2741         cost = 1 + SH_DYNAMIC_SHIFT_COST;
2742       return cost;
2743     }
2744   else
2745     return shift_insns[value];
2746 }
2747
2748 /* Return the cost of an AND operation.  */
2749
2750 static inline int
2751 andcosts (rtx x)
2752 {
2753   int i;
2754
2755   /* Anding with a register is a single cycle and instruction.  */
2756   if (!CONST_INT_P (XEXP (x, 1)))
2757     return 1;
2758
2759   i = INTVAL (XEXP (x, 1));
2760
2761   if (TARGET_SHMEDIA)
2762     {
2763       if (satisfies_constraint_I10 (XEXP (x, 1))
2764           || satisfies_constraint_J16 (XEXP (x, 1)))
2765         return 1;
2766       else
2767         return 1 + rtx_cost (XEXP (x, 1), AND, !optimize_size);
2768     }
2769
2770   /* These constants are single cycle extu.[bw] instructions.  */
2771   if (i == 0xff || i == 0xffff)
2772     return 1;
2773   /* Constants that can be used in an and immediate instruction in a single
2774      cycle, but this requires r0, so make it a little more expensive.  */
2775   if (CONST_OK_FOR_K08 (i))
2776     return 2;
2777   /* Constants that can be loaded with a mov immediate and an and.
2778      This case is probably unnecessary.  */
2779   if (CONST_OK_FOR_I08 (i))
2780     return 2;
2781   /* Any other constants requires a 2 cycle pc-relative load plus an and.
2782      This case is probably unnecessary.  */
2783   return 3;
2784 }
2785
2786 /* Return the cost of an addition or a subtraction.  */
2787
2788 static inline int
2789 addsubcosts (rtx x)
2790 {
2791   /* Adding a register is a single cycle insn.  */
2792   if (REG_P (XEXP (x, 1))
2793       || GET_CODE (XEXP (x, 1)) == SUBREG)
2794     return 1;
2795
2796   /* Likewise for small constants.  */
2797   if (CONST_INT_P (XEXP (x, 1))
2798       && CONST_OK_FOR_ADD (INTVAL (XEXP (x, 1))))
2799     return 1;
2800
2801   if (TARGET_SHMEDIA)
2802     switch (GET_CODE (XEXP (x, 1)))
2803       {
2804       case CONST:
2805       case LABEL_REF:
2806       case SYMBOL_REF:
2807         return TARGET_SHMEDIA64 ? 5 : 3;
2808
2809       case CONST_INT:
2810         if (CONST_OK_FOR_I16 (INTVAL (XEXP (x, 1))))
2811           return 2;
2812         else if (CONST_OK_FOR_I16 (INTVAL (XEXP (x, 1)) >> 16))
2813           return 3;
2814         else if (CONST_OK_FOR_I16 ((INTVAL (XEXP (x, 1)) >> 16) >> 16))
2815           return 4;
2816
2817         /* Fall through.  */
2818       default:
2819         return 5;
2820       }
2821
2822   /* Any other constant requires a 2 cycle pc-relative load plus an
2823      addition.  */
2824   return 3;
2825 }
2826
2827 /* Return the cost of a multiply.  */
2828 static inline int
2829 multcosts (rtx x ATTRIBUTE_UNUSED)
2830 {
2831   if (sh_multcost >= 0)
2832     return sh_multcost;
2833   if (TARGET_SHMEDIA)
2834     /* ??? We have a mul insn, but it has a latency of three, and doesn't
2835        accept constants.  Ideally, we would use a cost of one or two and
2836        add the cost of the operand, but disregard the latter when inside loops
2837        and loop invariant code motion is still to follow.
2838        Using a multiply first and splitting it later if it's a loss
2839        doesn't work because of different sign / zero extension semantics
2840        of multiplies vs. shifts.  */
2841     return TARGET_SMALLCODE ? 2 : 3;
2842
2843   if (TARGET_SH2)
2844     {
2845       /* We have a mul insn, so we can never take more than the mul and the
2846          read of the mac reg, but count more because of the latency and extra
2847          reg usage.  */
2848       if (TARGET_SMALLCODE)
2849         return 2;
2850       return 3;
2851     }
2852
2853   /* If we're aiming at small code, then just count the number of
2854      insns in a multiply call sequence.  */
2855   if (TARGET_SMALLCODE)
2856     return 5;
2857
2858   /* Otherwise count all the insns in the routine we'd be calling too.  */
2859   return 20;
2860 }
2861
2862 /* Compute a (partial) cost for rtx X.  Return true if the complete
2863    cost has been computed, and false if subexpressions should be
2864    scanned.  In either case, *TOTAL contains the cost result.  */
2865
2866 static bool
2867 sh_rtx_costs (rtx x, int code, int outer_code, int *total,
2868               bool speed ATTRIBUTE_UNUSED)
2869 {
2870   switch (code)
2871     {
2872     case CONST_INT:
2873       if (TARGET_SHMEDIA)
2874         {
2875           if (INTVAL (x) == 0)
2876             *total = 0;
2877           else if (outer_code == AND && and_operand ((x), DImode))
2878             *total = 0;
2879           else if ((outer_code == IOR || outer_code == XOR
2880                     || outer_code == PLUS)
2881                    && CONST_OK_FOR_I10 (INTVAL (x)))
2882             *total = 0;
2883           else if (CONST_OK_FOR_I16 (INTVAL (x)))
2884             *total = COSTS_N_INSNS (outer_code != SET);
2885           else if (CONST_OK_FOR_I16 (INTVAL (x) >> 16))
2886             *total = COSTS_N_INSNS ((outer_code != SET) + 1);
2887           else if (CONST_OK_FOR_I16 ((INTVAL (x) >> 16) >> 16))
2888             *total = COSTS_N_INSNS ((outer_code != SET) + 2);
2889           else
2890             *total = COSTS_N_INSNS ((outer_code != SET) + 3);
2891           return true;
2892         }
2893       if (CONST_OK_FOR_I08 (INTVAL (x)))
2894         *total = 0;
2895       else if ((outer_code == AND || outer_code == IOR || outer_code == XOR)
2896                && CONST_OK_FOR_K08 (INTVAL (x)))
2897         *total = 1;
2898       /* prepare_cmp_insn will force costly constants int registers before
2899          the cbranch[sd]i4 patterns can see them, so preserve potentially
2900          interesting ones not covered by I08 above.  */
2901       else if (outer_code == COMPARE
2902                && ((unsigned HOST_WIDE_INT) INTVAL (x)
2903                     == (unsigned HOST_WIDE_INT) 0x7fffffff + 1
2904                     || INTVAL (x) == 0x7fffffff
2905                    || INTVAL (x) == 0x80 || INTVAL (x) == -0x81))
2906         *total = 1;
2907       else
2908         *total = 8;
2909       return true;
2910
2911     case CONST:
2912     case LABEL_REF:
2913     case SYMBOL_REF:
2914       if (TARGET_SHMEDIA64)
2915         *total = COSTS_N_INSNS (4);
2916       else if (TARGET_SHMEDIA32)
2917         *total = COSTS_N_INSNS (2);
2918       else
2919         *total = 5;
2920       return true;
2921
2922     case CONST_DOUBLE:
2923       if (TARGET_SHMEDIA)
2924         *total = COSTS_N_INSNS (4);
2925       /* prepare_cmp_insn will force costly constants int registers before
2926          the cbranchdi4 pattern can see them, so preserve potentially
2927          interesting ones.  */
2928       else if (outer_code == COMPARE && GET_MODE (x) == DImode)
2929         *total = 1;
2930       else
2931         *total = 10;
2932       return true;
2933     case CONST_VECTOR:
2934       if (x == CONST0_RTX (GET_MODE (x)))
2935         *total = 0;
2936       else if (sh_1el_vec (x, VOIDmode))
2937         *total = outer_code != SET;
2938       if (sh_rep_vec (x, VOIDmode))
2939         *total = ((GET_MODE_UNIT_SIZE (GET_MODE (x)) + 3) / 4
2940                   + (outer_code != SET));
2941       *total = COSTS_N_INSNS (3) + (outer_code != SET);
2942       return true;
2943
2944     case PLUS:
2945     case MINUS:
2946       *total = COSTS_N_INSNS (addsubcosts (x));
2947       return true;
2948
2949     case AND:
2950       *total = COSTS_N_INSNS (andcosts (x));
2951       return true;
2952
2953     case MULT:
2954       *total = COSTS_N_INSNS (multcosts (x));
2955       return true;
2956
2957     case ASHIFT:
2958     case ASHIFTRT:
2959     case LSHIFTRT:
2960       *total = COSTS_N_INSNS (shiftcosts (x));
2961       return true;
2962
2963     case DIV:
2964     case UDIV:
2965     case MOD:
2966     case UMOD:
2967       *total = COSTS_N_INSNS (20);
2968       return true;
2969
2970     case PARALLEL:
2971       if (sh_1el_vec (x, VOIDmode))
2972         *total = outer_code != SET;
2973       if (sh_rep_vec (x, VOIDmode))
2974         *total = ((GET_MODE_UNIT_SIZE (GET_MODE (x)) + 3) / 4
2975                   + (outer_code != SET));
2976       *total = COSTS_N_INSNS (3) + (outer_code != SET);
2977       return true;
2978
2979     case FLOAT:
2980     case FIX:
2981       *total = 100;
2982       return true;
2983
2984     default:
2985       return false;
2986     }
2987 }
2988
2989 /* Compute the cost of an address.  For the SH, all valid addresses are
2990    the same cost.  Use a slightly higher cost for reg + reg addressing,
2991    since it increases pressure on r0.  */
2992
2993 static int
2994 sh_address_cost (rtx X,
2995                  bool speed ATTRIBUTE_UNUSED)
2996 {
2997   return (GET_CODE (X) == PLUS
2998           && ! CONSTANT_P (XEXP (X, 1))
2999           && ! TARGET_SHMEDIA ? 1 : 0);
3000 }
3001
3002 /* Code to expand a shift.  */
3003
3004 void
3005 gen_ashift (int type, int n, rtx reg)
3006 {
3007   /* Negative values here come from the shift_amounts array.  */
3008   if (n < 0)
3009     {
3010       if (type == ASHIFT)
3011         type = LSHIFTRT;
3012       else
3013         type = ASHIFT;
3014       n = -n;
3015     }
3016
3017   switch (type)
3018     {
3019     case ASHIFTRT:
3020       emit_insn (gen_ashrsi3_k (reg, reg, GEN_INT (n)));
3021       break;
3022     case LSHIFTRT:
3023       if (n == 1)
3024         emit_insn (gen_lshrsi3_m (reg, reg, GEN_INT (n)));
3025       else
3026         emit_insn (gen_lshrsi3_k (reg, reg, GEN_INT (n)));
3027       break;
3028     case ASHIFT:
3029       emit_insn (gen_ashlsi3_std (reg, reg, GEN_INT (n)));
3030       break;
3031     }
3032 }
3033
3034 /* Same for HImode */
3035
3036 void
3037 gen_ashift_hi (int type, int n, rtx reg)
3038 {
3039   /* Negative values here come from the shift_amounts array.  */
3040   if (n < 0)
3041     {
3042       if (type == ASHIFT)
3043         type = LSHIFTRT;
3044       else
3045         type = ASHIFT;
3046       n = -n;
3047     }
3048
3049   switch (type)
3050     {
3051     case ASHIFTRT:
3052     case LSHIFTRT:
3053       /* We don't have HImode right shift operations because using the
3054          ordinary 32 bit shift instructions for that doesn't generate proper
3055          zero/sign extension.
3056          gen_ashift_hi is only called in contexts where we know that the
3057          sign extension works out correctly.  */
3058       {
3059         int offset = 0;
3060         if (GET_CODE (reg) == SUBREG)
3061           {
3062             offset = SUBREG_BYTE (reg);
3063             reg = SUBREG_REG (reg);
3064           }
3065         gen_ashift (type, n, gen_rtx_SUBREG (SImode, reg, offset));
3066         break;
3067       }
3068     case ASHIFT:
3069       emit_insn (gen_ashlhi3_k (reg, reg, GEN_INT (n)));
3070       break;
3071     }
3072 }
3073
3074 /* Output RTL to split a constant shift into its component SH constant
3075    shift instructions.  */
3076
3077 void
3078 gen_shifty_op (int code, rtx *operands)
3079 {
3080   int value = INTVAL (operands[2]);
3081   int max, i;
3082
3083   /* Truncate the shift count in case it is out of bounds.  */
3084   value = value & 31;
3085
3086   if (value == 31)
3087     {
3088       if (code == LSHIFTRT)
3089         {
3090           emit_insn (gen_rotlsi3_1 (operands[0], operands[0]));
3091           emit_insn (gen_movt (operands[0]));
3092           return;
3093         }
3094       else if (code == ASHIFT)
3095         {
3096           /* There is a two instruction sequence for 31 bit left shifts,
3097              but it requires r0.  */
3098           if (REG_P (operands[0]) && REGNO (operands[0]) == 0)
3099             {
3100               emit_insn (gen_andsi3 (operands[0], operands[0], const1_rtx));
3101               emit_insn (gen_rotlsi3_31 (operands[0], operands[0]));
3102               return;
3103             }
3104         }
3105     }
3106   else if (value == 0)
3107     {
3108       /* This can happen even when optimizing, if there were subregs before
3109          reload.  Don't output a nop here, as this is never optimized away;
3110          use a no-op move instead.  */
3111       emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[0]));
3112       return;
3113     }
3114
3115   max = shift_insns[value];
3116   for (i = 0; i < max; i++)
3117     gen_ashift (code, shift_amounts[value][i], operands[0]);
3118 }
3119
3120 /* Same as above, but optimized for values where the topmost bits don't
3121    matter.  */
3122
3123 void
3124 gen_shifty_hi_op (int code, rtx *operands)
3125 {
3126   int value = INTVAL (operands[2]);
3127   int max, i;
3128   void (*gen_fun) (int, int, rtx);
3129
3130   /* This operation is used by and_shl for SImode values with a few
3131      high bits known to be cleared.  */
3132   value &= 31;
3133   if (value == 0)
3134     {
3135       emit_insn (gen_nop ());
3136       return;
3137     }
3138
3139   gen_fun = GET_MODE (operands[0]) == HImode ? gen_ashift_hi : gen_ashift;
3140   if (code == ASHIFT)
3141     {
3142       max = ext_shift_insns[value];
3143       for (i = 0; i < max; i++)
3144         gen_fun (code, ext_shift_amounts[value][i], operands[0]);
3145     }
3146   else
3147     /* When shifting right, emit the shifts in reverse order, so that
3148        solitary negative values come first.  */
3149     for (i = ext_shift_insns[value] - 1; i >= 0; i--)
3150       gen_fun (code, ext_shift_amounts[value][i], operands[0]);
3151 }
3152
3153 /* Output RTL for an arithmetic right shift.  */
3154
3155 /* ??? Rewrite to use super-optimizer sequences.  */
3156
3157 int
3158 expand_ashiftrt (rtx *operands)
3159 {
3160   rtx wrk;
3161   char func[18];
3162   int value;
3163
3164   if (TARGET_SH3)
3165     {
3166       if (!CONST_INT_P (operands[2]))
3167         {
3168           rtx count = copy_to_mode_reg (SImode, operands[2]);
3169           emit_insn (gen_negsi2 (count, count));
3170           emit_insn (gen_ashrsi3_d (operands[0], operands[1], count));
3171           return 1;
3172         }
3173       else if (ashiftrt_insns[INTVAL (operands[2]) & 31]
3174                > 1 + SH_DYNAMIC_SHIFT_COST)
3175         {
3176           rtx count
3177             = force_reg (SImode, GEN_INT (- (INTVAL (operands[2]) & 31)));
3178           emit_insn (gen_ashrsi3_d (operands[0], operands[1], count));
3179           return 1;
3180         }
3181     }
3182   if (!CONST_INT_P (operands[2]))
3183     return 0;
3184
3185   value = INTVAL (operands[2]) & 31;
3186
3187   if (value == 31)
3188     {
3189       /* If we are called from abs expansion, arrange things so that we
3190          we can use a single MT instruction that doesn't clobber the source,
3191          if LICM can hoist out the load of the constant zero.  */
3192       if (currently_expanding_to_rtl)
3193         {
3194           emit_insn (gen_cmpgtsi_t (force_reg (SImode, CONST0_RTX (SImode)),
3195                                     operands[1]));
3196           emit_insn (gen_mov_neg_si_t (operands[0]));
3197           return 1;
3198         }
3199       emit_insn (gen_ashrsi2_31 (operands[0], operands[1]));
3200       return 1;
3201     }
3202   else if (value >= 16 && value <= 19)
3203     {
3204       wrk = gen_reg_rtx (SImode);
3205       emit_insn (gen_ashrsi2_16 (wrk, operands[1]));
3206       value -= 16;
3207       while (value--)
3208         gen_ashift (ASHIFTRT, 1, wrk);
3209       emit_move_insn (operands[0], wrk);
3210       return 1;
3211     }
3212   /* Expand a short sequence inline, longer call a magic routine.  */
3213   else if (value <= 5)
3214     {
3215       wrk = gen_reg_rtx (SImode);
3216       emit_move_insn (wrk, operands[1]);
3217       while (value--)
3218         gen_ashift (ASHIFTRT, 1, wrk);
3219       emit_move_insn (operands[0], wrk);
3220       return 1;
3221     }
3222
3223   wrk = gen_reg_rtx (Pmode);
3224
3225   /* Load the value into an arg reg and call a helper.  */
3226   emit_move_insn (gen_rtx_REG (SImode, 4), operands[1]);
3227   sprintf (func, "__ashiftrt_r4_%d", value);
3228   function_symbol (wrk, func, SFUNC_STATIC);
3229   emit_insn (gen_ashrsi3_n (GEN_INT (value), wrk));
3230   emit_move_insn (operands[0], gen_rtx_REG (SImode, 4));
3231   return 1;
3232 }
3233
3234 int
3235 sh_dynamicalize_shift_p (rtx count)
3236 {
3237   return shift_insns[INTVAL (count) & 31] > 1 + SH_DYNAMIC_SHIFT_COST;
3238 }
3239
3240 /* Try to find a good way to implement the combiner pattern
3241   [(set (match_operand:SI 0 "register_operand" "r")
3242         (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
3243                            (match_operand:SI 2 "const_int_operand" "n"))
3244                 (match_operand:SI 3 "const_int_operand" "n"))) .
3245   LEFT_RTX is operand 2 in the above pattern, and MASK_RTX is operand 3.
3246   return 0 for simple right / left or left/right shift combination.
3247   return 1 for a combination of shifts with zero_extend.
3248   return 2 for a combination of shifts with an AND that needs r0.
3249   return 3 for a combination of shifts with an AND that needs an extra
3250     scratch register, when the three highmost bits of the AND mask are clear.
3251   return 4 for a combination of shifts with an AND that needs an extra
3252     scratch register, when any of the three highmost bits of the AND mask
3253     is set.
3254   If ATTRP is set, store an initial right shift width in ATTRP[0],
3255   and the instruction length in ATTRP[1] .  These values are not valid
3256   when returning 0.
3257   When ATTRP is set and returning 1, ATTRP[2] gets set to the index into
3258   shift_amounts for the last shift value that is to be used before the
3259   sign extend.  */
3260 int
3261 shl_and_kind (rtx left_rtx, rtx mask_rtx, int *attrp)
3262 {
3263   unsigned HOST_WIDE_INT mask, lsb, mask2, lsb2;
3264   int left = INTVAL (left_rtx), right;
3265   int best = 0;
3266   int cost, best_cost = 10000;
3267   int best_right = 0, best_len = 0;
3268   int i;
3269   int can_ext;
3270
3271   if (left < 0 || left > 31)
3272     return 0;
3273   if (CONST_INT_P (mask_rtx))
3274     mask = (unsigned HOST_WIDE_INT) INTVAL (mask_rtx) >> left;
3275   else
3276     mask = (unsigned HOST_WIDE_INT) GET_MODE_MASK (SImode) >> left;
3277   /* Can this be expressed as a right shift / left shift pair?  */
3278   lsb = ((mask ^ (mask - 1)) >> 1) + 1;
3279   right = exact_log2 (lsb);
3280   mask2 = ~(mask + lsb - 1);
3281   lsb2 = ((mask2 ^ (mask2 - 1)) >> 1) + 1;
3282   /* mask has no zeroes but trailing zeroes <==> ! mask2 */
3283   if (! mask2)
3284     best_cost = shift_insns[right] + shift_insns[right + left];
3285   /* mask has no trailing zeroes <==> ! right */
3286   else if (! right && mask2 == ~(lsb2 - 1))
3287     {
3288       int late_right = exact_log2 (lsb2);
3289       best_cost = shift_insns[left + late_right] + shift_insns[late_right];
3290     }
3291   /* Try to use zero extend.  */
3292   if (mask2 == ~(lsb2 - 1))
3293     {
3294       int width, first;
3295
3296       for (width = 8; width <= 16; width += 8)
3297         {
3298           /* Can we zero-extend right away?  */
3299           if (lsb2 == (unsigned HOST_WIDE_INT) 1 << width)
3300             {
3301               cost
3302                 = 1 + ext_shift_insns[right] + ext_shift_insns[left + right];
3303               if (cost < best_cost)
3304                 {
3305                   best = 1;
3306                   best_cost = cost;
3307                   best_right = right;
3308                   best_len = cost;
3309                   if (attrp)
3310                     attrp[2] = -1;
3311                 }
3312               continue;
3313             }
3314           /* ??? Could try to put zero extend into initial right shift,
3315              or even shift a bit left before the right shift.  */
3316           /* Determine value of first part of left shift, to get to the
3317              zero extend cut-off point.  */
3318           first = width - exact_log2 (lsb2) + right;
3319           if (first >= 0 && right + left - first >= 0)
3320             {
3321               cost = ext_shift_insns[right] + ext_shift_insns[first] + 1
3322                 + ext_shift_insns[right + left - first];
3323               if (cost < best_cost)
3324                 {
3325                   best = 1;
3326                   best_cost = cost;
3327                   best_right = right;
3328                   best_len = cost;
3329                   if (attrp)
3330                     attrp[2] = first;
3331                 }
3332             }
3333         }
3334     }
3335   /* Try to use r0 AND pattern */
3336   for (i = 0; i <= 2; i++)
3337     {
3338       if (i > right)
3339         break;
3340       if (! CONST_OK_FOR_K08 (mask >> i))
3341         continue;
3342       cost = (i != 0) + 2 + ext_shift_insns[left + i];
3343       if (cost < best_cost)
3344         {
3345           best = 2;
3346           best_cost = cost;
3347           best_right = i;
3348           best_len = cost - 1;
3349         }
3350     }
3351   /* Try to use a scratch register to hold the AND operand.  */
3352   can_ext = ((mask << left) & ((unsigned HOST_WIDE_INT) 3 << 30)) == 0;
3353   for (i = 0; i <= 2; i++)
3354     {
3355       if (i > right)
3356         break;
3357       cost = (i != 0) + (CONST_OK_FOR_I08 (mask >> i) ? 2 : 3)
3358         + (can_ext ? ext_shift_insns : shift_insns)[left + i];
3359       if (cost < best_cost)
3360         {
3361           best = 4 - can_ext;
3362           best_cost = cost;
3363           best_right = i;
3364           best_len = cost - 1 - ! CONST_OK_FOR_I08 (mask >> i);
3365         }
3366     }
3367
3368   if (attrp)
3369     {
3370       attrp[0] = best_right;
3371       attrp[1] = best_len;
3372     }
3373   return best;
3374 }
3375
3376 /* This is used in length attributes of the unnamed instructions
3377    corresponding to shl_and_kind return values of 1 and 2.  */
3378 int
3379 shl_and_length (rtx insn)
3380 {
3381   rtx set_src, left_rtx, mask_rtx;
3382   int attributes[3];
3383
3384   set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
3385   left_rtx = XEXP (XEXP (set_src, 0), 1);
3386   mask_rtx = XEXP (set_src, 1);
3387   shl_and_kind (left_rtx, mask_rtx, attributes);
3388   return attributes[1];
3389 }
3390
3391 /* This is used in length attribute of the and_shl_scratch instruction.  */
3392
3393 int
3394 shl_and_scr_length (rtx insn)
3395 {
3396   rtx set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
3397   int len = shift_insns[INTVAL (XEXP (set_src, 1)) & 31];
3398   rtx op = XEXP (set_src, 0);
3399   len += shift_insns[INTVAL (XEXP (op, 1)) & 31] + 1;
3400   op = XEXP (XEXP (op, 0), 0);
3401   return len + shift_insns[INTVAL (XEXP (op, 1)) & 31];
3402 }
3403
3404 /* Generate rtl for instructions for which shl_and_kind advised a particular
3405    method of generating them, i.e. returned zero.  */
3406
3407 int
3408 gen_shl_and (rtx dest, rtx left_rtx, rtx mask_rtx, rtx source)
3409 {
3410   int attributes[3];
3411   unsigned HOST_WIDE_INT mask;
3412   int kind = shl_and_kind (left_rtx, mask_rtx, attributes);
3413   int right, total_shift;
3414   void (*shift_gen_fun) (int, rtx *) = gen_shifty_hi_op;
3415
3416   right = attributes[0];
3417   total_shift = INTVAL (left_rtx) + right;
3418   mask = (unsigned HOST_WIDE_INT) INTVAL (mask_rtx) >> total_shift;
3419   switch (kind)
3420     {
3421     default:
3422       return -1;
3423     case 1:
3424       {
3425         int first = attributes[2];
3426         rtx operands[3];
3427
3428         if (first < 0)
3429           {
3430             emit_insn ((mask << right) <= 0xff
3431                        ? gen_zero_extendqisi2 (dest,
3432                                                gen_lowpart (QImode, source))
3433                        : gen_zero_extendhisi2 (dest,
3434                                                gen_lowpart (HImode, source)));
3435             source = dest;
3436           }
3437         if (source != dest)
3438           emit_insn (gen_movsi (dest, source));
3439         operands[0] = dest;
3440         if (right)
3441           {
3442             operands[2] = GEN_INT (right);
3443             gen_shifty_hi_op (LSHIFTRT, operands);
3444           }
3445         if (first > 0)
3446           {
3447             operands[2] = GEN_INT (first);
3448             gen_shifty_hi_op (ASHIFT, operands);
3449             total_shift -= first;
3450             mask <<= first;
3451           }
3452         if (first >= 0)
3453           emit_insn (mask <= 0xff
3454                      ? gen_zero_extendqisi2 (dest, gen_lowpart (QImode, dest))
3455                      : gen_zero_extendhisi2 (dest, gen_lowpart (HImode, dest)));
3456         if (total_shift > 0)
3457           {
3458             operands[2] = GEN_INT (total_shift);
3459             gen_shifty_hi_op (ASHIFT, operands);
3460           }
3461         break;
3462       }
3463     case 4:
3464       shift_gen_fun = gen_shifty_op;
3465     case 3:
3466       /* If the topmost bit that matters is set, set the topmost bits
3467          that don't matter.  This way, we might be able to get a shorter
3468          signed constant.  */
3469       if (mask & ((HOST_WIDE_INT) 1 << (31 - total_shift)))
3470         mask |= (HOST_WIDE_INT) ~0 << (31 - total_shift);
3471     case 2:
3472       /* Don't expand fine-grained when combining, because that will
3473          make the pattern fail.  */
3474       if (currently_expanding_to_rtl
3475           || reload_in_progress || reload_completed)
3476         {
3477           rtx operands[3];
3478
3479           /* Cases 3 and 4 should be handled by this split
3480              only while combining  */
3481           gcc_assert (kind <= 2);
3482           if (right)
3483             {
3484               emit_insn (gen_lshrsi3 (dest, source, GEN_INT (right)));
3485               source = dest;
3486             }
3487           emit_insn (gen_andsi3 (dest, source, GEN_INT (mask)));
3488           if (total_shift)
3489             {
3490               operands[0] = dest;
3491               operands[1] = dest;
3492               operands[2] = GEN_INT (total_shift);
3493               shift_gen_fun (ASHIFT, operands);
3494             }
3495           break;
3496         }
3497       else
3498         {
3499           int neg = 0;
3500           if (kind != 4 && total_shift < 16)
3501             {
3502               neg = -ext_shift_amounts[total_shift][1];
3503               if (neg > 0)
3504                 neg -= ext_shift_amounts[total_shift][2];
3505               else
3506                 neg = 0;
3507             }
3508           emit_insn (gen_and_shl_scratch (dest, source,
3509                                           GEN_INT (right),
3510                                           GEN_INT (mask),
3511                                           GEN_INT (total_shift + neg),
3512                                           GEN_INT (neg)));
3513           emit_insn (gen_movsi (dest, dest));
3514           break;
3515         }
3516     }
3517   return 0;
3518 }
3519
3520 /* Try to find a good way to implement the combiner pattern
3521   [(set (match_operand:SI 0 "register_operand" "=r")
3522         (sign_extract:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
3523                                     (match_operand:SI 2 "const_int_operand" "n")
3524                          (match_operand:SI 3 "const_int_operand" "n")
3525                          (const_int 0)))
3526    (clobber (reg:SI T_REG))]
3527   LEFT_RTX is operand 2 in the above pattern, and SIZE_RTX is operand 3.
3528   return 0 for simple left / right shift combination.
3529   return 1 for left shift / 8 bit sign extend / left shift.
3530   return 2 for left shift / 16 bit sign extend / left shift.
3531   return 3 for left shift / 8 bit sign extend / shift / sign extend.
3532   return 4 for left shift / 16 bit sign extend / shift / sign extend.
3533   return 5 for left shift / 16 bit sign extend / right shift
3534   return 6 for < 8 bit sign extend / left shift.
3535   return 7 for < 8 bit sign extend / left shift / single right shift.
3536   If COSTP is nonzero, assign the calculated cost to *COSTP.  */
3537
3538 int
3539 shl_sext_kind (rtx left_rtx, rtx size_rtx, int *costp)
3540 {
3541   int left, size, insize, ext;
3542   int cost = 0, best_cost;
3543   int kind;
3544
3545   left = INTVAL (left_rtx);
3546   size = INTVAL (size_rtx);
3547   insize = size - left;
3548   gcc_assert (insize > 0);
3549   /* Default to left / right shift.  */
3550   kind = 0;
3551   best_cost = shift_insns[32 - insize] + ashiftrt_insns[32 - size];
3552   if (size <= 16)
3553     {
3554       /* 16 bit shift / sign extend / 16 bit shift */
3555       cost = shift_insns[16 - insize] + 1 + ashiftrt_insns[16 - size];
3556       /* If ashiftrt_insns[16 - size] is 8, this choice will be overridden
3557          below, by alternative 3 or something even better.  */
3558       if (cost < best_cost)
3559         {
3560           kind = 5;
3561           best_cost = cost;
3562         }
3563     }
3564   /* Try a plain sign extend between two shifts.  */
3565   for (ext = 16; ext >= insize; ext -= 8)
3566     {
3567       if (ext <= size)
3568         {
3569           cost = ext_shift_insns[ext - insize] + 1 + shift_insns[size - ext];
3570           if (cost < best_cost)
3571             {
3572               kind = ext / (unsigned) 8;
3573               best_cost = cost;
3574             }
3575         }
3576       /* Check if we can do a sloppy shift with a final signed shift
3577          restoring the sign.  */
3578       if (EXT_SHIFT_SIGNED (size - ext))
3579         cost = ext_shift_insns[ext - insize] + ext_shift_insns[size - ext] + 1;
3580       /* If not, maybe it's still cheaper to do the second shift sloppy,
3581          and do a final sign extend?  */
3582       else if (size <= 16)
3583         cost = ext_shift_insns[ext - insize] + 1
3584           + ext_shift_insns[size > ext ? size - ext : ext - size] + 1;
3585       else
3586         continue;
3587       if (cost < best_cost)
3588         {
3589           kind = ext / (unsigned) 8 + 2;
3590           best_cost = cost;
3591         }
3592     }
3593   /* Check if we can sign extend in r0 */
3594   if (insize < 8)
3595     {
3596       cost = 3 + shift_insns[left];
3597       if (cost < best_cost)
3598         {
3599           kind = 6;
3600           best_cost = cost;
3601         }
3602       /* Try the same with a final signed shift.  */
3603       if (left < 31)
3604         {
3605           cost = 3 + ext_shift_insns[left + 1] + 1;
3606           if (cost < best_cost)
3607             {
3608               kind = 7;
3609               best_cost = cost;
3610             }
3611         }
3612     }
3613   if (TARGET_SH3)
3614     {
3615       /* Try to use a dynamic shift.  */
3616       cost = shift_insns[32 - insize] + 1 + SH_DYNAMIC_SHIFT_COST;
3617       if (cost < best_cost)
3618         {
3619           kind = 0;
3620           best_cost = cost;
3621         }
3622     }
3623   if (costp)
3624     *costp = cost;
3625   return kind;
3626 }
3627
3628 /* Function to be used in the length attribute of the instructions
3629    implementing this pattern.  */
3630
3631 int
3632 shl_sext_length (rtx insn)
3633 {
3634   rtx set_src, left_rtx, size_rtx;
3635   int cost;
3636
3637   set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
3638   left_rtx = XEXP (XEXP (set_src, 0), 1);
3639   size_rtx = XEXP (set_src, 1);
3640   shl_sext_kind (left_rtx, size_rtx, &cost);
3641   return cost;
3642 }
3643
3644 /* Generate rtl for this pattern */
3645
3646 int
3647 gen_shl_sext (rtx dest, rtx left_rtx, rtx size_rtx, rtx source)
3648 {
3649   int kind;
3650   int left, size, insize, cost;
3651   rtx operands[3];
3652
3653   kind = shl_sext_kind (left_rtx, size_rtx, &cost);
3654   left = INTVAL (left_rtx);
3655   size = INTVAL (size_rtx);
3656   insize = size - left;
3657   switch (kind)
3658     {
3659     case 1:
3660     case 2:
3661     case 3:
3662     case 4:
3663       {
3664         int ext = kind & 1 ? 8 : 16;
3665         int shift2 = size - ext;
3666
3667         /* Don't expand fine-grained when combining, because that will
3668            make the pattern fail.  */
3669         if (! currently_expanding_to_rtl
3670             && ! reload_in_progress && ! reload_completed)
3671           {
3672             emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
3673             emit_insn (gen_movsi (dest, source));
3674             break;
3675           }
3676         if (dest != source)
3677           emit_insn (gen_movsi (dest, source));
3678         operands[0] = dest;
3679         if (ext - insize)
3680           {
3681             operands[2] = GEN_INT (ext - insize);
3682             gen_shifty_hi_op (ASHIFT, operands);
3683           }
3684         emit_insn (kind & 1
3685                    ? gen_extendqisi2 (dest, gen_lowpart (QImode, dest))
3686                    : gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
3687         if (kind <= 2)
3688           {
3689             if (shift2)
3690               {
3691                 operands[2] = GEN_INT (shift2);
3692                 gen_shifty_op (ASHIFT, operands);
3693               }
3694           }
3695         else
3696           {
3697             if (shift2 > 0)
3698               {
3699                 if (EXT_SHIFT_SIGNED (shift2))
3700                   {
3701                     operands[2] = GEN_INT (shift2 + 1);
3702                     gen_shifty_op (ASHIFT, operands);
3703                     operands[2] = const1_rtx;
3704                     gen_shifty_op (ASHIFTRT, operands);
3705                     break;
3706                   }
3707                 operands[2] = GEN_INT (shift2);
3708                 gen_shifty_hi_op (ASHIFT, operands);
3709               }
3710             else if (shift2)
3711               {
3712                 operands[2] = GEN_INT (-shift2);
3713                 gen_shifty_hi_op (LSHIFTRT, operands);
3714               }
3715             emit_insn (size <= 8
3716                        ? gen_extendqisi2 (dest, gen_lowpart (QImode, dest))
3717                        : gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
3718           }
3719         break;
3720       }
3721     case 5:
3722       {
3723         int i = 16 - size;
3724         if (! currently_expanding_to_rtl
3725             && ! reload_in_progress && ! reload_completed)
3726           emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
3727         else
3728           {
3729             operands[0] = dest;
3730             operands[2] = GEN_INT (16 - insize);
3731             gen_shifty_hi_op (ASHIFT, operands);
3732             emit_insn (gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
3733           }
3734         /* Don't use gen_ashrsi3 because it generates new pseudos.  */
3735         while (--i >= 0)
3736           gen_ashift (ASHIFTRT, 1, dest);
3737         break;
3738       }
3739     case 6:
3740     case 7:
3741       /* Don't expand fine-grained when combining, because that will
3742          make the pattern fail.  */
3743       if (! currently_expanding_to_rtl
3744           && ! reload_in_progress && ! reload_completed)
3745         {
3746           emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
3747           emit_insn (gen_movsi (dest, source));
3748           break;
3749         }
3750       emit_insn (gen_andsi3 (dest, source, GEN_INT ((1 << insize) - 1)));
3751       emit_insn (gen_xorsi3 (dest, dest, GEN_INT (1 << (insize - 1))));
3752       emit_insn (gen_addsi3 (dest, dest, GEN_INT (-1 << (insize - 1))));
3753       operands[0] = dest;
3754       operands[2] = kind == 7 ? GEN_INT (left + 1) : left_rtx;
3755       gen_shifty_op (ASHIFT, operands);
3756       if (kind == 7)
3757         emit_insn (gen_ashrsi3_k (dest, dest, const1_rtx));
3758       break;
3759     default:
3760       return -1;
3761     }
3762   return 0;
3763 }
3764
3765 /* Prefix a symbol_ref name with "datalabel".  */
3766
3767 rtx
3768 gen_datalabel_ref (rtx sym)
3769 {
3770   const char *str;
3771
3772   if (GET_CODE (sym) == LABEL_REF)
3773     return gen_rtx_CONST (GET_MODE (sym),
3774                           gen_rtx_UNSPEC (GET_MODE (sym),
3775                                           gen_rtvec (1, sym),
3776                                           UNSPEC_DATALABEL));
3777
3778   gcc_assert (GET_CODE (sym) == SYMBOL_REF);
3779
3780   str = XSTR (sym, 0);
3781   /* Share all SYMBOL_REF strings with the same value - that is important
3782      for cse.  */
3783   str = IDENTIFIER_POINTER (get_identifier (str));
3784   XSTR (sym, 0) = str;
3785
3786   return sym;
3787 }
3788
3789 \f
3790 static alloc_pool label_ref_list_pool;
3791
3792 typedef struct label_ref_list_d
3793 {
3794   rtx label;
3795   struct label_ref_list_d *next;
3796 } *label_ref_list_t;
3797
3798 /* The SH cannot load a large constant into a register, constants have to
3799    come from a pc relative load.  The reference of a pc relative load
3800    instruction must be less than 1k in front of the instruction.  This
3801    means that we often have to dump a constant inside a function, and
3802    generate code to branch around it.
3803
3804    It is important to minimize this, since the branches will slow things
3805    down and make things bigger.
3806
3807    Worst case code looks like:
3808
3809    mov.l L1,rn
3810    bra   L2
3811    nop
3812    align
3813    L1:   .long value
3814    L2:
3815    ..
3816
3817    mov.l L3,rn
3818    bra   L4
3819    nop
3820    align
3821    L3:   .long value
3822    L4:
3823    ..
3824
3825    We fix this by performing a scan before scheduling, which notices which
3826    instructions need to have their operands fetched from the constant table
3827    and builds the table.
3828
3829    The algorithm is:
3830
3831    scan, find an instruction which needs a pcrel move.  Look forward, find the
3832    last barrier which is within MAX_COUNT bytes of the requirement.
3833    If there isn't one, make one.  Process all the instructions between
3834    the find and the barrier.
3835
3836    In the above example, we can tell that L3 is within 1k of L1, so
3837    the first move can be shrunk from the 3 insn+constant sequence into
3838    just 1 insn, and the constant moved to L3 to make:
3839
3840    mov.l        L1,rn
3841    ..
3842    mov.l        L3,rn
3843    bra          L4
3844    nop
3845    align
3846    L3:.long value
3847    L4:.long value
3848
3849    Then the second move becomes the target for the shortening process.  */
3850
3851 typedef struct
3852 {
3853   rtx value;                    /* Value in table.  */
3854   rtx label;                    /* Label of value.  */
3855   label_ref_list_t wend;        /* End of window.  */
3856   enum machine_mode mode;       /* Mode of value.  */
3857
3858   /* True if this constant is accessed as part of a post-increment
3859      sequence.  Note that HImode constants are never accessed in this way.  */
3860   bool part_of_sequence_p;
3861 } pool_node;
3862
3863 /* The maximum number of constants that can fit into one pool, since
3864    constants in the range 0..510 are at least 2 bytes long, and in the
3865    range from there to 1018 at least 4 bytes.  */
3866
3867 #define MAX_POOL_SIZE 372
3868 static pool_node pool_vector[MAX_POOL_SIZE];
3869 static int pool_size;
3870 static rtx pool_window_label;
3871 static int pool_window_last;
3872
3873 static int max_labelno_before_reorg;
3874
3875 /* ??? If we need a constant in HImode which is the truncated value of a
3876    constant we need in SImode, we could combine the two entries thus saving
3877    two bytes.  Is this common enough to be worth the effort of implementing
3878    it?  */
3879
3880 /* ??? This stuff should be done at the same time that we shorten branches.
3881    As it is now, we must assume that all branches are the maximum size, and
3882    this causes us to almost always output constant pools sooner than
3883    necessary.  */
3884
3885 /* Add a constant to the pool and return its label.  */
3886
3887 static rtx
3888 add_constant (rtx x, enum machine_mode mode, rtx last_value)
3889 {
3890   int i;
3891   rtx lab, new_rtx;
3892   label_ref_list_t ref, newref;
3893
3894   /* First see if we've already got it.  */
3895   for (i = 0; i < pool_size; i++)
3896     {
3897       if (x->code == pool_vector[i].value->code
3898           && mode == pool_vector[i].mode)
3899         {
3900           if (x->code == CODE_LABEL)
3901             {
3902               if (XINT (x, 3) != XINT (pool_vector[i].value, 3))
3903                 continue;
3904             }
3905           if (rtx_equal_p (x, pool_vector[i].value))
3906             {
3907               lab = new_rtx = 0;
3908               if (! last_value
3909                   || ! i
3910                   || ! rtx_equal_p (last_value, pool_vector[i-1].value))
3911                 {
3912                   new_rtx = gen_label_rtx ();
3913                   LABEL_REFS (new_rtx) = pool_vector[i].label;
3914                   pool_vector[i].label = lab = new_rtx;
3915                 }
3916               if (lab && pool_window_label)
3917                 {
3918                   newref = (label_ref_list_t) pool_alloc (label_ref_list_pool);
3919                   newref->label = pool_window_label;
3920                   ref = pool_vector[pool_window_last].wend;
3921                   newref->next = ref;
3922                   pool_vector[pool_window_last].wend = newref;
3923                 }
3924               if (new_rtx)
3925                 pool_window_label = new_rtx;
3926               pool_window_last = i;
3927               return lab;
3928             }
3929         }
3930     }
3931
3932   /* Need a new one.  */
3933   pool_vector[pool_size].value = x;
3934   if (last_value && rtx_equal_p (last_value, pool_vector[pool_size - 1].value))
3935     {
3936       lab = 0;
3937       pool_vector[pool_size - 1].part_of_sequence_p = true;
3938     }
3939   else
3940     lab = gen_label_rtx ();
3941   pool_vector[pool_size].mode = mode;
3942   pool_vector[pool_size].label = lab;
3943   pool_vector[pool_size].wend = NULL;
3944   pool_vector[pool_size].part_of_sequence_p = (lab == 0);
3945   if (lab && pool_window_label)
3946     {
3947       newref = (label_ref_list_t) pool_alloc (label_ref_list_pool);
3948       newref->label = pool_window_label;
3949       ref = pool_vector[pool_window_last].wend;
3950       newref->next = ref;
3951       pool_vector[pool_window_last].wend = newref;
3952     }
3953   if (lab)
3954     pool_window_label = lab;
3955   pool_window_last = pool_size;
3956   pool_size++;
3957   return lab;
3958 }
3959
3960 /* Output the literal table.  START, if nonzero, is the first instruction
3961    this table is needed for, and also indicates that there is at least one
3962    casesi_worker_2 instruction; We have to emit the operand3 labels from
3963    these insns at a 4-byte  aligned position.  BARRIER is the barrier
3964    after which we are to place the table.  */
3965
3966 static void
3967 dump_table (rtx start, rtx barrier)
3968 {
3969   rtx scan = barrier;
3970   int i;
3971   int need_align = 1;
3972   rtx lab;
3973   label_ref_list_t ref;
3974   int have_df = 0;
3975
3976   /* Do two passes, first time dump out the HI sized constants.  */
3977
3978   for (i = 0; i < pool_size; i++)
3979     {
3980       pool_node *p = &pool_vector[i];
3981
3982       if (p->mode == HImode)
3983         {
3984           if (need_align)
3985             {
3986               scan = emit_insn_after (gen_align_2 (), scan);
3987               need_align = 0;
3988             }
3989           for (lab = p->label; lab; lab = LABEL_REFS (lab))
3990             scan = emit_label_after (lab, scan);
3991           scan = emit_insn_after (gen_consttable_2 (p->value, const0_rtx),
3992                                   scan);
3993           for (ref = p->wend; ref; ref = ref->next)
3994             {
3995               lab = ref->label;
3996               scan = emit_insn_after (gen_consttable_window_end (lab), scan);
3997             }
3998         }
3999       else if (p->mode == DFmode)
4000         have_df = 1;
4001     }
4002
4003   need_align = 1;
4004
4005   if (start)
4006     {
4007       scan = emit_insn_after (gen_align_4 (), scan);
4008       need_align = 0;
4009       for (; start != barrier; start = NEXT_INSN (start))
4010         if (NONJUMP_INSN_P (start)
4011             && recog_memoized (start) == CODE_FOR_casesi_worker_2)
4012           {
4013             rtx src = SET_SRC (XVECEXP (PATTERN (start), 0, 0));
4014             rtx lab = XEXP (XVECEXP (src, 0, 3), 0);
4015
4016             scan = emit_label_after (lab, scan);
4017           }
4018     }
4019   if (TARGET_FMOVD && TARGET_ALIGN_DOUBLE && have_df)
4020     {
4021       rtx align_insn = NULL_RTX;
4022
4023       scan = emit_label_after (gen_label_rtx (), scan);
4024       scan = emit_insn_after (gen_align_log (GEN_INT (3)), scan);
4025       need_align = 0;
4026
4027       for (i = 0; i < pool_size; i++)
4028         {
4029           pool_node *p = &pool_vector[i];
4030
4031           switch (p->mode)
4032             {
4033             case HImode:
4034               break;
4035             case SImode:
4036             case SFmode:
4037               if (align_insn && !p->part_of_sequence_p)
4038                 {
4039                   for (lab = p->label; lab; lab = LABEL_REFS (lab))
4040                     emit_label_before (lab, align_insn);
4041                   emit_insn_before (gen_consttable_4 (p->value, const0_rtx),
4042                                     align_insn);
4043                   for (ref = p->wend; ref; ref = ref->next)
4044                     {
4045                       lab = ref->label;
4046                       emit_insn_before (gen_consttable_window_end (lab),
4047                                         align_insn);
4048                     }
4049                   delete_insn (align_insn);
4050                   align_insn = NULL_RTX;
4051                   continue;
4052                 }
4053               else
4054                 {
4055                   for (lab = p->label; lab; lab = LABEL_REFS (lab))
4056                     scan = emit_label_after (lab, scan);
4057                   scan = emit_insn_after (gen_consttable_4 (p->value,
4058                                                             const0_rtx), scan);
4059                   need_align = ! need_align;
4060                 }
4061               break;
4062             case DFmode:
4063               if (need_align)
4064                 {
4065                   scan = emit_insn_after (gen_align_log (GEN_INT (3)), scan);
4066                   align_insn = scan;
4067                   need_align = 0;
4068                 }
4069             case DImode:
4070               for (lab = p->label; lab; lab = LABEL_REFS (lab))
4071                 scan = emit_label_after (lab, scan);
4072               scan = emit_insn_after (gen_consttable_8 (p->value, const0_rtx),
4073                                       scan);
4074               break;
4075             default:
4076               gcc_unreachable ();
4077             }
4078
4079           if (p->mode != HImode)
4080             {
4081               for (ref = p->wend; ref; ref = ref->next)
4082                 {
4083                   lab = ref->label;
4084                   scan = emit_insn_after (gen_consttable_window_end (lab),
4085                                           scan);
4086                 }
4087             }
4088         }
4089
4090       pool_size = 0;
4091     }
4092
4093   for (i = 0; i < pool_size; i++)
4094     {
4095       pool_node *p = &pool_vector[i];
4096
4097       switch (p->mode)
4098         {
4099         case HImode:
4100           break;
4101         case SImode:
4102         case SFmode:
4103           if (need_align)
4104             {
4105               need_align = 0;
4106               scan = emit_label_after (gen_label_rtx (), scan);
4107               scan = emit_insn_after (gen_align_4 (), scan);
4108             }
4109           for (lab = p->label; lab; lab = LABEL_REFS (lab))
4110             scan = emit_label_after (lab, scan);
4111           scan = emit_insn_after (gen_consttable_4 (p->value, const0_rtx),
4112                                   scan);
4113           break;
4114         case DFmode:
4115         case DImode:
4116           if (need_align)
4117             {
4118               need_align = 0;
4119               scan = emit_label_after (gen_label_rtx (), scan);
4120               scan = emit_insn_after (gen_align_4 (), scan);
4121             }
4122           for (lab = p->label; lab; lab = LABEL_REFS (lab))
4123             scan = emit_label_after (lab, scan);
4124           scan = emit_insn_after (gen_consttable_8 (p->value, const0_rtx),
4125                                   scan);
4126           break;
4127         default:
4128           gcc_unreachable ();
4129         }
4130
4131       if (p->mode != HImode)
4132         {
4133           for (ref = p->wend; ref; ref = ref->next)
4134             {
4135               lab = ref->label;
4136               scan = emit_insn_after (gen_consttable_window_end (lab), scan);
4137             }
4138         }
4139     }
4140
4141   scan = emit_insn_after (gen_consttable_end (), scan);
4142   scan = emit_barrier_after (scan);
4143   pool_size = 0;
4144   pool_window_label = NULL_RTX;
4145   pool_window_last = 0;
4146 }
4147
4148 /* Return nonzero if constant would be an ok source for a
4149    mov.w instead of a mov.l.  */
4150
4151 static int
4152 hi_const (rtx src)
4153 {
4154   return (CONST_INT_P (src)
4155           && INTVAL (src) >= -32768
4156           && INTVAL (src) <= 32767);
4157 }
4158
4159 #define MOVA_LABELREF(mova) XVECEXP (SET_SRC (PATTERN (mova)), 0, 0)
4160
4161 /* Nonzero if the insn is a move instruction which needs to be fixed.  */
4162
4163 /* ??? For a DImode/DFmode moves, we don't need to fix it if each half of the
4164    CONST_DOUBLE input value is CONST_OK_FOR_I08.  For a SFmode move, we don't
4165    need to fix it if the input value is CONST_OK_FOR_I08.  */
4166
4167 static int
4168 broken_move (rtx insn)
4169 {
4170   if (NONJUMP_INSN_P (insn))
4171     {
4172       rtx pat = PATTERN (insn);
4173       if (GET_CODE (pat) == PARALLEL)
4174         pat = XVECEXP (pat, 0, 0);
4175       if (GET_CODE (pat) == SET
4176           /* We can load any 8-bit value if we don't care what the high
4177              order bits end up as.  */
4178           && GET_MODE (SET_DEST (pat)) != QImode
4179           && (CONSTANT_P (SET_SRC (pat))
4180               /* Match mova_const.  */
4181               || (GET_CODE (SET_SRC (pat)) == UNSPEC
4182                   && XINT (SET_SRC (pat), 1) == UNSPEC_MOVA
4183                   && GET_CODE (XVECEXP (SET_SRC (pat), 0, 0)) == CONST))
4184           && ! (TARGET_SH2E
4185                 && GET_CODE (SET_SRC (pat)) == CONST_DOUBLE
4186                 && (fp_zero_operand (SET_SRC (pat))
4187                     || fp_one_operand (SET_SRC (pat)))
4188                 /* ??? If this is a -m4 or -m4-single compilation, in general
4189                    we don't know the current setting of fpscr, so disable fldi.
4190                    There is an exception if this was a register-register move
4191                    before reload - and hence it was ascertained that we have
4192                    single precision setting - and in a post-reload optimization
4193                    we changed this to do a constant load.  In that case
4194                    we don't have an r0 clobber, hence we must use fldi.  */
4195                 && (! TARGET_SH4 || TARGET_FMOVD
4196                     || (GET_CODE (XEXP (XVECEXP (PATTERN (insn), 0, 2), 0))
4197                         == SCRATCH))
4198                 && REG_P (SET_DEST (pat))
4199                 && FP_REGISTER_P (REGNO (SET_DEST (pat))))
4200           && ! (TARGET_SH2A
4201                 && GET_MODE (SET_DEST (pat)) == SImode
4202                 && (satisfies_constraint_I20 (SET_SRC (pat))
4203                    || satisfies_constraint_I28 (SET_SRC (pat))))
4204           && ! satisfies_constraint_I08 (SET_SRC (pat)))
4205         return 1;
4206     }
4207
4208   return 0;
4209 }
4210
4211 static int
4212 mova_p (rtx insn)
4213 {
4214   return (NONJUMP_INSN_P (insn)
4215           && GET_CODE (PATTERN (insn)) == SET
4216           && GET_CODE (SET_SRC (PATTERN (insn))) == UNSPEC
4217           && XINT (SET_SRC (PATTERN (insn)), 1) == UNSPEC_MOVA
4218           /* Don't match mova_const.  */
4219           && GET_CODE (MOVA_LABELREF (insn)) == LABEL_REF);
4220 }
4221
4222 /* Fix up a mova from a switch that went out of range.  */
4223 static void
4224 fixup_mova (rtx mova)
4225 {
4226   PUT_MODE (XEXP (MOVA_LABELREF (mova), 0), QImode);
4227   if (! flag_pic)
4228     {
4229       SET_SRC (PATTERN (mova)) = MOVA_LABELREF (mova);
4230       INSN_CODE (mova) = -1;
4231     }
4232   else
4233     {
4234       rtx worker = mova;
4235       rtx lab = gen_label_rtx ();
4236       rtx wpat, wpat0, wpat1, wsrc, target, base, diff;
4237
4238       do
4239         {
4240           worker = NEXT_INSN (worker);
4241           gcc_assert (worker
4242                       && !LABEL_P (worker)
4243                       && !JUMP_P (worker));
4244         } while (NOTE_P (worker)
4245                  || recog_memoized (worker) != CODE_FOR_casesi_worker_1);
4246       wpat = PATTERN (worker);
4247       wpat0 = XVECEXP (wpat, 0, 0);
4248       wpat1 = XVECEXP (wpat, 0, 1);
4249       wsrc = SET_SRC (wpat0);
4250       PATTERN (worker) = (gen_casesi_worker_2
4251                           (SET_DEST (wpat0), XVECEXP (wsrc, 0, 1),
4252                            XEXP (XVECEXP (wsrc, 0, 2), 0), lab,
4253                            XEXP (wpat1, 0)));
4254       INSN_CODE (worker) = -1;
4255       target = XVECEXP (SET_SRC (PATTERN (mova)), 0, 0);
4256       base = gen_rtx_LABEL_REF (Pmode, lab);
4257       diff = gen_rtx_UNSPEC (Pmode, gen_rtvec (2, target, base), UNSPEC_SYMOFF);
4258       SET_SRC (PATTERN (mova)) = gen_rtx_CONST (Pmode, diff);
4259       INSN_CODE (mova) = -1;
4260     }
4261 }
4262
4263 /* NEW_MOVA is a mova we've just encountered while scanning forward.  Update
4264    *num_mova, and check if the new mova is not nested within the first one.
4265    return 0 if *first_mova was replaced, 1 if new_mova was replaced,
4266    2 if new_mova has been assigned to *first_mova, -1 otherwise..  */
4267 static int
4268 untangle_mova (int *num_mova, rtx *first_mova, rtx new_mova)
4269 {
4270   int n_addr = 0; /* Initialization to shut up spurious warning.  */
4271   int f_target, n_target = 0; /* Likewise.  */
4272
4273   if (optimize)
4274     {
4275       /* If NEW_MOVA has no address yet, it will be handled later.  */
4276       if (INSN_ADDRESSES_SIZE() <= (unsigned) INSN_UID (new_mova))
4277         return -1;
4278
4279       n_addr = INSN_ADDRESSES (INSN_UID (new_mova));
4280       n_target = INSN_ADDRESSES (INSN_UID (XEXP (MOVA_LABELREF (new_mova), 0)));
4281       if (n_addr > n_target || n_addr + 1022 < n_target)
4282         {
4283           /* Change the mova into a load.
4284              broken_move will then return true for it.  */
4285           fixup_mova (new_mova);
4286           return 1;
4287         }
4288     }
4289   if (!(*num_mova)++)
4290     {
4291       *first_mova = new_mova;
4292       return 2;
4293     }
4294   if (!optimize
4295       || ((f_target
4296            = INSN_ADDRESSES (INSN_UID (XEXP (MOVA_LABELREF (*first_mova), 0))))
4297           >= n_target))
4298     return -1;
4299
4300   (*num_mova)--;
4301   if (f_target - INSN_ADDRESSES (INSN_UID (*first_mova))
4302       > n_target - n_addr)
4303     {
4304       fixup_mova (*first_mova);
4305       return 0;
4306     }
4307   else
4308     {
4309       fixup_mova (new_mova);
4310       return 1;
4311     }
4312 }
4313
4314 /* Find the last barrier from insn FROM which is close enough to hold the
4315    constant pool.  If we can't find one, then create one near the end of
4316    the range.  */
4317
4318 static rtx
4319 find_barrier (int num_mova, rtx mova, rtx from)
4320 {
4321   int count_si = 0;
4322   int count_hi = 0;
4323   int found_hi = 0;
4324   int found_si = 0;
4325   int found_di = 0;
4326   int hi_align = 2;
4327   int si_align = 2;
4328   int leading_mova = num_mova;
4329   rtx barrier_before_mova = 0, found_barrier = 0, good_barrier = 0;
4330   int si_limit;
4331   int hi_limit;
4332   rtx orig = from;
4333
4334   /* For HImode: range is 510, add 4 because pc counts from address of
4335      second instruction after this one, subtract 2 for the jump instruction
4336      that we may need to emit before the table, subtract 2 for the instruction
4337      that fills the jump delay slot (in very rare cases, reorg will take an
4338      instruction from after the constant pool or will leave the delay slot
4339      empty).  This gives 510.
4340      For SImode: range is 1020, add 4 because pc counts from address of
4341      second instruction after this one, subtract 2 in case pc is 2 byte
4342      aligned, subtract 2 for the jump instruction that we may need to emit
4343      before the table, subtract 2 for the instruction that fills the jump
4344      delay slot.  This gives 1018.  */
4345
4346   /* The branch will always be shortened now that the reference address for
4347      forward branches is the successor address, thus we need no longer make
4348      adjustments to the [sh]i_limit for -O0.  */
4349
4350   si_limit = 1018;
4351   hi_limit = 510;
4352
4353   while (from && count_si < si_limit && count_hi < hi_limit)
4354     {
4355       int inc = get_attr_length (from);
4356       int new_align = 1;
4357
4358       /* If this is a label that existed at the time of the compute_alignments
4359          call, determine the alignment.  N.B.  When find_barrier recurses for
4360          an out-of-reach mova, we might see labels at the start of previously
4361          inserted constant tables.  */
4362       if (LABEL_P (from)
4363           && CODE_LABEL_NUMBER (from) <= max_labelno_before_reorg)
4364         {
4365           if (optimize)
4366             new_align = 1 << label_to_alignment (from);
4367           else if (BARRIER_P (prev_nonnote_insn (from)))
4368             new_align = 1 << barrier_align (from);
4369           else
4370             new_align = 1;
4371           inc = 0;
4372         }
4373       /* In case we are scanning a constant table because of recursion, check
4374          for explicit alignments.  If the table is long, we might be forced
4375          to emit the new table in front of it; the length of the alignment
4376          might be the last straw.  */
4377       else if (NONJUMP_INSN_P (from)
4378                && GET_CODE (PATTERN (from)) == UNSPEC_VOLATILE
4379                && XINT (PATTERN (from), 1) == UNSPECV_ALIGN)
4380         new_align = INTVAL (XVECEXP (PATTERN (from), 0, 0));
4381       /* When we find the end of a constant table, paste the new constant
4382          at the end.  That is better than putting it in front because
4383          this way, we don't need extra alignment for adding a 4-byte-aligned
4384          mov(a) label to a 2/4 or 8/4 byte aligned table.  */
4385       else if (NONJUMP_INSN_P (from)
4386                && GET_CODE (PATTERN (from)) == UNSPEC_VOLATILE
4387                && XINT (PATTERN (from), 1) == UNSPECV_CONST_END)
4388         return from;
4389
4390       if (BARRIER_P (from))
4391         {
4392           rtx next;
4393
4394           found_barrier = from;
4395
4396           /* If we are at the end of the function, or in front of an alignment
4397              instruction, we need not insert an extra alignment.  We prefer
4398              this kind of barrier.  */
4399           if (barrier_align (from) > 2)
4400             good_barrier = from;
4401
4402           /* If we are at the end of a hot/cold block, dump the constants
4403              here.  */
4404           next = NEXT_INSN (from);
4405           if (next
4406               && NOTE_P (next)
4407               && NOTE_KIND (next) == NOTE_INSN_SWITCH_TEXT_SECTIONS)
4408             break;
4409         }
4410
4411       if (broken_move (from))
4412         {
4413           rtx pat, src, dst;
4414           enum machine_mode mode;
4415
4416           pat = PATTERN (from);
4417           if (GET_CODE (pat) == PARALLEL)
4418             pat = XVECEXP (pat, 0, 0);
4419           src = SET_SRC (pat);
4420           dst = SET_DEST (pat);
4421           mode = GET_MODE (dst);
4422
4423           /* We must explicitly check the mode, because sometimes the
4424              front end will generate code to load unsigned constants into
4425              HImode targets without properly sign extending them.  */
4426           if (mode == HImode
4427               || (mode == SImode && hi_const (src) && REGNO (dst) != FPUL_REG))
4428             {
4429               found_hi += 2;
4430               /* We put the short constants before the long constants, so
4431                  we must count the length of short constants in the range
4432                  for the long constants.  */
4433               /* ??? This isn't optimal, but is easy to do.  */
4434               si_limit -= 2;
4435             }
4436           else
4437             {
4438               /* We dump DF/DI constants before SF/SI ones, because
4439                  the limit is the same, but the alignment requirements
4440                  are higher.  We may waste up to 4 additional bytes
4441                  for alignment, and the DF/DI constant may have
4442                  another SF/SI constant placed before it.  */
4443               if (TARGET_SHCOMPACT
4444                   && ! found_di
4445                   && (mode == DFmode || mode == DImode))
4446                 {
4447                   found_di = 1;
4448                   si_limit -= 8;
4449                 }
4450               while (si_align > 2 && found_si + si_align - 2 > count_si)
4451                 si_align >>= 1;
4452               if (found_si > count_si)
4453                 count_si = found_si;
4454               found_si += GET_MODE_SIZE (mode);
4455               if (num_mova)
4456                 si_limit -= GET_MODE_SIZE (mode);
4457             }
4458         }
4459
4460       if (mova_p (from))
4461         {
4462           switch (untangle_mova (&num_mova, &mova, from))
4463             {
4464               case 0:   return find_barrier (0, 0, mova);
4465               case 2:
4466                 {
4467                   leading_mova = 0;
4468                   barrier_before_mova
4469                     = good_barrier ? good_barrier : found_barrier;
4470                 }
4471               default:  break;
4472             }
4473           if (found_si > count_si)
4474             count_si = found_si;
4475         }
4476       else if (JUMP_TABLE_DATA_P (from))
4477         {
4478           if ((num_mova > 1 && GET_MODE (prev_nonnote_insn (from)) == VOIDmode)
4479               || (num_mova
4480                   && (prev_nonnote_insn (from)
4481                       == XEXP (MOVA_LABELREF (mova), 0))))
4482             num_mova--;
4483           if (barrier_align (next_real_insn (from)) == align_jumps_log)
4484             {
4485               /* We have just passed the barrier in front of the
4486                  ADDR_DIFF_VEC, which is stored in found_barrier.  Since
4487                  the ADDR_DIFF_VEC is accessed as data, just like our pool
4488                  constants, this is a good opportunity to accommodate what
4489                  we have gathered so far.
4490                  If we waited any longer, we could end up at a barrier in
4491                  front of code, which gives worse cache usage for separated
4492                  instruction / data caches.  */
4493               good_barrier = found_barrier;
4494               break;
4495             }
4496           else
4497             {
4498               rtx body = PATTERN (from);
4499               inc = XVECLEN (body, 1) * GET_MODE_SIZE (GET_MODE (body));
4500             }
4501         }
4502       /* For the SH1, we generate alignments even after jumps-around-jumps.  */
4503       else if (JUMP_P (from)
4504                && ! TARGET_SH2
4505                && ! TARGET_SMALLCODE)
4506         new_align = 4;
4507
4508       if (found_si)
4509         {
4510           count_si += inc;
4511           if (new_align > si_align)
4512             {
4513               si_limit -= (count_si - 1) & (new_align - si_align);
4514               si_align = new_align;
4515             }
4516           count_si = (count_si + new_align - 1) & -new_align;
4517         }
4518       if (found_hi)
4519         {
4520           count_hi += inc;
4521           if (new_align > hi_align)
4522             {
4523               hi_limit -= (count_hi - 1) & (new_align - hi_align);
4524               hi_align = new_align;
4525             }
4526           count_hi = (count_hi + new_align - 1) & -new_align;
4527         }
4528       from = NEXT_INSN (from);
4529     }
4530
4531   if (num_mova)
4532     {
4533       if (leading_mova)
4534         {
4535           /* Try as we might, the leading mova is out of range.  Change
4536              it into a load (which will become a pcload) and retry.  */
4537           fixup_mova (mova);
4538           return find_barrier (0, 0, mova);
4539         }
4540       else
4541         {
4542           /* Insert the constant pool table before the mova instruction,
4543              to prevent the mova label reference from going out of range.  */
4544           from = mova;
4545           good_barrier = found_barrier = barrier_before_mova;
4546         }
4547     }
4548
4549   if (found_barrier)
4550     {
4551       if (good_barrier && next_real_insn (found_barrier))
4552         found_barrier = good_barrier;
4553     }
4554   else
4555     {
4556       /* We didn't find a barrier in time to dump our stuff,
4557          so we'll make one.  */
4558       rtx label = gen_label_rtx ();
4559
4560       /* If we exceeded the range, then we must back up over the last
4561          instruction we looked at.  Otherwise, we just need to undo the
4562          NEXT_INSN at the end of the loop.  */
4563       if (PREV_INSN (from) != orig
4564           && (count_hi > hi_limit || count_si > si_limit))
4565         from = PREV_INSN (PREV_INSN (from));
4566       else
4567         from = PREV_INSN (from);
4568
4569       /* Walk back to be just before any jump or label.
4570          Putting it before a label reduces the number of times the branch
4571          around the constant pool table will be hit.  Putting it before
4572          a jump makes it more likely that the bra delay slot will be
4573          filled.  */
4574       while (NOTE_P (from) || JUMP_P (from)
4575              || LABEL_P (from))
4576         from = PREV_INSN (from);
4577
4578       from = emit_jump_insn_after (gen_jump (label), from);
4579       JUMP_LABEL (from) = label;
4580       LABEL_NUSES (label) = 1;
4581       found_barrier = emit_barrier_after (from);
4582       emit_label_after (label, found_barrier);
4583     }
4584
4585   return found_barrier;
4586 }
4587
4588 /* If the instruction INSN is implemented by a special function, and we can
4589    positively find the register that is used to call the sfunc, and this
4590    register is not used anywhere else in this instruction - except as the
4591    destination of a set, return this register; else, return 0.  */
4592 rtx
4593 sfunc_uses_reg (rtx insn)
4594 {
4595   int i;
4596   rtx pattern, part, reg_part, reg;
4597
4598   if (!NONJUMP_INSN_P (insn))
4599     return 0;
4600   pattern = PATTERN (insn);
4601   if (GET_CODE (pattern) != PARALLEL || get_attr_type (insn) != TYPE_SFUNC)
4602     return 0;
4603
4604   for (reg_part = 0, i = XVECLEN (pattern, 0) - 1; i >= 1; i--)
4605     {
4606       part = XVECEXP (pattern, 0, i);
4607       if (GET_CODE (part) == USE && GET_MODE (XEXP (part, 0)) == SImode)
4608         reg_part = part;
4609     }
4610   if (! reg_part)
4611     return 0;
4612   reg = XEXP (reg_part, 0);
4613   for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
4614     {
4615       part = XVECEXP (pattern, 0, i);
4616       if (part == reg_part || GET_CODE (part) == CLOBBER)
4617         continue;
4618       if (reg_mentioned_p (reg, ((GET_CODE (part) == SET
4619                                   && REG_P (SET_DEST (part)))
4620                                  ? SET_SRC (part) : part)))
4621         return 0;
4622     }
4623   return reg;
4624 }
4625
4626 /* See if the only way in which INSN uses REG is by calling it, or by
4627    setting it while calling it.  Set *SET to a SET rtx if the register
4628    is set by INSN.  */
4629
4630 static int
4631 noncall_uses_reg (rtx reg, rtx insn, rtx *set)
4632 {
4633   rtx pattern, reg2;
4634
4635   *set = NULL_RTX;
4636
4637   reg2 = sfunc_uses_reg (insn);
4638   if (reg2 && REGNO (reg2) == REGNO (reg))
4639     {
4640       pattern = single_set (insn);
4641       if (pattern
4642           && REG_P (SET_DEST (pattern))
4643           && REGNO (reg) == REGNO (SET_DEST (pattern)))
4644         *set = pattern;
4645       return 0;
4646     }
4647   if (!CALL_P (insn))
4648     {
4649       /* We don't use rtx_equal_p because we don't care if the mode is
4650          different.  */
4651       pattern = single_set (insn);
4652       if (pattern
4653           && REG_P (SET_DEST (pattern))
4654           && REGNO (reg) == REGNO (SET_DEST (pattern)))
4655         {
4656           rtx par, part;
4657           int i;
4658
4659           *set = pattern;
4660           par = PATTERN (insn);
4661           if (GET_CODE (par) == PARALLEL)
4662             for (i = XVECLEN (par, 0) - 1; i >= 0; i--)
4663               {
4664                 part = XVECEXP (par, 0, i);
4665                 if (GET_CODE (part) != SET && reg_mentioned_p (reg, part))
4666                   return 1;
4667               }
4668           return reg_mentioned_p (reg, SET_SRC (pattern));
4669         }
4670
4671       return 1;
4672     }
4673
4674   pattern = PATTERN (insn);
4675
4676   if (GET_CODE (pattern) == PARALLEL)
4677     {
4678       int i;
4679
4680       for (i = XVECLEN (pattern, 0) - 1; i >= 1; i--)
4681         if (reg_mentioned_p (reg, XVECEXP (pattern, 0, i)))
4682           return 1;
4683       pattern = XVECEXP (pattern, 0, 0);
4684     }
4685
4686   if (GET_CODE (pattern) == SET)
4687     {
4688       if (reg_mentioned_p (reg, SET_DEST (pattern)))
4689         {
4690           /* We don't use rtx_equal_p, because we don't care if the
4691              mode is different.  */
4692           if (!REG_P (SET_DEST (pattern))
4693               || REGNO (reg) != REGNO (SET_DEST (pattern)))
4694             return 1;
4695
4696           *set = pattern;
4697         }
4698
4699       pattern = SET_SRC (pattern);
4700     }
4701
4702   if (GET_CODE (pattern) != CALL
4703       || !MEM_P (XEXP (pattern, 0))
4704       || ! rtx_equal_p (reg, XEXP (XEXP (pattern, 0), 0)))
4705     return 1;
4706
4707   return 0;
4708 }
4709
4710 /* Given a X, a pattern of an insn or a part of it, return a mask of used
4711    general registers.  Bits 0..15 mean that the respective registers
4712    are used as inputs in the instruction.  Bits 16..31 mean that the
4713    registers 0..15, respectively, are used as outputs, or are clobbered.
4714    IS_DEST should be set to 16 if X is the destination of a SET, else to 0.  */
4715 int
4716 regs_used (rtx x, int is_dest)
4717 {
4718   enum rtx_code code;
4719   const char *fmt;
4720   int i, used = 0;
4721
4722   if (! x)
4723     return used;
4724   code = GET_CODE (x);
4725   switch (code)
4726     {
4727     case REG:
4728       if (REGNO (x) < 16)
4729         return (((1 << HARD_REGNO_NREGS (0, GET_MODE (x))) - 1)
4730                 << (REGNO (x) + is_dest));
4731       return 0;
4732     case SUBREG:
4733       {
4734         rtx y = SUBREG_REG (x);
4735
4736         if (!REG_P (y))
4737           break;
4738         if (REGNO (y) < 16)
4739           return (((1 << HARD_REGNO_NREGS (0, GET_MODE (x))) - 1)
4740                   << (REGNO (y) +
4741                       subreg_regno_offset (REGNO (y),
4742                                            GET_MODE (y),
4743                                            SUBREG_BYTE (x),
4744                                            GET_MODE (x)) + is_dest));
4745         return 0;
4746       }
4747     case SET:
4748       return regs_used (SET_SRC (x), 0) | regs_used (SET_DEST (x), 16);
4749     case RETURN:
4750       /* If there was a return value, it must have been indicated with USE.  */
4751       return 0x00ffff00;
4752     case CLOBBER:
4753       is_dest = 1;
4754       break;
4755     case MEM:
4756       is_dest = 0;
4757       break;
4758     case CALL:
4759       used |= 0x00ff00f0;
4760       break;
4761     default:
4762       break;
4763     }
4764
4765   fmt = GET_RTX_FORMAT (code);
4766
4767   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4768     {
4769       if (fmt[i] == 'E')
4770         {
4771           register int j;
4772           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
4773             used |= regs_used (XVECEXP (x, i, j), is_dest);
4774         }
4775       else if (fmt[i] == 'e')
4776         used |= regs_used (XEXP (x, i), is_dest);
4777     }
4778   return used;
4779 }
4780
4781 /* Create an instruction that prevents redirection of a conditional branch
4782    to the destination of the JUMP with address ADDR.
4783    If the branch needs to be implemented as an indirect jump, try to find
4784    a scratch register for it.
4785    If NEED_BLOCK is 0, don't do anything unless we need a scratch register.
4786    If any preceding insn that doesn't fit into a delay slot is good enough,
4787    pass 1.  Pass 2 if a definite blocking insn is needed.
4788    -1 is used internally to avoid deep recursion.
4789    If a blocking instruction is made or recognized, return it.  */
4790
4791 static rtx
4792 gen_block_redirect (rtx jump, int addr, int need_block)
4793 {
4794   int dead = 0;
4795   rtx prev = prev_nonnote_insn (jump);
4796   rtx dest;
4797
4798   /* First, check if we already have an instruction that satisfies our need.  */
4799   if (prev && NONJUMP_INSN_P (prev) && ! INSN_DELETED_P (prev))
4800     {
4801       if (INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch)
4802         return prev;
4803       if (GET_CODE (PATTERN (prev)) == USE
4804           || GET_CODE (PATTERN (prev)) == CLOBBER
4805           || get_attr_in_delay_slot (prev) == IN_DELAY_SLOT_YES)
4806         prev = jump;
4807       else if ((need_block &= ~1) < 0)
4808         return prev;
4809       else if (recog_memoized (prev) == CODE_FOR_block_branch_redirect)
4810         need_block = 0;
4811     }
4812   if (GET_CODE (PATTERN (jump)) == RETURN)
4813     {
4814       if (! need_block)
4815         return prev;
4816       /* Reorg even does nasty things with return insns that cause branches
4817          to go out of range - see find_end_label and callers.  */
4818       return emit_insn_before (gen_block_branch_redirect (const0_rtx) , jump);
4819     }
4820   /* We can't use JUMP_LABEL here because it might be undefined
4821      when not optimizing.  */
4822   dest = XEXP (SET_SRC (PATTERN (jump)), 0);
4823   /* If the branch is out of range, try to find a scratch register for it.  */
4824   if (optimize
4825       && (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092
4826           > 4092 + 4098))
4827     {
4828       rtx scan;
4829       /* Don't look for the stack pointer as a scratch register,
4830          it would cause trouble if an interrupt occurred.  */
4831       unsigned attempt = 0x7fff, used;
4832       int jump_left = flag_expensive_optimizations + 1;
4833
4834       /* It is likely that the most recent eligible instruction is wanted for
4835          the delay slot.  Therefore, find out which registers it uses, and
4836          try to avoid using them.  */
4837
4838       for (scan = jump; (scan = PREV_INSN (scan)); )
4839         {
4840           enum rtx_code code;
4841
4842           if (INSN_DELETED_P (scan))
4843             continue;
4844           code = GET_CODE (scan);
4845           if (code == CODE_LABEL || code == JUMP_INSN)
4846             break;
4847           if (code == INSN
4848               && GET_CODE (PATTERN (scan)) != USE
4849               && GET_CODE (PATTERN (scan)) != CLOBBER
4850               && get_attr_in_delay_slot (scan) == IN_DELAY_SLOT_YES)
4851             {
4852               attempt &= ~regs_used (PATTERN (scan), 0);
4853               break;
4854             }
4855         }
4856       for (used = dead = 0, scan = JUMP_LABEL (jump);
4857            (scan = NEXT_INSN (scan)); )
4858         {
4859           enum rtx_code code;
4860
4861           if (INSN_DELETED_P (scan))
4862             continue;
4863           code = GET_CODE (scan);
4864           if (INSN_P (scan))
4865             {
4866               used |= regs_used (PATTERN (scan), 0);
4867               if (code == CALL_INSN)
4868                 used |= regs_used (CALL_INSN_FUNCTION_USAGE (scan), 0);
4869               dead |= (used >> 16) & ~used;
4870               if (dead & attempt)
4871                 {
4872                   dead &= attempt;
4873                   break;
4874                 }
4875               if (code == JUMP_INSN)
4876                 {
4877                   if (jump_left-- && simplejump_p (scan))
4878                     scan = JUMP_LABEL (scan);
4879                   else
4880                     break;
4881                 }
4882             }
4883         }
4884       /* Mask out the stack pointer again, in case it was
4885          the only 'free' register we have found.  */
4886       dead &= 0x7fff;
4887     }
4888   /* If the immediate destination is still in range, check for possible
4889      threading with a jump beyond the delay slot insn.
4890      Don't check if we are called recursively; the jump has been or will be
4891      checked in a different invocation then.  */
4892
4893   else if (optimize && need_block >= 0)
4894     {
4895       rtx next = next_active_insn (next_active_insn (dest));
4896       if (next && JUMP_P (next)
4897           && GET_CODE (PATTERN (next)) == SET
4898           && recog_memoized (next) == CODE_FOR_jump_compact)
4899         {
4900           dest = JUMP_LABEL (next);
4901           if (dest
4902               && (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092
4903                   > 4092 + 4098))
4904             gen_block_redirect (next, INSN_ADDRESSES (INSN_UID (next)), -1);
4905         }
4906     }
4907
4908   if (dead)
4909     {
4910       rtx reg = gen_rtx_REG (SImode, exact_log2 (dead & -dead));
4911
4912       /* It would be nice if we could convert the jump into an indirect
4913          jump / far branch right now, and thus exposing all constituent
4914          instructions to further optimization.  However, reorg uses
4915          simplejump_p to determine if there is an unconditional jump where
4916          it should try to schedule instructions from the target of the
4917          branch; simplejump_p fails for indirect jumps even if they have
4918          a JUMP_LABEL.  */
4919       rtx insn = emit_insn_before (gen_indirect_jump_scratch
4920                                    (reg, GEN_INT (INSN_UID (JUMP_LABEL (jump))))
4921                                    , jump);
4922       /* ??? We would like this to have the scope of the jump, but that
4923          scope will change when a delay slot insn of an inner scope is added.
4924          Hence, after delay slot scheduling, we'll have to expect
4925          NOTE_INSN_BLOCK_END notes between the indirect_jump_scratch and
4926          the jump.  */
4927
4928       INSN_LOCATOR (insn) = INSN_LOCATOR (jump);
4929       INSN_CODE (insn) = CODE_FOR_indirect_jump_scratch;
4930       return insn;
4931     }
4932   else if (need_block)
4933     /* We can't use JUMP_LABEL here because it might be undefined
4934        when not optimizing.  */
4935     return emit_insn_before (gen_block_branch_redirect
4936                       (GEN_INT (INSN_UID (XEXP (SET_SRC (PATTERN (jump)), 0))))
4937                       , jump);
4938   return prev;
4939 }
4940
4941 #define CONDJUMP_MIN -252
4942 #define CONDJUMP_MAX 262
4943 struct far_branch
4944 {
4945   /* A label (to be placed) in front of the jump
4946      that jumps to our ultimate destination.  */
4947   rtx near_label;
4948   /* Where we are going to insert it if we cannot move the jump any farther,
4949      or the jump itself if we have picked up an existing jump.  */
4950   rtx insert_place;
4951   /* The ultimate destination.  */
4952   rtx far_label;
4953   struct far_branch *prev;
4954   /* If the branch has already been created, its address;
4955      else the address of its first prospective user.  */
4956   int address;
4957 };
4958
4959 static void gen_far_branch (struct far_branch *);
4960 enum mdep_reorg_phase_e mdep_reorg_phase;
4961 static void
4962 gen_far_branch (struct far_branch *bp)
4963 {
4964   rtx insn = bp->insert_place;
4965   rtx jump;
4966   rtx label = gen_label_rtx ();
4967   int ok;
4968
4969   emit_label_after (label, insn);
4970   if (bp->far_label)
4971     {
4972       jump = emit_jump_insn_after (gen_jump (bp->far_label), insn);
4973       LABEL_NUSES (bp->far_label)++;
4974     }
4975   else
4976     jump = emit_jump_insn_after (gen_return (), insn);
4977   /* Emit a barrier so that reorg knows that any following instructions
4978      are not reachable via a fall-through path.
4979      But don't do this when not optimizing, since we wouldn't suppress the
4980      alignment for the barrier then, and could end up with out-of-range
4981      pc-relative loads.  */
4982   if (optimize)
4983     emit_barrier_after (jump);
4984   emit_label_after (bp->near_label, insn);
4985   JUMP_LABEL (jump) = bp->far_label;
4986   ok = invert_jump (insn, label, 1);
4987   gcc_assert (ok);
4988
4989   /* If we are branching around a jump (rather than a return), prevent
4990      reorg from using an insn from the jump target as the delay slot insn -
4991      when reorg did this, it pessimized code (we rather hide the delay slot)
4992      and it could cause branches to go out of range.  */
4993   if (bp->far_label)
4994     (emit_insn_after
4995      (gen_stuff_delay_slot
4996       (GEN_INT (INSN_UID (XEXP (SET_SRC (PATTERN (jump)), 0))),
4997        GEN_INT (recog_memoized (insn) == CODE_FOR_branch_false)),
4998       insn));
4999   /* Prevent reorg from undoing our splits.  */
5000   gen_block_redirect (jump, bp->address += 2, 2);
5001 }
5002
5003 /* Fix up ADDR_DIFF_VECs.  */
5004 void
5005 fixup_addr_diff_vecs (rtx first)
5006 {
5007   rtx insn;
5008
5009   for (insn = first; insn; insn = NEXT_INSN (insn))
5010     {
5011       rtx vec_lab, pat, prev, prevpat, x, braf_label;
5012
5013       if (!JUMP_P (insn)
5014           || GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
5015         continue;
5016       pat = PATTERN (insn);
5017       vec_lab = XEXP (XEXP (pat, 0), 0);
5018
5019       /* Search the matching casesi_jump_2.  */
5020       for (prev = vec_lab; ; prev = PREV_INSN (prev))
5021         {
5022           if (!JUMP_P (prev))
5023             continue;
5024           prevpat = PATTERN (prev);
5025           if (GET_CODE (prevpat) != PARALLEL || XVECLEN (prevpat, 0) != 2)
5026             continue;
5027           x = XVECEXP (prevpat, 0, 1);
5028           if (GET_CODE (x) != USE)
5029             continue;
5030           x = XEXP (x, 0);
5031           if (GET_CODE (x) == LABEL_REF && XEXP (x, 0) == vec_lab)
5032             break;
5033         }
5034       /* FIXME: This is a bug in the optimizer, but it seems harmless
5035          to just avoid panicing.  */
5036       if (!prev)
5037         continue;
5038
5039       /* Emit the reference label of the braf where it belongs, right after
5040          the casesi_jump_2 (i.e. braf).  */
5041       braf_label = XEXP (XEXP (SET_SRC (XVECEXP (prevpat, 0, 0)), 1), 0);
5042       emit_label_after (braf_label, prev);
5043
5044       /* Fix up the ADDR_DIF_VEC to be relative
5045          to the reference address of the braf.  */
5046       XEXP (XEXP (pat, 0), 0) = braf_label;
5047     }
5048 }
5049
5050 /* BARRIER_OR_LABEL is either a BARRIER or a CODE_LABEL immediately following
5051    a barrier.  Return the base 2 logarithm of the desired alignment.  */
5052 int
5053 barrier_align (rtx barrier_or_label)
5054 {
5055   rtx next = next_real_insn (barrier_or_label), pat, prev;
5056   int slot, credit, jump_to_next = 0;
5057
5058   if (! next)
5059     return 0;
5060
5061   pat = PATTERN (next);
5062
5063   if (GET_CODE (pat) == ADDR_DIFF_VEC)
5064     return 2;
5065
5066   if (GET_CODE (pat) == UNSPEC_VOLATILE && XINT (pat, 1) == UNSPECV_ALIGN)
5067     /* This is a barrier in front of a constant table.  */
5068     return 0;
5069
5070   prev = prev_real_insn (barrier_or_label);
5071   if (GET_CODE (PATTERN (prev)) == ADDR_DIFF_VEC)
5072     {
5073       pat = PATTERN (prev);
5074       /* If this is a very small table, we want to keep the alignment after
5075          the table to the minimum for proper code alignment.  */
5076       return ((TARGET_SMALLCODE
5077                || ((unsigned) XVECLEN (pat, 1) * GET_MODE_SIZE (GET_MODE (pat))
5078                    <= (unsigned) 1 << (CACHE_LOG - 2)))
5079               ? 1 << TARGET_SHMEDIA : align_jumps_log);
5080     }
5081
5082   if (TARGET_SMALLCODE)
5083     return 0;
5084
5085   if (! TARGET_SH2 || ! optimize)
5086     return align_jumps_log;
5087
5088   /* When fixing up pcloads, a constant table might be inserted just before
5089      the basic block that ends with the barrier.  Thus, we can't trust the
5090      instruction lengths before that.  */
5091   if (mdep_reorg_phase > SH_FIXUP_PCLOAD)
5092     {
5093       /* Check if there is an immediately preceding branch to the insn beyond
5094          the barrier.  We must weight the cost of discarding useful information
5095          from the current cache line when executing this branch and there is
5096          an alignment, against that of fetching unneeded insn in front of the
5097          branch target when there is no alignment.  */
5098
5099       /* There are two delay_slot cases to consider.  One is the simple case
5100          where the preceding branch is to the insn beyond the barrier (simple
5101          delay slot filling), and the other is where the preceding branch has
5102          a delay slot that is a duplicate of the insn after the barrier
5103          (fill_eager_delay_slots) and the branch is to the insn after the insn
5104          after the barrier.  */
5105
5106       /* PREV is presumed to be the JUMP_INSN for the barrier under
5107          investigation.  Skip to the insn before it.  */
5108       prev = prev_real_insn (prev);
5109
5110       for (slot = 2, credit = (1 << (CACHE_LOG - 2)) + 2;
5111            credit >= 0 && prev && NONJUMP_INSN_P (prev);
5112            prev = prev_real_insn (prev))
5113         {
5114           jump_to_next = 0;
5115           if (GET_CODE (PATTERN (prev)) == USE
5116               || GET_CODE (PATTERN (prev)) == CLOBBER)
5117             continue;
5118           if (GET_CODE (PATTERN (prev)) == SEQUENCE)
5119             {
5120               prev = XVECEXP (PATTERN (prev), 0, 1);
5121               if (INSN_UID (prev) == INSN_UID (next))
5122                 {
5123                   /* Delay slot was filled with insn at jump target.  */
5124                   jump_to_next = 1;
5125                   continue;
5126                 }
5127             }
5128
5129           if (slot &&
5130               get_attr_in_delay_slot (prev) == IN_DELAY_SLOT_YES)
5131             slot = 0;
5132           credit -= get_attr_length (prev);
5133         }
5134       if (prev
5135           && JUMP_P (prev)
5136           && JUMP_LABEL (prev))
5137         {
5138           rtx x;
5139           if (jump_to_next
5140               || next_real_insn (JUMP_LABEL (prev)) == next
5141               /* If relax_delay_slots() decides NEXT was redundant
5142                  with some previous instruction, it will have
5143                  redirected PREV's jump to the following insn.  */
5144               || JUMP_LABEL (prev) == next_nonnote_insn (next)
5145               /* There is no upper bound on redundant instructions
5146                  that might have been skipped, but we must not put an
5147                  alignment where none had been before.  */
5148               || (x = (NEXT_INSN (NEXT_INSN (PREV_INSN (prev)))),
5149                   (INSN_P (x)
5150                    && (INSN_CODE (x) == CODE_FOR_block_branch_redirect
5151                        || INSN_CODE (x) == CODE_FOR_indirect_jump_scratch
5152                        || INSN_CODE (x) == CODE_FOR_stuff_delay_slot))))
5153             {
5154               rtx pat = PATTERN (prev);
5155               if (GET_CODE (pat) == PARALLEL)
5156                 pat = XVECEXP (pat, 0, 0);
5157               if (credit - slot >= (GET_CODE (SET_SRC (pat)) == PC ? 2 : 0))
5158                 return 0;
5159             }
5160         }
5161     }
5162
5163   return align_jumps_log;
5164 }
5165
5166 /* If we are inside a phony loop, almost any kind of label can turn up as the
5167    first one in the loop.  Aligning a braf label causes incorrect switch
5168    destination addresses; we can detect braf labels because they are
5169    followed by a BARRIER.
5170    Applying loop alignment to small constant or switch tables is a waste
5171    of space, so we suppress this too.  */
5172 int
5173 sh_loop_align (rtx label)
5174 {
5175   rtx next = label;
5176
5177   do
5178     next = next_nonnote_insn (next);
5179   while (next && LABEL_P (next));
5180
5181   if (! next
5182       || ! INSN_P (next)
5183       || GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC
5184       || recog_memoized (next) == CODE_FOR_consttable_2)
5185     return 0;
5186
5187   return align_loops_log;
5188 }
5189
5190 /* Do a final pass over the function, just before delayed branch
5191    scheduling.  */
5192
5193 static void
5194 sh_reorg (void)
5195 {
5196   rtx first, insn, mova = NULL_RTX;
5197   int num_mova;
5198   rtx r0_rtx = gen_rtx_REG (Pmode, 0);
5199   rtx r0_inc_rtx = gen_rtx_POST_INC (Pmode, r0_rtx);
5200
5201   first = get_insns ();
5202   max_labelno_before_reorg = max_label_num ();
5203
5204   /* We must split call insns before introducing `mova's.  If we're
5205      optimizing, they'll have already been split.  Otherwise, make
5206      sure we don't split them too late.  */
5207   if (! optimize)
5208     split_all_insns_noflow ();
5209
5210   if (TARGET_SHMEDIA)
5211     return;
5212
5213   /* If relaxing, generate pseudo-ops to associate function calls with
5214      the symbols they call.  It does no harm to not generate these
5215      pseudo-ops.  However, when we can generate them, it enables to
5216      linker to potentially relax the jsr to a bsr, and eliminate the
5217      register load and, possibly, the constant pool entry.  */
5218
5219   mdep_reorg_phase = SH_INSERT_USES_LABELS;
5220   if (TARGET_RELAX)
5221     {
5222       /* Remove all REG_LABEL_OPERAND notes.  We want to use them for our
5223          own purposes.  This works because none of the remaining passes
5224          need to look at them.
5225
5226          ??? But it may break in the future.  We should use a machine
5227          dependent REG_NOTE, or some other approach entirely.  */
5228       for (insn = first; insn; insn = NEXT_INSN (insn))
5229         {
5230           if (INSN_P (insn))
5231             {
5232               rtx note;
5233
5234               while ((note = find_reg_note (insn, REG_LABEL_OPERAND,
5235                                             NULL_RTX)) != 0)
5236                 remove_note (insn, note);
5237             }
5238         }
5239
5240       for (insn = first; insn; insn = NEXT_INSN (insn))
5241         {
5242           rtx pattern, reg, link, set, scan, dies, label;
5243           int rescan = 0, foundinsn = 0;
5244
5245           if (CALL_P (insn))
5246             {
5247               pattern = PATTERN (insn);
5248
5249               if (GET_CODE (pattern) == PARALLEL)
5250                 pattern = XVECEXP (pattern, 0, 0);
5251               if (GET_CODE (pattern) == SET)
5252                 pattern = SET_SRC (pattern);
5253
5254               if (GET_CODE (pattern) != CALL
5255                   || !MEM_P (XEXP (pattern, 0)))
5256                 continue;
5257
5258               reg = XEXP (XEXP (pattern, 0), 0);
5259             }
5260           else
5261             {
5262               reg = sfunc_uses_reg (insn);
5263               if (! reg)
5264                 continue;
5265             }
5266
5267           if (!REG_P (reg))
5268             continue;
5269
5270           /* Try scanning backward to find where the register is set.  */
5271           link = NULL;
5272           for (scan = PREV_INSN (insn);
5273                scan && !LABEL_P (scan);
5274                scan = PREV_INSN (scan))
5275             {
5276               if (! INSN_P (scan))
5277                 continue;
5278
5279               if (! reg_mentioned_p (reg, scan))
5280                 continue;
5281
5282               if (noncall_uses_reg (reg, scan, &set))
5283                 break;
5284
5285               if (set)
5286                 {
5287                   link = scan;
5288                   break;
5289                 }
5290             }
5291
5292           if (! link)
5293             continue;
5294
5295           /* The register is set at LINK.  */
5296
5297           /* We can only optimize the function call if the register is
5298              being set to a symbol.  In theory, we could sometimes
5299              optimize calls to a constant location, but the assembler
5300              and linker do not support that at present.  */
5301           if (GET_CODE (SET_SRC (set)) != SYMBOL_REF
5302               && GET_CODE (SET_SRC (set)) != LABEL_REF)
5303             continue;
5304
5305           /* Scan forward from LINK to the place where REG dies, and
5306              make sure that the only insns which use REG are
5307              themselves function calls.  */
5308
5309           /* ??? This doesn't work for call targets that were allocated
5310              by reload, since there may not be a REG_DEAD note for the
5311              register.  */
5312
5313           dies = NULL_RTX;
5314           for (scan = NEXT_INSN (link); scan; scan = NEXT_INSN (scan))
5315             {
5316               rtx scanset;
5317
5318               /* Don't try to trace forward past a CODE_LABEL if we haven't
5319                  seen INSN yet.  Ordinarily, we will only find the setting insn
5320                  if it is in the same basic block.  However,
5321                  cross-jumping can insert code labels in between the load and
5322                  the call, and can result in situations where a single call
5323                  insn may have two targets depending on where we came from.  */
5324
5325               if (LABEL_P (scan) && ! foundinsn)
5326                 break;
5327
5328               if (! INSN_P (scan))
5329                 continue;
5330
5331               /* Don't try to trace forward past a JUMP.  To optimize
5332                  safely, we would have to check that all the
5333                  instructions at the jump destination did not use REG.  */
5334
5335               if (JUMP_P (scan))
5336                 break;
5337
5338               if (! reg_mentioned_p (reg, scan))
5339                 continue;
5340
5341               if (noncall_uses_reg (reg, scan, &scanset))
5342                 break;
5343
5344               if (scan == insn)
5345                 foundinsn = 1;
5346
5347               if (scan != insn
5348                   && (CALL_P (scan) || sfunc_uses_reg (scan)))
5349                 {
5350                   /* There is a function call to this register other
5351                      than the one we are checking.  If we optimize
5352                      this call, we need to rescan again below.  */
5353                   rescan = 1;
5354                 }
5355
5356               /* ??? We shouldn't have to worry about SCANSET here.
5357                  We should just be able to check for a REG_DEAD note
5358                  on a function call.  However, the REG_DEAD notes are
5359                  apparently not dependable around libcalls; c-torture
5360                  execute/920501-2 is a test case.  If SCANSET is set,
5361                  then this insn sets the register, so it must have
5362                  died earlier.  Unfortunately, this will only handle
5363                  the cases in which the register is, in fact, set in a
5364                  later insn.  */
5365
5366               /* ??? We shouldn't have to use FOUNDINSN here.
5367                  This dates back to when we used LOG_LINKS to find
5368                  the most recent insn which sets the register.  */
5369
5370               if (foundinsn
5371                   && (scanset
5372                       || find_reg_note (scan, REG_DEAD, reg)))
5373                 {
5374                   dies = scan;
5375                   break;
5376                 }
5377             }
5378
5379           if (! dies)
5380             {
5381               /* Either there was a branch, or some insn used REG
5382                  other than as a function call address.  */
5383               continue;
5384             }
5385
5386           /* Create a code label, and put it in a REG_LABEL_OPERAND note
5387              on the insn which sets the register, and on each call insn
5388              which uses the register.  In final_prescan_insn we look for
5389              the REG_LABEL_OPERAND notes, and output the appropriate label
5390              or pseudo-op.  */
5391
5392           label = gen_label_rtx ();
5393           add_reg_note (link, REG_LABEL_OPERAND, label);
5394           add_reg_note (insn, REG_LABEL_OPERAND, label);
5395           if (rescan)
5396             {
5397               scan = link;
5398               do
5399                 {
5400                   rtx reg2;
5401
5402                   scan = NEXT_INSN (scan);
5403                   if (scan != insn
5404                       && ((CALL_P (scan)
5405                            && reg_mentioned_p (reg, scan))
5406                           || ((reg2 = sfunc_uses_reg (scan))
5407                               && REGNO (reg2) == REGNO (reg))))
5408                     add_reg_note (scan, REG_LABEL_OPERAND, label);
5409                 }
5410               while (scan != dies);
5411             }
5412         }
5413     }
5414
5415   if (TARGET_SH2)
5416     fixup_addr_diff_vecs (first);
5417
5418   if (optimize)
5419     {
5420       mdep_reorg_phase = SH_SHORTEN_BRANCHES0;
5421       shorten_branches (first);
5422     }
5423
5424   /* Scan the function looking for move instructions which have to be
5425      changed to pc-relative loads and insert the literal tables.  */
5426   label_ref_list_pool = create_alloc_pool ("label references list",
5427                                            sizeof (struct label_ref_list_d),
5428                                            30);
5429   mdep_reorg_phase = SH_FIXUP_PCLOAD;
5430   for (insn = first, num_mova = 0; insn; insn = NEXT_INSN (insn))
5431     {
5432       if (mova_p (insn))
5433         {
5434           /* ??? basic block reordering can move a switch table dispatch
5435              below the switch table.  Check if that has happened.
5436              We only have the addresses available when optimizing; but then,
5437              this check shouldn't be needed when not optimizing.  */
5438           if (!untangle_mova (&num_mova, &mova, insn))
5439             {
5440               insn = mova;
5441               num_mova = 0;
5442             }
5443         }
5444       else if (JUMP_P (insn)
5445                && GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
5446                && num_mova
5447                /* ??? loop invariant motion can also move a mova out of a
5448                   loop.  Since loop does this code motion anyway, maybe we
5449                   should wrap UNSPEC_MOVA into a CONST, so that reload can
5450                   move it back.  */
5451                && ((num_mova > 1
5452                     && GET_MODE (prev_nonnote_insn (insn)) == VOIDmode)
5453                    || (prev_nonnote_insn (insn)
5454                        == XEXP (MOVA_LABELREF (mova), 0))))
5455         {
5456           rtx scan;
5457           int total;
5458
5459           num_mova--;
5460
5461           /* Some code might have been inserted between the mova and
5462              its ADDR_DIFF_VEC.  Check if the mova is still in range.  */
5463           for (scan = mova, total = 0; scan != insn; scan = NEXT_INSN (scan))
5464             total += get_attr_length (scan);
5465
5466           /* range of mova is 1020, add 4 because pc counts from address of
5467              second instruction after this one, subtract 2 in case pc is 2
5468              byte aligned.  Possible alignment needed for the ADDR_DIFF_VEC
5469              cancels out with alignment effects of the mova itself.  */
5470           if (total > 1022)
5471             {
5472               /* Change the mova into a load, and restart scanning
5473                  there.  broken_move will then return true for mova.  */
5474               fixup_mova (mova);
5475               insn = mova;
5476             }
5477         }
5478       if (broken_move (insn)
5479           || (NONJUMP_INSN_P (insn)
5480               && recog_memoized (insn) == CODE_FOR_casesi_worker_2))
5481         {
5482           rtx scan;
5483           /* Scan ahead looking for a barrier to stick the constant table
5484              behind.  */
5485           rtx barrier = find_barrier (num_mova, mova, insn);
5486           rtx last_float_move = NULL_RTX, last_float = 0, *last_float_addr = NULL;
5487           int need_aligned_label = 0;
5488
5489           if (num_mova && ! mova_p (mova))
5490             {
5491               /* find_barrier had to change the first mova into a
5492                  pcload; thus, we have to start with this new pcload.  */
5493               insn = mova;
5494               num_mova = 0;
5495             }
5496           /* Now find all the moves between the points and modify them.  */
5497           for (scan = insn; scan != barrier; scan = NEXT_INSN (scan))
5498             {
5499               if (LABEL_P (scan))
5500                 last_float = 0;
5501               if (NONJUMP_INSN_P (scan)
5502                   && recog_memoized (scan) == CODE_FOR_casesi_worker_2)
5503                 need_aligned_label = 1;
5504               if (broken_move (scan))
5505                 {
5506                   rtx *patp = &PATTERN (scan), pat = *patp;
5507                   rtx src, dst;
5508                   rtx lab;
5509                   rtx newsrc;
5510                   enum machine_mode mode;
5511
5512                   if (GET_CODE (pat) == PARALLEL)
5513                     patp = &XVECEXP (pat, 0, 0), pat = *patp;
5514                   src = SET_SRC (pat);
5515                   dst = SET_DEST (pat);
5516                   mode = GET_MODE (dst);
5517
5518                   if (mode == SImode && hi_const (src)
5519                       && REGNO (dst) != FPUL_REG)
5520                     {
5521                       int offset = 0;
5522
5523                       mode = HImode;
5524                       while (GET_CODE (dst) == SUBREG)
5525                         {
5526                           offset += subreg_regno_offset (REGNO (SUBREG_REG (dst)),
5527                                                          GET_MODE (SUBREG_REG (dst)),
5528                                                          SUBREG_BYTE (dst),
5529                                                          GET_MODE (dst));
5530                           dst = SUBREG_REG (dst);
5531                         }
5532                       dst = gen_rtx_REG (HImode, REGNO (dst) + offset);
5533                     }
5534                   if (REG_P (dst) && FP_ANY_REGISTER_P (REGNO (dst)))
5535                     {
5536                       /* This must be an insn that clobbers r0.  */
5537                       rtx *clobberp = &XVECEXP (PATTERN (scan), 0,
5538                                                 XVECLEN (PATTERN (scan), 0)
5539                                                 - 1);
5540                       rtx clobber = *clobberp;
5541
5542                       gcc_assert (GET_CODE (clobber) == CLOBBER
5543                                   && rtx_equal_p (XEXP (clobber, 0), r0_rtx));
5544
5545                       if (last_float
5546                           && reg_set_between_p (r0_rtx, last_float_move, scan))
5547                         last_float = 0;
5548                       if (last_float
5549                           && TARGET_SHCOMPACT
5550                           && GET_MODE_SIZE (mode) != 4
5551                           && GET_MODE_SIZE (GET_MODE (last_float)) == 4)
5552                         last_float = 0;
5553                       lab = add_constant (src, mode, last_float);
5554                       if (lab)
5555                         emit_insn_before (gen_mova (lab), scan);
5556                       else
5557                         {
5558                           /* There will be a REG_UNUSED note for r0 on
5559                              LAST_FLOAT_MOVE; we have to change it to REG_INC,
5560                              lest reorg:mark_target_live_regs will not
5561                              consider r0 to be used, and we end up with delay
5562                              slot insn in front of SCAN that clobbers r0.  */
5563                           rtx note
5564                             = find_regno_note (last_float_move, REG_UNUSED, 0);
5565
5566                           /* If we are not optimizing, then there may not be
5567                              a note.  */
5568                           if (note)
5569                             PUT_REG_NOTE_KIND (note, REG_INC);
5570
5571                           *last_float_addr = r0_inc_rtx;
5572                         }
5573                       last_float_move = scan;
5574                       last_float = src;
5575                       newsrc = gen_const_mem (mode,
5576                                         (((TARGET_SH4 && ! TARGET_FMOVD)
5577                                           || REGNO (dst) == FPUL_REG)
5578                                          ? r0_inc_rtx
5579                                          : r0_rtx));
5580                       last_float_addr = &XEXP (newsrc, 0);
5581
5582                       /* Remove the clobber of r0.  */
5583                       *clobberp = gen_rtx_CLOBBER (GET_MODE (clobber),
5584                                                    gen_rtx_SCRATCH (Pmode));
5585                     }
5586                   /* This is a mova needing a label.  Create it.  */
5587                   else if (GET_CODE (src) == UNSPEC
5588                            && XINT (src, 1) == UNSPEC_MOVA
5589                            && GET_CODE (XVECEXP (src, 0, 0)) == CONST)
5590                     {
5591                       lab = add_constant (XVECEXP (src, 0, 0), mode, 0);
5592                       newsrc = gen_rtx_LABEL_REF (VOIDmode, lab);
5593                       newsrc = gen_rtx_UNSPEC (SImode,
5594                                                gen_rtvec (1, newsrc),
5595                                                UNSPEC_MOVA);
5596                     }
5597                   else
5598                     {
5599                       lab = add_constant (src, mode, 0);
5600                       newsrc = gen_rtx_LABEL_REF (VOIDmode, lab);
5601                       newsrc = gen_const_mem (mode, newsrc);
5602                     }
5603                   *patp = gen_rtx_SET (VOIDmode, dst, newsrc);
5604                   INSN_CODE (scan) = -1;
5605                 }
5606             }
5607           dump_table (need_aligned_label ? insn : 0, barrier);
5608           insn = barrier;
5609         }
5610     }
5611   free_alloc_pool (label_ref_list_pool);
5612   for (insn = first; insn; insn = NEXT_INSN (insn))
5613     PUT_MODE (insn, VOIDmode);
5614
5615   mdep_reorg_phase = SH_SHORTEN_BRANCHES1;
5616   INSN_ADDRESSES_FREE ();
5617   split_branches (first);
5618
5619   /* The INSN_REFERENCES_ARE_DELAYED in sh.h is problematic because it
5620      also has an effect on the register that holds the address of the sfunc.
5621      Insert an extra dummy insn in front of each sfunc that pretends to
5622      use this register.  */
5623   if (flag_delayed_branch)
5624     {
5625       for (insn = first; insn; insn = NEXT_INSN (insn))
5626         {
5627           rtx reg = sfunc_uses_reg (insn);
5628
5629           if (! reg)
5630             continue;
5631           emit_insn_before (gen_use_sfunc_addr (reg), insn);
5632         }
5633     }
5634 #if 0
5635   /* fpscr is not actually a user variable, but we pretend it is for the
5636      sake of the previous optimization passes, since we want it handled like
5637      one.  However, we don't have any debugging information for it, so turn
5638      it into a non-user variable now.  */
5639   if (TARGET_SH4)
5640     REG_USERVAR_P (get_fpscr_rtx ()) = 0;
5641 #endif
5642   mdep_reorg_phase = SH_AFTER_MDEP_REORG;
5643 }
5644
5645 int
5646 get_dest_uid (rtx label, int max_uid)
5647 {
5648   rtx dest = next_real_insn (label);
5649   int dest_uid;
5650   if (! dest)
5651     /* This can happen for an undefined label.  */
5652     return 0;
5653   dest_uid = INSN_UID (dest);
5654   /* If this is a newly created branch redirection blocking instruction,
5655      we cannot index the branch_uid or insn_addresses arrays with its
5656      uid.  But then, we won't need to, because the actual destination is
5657      the following branch.  */
5658   while (dest_uid >= max_uid)
5659     {
5660       dest = NEXT_INSN (dest);
5661       dest_uid = INSN_UID (dest);
5662     }
5663   if (JUMP_P (dest) && GET_CODE (PATTERN (dest)) == RETURN)
5664     return 0;
5665   return dest_uid;
5666 }
5667
5668 /* Split condbranches that are out of range.  Also add clobbers for
5669    scratch registers that are needed in far jumps.
5670    We do this before delay slot scheduling, so that it can take our
5671    newly created instructions into account.  It also allows us to
5672    find branches with common targets more easily.  */
5673
5674 static void
5675 split_branches (rtx first)
5676 {
5677   rtx insn;
5678   struct far_branch **uid_branch, *far_branch_list = 0;
5679   int max_uid = get_max_uid ();
5680   int ok;
5681
5682   /* Find out which branches are out of range.  */
5683   shorten_branches (first);
5684
5685   uid_branch = (struct far_branch **) alloca (max_uid * sizeof *uid_branch);
5686   memset ((char *) uid_branch, 0, max_uid * sizeof *uid_branch);
5687
5688   for (insn = first; insn; insn = NEXT_INSN (insn))
5689     if (! INSN_P (insn))
5690       continue;
5691     else if (INSN_DELETED_P (insn))
5692       {
5693         /* Shorten_branches would split this instruction again,
5694            so transform it into a note.  */
5695         SET_INSN_DELETED (insn);
5696       }
5697     else if (JUMP_P (insn)
5698              /* Don't mess with ADDR_DIFF_VEC */
5699              && (GET_CODE (PATTERN (insn)) == SET
5700                  || GET_CODE (PATTERN (insn)) == RETURN))
5701       {
5702         enum attr_type type = get_attr_type (insn);
5703         if (type == TYPE_CBRANCH)
5704           {
5705             rtx next, beyond;
5706
5707             if (get_attr_length (insn) > 4)
5708               {
5709                 rtx src = SET_SRC (PATTERN (insn));
5710                 rtx olabel = XEXP (XEXP (src, 1), 0);
5711                 int addr = INSN_ADDRESSES (INSN_UID (insn));
5712                 rtx label = 0;
5713                 int dest_uid = get_dest_uid (olabel, max_uid);
5714                 struct far_branch *bp = uid_branch[dest_uid];
5715
5716                 /* redirect_jump needs a valid JUMP_LABEL, and it might delete
5717                    the label if the LABEL_NUSES count drops to zero.  There is
5718                    always a jump_optimize pass that sets these values, but it
5719                    proceeds to delete unreferenced code, and then if not
5720                    optimizing, to un-delete the deleted instructions, thus
5721                    leaving labels with too low uses counts.  */
5722                 if (! optimize)
5723                   {
5724                     JUMP_LABEL (insn) = olabel;
5725                     LABEL_NUSES (olabel)++;
5726                   }
5727                 if (! bp)
5728                   {
5729                     bp = (struct far_branch *) alloca (sizeof *bp);
5730                     uid_branch[dest_uid] = bp;
5731                     bp->prev = far_branch_list;
5732                     far_branch_list = bp;
5733                     bp->far_label
5734                       = XEXP (XEXP (SET_SRC (PATTERN (insn)), 1), 0);
5735                     LABEL_NUSES (bp->far_label)++;
5736                   }
5737                 else
5738                   {
5739                     label = bp->near_label;
5740                     if (! label && bp->address - addr >= CONDJUMP_MIN)
5741                       {
5742                         rtx block = bp->insert_place;
5743
5744                         if (GET_CODE (PATTERN (block)) == RETURN)
5745                           block = PREV_INSN (block);
5746                         else
5747                           block = gen_block_redirect (block,
5748                                                       bp->address, 2);
5749                         label = emit_label_after (gen_label_rtx (),
5750                                                   PREV_INSN (block));
5751                         bp->near_label = label;
5752                       }
5753                     else if (label && ! NEXT_INSN (label))
5754                       {
5755                         if (addr + 2 - bp->address <= CONDJUMP_MAX)
5756                           bp->insert_place = insn;
5757                         else
5758                           gen_far_branch (bp);
5759                       }
5760                   }
5761                 if (! label
5762                     || (NEXT_INSN (label) && bp->address - addr < CONDJUMP_MIN))
5763                   {
5764                     bp->near_label = label = gen_label_rtx ();
5765                     bp->insert_place = insn;
5766                     bp->address = addr;
5767                   }
5768                 ok = redirect_jump (insn, label, 0);
5769                 gcc_assert (ok);
5770               }
5771             else
5772               {
5773                 /* get_attr_length (insn) == 2 */
5774                 /* Check if we have a pattern where reorg wants to redirect
5775                    the branch to a label from an unconditional branch that
5776                    is too far away.  */
5777                 /* We can't use JUMP_LABEL here because it might be undefined
5778                    when not optimizing.  */
5779                 /* A syntax error might cause beyond to be NULL_RTX.  */
5780                 beyond
5781                   = next_active_insn (XEXP (XEXP (SET_SRC (PATTERN (insn)), 1),
5782                                             0));
5783
5784                 if (beyond
5785                     && (JUMP_P (beyond)
5786                         || ((beyond = next_active_insn (beyond))
5787                             && JUMP_P (beyond)))
5788                     && GET_CODE (PATTERN (beyond)) == SET
5789                     && recog_memoized (beyond) == CODE_FOR_jump_compact
5790                     && ((INSN_ADDRESSES
5791                          (INSN_UID (XEXP (SET_SRC (PATTERN (beyond)), 0)))
5792                          - INSN_ADDRESSES (INSN_UID (insn)) + (unsigned) 252)
5793                         > 252 + 258 + 2))
5794                   gen_block_redirect (beyond,
5795                                       INSN_ADDRESSES (INSN_UID (beyond)), 1);
5796               }
5797
5798             next = next_active_insn (insn);
5799
5800             if ((JUMP_P (next)
5801                  || ((next = next_active_insn (next))
5802                      && JUMP_P (next)))
5803                 && GET_CODE (PATTERN (next)) == SET
5804                 && recog_memoized (next) == CODE_FOR_jump_compact
5805                 && ((INSN_ADDRESSES
5806                      (INSN_UID (XEXP (SET_SRC (PATTERN (next)), 0)))
5807                      - INSN_ADDRESSES (INSN_UID (insn)) + (unsigned) 252)
5808                     > 252 + 258 + 2))
5809               gen_block_redirect (next, INSN_ADDRESSES (INSN_UID (next)), 1);
5810           }
5811         else if (type == TYPE_JUMP || type == TYPE_RETURN)
5812           {
5813             int addr = INSN_ADDRESSES (INSN_UID (insn));
5814             rtx far_label = 0;
5815             int dest_uid = 0;
5816             struct far_branch *bp;
5817
5818             if (type == TYPE_JUMP)
5819               {
5820                 far_label = XEXP (SET_SRC (PATTERN (insn)), 0);
5821                 dest_uid = get_dest_uid (far_label, max_uid);
5822                 if (! dest_uid)
5823                   {
5824                     /* Parse errors can lead to labels outside
5825                       the insn stream.  */
5826                     if (! NEXT_INSN (far_label))
5827                       continue;
5828
5829                     if (! optimize)
5830                       {
5831                         JUMP_LABEL (insn) = far_label;
5832                         LABEL_NUSES (far_label)++;
5833                       }
5834                     redirect_jump (insn, NULL_RTX, 1);
5835                     far_label = 0;
5836                   }
5837               }
5838             bp = uid_branch[dest_uid];
5839             if (! bp)
5840               {
5841                 bp = (struct far_branch *) alloca (sizeof *bp);
5842                 uid_branch[dest_uid] = bp;
5843                 bp->prev = far_branch_list;
5844                 far_branch_list = bp;
5845                 bp->near_label = 0;
5846                 bp->far_label = far_label;
5847                 if (far_label)
5848                   LABEL_NUSES (far_label)++;
5849               }
5850             else if (bp->near_label && ! NEXT_INSN (bp->near_label))
5851               if (addr - bp->address <= CONDJUMP_MAX)
5852                 emit_label_after (bp->near_label, PREV_INSN (insn));
5853               else
5854                 {
5855                   gen_far_branch (bp);
5856                   bp->near_label = 0;
5857                 }
5858             else
5859               bp->near_label = 0;
5860             bp->address = addr;
5861             bp->insert_place = insn;
5862             if (! far_label)
5863               emit_insn_before (gen_block_branch_redirect (const0_rtx), insn);
5864             else
5865               gen_block_redirect (insn, addr, bp->near_label ? 2 : 0);
5866           }
5867       }
5868   /* Generate all pending far branches,
5869      and free our references to the far labels.  */
5870   while (far_branch_list)
5871     {
5872       if (far_branch_list->near_label
5873           && ! NEXT_INSN (far_branch_list->near_label))
5874         gen_far_branch (far_branch_list);
5875       if (optimize
5876           && far_branch_list->far_label
5877           && ! --LABEL_NUSES (far_branch_list->far_label))
5878         delete_insn (far_branch_list->far_label);
5879       far_branch_list = far_branch_list->prev;
5880     }
5881
5882   /* Instruction length information is no longer valid due to the new
5883      instructions that have been generated.  */
5884   init_insn_lengths ();
5885 }
5886
5887 /* Dump out instruction addresses, which is useful for debugging the
5888    constant pool table stuff.
5889
5890    If relaxing, output the label and pseudo-ops used to link together
5891    calls and the instruction which set the registers.  */
5892
5893 /* ??? The addresses printed by this routine for insns are nonsense for
5894    insns which are inside of a sequence where none of the inner insns have
5895    variable length.  This is because the second pass of shorten_branches
5896    does not bother to update them.  */
5897
5898 void
5899 final_prescan_insn (rtx insn, rtx *opvec ATTRIBUTE_UNUSED,
5900                     int noperands ATTRIBUTE_UNUSED)
5901 {
5902   if (TARGET_DUMPISIZE)
5903     fprintf (asm_out_file, "\n! at %04x\n", INSN_ADDRESSES (INSN_UID (insn)));
5904
5905   if (TARGET_RELAX)
5906     {
5907       rtx note;
5908
5909       note = find_reg_note (insn, REG_LABEL_OPERAND, NULL_RTX);
5910       if (note)
5911         {
5912           rtx pattern;
5913
5914           pattern = PATTERN (insn);
5915           if (GET_CODE (pattern) == PARALLEL)
5916             pattern = XVECEXP (pattern, 0, 0);
5917           switch (GET_CODE (pattern))
5918             {
5919             case SET:
5920               if (GET_CODE (SET_SRC (pattern)) != CALL
5921                   && get_attr_type (insn) != TYPE_SFUNC)
5922                 {
5923                   targetm.asm_out.internal_label
5924                     (asm_out_file, "L", CODE_LABEL_NUMBER (XEXP (note, 0)));
5925                   break;
5926                 }
5927               /* else FALLTHROUGH */
5928             case CALL:
5929               asm_fprintf (asm_out_file, "\t.uses %LL%d\n",
5930                            CODE_LABEL_NUMBER (XEXP (note, 0)));
5931               break;
5932
5933             default:
5934               gcc_unreachable ();
5935             }
5936         }
5937     }
5938 }
5939
5940 /* Dump out any constants accumulated in the final pass.  These will
5941    only be labels.  */
5942
5943 const char *
5944 output_jump_label_table (void)
5945 {
5946   int i;
5947
5948   if (pool_size)
5949     {
5950       fprintf (asm_out_file, "\t.align 2\n");
5951       for (i = 0; i < pool_size; i++)
5952         {
5953           pool_node *p = &pool_vector[i];
5954
5955           (*targetm.asm_out.internal_label) (asm_out_file, "L",
5956                                      CODE_LABEL_NUMBER (p->label));
5957           output_asm_insn (".long       %O0", &p->value);
5958         }
5959       pool_size = 0;
5960     }
5961
5962   return "";
5963 }
5964 \f
5965 /* A full frame looks like:
5966
5967    arg-5
5968    arg-4
5969    [ if current_function_anonymous_args
5970    arg-3
5971    arg-2
5972    arg-1
5973    arg-0 ]
5974    saved-fp
5975    saved-r10
5976    saved-r11
5977    saved-r12
5978    saved-pr
5979    local-n
5980    ..
5981    local-1
5982    local-0        <- fp points here.  */
5983
5984 /* Number of bytes pushed for anonymous args, used to pass information
5985    between expand_prologue and expand_epilogue.  */
5986
5987 /* Adjust the stack by SIZE bytes.  REG holds the rtl of the register to be
5988    adjusted.  If epilogue_p is zero, this is for a prologue; otherwise, it's
5989    for an epilogue and a negative value means that it's for a sibcall
5990    epilogue.  If LIVE_REGS_MASK is nonzero, it points to a HARD_REG_SET of
5991    all the registers that are about to be restored, and hence dead.  */
5992
5993 static void
5994 output_stack_adjust (int size, rtx reg, int epilogue_p,
5995                      HARD_REG_SET *live_regs_mask)
5996 {
5997   rtx (*emit_fn) (rtx) = epilogue_p ? &emit_insn : &frame_insn;
5998   if (size)
5999     {
6000       HOST_WIDE_INT align = STACK_BOUNDARY / BITS_PER_UNIT;
6001
6002 /* This test is bogus, as output_stack_adjust is used to re-align the
6003    stack.  */
6004 #if 0
6005       gcc_assert (!(size % align));
6006 #endif
6007
6008       if (CONST_OK_FOR_ADD (size))
6009         emit_fn (GEN_ADD3 (reg, reg, GEN_INT (size)));
6010       /* Try to do it with two partial adjustments; however, we must make
6011          sure that the stack is properly aligned at all times, in case
6012          an interrupt occurs between the two partial adjustments.  */
6013       else if (CONST_OK_FOR_ADD (size / 2 & -align)
6014                && CONST_OK_FOR_ADD (size - (size / 2 & -align)))
6015         {
6016           emit_fn (GEN_ADD3 (reg, reg, GEN_INT (size / 2 & -align)));
6017           emit_fn (GEN_ADD3 (reg, reg, GEN_INT (size - (size / 2 & -align))));
6018         }
6019       else
6020         {
6021           rtx const_reg;
6022           rtx insn;
6023           int temp = epilogue_p ? 7 : (TARGET_SH5 ? 0 : 1);
6024           int i;
6025
6026           /* If TEMP is invalid, we could temporarily save a general
6027              register to MACL.  However, there is currently no need
6028              to handle this case, so just die when we see it.  */
6029           if (epilogue_p < 0
6030               || current_function_interrupt
6031               || ! call_really_used_regs[temp] || fixed_regs[temp])
6032             temp = -1;
6033           if (temp < 0 && ! current_function_interrupt
6034               && (TARGET_SHMEDIA || epilogue_p >= 0))
6035             {
6036               HARD_REG_SET temps;
6037               COPY_HARD_REG_SET (temps, call_used_reg_set);
6038               AND_COMPL_HARD_REG_SET (temps, call_fixed_reg_set);
6039               if (epilogue_p > 0)
6040                 {
6041                   int nreg = 0;
6042                   if (crtl->return_rtx)
6043                     {
6044                       enum machine_mode mode;
6045                       mode = GET_MODE (crtl->return_rtx);
6046                       if (BASE_RETURN_VALUE_REG (mode) == FIRST_RET_REG)
6047                         nreg = HARD_REGNO_NREGS (FIRST_RET_REG, mode);
6048                     }
6049                   for (i = 0; i < nreg; i++)
6050                     CLEAR_HARD_REG_BIT (temps, FIRST_RET_REG + i);
6051                   if (crtl->calls_eh_return)
6052                     {
6053                       CLEAR_HARD_REG_BIT (temps, EH_RETURN_STACKADJ_REGNO);
6054                       for (i = 0; i <= 3; i++)
6055                         CLEAR_HARD_REG_BIT (temps, EH_RETURN_DATA_REGNO (i));
6056                     }
6057                 }
6058               if (TARGET_SHMEDIA && epilogue_p < 0)
6059                 for (i = FIRST_TARGET_REG; i <= LAST_TARGET_REG; i++)
6060                   CLEAR_HARD_REG_BIT (temps, i);
6061               if (epilogue_p <= 0)
6062                 {
6063                   for (i = FIRST_PARM_REG;
6064                        i < FIRST_PARM_REG + NPARM_REGS (SImode); i++)
6065                     CLEAR_HARD_REG_BIT (temps, i);
6066                   if (cfun->static_chain_decl != NULL)
6067                     CLEAR_HARD_REG_BIT (temps, STATIC_CHAIN_REGNUM);
6068                 }
6069               temp = scavenge_reg (&temps);
6070             }
6071           if (temp < 0 && live_regs_mask)
6072             {
6073               HARD_REG_SET temps;
6074
6075               COPY_HARD_REG_SET (temps, *live_regs_mask);
6076               CLEAR_HARD_REG_BIT (temps, REGNO (reg));
6077               temp = scavenge_reg (&temps);
6078             }
6079           if (temp < 0)
6080             {
6081               rtx adj_reg, tmp_reg, mem;
6082
6083               /* If we reached here, the most likely case is the (sibcall)
6084                  epilogue for non SHmedia.  Put a special push/pop sequence
6085                  for such case as the last resort.  This looks lengthy but
6086                  would not be problem because it seems to be very
6087                  rare.  */
6088
6089               gcc_assert (!TARGET_SHMEDIA && epilogue_p);
6090
6091
6092                /* ??? There is still the slight possibility that r4 or
6093                   r5 have been reserved as fixed registers or assigned
6094                   as global registers, and they change during an
6095                   interrupt.  There are possible ways to handle this:
6096
6097                   - If we are adjusting the frame pointer (r14), we can do
6098                     with a single temp register and an ordinary push / pop
6099                     on the stack.
6100                   - Grab any call-used or call-saved registers (i.e. not
6101                     fixed or globals) for the temps we need.  We might
6102                     also grab r14 if we are adjusting the stack pointer.
6103                     If we can't find enough available registers, issue
6104                     a diagnostic and die - the user must have reserved
6105                     way too many registers.
6106                  But since all this is rather unlikely to happen and
6107                  would require extra testing, we just die if r4 / r5
6108                  are not available.  */
6109               gcc_assert (!fixed_regs[4] && !fixed_regs[5]
6110                           && !global_regs[4] && !global_regs[5]);
6111
6112               adj_reg = gen_rtx_REG (GET_MODE (reg), 4);
6113               tmp_reg = gen_rtx_REG (GET_MODE (reg), 5);
6114               emit_move_insn (gen_tmp_stack_mem (Pmode, reg), adj_reg);
6115               emit_insn (GEN_MOV (adj_reg, GEN_INT (size)));
6116               emit_insn (GEN_ADD3 (adj_reg, adj_reg, reg));
6117               mem = gen_tmp_stack_mem (Pmode, gen_rtx_PRE_DEC (Pmode, adj_reg));
6118               emit_move_insn (mem, tmp_reg);
6119               emit_move_insn (tmp_reg, gen_tmp_stack_mem (Pmode, reg));
6120               mem = gen_tmp_stack_mem (Pmode, gen_rtx_PRE_DEC (Pmode, adj_reg));
6121               emit_move_insn (mem, tmp_reg);
6122               emit_move_insn (reg, adj_reg);
6123               mem = gen_tmp_stack_mem (Pmode, gen_rtx_POST_INC (Pmode, reg));
6124               emit_move_insn (adj_reg, mem);
6125               mem = gen_tmp_stack_mem (Pmode, gen_rtx_POST_INC (Pmode, reg));
6126               emit_move_insn (tmp_reg, mem);
6127               /* Tell flow the insns that pop r4/r5 aren't dead.  */
6128               emit_use (tmp_reg);
6129               emit_use (adj_reg);
6130               return;
6131             }
6132           const_reg = gen_rtx_REG (GET_MODE (reg), temp);
6133
6134           /* If SIZE is negative, subtract the positive value.
6135              This sometimes allows a constant pool entry to be shared
6136              between prologue and epilogue code.  */
6137           if (size < 0)
6138             {
6139               emit_insn (GEN_MOV (const_reg, GEN_INT (-size)));
6140               insn = emit_fn (GEN_SUB3 (reg, reg, const_reg));
6141             }
6142           else
6143             {
6144               emit_insn (GEN_MOV (const_reg, GEN_INT (size)));
6145               insn = emit_fn (GEN_ADD3 (reg, reg, const_reg));
6146             }
6147           if (! epilogue_p)
6148             add_reg_note (insn, REG_FRAME_RELATED_EXPR,
6149                           gen_rtx_SET (VOIDmode, reg,
6150                                        gen_rtx_PLUS (SImode, reg,
6151                                                      GEN_INT (size))));
6152         }
6153     }
6154 }
6155
6156 static rtx
6157 frame_insn (rtx x)
6158 {
6159   x = emit_insn (x);
6160   RTX_FRAME_RELATED_P (x) = 1;
6161   return x;
6162 }
6163
6164 /* Output RTL to push register RN onto the stack.  */
6165
6166 static rtx
6167 push (int rn)
6168 {
6169   rtx x;
6170   if (rn == FPUL_REG)
6171     x = gen_push_fpul ();
6172   else if (rn == FPSCR_REG)
6173     x = gen_push_fpscr ();
6174   else if ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && TARGET_FMOVD && ! TARGET_FPU_SINGLE
6175            && FP_OR_XD_REGISTER_P (rn))
6176     {
6177       if (FP_REGISTER_P (rn) && (rn - FIRST_FP_REG) & 1)
6178         return NULL_RTX;
6179       x = gen_push_4 (gen_rtx_REG (DFmode, rn));
6180     }
6181   else if (TARGET_SH2E && FP_REGISTER_P (rn))
6182     x = gen_push_e (gen_rtx_REG (SFmode, rn));
6183   else
6184     x = gen_push (gen_rtx_REG (SImode, rn));
6185
6186   x = frame_insn (x);
6187   add_reg_note (x, REG_INC, gen_rtx_REG (SImode, STACK_POINTER_REGNUM));
6188   return x;
6189 }
6190
6191 /* Output RTL to pop register RN from the stack.  */
6192
6193 static void
6194 pop (int rn)
6195 {
6196   rtx x;
6197   if (rn == FPUL_REG)
6198     x = gen_pop_fpul ();
6199   else if (rn == FPSCR_REG)
6200     x = gen_pop_fpscr ();
6201   else if ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && TARGET_FMOVD && ! TARGET_FPU_SINGLE
6202            && FP_OR_XD_REGISTER_P (rn))
6203     {
6204       if (FP_REGISTER_P (rn) && (rn - FIRST_FP_REG) & 1)
6205         return;
6206       x = gen_pop_4 (gen_rtx_REG (DFmode, rn));
6207     }
6208   else if (TARGET_SH2E && FP_REGISTER_P (rn))
6209     x = gen_pop_e (gen_rtx_REG (SFmode, rn));
6210   else
6211     x = gen_pop (gen_rtx_REG (SImode, rn));
6212
6213   x = emit_insn (x);
6214   add_reg_note (x, REG_INC, gen_rtx_REG (SImode, STACK_POINTER_REGNUM));
6215 }
6216
6217 /* Generate code to push the regs specified in the mask.  */
6218
6219 static void
6220 push_regs (HARD_REG_SET *mask, int interrupt_handler)
6221 {
6222   int i = interrupt_handler ? LAST_BANKED_REG + 1 : 0;
6223   int skip_fpscr = 0;
6224
6225   /* Push PR last; this gives better latencies after the prologue, and
6226      candidates for the return delay slot when there are no general
6227      registers pushed.  */
6228   for (; i < FIRST_PSEUDO_REGISTER; i++)
6229     {
6230       /* If this is an interrupt handler, and the SZ bit varies,
6231          and we have to push any floating point register, we need
6232          to switch to the correct precision first.  */
6233       if (i == FIRST_FP_REG && interrupt_handler && TARGET_FMOVD
6234           && hard_reg_set_intersect_p (*mask, reg_class_contents[DF_REGS]))
6235         {
6236           HARD_REG_SET unsaved;
6237
6238           push (FPSCR_REG);
6239           COMPL_HARD_REG_SET (unsaved, *mask);
6240           fpscr_set_from_mem (NORMAL_MODE (FP_MODE), unsaved);
6241           skip_fpscr = 1;
6242         }
6243       if (i != PR_REG
6244           && (i != FPSCR_REG || ! skip_fpscr)
6245           && TEST_HARD_REG_BIT (*mask, i))
6246            {
6247         /* If the ISR has RESBANK attribute assigned, don't push any of
6248            the following registers - R0-R14, MACH, MACL and GBR.  */
6249       if (! (sh_cfun_resbank_handler_p ()
6250              && ((i >= FIRST_GENERAL_REG && i < LAST_GENERAL_REG)
6251                  || i == MACH_REG
6252                  || i == MACL_REG
6253                  || i == GBR_REG)))
6254           push (i);
6255         }
6256     }
6257
6258   /* Push banked registers last to improve delay slot opportunities.  */
6259   if (interrupt_handler)
6260     for (i = FIRST_BANKED_REG; i <= LAST_BANKED_REG; i++)
6261       if (TEST_HARD_REG_BIT (*mask, i))
6262         push (i);
6263
6264   /* Don't push PR register for an ISR with RESBANK attribute assigned.  */
6265   if (TEST_HARD_REG_BIT (*mask, PR_REG) && !sh_cfun_resbank_handler_p ())
6266     push (PR_REG);
6267 }
6268
6269 /* Calculate how much extra space is needed to save all callee-saved
6270    target registers.
6271    LIVE_REGS_MASK is the register mask calculated by calc_live_regs.  */
6272
6273 static int
6274 shmedia_target_regs_stack_space (HARD_REG_SET *live_regs_mask)
6275 {
6276   int reg;
6277   int stack_space = 0;
6278   int interrupt_handler = sh_cfun_interrupt_handler_p ();
6279
6280   for (reg = LAST_TARGET_REG; reg >= FIRST_TARGET_REG; reg--)
6281     if ((! call_really_used_regs[reg] || interrupt_handler)
6282         && ! TEST_HARD_REG_BIT (*live_regs_mask, reg))
6283       /* Leave space to save this target register on the stack,
6284          in case target register allocation wants to use it.  */
6285       stack_space += GET_MODE_SIZE (REGISTER_NATURAL_MODE (reg));
6286   return stack_space;
6287 }
6288
6289 /* Decide whether we should reserve space for callee-save target registers,
6290    in case target register allocation wants to use them.  REGS_SAVED is
6291    the space, in bytes, that is already required for register saves.
6292    LIVE_REGS_MASK is the register mask calculated by calc_live_regs.  */
6293
6294 static int
6295 shmedia_reserve_space_for_target_registers_p (int regs_saved,
6296                                               HARD_REG_SET *live_regs_mask)
6297 {
6298   if (optimize_size)
6299     return 0;
6300   return shmedia_target_regs_stack_space (live_regs_mask) <= regs_saved;
6301 }
6302
6303 /* Decide how much space to reserve for callee-save target registers
6304    in case target register allocation wants to use them.
6305    LIVE_REGS_MASK is the register mask calculated by calc_live_regs.  */
6306
6307 static int
6308 shmedia_target_regs_stack_adjust (HARD_REG_SET *live_regs_mask)
6309 {
6310   if (shmedia_space_reserved_for_target_registers)
6311     return shmedia_target_regs_stack_space (live_regs_mask);
6312   else
6313     return 0;
6314 }
6315
6316 /* Work out the registers which need to be saved, both as a mask and a
6317    count of saved words.  Return the count.
6318
6319    If doing a pragma interrupt function, then push all regs used by the
6320    function, and if we call another function (we can tell by looking at PR),
6321    make sure that all the regs it clobbers are safe too.  */
6322
6323 static int
6324 calc_live_regs (HARD_REG_SET *live_regs_mask)
6325 {
6326   unsigned int reg;
6327   int count;
6328   tree attrs;
6329   bool interrupt_or_trapa_handler, trapa_handler, interrupt_handler;
6330   bool nosave_low_regs;
6331   int pr_live, has_call;
6332
6333   attrs = DECL_ATTRIBUTES (current_function_decl);
6334   interrupt_or_trapa_handler = sh_cfun_interrupt_handler_p ();
6335   trapa_handler = lookup_attribute ("trapa_handler", attrs) != NULL_TREE;
6336   interrupt_handler = interrupt_or_trapa_handler && ! trapa_handler;
6337   nosave_low_regs = lookup_attribute ("nosave_low_regs", attrs) != NULL_TREE;
6338
6339   CLEAR_HARD_REG_SET (*live_regs_mask);
6340   if ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && TARGET_FMOVD && interrupt_handler
6341       && df_regs_ever_live_p (FPSCR_REG))
6342     target_flags &= ~MASK_FPU_SINGLE;
6343   /* If we can save a lot of saves by switching to double mode, do that.  */
6344   else if ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && TARGET_FMOVD && TARGET_FPU_SINGLE)
6345     for (count = 0, reg = FIRST_FP_REG; reg <= LAST_FP_REG; reg += 2)
6346       if (df_regs_ever_live_p (reg) && df_regs_ever_live_p (reg+1)
6347           && (! call_really_used_regs[reg]
6348               || interrupt_handler)
6349           && ++count > 2)
6350         {
6351           target_flags &= ~MASK_FPU_SINGLE;
6352           break;
6353         }
6354   /* PR_MEDIA_REG is a general purpose register, thus global_alloc already
6355      knows how to use it.  That means the pseudo originally allocated for
6356      the initial value can become the PR_MEDIA_REG hard register, as seen for
6357      execute/20010122-1.c:test9.  */
6358   if (TARGET_SHMEDIA)
6359     /* ??? this function is called from initial_elimination_offset, hence we
6360        can't use the result of sh_media_register_for_return here.  */
6361     pr_live = sh_pr_n_sets ();
6362   else
6363     {
6364       rtx pr_initial = has_hard_reg_initial_val (Pmode, PR_REG);
6365       pr_live = (pr_initial
6366                  ? (!REG_P (pr_initial)
6367                     || REGNO (pr_initial) != (PR_REG))
6368                  : df_regs_ever_live_p (PR_REG));
6369       /* For Shcompact, if not optimizing, we end up with a memory reference
6370          using the return address pointer for __builtin_return_address even
6371          though there is no actual need to put the PR register on the stack.  */
6372       pr_live |= df_regs_ever_live_p (RETURN_ADDRESS_POINTER_REGNUM);
6373     }
6374   /* Force PR to be live if the prologue has to call the SHmedia
6375      argument decoder or register saver.  */
6376   if (TARGET_SHCOMPACT
6377       && ((crtl->args.info.call_cookie
6378            & ~ CALL_COOKIE_RET_TRAMP (1))
6379           || crtl->saves_all_registers))
6380     pr_live = 1;
6381   has_call = TARGET_SHMEDIA ? ! leaf_function_p () : pr_live;
6382   for (count = 0, reg = FIRST_PSEUDO_REGISTER; reg-- != 0; )
6383     {
6384       if (reg == (TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG)
6385           ? pr_live
6386           : interrupt_handler
6387           ? (/* Need to save all the regs ever live.  */
6388              (df_regs_ever_live_p (reg)
6389               || (call_really_used_regs[reg]
6390                   && (! fixed_regs[reg] || reg == MACH_REG || reg == MACL_REG
6391                       || reg == PIC_OFFSET_TABLE_REGNUM)
6392                   && has_call)
6393               || (TARGET_SHMEDIA && has_call
6394                   && REGISTER_NATURAL_MODE (reg) == SImode
6395                   && (GENERAL_REGISTER_P (reg) || TARGET_REGISTER_P (reg))))
6396              && reg != STACK_POINTER_REGNUM && reg != ARG_POINTER_REGNUM
6397              && reg != RETURN_ADDRESS_POINTER_REGNUM
6398              && reg != T_REG && reg != GBR_REG
6399              /* Push fpscr only on targets which have FPU */
6400              && (reg != FPSCR_REG || TARGET_FPU_ANY))
6401           : (/* Only push those regs which are used and need to be saved.  */
6402              (TARGET_SHCOMPACT
6403               && flag_pic
6404               && crtl->args.info.call_cookie
6405               && reg == PIC_OFFSET_TABLE_REGNUM)
6406              || (df_regs_ever_live_p (reg)
6407                  && ((!call_really_used_regs[reg]
6408                       && !(reg != PIC_OFFSET_TABLE_REGNUM
6409                            && fixed_regs[reg] && call_used_regs[reg]))
6410                      || (trapa_handler && reg == FPSCR_REG && TARGET_FPU_ANY)))
6411              || (crtl->calls_eh_return
6412                  && (reg == EH_RETURN_DATA_REGNO (0)
6413                      || reg == EH_RETURN_DATA_REGNO (1)
6414                      || reg == EH_RETURN_DATA_REGNO (2)
6415                      || reg == EH_RETURN_DATA_REGNO (3)))
6416              || ((reg == MACL_REG || reg == MACH_REG)
6417                  && df_regs_ever_live_p (reg)
6418                  && sh_cfun_attr_renesas_p ())
6419              ))
6420         {
6421           SET_HARD_REG_BIT (*live_regs_mask, reg);
6422           count += GET_MODE_SIZE (REGISTER_NATURAL_MODE (reg));
6423
6424           if ((TARGET_SH4 || TARGET_SH2A_DOUBLE || TARGET_SH5) && TARGET_FMOVD
6425               && GET_MODE_CLASS (REGISTER_NATURAL_MODE (reg)) == MODE_FLOAT)
6426             {
6427               if (FP_REGISTER_P (reg))
6428                 {
6429                   if (! TARGET_FPU_SINGLE && ! df_regs_ever_live_p (reg ^ 1))
6430                     {
6431                       SET_HARD_REG_BIT (*live_regs_mask, (reg ^ 1));
6432                       count += GET_MODE_SIZE (REGISTER_NATURAL_MODE (reg ^ 1));
6433                     }
6434                 }
6435               else if (XD_REGISTER_P (reg))
6436                 {
6437                   /* Must switch to double mode to access these registers.  */
6438                   target_flags &= ~MASK_FPU_SINGLE;
6439                 }
6440             }
6441         }
6442       if (nosave_low_regs && reg == R8_REG)
6443         break;
6444     }
6445   /* If we have a target register optimization pass after prologue / epilogue
6446      threading, we need to assume all target registers will be live even if
6447      they aren't now.  */
6448   if (flag_branch_target_load_optimize2
6449       && TARGET_SAVE_ALL_TARGET_REGS
6450       && shmedia_space_reserved_for_target_registers)
6451     for (reg = LAST_TARGET_REG; reg >= FIRST_TARGET_REG; reg--)
6452       if ((! call_really_used_regs[reg] || interrupt_handler)
6453           && ! TEST_HARD_REG_BIT (*live_regs_mask, reg))
6454         {
6455           SET_HARD_REG_BIT (*live_regs_mask, reg);
6456           count += GET_MODE_SIZE (REGISTER_NATURAL_MODE (reg));
6457         }
6458   /* If this is an interrupt handler, we don't have any call-clobbered
6459      registers we can conveniently use for target register save/restore.
6460      Make sure we save at least one general purpose register when we need
6461      to save target registers.  */
6462   if (interrupt_handler
6463       && hard_reg_set_intersect_p (*live_regs_mask,
6464                                    reg_class_contents[TARGET_REGS])
6465       && ! hard_reg_set_intersect_p (*live_regs_mask,
6466                                      reg_class_contents[GENERAL_REGS]))
6467     {
6468       SET_HARD_REG_BIT (*live_regs_mask, R0_REG);
6469       count += GET_MODE_SIZE (REGISTER_NATURAL_MODE (R0_REG));
6470     }
6471
6472   return count;
6473 }
6474
6475 /* Code to generate prologue and epilogue sequences */
6476
6477 /* PUSHED is the number of bytes that are being pushed on the
6478    stack for register saves.  Return the frame size, padded
6479    appropriately so that the stack stays properly aligned.  */
6480 static HOST_WIDE_INT
6481 rounded_frame_size (int pushed)
6482 {
6483   HOST_WIDE_INT size = get_frame_size ();
6484   HOST_WIDE_INT align = STACK_BOUNDARY / BITS_PER_UNIT;
6485
6486   return ((size + pushed + align - 1) & -align) - pushed;
6487 }
6488
6489 /* Choose a call-clobbered target-branch register that remains
6490    unchanged along the whole function.  We set it up as the return
6491    value in the prologue.  */
6492 int
6493 sh_media_register_for_return (void)
6494 {
6495   int regno;
6496   int tr0_used;
6497
6498   if (! current_function_is_leaf)
6499     return -1;
6500   if (lookup_attribute ("interrupt_handler",
6501                         DECL_ATTRIBUTES (current_function_decl)))
6502     return -1;
6503   if (sh_cfun_interrupt_handler_p ())
6504     return -1;
6505
6506   tr0_used = flag_pic && df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM);
6507
6508   for (regno = FIRST_TARGET_REG + tr0_used; regno <= LAST_TARGET_REG; regno++)
6509     if (call_really_used_regs[regno] && ! df_regs_ever_live_p (regno))
6510       return regno;
6511
6512   return -1;
6513 }
6514
6515 /* The maximum registers we need to save are:
6516    - 62 general purpose registers (r15 is stack pointer, r63 is zero)
6517    - 32 floating point registers (for each pair, we save none,
6518          one single precision value, or a double precision value).
6519    -  8 target registers
6520    -  add 1 entry for a delimiter.  */
6521 #define MAX_SAVED_REGS (62+32+8)
6522
6523 typedef struct save_entry_s
6524 {
6525   unsigned char reg;
6526   unsigned char mode;
6527   short offset;
6528 } save_entry;
6529
6530 #define MAX_TEMPS 4
6531
6532 /* There will be a delimiter entry with VOIDmode both at the start and the
6533    end of a filled in schedule.  The end delimiter has the offset of the
6534    save with the smallest (i.e. most negative) offset.  */
6535 typedef struct save_schedule_s
6536 {
6537   save_entry entries[MAX_SAVED_REGS + 2];
6538   int temps[MAX_TEMPS+1];
6539 } save_schedule;
6540
6541 /* Fill in SCHEDULE according to LIVE_REGS_MASK.  If RESTORE is nonzero,
6542    use reverse order.  Returns the last entry written to (not counting
6543    the delimiter).  OFFSET_BASE is a number to be added to all offset
6544    entries.  */
6545
6546 static save_entry *
6547 sh5_schedule_saves (HARD_REG_SET *live_regs_mask, save_schedule *schedule,
6548                     int offset_base)
6549 {
6550   int align, i;
6551   save_entry *entry = schedule->entries;
6552   int tmpx = 0;
6553   int offset;
6554
6555   if (! current_function_interrupt)
6556     for (i = FIRST_GENERAL_REG; tmpx < MAX_TEMPS && i <= LAST_GENERAL_REG; i++)
6557       if (call_really_used_regs[i] && ! fixed_regs[i] && i != PR_MEDIA_REG
6558           && ! FUNCTION_ARG_REGNO_P (i)
6559           && i != FIRST_RET_REG
6560           && ! (cfun->static_chain_decl != NULL && i == STATIC_CHAIN_REGNUM)
6561           && ! (crtl->calls_eh_return
6562                 && (i == EH_RETURN_STACKADJ_REGNO
6563                     || ((unsigned) i >= EH_RETURN_DATA_REGNO (0)
6564                         && (unsigned) i <= EH_RETURN_DATA_REGNO (3)))))
6565         schedule->temps[tmpx++] = i;
6566   entry->reg = -1;
6567   entry->mode = VOIDmode;
6568   entry->offset = offset_base;
6569   entry++;
6570   /* We loop twice: first, we save 8-byte aligned registers in the
6571      higher addresses, that are known to be aligned.  Then, we
6572      proceed to saving 32-bit registers that don't need 8-byte
6573      alignment.
6574      If this is an interrupt function, all registers that need saving
6575      need to be saved in full.  moreover, we need to postpone saving
6576      target registers till we have saved some general purpose registers
6577      we can then use as scratch registers.  */
6578   offset = offset_base;
6579   for (align = 1; align >= 0; align--)
6580     {
6581       for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; i--)
6582         if (TEST_HARD_REG_BIT (*live_regs_mask, i))
6583           {
6584             enum machine_mode mode = REGISTER_NATURAL_MODE (i);
6585             int reg = i;
6586
6587             if (current_function_interrupt)
6588               {
6589                 if (TARGET_REGISTER_P (i))
6590                   continue;
6591                 if (GENERAL_REGISTER_P (i))
6592                   mode = DImode;
6593               }
6594             if (mode == SFmode && (i % 2) == 1
6595                 && ! TARGET_FPU_SINGLE && FP_REGISTER_P (i)
6596                 && (TEST_HARD_REG_BIT (*live_regs_mask, (i ^ 1))))
6597               {
6598                 mode = DFmode;
6599                 i--;
6600                 reg--;
6601               }
6602
6603             /* If we're doing the aligned pass and this is not aligned,
6604                or we're doing the unaligned pass and this is aligned,
6605                skip it.  */
6606             if ((GET_MODE_SIZE (mode) % (STACK_BOUNDARY / BITS_PER_UNIT) == 0)
6607                 != align)
6608               continue;
6609
6610             if (current_function_interrupt
6611                 && GENERAL_REGISTER_P (i)
6612                 && tmpx < MAX_TEMPS)
6613               schedule->temps[tmpx++] = i;
6614
6615             offset -= GET_MODE_SIZE (mode);
6616             entry->reg = i;
6617             entry->mode = mode;
6618             entry->offset = offset;
6619             entry++;
6620           }
6621       if (align && current_function_interrupt)
6622         for (i = LAST_TARGET_REG; i >= FIRST_TARGET_REG; i--)
6623           if (TEST_HARD_REG_BIT (*live_regs_mask, i))
6624             {
6625               offset -= GET_MODE_SIZE (DImode);
6626               entry->reg = i;
6627               entry->mode = DImode;
6628               entry->offset = offset;
6629               entry++;
6630             }
6631     }
6632   entry->reg = -1;
6633   entry->mode = VOIDmode;
6634   entry->offset = offset;
6635   schedule->temps[tmpx] = -1;
6636   return entry - 1;
6637 }
6638
6639 void
6640 sh_expand_prologue (void)
6641 {
6642   HARD_REG_SET live_regs_mask;
6643   int d, i;
6644   int d_rounding = 0;
6645   int save_flags = target_flags;
6646   int pretend_args;
6647   tree sp_switch_attr
6648     = lookup_attribute ("sp_switch", DECL_ATTRIBUTES (current_function_decl));
6649
6650   current_function_interrupt = sh_cfun_interrupt_handler_p ();
6651
6652   /* We have pretend args if we had an object sent partially in registers
6653      and partially on the stack, e.g. a large structure.  */
6654   pretend_args = crtl->args.pretend_args_size;
6655   if (TARGET_VARARGS_PRETEND_ARGS (current_function_decl)
6656       && (NPARM_REGS(SImode)
6657           > crtl->args.info.arg_count[(int) SH_ARG_INT]))
6658     pretend_args = 0;
6659   output_stack_adjust (-pretend_args
6660                        - crtl->args.info.stack_regs * 8,
6661                        stack_pointer_rtx, 0, NULL);
6662
6663   if (TARGET_SHCOMPACT && flag_pic && crtl->args.info.call_cookie)
6664     /* We're going to use the PIC register to load the address of the
6665        incoming-argument decoder and/or of the return trampoline from
6666        the GOT, so make sure the PIC register is preserved and
6667        initialized.  */
6668     df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
6669
6670   if (TARGET_SHCOMPACT
6671       && (crtl->args.info.call_cookie & ~ CALL_COOKIE_RET_TRAMP(1)))
6672     {
6673       int reg;
6674
6675       /* First, make all registers with incoming arguments that will
6676          be pushed onto the stack live, so that register renaming
6677          doesn't overwrite them.  */
6678       for (reg = 0; reg < NPARM_REGS (SImode); reg++)
6679         if (CALL_COOKIE_STACKSEQ_GET (crtl->args.info.call_cookie)
6680             >= NPARM_REGS (SImode) - reg)
6681           for (; reg < NPARM_REGS (SImode); reg++)
6682             emit_insn (gen_shcompact_preserve_incoming_args
6683                        (gen_rtx_REG (SImode, FIRST_PARM_REG + reg)));
6684         else if (CALL_COOKIE_INT_REG_GET
6685                  (crtl->args.info.call_cookie, reg) == 1)
6686           emit_insn (gen_shcompact_preserve_incoming_args
6687                      (gen_rtx_REG (SImode, FIRST_PARM_REG + reg)));
6688
6689       emit_move_insn (gen_rtx_REG (Pmode, MACL_REG),
6690                       stack_pointer_rtx);
6691       emit_move_insn (gen_rtx_REG (SImode, R0_REG),
6692                       GEN_INT (crtl->args.info.call_cookie));
6693       emit_move_insn (gen_rtx_REG (SImode, MACH_REG),
6694                       gen_rtx_REG (SImode, R0_REG));
6695     }
6696   else if (TARGET_SHMEDIA)
6697     {
6698       int tr = sh_media_register_for_return ();
6699
6700       if (tr >= 0)
6701         emit_move_insn (gen_rtx_REG (DImode, tr),
6702                         gen_rtx_REG (DImode, PR_MEDIA_REG));
6703     }
6704
6705   /* Emit the code for SETUP_VARARGS.  */
6706   if (cfun->stdarg)
6707     {
6708       if (TARGET_VARARGS_PRETEND_ARGS (current_function_decl))
6709         {
6710           /* Push arg regs as if they'd been provided by caller in stack.  */
6711           for (i = 0; i < NPARM_REGS(SImode); i++)
6712             {
6713               int rn = NPARM_REGS(SImode) + FIRST_PARM_REG - i - 1;
6714               rtx insn;
6715
6716               if (i >= (NPARM_REGS(SImode)
6717                         - crtl->args.info.arg_count[(int) SH_ARG_INT]
6718                         ))
6719                 break;
6720               insn = push (rn);
6721             }
6722         }
6723     }
6724
6725   /* If we're supposed to switch stacks at function entry, do so now.  */
6726   if (sp_switch_attr)
6727     {
6728       /* The argument specifies a variable holding the address of the
6729          stack the interrupt function should switch to/from at entry/exit.  */
6730       const char *s
6731         = ggc_strdup (TREE_STRING_POINTER (TREE_VALUE (sp_switch_attr)));
6732       rtx sp_switch = gen_rtx_SYMBOL_REF (Pmode, s);
6733
6734       emit_insn (gen_sp_switch_1 (sp_switch));
6735     }
6736
6737   d = calc_live_regs (&live_regs_mask);
6738   /* ??? Maybe we could save some switching if we can move a mode switch
6739      that already happens to be at the function start into the prologue.  */
6740   if (target_flags != save_flags && ! current_function_interrupt)
6741     emit_insn (gen_toggle_sz ());
6742
6743   if (TARGET_SH5)
6744     {
6745       int offset_base, offset;
6746       rtx r0 = NULL_RTX;
6747       int offset_in_r0 = -1;
6748       int sp_in_r0 = 0;
6749       int tregs_space = shmedia_target_regs_stack_adjust (&live_regs_mask);
6750       int total_size, save_size;
6751       save_schedule schedule;
6752       save_entry *entry;
6753       int *tmp_pnt;
6754
6755       if (call_really_used_regs[R0_REG] && ! fixed_regs[R0_REG]
6756           && ! current_function_interrupt)
6757         r0 = gen_rtx_REG (Pmode, R0_REG);
6758
6759       /* D is the actual number of bytes that we need for saving registers,
6760          however, in initial_elimination_offset we have committed to using
6761          an additional TREGS_SPACE amount of bytes - in order to keep both
6762          addresses to arguments supplied by the caller and local variables
6763          valid, we must keep this gap.  Place it between the incoming
6764          arguments and the actually saved registers in a bid to optimize
6765          locality of reference.  */
6766       total_size = d + tregs_space;
6767       total_size += rounded_frame_size (total_size);
6768       save_size = total_size - rounded_frame_size (d);
6769       if (save_size % (STACK_BOUNDARY / BITS_PER_UNIT))
6770         d_rounding = ((STACK_BOUNDARY / BITS_PER_UNIT)
6771                         - save_size % (STACK_BOUNDARY / BITS_PER_UNIT));
6772
6773       /* If adjusting the stack in a single step costs nothing extra, do so.
6774          I.e. either if a single addi is enough, or we need a movi anyway,
6775          and we don't exceed the maximum offset range (the test for the
6776          latter is conservative for simplicity).  */
6777       if (TARGET_SHMEDIA
6778           && (CONST_OK_FOR_I10 (-total_size)
6779               || (! CONST_OK_FOR_I10 (-(save_size + d_rounding))
6780                   && total_size <= 2044)))
6781         d_rounding = total_size - save_size;
6782
6783       offset_base = d + d_rounding;
6784
6785       output_stack_adjust (-(save_size + d_rounding), stack_pointer_rtx,
6786                            0, NULL);
6787
6788       sh5_schedule_saves (&live_regs_mask, &schedule, offset_base);
6789       tmp_pnt = schedule.temps;
6790       for (entry = &schedule.entries[1]; entry->mode != VOIDmode; entry++)
6791         {
6792           enum machine_mode mode = (enum machine_mode) entry->mode;
6793           unsigned int reg = entry->reg;
6794           rtx reg_rtx, mem_rtx, pre_dec = NULL_RTX;
6795           rtx orig_reg_rtx;
6796
6797           offset = entry->offset;
6798
6799           reg_rtx = gen_rtx_REG (mode, reg);
6800
6801           mem_rtx = gen_frame_mem (mode,
6802                                    gen_rtx_PLUS (Pmode,
6803                                                  stack_pointer_rtx,
6804                                                  GEN_INT (offset)));
6805
6806           if (!memory_address_p (mode, XEXP (mem_rtx, 0)))
6807             {
6808               gcc_assert (r0);
6809               mem_rtx = NULL_RTX;
6810             }
6811
6812           if (HAVE_PRE_DECREMENT
6813               && (offset_in_r0 - offset == GET_MODE_SIZE (mode)
6814                   || mem_rtx == NULL_RTX
6815                   || reg == PR_REG || SPECIAL_REGISTER_P (reg)))
6816             {
6817               pre_dec = gen_frame_mem (mode, gen_rtx_PRE_DEC (Pmode, r0));
6818
6819               if (!memory_address_p (mode, XEXP (pre_dec, 0)))
6820                 pre_dec = NULL_RTX;
6821               else
6822                 {
6823                   mem_rtx = NULL_RTX;
6824                   offset += GET_MODE_SIZE (mode);
6825                 }
6826             }
6827
6828           if (mem_rtx != NULL_RTX)
6829             goto addr_ok;
6830
6831           if (offset_in_r0 == -1)
6832             {
6833               emit_move_insn (r0, GEN_INT (offset));
6834               offset_in_r0 = offset;
6835             }
6836           else if (offset != offset_in_r0)
6837             {
6838               emit_move_insn (r0,
6839                               gen_rtx_PLUS
6840                               (Pmode, r0,
6841                                GEN_INT (offset - offset_in_r0)));
6842               offset_in_r0 += offset - offset_in_r0;
6843             }
6844
6845           if (pre_dec != NULL_RTX)
6846             {
6847               if (! sp_in_r0)
6848                 {
6849                   emit_move_insn (r0,
6850                                   gen_rtx_PLUS
6851                                   (Pmode, r0, stack_pointer_rtx));
6852                   sp_in_r0 = 1;
6853                 }
6854
6855               offset -= GET_MODE_SIZE (mode);
6856               offset_in_r0 -= GET_MODE_SIZE (mode);
6857
6858               mem_rtx = pre_dec;
6859             }
6860           else if (sp_in_r0)
6861             mem_rtx = gen_frame_mem (mode, r0);
6862           else
6863             mem_rtx = gen_frame_mem (mode,
6864                                      gen_rtx_PLUS (Pmode,
6865                                                    stack_pointer_rtx,
6866                                                    r0));
6867
6868           /* We must not use an r0-based address for target-branch
6869              registers or for special registers without pre-dec
6870              memory addresses, since we store their values in r0
6871              first.  */
6872           gcc_assert (!TARGET_REGISTER_P (reg)
6873                       && ((reg != PR_REG && !SPECIAL_REGISTER_P (reg))
6874                           || mem_rtx == pre_dec));
6875
6876         addr_ok:
6877           orig_reg_rtx = reg_rtx;
6878           if (TARGET_REGISTER_P (reg)
6879               || ((reg == PR_REG || SPECIAL_REGISTER_P (reg))
6880                   && mem_rtx != pre_dec))
6881             {
6882               rtx tmp_reg = gen_rtx_REG (GET_MODE (reg_rtx), *tmp_pnt);
6883
6884               emit_move_insn (tmp_reg, reg_rtx);
6885
6886               if (REGNO (tmp_reg) == R0_REG)
6887                 {
6888                   offset_in_r0 = -1;
6889                   sp_in_r0 = 0;
6890                   gcc_assert (!refers_to_regno_p
6891                               (R0_REG, R0_REG+1, mem_rtx, (rtx *) 0));
6892                 }
6893
6894               if (*++tmp_pnt <= 0)
6895                 tmp_pnt = schedule.temps;
6896
6897               reg_rtx = tmp_reg;
6898             }
6899           {
6900             rtx insn;
6901
6902             /* Mark as interesting for dwarf cfi generator */
6903             insn = emit_move_insn (mem_rtx, reg_rtx);
6904             RTX_FRAME_RELATED_P (insn) = 1;
6905             /* If we use an intermediate register for the save, we can't
6906                describe this exactly in cfi as a copy of the to-be-saved
6907                register into the temporary register and then the temporary
6908                register on the stack, because the temporary register can
6909                have a different natural size than the to-be-saved register.
6910                Thus, we gloss over the intermediate copy and pretend we do
6911                a direct save from the to-be-saved register.  */
6912             if (REGNO (reg_rtx) != reg)
6913               {
6914                 rtx set;
6915
6916                 set = gen_rtx_SET (VOIDmode, mem_rtx, orig_reg_rtx);
6917                 add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
6918               }
6919
6920             if (TARGET_SHCOMPACT && (offset_in_r0 != -1))
6921               {
6922                 rtx reg_rtx = gen_rtx_REG (mode, reg);
6923                 rtx set;
6924                 rtx mem_rtx = gen_frame_mem (mode,
6925                                              gen_rtx_PLUS (Pmode,
6926                                                            stack_pointer_rtx,
6927                                                            GEN_INT (offset)));
6928
6929                 set = gen_rtx_SET (VOIDmode, mem_rtx, reg_rtx);
6930                 add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
6931               }
6932           }
6933         }
6934
6935       gcc_assert (entry->offset == d_rounding);
6936     }
6937   else
6938     push_regs (&live_regs_mask, current_function_interrupt);
6939
6940   if (flag_pic && df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM))
6941     emit_insn (gen_GOTaddr2picreg ());
6942
6943   if (SHMEDIA_REGS_STACK_ADJUST ())
6944     {
6945       /* This must NOT go through the PLT, otherwise mach and macl
6946          may be clobbered.  */
6947       function_symbol (gen_rtx_REG (Pmode, R0_REG),
6948                        (TARGET_FPU_ANY
6949                         ? "__GCC_push_shmedia_regs"
6950                         : "__GCC_push_shmedia_regs_nofpu"), SFUNC_GOT);
6951       emit_insn (gen_shmedia_save_restore_regs_compact
6952                  (GEN_INT (-SHMEDIA_REGS_STACK_ADJUST ())));
6953     }
6954
6955   if (target_flags != save_flags && ! current_function_interrupt)
6956     emit_insn (gen_toggle_sz ());
6957
6958   target_flags = save_flags;
6959
6960   output_stack_adjust (-rounded_frame_size (d) + d_rounding,
6961                        stack_pointer_rtx, 0, NULL);
6962
6963   if (frame_pointer_needed)
6964     frame_insn (GEN_MOV (hard_frame_pointer_rtx, stack_pointer_rtx));
6965
6966   if (TARGET_SHCOMPACT
6967       && (crtl->args.info.call_cookie & ~ CALL_COOKIE_RET_TRAMP(1)))
6968     {
6969       /* This must NOT go through the PLT, otherwise mach and macl
6970          may be clobbered.  */
6971       function_symbol (gen_rtx_REG (Pmode, R0_REG),
6972                       "__GCC_shcompact_incoming_args", SFUNC_GOT);
6973       emit_insn (gen_shcompact_incoming_args ());
6974     }
6975 }
6976
6977 void
6978 sh_expand_epilogue (bool sibcall_p)
6979 {
6980   HARD_REG_SET live_regs_mask;
6981   int d, i;
6982   int d_rounding = 0;
6983
6984   int save_flags = target_flags;
6985   int frame_size, save_size;
6986   int fpscr_deferred = 0;
6987   int e = sibcall_p ? -1 : 1;
6988
6989   d = calc_live_regs (&live_regs_mask);
6990
6991   save_size = d;
6992   frame_size = rounded_frame_size (d);
6993
6994   if (TARGET_SH5)
6995     {
6996       int tregs_space = shmedia_target_regs_stack_adjust (&live_regs_mask);
6997       int total_size;
6998       if (d % (STACK_BOUNDARY / BITS_PER_UNIT))
6999       d_rounding = ((STACK_BOUNDARY / BITS_PER_UNIT)
7000                     - d % (STACK_BOUNDARY / BITS_PER_UNIT));
7001
7002       total_size = d + tregs_space;
7003       total_size += rounded_frame_size (total_size);
7004       save_size = total_size - frame_size;
7005
7006       /* If adjusting the stack in a single step costs nothing extra, do so.
7007          I.e. either if a single addi is enough, or we need a movi anyway,
7008          and we don't exceed the maximum offset range (the test for the
7009          latter is conservative for simplicity).  */
7010       if (TARGET_SHMEDIA
7011           && ! frame_pointer_needed
7012           && (CONST_OK_FOR_I10 (total_size)
7013               || (! CONST_OK_FOR_I10 (save_size + d_rounding)
7014                   && total_size <= 2044)))
7015         d_rounding = frame_size;
7016
7017       frame_size -= d_rounding;
7018     }
7019
7020   if (frame_pointer_needed)
7021     {
7022       /* We must avoid scheduling the epilogue with previous basic blocks.
7023          See PR/18032 and PR/40313.  */
7024       emit_insn (gen_blockage ());
7025       output_stack_adjust (frame_size, hard_frame_pointer_rtx, e,
7026                            &live_regs_mask);
7027
7028       /* We must avoid moving the stack pointer adjustment past code
7029          which reads from the local frame, else an interrupt could
7030          occur after the SP adjustment and clobber data in the local
7031          frame.  */
7032       emit_insn (gen_blockage ());
7033       emit_insn (GEN_MOV (stack_pointer_rtx, hard_frame_pointer_rtx));
7034     }
7035   else if (frame_size)
7036     {
7037       /* We must avoid moving the stack pointer adjustment past code
7038          which reads from the local frame, else an interrupt could
7039          occur after the SP adjustment and clobber data in the local
7040          frame.  */
7041       emit_insn (gen_blockage ());
7042       output_stack_adjust (frame_size, stack_pointer_rtx, e, &live_regs_mask);
7043     }
7044
7045   if (SHMEDIA_REGS_STACK_ADJUST ())
7046     {
7047       function_symbol (gen_rtx_REG (Pmode, R0_REG),
7048                        (TARGET_FPU_ANY
7049                         ? "__GCC_pop_shmedia_regs"
7050                         : "__GCC_pop_shmedia_regs_nofpu"), SFUNC_GOT);
7051       /* This must NOT go through the PLT, otherwise mach and macl
7052          may be clobbered.  */
7053       emit_insn (gen_shmedia_save_restore_regs_compact
7054                  (GEN_INT (SHMEDIA_REGS_STACK_ADJUST ())));
7055     }
7056
7057   /* Pop all the registers.  */
7058
7059   if (target_flags != save_flags && ! current_function_interrupt)
7060     emit_insn (gen_toggle_sz ());
7061   if (TARGET_SH5)
7062     {
7063       int offset_base, offset;
7064       int offset_in_r0 = -1;
7065       int sp_in_r0 = 0;
7066       rtx r0 = gen_rtx_REG (Pmode, R0_REG);
7067       save_schedule schedule;
7068       save_entry *entry;
7069       int *tmp_pnt;
7070
7071       entry = sh5_schedule_saves (&live_regs_mask, &schedule, d_rounding);
7072       offset_base = -entry[1].offset + d_rounding;
7073       tmp_pnt = schedule.temps;
7074       for (; entry->mode != VOIDmode; entry--)
7075         {
7076           enum machine_mode mode = (enum machine_mode) entry->mode;
7077           int reg = entry->reg;
7078           rtx reg_rtx, mem_rtx, post_inc = NULL_RTX, insn;
7079
7080           offset = offset_base + entry->offset;
7081           reg_rtx = gen_rtx_REG (mode, reg);
7082
7083           mem_rtx = gen_frame_mem (mode,
7084                                    gen_rtx_PLUS (Pmode,
7085                                                  stack_pointer_rtx,
7086                                                  GEN_INT (offset)));
7087
7088           if (!memory_address_p (mode, XEXP (mem_rtx, 0)))
7089             mem_rtx = NULL_RTX;
7090
7091           if (HAVE_POST_INCREMENT
7092               && (offset == offset_in_r0
7093                   || (offset + GET_MODE_SIZE (mode) != d + d_rounding
7094                       && mem_rtx == NULL_RTX)
7095                   || reg == PR_REG || SPECIAL_REGISTER_P (reg)))
7096             {
7097               post_inc = gen_frame_mem (mode, gen_rtx_POST_INC (Pmode, r0));
7098
7099               if (!memory_address_p (mode, XEXP (post_inc, 0)))
7100                 post_inc = NULL_RTX;
7101               else
7102                 mem_rtx = NULL_RTX;
7103             }
7104
7105           if (mem_rtx != NULL_RTX)
7106             goto addr_ok;
7107
7108           if (offset_in_r0 == -1)
7109             {
7110               emit_move_insn (r0, GEN_INT (offset));
7111               offset_in_r0 = offset;
7112             }
7113           else if (offset != offset_in_r0)
7114             {
7115               emit_move_insn (r0,
7116                               gen_rtx_PLUS
7117                               (Pmode, r0,
7118                                GEN_INT (offset - offset_in_r0)));
7119               offset_in_r0 += offset - offset_in_r0;
7120             }
7121
7122           if (post_inc != NULL_RTX)
7123             {
7124               if (! sp_in_r0)
7125                 {
7126                   emit_move_insn (r0,
7127                                   gen_rtx_PLUS
7128                                   (Pmode, r0, stack_pointer_rtx));
7129                   sp_in_r0 = 1;
7130                 }
7131
7132               mem_rtx = post_inc;
7133
7134               offset_in_r0 += GET_MODE_SIZE (mode);
7135             }
7136           else if (sp_in_r0)
7137             mem_rtx = gen_frame_mem (mode, r0);
7138           else
7139             mem_rtx = gen_frame_mem (mode,
7140                                      gen_rtx_PLUS (Pmode,
7141                                                    stack_pointer_rtx,
7142                                                    r0));
7143
7144           gcc_assert ((reg != PR_REG && !SPECIAL_REGISTER_P (reg))
7145                       || mem_rtx == post_inc);
7146
7147         addr_ok:
7148           if ((reg == PR_REG || SPECIAL_REGISTER_P (reg))
7149               && mem_rtx != post_inc)
7150             {
7151               insn = emit_move_insn (r0, mem_rtx);
7152               mem_rtx = r0;
7153             }
7154           else if (TARGET_REGISTER_P (reg))
7155             {
7156               rtx tmp_reg = gen_rtx_REG (mode, *tmp_pnt);
7157
7158               /* Give the scheduler a bit of freedom by using up to
7159                  MAX_TEMPS registers in a round-robin fashion.  */
7160               insn = emit_move_insn (tmp_reg, mem_rtx);
7161               mem_rtx = tmp_reg;
7162               if (*++tmp_pnt < 0)
7163                 tmp_pnt = schedule.temps;
7164             }
7165
7166           insn = emit_move_insn (reg_rtx, mem_rtx);
7167         }
7168
7169       gcc_assert (entry->offset + offset_base == d + d_rounding);
7170     }
7171   else /* ! TARGET_SH5 */
7172     {
7173       int last_reg;
7174
7175       save_size = 0;
7176         /* For an ISR with RESBANK attribute assigned, don't pop PR
7177            register.  */
7178       if (TEST_HARD_REG_BIT (live_regs_mask, PR_REG)
7179           && !sh_cfun_resbank_handler_p ())
7180         {
7181           if (!frame_pointer_needed)
7182             emit_insn (gen_blockage ());
7183           pop (PR_REG);
7184         }
7185
7186       /* Banked registers are poped first to avoid being scheduled in the
7187          delay slot. RTE switches banks before the ds instruction.  */
7188       if (current_function_interrupt)
7189         {
7190           for (i = FIRST_BANKED_REG; i <= LAST_BANKED_REG; i++)
7191             if (TEST_HARD_REG_BIT (live_regs_mask, i))
7192               pop (LAST_BANKED_REG - i);
7193
7194           last_reg = FIRST_PSEUDO_REGISTER - LAST_BANKED_REG - 1;
7195         }
7196       else
7197         last_reg = FIRST_PSEUDO_REGISTER;
7198
7199       for (i = 0; i < last_reg; i++)
7200         {
7201           int j = (FIRST_PSEUDO_REGISTER - 1) - i;
7202
7203           if (j == FPSCR_REG && current_function_interrupt && TARGET_FMOVD
7204               && hard_reg_set_intersect_p (live_regs_mask,
7205                                           reg_class_contents[DF_REGS]))
7206             fpscr_deferred = 1;
7207           /* For an ISR with RESBANK attribute assigned, don't pop
7208              following registers, R0-R14, MACH, MACL and GBR.  */
7209           else if (j != PR_REG && TEST_HARD_REG_BIT (live_regs_mask, j)
7210                    && ! (sh_cfun_resbank_handler_p ()
7211                          && ((j >= FIRST_GENERAL_REG
7212                               && j < LAST_GENERAL_REG)
7213                               || j == MACH_REG
7214                               || j == MACL_REG
7215                               || j == GBR_REG)))
7216             pop (j);
7217
7218           if (j == FIRST_FP_REG && fpscr_deferred)
7219             pop (FPSCR_REG);
7220         }
7221     }
7222   if (target_flags != save_flags && ! current_function_interrupt)
7223     emit_insn (gen_toggle_sz ());
7224   target_flags = save_flags;
7225
7226   output_stack_adjust (crtl->args.pretend_args_size
7227                        + save_size + d_rounding
7228                        + crtl->args.info.stack_regs * 8,
7229                        stack_pointer_rtx, e, NULL);
7230
7231   if (crtl->calls_eh_return)
7232     emit_insn (GEN_ADD3 (stack_pointer_rtx, stack_pointer_rtx,
7233                          EH_RETURN_STACKADJ_RTX));
7234
7235   /* Switch back to the normal stack if necessary.  */
7236   if (lookup_attribute ("sp_switch", DECL_ATTRIBUTES (current_function_decl)))
7237     emit_insn (gen_sp_switch_2 ());
7238
7239   /* Tell flow the insn that pops PR isn't dead.  */
7240   /* PR_REG will never be live in SHmedia mode, and we don't need to
7241      USE PR_MEDIA_REG, since it will be explicitly copied to TR0_REG
7242      by the return pattern.  */
7243   if (TEST_HARD_REG_BIT (live_regs_mask, PR_REG))
7244     emit_use (gen_rtx_REG (SImode, PR_REG));
7245 }
7246
7247 static int sh_need_epilogue_known = 0;
7248
7249 int
7250 sh_need_epilogue (void)
7251 {
7252   if (! sh_need_epilogue_known)
7253     {
7254       rtx epilogue;
7255
7256       start_sequence ();
7257       sh_expand_epilogue (0);
7258       epilogue = get_insns ();
7259       end_sequence ();
7260       sh_need_epilogue_known = (epilogue == NULL ? -1 : 1);
7261     }
7262   return sh_need_epilogue_known > 0;
7263 }
7264
7265 /* Emit code to change the current function's return address to RA.
7266    TEMP is available as a scratch register, if needed.  */
7267
7268 void
7269 sh_set_return_address (rtx ra, rtx tmp)
7270 {
7271   HARD_REG_SET live_regs_mask;
7272   int d;
7273   int pr_reg = TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG;
7274   int pr_offset;
7275
7276   d = calc_live_regs (&live_regs_mask);
7277
7278   /* If pr_reg isn't life, we can set it (or the register given in
7279      sh_media_register_for_return) directly.  */
7280   if (! TEST_HARD_REG_BIT (live_regs_mask, pr_reg))
7281     {
7282       rtx rr;
7283
7284       if (TARGET_SHMEDIA)
7285         {
7286           int rr_regno = sh_media_register_for_return ();
7287
7288           if (rr_regno < 0)
7289             rr_regno = pr_reg;
7290
7291           rr = gen_rtx_REG (DImode, rr_regno);
7292         }
7293       else
7294         rr = gen_rtx_REG (SImode, pr_reg);
7295
7296       emit_insn (GEN_MOV (rr, ra));
7297       /* Tell flow the register for return isn't dead.  */
7298       emit_use (rr);
7299       return;
7300     }
7301
7302   if (TARGET_SH5)
7303     {
7304       int offset;
7305       save_schedule schedule;
7306       save_entry *entry;
7307
7308       entry = sh5_schedule_saves (&live_regs_mask, &schedule, 0);
7309       offset = entry[1].offset;
7310       for (; entry->mode != VOIDmode; entry--)
7311         if (entry->reg == pr_reg)
7312           goto found;
7313
7314       /* We can't find pr register.  */
7315       gcc_unreachable ();
7316
7317     found:
7318       offset = entry->offset - offset;
7319       pr_offset = (rounded_frame_size (d) + offset
7320                    + SHMEDIA_REGS_STACK_ADJUST ());
7321     }
7322   else
7323     pr_offset = rounded_frame_size (d);
7324
7325   emit_insn (GEN_MOV (tmp, GEN_INT (pr_offset)));
7326   emit_insn (GEN_ADD3 (tmp, tmp, hard_frame_pointer_rtx));
7327
7328   tmp = gen_frame_mem (Pmode, tmp);
7329   emit_insn (GEN_MOV (tmp, ra));
7330   /* Tell this store isn't dead.  */
7331   emit_use (tmp);
7332 }
7333
7334 /* Clear variables at function end.  */
7335
7336 static void
7337 sh_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
7338                              HOST_WIDE_INT size ATTRIBUTE_UNUSED)
7339 {
7340   sh_need_epilogue_known = 0;
7341 }
7342
7343 static rtx
7344 sh_builtin_saveregs (void)
7345 {
7346   /* First unnamed integer register.  */
7347   int first_intreg = crtl->args.info.arg_count[(int) SH_ARG_INT];
7348   /* Number of integer registers we need to save.  */
7349   int n_intregs = MAX (0, NPARM_REGS (SImode) - first_intreg);
7350   /* First unnamed SFmode float reg */
7351   int first_floatreg = crtl->args.info.arg_count[(int) SH_ARG_FLOAT];
7352   /* Number of SFmode float regs to save.  */
7353   int n_floatregs = MAX (0, NPARM_REGS (SFmode) - first_floatreg);
7354   rtx regbuf, fpregs;
7355   int bufsize, regno;
7356   alias_set_type alias_set;
7357
7358   if (TARGET_SH5)
7359     {
7360       if (n_intregs)
7361         {
7362           int pushregs = n_intregs;
7363
7364           while (pushregs < NPARM_REGS (SImode) - 1
7365                  && (CALL_COOKIE_INT_REG_GET
7366                         (crtl->args.info.call_cookie,
7367                          NPARM_REGS (SImode) - pushregs)
7368                      == 1))
7369             {
7370               crtl->args.info.call_cookie
7371                 &= ~ CALL_COOKIE_INT_REG (NPARM_REGS (SImode)
7372                                           - pushregs, 1);
7373               pushregs++;
7374             }
7375
7376           if (pushregs == NPARM_REGS (SImode))
7377             crtl->args.info.call_cookie
7378               |= (CALL_COOKIE_INT_REG (0, 1)
7379                   | CALL_COOKIE_STACKSEQ (pushregs - 1));
7380           else
7381             crtl->args.info.call_cookie
7382               |= CALL_COOKIE_STACKSEQ (pushregs);
7383
7384           crtl->args.pretend_args_size += 8 * n_intregs;
7385         }
7386       if (TARGET_SHCOMPACT)
7387         return const0_rtx;
7388     }
7389
7390   if (! TARGET_SH2E && ! TARGET_SH4 && ! TARGET_SH5)
7391     {
7392       error ("__builtin_saveregs not supported by this subtarget");
7393       return const0_rtx;
7394     }
7395
7396   if (TARGET_SHMEDIA)
7397     n_floatregs = 0;
7398
7399   /* Allocate block of memory for the regs.  */
7400   /* ??? If n_intregs + n_floatregs == 0, should we allocate at least 1 byte?
7401      Or can assign_stack_local accept a 0 SIZE argument?  */
7402   bufsize = (n_intregs * UNITS_PER_WORD) + (n_floatregs * UNITS_PER_WORD);
7403
7404   if (TARGET_SHMEDIA)
7405     regbuf = gen_frame_mem (BLKmode, gen_rtx_REG (Pmode, ARG_POINTER_REGNUM));
7406   else if (n_floatregs & 1)
7407     {
7408       rtx addr;
7409
7410       regbuf = assign_stack_local (BLKmode, bufsize + UNITS_PER_WORD, 0);
7411       addr = copy_to_mode_reg (Pmode, XEXP (regbuf, 0));
7412       emit_insn (gen_iorsi3 (addr, addr, GEN_INT (UNITS_PER_WORD)));
7413       regbuf = change_address (regbuf, BLKmode, addr);
7414     }
7415   else if (STACK_BOUNDARY < 64 && TARGET_FPU_DOUBLE && n_floatregs)
7416     {
7417       rtx addr, mask;
7418
7419       regbuf = assign_stack_local (BLKmode, bufsize + UNITS_PER_WORD, 0);
7420       addr = copy_to_mode_reg (Pmode, plus_constant (XEXP (regbuf, 0), 4));
7421       mask = copy_to_mode_reg (Pmode, GEN_INT (-8));
7422       emit_insn (gen_andsi3 (addr, addr, mask));
7423       regbuf = change_address (regbuf, BLKmode, addr);
7424     }
7425   else
7426     regbuf = assign_stack_local (BLKmode, bufsize, TARGET_FPU_DOUBLE ? 64 : 0);
7427   alias_set = get_varargs_alias_set ();
7428   set_mem_alias_set (regbuf, alias_set);
7429
7430   /* Save int args.
7431      This is optimized to only save the regs that are necessary.  Explicitly
7432      named args need not be saved.  */
7433   if (n_intregs > 0)
7434     move_block_from_reg (BASE_ARG_REG (SImode) + first_intreg,
7435                          adjust_address (regbuf, BLKmode,
7436                                          n_floatregs * UNITS_PER_WORD),
7437                          n_intregs);
7438
7439   if (TARGET_SHMEDIA)
7440     /* Return the address of the regbuf.  */
7441     return XEXP (regbuf, 0);
7442
7443   /* Save float args.
7444      This is optimized to only save the regs that are necessary.  Explicitly
7445      named args need not be saved.
7446      We explicitly build a pointer to the buffer because it halves the insn
7447      count when not optimizing (otherwise the pointer is built for each reg
7448      saved).
7449      We emit the moves in reverse order so that we can use predecrement.  */
7450
7451   fpregs = copy_to_mode_reg (Pmode,
7452                              plus_constant (XEXP (regbuf, 0),
7453                                             n_floatregs * UNITS_PER_WORD));
7454   if (TARGET_SH4 || TARGET_SH2A_DOUBLE)
7455     {
7456       rtx mem;
7457       for (regno = NPARM_REGS (DFmode) - 2; regno >= first_floatreg; regno -= 2)
7458         {
7459           emit_insn (gen_addsi3 (fpregs, fpregs,
7460                                  GEN_INT (-2 * UNITS_PER_WORD)));
7461           mem = change_address (regbuf, DFmode, fpregs);
7462           emit_move_insn (mem,
7463                           gen_rtx_REG (DFmode, BASE_ARG_REG (DFmode) + regno));
7464         }
7465       regno = first_floatreg;
7466       if (regno & 1)
7467         {
7468           emit_insn (gen_addsi3 (fpregs, fpregs, GEN_INT (-UNITS_PER_WORD)));
7469           mem = change_address (regbuf, SFmode, fpregs);
7470           emit_move_insn (mem,
7471                           gen_rtx_REG (SFmode, BASE_ARG_REG (SFmode) + regno
7472                                                 - (TARGET_LITTLE_ENDIAN != 0)));
7473         }
7474     }
7475   else
7476     for (regno = NPARM_REGS (SFmode) - 1; regno >= first_floatreg; regno--)
7477       {
7478         rtx mem;
7479
7480         emit_insn (gen_addsi3 (fpregs, fpregs, GEN_INT (-UNITS_PER_WORD)));
7481         mem = change_address (regbuf, SFmode, fpregs);
7482         emit_move_insn (mem,
7483                         gen_rtx_REG (SFmode, BASE_ARG_REG (SFmode) + regno));
7484       }
7485
7486   /* Return the address of the regbuf.  */
7487   return XEXP (regbuf, 0);
7488 }
7489
7490 /* Define the `__builtin_va_list' type for the ABI.  */
7491
7492 static tree
7493 sh_build_builtin_va_list (void)
7494 {
7495   tree f_next_o, f_next_o_limit, f_next_fp, f_next_fp_limit, f_next_stack;
7496   tree record;
7497
7498   if (TARGET_SH5 || (! TARGET_SH2E && ! TARGET_SH4)
7499       || TARGET_HITACHI || sh_cfun_attr_renesas_p ())
7500     return ptr_type_node;
7501
7502   record = (*lang_hooks.types.make_type) (RECORD_TYPE);
7503
7504   f_next_o = build_decl (FIELD_DECL, get_identifier ("__va_next_o"),
7505                          ptr_type_node);
7506   f_next_o_limit = build_decl (FIELD_DECL,
7507                                get_identifier ("__va_next_o_limit"),
7508                                ptr_type_node);
7509   f_next_fp = build_decl (FIELD_DECL, get_identifier ("__va_next_fp"),
7510                           ptr_type_node);
7511   f_next_fp_limit = build_decl (FIELD_DECL,
7512                                 get_identifier ("__va_next_fp_limit"),
7513                                 ptr_type_node);
7514   f_next_stack = build_decl (FIELD_DECL, get_identifier ("__va_next_stack"),
7515                              ptr_type_node);
7516
7517   DECL_FIELD_CONTEXT (f_next_o) = record;
7518   DECL_FIELD_CONTEXT (f_next_o_limit) = record;
7519   DECL_FIELD_CONTEXT (f_next_fp) = record;
7520   DECL_FIELD_CONTEXT (f_next_fp_limit) = record;
7521   DECL_FIELD_CONTEXT (f_next_stack) = record;
7522
7523   TYPE_FIELDS (record) = f_next_o;
7524   TREE_CHAIN (f_next_o) = f_next_o_limit;
7525   TREE_CHAIN (f_next_o_limit) = f_next_fp;
7526   TREE_CHAIN (f_next_fp) = f_next_fp_limit;
7527   TREE_CHAIN (f_next_fp_limit) = f_next_stack;
7528
7529   layout_type (record);
7530
7531   return record;
7532 }
7533
7534 /* Implement `va_start' for varargs and stdarg.  */
7535
7536 static void
7537 sh_va_start (tree valist, rtx nextarg)
7538 {
7539   tree f_next_o, f_next_o_limit, f_next_fp, f_next_fp_limit, f_next_stack;
7540   tree next_o, next_o_limit, next_fp, next_fp_limit, next_stack;
7541   tree t, u;
7542   int nfp, nint;
7543
7544   if (TARGET_SH5)
7545     {
7546       expand_builtin_saveregs ();
7547       std_expand_builtin_va_start (valist, nextarg);
7548       return;
7549     }
7550
7551   if ((! TARGET_SH2E && ! TARGET_SH4)
7552       || TARGET_HITACHI || sh_cfun_attr_renesas_p ())
7553     {
7554       std_expand_builtin_va_start (valist, nextarg);
7555       return;
7556     }
7557
7558   f_next_o = TYPE_FIELDS (va_list_type_node);
7559   f_next_o_limit = TREE_CHAIN (f_next_o);
7560   f_next_fp = TREE_CHAIN (f_next_o_limit);
7561   f_next_fp_limit = TREE_CHAIN (f_next_fp);
7562   f_next_stack = TREE_CHAIN (f_next_fp_limit);
7563
7564   next_o = build3 (COMPONENT_REF, TREE_TYPE (f_next_o), valist, f_next_o,
7565                    NULL_TREE);
7566   next_o_limit = build3 (COMPONENT_REF, TREE_TYPE (f_next_o_limit),
7567                          valist, f_next_o_limit, NULL_TREE);
7568   next_fp = build3 (COMPONENT_REF, TREE_TYPE (f_next_fp), valist, f_next_fp,
7569                     NULL_TREE);
7570   next_fp_limit = build3 (COMPONENT_REF, TREE_TYPE (f_next_fp_limit),
7571                           valist, f_next_fp_limit, NULL_TREE);
7572   next_stack = build3 (COMPONENT_REF, TREE_TYPE (f_next_stack),
7573                        valist, f_next_stack, NULL_TREE);
7574
7575   /* Call __builtin_saveregs.  */
7576   u = make_tree (sizetype, expand_builtin_saveregs ());
7577   u = fold_convert (ptr_type_node, u);
7578   t = build2 (MODIFY_EXPR, ptr_type_node, next_fp, u);
7579   TREE_SIDE_EFFECTS (t) = 1;
7580   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7581
7582   nfp = crtl->args.info.arg_count[SH_ARG_FLOAT];
7583   if (nfp < 8)
7584     nfp = 8 - nfp;
7585   else
7586     nfp = 0;
7587   u = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, u,
7588                    size_int (UNITS_PER_WORD * nfp));
7589   t = build2 (MODIFY_EXPR, ptr_type_node, next_fp_limit, u);
7590   TREE_SIDE_EFFECTS (t) = 1;
7591   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7592
7593   t = build2 (MODIFY_EXPR, ptr_type_node, next_o, u);
7594   TREE_SIDE_EFFECTS (t) = 1;
7595   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7596
7597   nint = crtl->args.info.arg_count[SH_ARG_INT];
7598   if (nint < 4)
7599     nint = 4 - nint;
7600   else
7601     nint = 0;
7602   u = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, u,
7603                    size_int (UNITS_PER_WORD * nint));
7604   t = build2 (MODIFY_EXPR, ptr_type_node, next_o_limit, u);
7605   TREE_SIDE_EFFECTS (t) = 1;
7606   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7607
7608   u = make_tree (ptr_type_node, nextarg);
7609   t = build2 (MODIFY_EXPR, ptr_type_node, next_stack, u);
7610   TREE_SIDE_EFFECTS (t) = 1;
7611   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7612 }
7613
7614 /* TYPE is a RECORD_TYPE.  If there is only a single nonzero-sized
7615    member, return it.  */
7616 static tree
7617 find_sole_member (tree type)
7618 {
7619   tree field, member = NULL_TREE;
7620
7621   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
7622     {
7623       if (TREE_CODE (field) != FIELD_DECL)
7624         continue;
7625       if (!DECL_SIZE (field))
7626         return NULL_TREE;
7627       if (integer_zerop (DECL_SIZE (field)))
7628         continue;
7629       if (member)
7630         return NULL_TREE;
7631       member = field;
7632     }
7633   return member;
7634 }
7635 /* Implement `va_arg'.  */
7636
7637 static tree
7638 sh_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
7639                          gimple_seq *post_p ATTRIBUTE_UNUSED)
7640 {
7641   HOST_WIDE_INT size, rsize;
7642   tree tmp, pptr_type_node;
7643   tree addr, lab_over = NULL, result = NULL;
7644   int pass_by_ref = targetm.calls.must_pass_in_stack (TYPE_MODE (type), type);
7645   tree eff_type;
7646
7647   if (pass_by_ref)
7648     type = build_pointer_type (type);
7649
7650   size = int_size_in_bytes (type);
7651   rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
7652   pptr_type_node = build_pointer_type (ptr_type_node);
7653
7654   if (! TARGET_SH5 && (TARGET_SH2E || TARGET_SH4)
7655       && ! (TARGET_HITACHI || sh_cfun_attr_renesas_p ()))
7656     {
7657       tree f_next_o, f_next_o_limit, f_next_fp, f_next_fp_limit, f_next_stack;
7658       tree next_o, next_o_limit, next_fp, next_fp_limit, next_stack;
7659       int pass_as_float;
7660       tree lab_false;
7661       tree member;
7662
7663       f_next_o = TYPE_FIELDS (va_list_type_node);
7664       f_next_o_limit = TREE_CHAIN (f_next_o);
7665       f_next_fp = TREE_CHAIN (f_next_o_limit);
7666       f_next_fp_limit = TREE_CHAIN (f_next_fp);
7667       f_next_stack = TREE_CHAIN (f_next_fp_limit);
7668
7669       next_o = build3 (COMPONENT_REF, TREE_TYPE (f_next_o), valist, f_next_o,
7670                        NULL_TREE);
7671       next_o_limit = build3 (COMPONENT_REF, TREE_TYPE (f_next_o_limit),
7672                              valist, f_next_o_limit, NULL_TREE);
7673       next_fp = build3 (COMPONENT_REF, TREE_TYPE (f_next_fp),
7674                         valist, f_next_fp, NULL_TREE);
7675       next_fp_limit = build3 (COMPONENT_REF, TREE_TYPE (f_next_fp_limit),
7676                               valist, f_next_fp_limit, NULL_TREE);
7677       next_stack = build3 (COMPONENT_REF, TREE_TYPE (f_next_stack),
7678                            valist, f_next_stack, NULL_TREE);
7679
7680       /* Structures with a single member with a distinct mode are passed
7681          like their member.  This is relevant if the latter has a REAL_TYPE
7682          or COMPLEX_TYPE type.  */
7683       eff_type = type;
7684       while (TREE_CODE (eff_type) == RECORD_TYPE
7685              && (member = find_sole_member (eff_type))
7686              && (TREE_CODE (TREE_TYPE (member)) == REAL_TYPE
7687                  || TREE_CODE (TREE_TYPE (member)) == COMPLEX_TYPE
7688                  || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE))
7689         {
7690           tree field_type = TREE_TYPE (member);
7691
7692           if (TYPE_MODE (eff_type) == TYPE_MODE (field_type))
7693             eff_type = field_type;
7694           else
7695             {
7696               gcc_assert ((TYPE_ALIGN (eff_type)
7697                            < GET_MODE_ALIGNMENT (TYPE_MODE (field_type)))
7698                           || (TYPE_ALIGN (eff_type)
7699                               > GET_MODE_BITSIZE (TYPE_MODE (field_type))));
7700               break;
7701             }
7702         }
7703
7704       if (TARGET_SH4 || TARGET_SH2A_DOUBLE)
7705         {
7706           pass_as_float = ((TREE_CODE (eff_type) == REAL_TYPE && size <= 8)
7707                            || (TREE_CODE (eff_type) == COMPLEX_TYPE
7708                                && TREE_CODE (TREE_TYPE (eff_type)) == REAL_TYPE
7709                                && size <= 16));
7710         }
7711       else
7712         {
7713           pass_as_float = (TREE_CODE (eff_type) == REAL_TYPE && size == 4);
7714         }
7715
7716       addr = create_tmp_var (pptr_type_node, NULL);
7717       lab_false = create_artificial_label ();
7718       lab_over = create_artificial_label ();
7719
7720       valist = build1 (INDIRECT_REF, ptr_type_node, addr);
7721
7722       if (pass_as_float)
7723         {
7724           tree next_fp_tmp = create_tmp_var (TREE_TYPE (f_next_fp), NULL);
7725           tree cmp;
7726           bool is_double = size == 8 && TREE_CODE (eff_type) == REAL_TYPE;
7727
7728           tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_fp));
7729           gimplify_assign (unshare_expr (addr), tmp, pre_p);
7730
7731           gimplify_assign (unshare_expr (next_fp_tmp), valist, pre_p);
7732           tmp = next_fp_limit;
7733           if (size > 4 && !is_double)
7734             tmp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (tmp),
7735                           unshare_expr (tmp), size_int (4 - size));
7736           tmp = build2 (GE_EXPR, boolean_type_node,
7737                         unshare_expr (next_fp_tmp), unshare_expr (tmp));
7738           cmp = build3 (COND_EXPR, void_type_node, tmp,
7739                         build1 (GOTO_EXPR, void_type_node,
7740                                 unshare_expr (lab_false)), NULL_TREE);
7741           if (!is_double)
7742             gimplify_and_add (cmp, pre_p);
7743
7744           if (TYPE_ALIGN (eff_type) > BITS_PER_WORD
7745               || (is_double || size == 16))
7746             {
7747               tmp = fold_convert (sizetype, next_fp_tmp);
7748               tmp = build2 (BIT_AND_EXPR, sizetype, tmp,
7749                             size_int (UNITS_PER_WORD));
7750               tmp = build2 (POINTER_PLUS_EXPR, ptr_type_node,
7751                             unshare_expr (next_fp_tmp), tmp);
7752               gimplify_assign (unshare_expr (next_fp_tmp), tmp, pre_p);
7753             }
7754           if (is_double)
7755             gimplify_and_add (cmp, pre_p);
7756
7757 #ifdef FUNCTION_ARG_SCmode_WART
7758           if (TYPE_MODE (eff_type) == SCmode
7759               && TARGET_SH4 && TARGET_LITTLE_ENDIAN)
7760             {
7761               tree subtype = TREE_TYPE (eff_type);
7762               tree real, imag;
7763
7764               imag
7765                 = std_gimplify_va_arg_expr (next_fp_tmp, subtype, pre_p, NULL);
7766               imag = get_initialized_tmp_var (imag, pre_p, NULL);
7767
7768               real
7769                 = std_gimplify_va_arg_expr (next_fp_tmp, subtype, pre_p, NULL);
7770               real = get_initialized_tmp_var (real, pre_p, NULL);
7771
7772               result = build2 (COMPLEX_EXPR, eff_type, real, imag);
7773               if (type != eff_type)
7774                 result = build1 (VIEW_CONVERT_EXPR, type, result);
7775               result = get_initialized_tmp_var (result, pre_p, NULL);
7776             }
7777 #endif /* FUNCTION_ARG_SCmode_WART */
7778
7779           tmp = build1 (GOTO_EXPR, void_type_node, unshare_expr (lab_over));
7780           gimplify_and_add (tmp, pre_p);
7781
7782           tmp = build1 (LABEL_EXPR, void_type_node, unshare_expr (lab_false));
7783           gimplify_and_add (tmp, pre_p);
7784
7785           tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_stack));
7786           gimplify_assign (unshare_expr (addr), tmp, pre_p);
7787           gimplify_assign (unshare_expr (next_fp_tmp),
7788                            unshare_expr (valist), pre_p);
7789
7790           gimplify_assign (unshare_expr (valist),
7791                            unshare_expr (next_fp_tmp), post_p);
7792           valist = next_fp_tmp;
7793         }
7794       else
7795         {
7796           tmp = build2 (POINTER_PLUS_EXPR, ptr_type_node,
7797                         unshare_expr (next_o), size_int (rsize));
7798           tmp = build2 (GT_EXPR, boolean_type_node, tmp,
7799                         unshare_expr (next_o_limit));
7800           tmp = build3 (COND_EXPR, void_type_node, tmp,
7801                         build1 (GOTO_EXPR, void_type_node,
7802                                 unshare_expr (lab_false)),
7803                         NULL_TREE);
7804           gimplify_and_add (tmp, pre_p);
7805
7806           tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_o));
7807           gimplify_assign (unshare_expr (addr), tmp, pre_p);
7808
7809           tmp = build1 (GOTO_EXPR, void_type_node, unshare_expr (lab_over));
7810           gimplify_and_add (tmp, pre_p);
7811
7812           tmp = build1 (LABEL_EXPR, void_type_node, unshare_expr (lab_false));
7813           gimplify_and_add (tmp, pre_p);
7814
7815           if (size > 4 && ! (TARGET_SH4 || TARGET_SH2A))
7816             gimplify_assign (unshare_expr (next_o),
7817                              unshare_expr (next_o_limit), pre_p);
7818
7819           tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_stack));
7820           gimplify_assign (unshare_expr (addr), tmp, pre_p);
7821         }
7822
7823       if (!result)
7824         {
7825           tmp = build1 (LABEL_EXPR, void_type_node, unshare_expr (lab_over));
7826           gimplify_and_add (tmp, pre_p);
7827         }
7828     }
7829
7830   /* ??? In va-sh.h, there had been code to make values larger than
7831      size 8 indirect.  This does not match the FUNCTION_ARG macros.  */
7832
7833   tmp = std_gimplify_va_arg_expr (valist, type, pre_p, NULL);
7834   if (result)
7835     {
7836       gimplify_assign (result, tmp, pre_p);
7837
7838       tmp = build1 (LABEL_EXPR, void_type_node, unshare_expr (lab_over));
7839       gimplify_and_add (tmp, pre_p);
7840     }
7841   else
7842     result = tmp;
7843
7844   if (pass_by_ref)
7845     result = build_va_arg_indirect_ref (result);
7846
7847   return result;
7848 }
7849
7850 /* 64 bit floating points memory transfers are paired single precision loads
7851    or store. So DWARF information needs fixing in little endian (unless
7852    PR=SZ=1 in FPSCR).  */
7853 rtx
7854 sh_dwarf_register_span (rtx reg)
7855 {
7856   unsigned regno = REGNO (reg);
7857
7858   if (WORDS_BIG_ENDIAN || GET_MODE (reg) != DFmode)
7859     return NULL_RTX;
7860
7861   return
7862     gen_rtx_PARALLEL (VOIDmode,
7863                       gen_rtvec (2,
7864                                  gen_rtx_REG (SFmode,
7865                                               DBX_REGISTER_NUMBER (regno+1)),
7866                                  gen_rtx_REG (SFmode,
7867                                               DBX_REGISTER_NUMBER (regno))));
7868 }
7869
7870 bool
7871 sh_promote_prototypes (const_tree type)
7872 {
7873   if (TARGET_HITACHI)
7874     return 0;
7875   if (! type)
7876     return 1;
7877   return ! sh_attr_renesas_p (type);
7878 }
7879
7880 /* Whether an argument must be passed by reference.  On SHcompact, we
7881    pretend arguments wider than 32-bits that would have been passed in
7882    registers are passed by reference, so that an SHmedia trampoline
7883    loads them into the full 64-bits registers.  */
7884
7885 static int
7886 shcompact_byref (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
7887                  const_tree type, bool named)
7888 {
7889   unsigned HOST_WIDE_INT size;
7890
7891   if (type)
7892     size = int_size_in_bytes (type);
7893   else
7894     size = GET_MODE_SIZE (mode);
7895
7896   if (cum->arg_count[SH_ARG_INT] < NPARM_REGS (SImode)
7897       && (!named
7898           || GET_SH_ARG_CLASS (mode) == SH_ARG_INT
7899           || (GET_SH_ARG_CLASS (mode) == SH_ARG_FLOAT
7900               && cum->arg_count[SH_ARG_FLOAT] >= NPARM_REGS (SFmode)))
7901       && size > 4
7902       && !SHCOMPACT_FORCE_ON_STACK (mode, type)
7903       && !SH5_WOULD_BE_PARTIAL_NREGS (*cum, mode, type, named))
7904     return size;
7905   else
7906     return 0;
7907 }
7908
7909 static bool
7910 sh_pass_by_reference (CUMULATIVE_ARGS *cum, enum machine_mode mode,
7911                       const_tree type, bool named)
7912 {
7913   if (targetm.calls.must_pass_in_stack (mode, type))
7914     return true;
7915
7916   /* ??? std_gimplify_va_arg_expr passes NULL for cum.  That function
7917      wants to know about pass-by-reference semantics for incoming
7918      arguments.  */
7919   if (! cum)
7920     return false;
7921
7922   if (TARGET_SHCOMPACT)
7923     {
7924       cum->byref = shcompact_byref (cum, mode, type, named);
7925       return cum->byref != 0;
7926     }
7927
7928   return false;
7929 }
7930
7931 static bool
7932 sh_callee_copies (CUMULATIVE_ARGS *cum, enum machine_mode mode,
7933                   const_tree type, bool named ATTRIBUTE_UNUSED)
7934 {
7935   /* ??? How can it possibly be correct to return true only on the
7936      caller side of the equation?  Is there someplace else in the
7937      sh backend that's magically producing the copies?  */
7938   return (cum->outgoing
7939           && ((mode == BLKmode ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode))
7940               % SH_MIN_ALIGN_FOR_CALLEE_COPY == 0));
7941 }
7942
7943 static int
7944 sh_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
7945                       tree type, bool named ATTRIBUTE_UNUSED)
7946 {
7947   int words = 0;
7948
7949   if (!TARGET_SH5
7950       && PASS_IN_REG_P (*cum, mode, type)
7951       && !(TARGET_SH4 || TARGET_SH2A_DOUBLE)
7952       && (ROUND_REG (*cum, mode)
7953           + (mode != BLKmode
7954              ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
7955              : ROUND_ADVANCE (int_size_in_bytes (type)))
7956           > NPARM_REGS (mode)))
7957     words = NPARM_REGS (mode) - ROUND_REG (*cum, mode);
7958
7959   else if (!TARGET_SHCOMPACT
7960            && SH5_WOULD_BE_PARTIAL_NREGS (*cum, mode, type, named))
7961     words = NPARM_REGS (SImode) - cum->arg_count[SH_ARG_INT];
7962
7963   return words * UNITS_PER_WORD;
7964 }
7965
7966
7967 /* Define where to put the arguments to a function.
7968    Value is zero to push the argument on the stack,
7969    or a hard register in which to store the argument.
7970
7971    MODE is the argument's machine mode.
7972    TYPE is the data type of the argument (as a tree).
7973     This is null for libcalls where that information may
7974     not be available.
7975    CUM is a variable of type CUMULATIVE_ARGS which gives info about
7976     the preceding args and about the function being called.
7977    NAMED is nonzero if this argument is a named parameter
7978     (otherwise it is an extra parameter matching an ellipsis).
7979
7980    On SH the first args are normally in registers
7981    and the rest are pushed.  Any arg that starts within the first
7982    NPARM_REGS words is at least partially passed in a register unless
7983    its data type forbids.  */
7984
7985
7986 rtx
7987 sh_function_arg (CUMULATIVE_ARGS *ca, enum machine_mode mode,
7988                  tree type, int named)
7989 {
7990   if (! TARGET_SH5 && mode == VOIDmode)
7991     return GEN_INT (ca->renesas_abi ? 1 : 0);
7992
7993   if (! TARGET_SH5
7994       && PASS_IN_REG_P (*ca, mode, type)
7995       && (named || ! (TARGET_HITACHI || ca->renesas_abi)))
7996     {
7997       int regno;
7998
7999       if (mode == SCmode && TARGET_SH4 && TARGET_LITTLE_ENDIAN
8000           && (! FUNCTION_ARG_SCmode_WART || (ROUND_REG (*ca, mode) & 1)))
8001         {
8002           rtx r1 = gen_rtx_EXPR_LIST (VOIDmode,
8003                                       gen_rtx_REG (SFmode,
8004                                                    BASE_ARG_REG (mode)
8005                                                    + (ROUND_REG (*ca, mode) ^ 1)),
8006                                       const0_rtx);
8007           rtx r2 = gen_rtx_EXPR_LIST (VOIDmode,
8008                                       gen_rtx_REG (SFmode,
8009                                                    BASE_ARG_REG (mode)
8010                                                    + ((ROUND_REG (*ca, mode) + 1) ^ 1)),
8011                                       GEN_INT (4));
8012           return gen_rtx_PARALLEL(SCmode, gen_rtvec(2, r1, r2));
8013         }
8014
8015      /* If the alignment of a DF value causes an SF register to be
8016         skipped, we will use that skipped register for the next SF
8017         value.  */
8018       if ((TARGET_HITACHI || ca->renesas_abi)
8019           && ca->free_single_fp_reg
8020           && mode == SFmode)
8021         return gen_rtx_REG (mode, ca->free_single_fp_reg);
8022
8023       regno = (BASE_ARG_REG (mode) + ROUND_REG (*ca, mode))
8024                ^ (mode == SFmode && TARGET_SH4
8025                   && TARGET_LITTLE_ENDIAN != 0
8026                   && ! TARGET_HITACHI && ! ca->renesas_abi);
8027       return gen_rtx_REG (mode, regno);
8028
8029     }
8030
8031   if (TARGET_SH5)
8032     {
8033       if (mode == VOIDmode && TARGET_SHCOMPACT)
8034         return GEN_INT (ca->call_cookie);
8035
8036       /* The following test assumes unnamed arguments are promoted to
8037          DFmode.  */
8038       if (mode == SFmode && ca->free_single_fp_reg)
8039         return SH5_PROTOTYPED_FLOAT_ARG (*ca, mode, ca->free_single_fp_reg);
8040
8041       if ((GET_SH_ARG_CLASS (mode) == SH_ARG_FLOAT)
8042           && (named || ! ca->prototype_p)
8043           && ca->arg_count[(int) SH_ARG_FLOAT] < NPARM_REGS (SFmode))
8044         {
8045           if (! ca->prototype_p && TARGET_SHMEDIA)
8046             return SH5_PROTOTYPELESS_FLOAT_ARG (*ca, mode);
8047
8048           return SH5_PROTOTYPED_FLOAT_ARG (*ca, mode,
8049                                            FIRST_FP_PARM_REG
8050                                            + ca->arg_count[(int) SH_ARG_FLOAT]);
8051         }
8052
8053       if (ca->arg_count[(int) SH_ARG_INT] < NPARM_REGS (SImode)
8054           && (! TARGET_SHCOMPACT
8055               || (! SHCOMPACT_FORCE_ON_STACK (mode, type)
8056                   && ! SH5_WOULD_BE_PARTIAL_NREGS (*ca, mode,
8057                                                    type, named))))
8058         {
8059           return gen_rtx_REG (mode, (FIRST_PARM_REG
8060                                        + ca->arg_count[(int) SH_ARG_INT]));
8061         }
8062
8063       return 0;
8064     }
8065
8066   return 0;
8067 }
8068
8069 /* Update the data in CUM to advance over an argument
8070    of mode MODE and data type TYPE.
8071    (TYPE is null for libcalls where that information may not be
8072    available.)  */
8073
8074 void
8075 sh_function_arg_advance (CUMULATIVE_ARGS *ca, enum machine_mode mode,
8076                          tree type, int named)
8077 {
8078   if (ca->force_mem)
8079     ca->force_mem = 0;
8080   else if (TARGET_SH5)
8081     {
8082       tree type2 = (ca->byref && type
8083                     ? TREE_TYPE (type)
8084                     : type);
8085       enum machine_mode mode2 = (ca->byref && type
8086                                  ? TYPE_MODE (type2)
8087                                  : mode);
8088       int dwords = ((ca->byref
8089                      ? ca->byref
8090                      : mode2 == BLKmode
8091                      ? int_size_in_bytes (type2)
8092                      : GET_MODE_SIZE (mode2)) + 7) / 8;
8093       int numregs = MIN (dwords, NPARM_REGS (SImode)
8094                          - ca->arg_count[(int) SH_ARG_INT]);
8095
8096       if (numregs)
8097         {
8098           ca->arg_count[(int) SH_ARG_INT] += numregs;
8099           if (TARGET_SHCOMPACT
8100               && SHCOMPACT_FORCE_ON_STACK (mode2, type2))
8101             {
8102               ca->call_cookie
8103                 |= CALL_COOKIE_INT_REG (ca->arg_count[(int) SH_ARG_INT]
8104                                         - numregs, 1);
8105               /* N.B. We want this also for outgoing.  */
8106               ca->stack_regs += numregs;
8107             }
8108           else if (ca->byref)
8109             {
8110               if (! ca->outgoing)
8111                 ca->stack_regs += numregs;
8112               ca->byref_regs += numregs;
8113               ca->byref = 0;
8114               do
8115                 ca->call_cookie
8116                   |= CALL_COOKIE_INT_REG (ca->arg_count[(int) SH_ARG_INT]
8117                                           - numregs, 2);
8118               while (--numregs);
8119               ca->call_cookie
8120                 |= CALL_COOKIE_INT_REG (ca->arg_count[(int) SH_ARG_INT]
8121                                         - 1, 1);
8122             }
8123           else if (dwords > numregs)
8124             {
8125               int pushregs = numregs;
8126
8127               if (TARGET_SHCOMPACT)
8128                 ca->stack_regs += numregs;
8129               while (pushregs < NPARM_REGS (SImode) - 1
8130                      && (CALL_COOKIE_INT_REG_GET
8131                          (ca->call_cookie,
8132                           NPARM_REGS (SImode) - pushregs)
8133                          == 1))
8134                 {
8135                   ca->call_cookie
8136                     &= ~ CALL_COOKIE_INT_REG (NPARM_REGS (SImode)
8137                                               - pushregs, 1);
8138                   pushregs++;
8139                 }
8140               if (numregs == NPARM_REGS (SImode))
8141                 ca->call_cookie
8142                   |= CALL_COOKIE_INT_REG (0, 1)
8143                   | CALL_COOKIE_STACKSEQ (numregs - 1);
8144               else
8145                 ca->call_cookie
8146                   |= CALL_COOKIE_STACKSEQ (numregs);
8147             }
8148         }
8149       if (GET_SH_ARG_CLASS (mode2) == SH_ARG_FLOAT
8150           && (named || ! ca->prototype_p))
8151         {
8152           if (mode2 == SFmode && ca->free_single_fp_reg)
8153             ca->free_single_fp_reg = 0;
8154           else if (ca->arg_count[(int) SH_ARG_FLOAT]
8155                    < NPARM_REGS (SFmode))
8156             {
8157               int numfpregs
8158                 = MIN ((GET_MODE_SIZE (mode2) + 7) / 8 * 2,
8159                        NPARM_REGS (SFmode)
8160                        - ca->arg_count[(int) SH_ARG_FLOAT]);
8161
8162               ca->arg_count[(int) SH_ARG_FLOAT] += numfpregs;
8163
8164               if (TARGET_SHCOMPACT && ! ca->prototype_p)
8165                 {
8166                   if (ca->outgoing && numregs > 0)
8167                     do
8168                       {
8169                         ca->call_cookie
8170                           |= (CALL_COOKIE_INT_REG
8171                               (ca->arg_count[(int) SH_ARG_INT]
8172                                - numregs + ((numfpregs - 2) / 2),
8173                                4 + (ca->arg_count[(int) SH_ARG_FLOAT]
8174                                     - numfpregs) / 2));
8175                       }
8176                     while (numfpregs -= 2);
8177                 }
8178               else if (mode2 == SFmode && (named)
8179                        && (ca->arg_count[(int) SH_ARG_FLOAT]
8180                            < NPARM_REGS (SFmode)))
8181                 ca->free_single_fp_reg
8182                   = FIRST_FP_PARM_REG - numfpregs
8183                   + ca->arg_count[(int) SH_ARG_FLOAT] + 1;
8184             }
8185         }
8186       return;
8187     }
8188
8189   if ((TARGET_HITACHI || ca->renesas_abi) && TARGET_FPU_DOUBLE)
8190     {
8191       /* Note that we've used the skipped register.  */
8192       if (mode == SFmode && ca->free_single_fp_reg)
8193         {
8194           ca->free_single_fp_reg = 0;
8195           return;
8196         }
8197       /* When we have a DF after an SF, there's an SF register that get
8198          skipped in order to align the DF value.  We note this skipped
8199          register, because the next SF value will use it, and not the
8200          SF that follows the DF.  */
8201       if (mode == DFmode
8202           && ROUND_REG (*ca, DFmode) != ROUND_REG (*ca, SFmode))
8203         {
8204           ca->free_single_fp_reg = (ROUND_REG (*ca, SFmode)
8205                                     + BASE_ARG_REG (mode));
8206         }
8207     }
8208
8209   if (! ((TARGET_SH4 || TARGET_SH2A) || ca->renesas_abi)
8210       || PASS_IN_REG_P (*ca, mode, type))
8211     (ca->arg_count[(int) GET_SH_ARG_CLASS (mode)]
8212      = (ROUND_REG (*ca, mode)
8213         + (mode == BLKmode
8214            ? ROUND_ADVANCE (int_size_in_bytes (type))
8215            : ROUND_ADVANCE (GET_MODE_SIZE (mode)))));
8216 }
8217
8218 /* The Renesas calling convention doesn't quite fit into this scheme since
8219    the address is passed like an invisible argument, but one that is always
8220    passed in memory.  */
8221 static rtx
8222 sh_struct_value_rtx (tree fndecl, int incoming ATTRIBUTE_UNUSED)
8223 {
8224   if (TARGET_HITACHI || sh_attr_renesas_p (fndecl))
8225     return 0;
8226   return gen_rtx_REG (Pmode, 2);
8227 }
8228
8229 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
8230
8231 static bool
8232 sh_return_in_memory (const_tree type, const_tree fndecl)
8233 {
8234   if (TARGET_SH5)
8235     {
8236       if (TYPE_MODE (type) == BLKmode)
8237         return ((unsigned HOST_WIDE_INT) int_size_in_bytes (type)) > 8;
8238       else
8239         return GET_MODE_SIZE (TYPE_MODE (type)) > 8;
8240     }
8241   else
8242     {
8243       return (TYPE_MODE (type) == BLKmode
8244               || ((TARGET_HITACHI || sh_attr_renesas_p (fndecl))
8245                   && TREE_CODE (type) == RECORD_TYPE));
8246     }
8247 }
8248
8249 /* We actually emit the code in sh_expand_prologue.  We used to use
8250    a static variable to flag that we need to emit this code, but that
8251    doesn't when inlining, when functions are deferred and then emitted
8252    later.  Fortunately, we already have two flags that are part of struct
8253    function that tell if a function uses varargs or stdarg.  */
8254 static void
8255 sh_setup_incoming_varargs (CUMULATIVE_ARGS *ca,
8256                            enum machine_mode mode,
8257                            tree type,
8258                            int *pretend_arg_size,
8259                            int second_time ATTRIBUTE_UNUSED)
8260 {
8261   gcc_assert (cfun->stdarg);
8262   if (TARGET_VARARGS_PRETEND_ARGS (current_function_decl))
8263     {
8264       int named_parm_regs, anon_parm_regs;
8265
8266       named_parm_regs = (ROUND_REG (*ca, mode)
8267                          + (mode == BLKmode
8268                             ? ROUND_ADVANCE (int_size_in_bytes (type))
8269                             : ROUND_ADVANCE (GET_MODE_SIZE (mode))));
8270       anon_parm_regs = NPARM_REGS (SImode) - named_parm_regs;
8271       if (anon_parm_regs > 0)
8272         *pretend_arg_size = anon_parm_regs * 4;
8273     }
8274 }
8275
8276 static bool
8277 sh_strict_argument_naming (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
8278 {
8279   return TARGET_SH5;
8280 }
8281
8282 static bool
8283 sh_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca)
8284 {
8285   return ! (TARGET_HITACHI || ca->renesas_abi) && ! TARGET_SH5;
8286 }
8287
8288
8289 /* Define the offset between two registers, one to be eliminated, and
8290    the other its replacement, at the start of a routine.  */
8291
8292 int
8293 initial_elimination_offset (int from, int to)
8294 {
8295   int regs_saved;
8296   int regs_saved_rounding = 0;
8297   int total_saved_regs_space;
8298   int total_auto_space;
8299   int save_flags = target_flags;
8300   int copy_flags;
8301   HARD_REG_SET live_regs_mask;
8302
8303   shmedia_space_reserved_for_target_registers = false;
8304   regs_saved = calc_live_regs (&live_regs_mask);
8305   regs_saved += SHMEDIA_REGS_STACK_ADJUST ();
8306
8307   if (shmedia_reserve_space_for_target_registers_p (regs_saved, &live_regs_mask))
8308     {
8309       shmedia_space_reserved_for_target_registers = true;
8310       regs_saved += shmedia_target_regs_stack_adjust (&live_regs_mask);
8311     }
8312
8313   if (TARGET_SH5 && regs_saved % (STACK_BOUNDARY / BITS_PER_UNIT))
8314     regs_saved_rounding = ((STACK_BOUNDARY / BITS_PER_UNIT)
8315                            - regs_saved % (STACK_BOUNDARY / BITS_PER_UNIT));
8316
8317   total_auto_space = rounded_frame_size (regs_saved) - regs_saved_rounding;
8318   copy_flags = target_flags;
8319   target_flags = save_flags;
8320
8321   total_saved_regs_space = regs_saved + regs_saved_rounding;
8322
8323   if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
8324     return total_saved_regs_space + total_auto_space
8325       + crtl->args.info.byref_regs * 8;
8326
8327   if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
8328     return total_saved_regs_space + total_auto_space
8329       + crtl->args.info.byref_regs * 8;
8330
8331   /* Initial gap between fp and sp is 0.  */
8332   if (from == HARD_FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
8333     return 0;
8334
8335   if (from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
8336     return rounded_frame_size (0);
8337
8338   if (from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
8339     return rounded_frame_size (0);
8340
8341   gcc_assert (from == RETURN_ADDRESS_POINTER_REGNUM
8342               && (to == HARD_FRAME_POINTER_REGNUM
8343                   || to == STACK_POINTER_REGNUM));
8344   if (TARGET_SH5)
8345     {
8346       int n = total_saved_regs_space;
8347       int pr_reg = TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG;
8348       save_schedule schedule;
8349       save_entry *entry;
8350
8351       n += total_auto_space;
8352
8353       /* If it wasn't saved, there's not much we can do.  */
8354       if (! TEST_HARD_REG_BIT (live_regs_mask, pr_reg))
8355         return n;
8356
8357       target_flags = copy_flags;
8358
8359       sh5_schedule_saves (&live_regs_mask, &schedule, n);
8360       for (entry = &schedule.entries[1]; entry->mode != VOIDmode; entry++)
8361         if (entry->reg == pr_reg)
8362           {
8363             target_flags = save_flags;
8364             return entry->offset;
8365           }
8366       gcc_unreachable ();
8367     }
8368   else
8369     return total_auto_space;
8370 }
8371
8372 /* Parse the -mfixed-range= option string.  */
8373 void
8374 sh_fix_range (const char *const_str)
8375 {
8376   int i, first, last;
8377   char *str, *dash, *comma;
8378
8379   /* str must be of the form REG1'-'REG2{,REG1'-'REG} where REG1 and
8380      REG2 are either register names or register numbers.  The effect
8381      of this option is to mark the registers in the range from REG1 to
8382      REG2 as ``fixed'' so they won't be used by the compiler.  */
8383
8384   i = strlen (const_str);
8385   str = (char *) alloca (i + 1);
8386   memcpy (str, const_str, i + 1);
8387
8388   while (1)
8389     {
8390       dash = strchr (str, '-');
8391       if (!dash)
8392         {
8393           warning (0, "value of -mfixed-range must have form REG1-REG2");
8394           return;
8395         }
8396       *dash = '\0';
8397       comma = strchr (dash + 1, ',');
8398       if (comma)
8399         *comma = '\0';
8400
8401       first = decode_reg_name (str);
8402       if (first < 0)
8403         {
8404           warning (0, "unknown register name: %s", str);
8405           return;
8406         }
8407
8408       last = decode_reg_name (dash + 1);
8409       if (last < 0)
8410         {
8411           warning (0, "unknown register name: %s", dash + 1);
8412           return;
8413         }
8414
8415       *dash = '-';
8416
8417       if (first > last)
8418         {
8419           warning (0, "%s-%s is an empty range", str, dash + 1);
8420           return;
8421         }
8422
8423       for (i = first; i <= last; ++i)
8424         fixed_regs[i] = call_used_regs[i] = 1;
8425
8426       if (!comma)
8427         break;
8428
8429       *comma = ',';
8430       str = comma + 1;
8431     }
8432 }
8433 \f
8434 /* Insert any deferred function attributes from earlier pragmas.  */
8435 static void
8436 sh_insert_attributes (tree node, tree *attributes)
8437 {
8438   tree attrs;
8439
8440   if (TREE_CODE (node) != FUNCTION_DECL)
8441     return;
8442
8443   /* We are only interested in fields.  */
8444   if (!DECL_P (node))
8445     return;
8446
8447   /* Append the attributes to the deferred attributes.  */
8448   *sh_deferred_function_attributes_tail = *attributes;
8449   attrs = sh_deferred_function_attributes;
8450   if (!attrs)
8451     return;
8452
8453   /* Some attributes imply or require the interrupt attribute.  */
8454   if (!lookup_attribute ("interrupt_handler", attrs)
8455       && !lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (node)))
8456     {
8457       /* If we have a trapa_handler, but no interrupt_handler attribute,
8458          insert an interrupt_handler attribute.  */
8459       if (lookup_attribute ("trapa_handler", attrs) != NULL_TREE)
8460         /* We can't use sh_pr_interrupt here because that's not in the
8461            java frontend.  */
8462         attrs
8463           = tree_cons (get_identifier("interrupt_handler"), NULL_TREE, attrs);
8464       /* However, for sp_switch, trap_exit, nosave_low_regs and resbank,
8465          if the interrupt attribute is missing, we ignore the attribute
8466          and warn.  */
8467       else if (lookup_attribute ("sp_switch", attrs)
8468                || lookup_attribute ("trap_exit", attrs)
8469                || lookup_attribute ("nosave_low_regs", attrs)
8470                || lookup_attribute ("resbank", attrs))
8471         {
8472           tree *tail;
8473
8474           for (tail = attributes; attrs; attrs = TREE_CHAIN (attrs))
8475             {
8476               if (is_attribute_p ("sp_switch", TREE_PURPOSE (attrs))
8477                   || is_attribute_p ("trap_exit", TREE_PURPOSE (attrs))
8478                   || is_attribute_p ("nosave_low_regs", TREE_PURPOSE (attrs))
8479                   || is_attribute_p ("resbank", TREE_PURPOSE (attrs)))
8480                 warning (OPT_Wattributes,
8481                          "%qE attribute only applies to interrupt functions",
8482                          TREE_PURPOSE (attrs));
8483               else
8484                 {
8485                   *tail = tree_cons (TREE_PURPOSE (attrs), NULL_TREE,
8486                                      NULL_TREE);
8487                   tail = &TREE_CHAIN (*tail);
8488                 }
8489             }
8490           attrs = *attributes;
8491         }
8492     }
8493
8494   /* Install the processed list.  */
8495   *attributes = attrs;
8496
8497   /* Clear deferred attributes.  */
8498   sh_deferred_function_attributes = NULL_TREE;
8499   sh_deferred_function_attributes_tail = &sh_deferred_function_attributes;
8500
8501   return;
8502 }
8503
8504 /* Supported attributes:
8505
8506    interrupt_handler -- specifies this function is an interrupt handler.
8507
8508    trapa_handler - like above, but don't save all registers.
8509
8510    sp_switch -- specifies an alternate stack for an interrupt handler
8511    to run on.
8512
8513    trap_exit -- use a trapa to exit an interrupt function instead of
8514    an rte instruction.
8515
8516    nosave_low_regs - don't save r0..r7 in an interrupt handler.
8517      This is useful on the SH3 and upwards,
8518      which has a separate set of low regs for User and Supervisor modes.
8519      This should only be used for the lowest level of interrupts.  Higher levels
8520      of interrupts must save the registers in case they themselves are
8521      interrupted.
8522
8523    renesas -- use Renesas calling/layout conventions (functions and
8524    structures).
8525
8526    resbank -- In case of an ISR, use a register bank to save registers
8527    R0-R14, MACH, MACL, GBR and PR.  This is useful only on SH2A targets.
8528 */
8529
8530 const struct attribute_spec sh_attribute_table[] =
8531 {
8532   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
8533   { "interrupt_handler", 0, 0, true,  false, false, sh_handle_interrupt_handler_attribute },
8534   { "sp_switch",         1, 1, true,  false, false, sh_handle_sp_switch_attribute },
8535   { "trap_exit",         1, 1, true,  false, false, sh_handle_trap_exit_attribute },
8536   { "renesas",           0, 0, false, true, false, sh_handle_renesas_attribute },
8537   { "trapa_handler",     0, 0, true,  false, false, sh_handle_interrupt_handler_attribute },
8538   { "nosave_low_regs",   0, 0, true,  false, false, sh_handle_interrupt_handler_attribute },
8539   { "resbank",           0, 0, true,  false, false, sh_handle_resbank_handler_attribute },
8540   { "function_vector",   1, 1, true,  false, false, sh2a_handle_function_vector_handler_attribute },
8541 #ifdef SYMBIAN
8542   /* Symbian support adds three new attributes:
8543      dllexport - for exporting a function/variable that will live in a dll
8544      dllimport - for importing a function/variable from a dll
8545
8546      Microsoft allows multiple declspecs in one __declspec, separating
8547      them with spaces.  We do NOT support this.  Instead, use __declspec
8548      multiple times.  */
8549   { "dllimport",         0, 0, true,  false, false, sh_symbian_handle_dll_attribute },
8550   { "dllexport",         0, 0, true,  false, false, sh_symbian_handle_dll_attribute },
8551 #endif
8552   { NULL,                0, 0, false, false, false, NULL }
8553 };
8554
8555 /* Handle a 'resbank' attribute.  */
8556 static tree
8557 sh_handle_resbank_handler_attribute (tree * node, tree name,
8558                                      tree args ATTRIBUTE_UNUSED,
8559                                      int flags ATTRIBUTE_UNUSED,
8560                                      bool * no_add_attrs)
8561 {
8562   if (!TARGET_SH2A)
8563     {
8564       warning (OPT_Wattributes, "%qE attribute is supported only for SH2A",
8565                name);
8566       *no_add_attrs = true;
8567     }
8568   if (TREE_CODE (*node) != FUNCTION_DECL)
8569     {
8570       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8571                name);
8572       *no_add_attrs = true;
8573     }
8574
8575   return NULL_TREE;
8576 }
8577
8578 /* Handle an "interrupt_handler" attribute; arguments as in
8579    struct attribute_spec.handler.  */
8580 static tree
8581 sh_handle_interrupt_handler_attribute (tree *node, tree name,
8582                                        tree args ATTRIBUTE_UNUSED,
8583                                        int flags ATTRIBUTE_UNUSED,
8584                                        bool *no_add_attrs)
8585 {
8586   if (TREE_CODE (*node) != FUNCTION_DECL)
8587     {
8588       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8589                name);
8590       *no_add_attrs = true;
8591     }
8592   else if (TARGET_SHCOMPACT)
8593     {
8594       error ("attribute interrupt_handler is not compatible with -m5-compact");
8595       *no_add_attrs = true;
8596     }
8597
8598   return NULL_TREE;
8599 }
8600
8601 /* Handle an 'function_vector' attribute; arguments as in
8602    struct attribute_spec.handler.  */
8603 static tree
8604 sh2a_handle_function_vector_handler_attribute (tree * node, tree name,
8605                                                tree args ATTRIBUTE_UNUSED,
8606                                                int flags ATTRIBUTE_UNUSED,
8607                                                bool * no_add_attrs)
8608 {
8609   if (!TARGET_SH2A)
8610     {
8611       warning (OPT_Wattributes, "%qE attribute only applies to SH2A",
8612                name);
8613       *no_add_attrs = true;
8614     }
8615   else if (TREE_CODE (*node) != FUNCTION_DECL)
8616     {
8617       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8618                name);
8619       *no_add_attrs = true;
8620     }
8621   else if (TREE_CODE (TREE_VALUE (args)) != INTEGER_CST)
8622     {
8623       /* The argument must be a constant integer.  */
8624       warning (OPT_Wattributes,
8625                "%qE attribute argument not an integer constant",
8626                name);
8627       *no_add_attrs = true;
8628     }
8629   else if (TREE_INT_CST_LOW (TREE_VALUE (args)) > 255)
8630     {
8631       /* The argument value must be between 0 to 255.  */
8632       warning (OPT_Wattributes,
8633                "%qE attribute argument should be between 0 to 255",
8634                name);
8635       *no_add_attrs = true;
8636     }
8637   return NULL_TREE;
8638 }
8639
8640 /* Returns 1 if current function has been assigned the attribute
8641    'function_vector'.  */
8642 int
8643 sh2a_is_function_vector_call (rtx x)
8644 {
8645   if (GET_CODE (x) == SYMBOL_REF
8646       && (SYMBOL_REF_FLAGS (x) & SYMBOL_FLAG_FUNCVEC_FUNCTION))
8647     {
8648       tree tr = SYMBOL_REF_DECL (x);
8649
8650       if (sh2a_function_vector_p (tr))
8651         return 1;
8652     }
8653
8654   return 0;
8655 }
8656
8657 /* Returns the function vector number, if the the attribute
8658    'function_vector' is assigned, otherwise returns zero.  */
8659 int
8660 sh2a_get_function_vector_number (rtx x)
8661 {
8662   int num;
8663   tree list, t;
8664
8665   if ((GET_CODE (x) == SYMBOL_REF)
8666       && (SYMBOL_REF_FLAGS (x) & SYMBOL_FLAG_FUNCVEC_FUNCTION))
8667     {
8668       t = SYMBOL_REF_DECL (x);
8669
8670       if (TREE_CODE (t) != FUNCTION_DECL)
8671         return 0;
8672
8673       list = SH_ATTRIBUTES (t);
8674       while (list)
8675         {
8676           if (is_attribute_p ("function_vector", TREE_PURPOSE (list)))
8677             {
8678               num = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list)));
8679               return num;
8680             }
8681
8682           list = TREE_CHAIN (list);
8683         }
8684
8685       return 0;
8686     }
8687   else
8688     return 0;
8689 }
8690
8691 /* Handle an "sp_switch" attribute; arguments as in
8692    struct attribute_spec.handler.  */
8693 static tree
8694 sh_handle_sp_switch_attribute (tree *node, tree name, tree args,
8695                                int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
8696 {
8697   if (TREE_CODE (*node) != FUNCTION_DECL)
8698     {
8699       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8700                name);
8701       *no_add_attrs = true;
8702     }
8703   else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
8704     {
8705       /* The argument must be a constant string.  */
8706       warning (OPT_Wattributes, "%qE attribute argument not a string constant",
8707                name);
8708       *no_add_attrs = true;
8709     }
8710
8711   return NULL_TREE;
8712 }
8713
8714 /* Handle an "trap_exit" attribute; arguments as in
8715    struct attribute_spec.handler.  */
8716 static tree
8717 sh_handle_trap_exit_attribute (tree *node, tree name, tree args,
8718                                int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
8719 {
8720   if (TREE_CODE (*node) != FUNCTION_DECL)
8721     {
8722       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8723                name);
8724       *no_add_attrs = true;
8725     }
8726   /* The argument specifies a trap number to be used in a trapa instruction
8727      at function exit (instead of an rte instruction).  */
8728   else if (TREE_CODE (TREE_VALUE (args)) != INTEGER_CST)
8729     {
8730       /* The argument must be a constant integer.  */
8731       warning (OPT_Wattributes, "%qE attribute argument not an "
8732                "integer constant", name);
8733       *no_add_attrs = true;
8734     }
8735
8736   return NULL_TREE;
8737 }
8738
8739 static tree
8740 sh_handle_renesas_attribute (tree *node ATTRIBUTE_UNUSED,
8741                              tree name ATTRIBUTE_UNUSED,
8742                              tree args ATTRIBUTE_UNUSED,
8743                              int flags ATTRIBUTE_UNUSED,
8744                              bool *no_add_attrs ATTRIBUTE_UNUSED)
8745 {
8746   return NULL_TREE;
8747 }
8748
8749 /* True if __attribute__((renesas)) or -mrenesas.  */
8750 int
8751 sh_attr_renesas_p (const_tree td)
8752 {
8753   if (TARGET_HITACHI)
8754     return 1;
8755   if (td == 0)
8756     return 0;
8757   if (DECL_P (td))
8758     td = TREE_TYPE (td);
8759   if (td == error_mark_node)
8760     return 0;
8761   return (lookup_attribute ("renesas", TYPE_ATTRIBUTES (td))
8762           != NULL_TREE);
8763 }
8764
8765 /* True if __attribute__((renesas)) or -mrenesas, for the current
8766    function.  */
8767 int
8768 sh_cfun_attr_renesas_p (void)
8769 {
8770   return sh_attr_renesas_p (current_function_decl);
8771 }
8772
8773 int
8774 sh_cfun_interrupt_handler_p (void)
8775 {
8776   return (lookup_attribute ("interrupt_handler",
8777                             DECL_ATTRIBUTES (current_function_decl))
8778           != NULL_TREE);
8779 }
8780
8781 /* Returns 1 if FUNC has been assigned the attribute
8782    "function_vector".  */
8783 int
8784 sh2a_function_vector_p (tree func)
8785 {
8786   tree list;
8787   if (TREE_CODE (func) != FUNCTION_DECL)
8788     return 0;
8789
8790   list = SH_ATTRIBUTES (func);
8791   while (list)
8792     {
8793       if (is_attribute_p ("function_vector", TREE_PURPOSE (list)))
8794         return 1;
8795
8796       list = TREE_CHAIN (list);
8797     }
8798   return 0;
8799 }
8800
8801 /* Returns TRUE if given tree has the "resbank" attribute.  */
8802
8803 int
8804 sh_cfun_resbank_handler_p (void)
8805 {
8806   return ((lookup_attribute ("resbank",
8807                              DECL_ATTRIBUTES (current_function_decl))
8808            != NULL_TREE)
8809           && (lookup_attribute ("interrupt_handler",
8810                                 DECL_ATTRIBUTES (current_function_decl))
8811               != NULL_TREE) && TARGET_SH2A);
8812 }
8813
8814 /* Implement TARGET_CHECK_PCH_TARGET_FLAGS.  */
8815
8816 static const char *
8817 sh_check_pch_target_flags (int old_flags)
8818 {
8819   if ((old_flags ^ target_flags) & (MASK_SH1 | MASK_SH2 | MASK_SH3
8820                                     | MASK_SH_E | MASK_HARD_SH4
8821                                     | MASK_FPU_SINGLE | MASK_SH4))
8822     return _("created and used with different architectures / ABIs");
8823   if ((old_flags ^ target_flags) & MASK_HITACHI)
8824     return _("created and used with different ABIs");
8825   if ((old_flags ^ target_flags) & MASK_LITTLE_ENDIAN)
8826     return _("created and used with different endianness");
8827   return NULL;
8828 }
8829 \f
8830 /* Predicates used by the templates.  */
8831
8832 /* Returns 1 if OP is MACL, MACH or PR.  The input must be a REG rtx.
8833    Used only in general_movsrc_operand.  */
8834
8835 int
8836 system_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
8837 {
8838   switch (REGNO (op))
8839     {
8840     case PR_REG:
8841     case MACL_REG:
8842     case MACH_REG:
8843       return 1;
8844     }
8845   return 0;
8846 }
8847
8848 /* Nonzero if OP is a floating point value with value 0.0.  */
8849
8850 int
8851 fp_zero_operand (rtx op)
8852 {
8853   REAL_VALUE_TYPE r;
8854
8855   if (GET_MODE (op) != SFmode)
8856     return 0;
8857
8858   REAL_VALUE_FROM_CONST_DOUBLE (r, op);
8859   return REAL_VALUES_EQUAL (r, dconst0) && ! REAL_VALUE_MINUS_ZERO (r);
8860 }
8861
8862 /* Nonzero if OP is a floating point value with value 1.0.  */
8863
8864 int
8865 fp_one_operand (rtx op)
8866 {
8867   REAL_VALUE_TYPE r;
8868
8869   if (GET_MODE (op) != SFmode)
8870     return 0;
8871
8872   REAL_VALUE_FROM_CONST_DOUBLE (r, op);
8873   return REAL_VALUES_EQUAL (r, dconst1);
8874 }
8875
8876 /* For -m4 and -m4-single-only, mode switching is used.  If we are
8877    compiling without -mfmovd, movsf_ie isn't taken into account for
8878    mode switching.  We could check in machine_dependent_reorg for
8879    cases where we know we are in single precision mode, but there is
8880    interface to find that out during reload, so we must avoid
8881    choosing an fldi alternative during reload and thus failing to
8882    allocate a scratch register for the constant loading.  */
8883 int
8884 fldi_ok (void)
8885 {
8886   return ! TARGET_SH4 || TARGET_FMOVD || reload_completed;
8887 }
8888
8889 int
8890 tertiary_reload_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
8891 {
8892   enum rtx_code code = GET_CODE (op);
8893   return code == MEM || (TARGET_SH4 && code == CONST_DOUBLE);
8894 }
8895
8896 /* Return the TLS type for TLS symbols, 0 for otherwise.  */
8897 enum tls_model
8898 tls_symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
8899 {
8900   if (GET_CODE (op) != SYMBOL_REF)
8901     return TLS_MODEL_NONE;
8902   return SYMBOL_REF_TLS_MODEL (op);
8903 }
8904 \f
8905 /* Return the destination address of a branch.  */
8906
8907 static int
8908 branch_dest (rtx branch)
8909 {
8910   rtx dest = SET_SRC (PATTERN (branch));
8911   int dest_uid;
8912
8913   if (GET_CODE (dest) == IF_THEN_ELSE)
8914     dest = XEXP (dest, 1);
8915   dest = XEXP (dest, 0);
8916   dest_uid = INSN_UID (dest);
8917   return INSN_ADDRESSES (dest_uid);
8918 }
8919 \f
8920 /* Return nonzero if REG is not used after INSN.
8921    We assume REG is a reload reg, and therefore does
8922    not live past labels.  It may live past calls or jumps though.  */
8923 int
8924 reg_unused_after (rtx reg, rtx insn)
8925 {
8926   enum rtx_code code;
8927   rtx set;
8928
8929   /* If the reg is set by this instruction, then it is safe for our
8930      case.  Disregard the case where this is a store to memory, since
8931      we are checking a register used in the store address.  */
8932   set = single_set (insn);
8933   if (set && !MEM_P (SET_DEST (set))
8934       && reg_overlap_mentioned_p (reg, SET_DEST (set)))
8935     return 1;
8936
8937   while ((insn = NEXT_INSN (insn)))
8938     {
8939       rtx set;
8940       if (!INSN_P (insn))
8941         continue;
8942
8943       code = GET_CODE (insn);
8944
8945 #if 0
8946       /* If this is a label that existed before reload, then the register
8947          if dead here.  However, if this is a label added by reorg, then
8948          the register may still be live here.  We can't tell the difference,
8949          so we just ignore labels completely.  */
8950       if (code == CODE_LABEL)
8951         return 1;
8952       /* else */
8953 #endif
8954
8955       if (code == JUMP_INSN)
8956         return 0;
8957
8958       /* If this is a sequence, we must handle them all at once.
8959          We could have for instance a call that sets the target register,
8960          and an insn in a delay slot that uses the register.  In this case,
8961          we must return 0.  */
8962       else if (code == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
8963         {
8964           int i;
8965           int retval = 0;
8966
8967           for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
8968             {
8969               rtx this_insn = XVECEXP (PATTERN (insn), 0, i);
8970               rtx set = single_set (this_insn);
8971
8972               if (CALL_P (this_insn))
8973                 code = CALL_INSN;
8974               else if (JUMP_P (this_insn))
8975                 {
8976                   if (INSN_ANNULLED_BRANCH_P (this_insn))
8977                     return 0;
8978                   code = JUMP_INSN;
8979                 }
8980
8981               if (set && reg_overlap_mentioned_p (reg, SET_SRC (set)))
8982                 return 0;
8983               if (set && reg_overlap_mentioned_p (reg, SET_DEST (set)))
8984                 {
8985                   if (!MEM_P (SET_DEST (set)))
8986                     retval = 1;
8987                   else
8988                     return 0;
8989                 }
8990               if (set == 0
8991                   && reg_overlap_mentioned_p (reg, PATTERN (this_insn)))
8992                 return 0;
8993             }
8994           if (retval == 1)
8995             return 1;
8996           else if (code == JUMP_INSN)
8997             return 0;
8998         }
8999
9000       set = single_set (insn);
9001       if (set && reg_overlap_mentioned_p (reg, SET_SRC (set)))
9002         return 0;
9003       if (set && reg_overlap_mentioned_p (reg, SET_DEST (set)))
9004         return !MEM_P (SET_DEST (set));
9005       if (set == 0 && reg_overlap_mentioned_p (reg, PATTERN (insn)))
9006         return 0;
9007
9008       if (code == CALL_INSN && call_really_used_regs[REGNO (reg)])
9009         return 1;
9010     }
9011   return 1;
9012 }
9013 \f
9014 #include "ggc.h"
9015
9016 static GTY(()) rtx fpscr_rtx;
9017 rtx
9018 get_fpscr_rtx (void)
9019 {
9020   if (! fpscr_rtx)
9021     {
9022       fpscr_rtx = gen_rtx_REG (PSImode, FPSCR_REG);
9023       REG_USERVAR_P (fpscr_rtx) = 1;
9024       mark_user_reg (fpscr_rtx);
9025     }
9026   if (! reload_completed || mdep_reorg_phase != SH_AFTER_MDEP_REORG)
9027     mark_user_reg (fpscr_rtx);
9028   return fpscr_rtx;
9029 }
9030
9031 static GTY(()) tree fpscr_values;
9032
9033 static void
9034 emit_fpu_switch (rtx scratch, int index)
9035 {
9036   rtx dst, src;
9037
9038   if (fpscr_values == NULL)
9039     {
9040       tree t;
9041
9042       t = build_index_type (integer_one_node);
9043       t = build_array_type (integer_type_node, t);
9044       t = build_decl (VAR_DECL, get_identifier ("__fpscr_values"), t);
9045       DECL_ARTIFICIAL (t) = 1;
9046       DECL_IGNORED_P (t) = 1;
9047       DECL_EXTERNAL (t) = 1;
9048       TREE_STATIC (t) = 1;
9049       TREE_PUBLIC (t) = 1;
9050       TREE_USED (t) = 1;
9051
9052       fpscr_values = t;
9053     }
9054
9055   src = DECL_RTL (fpscr_values);
9056   if (!can_create_pseudo_p ())
9057     {
9058       emit_move_insn (scratch, XEXP (src, 0));
9059       if (index != 0)
9060         emit_insn (gen_addsi3 (scratch, scratch, GEN_INT (index * 4)));
9061       src = adjust_automodify_address (src, PSImode, scratch, index * 4);
9062     }
9063   else
9064     src = adjust_address (src, PSImode, index * 4);
9065
9066   dst = get_fpscr_rtx ();
9067   emit_move_insn (dst, src);
9068 }
9069
9070 void
9071 emit_sf_insn (rtx pat)
9072 {
9073   emit_insn (pat);
9074 }
9075
9076 void
9077 emit_df_insn (rtx pat)
9078 {
9079   emit_insn (pat);
9080 }
9081
9082 void
9083 expand_sf_unop (rtx (*fun) (rtx, rtx, rtx), rtx *operands)
9084 {
9085   emit_sf_insn ((*fun) (operands[0], operands[1], get_fpscr_rtx ()));
9086 }
9087
9088 void
9089 expand_sf_binop (rtx (*fun) (rtx, rtx, rtx, rtx), rtx *operands)
9090 {
9091   emit_sf_insn ((*fun) (operands[0], operands[1], operands[2],
9092                          get_fpscr_rtx ()));
9093 }
9094
9095 void
9096 expand_df_unop (rtx (*fun) (rtx, rtx, rtx), rtx *operands)
9097 {
9098   emit_df_insn ((*fun) (operands[0], operands[1], get_fpscr_rtx ()));
9099 }
9100
9101 void
9102 expand_df_binop (rtx (*fun) (rtx, rtx, rtx, rtx), rtx *operands)
9103 {
9104   emit_df_insn ((*fun) (operands[0], operands[1], operands[2],
9105                         get_fpscr_rtx ()));
9106 }
9107 \f
9108 static rtx get_free_reg (HARD_REG_SET);
9109
9110 /* This function returns a register to use to load the address to load
9111    the fpscr from.  Currently it always returns r1 or r7, but when we are
9112    able to use pseudo registers after combine, or have a better mechanism
9113    for choosing a register, it should be done here.  */
9114 /* REGS_LIVE is the liveness information for the point for which we
9115    need this allocation.  In some bare-bones exit blocks, r1 is live at the
9116    start.  We can even have all of r0..r3 being live:
9117 __complex__ long long f (double d) { if (d == 0) return 2; else return 3; }
9118    INSN before which new insns are placed with will clobber the register
9119    we return.  If a basic block consists only of setting the return value
9120    register to a pseudo and using that register, the return value is not
9121    live before or after this block, yet we we'll insert our insns right in
9122    the middle.  */
9123
9124 static rtx
9125 get_free_reg (HARD_REG_SET regs_live)
9126 {
9127   if (! TEST_HARD_REG_BIT (regs_live, 1))
9128     return gen_rtx_REG (Pmode, 1);
9129
9130   /* Hard reg 1 is live; since this is a SMALL_REGISTER_CLASSES target,
9131      there shouldn't be anything but a jump before the function end.  */
9132   gcc_assert (!TEST_HARD_REG_BIT (regs_live, 7));
9133   return gen_rtx_REG (Pmode, 7);
9134 }
9135
9136 /* This function will set the fpscr from memory.
9137    MODE is the mode we are setting it to.  */
9138 void
9139 fpscr_set_from_mem (int mode, HARD_REG_SET regs_live)
9140 {
9141   enum attr_fp_mode fp_mode = (enum attr_fp_mode) mode;
9142   enum attr_fp_mode norm_mode = ACTUAL_NORMAL_MODE (FP_MODE);
9143   rtx addr_reg;
9144
9145   addr_reg = !can_create_pseudo_p () ? get_free_reg (regs_live) : NULL_RTX;
9146   emit_fpu_switch (addr_reg, fp_mode == norm_mode);
9147 }
9148
9149 /* Is the given character a logical line separator for the assembler?  */
9150 #ifndef IS_ASM_LOGICAL_LINE_SEPARATOR
9151 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) ((C) == ';')
9152 #endif
9153
9154 int
9155 sh_insn_length_adjustment (rtx insn)
9156 {
9157   /* Instructions with unfilled delay slots take up an extra two bytes for
9158      the nop in the delay slot.  */
9159   if (((NONJUMP_INSN_P (insn)
9160         && GET_CODE (PATTERN (insn)) != USE
9161         && GET_CODE (PATTERN (insn)) != CLOBBER)
9162        || CALL_P (insn)
9163        || (JUMP_P (insn)
9164            && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC
9165            && GET_CODE (PATTERN (insn)) != ADDR_VEC))
9166       && GET_CODE (PATTERN (NEXT_INSN (PREV_INSN (insn)))) != SEQUENCE
9167       && get_attr_needs_delay_slot (insn) == NEEDS_DELAY_SLOT_YES)
9168     return 2;
9169
9170   /* SH2e has a bug that prevents the use of annulled branches, so if
9171      the delay slot is not filled, we'll have to put a NOP in it.  */
9172   if (sh_cpu_attr == CPU_SH2E
9173       && JUMP_P (insn)
9174       && GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC
9175       && GET_CODE (PATTERN (insn)) != ADDR_VEC
9176       && get_attr_type (insn) == TYPE_CBRANCH
9177       && GET_CODE (PATTERN (NEXT_INSN (PREV_INSN (insn)))) != SEQUENCE)
9178     return 2;
9179
9180   /* sh-dsp parallel processing insn take four bytes instead of two.  */
9181
9182   if (NONJUMP_INSN_P (insn))
9183     {
9184       int sum = 0;
9185       rtx body = PATTERN (insn);
9186       const char *templ;
9187       char c;
9188       int maybe_label = 1;
9189
9190       if (GET_CODE (body) == ASM_INPUT)
9191         templ = XSTR (body, 0);
9192       else if (asm_noperands (body) >= 0)
9193         templ
9194           = decode_asm_operands (body, NULL, NULL, NULL, NULL, NULL);
9195       else
9196         return 0;
9197       do
9198         {
9199           int ppi_adjust = 0;
9200
9201           do
9202             c = *templ++;
9203           while (c == ' ' || c == '\t');
9204           /* all sh-dsp parallel-processing insns start with p.
9205              The only non-ppi sh insn starting with p is pref.
9206              The only ppi starting with pr is prnd.  */
9207           if ((c == 'p' || c == 'P') && strncasecmp ("re", templ, 2))
9208             ppi_adjust = 2;
9209           /* The repeat pseudo-insn expands two three insns, a total of
9210              six bytes in size.  */
9211           else if ((c == 'r' || c == 'R')
9212                    && ! strncasecmp ("epeat", templ, 5))
9213             ppi_adjust = 4;
9214           while (c && c != '\n'
9215                  && ! IS_ASM_LOGICAL_LINE_SEPARATOR (c, templ))
9216             {
9217               /* If this is a label, it is obviously not a ppi insn.  */
9218               if (c == ':' && maybe_label)
9219                 {
9220                   ppi_adjust = 0;
9221                   break;
9222                 }
9223               else if (c == '\'' || c == '"')
9224                 maybe_label = 0;
9225               c = *templ++;
9226             }
9227           sum += ppi_adjust;
9228           maybe_label = c != ':';
9229         }
9230       while (c);
9231       return sum;
9232     }
9233   return 0;
9234 }
9235 \f
9236 /* Return TRUE for a valid displacement for the REG+disp addressing
9237    with MODE.  */
9238
9239 /* ??? The SH2e does not have the REG+disp addressing mode when loading values
9240    into the FRx registers.  We implement this by setting the maximum offset
9241    to zero when the value is SFmode.  This also restricts loading of SFmode
9242    values into the integer registers, but that can't be helped.  */
9243
9244 /* The SH allows a displacement in a QI or HI amode, but only when the
9245    other operand is R0. GCC doesn't handle this very well, so we forgot
9246    all of that.
9247
9248    A legitimate index for a QI or HI is 0, SI can be any number 0..63,
9249    DI can be any number 0..60.  */
9250
9251 bool
9252 sh_legitimate_index_p (enum machine_mode mode, rtx op)
9253 {
9254   if (CONST_INT_P (op))
9255     {
9256       if (TARGET_SHMEDIA)
9257         {
9258           int size;
9259
9260           /* Check if this the address of an unaligned load / store.  */
9261           if (mode == VOIDmode)
9262             return CONST_OK_FOR_I06 (INTVAL (op));
9263
9264           size = GET_MODE_SIZE (mode);
9265           return (!(INTVAL (op) & (size - 1))
9266                   && INTVAL (op) >= -512 * size
9267                   && INTVAL (op) < 512 * size);
9268         }
9269
9270       if (TARGET_SH2A)
9271         {
9272           if (GET_MODE_SIZE (mode) == 1
9273                 && (unsigned) INTVAL (op) < 4096)
9274             return true;
9275         }
9276
9277       if ((GET_MODE_SIZE (mode) == 4
9278            && (unsigned) INTVAL (op) < 64
9279            && !(INTVAL (op) & 3)
9280            && !(TARGET_SH2E && mode == SFmode))
9281           || (GET_MODE_SIZE (mode) == 4
9282               && (unsigned) INTVAL (op) < 16383
9283               && !(INTVAL (op) & 3) && TARGET_SH2A))
9284         return true;
9285
9286       if ((GET_MODE_SIZE (mode) == 8
9287            && (unsigned) INTVAL (op) < 60
9288            && !(INTVAL (op) & 3)
9289            && !((TARGET_SH4 || TARGET_SH2A) && mode == DFmode))
9290           || ((GET_MODE_SIZE (mode)==8)
9291               && (unsigned) INTVAL (op) < 8192
9292               && !(INTVAL (op) & (TARGET_SH2A_DOUBLE ? 7 : 3))
9293               && (TARGET_SH2A && mode == DFmode)))
9294         return true;
9295     }
9296
9297   return false;
9298 }
9299
9300 /* Recognize an RTL expression that is a valid memory address for
9301    an instruction.
9302    The MODE argument is the machine mode for the MEM expression
9303    that wants to use this address.
9304    Allow  REG
9305           REG+disp
9306           REG+r0
9307           REG++
9308           --REG  */
9309
9310 static bool
9311 sh_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
9312 {
9313   if (MAYBE_BASE_REGISTER_RTX_P (x, strict))
9314     return true;
9315   else if ((GET_CODE (x) == POST_INC || GET_CODE (x) == PRE_DEC)
9316            && ! TARGET_SHMEDIA
9317            && MAYBE_BASE_REGISTER_RTX_P (XEXP (x, 0), strict))
9318     return true;
9319   else if (GET_CODE (x) == PLUS
9320            && (mode != PSImode || reload_completed))
9321     {
9322       rtx xop0 = XEXP (x, 0);
9323       rtx xop1 = XEXP (x, 1);
9324
9325       if (GET_MODE_SIZE (mode) <= 8
9326           && MAYBE_BASE_REGISTER_RTX_P (xop0, strict)
9327           && sh_legitimate_index_p (mode, xop1))
9328         return true;
9329
9330       if ((ALLOW_INDEXED_ADDRESS || GET_MODE (x) == DImode
9331            || ((xop0 == stack_pointer_rtx
9332                 || xop0 == hard_frame_pointer_rtx)
9333                && REG_P (xop1) && REGNO (xop1) == R0_REG)
9334            || ((xop1 == stack_pointer_rtx
9335                 || xop1 == hard_frame_pointer_rtx)
9336                && REG_P (xop0) && REGNO (xop0) == R0_REG))
9337           && ((!TARGET_SHMEDIA && GET_MODE_SIZE (mode) <= 4)
9338               || (TARGET_SHMEDIA && GET_MODE_SIZE (mode) <= 8)
9339               || ((TARGET_SH4 || TARGET_SH2A_DOUBLE)
9340                   && TARGET_FMOVD && mode == DFmode)))
9341         {
9342           if (MAYBE_BASE_REGISTER_RTX_P (xop1, strict)
9343               && MAYBE_INDEX_REGISTER_RTX_P (xop0, strict))
9344             return true;
9345           if (MAYBE_INDEX_REGISTER_RTX_P (xop1, strict)
9346               && MAYBE_BASE_REGISTER_RTX_P (xop0, strict))
9347             return true;
9348         }
9349     }
9350
9351   return false;
9352 }
9353 \f
9354 /* Return TRUE if X references a SYMBOL_REF or LABEL_REF whose symbol
9355    isn't protected by a PIC unspec.  */
9356 int
9357 nonpic_symbol_mentioned_p (rtx x)
9358 {
9359   register const char *fmt;
9360   register int i;
9361
9362   if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF
9363       || GET_CODE (x) == PC)
9364     return 1;
9365
9366   /* We don't want to look into the possible MEM location of a
9367      CONST_DOUBLE, since we're not going to use it, in general.  */
9368   if (GET_CODE (x) == CONST_DOUBLE)
9369     return 0;
9370
9371   if (GET_CODE (x) == UNSPEC
9372       && (XINT (x, 1) == UNSPEC_PIC
9373           || XINT (x, 1) == UNSPEC_GOT
9374           || XINT (x, 1) == UNSPEC_GOTOFF
9375           || XINT (x, 1) == UNSPEC_GOTPLT
9376           || XINT (x, 1) == UNSPEC_GOTTPOFF
9377           || XINT (x, 1) == UNSPEC_DTPOFF
9378           || XINT (x, 1) == UNSPEC_PLT
9379           || XINT (x, 1) == UNSPEC_SYMOFF
9380           || XINT (x, 1) == UNSPEC_PCREL_SYMOFF))
9381     return 0;
9382
9383   fmt = GET_RTX_FORMAT (GET_CODE (x));
9384   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
9385     {
9386       if (fmt[i] == 'E')
9387         {
9388           register int j;
9389
9390           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
9391             if (nonpic_symbol_mentioned_p (XVECEXP (x, i, j)))
9392               return 1;
9393         }
9394       else if (fmt[i] == 'e' && nonpic_symbol_mentioned_p (XEXP (x, i)))
9395         return 1;
9396     }
9397
9398   return 0;
9399 }
9400
9401 /* Convert a non-PIC address in `orig' to a PIC address using @GOT or
9402    @GOTOFF in `reg'.  */
9403 rtx
9404 legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
9405                         rtx reg)
9406 {
9407   if (tls_symbolic_operand (orig, Pmode) != TLS_MODEL_NONE)
9408     return orig;
9409
9410   if (GET_CODE (orig) == LABEL_REF
9411       || (GET_CODE (orig) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (orig)))
9412     {
9413       if (reg == 0)
9414         reg = gen_reg_rtx (Pmode);
9415
9416       emit_insn (gen_symGOTOFF2reg (reg, orig));
9417       return reg;
9418     }
9419   else if (GET_CODE (orig) == SYMBOL_REF)
9420     {
9421       if (reg == 0)
9422         reg = gen_reg_rtx (Pmode);
9423
9424       emit_insn (gen_symGOT2reg (reg, orig));
9425       return reg;
9426     }
9427   return orig;
9428 }
9429
9430 /* Try machine-dependent ways of modifying an illegitimate address
9431    to be legitimate.  If we find one, return the new, valid address.
9432    Otherwise, return X.
9433
9434    For the SH, if X is almost suitable for indexing, but the offset is
9435    out of range, convert it into a normal form so that CSE has a chance
9436    of reducing the number of address registers used.  */
9437
9438 static rtx
9439 sh_legitimize_address (rtx x, rtx oldx, enum machine_mode mode)
9440 {
9441   if (flag_pic)
9442     x = legitimize_pic_address (oldx, mode, NULL_RTX);
9443
9444   if (GET_CODE (x) == PLUS
9445       && (GET_MODE_SIZE (mode) == 4
9446           || GET_MODE_SIZE (mode) == 8)
9447       && CONST_INT_P (XEXP (x, 1))
9448       && BASE_REGISTER_RTX_P (XEXP (x, 0))
9449       && ! TARGET_SHMEDIA
9450       && ! ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && mode == DFmode)
9451       && ! (TARGET_SH2E && mode == SFmode))
9452     {
9453       rtx index_rtx = XEXP (x, 1);
9454       HOST_WIDE_INT offset = INTVAL (index_rtx), offset_base;
9455       rtx sum;
9456
9457       /* On rare occasions, we might get an unaligned pointer
9458          that is indexed in a way to give an aligned address.
9459          Therefore, keep the lower two bits in offset_base.  */
9460       /* Instead of offset_base 128..131 use 124..127, so that
9461          simple add suffices.  */
9462       if (offset > 127)
9463         offset_base = ((offset + 4) & ~60) - 4;
9464       else
9465         offset_base = offset & ~60;
9466
9467       /* Sometimes the normal form does not suit DImode.  We
9468          could avoid that by using smaller ranges, but that
9469          would give less optimized code when SImode is
9470          prevalent.  */
9471       if (GET_MODE_SIZE (mode) + offset - offset_base <= 64)
9472         {
9473           sum = expand_binop (Pmode, add_optab, XEXP (x, 0),
9474                               GEN_INT (offset_base), NULL_RTX, 0,
9475                               OPTAB_LIB_WIDEN);
9476
9477           return gen_rtx_PLUS (Pmode, sum, GEN_INT (offset - offset_base));
9478         }
9479     }
9480
9481   return x;
9482 }
9483
9484 /* Mark the use of a constant in the literal table. If the constant
9485    has multiple labels, make it unique.  */
9486 static rtx
9487 mark_constant_pool_use (rtx x)
9488 {
9489   rtx insn, lab, pattern;
9490
9491   if (x == NULL)
9492     return x;
9493
9494   switch (GET_CODE (x))
9495     {
9496     case LABEL_REF:
9497       x = XEXP (x, 0);
9498     case CODE_LABEL:
9499       break;
9500     default:
9501       return x;
9502     }
9503
9504   /* Get the first label in the list of labels for the same constant
9505      and delete another labels in the list.  */
9506   lab = x;
9507   for (insn = PREV_INSN (x); insn; insn = PREV_INSN (insn))
9508     {
9509       if (!LABEL_P (insn)
9510           || LABEL_REFS (insn) != NEXT_INSN (insn))
9511         break;
9512       lab = insn;
9513     }
9514
9515   for (insn = LABEL_REFS (lab); insn; insn = LABEL_REFS (insn))
9516     INSN_DELETED_P (insn) = 1;
9517
9518   /* Mark constants in a window.  */
9519   for (insn = NEXT_INSN (x); insn; insn = NEXT_INSN (insn))
9520     {
9521       if (!NONJUMP_INSN_P (insn))
9522         continue;
9523
9524       pattern = PATTERN (insn);
9525       if (GET_CODE (pattern) != UNSPEC_VOLATILE)
9526         continue;
9527
9528       switch (XINT (pattern, 1))
9529         {
9530         case UNSPECV_CONST2:
9531         case UNSPECV_CONST4:
9532         case UNSPECV_CONST8:
9533           XVECEXP (pattern, 0, 1) = const1_rtx;
9534           break;
9535         case UNSPECV_WINDOW_END:
9536           if (XVECEXP (pattern, 0, 0) == x)
9537             return lab;
9538           break;
9539         case UNSPECV_CONST_END:
9540           return lab;
9541         default:
9542           break;
9543         }
9544     }
9545
9546   return lab;
9547 }
9548 \f
9549 /* Return true if it's possible to redirect BRANCH1 to the destination
9550    of an unconditional jump BRANCH2.  We only want to do this if the
9551    resulting branch will have a short displacement.  */
9552 int
9553 sh_can_redirect_branch (rtx branch1, rtx branch2)
9554 {
9555   if (flag_expensive_optimizations && simplejump_p (branch2))
9556     {
9557       rtx dest = XEXP (SET_SRC (single_set (branch2)), 0);
9558       rtx insn;
9559       int distance;
9560
9561       for (distance = 0, insn = NEXT_INSN (branch1);
9562            insn && distance < 256;
9563            insn = PREV_INSN (insn))
9564         {
9565           if (insn == dest)
9566             return 1;
9567           else
9568             distance += get_attr_length (insn);
9569         }
9570       for (distance = 0, insn = NEXT_INSN (branch1);
9571            insn && distance < 256;
9572            insn = NEXT_INSN (insn))
9573         {
9574           if (insn == dest)
9575             return 1;
9576           else
9577             distance += get_attr_length (insn);
9578         }
9579     }
9580   return 0;
9581 }
9582
9583 /* Return nonzero if register old_reg can be renamed to register new_reg.  */
9584 int
9585 sh_hard_regno_rename_ok (unsigned int old_reg ATTRIBUTE_UNUSED,
9586                          unsigned int new_reg)
9587 {
9588   /* Interrupt functions can only use registers that have already been
9589      saved by the prologue, even if they would normally be
9590      call-clobbered.  */
9591
9592   if (sh_cfun_interrupt_handler_p () && !df_regs_ever_live_p (new_reg))
9593     return 0;
9594
9595   return 1;
9596 }
9597
9598 /* Function to update the integer COST
9599    based on the relationship between INSN that is dependent on
9600    DEP_INSN through the dependence LINK.  The default is to make no
9601    adjustment to COST.  This can be used for example to specify to
9602    the scheduler that an output- or anti-dependence does not incur
9603    the same cost as a data-dependence.  The return value should be
9604    the new value for COST.  */
9605 static int
9606 sh_adjust_cost (rtx insn, rtx link ATTRIBUTE_UNUSED, rtx dep_insn, int cost)
9607 {
9608   rtx reg, use_pat;
9609
9610   if (TARGET_SHMEDIA)
9611     {
9612       /* On SHmedia, if the dependence is an anti-dependence or
9613          output-dependence, there is no cost.  */
9614       if (REG_NOTE_KIND (link) != 0)
9615         {
9616           /* However, dependencies between target register loads and
9617              uses of the register in a subsequent block that are separated
9618              by a conditional branch are not modelled - we have to do with
9619              the anti-dependency between the target register load and the
9620              conditional branch that ends the current block.  */
9621           if (REG_NOTE_KIND (link) == REG_DEP_ANTI
9622               && GET_CODE (PATTERN (dep_insn)) == SET
9623               && (get_attr_type (dep_insn) == TYPE_PT_MEDIA
9624                   || get_attr_type (dep_insn) == TYPE_PTABS_MEDIA)
9625               && get_attr_type (insn) == TYPE_CBRANCH_MEDIA)
9626             {
9627               int orig_cost = cost;
9628               rtx note = find_reg_note (insn, REG_BR_PROB, 0);
9629               rtx target = ((! note
9630                              || INTVAL (XEXP (note, 0)) * 2 < REG_BR_PROB_BASE)
9631                             ? insn : JUMP_LABEL (insn));
9632               /* On the likely path, the branch costs 1, on the unlikely path,
9633                  it costs 3.  */
9634               cost--;
9635               do
9636                 target = next_active_insn (target);
9637               while (target && ! flow_dependent_p (target, dep_insn)
9638                      && --cost > 0);
9639               /* If two branches are executed in immediate succession, with the
9640                  first branch properly predicted, this causes a stall at the
9641                  second branch, hence we won't need the target for the
9642                  second branch for two cycles after the launch of the first
9643                  branch.  */
9644               if (cost > orig_cost - 2)
9645                 cost = orig_cost - 2;
9646             }
9647           else
9648             cost = 0;
9649         }
9650
9651       else if (get_attr_is_mac_media (insn)
9652                && get_attr_is_mac_media (dep_insn))
9653         cost = 1;
9654
9655       else if (! reload_completed
9656                && GET_CODE (PATTERN (insn)) == SET
9657                && GET_CODE (SET_SRC (PATTERN (insn))) == FLOAT
9658                && GET_CODE (PATTERN (dep_insn)) == SET
9659                && fp_arith_reg_operand (SET_SRC (PATTERN (dep_insn)), VOIDmode)
9660                && cost < 4)
9661         cost = 4;
9662       /* Schedule the ptabs for a casesi_jump_media in preference to stuff
9663          that is needed at the target.  */
9664       else if (get_attr_type (insn) == TYPE_JUMP_MEDIA
9665                && ! flow_dependent_p (insn, dep_insn))
9666         cost--;
9667     }
9668   else if (REG_NOTE_KIND (link) == 0)
9669     {
9670       enum attr_type type;
9671       rtx dep_set;
9672
9673       if (recog_memoized (insn) < 0
9674           || recog_memoized (dep_insn) < 0)
9675         return cost;
9676
9677       dep_set = single_set (dep_insn);
9678
9679       /* The latency that we specify in the scheduling description refers
9680          to the actual output, not to an auto-increment register; for that,
9681          the latency is one.  */
9682       if (dep_set && MEM_P (SET_SRC (dep_set)) && cost > 1)
9683         {
9684           rtx set = single_set (insn);
9685
9686           if (set
9687               && !reg_mentioned_p (SET_DEST (dep_set), SET_SRC (set))
9688               && (!MEM_P (SET_DEST (set))
9689                   || !reg_mentioned_p (SET_DEST (dep_set),
9690                                        XEXP (SET_DEST (set), 0))))
9691             cost = 1;
9692         }
9693       /* The only input for a call that is timing-critical is the
9694          function's address.  */
9695       if (CALL_P (insn))
9696         {
9697           rtx call = PATTERN (insn);
9698
9699           if (GET_CODE (call) == PARALLEL)
9700             call = XVECEXP (call, 0 ,0);
9701           if (GET_CODE (call) == SET)
9702             call = SET_SRC (call);
9703           if (GET_CODE (call) == CALL && MEM_P (XEXP (call, 0))
9704                   /* sibcalli_thunk uses a symbol_ref in an unspec.  */
9705               && (GET_CODE (XEXP (XEXP (call, 0), 0)) == UNSPEC
9706                   || ! reg_set_p (XEXP (XEXP (call, 0), 0), dep_insn)))
9707             cost -= TARGET_SH4_300 ? 3 : 6;
9708         }
9709       /* Likewise, the most timing critical input for an sfuncs call
9710          is the function address.  However, sfuncs typically start
9711          using their arguments pretty quickly.
9712          Assume a four cycle delay for SH4 before they are needed.
9713          Cached ST40-300 calls are quicker, so assume only a one
9714          cycle delay there.
9715          ??? Maybe we should encode the delays till input registers
9716          are needed by sfuncs into the sfunc call insn.  */
9717       /* All sfunc calls are parallels with at least four components.
9718          Exploit this to avoid unnecessary calls to sfunc_uses_reg.  */
9719       else if (GET_CODE (PATTERN (insn)) == PARALLEL
9720                && XVECLEN (PATTERN (insn), 0) >= 4
9721                && (reg = sfunc_uses_reg (insn)))
9722         {
9723           if (! reg_set_p (reg, dep_insn))
9724             cost -= TARGET_SH4_300 ? 1 : 4;
9725         }
9726       if (TARGET_HARD_SH4 && !TARGET_SH4_300)
9727         {
9728           enum attr_type dep_type = get_attr_type (dep_insn);
9729
9730           if (dep_type == TYPE_FLOAD || dep_type == TYPE_PCFLOAD)
9731             cost--;
9732           else if ((dep_type == TYPE_LOAD_SI || dep_type == TYPE_PCLOAD_SI)
9733                    && (type = get_attr_type (insn)) != TYPE_CALL
9734                    && type != TYPE_SFUNC)
9735             cost--;
9736           /* When the preceding instruction loads the shift amount of
9737              the following SHAD/SHLD, the latency of the load is increased
9738              by 1 cycle.  */
9739           if (get_attr_type (insn) == TYPE_DYN_SHIFT
9740               && get_attr_any_int_load (dep_insn) == ANY_INT_LOAD_YES
9741               && reg_overlap_mentioned_p (SET_DEST (dep_set),
9742                                           XEXP (SET_SRC (single_set (insn)),
9743                                                 1)))
9744             cost++;
9745           /* When an LS group instruction with a latency of less than
9746              3 cycles is followed by a double-precision floating-point
9747              instruction, FIPR, or FTRV, the latency of the first
9748              instruction is increased to 3 cycles.  */
9749           else if (cost < 3
9750                    && get_attr_insn_class (dep_insn) == INSN_CLASS_LS_GROUP
9751                    && get_attr_dfp_comp (insn) == DFP_COMP_YES)
9752             cost = 3;
9753           /* The lsw register of a double-precision computation is ready one
9754              cycle earlier.  */
9755           else if (reload_completed
9756                    && get_attr_dfp_comp (dep_insn) == DFP_COMP_YES
9757                    && (use_pat = single_set (insn))
9758                    && ! regno_use_in (REGNO (SET_DEST (single_set (dep_insn))),
9759                                       SET_SRC (use_pat)))
9760             cost -= 1;
9761
9762           if (get_attr_any_fp_comp (dep_insn) == ANY_FP_COMP_YES
9763               && get_attr_late_fp_use (insn) == LATE_FP_USE_YES)
9764             cost -= 1;
9765         }
9766       else if (TARGET_SH4_300)
9767         {
9768           /* Stores need their input register two cycles later.  */
9769           if (dep_set && cost >= 1
9770               && ((type = get_attr_type (insn)) == TYPE_STORE
9771                   || type == TYPE_PSTORE
9772                   || type == TYPE_FSTORE || type == TYPE_MAC_MEM))
9773             {
9774               rtx set = single_set (insn);
9775
9776               if (!reg_mentioned_p (SET_SRC (set), XEXP (SET_DEST (set), 0))
9777                   && rtx_equal_p (SET_SRC (set), SET_DEST (dep_set)))
9778                 {
9779                   cost -= 2;
9780                   /* But don't reduce the cost below 1 if the address depends
9781                      on a side effect of dep_insn.  */
9782                   if (cost < 1
9783                       && modified_in_p (XEXP (SET_DEST (set), 0), dep_insn))
9784                     cost = 1;
9785                 }
9786             }
9787         }
9788     }
9789   /* An anti-dependence penalty of two applies if the first insn is a double
9790      precision fadd / fsub / fmul.  */
9791   else if (!TARGET_SH4_300
9792            && REG_NOTE_KIND (link) == REG_DEP_ANTI
9793            && recog_memoized (dep_insn) >= 0
9794            && (get_attr_type (dep_insn) == TYPE_DFP_ARITH
9795                || get_attr_type (dep_insn) == TYPE_DFP_MUL)
9796            /* A lot of alleged anti-flow dependences are fake,
9797               so check this one is real.  */
9798            && flow_dependent_p (dep_insn, insn))
9799     cost = 2;
9800
9801   return cost;
9802 }
9803
9804 /* Check if INSN is flow-dependent on DEP_INSN.  Can also be used to check
9805    if DEP_INSN is anti-flow dependent on INSN.  */
9806 static int
9807 flow_dependent_p (rtx insn, rtx dep_insn)
9808 {
9809   rtx tmp = PATTERN (insn);
9810
9811   note_stores (PATTERN (dep_insn), flow_dependent_p_1, &tmp);
9812   return tmp == NULL_RTX;
9813 }
9814
9815 /* A helper function for flow_dependent_p called through note_stores.  */
9816 static void
9817 flow_dependent_p_1 (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data)
9818 {
9819   rtx * pinsn = (rtx *) data;
9820
9821   if (*pinsn && reg_referenced_p (x, *pinsn))
9822     *pinsn = NULL_RTX;
9823 }
9824
9825 /* For use by sh_allocate_initial_value.  Note that sh.md contains some
9826    'special function' patterns (type sfunc) that clobber pr, but that
9827    do not look like function calls to leaf_function_p.  Hence we must
9828    do this extra check.  */
9829 static int
9830 sh_pr_n_sets (void)
9831 {
9832   return DF_REG_DEF_COUNT (TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG);
9833 }
9834
9835 /* Return where to allocate pseudo for a given hard register initial
9836    value.  */
9837 static rtx
9838 sh_allocate_initial_value (rtx hard_reg)
9839 {
9840   rtx x;
9841
9842   if (REGNO (hard_reg) == (TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG))
9843     {
9844       if (current_function_is_leaf
9845           && ! sh_pr_n_sets ()
9846           && ! (TARGET_SHCOMPACT
9847                 && ((crtl->args.info.call_cookie
9848                      & ~ CALL_COOKIE_RET_TRAMP (1))
9849                     || crtl->saves_all_registers)))
9850         x = hard_reg;
9851       else
9852         x = gen_frame_mem (Pmode, return_address_pointer_rtx);
9853     }
9854   else
9855     x = NULL_RTX;
9856
9857   return x;
9858 }
9859
9860 /* This function returns "2" to indicate dual issue for the SH4
9861    processor.  To be used by the DFA pipeline description.  */
9862 static int
9863 sh_issue_rate (void)
9864 {
9865   if (TARGET_SUPERSCALAR)
9866     return 2;
9867   else
9868     return 1;
9869 }
9870
9871 /* Functions for ready queue reordering for sched1.  */
9872
9873 /* Get weight for mode for a set x.  */
9874 static short
9875 find_set_regmode_weight (rtx x, enum machine_mode mode)
9876 {
9877   if (GET_CODE (x) == CLOBBER && register_operand (SET_DEST (x), mode))
9878     return 1;
9879   if (GET_CODE (x) == SET && register_operand (SET_DEST (x), mode))
9880     {
9881       if (REG_P (SET_DEST (x)))
9882         {
9883           if (!reg_mentioned_p (SET_DEST (x), SET_SRC (x)))
9884             return 1;
9885           else
9886             return 0;
9887         }
9888       return 1;
9889     }
9890   return 0;
9891 }
9892
9893 /* Get regmode weight for insn.  */
9894 static short
9895 find_insn_regmode_weight (rtx insn, enum machine_mode mode)
9896 {
9897   short reg_weight = 0;
9898   rtx x;
9899
9900   /* Increment weight for each register born here.  */
9901   x = PATTERN (insn);
9902   reg_weight += find_set_regmode_weight (x, mode);
9903   if (GET_CODE (x) == PARALLEL)
9904     {
9905       int j;
9906       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
9907         {
9908           x = XVECEXP (PATTERN (insn), 0, j);
9909           reg_weight += find_set_regmode_weight (x, mode);
9910         }
9911     }
9912   /* Decrement weight for each register that dies here.  */
9913   for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
9914     {
9915       if (REG_NOTE_KIND (x) == REG_DEAD || REG_NOTE_KIND (x) == REG_UNUSED)
9916         {
9917           rtx note = XEXP (x, 0);
9918           if (REG_P (note) && GET_MODE (note) == mode)
9919             reg_weight--;
9920         }
9921     }
9922   return reg_weight;
9923 }
9924
9925 /* Calculate regmode weights for all insns of a basic block.  */
9926 static void
9927 find_regmode_weight (basic_block b, enum machine_mode mode)
9928 {
9929   rtx insn, next_tail, head, tail;
9930
9931   get_ebb_head_tail (b, b, &head, &tail);
9932   next_tail = NEXT_INSN (tail);
9933
9934   for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
9935     {
9936       /* Handle register life information.  */
9937       if (!INSN_P (insn))
9938         continue;
9939
9940       if (mode == SFmode)
9941         INSN_REGMODE_WEIGHT (insn, mode) =
9942           find_insn_regmode_weight (insn, mode) + 2 * find_insn_regmode_weight (insn, DFmode);
9943       else if (mode == SImode)
9944         INSN_REGMODE_WEIGHT (insn, mode) =
9945           find_insn_regmode_weight (insn, mode) + 2 * find_insn_regmode_weight (insn, DImode);
9946     }
9947 }
9948
9949 /* Comparison function for ready queue sorting.  */
9950 static int
9951 rank_for_reorder (const void *x, const void *y)
9952 {
9953   rtx tmp = *(const rtx *) y;
9954   rtx tmp2 = *(const rtx *) x;
9955
9956   /* The insn in a schedule group should be issued the first.  */
9957   if (SCHED_GROUP_P (tmp) != SCHED_GROUP_P (tmp2))
9958     return SCHED_GROUP_P (tmp2) ? 1 : -1;
9959
9960   /* If insns are equally good, sort by INSN_LUID (original insn order), This
9961      minimizes instruction movement, thus minimizing sched's effect on
9962      register pressure.  */
9963   return INSN_LUID (tmp) - INSN_LUID (tmp2);
9964 }
9965
9966 /* Resort the array A in which only element at index N may be out of order.  */
9967 static void
9968 swap_reorder (rtx *a, int n)
9969 {
9970   rtx insn = a[n - 1];
9971   int i = n - 2;
9972
9973   while (i >= 0 && rank_for_reorder (a + i, &insn) >= 0)
9974     {
9975       a[i + 1] = a[i];
9976       i -= 1;
9977     }
9978   a[i + 1] = insn;
9979 }
9980
9981 #define SCHED_REORDER(READY, N_READY)                                   \
9982   do                                                                    \
9983     {                                                                   \
9984       if ((N_READY) == 2)                                               \
9985         swap_reorder (READY, N_READY);                                  \
9986       else if ((N_READY) > 2)                                           \
9987         qsort (READY, N_READY, sizeof (rtx), rank_for_reorder);         \
9988     }                                                                   \
9989   while (0)
9990
9991 /* Sort the ready list READY by ascending priority, using the SCHED_REORDER
9992    macro.  */
9993 static void
9994 ready_reorder (rtx *ready, int nready)
9995 {
9996   SCHED_REORDER (ready, nready);
9997 }
9998
9999 /* Count life regions of r0 for a block.  */
10000 static int
10001 find_r0_life_regions (basic_block b)
10002 {
10003   rtx end, insn;
10004   rtx pset;
10005   rtx r0_reg;
10006   int live;
10007   int set;
10008   int death = 0;
10009
10010   if (REGNO_REG_SET_P (df_get_live_in (b), R0_REG))
10011     {
10012       set = 1;
10013       live = 1;
10014     }
10015   else
10016     {
10017       set = 0;
10018       live = 0;
10019     }
10020
10021   insn = BB_HEAD (b);
10022   end = BB_END (b);
10023   r0_reg = gen_rtx_REG (SImode, R0_REG);
10024   while (1)
10025     {
10026       if (INSN_P (insn))
10027         {
10028           if (find_regno_note (insn, REG_DEAD, R0_REG))
10029             {
10030               death++;
10031               live = 0;
10032             }
10033           if (!live
10034               && (pset = single_set (insn))
10035               && reg_overlap_mentioned_p (r0_reg, SET_DEST (pset))
10036               && !find_regno_note (insn, REG_UNUSED, R0_REG))
10037             {
10038               set++;
10039               live = 1;
10040             }
10041         }
10042       if (insn == end)
10043         break;
10044       insn = NEXT_INSN (insn);
10045     }
10046   return set - death;
10047 }
10048
10049 /* Calculate regmode weights for all insns of all basic block.  */
10050 static void
10051 sh_md_init_global (FILE *dump ATTRIBUTE_UNUSED,
10052                    int verbose ATTRIBUTE_UNUSED,
10053                    int old_max_uid)
10054 {
10055   basic_block b;
10056
10057   regmode_weight[0] = (short *) xcalloc (old_max_uid, sizeof (short));
10058   regmode_weight[1] = (short *) xcalloc (old_max_uid, sizeof (short));
10059   r0_life_regions = 0;
10060
10061   FOR_EACH_BB_REVERSE (b)
10062   {
10063     find_regmode_weight (b, SImode);
10064     find_regmode_weight (b, SFmode);
10065     if (!reload_completed)
10066       r0_life_regions += find_r0_life_regions (b);
10067   }
10068
10069   CURR_REGMODE_PRESSURE (SImode) = 0;
10070   CURR_REGMODE_PRESSURE (SFmode) = 0;
10071
10072 }
10073
10074 /* Cleanup.  */
10075 static void
10076 sh_md_finish_global (FILE *dump ATTRIBUTE_UNUSED,
10077                      int verbose ATTRIBUTE_UNUSED)
10078 {
10079   if (regmode_weight[0])
10080     {
10081       free (regmode_weight[0]);
10082       regmode_weight[0] = NULL;
10083     }
10084   if (regmode_weight[1])
10085     {
10086       free (regmode_weight[1]);
10087       regmode_weight[1] = NULL;
10088     }
10089 }
10090
10091 /* The scalar modes supported differs from the default version in TImode
10092    for 32-bit SHMEDIA.  */
10093 static bool
10094 sh_scalar_mode_supported_p (enum machine_mode mode)
10095 {
10096   if (TARGET_SHMEDIA32 && mode == TImode)
10097     return false;
10098
10099   return default_scalar_mode_supported_p (mode);
10100 }
10101
10102 /* Cache the can_issue_more so that we can return it from reorder2. Also,
10103    keep count of register pressures on SImode and SFmode. */
10104 static int
10105 sh_variable_issue (FILE *dump ATTRIBUTE_UNUSED,
10106                    int sched_verbose ATTRIBUTE_UNUSED,
10107                    rtx insn,
10108                    int can_issue_more)
10109 {
10110   if (GET_CODE (PATTERN (insn)) != USE
10111       && GET_CODE (PATTERN (insn)) != CLOBBER)
10112     cached_can_issue_more = can_issue_more - 1;
10113   else
10114     cached_can_issue_more = can_issue_more;
10115
10116   if (reload_completed)
10117     return cached_can_issue_more;
10118
10119   CURR_REGMODE_PRESSURE (SImode) += INSN_REGMODE_WEIGHT (insn, SImode);
10120   CURR_REGMODE_PRESSURE (SFmode) += INSN_REGMODE_WEIGHT (insn, SFmode);
10121
10122   return cached_can_issue_more;
10123 }
10124
10125 static void
10126 sh_md_init (FILE *dump ATTRIBUTE_UNUSED,
10127             int verbose ATTRIBUTE_UNUSED,
10128             int veclen ATTRIBUTE_UNUSED)
10129 {
10130   CURR_REGMODE_PRESSURE (SImode) = 0;
10131   CURR_REGMODE_PRESSURE (SFmode) = 0;
10132 }
10133
10134 /* Some magic numbers.  */
10135 /* Pressure on register r0 can lead to spill failures. so avoid sched1 for
10136    functions that already have high pressure on r0. */
10137 #define R0_MAX_LIFE_REGIONS 2
10138 /* Register Pressure thresholds for SImode and SFmode registers.  */
10139 #define SIMODE_MAX_WEIGHT 5
10140 #define SFMODE_MAX_WEIGHT 10
10141
10142 /* Return true if the pressure is high for MODE.  */
10143 static short
10144 high_pressure (enum machine_mode mode)
10145 {
10146   /* Pressure on register r0 can lead to spill failures. so avoid sched1 for
10147      functions that already have high pressure on r0. */
10148    if (r0_life_regions >= R0_MAX_LIFE_REGIONS)
10149      return 1;
10150
10151   if (mode == SFmode)
10152     return (CURR_REGMODE_PRESSURE (SFmode) > SFMODE_MAX_WEIGHT);
10153   else
10154     return (CURR_REGMODE_PRESSURE (SImode) > SIMODE_MAX_WEIGHT);
10155 }
10156
10157 /* Reorder ready queue if register pressure is high.  */
10158 static int
10159 sh_reorder (FILE *dump ATTRIBUTE_UNUSED,
10160             int sched_verbose ATTRIBUTE_UNUSED,
10161             rtx *ready,
10162             int *n_readyp,
10163             int clock_var ATTRIBUTE_UNUSED)
10164 {
10165   if (reload_completed)
10166     return sh_issue_rate ();
10167
10168   if (high_pressure (SFmode) || high_pressure (SImode))
10169     {
10170       ready_reorder (ready, *n_readyp);
10171     }
10172
10173   return sh_issue_rate ();
10174 }
10175
10176 /* Skip cycles if the current register pressure is high.  */
10177 static int
10178 sh_reorder2 (FILE *dump ATTRIBUTE_UNUSED,
10179              int sched_verbose ATTRIBUTE_UNUSED,
10180              rtx *ready ATTRIBUTE_UNUSED,
10181              int *n_readyp ATTRIBUTE_UNUSED,
10182              int clock_var ATTRIBUTE_UNUSED)
10183 {
10184   if (reload_completed)
10185     return cached_can_issue_more;
10186
10187   if (high_pressure(SFmode) || high_pressure (SImode))
10188     skip_cycles = 1;
10189
10190   return cached_can_issue_more;
10191 }
10192
10193 /* Skip cycles without sorting the ready queue. This will move insn from
10194    Q->R. If this is the last cycle we are skipping; allow sorting of ready
10195    queue by sh_reorder.  */
10196
10197 /* Generally, skipping these many cycles are sufficient for all insns to move
10198    from Q -> R.  */
10199 #define MAX_SKIPS 8
10200
10201 static int
10202 sh_dfa_new_cycle (FILE *sched_dump ATTRIBUTE_UNUSED,
10203                   int sched_verbose ATTRIBUTE_UNUSED,
10204                   rtx insn ATTRIBUTE_UNUSED,
10205                   int last_clock_var,
10206                   int clock_var,
10207                   int *sort_p)
10208 {
10209   if (reload_completed)
10210     return 0;
10211
10212   if (skip_cycles)
10213     {
10214       if ((clock_var - last_clock_var) < MAX_SKIPS)
10215         {
10216           *sort_p = 0;
10217           return 1;
10218         }
10219       /* If this is the last cycle we are skipping, allow reordering of R.  */
10220       if ((clock_var - last_clock_var) == MAX_SKIPS)
10221         {
10222           *sort_p = 1;
10223           return 1;
10224         }
10225     }
10226
10227   skip_cycles = 0;
10228
10229   return 0;
10230 }
10231
10232 /* SHmedia requires registers for branches, so we can't generate new
10233    branches past reload.  */
10234 static bool
10235 sh_cannot_modify_jumps_p (void)
10236 {
10237   return (TARGET_SHMEDIA && (reload_in_progress || reload_completed));
10238 }
10239
10240 static enum reg_class
10241 sh_target_reg_class (void)
10242 {
10243   return TARGET_SHMEDIA ? TARGET_REGS : NO_REGS;
10244 }
10245
10246 static bool
10247 sh_optimize_target_register_callee_saved (bool after_prologue_epilogue_gen)
10248 {
10249   HARD_REG_SET dummy;
10250 #if 0
10251   rtx insn;
10252 #endif
10253
10254   if (! shmedia_space_reserved_for_target_registers)
10255     return 0;
10256   if (after_prologue_epilogue_gen && ! TARGET_SAVE_ALL_TARGET_REGS)
10257     return 0;
10258   if (calc_live_regs (&dummy) >= 6 * 8)
10259     return 1;
10260   return 0;
10261 }
10262
10263 static bool
10264 sh_ms_bitfield_layout_p (const_tree record_type ATTRIBUTE_UNUSED)
10265 {
10266   return (TARGET_SH5 || TARGET_HITACHI || sh_attr_renesas_p (record_type));
10267 }
10268 \f
10269 /*
10270    On the SH1..SH4, the trampoline looks like
10271    2 0002 D202                  mov.l   l2,r2
10272    1 0000 D301                  mov.l   l1,r3
10273    3 0004 422B                  jmp     @r2
10274    4 0006 0009                  nop
10275    5 0008 00000000      l1:     .long   area
10276    6 000c 00000000      l2:     .long   function
10277
10278    SH5 (compact) uses r1 instead of r3 for the static chain.  */
10279
10280
10281 /* Emit RTL insns to initialize the variable parts of a trampoline.
10282    FNADDR is an RTX for the address of the function's pure code.
10283    CXT is an RTX for the static chain value for the function.  */
10284
10285 void
10286 sh_initialize_trampoline (rtx tramp, rtx fnaddr, rtx cxt)
10287 {
10288   rtx tramp_mem = gen_frame_mem (BLKmode, tramp);
10289
10290   if (TARGET_SHMEDIA64)
10291     {
10292       rtx tramp_templ;
10293       int fixed_len;
10294
10295       rtx movi1 = GEN_INT (0xcc000010);
10296       rtx shori1 = GEN_INT (0xc8000010);
10297       rtx src, dst;
10298
10299       /* The following trampoline works within a +- 128 KB range for cxt:
10300          ptb/u cxt,tr1; movi fnaddr >> 48,r0; shori fnaddr >> 32,r0;
10301          shori fnaddr >> 16,r0; shori fnaddr,r0; ptabs/l r0,tr0
10302          gettr tr1,r1; blink tr0,r63  */
10303       /* Address rounding makes it hard to compute the exact bounds of the
10304          offset for this trampoline, but we have a rather generous offset
10305          range, so frame_offset should do fine as an upper bound.  */
10306       if (cxt == virtual_stack_vars_rtx && frame_offset < 0x20000)
10307         {
10308           /* ??? could optimize this trampoline initialization
10309              by writing DImode words with two insns each.  */
10310           rtx mask = force_reg (DImode, GEN_INT (0x3fffc00));
10311           rtx insn = gen_rtx_MINUS (DImode, cxt, tramp);
10312           insn = gen_rtx_ASHIFT (DImode, insn, GEN_INT (10-2));
10313           insn = gen_rtx_AND (DImode, insn, mask);
10314           /* Or in ptb/u .,tr1 pattern */
10315           insn = gen_rtx_IOR (DImode, insn, gen_int_mode (0xec000010, SImode));
10316           insn = force_operand (insn, NULL_RTX);
10317           insn = gen_lowpart (SImode, insn);
10318           emit_move_insn (change_address (tramp_mem, SImode, NULL_RTX), insn);
10319           insn = gen_rtx_LSHIFTRT (DImode, fnaddr, GEN_INT (38));
10320           insn = gen_rtx_AND (DImode, insn, mask);
10321           insn = force_operand (gen_rtx_IOR (DImode, movi1, insn), NULL_RTX);
10322           insn = gen_lowpart (SImode, insn);
10323           emit_move_insn (adjust_address (tramp_mem, SImode, 4), insn);
10324           insn = gen_rtx_LSHIFTRT (DImode, fnaddr, GEN_INT (22));
10325           insn = gen_rtx_AND (DImode, insn, mask);
10326           insn = force_operand (gen_rtx_IOR (DImode, shori1, insn), NULL_RTX);
10327           insn = gen_lowpart (SImode, insn);
10328           emit_move_insn (adjust_address (tramp_mem, SImode, 8), insn);
10329           insn = gen_rtx_LSHIFTRT (DImode, fnaddr, GEN_INT (6));
10330           insn = gen_rtx_AND (DImode, insn, mask);
10331           insn = force_operand (gen_rtx_IOR (DImode, shori1, insn), NULL_RTX);
10332           insn = gen_lowpart (SImode, insn);
10333           emit_move_insn (adjust_address (tramp_mem, SImode, 12), insn);
10334           insn = gen_rtx_ASHIFT (DImode, fnaddr, GEN_INT (10));
10335           insn = gen_rtx_AND (DImode, insn, mask);
10336           insn = force_operand (gen_rtx_IOR (DImode, shori1, insn), NULL_RTX);
10337           insn = gen_lowpart (SImode, insn);
10338           emit_move_insn (adjust_address (tramp_mem, SImode, 16), insn);
10339           emit_move_insn (adjust_address (tramp_mem, SImode, 20),
10340                           GEN_INT (0x6bf10600));
10341           emit_move_insn (adjust_address (tramp_mem, SImode, 24),
10342                           GEN_INT (0x4415fc10));
10343           emit_move_insn (adjust_address (tramp_mem, SImode, 28),
10344                           GEN_INT (0x4401fff0));
10345           emit_insn (gen_ic_invalidate_line (tramp));
10346           return;
10347         }
10348       tramp_templ = gen_rtx_SYMBOL_REF (Pmode,"__GCC_nested_trampoline");
10349       fixed_len = TRAMPOLINE_SIZE - 2 * GET_MODE_SIZE (Pmode);
10350
10351       tramp_templ = gen_datalabel_ref (tramp_templ);
10352       dst = tramp_mem;
10353       src = gen_const_mem (BLKmode, tramp_templ);
10354       set_mem_align (dst, 256);
10355       set_mem_align (src, 64);
10356       emit_block_move (dst, src, GEN_INT (fixed_len), BLOCK_OP_NORMAL);
10357
10358       emit_move_insn (adjust_address (tramp_mem, Pmode, fixed_len), fnaddr);
10359       emit_move_insn (adjust_address (tramp_mem, Pmode,
10360                                       fixed_len + GET_MODE_SIZE (Pmode)),
10361                       cxt);
10362       emit_insn (gen_ic_invalidate_line (tramp));
10363       return;
10364     }
10365   else if (TARGET_SHMEDIA)
10366     {
10367       /* movi fnaddr >> 16,r1; shori fnaddr,r1; ptabs/l r1,tr0
10368          movi cxt >> 16,r1; shori cxt,r1; blink tr0,r63  */
10369       rtx quad0 = gen_reg_rtx (DImode), cxtload = gen_reg_rtx (DImode);
10370       rtx quad1 = gen_reg_rtx (DImode), quad2 = gen_reg_rtx (DImode);
10371       /* movi 0,r1: 0xcc000010 shori 0,r1: c8000010  concatenated,
10372          rotated 10 right, and higher 16 bit of every 32 selected.  */
10373       rtx movishori
10374         = force_reg (V2HImode, (simplify_gen_subreg
10375                                 (V2HImode, GEN_INT (0x4330432), SImode, 0)));
10376       rtx ptabs = force_reg (DImode, GEN_INT (0x6bf10600));
10377       rtx blink = force_reg (DImode, GEN_INT (0x4401fff0));
10378
10379       tramp = force_reg (Pmode, tramp);
10380       fnaddr = force_reg (SImode, fnaddr);
10381       cxt = force_reg (SImode, cxt);
10382       emit_insn (gen_mshflo_w_x (gen_rtx_SUBREG (V4HImode, quad0, 0),
10383                                  gen_rtx_SUBREG (V2HImode, fnaddr, 0),
10384                                  movishori));
10385       emit_insn (gen_rotrdi3_mextr (quad0, quad0,
10386                                     GEN_INT (TARGET_LITTLE_ENDIAN ? 24 : 56)));
10387       emit_insn (gen_ashldi3_media (quad0, quad0, const2_rtx));
10388       emit_move_insn (change_address (tramp_mem, DImode, NULL_RTX), quad0);
10389       emit_insn (gen_mshflo_w_x (gen_rtx_SUBREG (V4HImode, cxtload, 0),
10390                                  gen_rtx_SUBREG (V2HImode, cxt, 0),
10391                                  movishori));
10392       emit_insn (gen_rotrdi3_mextr (cxtload, cxtload,
10393                                     GEN_INT (TARGET_LITTLE_ENDIAN ? 24 : 56)));
10394       emit_insn (gen_ashldi3_media (cxtload, cxtload, const2_rtx));
10395       if (TARGET_LITTLE_ENDIAN)
10396         {
10397           emit_insn (gen_mshflo_l_di (quad1, ptabs, cxtload));
10398           emit_insn (gen_mextr4 (quad2, cxtload, blink));
10399         }
10400       else
10401         {
10402           emit_insn (gen_mextr4 (quad1, cxtload, ptabs));
10403           emit_insn (gen_mshflo_l_di (quad2, blink, cxtload));
10404         }
10405       emit_move_insn (adjust_address (tramp_mem, DImode, 8), quad1);
10406       emit_move_insn (adjust_address (tramp_mem, DImode, 16), quad2);
10407       emit_insn (gen_ic_invalidate_line (tramp));
10408       return;
10409     }
10410   else if (TARGET_SHCOMPACT)
10411     {
10412       emit_insn (gen_initialize_trampoline (tramp, cxt, fnaddr));
10413       return;
10414     }
10415   emit_move_insn (change_address (tramp_mem, SImode, NULL_RTX),
10416                   gen_int_mode (TARGET_LITTLE_ENDIAN ? 0xd301d202 : 0xd202d301,
10417                                 SImode));
10418   emit_move_insn (adjust_address (tramp_mem, SImode, 4),
10419                   gen_int_mode (TARGET_LITTLE_ENDIAN ? 0x0009422b : 0x422b0009,
10420                                 SImode));
10421   emit_move_insn (adjust_address (tramp_mem, SImode, 8), cxt);
10422   emit_move_insn (adjust_address (tramp_mem, SImode, 12), fnaddr);
10423   if (TARGET_HARVARD)
10424     {
10425       if (!TARGET_INLINE_IC_INVALIDATE
10426           || (!(TARGET_SH4A_ARCH || TARGET_SH4_300) && TARGET_USERMODE))
10427         emit_library_call (function_symbol (NULL, "__ic_invalidate",
10428                                             FUNCTION_ORDINARY),
10429                            LCT_NORMAL, VOIDmode, 1, tramp, SImode);
10430       else
10431         emit_insn (gen_ic_invalidate_line (tramp));
10432     }
10433 }
10434
10435 /* FIXME: This is overly conservative.  A SHcompact function that
10436    receives arguments ``by reference'' will have them stored in its
10437    own stack frame, so it must not pass pointers or references to
10438    these arguments to other functions by means of sibling calls.  */
10439 /* If PIC, we cannot make sibling calls to global functions
10440    because the PLT requires r12 to be live.  */
10441 static bool
10442 sh_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
10443 {
10444   return (1
10445           && (! TARGET_SHCOMPACT
10446               || crtl->args.info.stack_regs == 0)
10447           && ! sh_cfun_interrupt_handler_p ()
10448           && (! flag_pic
10449               || (decl && ! TREE_PUBLIC (decl))
10450               || (decl && DECL_VISIBILITY (decl) != VISIBILITY_DEFAULT)));
10451 }
10452 \f
10453 /* Machine specific built-in functions.  */
10454
10455 struct builtin_description
10456 {
10457   const enum insn_code icode;
10458   const char *const name;
10459   int signature;
10460 };
10461
10462 /* describe number and signedness of arguments; arg[0] == result
10463    (1: unsigned, 2: signed, 4: don't care, 8: pointer 0: no argument */
10464 /* 9: 64-bit pointer, 10: 32-bit pointer */
10465 static const char signature_args[][4] =
10466 {
10467 #define SH_BLTIN_V2SI2 0
10468   { 4, 4 },
10469 #define SH_BLTIN_V4HI2 1
10470   { 4, 4 },
10471 #define SH_BLTIN_V2SI3 2
10472   { 4, 4, 4 },
10473 #define SH_BLTIN_V4HI3 3
10474   { 4, 4, 4 },
10475 #define SH_BLTIN_V8QI3 4
10476   { 4, 4, 4 },
10477 #define SH_BLTIN_MAC_HISI 5
10478   { 1, 4, 4, 1 },
10479 #define SH_BLTIN_SH_HI 6
10480   { 4, 4, 1 },
10481 #define SH_BLTIN_SH_SI 7
10482   { 4, 4, 1 },
10483 #define SH_BLTIN_V4HI2V2SI 8
10484   { 4, 4, 4 },
10485 #define SH_BLTIN_V4HI2V8QI 9
10486   { 4, 4, 4 },
10487 #define SH_BLTIN_SISF 10
10488   { 4, 2 },
10489 #define SH_BLTIN_LDUA_L 11
10490   { 2, 10 },
10491 #define SH_BLTIN_LDUA_Q 12
10492   { 1, 10 },
10493 #define SH_BLTIN_STUA_L 13
10494   { 0, 10, 2 },
10495 #define SH_BLTIN_STUA_Q 14
10496   { 0, 10, 1 },
10497 #define SH_BLTIN_LDUA_L64 15
10498   { 2, 9 },
10499 #define SH_BLTIN_LDUA_Q64 16
10500   { 1, 9 },
10501 #define SH_BLTIN_STUA_L64 17
10502   { 0, 9, 2 },
10503 #define SH_BLTIN_STUA_Q64 18
10504   { 0, 9, 1 },
10505 #define SH_BLTIN_NUM_SHARED_SIGNATURES 19
10506 #define SH_BLTIN_2 19
10507 #define SH_BLTIN_SU 19
10508   { 1, 2 },
10509 #define SH_BLTIN_3 20
10510 #define SH_BLTIN_SUS 20
10511   { 2, 2, 1 },
10512 #define SH_BLTIN_PSSV 21
10513   { 0, 8, 2, 2 },
10514 #define SH_BLTIN_XXUU 22
10515 #define SH_BLTIN_UUUU 22
10516   { 1, 1, 1, 1 },
10517 #define SH_BLTIN_PV 23
10518   { 0, 8 },
10519 };
10520 /* mcmv: operands considered unsigned.  */
10521 /* mmulsum_wq, msad_ubq: result considered unsigned long long.  */
10522 /* mperm: control value considered unsigned int.  */
10523 /* mshalds, mshard, mshards, mshlld, mshlrd: shift count is unsigned int.  */
10524 /* mshards_q: returns signed short.  */
10525 /* nsb: takes long long arg, returns unsigned char.  */
10526 static const struct builtin_description bdesc[] =
10527 {
10528   { CODE_FOR_absv2si2,  "__builtin_absv2si2", SH_BLTIN_V2SI2 },
10529   { CODE_FOR_absv4hi2,  "__builtin_absv4hi2", SH_BLTIN_V4HI2 },
10530   { CODE_FOR_addv2si3,  "__builtin_addv2si3", SH_BLTIN_V2SI3 },
10531   { CODE_FOR_addv4hi3,  "__builtin_addv4hi3", SH_BLTIN_V4HI3 },
10532   { CODE_FOR_ssaddv2si3,"__builtin_ssaddv2si3", SH_BLTIN_V2SI3 },
10533   { CODE_FOR_usaddv8qi3,"__builtin_usaddv8qi3", SH_BLTIN_V8QI3 },
10534   { CODE_FOR_ssaddv4hi3,"__builtin_ssaddv4hi3", SH_BLTIN_V4HI3 },
10535   { CODE_FOR_alloco_i,  "__builtin_sh_media_ALLOCO", SH_BLTIN_PV },
10536   { CODE_FOR_negcmpeqv8qi,"__builtin_sh_media_MCMPEQ_B", SH_BLTIN_V8QI3 },
10537   { CODE_FOR_negcmpeqv2si,"__builtin_sh_media_MCMPEQ_L", SH_BLTIN_V2SI3 },
10538   { CODE_FOR_negcmpeqv4hi,"__builtin_sh_media_MCMPEQ_W", SH_BLTIN_V4HI3 },
10539   { CODE_FOR_negcmpgtuv8qi,"__builtin_sh_media_MCMPGT_UB", SH_BLTIN_V8QI3 },
10540   { CODE_FOR_negcmpgtv2si,"__builtin_sh_media_MCMPGT_L", SH_BLTIN_V2SI3 },
10541   { CODE_FOR_negcmpgtv4hi,"__builtin_sh_media_MCMPGT_W", SH_BLTIN_V4HI3 },
10542   { CODE_FOR_mcmv,      "__builtin_sh_media_MCMV", SH_BLTIN_UUUU },
10543   { CODE_FOR_mcnvs_lw,  "__builtin_sh_media_MCNVS_LW", SH_BLTIN_3 },
10544   { CODE_FOR_mcnvs_wb,  "__builtin_sh_media_MCNVS_WB", SH_BLTIN_V4HI2V8QI },
10545   { CODE_FOR_mcnvs_wub, "__builtin_sh_media_MCNVS_WUB", SH_BLTIN_V4HI2V8QI },
10546   { CODE_FOR_mextr1,    "__builtin_sh_media_MEXTR1", SH_BLTIN_V8QI3 },
10547   { CODE_FOR_mextr2,    "__builtin_sh_media_MEXTR2", SH_BLTIN_V8QI3 },
10548   { CODE_FOR_mextr3,    "__builtin_sh_media_MEXTR3", SH_BLTIN_V8QI3 },
10549   { CODE_FOR_mextr4,    "__builtin_sh_media_MEXTR4", SH_BLTIN_V8QI3 },
10550   { CODE_FOR_mextr5,    "__builtin_sh_media_MEXTR5", SH_BLTIN_V8QI3 },
10551   { CODE_FOR_mextr6,    "__builtin_sh_media_MEXTR6", SH_BLTIN_V8QI3 },
10552   { CODE_FOR_mextr7,    "__builtin_sh_media_MEXTR7", SH_BLTIN_V8QI3 },
10553   { CODE_FOR_mmacfx_wl, "__builtin_sh_media_MMACFX_WL", SH_BLTIN_MAC_HISI },
10554   { CODE_FOR_mmacnfx_wl,"__builtin_sh_media_MMACNFX_WL", SH_BLTIN_MAC_HISI },
10555   { CODE_FOR_mulv2si3,  "__builtin_mulv2si3", SH_BLTIN_V2SI3, },
10556   { CODE_FOR_mulv4hi3,  "__builtin_mulv4hi3", SH_BLTIN_V4HI3 },
10557   { CODE_FOR_mmulfx_l,  "__builtin_sh_media_MMULFX_L", SH_BLTIN_V2SI3 },
10558   { CODE_FOR_mmulfx_w,  "__builtin_sh_media_MMULFX_W", SH_BLTIN_V4HI3 },
10559   { CODE_FOR_mmulfxrp_w,"__builtin_sh_media_MMULFXRP_W", SH_BLTIN_V4HI3 },
10560   { CODE_FOR_mmulhi_wl, "__builtin_sh_media_MMULHI_WL", SH_BLTIN_V4HI2V2SI },
10561   { CODE_FOR_mmullo_wl, "__builtin_sh_media_MMULLO_WL", SH_BLTIN_V4HI2V2SI },
10562   { CODE_FOR_mmulsum_wq,"__builtin_sh_media_MMULSUM_WQ", SH_BLTIN_XXUU },
10563   { CODE_FOR_mperm_w,   "__builtin_sh_media_MPERM_W", SH_BLTIN_SH_HI },
10564   { CODE_FOR_msad_ubq,  "__builtin_sh_media_MSAD_UBQ", SH_BLTIN_XXUU },
10565   { CODE_FOR_mshalds_l, "__builtin_sh_media_MSHALDS_L", SH_BLTIN_SH_SI },
10566   { CODE_FOR_mshalds_w, "__builtin_sh_media_MSHALDS_W", SH_BLTIN_SH_HI },
10567   { CODE_FOR_ashrv2si3, "__builtin_ashrv2si3", SH_BLTIN_SH_SI },
10568   { CODE_FOR_ashrv4hi3, "__builtin_ashrv4hi3", SH_BLTIN_SH_HI },
10569   { CODE_FOR_mshards_q, "__builtin_sh_media_MSHARDS_Q", SH_BLTIN_SUS },
10570   { CODE_FOR_mshfhi_b,  "__builtin_sh_media_MSHFHI_B", SH_BLTIN_V8QI3 },
10571   { CODE_FOR_mshfhi_l,  "__builtin_sh_media_MSHFHI_L", SH_BLTIN_V2SI3 },
10572   { CODE_FOR_mshfhi_w,  "__builtin_sh_media_MSHFHI_W", SH_BLTIN_V4HI3 },
10573   { CODE_FOR_mshflo_b,  "__builtin_sh_media_MSHFLO_B", SH_BLTIN_V8QI3 },
10574   { CODE_FOR_mshflo_l,  "__builtin_sh_media_MSHFLO_L", SH_BLTIN_V2SI3 },
10575   { CODE_FOR_mshflo_w,  "__builtin_sh_media_MSHFLO_W", SH_BLTIN_V4HI3 },
10576   { CODE_FOR_ashlv2si3, "__builtin_ashlv2si3", SH_BLTIN_SH_SI },
10577   { CODE_FOR_ashlv4hi3, "__builtin_ashlv4hi3", SH_BLTIN_SH_HI },
10578   { CODE_FOR_lshrv2si3, "__builtin_lshrv2si3", SH_BLTIN_SH_SI },
10579   { CODE_FOR_lshrv4hi3, "__builtin_lshrv4hi3", SH_BLTIN_SH_HI },
10580   { CODE_FOR_subv2si3,  "__builtin_subv2si3", SH_BLTIN_V2SI3 },
10581   { CODE_FOR_subv4hi3,  "__builtin_subv4hi3", SH_BLTIN_V4HI3 },
10582   { CODE_FOR_sssubv2si3,"__builtin_sssubv2si3", SH_BLTIN_V2SI3 },
10583   { CODE_FOR_ussubv8qi3,"__builtin_ussubv8qi3", SH_BLTIN_V8QI3 },
10584   { CODE_FOR_sssubv4hi3,"__builtin_sssubv4hi3", SH_BLTIN_V4HI3 },
10585   { CODE_FOR_fcosa_s,   "__builtin_sh_media_FCOSA_S", SH_BLTIN_SISF },
10586   { CODE_FOR_fsina_s,   "__builtin_sh_media_FSINA_S", SH_BLTIN_SISF },
10587   { CODE_FOR_fipr,      "__builtin_sh_media_FIPR_S", SH_BLTIN_3 },
10588   { CODE_FOR_ftrv,      "__builtin_sh_media_FTRV_S", SH_BLTIN_3 },
10589   { CODE_FOR_mac_media, "__builtin_sh_media_FMAC_S", SH_BLTIN_3 },
10590   { CODE_FOR_sqrtdf2,   "__builtin_sh_media_FSQRT_D", SH_BLTIN_2 },
10591   { CODE_FOR_sqrtsf2,   "__builtin_sh_media_FSQRT_S", SH_BLTIN_2 },
10592   { CODE_FOR_fsrra_s,   "__builtin_sh_media_FSRRA_S", SH_BLTIN_2 },
10593   { CODE_FOR_ldhi_l,    "__builtin_sh_media_LDHI_L", SH_BLTIN_LDUA_L },
10594   { CODE_FOR_ldhi_q,    "__builtin_sh_media_LDHI_Q", SH_BLTIN_LDUA_Q },
10595   { CODE_FOR_ldlo_l,    "__builtin_sh_media_LDLO_L", SH_BLTIN_LDUA_L },
10596   { CODE_FOR_ldlo_q,    "__builtin_sh_media_LDLO_Q", SH_BLTIN_LDUA_Q },
10597   { CODE_FOR_sthi_l,    "__builtin_sh_media_STHI_L", SH_BLTIN_STUA_L },
10598   { CODE_FOR_sthi_q,    "__builtin_sh_media_STHI_Q", SH_BLTIN_STUA_Q },
10599   { CODE_FOR_stlo_l,    "__builtin_sh_media_STLO_L", SH_BLTIN_STUA_L },
10600   { CODE_FOR_stlo_q,    "__builtin_sh_media_STLO_Q", SH_BLTIN_STUA_Q },
10601   { CODE_FOR_ldhi_l64,  "__builtin_sh_media_LDHI_L", SH_BLTIN_LDUA_L64 },
10602   { CODE_FOR_ldhi_q64,  "__builtin_sh_media_LDHI_Q", SH_BLTIN_LDUA_Q64 },
10603   { CODE_FOR_ldlo_l64,  "__builtin_sh_media_LDLO_L", SH_BLTIN_LDUA_L64 },
10604   { CODE_FOR_ldlo_q64,  "__builtin_sh_media_LDLO_Q", SH_BLTIN_LDUA_Q64 },
10605   { CODE_FOR_sthi_l64,  "__builtin_sh_media_STHI_L", SH_BLTIN_STUA_L64 },
10606   { CODE_FOR_sthi_q64,  "__builtin_sh_media_STHI_Q", SH_BLTIN_STUA_Q64 },
10607   { CODE_FOR_stlo_l64,  "__builtin_sh_media_STLO_L", SH_BLTIN_STUA_L64 },
10608   { CODE_FOR_stlo_q64,  "__builtin_sh_media_STLO_Q", SH_BLTIN_STUA_Q64 },
10609   { CODE_FOR_nsb,       "__builtin_sh_media_NSB", SH_BLTIN_SU },
10610   { CODE_FOR_byterev,   "__builtin_sh_media_BYTEREV", SH_BLTIN_2 },
10611   { CODE_FOR_prefetch,  "__builtin_sh_media_PREFO", SH_BLTIN_PSSV },
10612 };
10613
10614 static void
10615 sh_media_init_builtins (void)
10616 {
10617   tree shared[SH_BLTIN_NUM_SHARED_SIGNATURES];
10618   const struct builtin_description *d;
10619
10620   memset (shared, 0, sizeof shared);
10621   for (d = bdesc; d - bdesc < (int) ARRAY_SIZE (bdesc); d++)
10622     {
10623       tree type, arg_type = 0;
10624       int signature = d->signature;
10625       int i;
10626
10627       if (signature < SH_BLTIN_NUM_SHARED_SIGNATURES && shared[signature])
10628         type = shared[signature];
10629       else
10630         {
10631           int has_result = signature_args[signature][0] != 0;
10632
10633           if ((signature_args[signature][1] & 8)
10634               && (((signature_args[signature][1] & 1) && TARGET_SHMEDIA32)
10635                   || ((signature_args[signature][1] & 2) && TARGET_SHMEDIA64)))
10636             continue;
10637           if (! TARGET_FPU_ANY
10638               && FLOAT_MODE_P (insn_data[d->icode].operand[0].mode))
10639             continue;
10640           type = void_list_node;
10641           for (i = 3; ; i--)
10642             {
10643               int arg = signature_args[signature][i];
10644               int opno = i - 1 + has_result;
10645
10646               if (arg & 8)
10647                 arg_type = ptr_type_node;
10648               else if (arg)
10649                 arg_type = (*lang_hooks.types.type_for_mode)
10650                   (insn_data[d->icode].operand[opno].mode,
10651                    (arg & 1));
10652               else if (i)
10653                 continue;
10654               else
10655                 arg_type = void_type_node;
10656               if (i == 0)
10657                 break;
10658               type = tree_cons (NULL_TREE, arg_type, type);
10659             }
10660           type = build_function_type (arg_type, type);
10661           if (signature < SH_BLTIN_NUM_SHARED_SIGNATURES)
10662             shared[signature] = type;
10663         }
10664       add_builtin_function (d->name, type, d - bdesc, BUILT_IN_MD,
10665                             NULL, NULL_TREE);
10666     }
10667 }
10668
10669 /* Implements target hook vector_mode_supported_p.  */
10670 bool
10671 sh_vector_mode_supported_p (enum machine_mode mode)
10672 {
10673   if (TARGET_FPU_ANY
10674       && ((mode == V2SFmode)
10675           || (mode == V4SFmode)
10676           || (mode == V16SFmode)))
10677     return true;
10678
10679   else if (TARGET_SHMEDIA
10680            && ((mode == V8QImode)
10681                || (mode == V2HImode)
10682                || (mode == V4HImode)
10683                || (mode == V2SImode)))
10684     return true;
10685
10686   return false;
10687 }
10688
10689 /* Implements target hook dwarf_calling_convention.  Return an enum
10690    of dwarf_calling_convention.  */
10691 int
10692 sh_dwarf_calling_convention (const_tree func)
10693 {
10694   if (sh_attr_renesas_p (func))
10695     return DW_CC_GNU_renesas_sh;
10696
10697   return DW_CC_normal;
10698 }
10699
10700 static void
10701 sh_init_builtins (void)
10702 {
10703   if (TARGET_SHMEDIA)
10704     sh_media_init_builtins ();
10705 }
10706
10707 /* Expand an expression EXP that calls a built-in function,
10708    with result going to TARGET if that's convenient
10709    (and in mode MODE if that's convenient).
10710    SUBTARGET may be used as the target for computing one of EXP's operands.
10711    IGNORE is nonzero if the value is to be ignored.  */
10712
10713 static rtx
10714 sh_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
10715                    enum machine_mode mode ATTRIBUTE_UNUSED, int ignore)
10716 {
10717   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
10718   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
10719   const struct builtin_description *d = &bdesc[fcode];
10720   enum insn_code icode = d->icode;
10721   int signature = d->signature;
10722   enum machine_mode tmode = VOIDmode;
10723   int nop = 0, i;
10724   rtx op[4];
10725   rtx pat = 0;
10726
10727   if (signature_args[signature][0])
10728     {
10729       if (ignore)
10730         return 0;
10731
10732       tmode = insn_data[icode].operand[0].mode;
10733       if (! target
10734           || GET_MODE (target) != tmode
10735           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10736         target = gen_reg_rtx (tmode);
10737       op[nop++] = target;
10738     }
10739   else
10740     target = 0;
10741
10742   for (i = 1; i <= 3; i++, nop++)
10743     {
10744       tree arg;
10745       enum machine_mode opmode, argmode;
10746       tree optype;
10747
10748       if (! signature_args[signature][i])
10749         break;
10750       arg = CALL_EXPR_ARG (exp, i - 1);
10751       if (arg == error_mark_node)
10752         return const0_rtx;
10753       if (signature_args[signature][i] & 8)
10754         {
10755           opmode = ptr_mode;
10756           optype = ptr_type_node;
10757         }
10758       else
10759         {
10760           opmode = insn_data[icode].operand[nop].mode;
10761           optype = (*lang_hooks.types.type_for_mode) (opmode, 0);
10762         }
10763       argmode = TYPE_MODE (TREE_TYPE (arg));
10764       if (argmode != opmode)
10765         arg = build1 (NOP_EXPR, optype, arg);
10766       op[nop] = expand_expr (arg, NULL_RTX, opmode, EXPAND_NORMAL);
10767       if (! (*insn_data[icode].operand[nop].predicate) (op[nop], opmode))
10768         op[nop] = copy_to_mode_reg (opmode, op[nop]);
10769     }
10770
10771   switch (nop)
10772     {
10773     case 1:
10774       pat = (*insn_data[d->icode].genfun) (op[0]);
10775       break;
10776     case 2:
10777       pat = (*insn_data[d->icode].genfun) (op[0], op[1]);
10778       break;
10779     case 3:
10780       pat = (*insn_data[d->icode].genfun) (op[0], op[1], op[2]);
10781       break;
10782     case 4:
10783       pat = (*insn_data[d->icode].genfun) (op[0], op[1], op[2], op[3]);
10784       break;
10785     default:
10786       gcc_unreachable ();
10787     }
10788   if (! pat)
10789     return 0;
10790   emit_insn (pat);
10791   return target;
10792 }
10793
10794 void
10795 sh_expand_unop_v2sf (enum rtx_code code, rtx op0, rtx op1)
10796 {
10797   rtx sel0 = const0_rtx;
10798   rtx sel1 = const1_rtx;
10799   rtx (*fn) (rtx, rtx, rtx, rtx, rtx) = gen_unary_sf_op;
10800   rtx op = gen_rtx_fmt_e (code, SFmode, op1);
10801
10802   emit_insn ((*fn) (op0, op1, op, sel0, sel0));
10803   emit_insn ((*fn) (op0, op1, op, sel1, sel1));
10804 }
10805
10806 void
10807 sh_expand_binop_v2sf (enum rtx_code code, rtx op0, rtx op1, rtx op2)
10808 {
10809   rtx op = gen_rtx_fmt_ee (code, SFmode, op1, op2);
10810
10811   emit_insn (gen_binary_sf_op0 (op0, op1, op2, op));
10812   emit_insn (gen_binary_sf_op1 (op0, op1, op2, op));
10813 }
10814
10815 /* Return true if hard register REGNO can hold a value of machine-mode MODE.
10816    We can allow any mode in any general register.  The special registers
10817    only allow SImode.  Don't allow any mode in the PR.
10818
10819    We cannot hold DCmode values in the XD registers because alter_reg
10820    handles subregs of them incorrectly.  We could work around this by
10821    spacing the XD registers like the DR registers, but this would require
10822    additional memory in every compilation to hold larger register vectors.
10823    We could hold SFmode / SCmode values in XD registers, but that
10824    would require a tertiary reload when reloading from / to memory,
10825    and a secondary reload to reload from / to general regs; that
10826    seems to be a loosing proposition.
10827
10828    We want to allow TImode FP regs so that when V4SFmode is loaded as TImode,
10829    it won't be ferried through GP registers first.  */
10830
10831 bool
10832 sh_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode)
10833 {
10834   if (SPECIAL_REGISTER_P (regno))
10835     return mode == SImode;
10836
10837   if (regno == FPUL_REG)
10838     return (mode == SImode || mode == SFmode);
10839
10840   if (FP_REGISTER_P (regno) && mode == SFmode)
10841     return true;
10842
10843   if (mode == V2SFmode)
10844     {
10845       if (((FP_REGISTER_P (regno) && (regno - FIRST_FP_REG) % 2 == 0)
10846            || GENERAL_REGISTER_P (regno)))
10847         return true;
10848       else
10849         return false;
10850     }
10851
10852   if (mode == V4SFmode)
10853     {
10854       if ((FP_REGISTER_P (regno) && (regno - FIRST_FP_REG) % 4 == 0)
10855           || GENERAL_REGISTER_P (regno))
10856         return true;
10857       else
10858         return false;
10859     }
10860
10861   if (mode == V16SFmode)
10862     {
10863       if (TARGET_SHMEDIA)
10864         {
10865           if (FP_REGISTER_P (regno) && (regno - FIRST_FP_REG) % 16 == 0)
10866             return true;
10867           else
10868             return false;
10869         }
10870       else
10871         return regno == FIRST_XD_REG;
10872     }
10873
10874   if (FP_REGISTER_P (regno))
10875     {
10876       if (mode == SFmode
10877           || mode == SImode
10878           || ((TARGET_SH2E || TARGET_SHMEDIA) && mode == SCmode)
10879           || ((((TARGET_SH4 || TARGET_SH2A_DOUBLE) && mode == DFmode)
10880                || mode == DCmode
10881                || (TARGET_SHMEDIA
10882                    && (mode == DFmode || mode == DImode
10883                        || mode == V2SFmode || mode == TImode)))
10884               && ((regno - FIRST_FP_REG) & 1) == 0)
10885           || ((TARGET_SH4 || TARGET_SHMEDIA) && mode == TImode
10886               && ((regno - FIRST_FP_REG) & 3) == 0))
10887         return true;
10888       else
10889         return false;
10890     }
10891
10892   if (XD_REGISTER_P (regno))
10893     return mode == DFmode;
10894
10895   if (TARGET_REGISTER_P (regno))
10896     return (mode == DImode || mode == SImode || mode == PDImode);
10897
10898   if (regno == PR_REG)
10899     return mode == SImode;
10900
10901   if (regno == FPSCR_REG)
10902     return mode == PSImode;
10903
10904   /* FIXME.  This works around PR target/37633 for -O0.  */
10905   if (!optimize && TARGET_SHMEDIA32 && GET_MODE_SIZE (mode) > 4)
10906     {
10907       unsigned int n = GET_MODE_SIZE (mode) / 8;
10908
10909       if (regno >= FIRST_GENERAL_REG + 10 - n + 1
10910           && regno <= FIRST_GENERAL_REG + 14)
10911         return false;
10912     }
10913
10914   return true;
10915 }
10916
10917 /* Return the class of registers for which a mode change from FROM to TO
10918    is invalid.  */
10919 bool
10920 sh_cannot_change_mode_class (enum machine_mode from, enum machine_mode to,
10921                              enum reg_class rclass)
10922 {
10923   /* We want to enable the use of SUBREGs as a means to
10924      VEC_SELECT a single element of a vector.  */
10925   if (to == SFmode && VECTOR_MODE_P (from) && GET_MODE_INNER (from) == SFmode)
10926     return (reg_classes_intersect_p (GENERAL_REGS, rclass));
10927
10928   if (GET_MODE_SIZE (from) != GET_MODE_SIZE (to))
10929     {
10930       if (TARGET_LITTLE_ENDIAN)
10931         {
10932           if (GET_MODE_SIZE (to) < 8 || GET_MODE_SIZE (from) < 8)
10933             return reg_classes_intersect_p (DF_REGS, rclass);
10934         }
10935       else
10936         {
10937           if (GET_MODE_SIZE (from) < 8)
10938             return reg_classes_intersect_p (DF_HI_REGS, rclass);
10939         }
10940     }
10941   return 0;
10942 }
10943
10944
10945 /* If ADDRESS refers to a CODE_LABEL, add NUSES to the number of times
10946    that label is used.  */
10947
10948 void
10949 sh_mark_label (rtx address, int nuses)
10950 {
10951   if (GOTOFF_P (address))
10952     {
10953       /* Extract the label or symbol.  */
10954       address = XEXP (address, 0);
10955       if (GET_CODE (address) == PLUS)
10956         address = XEXP (address, 0);
10957       address = XVECEXP (address, 0, 0);
10958     }
10959   if (GET_CODE (address) == LABEL_REF
10960       && LABEL_P (XEXP (address, 0)))
10961     LABEL_NUSES (XEXP (address, 0)) += nuses;
10962 }
10963
10964 /* Compute extra cost of moving data between one register class
10965    and another.  */
10966
10967 /* If SECONDARY*_RELOAD_CLASS says something about the src/dst pair, regclass
10968    uses this information.  Hence, the general register <-> floating point
10969    register information here is not used for SFmode.  */
10970
10971 int
10972 sh_register_move_cost (enum machine_mode mode,
10973                        enum reg_class srcclass, enum reg_class dstclass)
10974 {
10975   if (dstclass == T_REGS || dstclass == PR_REGS)
10976     return 10;
10977
10978   if (dstclass == MAC_REGS && srcclass == MAC_REGS)
10979     return 4;
10980
10981   if (mode == SImode && ! TARGET_SHMEDIA && TARGET_FMOVD
10982       && REGCLASS_HAS_FP_REG (srcclass)
10983       && REGCLASS_HAS_FP_REG (dstclass))
10984     return 4;
10985
10986   if (REGCLASS_HAS_FP_REG (dstclass) && srcclass == T_REGS)
10987     return ((TARGET_HARD_SH4 && !optimize_size) ? 10 : 7);
10988
10989   if ((REGCLASS_HAS_FP_REG (dstclass) && srcclass == MAC_REGS)
10990       || (dstclass == MAC_REGS && REGCLASS_HAS_FP_REG (srcclass)))
10991     return 9;
10992
10993   if ((REGCLASS_HAS_FP_REG (dstclass)
10994        && REGCLASS_HAS_GENERAL_REG (srcclass))
10995       || (REGCLASS_HAS_GENERAL_REG (dstclass)
10996           && REGCLASS_HAS_FP_REG (srcclass)))
10997     return ((TARGET_SHMEDIA ? 4 : TARGET_FMOVD ? 8 : 12)
10998             * ((GET_MODE_SIZE (mode) + 7) / 8U));
10999
11000   if ((dstclass == FPUL_REGS
11001        && REGCLASS_HAS_GENERAL_REG (srcclass))
11002       || (srcclass == FPUL_REGS
11003           && REGCLASS_HAS_GENERAL_REG (dstclass)))
11004     return 5;
11005
11006   if ((dstclass == FPUL_REGS
11007        && (srcclass == PR_REGS || srcclass == MAC_REGS || srcclass == T_REGS))
11008       || (srcclass == FPUL_REGS
11009           && (dstclass == PR_REGS || dstclass == MAC_REGS)))
11010     return 7;
11011
11012   if ((srcclass == TARGET_REGS && ! REGCLASS_HAS_GENERAL_REG (dstclass))
11013       || ((dstclass) == TARGET_REGS && ! REGCLASS_HAS_GENERAL_REG (srcclass)))
11014     return 20;
11015
11016   /* ??? ptabs faults on (value & 0x3) == 0x3  */
11017   if (TARGET_SHMEDIA
11018       && ((srcclass) == TARGET_REGS || (srcclass) == SIBCALL_REGS))
11019     {
11020       if (sh_gettrcost >= 0)
11021         return sh_gettrcost;
11022       else if (!TARGET_PT_FIXED)
11023         return 100;
11024     }
11025
11026   if ((srcclass == FPSCR_REGS && ! REGCLASS_HAS_GENERAL_REG (dstclass))
11027       || (dstclass == FPSCR_REGS && ! REGCLASS_HAS_GENERAL_REG (srcclass)))
11028   return 4;
11029
11030   if (TARGET_SHMEDIA
11031       || (TARGET_FMOVD
11032           && ! REGCLASS_HAS_GENERAL_REG (srcclass)
11033           && ! REGCLASS_HAS_GENERAL_REG (dstclass)))
11034     return 2 * ((GET_MODE_SIZE (mode) + 7) / 8U);
11035
11036   return 2 * ((GET_MODE_SIZE (mode) + 3) / 4U);
11037 }
11038
11039 static rtx emit_load_ptr (rtx, rtx);
11040
11041 static rtx
11042 emit_load_ptr (rtx reg, rtx addr)
11043 {
11044   rtx mem = gen_const_mem (ptr_mode, addr);
11045
11046   if (Pmode != ptr_mode)
11047     mem = gen_rtx_SIGN_EXTEND (Pmode, mem);
11048   return emit_move_insn (reg, mem);
11049 }
11050
11051 static void
11052 sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
11053                     HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
11054                     tree function)
11055 {
11056   CUMULATIVE_ARGS cum;
11057   int structure_value_byref = 0;
11058   rtx this_rtx, this_value, sibcall, insns, funexp;
11059   tree funtype = TREE_TYPE (function);
11060   int simple_add = CONST_OK_FOR_ADD (delta);
11061   int did_load = 0;
11062   rtx scratch0, scratch1, scratch2;
11063   unsigned i;
11064
11065   reload_completed = 1;
11066   epilogue_completed = 1;
11067   current_function_uses_only_leaf_regs = 1;
11068
11069   emit_note (NOTE_INSN_PROLOGUE_END);
11070
11071   /* Find the "this" pointer.  We have such a wide range of ABIs for the
11072      SH that it's best to do this completely machine independently.
11073      "this" is passed as first argument, unless a structure return pointer
11074      comes first, in which case "this" comes second.  */
11075   INIT_CUMULATIVE_ARGS (cum, funtype, NULL_RTX, 0, 1);
11076 #ifndef PCC_STATIC_STRUCT_RETURN
11077   if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
11078     structure_value_byref = 1;
11079 #endif /* not PCC_STATIC_STRUCT_RETURN */
11080   if (structure_value_byref && sh_struct_value_rtx (function, 0) == 0)
11081     {
11082       tree ptype = build_pointer_type (TREE_TYPE (funtype));
11083
11084       FUNCTION_ARG_ADVANCE (cum, Pmode, ptype, 1);
11085     }
11086   this_rtx = FUNCTION_ARG (cum, Pmode, ptr_type_node, 1);
11087
11088   /* For SHcompact, we only have r0 for a scratch register: r1 is the
11089      static chain pointer (even if you can't have nested virtual functions
11090      right now, someone might implement them sometime), and the rest of the
11091      registers are used for argument passing, are callee-saved, or reserved.  */
11092   /* We need to check call_used_regs / fixed_regs in case -fcall_saved-reg /
11093      -ffixed-reg has been used.  */
11094   if (! call_used_regs[0] || fixed_regs[0])
11095     error ("r0 needs to be available as a call-clobbered register");
11096   scratch0 = scratch1 = scratch2 = gen_rtx_REG (Pmode, 0);
11097   if (! TARGET_SH5)
11098     {
11099       if (call_used_regs[1] && ! fixed_regs[1])
11100         scratch1 = gen_rtx_REG (ptr_mode, 1);
11101       /* N.B., if not TARGET_HITACHI, register 2 is used to pass the pointer
11102          pointing where to return struct values.  */
11103       if (call_used_regs[3] && ! fixed_regs[3])
11104         scratch2 = gen_rtx_REG (Pmode, 3);
11105     }
11106   else if (TARGET_SHMEDIA)
11107     {
11108       for (i = FIRST_GENERAL_REG; i <= LAST_GENERAL_REG; i++)
11109         if (i != REGNO (scratch0) &&
11110             call_used_regs[i] && ! fixed_regs[i] && ! FUNCTION_ARG_REGNO_P (i))
11111           {
11112             scratch1 = gen_rtx_REG (ptr_mode, i);
11113             break;
11114           }
11115       if (scratch1 == scratch0)
11116         error ("Need a second call-clobbered general purpose register");
11117       for (i = FIRST_TARGET_REG; i <= LAST_TARGET_REG; i++)
11118         if (call_used_regs[i] && ! fixed_regs[i])
11119           {
11120             scratch2 = gen_rtx_REG (Pmode, i);
11121             break;
11122           }
11123       if (scratch2 == scratch0)
11124         error ("Need a call-clobbered target register");
11125     }
11126
11127   this_value = plus_constant (this_rtx, delta);
11128   if (vcall_offset
11129       && (simple_add || scratch0 != scratch1)
11130       && strict_memory_address_p (ptr_mode, this_value))
11131     {
11132       emit_load_ptr (scratch0, this_value);
11133       did_load = 1;
11134     }
11135
11136   if (!delta)
11137     ; /* Do nothing.  */
11138   else if (simple_add)
11139     emit_move_insn (this_rtx, this_value);
11140   else
11141     {
11142       emit_move_insn (scratch1, GEN_INT (delta));
11143       emit_insn (gen_add2_insn (this_rtx, scratch1));
11144     }
11145
11146   if (vcall_offset)
11147     {
11148       rtx offset_addr;
11149
11150       if (!did_load)
11151         emit_load_ptr (scratch0, this_rtx);
11152
11153       offset_addr = plus_constant (scratch0, vcall_offset);
11154       if (strict_memory_address_p (ptr_mode, offset_addr))
11155         ; /* Do nothing.  */
11156       else if (! TARGET_SH5 && scratch0 != scratch1)
11157         {
11158           /* scratch0 != scratch1, and we have indexed loads.  Get better
11159              schedule by loading the offset into r1 and using an indexed
11160              load - then the load of r1 can issue before the load from
11161              (this_rtx + delta) finishes.  */
11162           emit_move_insn (scratch1, GEN_INT (vcall_offset));
11163           offset_addr = gen_rtx_PLUS (Pmode, scratch0, scratch1);
11164         }
11165       else if (CONST_OK_FOR_ADD (vcall_offset))
11166         {
11167           emit_insn (gen_add2_insn (scratch0, GEN_INT (vcall_offset)));
11168           offset_addr = scratch0;
11169         }
11170       else if (scratch0 != scratch1)
11171         {
11172           emit_move_insn (scratch1, GEN_INT (vcall_offset));
11173           emit_insn (gen_add2_insn (scratch0, scratch1));
11174           offset_addr = scratch0;
11175         }
11176       else
11177         gcc_unreachable (); /* FIXME */
11178       emit_load_ptr (scratch0, offset_addr);
11179
11180       if (Pmode != ptr_mode)
11181         scratch0 = gen_rtx_TRUNCATE (ptr_mode, scratch0);
11182       emit_insn (gen_add2_insn (this_rtx, scratch0));
11183     }
11184
11185   /* Generate a tail call to the target function.  */
11186   if (! TREE_USED (function))
11187     {
11188       assemble_external (function);
11189       TREE_USED (function) = 1;
11190     }
11191   funexp = XEXP (DECL_RTL (function), 0);
11192   /* If the function is overridden, so is the thunk, hence we don't
11193      need GOT addressing even if this is a public symbol.  */
11194 #if 0
11195   if (TARGET_SH1 && ! flag_weak)
11196     sibcall = gen_sibcalli_thunk (funexp, const0_rtx);
11197   else
11198 #endif
11199   if (TARGET_SH2 && flag_pic)
11200     {
11201       sibcall = gen_sibcall_pcrel (funexp, const0_rtx);
11202       XEXP (XVECEXP (sibcall, 0, 2), 0) = scratch2;
11203     }
11204   else
11205     {
11206       if (TARGET_SHMEDIA && flag_pic)
11207         {
11208           funexp = gen_sym2PIC (funexp);
11209           PUT_MODE (funexp, Pmode);
11210         }
11211       emit_move_insn (scratch2, funexp);
11212       funexp = gen_rtx_MEM (FUNCTION_MODE, scratch2);
11213       sibcall = gen_sibcall (funexp, const0_rtx, NULL_RTX);
11214     }
11215   sibcall = emit_call_insn (sibcall);
11216   SIBLING_CALL_P (sibcall) = 1;
11217   use_reg (&CALL_INSN_FUNCTION_USAGE (sibcall), this_rtx);
11218   emit_barrier ();
11219
11220   /* Run just enough of rest_of_compilation to do scheduling and get
11221      the insns emitted.  Note that use_thunk calls
11222      assemble_start_function and assemble_end_function.  */
11223
11224   insn_locators_alloc ();
11225   insns = get_insns ();
11226
11227   if (optimize > 0)
11228     {
11229       if (! cfun->cfg)
11230         init_flow (cfun);
11231       split_all_insns_noflow ();
11232     }
11233
11234   sh_reorg ();
11235
11236   if (optimize > 0 && flag_delayed_branch)
11237     dbr_schedule (insns);
11238
11239   shorten_branches (insns);
11240   final_start_function (insns, file, 1);
11241   final (insns, file, 1);
11242   final_end_function ();
11243   free_after_compilation (cfun);
11244
11245   reload_completed = 0;
11246   epilogue_completed = 0;
11247 }
11248
11249 rtx
11250 function_symbol (rtx target, const char *name, enum sh_function_kind kind)
11251 {
11252   rtx sym;
11253
11254   /* If this is not an ordinary function, the name usually comes from a
11255      string literal or an sprintf buffer.  Make sure we use the same
11256      string consistently, so that cse will be able to unify address loads.  */
11257   if (kind != FUNCTION_ORDINARY)
11258     name = IDENTIFIER_POINTER (get_identifier (name));
11259   sym = gen_rtx_SYMBOL_REF (Pmode, name);
11260   SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_FUNCTION;
11261   if (flag_pic)
11262     switch (kind)
11263       {
11264       case FUNCTION_ORDINARY:
11265         break;
11266       case SFUNC_GOT:
11267         {
11268           rtx reg = target ? target : gen_reg_rtx (Pmode);
11269
11270           emit_insn (gen_symGOT2reg (reg, sym));
11271           sym = reg;
11272           break;
11273         }
11274       case SFUNC_STATIC:
11275         {
11276           /* ??? To allow cse to work, we use GOTOFF relocations.
11277              we could add combiner patterns to transform this into
11278              straight pc-relative calls with sym2PIC / bsrf when
11279              label load and function call are still 1:1 and in the
11280              same basic block during combine.  */
11281           rtx reg = target ? target : gen_reg_rtx (Pmode);
11282
11283           emit_insn (gen_symGOTOFF2reg (reg, sym));
11284           sym = reg;
11285           break;
11286         }
11287       }
11288   if (target && sym != target)
11289     {
11290       emit_move_insn (target, sym);
11291       return target;
11292     }
11293   return sym;
11294 }
11295
11296 /* Find the number of a general purpose register in S.  */
11297 static int
11298 scavenge_reg (HARD_REG_SET *s)
11299 {
11300   int r;
11301   for (r = FIRST_GENERAL_REG; r <= LAST_GENERAL_REG; r++)
11302     if (TEST_HARD_REG_BIT (*s, r))
11303       return r;
11304   return -1;
11305 }
11306
11307 rtx
11308 sh_get_pr_initial_val (void)
11309 {
11310   rtx val;
11311
11312   /* ??? Unfortunately, get_hard_reg_initial_val doesn't always work for the
11313      PR register on SHcompact, because it might be clobbered by the prologue.
11314      We check first if that is known to be the case.  */
11315   if (TARGET_SHCOMPACT
11316       && ((crtl->args.info.call_cookie
11317            & ~ CALL_COOKIE_RET_TRAMP (1))
11318           || crtl->saves_all_registers))
11319     return gen_frame_mem (SImode, return_address_pointer_rtx);
11320
11321   /* If we haven't finished rtl generation, there might be a nonlocal label
11322      that we haven't seen yet.
11323      ??? get_hard_reg_initial_val fails if it is called after register
11324      allocation has started, unless it has been called before for the
11325      same register.  And even then, we end in trouble if we didn't use
11326      the register in the same basic block before.  So call
11327      get_hard_reg_initial_val now and wrap it in an unspec if we might
11328      need to replace it.  */
11329   /* ??? We also must do this for TARGET_SH1 in general, because otherwise
11330      combine can put the pseudo returned by get_hard_reg_initial_val into
11331      instructions that need a general purpose registers, which will fail to
11332      be recognized when the pseudo becomes allocated to PR.  */
11333   val
11334     = get_hard_reg_initial_val (Pmode, TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG);
11335   if (TARGET_SH1)
11336     return gen_rtx_UNSPEC (SImode, gen_rtvec (1, val), UNSPEC_RA);
11337   return val;
11338 }
11339
11340 int
11341 sh_expand_t_scc (rtx operands[])
11342 {
11343   enum rtx_code code = GET_CODE (operands[1]);
11344   rtx target = operands[0];
11345   rtx op0 = operands[2];
11346   rtx op1 = operands[3];
11347   rtx result = target;
11348   HOST_WIDE_INT val;
11349
11350   if (!REG_P (op0) || REGNO (op0) != T_REG
11351       || !CONST_INT_P (op1))
11352     return 0;
11353   if (!REG_P (result))
11354     result = gen_reg_rtx (SImode);
11355   val = INTVAL (op1);
11356   if ((code == EQ && val == 1) || (code == NE && val == 0))
11357     emit_insn (gen_movt (result));
11358   else if (TARGET_SH2A && ((code == EQ && val == 0)
11359                             || (code == NE && val == 1)))
11360     emit_insn (gen_xorsi3_movrt (result));
11361   else if ((code == EQ && val == 0) || (code == NE && val == 1))
11362     {
11363       emit_clobber (result);
11364       emit_insn (gen_subc (result, result, result));
11365       emit_insn (gen_addsi3 (result, result, const1_rtx));
11366     }
11367   else if (code == EQ || code == NE)
11368     emit_insn (gen_move_insn (result, GEN_INT (code == NE)));
11369   else
11370     return 0;
11371   if (result != target)
11372     emit_move_insn (target, result);
11373   return 1;
11374 }
11375
11376 /* INSN is an sfunc; return the rtx that describes the address used.  */
11377 static rtx
11378 extract_sfunc_addr (rtx insn)
11379 {
11380   rtx pattern, part = NULL_RTX;
11381   int len, i;
11382
11383   pattern = PATTERN (insn);
11384   len = XVECLEN (pattern, 0);
11385   for (i = 0; i < len; i++)
11386     {
11387       part = XVECEXP (pattern, 0, i);
11388       if (GET_CODE (part) == USE && GET_MODE (XEXP (part, 0)) == Pmode
11389           && GENERAL_REGISTER_P (true_regnum (XEXP (part, 0))))
11390         return XEXP (part, 0);
11391     }
11392   gcc_assert (GET_CODE (XVECEXP (pattern, 0, 0)) == UNSPEC_VOLATILE);
11393   return XVECEXP (XVECEXP (pattern, 0, 0), 0, 1);
11394 }
11395
11396 /* Verify that the register in use_sfunc_addr still agrees with the address
11397    used in the sfunc.  This prevents fill_slots_from_thread from changing
11398    use_sfunc_addr.
11399    INSN is the use_sfunc_addr instruction, and REG is the register it
11400    guards.  */
11401 int
11402 check_use_sfunc_addr (rtx insn, rtx reg)
11403 {
11404   /* Search for the sfunc.  It should really come right after INSN.  */
11405   while ((insn = NEXT_INSN (insn)))
11406     {
11407       if (LABEL_P (insn) || JUMP_P (insn))
11408         break;
11409       if (! INSN_P (insn))
11410         continue;
11411
11412       if (GET_CODE (PATTERN (insn)) == SEQUENCE)
11413         insn = XVECEXP (PATTERN (insn), 0, 0);
11414       if (GET_CODE (PATTERN (insn)) != PARALLEL
11415           || get_attr_type (insn) != TYPE_SFUNC)
11416         continue;
11417       return rtx_equal_p (extract_sfunc_addr (insn), reg);
11418     }
11419   gcc_unreachable ();
11420 }
11421
11422 /* This function returns a constant rtx that represents pi / 2**15 in
11423    SFmode.  it's used to scale SFmode angles, in radians, to a
11424    fixed-point signed 16.16-bit fraction of a full circle, i.e., 2*pi
11425    maps to 0x10000).  */
11426
11427 static GTY(()) rtx sh_fsca_sf2int_rtx;
11428
11429 rtx
11430 sh_fsca_sf2int (void)
11431 {
11432   if (! sh_fsca_sf2int_rtx)
11433     {
11434       REAL_VALUE_TYPE rv;
11435
11436       real_from_string (&rv, "10430.378350470453");
11437       sh_fsca_sf2int_rtx = const_double_from_real_value (rv, SFmode);
11438     }
11439
11440   return sh_fsca_sf2int_rtx;
11441 }
11442
11443 /* This function returns a constant rtx that represents pi / 2**15 in
11444    DFmode.  it's used to scale DFmode angles, in radians, to a
11445    fixed-point signed 16.16-bit fraction of a full circle, i.e., 2*pi
11446    maps to 0x10000).  */
11447
11448 static GTY(()) rtx sh_fsca_df2int_rtx;
11449
11450 rtx
11451 sh_fsca_df2int (void)
11452 {
11453   if (! sh_fsca_df2int_rtx)
11454     {
11455       REAL_VALUE_TYPE rv;
11456
11457       real_from_string (&rv, "10430.378350470453");
11458       sh_fsca_df2int_rtx = const_double_from_real_value (rv, DFmode);
11459     }
11460
11461   return sh_fsca_df2int_rtx;
11462 }
11463
11464 /* This function returns a constant rtx that represents 2**15 / pi in
11465    SFmode.  it's used to scale a fixed-point signed 16.16-bit fraction
11466    of a full circle back to a SFmode value, i.e., 0x10000 maps to
11467    2*pi).  */
11468
11469 static GTY(()) rtx sh_fsca_int2sf_rtx;
11470
11471 rtx
11472 sh_fsca_int2sf (void)
11473 {
11474   if (! sh_fsca_int2sf_rtx)
11475     {
11476       REAL_VALUE_TYPE rv;
11477
11478       real_from_string (&rv, "9.587379924285257e-5");
11479       sh_fsca_int2sf_rtx = const_double_from_real_value (rv, SFmode);
11480     }
11481
11482   return sh_fsca_int2sf_rtx;
11483 }
11484
11485 /* Initialize the CUMULATIVE_ARGS structure.  */
11486
11487 void
11488 sh_init_cumulative_args (CUMULATIVE_ARGS *  pcum,
11489                          tree               fntype,
11490                          rtx                libname ATTRIBUTE_UNUSED,
11491                          tree               fndecl,
11492                          signed int         n_named_args,
11493                          enum machine_mode  mode)
11494 {
11495   pcum->arg_count [(int) SH_ARG_FLOAT] = 0;
11496   pcum->free_single_fp_reg = 0;
11497   pcum->stack_regs = 0;
11498   pcum->byref_regs = 0;
11499   pcum->byref = 0;
11500   pcum->outgoing = (n_named_args == -1) ? 0 : 1;
11501
11502   /* XXX - Should we check TARGET_HITACHI here ???  */
11503   pcum->renesas_abi = sh_attr_renesas_p (fntype) ? 1 : 0;
11504
11505   if (fntype)
11506     {
11507       pcum->force_mem = ((TARGET_HITACHI || pcum->renesas_abi)
11508                          && aggregate_value_p (TREE_TYPE (fntype), fndecl));
11509       pcum->prototype_p = TYPE_ARG_TYPES (fntype) ? TRUE : FALSE;
11510       pcum->arg_count [(int) SH_ARG_INT]
11511         = TARGET_SH5 && aggregate_value_p (TREE_TYPE (fntype), fndecl);
11512
11513       pcum->call_cookie
11514         = CALL_COOKIE_RET_TRAMP (TARGET_SHCOMPACT
11515                                  && pcum->arg_count [(int) SH_ARG_INT] == 0
11516                                  && (TYPE_MODE (TREE_TYPE (fntype)) == BLKmode
11517                                      ? int_size_in_bytes (TREE_TYPE (fntype))
11518                                      : GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (fntype)))) > 4
11519                                  && (BASE_RETURN_VALUE_REG (TYPE_MODE (TREE_TYPE (fntype)))
11520                                      == FIRST_RET_REG));
11521     }
11522   else
11523     {
11524       pcum->arg_count [(int) SH_ARG_INT] = 0;
11525       pcum->prototype_p = FALSE;
11526       if (mode != VOIDmode)
11527         {
11528           pcum->call_cookie =
11529             CALL_COOKIE_RET_TRAMP (TARGET_SHCOMPACT
11530                                    && GET_MODE_SIZE (mode) > 4
11531                                    && BASE_RETURN_VALUE_REG (mode) == FIRST_RET_REG);
11532
11533           /* If the default ABI is the Renesas ABI then all library
11534              calls must assume that the library will be using the
11535              Renesas ABI.  So if the function would return its result
11536              in memory then we must force the address of this memory
11537              block onto the stack.  Ideally we would like to call
11538              targetm.calls.return_in_memory() here but we do not have
11539              the TYPE or the FNDECL available so we synthesize the
11540              contents of that function as best we can.  */
11541           pcum->force_mem =
11542             (TARGET_DEFAULT & MASK_HITACHI)
11543             && (mode == BLKmode
11544                 || (GET_MODE_SIZE (mode) > 4
11545                     && !(mode == DFmode
11546                          && TARGET_FPU_DOUBLE)));
11547         }
11548       else
11549         {
11550           pcum->call_cookie = 0;
11551           pcum->force_mem = FALSE;
11552         }
11553     }
11554 }
11555
11556 /* Replace any occurrence of FROM(n) in X with TO(n).  The function does
11557    not enter into CONST_DOUBLE for the replace.
11558
11559    Note that copying is not done so X must not be shared unless all copies
11560    are to be modified.
11561
11562    This is like replace_rtx, except that we operate on N_REPLACEMENTS
11563    replacements simultaneously - FROM(n) is replacements[n*2] and to(n) is
11564    replacements[n*2+1] - and that we take mode changes into account.
11565
11566    If a replacement is ambiguous, return NULL_RTX.
11567
11568    If MODIFY is zero, don't modify any rtl in place,
11569    just return zero or nonzero for failure / success.  */
11570
11571 rtx
11572 replace_n_hard_rtx (rtx x, rtx *replacements, int n_replacements, int modify)
11573 {
11574   int i, j;
11575   const char *fmt;
11576
11577   /* The following prevents loops occurrence when we change MEM in
11578      CONST_DOUBLE onto the same CONST_DOUBLE.  */
11579   if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
11580     return x;
11581
11582   for (i = n_replacements - 1; i >= 0 ; i--)
11583   if (x == replacements[i*2] && GET_MODE (x) == GET_MODE (replacements[i*2+1]))
11584     return replacements[i*2+1];
11585
11586   /* Allow this function to make replacements in EXPR_LISTs.  */
11587   if (x == 0)
11588     return 0;
11589
11590   if (GET_CODE (x) == SUBREG)
11591     {
11592       rtx new_rtx = replace_n_hard_rtx (SUBREG_REG (x), replacements,
11593                                     n_replacements, modify);
11594
11595       if (CONST_INT_P (new_rtx))
11596         {
11597           x = simplify_subreg (GET_MODE (x), new_rtx,
11598                                GET_MODE (SUBREG_REG (x)),
11599                                SUBREG_BYTE (x));
11600           if (! x)
11601             abort ();
11602         }
11603       else if (modify)
11604         SUBREG_REG (x) = new_rtx;
11605
11606       return x;
11607     }
11608   else if (REG_P (x))
11609     {
11610       unsigned regno = REGNO (x);
11611       unsigned nregs = (regno < FIRST_PSEUDO_REGISTER
11612                         ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
11613       rtx result = NULL_RTX;
11614
11615       for (i = n_replacements - 1; i >= 0; i--)
11616         {
11617           rtx from = replacements[i*2];
11618           rtx to = replacements[i*2+1];
11619           unsigned from_regno, from_nregs, to_regno, new_regno;
11620
11621           if (!REG_P (from))
11622             continue;
11623           from_regno = REGNO (from);
11624           from_nregs = (from_regno < FIRST_PSEUDO_REGISTER
11625                         ? HARD_REGNO_NREGS (from_regno, GET_MODE (from)) : 1);
11626           if (regno < from_regno + from_nregs && regno + nregs > from_regno)
11627             {
11628               if (regno < from_regno
11629                   || regno + nregs > from_regno + nregs
11630                   || !REG_P (to)
11631                   || result)
11632                 return NULL_RTX;
11633               to_regno = REGNO (to);
11634               if (to_regno < FIRST_PSEUDO_REGISTER)
11635                 {
11636                   new_regno = regno + to_regno - from_regno;
11637                   if ((unsigned) HARD_REGNO_NREGS (new_regno, GET_MODE (x))
11638                       != nregs)
11639                     return NULL_RTX;
11640                   result = gen_rtx_REG (GET_MODE (x), new_regno);
11641                 }
11642               else if (GET_MODE (x) <= GET_MODE (to))
11643                 result = gen_lowpart_common (GET_MODE (x), to);
11644               else
11645                 result = gen_lowpart_SUBREG (GET_MODE (x), to);
11646             }
11647         }
11648       return result ? result : x;
11649     }
11650   else if (GET_CODE (x) == ZERO_EXTEND)
11651     {
11652       rtx new_rtx = replace_n_hard_rtx (XEXP (x, 0), replacements,
11653                                     n_replacements, modify);
11654
11655       if (CONST_INT_P (new_rtx))
11656         {
11657           x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
11658                                         new_rtx, GET_MODE (XEXP (x, 0)));
11659           if (! x)
11660             abort ();
11661         }
11662       else if (modify)
11663         XEXP (x, 0) = new_rtx;
11664
11665       return x;
11666     }
11667
11668   fmt = GET_RTX_FORMAT (GET_CODE (x));
11669   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
11670     {
11671       rtx new_rtx;
11672
11673       if (fmt[i] == 'e')
11674         {
11675           new_rtx = replace_n_hard_rtx (XEXP (x, i), replacements,
11676                                     n_replacements, modify);
11677           if (!new_rtx)
11678             return NULL_RTX;
11679           if (modify)
11680             XEXP (x, i) = new_rtx;
11681         }
11682       else if (fmt[i] == 'E')
11683         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
11684           {
11685             new_rtx = replace_n_hard_rtx (XVECEXP (x, i, j), replacements,
11686                                       n_replacements, modify);
11687           if (!new_rtx)
11688             return NULL_RTX;
11689             if (modify)
11690               XVECEXP (x, i, j) = new_rtx;
11691           }
11692     }
11693
11694   return x;
11695 }
11696
11697 rtx
11698 sh_gen_truncate (enum machine_mode mode, rtx x, int need_sign_ext)
11699 {
11700   enum rtx_code code = TRUNCATE;
11701
11702   if (GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
11703     {
11704       rtx inner = XEXP (x, 0);
11705       enum machine_mode inner_mode = GET_MODE (inner);
11706
11707       if (inner_mode == mode)
11708         return inner;
11709       else if (GET_MODE_SIZE (inner_mode) >= GET_MODE_SIZE (mode))
11710         x = inner;
11711       else if (GET_MODE_SIZE (inner_mode) < GET_MODE_SIZE (mode)
11712                && (! need_sign_ext || GET_CODE (x) == SIGN_EXTEND))
11713         {
11714           code = GET_CODE (x);
11715           x = inner;
11716         }
11717     }
11718   return gen_rtx_fmt_e (code, mode, x);
11719 }
11720
11721 /* called via for_each_rtx after reload, to clean up truncates of
11722    registers that span multiple actual hard registers.  */
11723 int
11724 shmedia_cleanup_truncate (rtx *p, void *n_changes)
11725 {
11726   rtx x = *p, reg;
11727
11728   if (GET_CODE (x) != TRUNCATE)
11729     return 0;
11730   reg = XEXP (x, 0);
11731   if (GET_MODE_SIZE (GET_MODE (reg)) > 8 && REG_P (reg))
11732     {
11733       enum machine_mode reg_mode = GET_MODE (reg);
11734       XEXP (x, 0) = simplify_subreg (DImode, reg, reg_mode,
11735                                      subreg_lowpart_offset (DImode, reg_mode));
11736       *(int*) n_changes += 1;
11737       return -1;
11738     }
11739   return 0;
11740 }
11741
11742 /* Load and store depend on the highpart of the address.  However,
11743    set_attr_alternative does not give well-defined results before reload,
11744    so we must look at the rtl ourselves to see if any of the feeding
11745    registers is used in a memref.  */
11746
11747 /* Called by sh_contains_memref_p via for_each_rtx.  */
11748 static int
11749 sh_contains_memref_p_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
11750 {
11751   return (MEM_P (*loc));
11752 }
11753
11754 /* Return nonzero iff INSN contains a MEM.  */
11755 int
11756 sh_contains_memref_p (rtx insn)
11757 {
11758   return for_each_rtx (&PATTERN (insn), &sh_contains_memref_p_1, NULL);
11759 }
11760
11761 /* Return nonzero iff INSN loads a banked register.  */
11762 int
11763 sh_loads_bankedreg_p (rtx insn)
11764 {
11765   if (GET_CODE (PATTERN (insn)) == SET)
11766     {
11767       rtx op = SET_DEST (PATTERN(insn));
11768       if (REG_P (op) && BANKED_REGISTER_P (REGNO (op)))
11769         return 1;
11770     }
11771
11772   return 0;
11773 }
11774
11775 /* FNADDR is the MEM expression from a call expander.  Return an address
11776    to use in an SHmedia insn pattern.  */
11777 rtx
11778 shmedia_prepare_call_address (rtx fnaddr, int is_sibcall)
11779 {
11780   int is_sym;
11781
11782   fnaddr = XEXP (fnaddr, 0);
11783   is_sym = GET_CODE (fnaddr) == SYMBOL_REF;
11784   if (flag_pic && is_sym)
11785     {
11786       if (! SYMBOL_REF_LOCAL_P (fnaddr))
11787         {
11788           rtx reg = gen_reg_rtx (Pmode);
11789
11790           /* We must not use GOTPLT for sibcalls, because PIC_REG
11791              must be restored before the PLT code gets to run.  */
11792           if (is_sibcall)
11793             emit_insn (gen_symGOT2reg (reg, fnaddr));
11794           else
11795             emit_insn (gen_symGOTPLT2reg (reg, fnaddr));
11796           fnaddr = reg;
11797         }
11798       else
11799         {
11800           fnaddr = gen_sym2PIC (fnaddr);
11801           PUT_MODE (fnaddr, Pmode);
11802         }
11803     }
11804   /* If ptabs might trap, make this visible to the rest of the compiler.
11805      We generally assume that symbols pertain to valid locations, but
11806      it is possible to generate invalid symbols with asm or linker tricks.
11807      In a list of functions where each returns its successor, an invalid
11808      symbol might denote an empty list.  */
11809   if (!TARGET_PT_FIXED
11810       && (!is_sym || TARGET_INVALID_SYMBOLS)
11811       && (!REG_P (fnaddr) || ! TARGET_REGISTER_P (REGNO (fnaddr))))
11812     {
11813       rtx tr = gen_reg_rtx (PDImode);
11814
11815       emit_insn (gen_ptabs (tr, fnaddr));
11816       fnaddr = tr;
11817     }
11818   else if (! target_reg_operand (fnaddr, Pmode))
11819     fnaddr = copy_to_mode_reg (Pmode, fnaddr);
11820   return fnaddr;
11821 }
11822
11823 enum reg_class
11824 sh_secondary_reload (bool in_p, rtx x, enum reg_class rclass,
11825                      enum machine_mode mode, secondary_reload_info *sri)
11826 {
11827   if (in_p)
11828     {
11829       if (REGCLASS_HAS_FP_REG (rclass)
11830           && ! TARGET_SHMEDIA
11831           && immediate_operand ((x), mode)
11832           && ! ((fp_zero_operand (x) || fp_one_operand (x))
11833                 && mode == SFmode && fldi_ok ()))
11834         switch (mode)
11835           {
11836           case SFmode:
11837             sri->icode = CODE_FOR_reload_insf__frn;
11838             return NO_REGS;
11839           case DFmode:
11840             sri->icode = CODE_FOR_reload_indf__frn;
11841             return NO_REGS;
11842           case SImode:
11843             /* ??? If we knew that we are in the appropriate mode -
11844                single precision - we could use a reload pattern directly.  */
11845             return FPUL_REGS;
11846           default:
11847             abort ();
11848           }
11849       if (rclass == FPUL_REGS
11850           && ((REG_P (x)
11851                && (REGNO (x) == MACL_REG || REGNO (x) == MACH_REG
11852                    || REGNO (x) == T_REG))
11853               || GET_CODE (x) == PLUS))
11854         return GENERAL_REGS;
11855       if (rclass == FPUL_REGS && immediate_operand (x, mode))
11856         {
11857           if (satisfies_constraint_I08 (x) || fp_zero_operand (x))
11858             return GENERAL_REGS;
11859           else if (mode == SFmode)
11860             return FP_REGS;
11861           sri->icode = CODE_FOR_reload_insi__i_fpul;
11862           return NO_REGS;
11863         }
11864       if (rclass == FPSCR_REGS
11865           && ((REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER)
11866               || (MEM_P (x) && GET_CODE (XEXP (x, 0)) == PLUS)))
11867         return GENERAL_REGS;
11868       if (REGCLASS_HAS_FP_REG (rclass)
11869           && TARGET_SHMEDIA
11870           && immediate_operand (x, mode)
11871           && x != CONST0_RTX (GET_MODE (x))
11872           && GET_MODE (x) != V4SFmode)
11873         return GENERAL_REGS;
11874       if ((mode == QImode || mode == HImode)
11875           && TARGET_SHMEDIA && inqhi_operand (x, mode))
11876         {
11877           sri->icode = ((mode == QImode)
11878                         ? CODE_FOR_reload_inqi : CODE_FOR_reload_inhi);
11879           return NO_REGS;
11880         }
11881       if (TARGET_SHMEDIA && rclass == GENERAL_REGS
11882           && (GET_CODE (x) == LABEL_REF || PIC_ADDR_P (x)))
11883         return TARGET_REGS;
11884     } /* end of input-only processing.  */
11885
11886   if (((REGCLASS_HAS_FP_REG (rclass)
11887         && (REG_P (x)
11888             && (GENERAL_OR_AP_REGISTER_P (REGNO (x))
11889                 || (FP_REGISTER_P (REGNO (x)) && mode == SImode
11890                     && TARGET_FMOVD))))
11891        || (REGCLASS_HAS_GENERAL_REG (rclass)
11892            && REG_P (x)
11893            && FP_REGISTER_P (REGNO (x))))
11894       && ! TARGET_SHMEDIA
11895       && (mode == SFmode || mode == SImode))
11896     return FPUL_REGS;
11897   if ((rclass == FPUL_REGS
11898        || (REGCLASS_HAS_FP_REG (rclass)
11899            && ! TARGET_SHMEDIA && mode == SImode))
11900       && (MEM_P (x)
11901           || (REG_P (x)
11902               && (REGNO (x) >= FIRST_PSEUDO_REGISTER
11903                   || REGNO (x) == T_REG
11904                   || system_reg_operand (x, VOIDmode)))))
11905     {
11906       if (rclass == FPUL_REGS)
11907         return GENERAL_REGS;
11908       return FPUL_REGS;
11909     }
11910   if ((rclass == TARGET_REGS
11911        || (TARGET_SHMEDIA && rclass == SIBCALL_REGS))
11912       && !satisfies_constraint_Csy (x)
11913       && (!REG_P (x) || ! GENERAL_REGISTER_P (REGNO (x))))
11914     return GENERAL_REGS;
11915   if ((rclass == MAC_REGS || rclass == PR_REGS)
11916       && REG_P (x) && ! GENERAL_REGISTER_P (REGNO (x))
11917       && rclass != REGNO_REG_CLASS (REGNO (x)))
11918     return GENERAL_REGS;
11919   if (rclass != GENERAL_REGS && REG_P (x)
11920       && TARGET_REGISTER_P (REGNO (x)))
11921     return GENERAL_REGS;
11922   return NO_REGS;
11923 }
11924
11925 enum sh_divide_strategy_e sh_div_strategy = SH_DIV_STRATEGY_DEFAULT;
11926
11927 #include "gt-sh.h"