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