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       /* There is a possibility that a bf is transformed into a bf/s by the
4583          delay slot scheduler.  */
4584       if (JUMP_P (from) && !JUMP_TABLE_DATA_P (from)
4585           && get_attr_type (from) == TYPE_CBRANCH
4586           && GET_CODE (PATTERN (NEXT_INSN (PREV_INSN (from)))) != SEQUENCE)
4587         inc += 2;
4588
4589       if (found_si)
4590         {
4591           count_si += inc;
4592           if (new_align > si_align)
4593             {
4594               si_limit -= (count_si - 1) & (new_align - si_align);
4595               si_align = new_align;
4596             }
4597           count_si = (count_si + new_align - 1) & -new_align;
4598         }
4599       if (found_hi)
4600         {
4601           count_hi += inc;
4602           if (new_align > hi_align)
4603             {
4604               hi_limit -= (count_hi - 1) & (new_align - hi_align);
4605               hi_align = new_align;
4606             }
4607           count_hi = (count_hi + new_align - 1) & -new_align;
4608         }
4609       from = NEXT_INSN (from);
4610     }
4611
4612   if (num_mova)
4613     {
4614       if (leading_mova)
4615         {
4616           /* Try as we might, the leading mova is out of range.  Change
4617              it into a load (which will become a pcload) and retry.  */
4618           fixup_mova (mova);
4619           return find_barrier (0, 0, mova);
4620         }
4621       else
4622         {
4623           /* Insert the constant pool table before the mova instruction,
4624              to prevent the mova label reference from going out of range.  */
4625           from = mova;
4626           good_barrier = found_barrier = barrier_before_mova;
4627         }
4628     }
4629
4630   if (found_barrier)
4631     {
4632       if (good_barrier && next_real_insn (found_barrier))
4633         found_barrier = good_barrier;
4634     }
4635   else
4636     {
4637       /* We didn't find a barrier in time to dump our stuff,
4638          so we'll make one.  */
4639       rtx label = gen_label_rtx ();
4640
4641       /* If we exceeded the range, then we must back up over the last
4642          instruction we looked at.  Otherwise, we just need to undo the
4643          NEXT_INSN at the end of the loop.  */
4644       if (PREV_INSN (from) != orig
4645           && (count_hi > hi_limit || count_si > si_limit))
4646         from = PREV_INSN (PREV_INSN (from));
4647       else
4648         from = PREV_INSN (from);
4649
4650       /* Don't emit a constant table int the middle of global pointer setting,
4651          since that that would move the addressing base GOT into another table.
4652          We need the first mov instruction before the _GLOBAL_OFFSET_TABLE_
4653          in the pool anyway, so just move up the whole constant pool.  */
4654       if (last_got)
4655         from = PREV_INSN (last_got);
4656
4657       /* Walk back to be just before any jump or label.
4658          Putting it before a label reduces the number of times the branch
4659          around the constant pool table will be hit.  Putting it before
4660          a jump makes it more likely that the bra delay slot will be
4661          filled.  */
4662       while (NOTE_P (from) || JUMP_P (from)
4663              || LABEL_P (from))
4664         from = PREV_INSN (from);
4665
4666       from = emit_jump_insn_after (gen_jump (label), from);
4667       JUMP_LABEL (from) = label;
4668       LABEL_NUSES (label) = 1;
4669       found_barrier = emit_barrier_after (from);
4670       emit_label_after (label, found_barrier);
4671     }
4672
4673   return found_barrier;
4674 }
4675
4676 /* If the instruction INSN is implemented by a special function, and we can
4677    positively find the register that is used to call the sfunc, and this
4678    register is not used anywhere else in this instruction - except as the
4679    destination of a set, return this register; else, return 0.  */
4680 rtx
4681 sfunc_uses_reg (rtx insn)
4682 {
4683   int i;
4684   rtx pattern, part, reg_part, reg;
4685
4686   if (!NONJUMP_INSN_P (insn))
4687     return 0;
4688   pattern = PATTERN (insn);
4689   if (GET_CODE (pattern) != PARALLEL || get_attr_type (insn) != TYPE_SFUNC)
4690     return 0;
4691
4692   for (reg_part = 0, i = XVECLEN (pattern, 0) - 1; i >= 1; i--)
4693     {
4694       part = XVECEXP (pattern, 0, i);
4695       if (GET_CODE (part) == USE && GET_MODE (XEXP (part, 0)) == SImode)
4696         reg_part = part;
4697     }
4698   if (! reg_part)
4699     return 0;
4700   reg = XEXP (reg_part, 0);
4701   for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
4702     {
4703       part = XVECEXP (pattern, 0, i);
4704       if (part == reg_part || GET_CODE (part) == CLOBBER)
4705         continue;
4706       if (reg_mentioned_p (reg, ((GET_CODE (part) == SET
4707                                   && REG_P (SET_DEST (part)))
4708                                  ? SET_SRC (part) : part)))
4709         return 0;
4710     }
4711   return reg;
4712 }
4713
4714 /* See if the only way in which INSN uses REG is by calling it, or by
4715    setting it while calling it.  Set *SET to a SET rtx if the register
4716    is set by INSN.  */
4717
4718 static int
4719 noncall_uses_reg (rtx reg, rtx insn, rtx *set)
4720 {
4721   rtx pattern, reg2;
4722
4723   *set = NULL_RTX;
4724
4725   reg2 = sfunc_uses_reg (insn);
4726   if (reg2 && REGNO (reg2) == REGNO (reg))
4727     {
4728       pattern = single_set (insn);
4729       if (pattern
4730           && REG_P (SET_DEST (pattern))
4731           && REGNO (reg) == REGNO (SET_DEST (pattern)))
4732         *set = pattern;
4733       return 0;
4734     }
4735   if (!CALL_P (insn))
4736     {
4737       /* We don't use rtx_equal_p because we don't care if the mode is
4738          different.  */
4739       pattern = single_set (insn);
4740       if (pattern
4741           && REG_P (SET_DEST (pattern))
4742           && REGNO (reg) == REGNO (SET_DEST (pattern)))
4743         {
4744           rtx par, part;
4745           int i;
4746
4747           *set = pattern;
4748           par = PATTERN (insn);
4749           if (GET_CODE (par) == PARALLEL)
4750             for (i = XVECLEN (par, 0) - 1; i >= 0; i--)
4751               {
4752                 part = XVECEXP (par, 0, i);
4753                 if (GET_CODE (part) != SET && reg_mentioned_p (reg, part))
4754                   return 1;
4755               }
4756           return reg_mentioned_p (reg, SET_SRC (pattern));
4757         }
4758
4759       return 1;
4760     }
4761
4762   pattern = PATTERN (insn);
4763
4764   if (GET_CODE (pattern) == PARALLEL)
4765     {
4766       int i;
4767
4768       for (i = XVECLEN (pattern, 0) - 1; i >= 1; i--)
4769         if (reg_mentioned_p (reg, XVECEXP (pattern, 0, i)))
4770           return 1;
4771       pattern = XVECEXP (pattern, 0, 0);
4772     }
4773
4774   if (GET_CODE (pattern) == SET)
4775     {
4776       if (reg_mentioned_p (reg, SET_DEST (pattern)))
4777         {
4778           /* We don't use rtx_equal_p, because we don't care if the
4779              mode is different.  */
4780           if (!REG_P (SET_DEST (pattern))
4781               || REGNO (reg) != REGNO (SET_DEST (pattern)))
4782             return 1;
4783
4784           *set = pattern;
4785         }
4786
4787       pattern = SET_SRC (pattern);
4788     }
4789
4790   if (GET_CODE (pattern) != CALL
4791       || !MEM_P (XEXP (pattern, 0))
4792       || ! rtx_equal_p (reg, XEXP (XEXP (pattern, 0), 0)))
4793     return 1;
4794
4795   return 0;
4796 }
4797
4798 /* Given a X, a pattern of an insn or a part of it, return a mask of used
4799    general registers.  Bits 0..15 mean that the respective registers
4800    are used as inputs in the instruction.  Bits 16..31 mean that the
4801    registers 0..15, respectively, are used as outputs, or are clobbered.
4802    IS_DEST should be set to 16 if X is the destination of a SET, else to 0.  */
4803 int
4804 regs_used (rtx x, int is_dest)
4805 {
4806   enum rtx_code code;
4807   const char *fmt;
4808   int i, used = 0;
4809
4810   if (! x)
4811     return used;
4812   code = GET_CODE (x);
4813   switch (code)
4814     {
4815     case REG:
4816       if (REGNO (x) < 16)
4817         return (((1 << HARD_REGNO_NREGS (0, GET_MODE (x))) - 1)
4818                 << (REGNO (x) + is_dest));
4819       return 0;
4820     case SUBREG:
4821       {
4822         rtx y = SUBREG_REG (x);
4823
4824         if (!REG_P (y))
4825           break;
4826         if (REGNO (y) < 16)
4827           return (((1 << HARD_REGNO_NREGS (0, GET_MODE (x))) - 1)
4828                   << (REGNO (y) +
4829                       subreg_regno_offset (REGNO (y),
4830                                            GET_MODE (y),
4831                                            SUBREG_BYTE (x),
4832                                            GET_MODE (x)) + is_dest));
4833         return 0;
4834       }
4835     case SET:
4836       return regs_used (SET_SRC (x), 0) | regs_used (SET_DEST (x), 16);
4837     case RETURN:
4838       /* If there was a return value, it must have been indicated with USE.  */
4839       return 0x00ffff00;
4840     case CLOBBER:
4841       is_dest = 1;
4842       break;
4843     case MEM:
4844       is_dest = 0;
4845       break;
4846     case CALL:
4847       used |= 0x00ff00f0;
4848       break;
4849     default:
4850       break;
4851     }
4852
4853   fmt = GET_RTX_FORMAT (code);
4854
4855   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
4856     {
4857       if (fmt[i] == 'E')
4858         {
4859           register int j;
4860           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
4861             used |= regs_used (XVECEXP (x, i, j), is_dest);
4862         }
4863       else if (fmt[i] == 'e')
4864         used |= regs_used (XEXP (x, i), is_dest);
4865     }
4866   return used;
4867 }
4868
4869 /* Create an instruction that prevents redirection of a conditional branch
4870    to the destination of the JUMP with address ADDR.
4871    If the branch needs to be implemented as an indirect jump, try to find
4872    a scratch register for it.
4873    If NEED_BLOCK is 0, don't do anything unless we need a scratch register.
4874    If any preceding insn that doesn't fit into a delay slot is good enough,
4875    pass 1.  Pass 2 if a definite blocking insn is needed.
4876    -1 is used internally to avoid deep recursion.
4877    If a blocking instruction is made or recognized, return it.  */
4878
4879 static rtx
4880 gen_block_redirect (rtx jump, int addr, int need_block)
4881 {
4882   int dead = 0;
4883   rtx prev = prev_nonnote_insn (jump);
4884   rtx dest;
4885
4886   /* First, check if we already have an instruction that satisfies our need.  */
4887   if (prev && NONJUMP_INSN_P (prev) && ! INSN_DELETED_P (prev))
4888     {
4889       if (INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch)
4890         return prev;
4891       if (GET_CODE (PATTERN (prev)) == USE
4892           || GET_CODE (PATTERN (prev)) == CLOBBER
4893           || get_attr_in_delay_slot (prev) == IN_DELAY_SLOT_YES)
4894         prev = jump;
4895       else if ((need_block &= ~1) < 0)
4896         return prev;
4897       else if (recog_memoized (prev) == CODE_FOR_block_branch_redirect)
4898         need_block = 0;
4899     }
4900   if (GET_CODE (PATTERN (jump)) == RETURN)
4901     {
4902       if (! need_block)
4903         return prev;
4904       /* Reorg even does nasty things with return insns that cause branches
4905          to go out of range - see find_end_label and callers.  */
4906       return emit_insn_before (gen_block_branch_redirect (const0_rtx) , jump);
4907     }
4908   /* We can't use JUMP_LABEL here because it might be undefined
4909      when not optimizing.  */
4910   dest = XEXP (SET_SRC (PATTERN (jump)), 0);
4911   /* If the branch is out of range, try to find a scratch register for it.  */
4912   if (optimize
4913       && (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092
4914           > 4092 + 4098))
4915     {
4916       rtx scan;
4917       /* Don't look for the stack pointer as a scratch register,
4918          it would cause trouble if an interrupt occurred.  */
4919       unsigned attempt = 0x7fff, used;
4920       int jump_left = flag_expensive_optimizations + 1;
4921
4922       /* It is likely that the most recent eligible instruction is wanted for
4923          the delay slot.  Therefore, find out which registers it uses, and
4924          try to avoid using them.  */
4925
4926       for (scan = jump; (scan = PREV_INSN (scan)); )
4927         {
4928           enum rtx_code code;
4929
4930           if (INSN_DELETED_P (scan))
4931             continue;
4932           code = GET_CODE (scan);
4933           if (code == CODE_LABEL || code == JUMP_INSN)
4934             break;
4935           if (code == INSN
4936               && GET_CODE (PATTERN (scan)) != USE
4937               && GET_CODE (PATTERN (scan)) != CLOBBER
4938               && get_attr_in_delay_slot (scan) == IN_DELAY_SLOT_YES)
4939             {
4940               attempt &= ~regs_used (PATTERN (scan), 0);
4941               break;
4942             }
4943         }
4944       for (used = dead = 0, scan = JUMP_LABEL (jump);
4945            (scan = NEXT_INSN (scan)); )
4946         {
4947           enum rtx_code code;
4948
4949           if (INSN_DELETED_P (scan))
4950             continue;
4951           code = GET_CODE (scan);
4952           if (INSN_P (scan))
4953             {
4954               used |= regs_used (PATTERN (scan), 0);
4955               if (code == CALL_INSN)
4956                 used |= regs_used (CALL_INSN_FUNCTION_USAGE (scan), 0);
4957               dead |= (used >> 16) & ~used;
4958               if (dead & attempt)
4959                 {
4960                   dead &= attempt;
4961                   break;
4962                 }
4963               if (code == JUMP_INSN)
4964                 {
4965                   if (jump_left-- && simplejump_p (scan))
4966                     scan = JUMP_LABEL (scan);
4967                   else
4968                     break;
4969                 }
4970             }
4971         }
4972       /* Mask out the stack pointer again, in case it was
4973          the only 'free' register we have found.  */
4974       dead &= 0x7fff;
4975     }
4976   /* If the immediate destination is still in range, check for possible
4977      threading with a jump beyond the delay slot insn.
4978      Don't check if we are called recursively; the jump has been or will be
4979      checked in a different invocation then.  */
4980
4981   else if (optimize && need_block >= 0)
4982     {
4983       rtx next = next_active_insn (next_active_insn (dest));
4984       if (next && JUMP_P (next)
4985           && GET_CODE (PATTERN (next)) == SET
4986           && recog_memoized (next) == CODE_FOR_jump_compact)
4987         {
4988           dest = JUMP_LABEL (next);
4989           if (dest
4990               && (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092
4991                   > 4092 + 4098))
4992             gen_block_redirect (next, INSN_ADDRESSES (INSN_UID (next)), -1);
4993         }
4994     }
4995
4996   if (dead)
4997     {
4998       rtx reg = gen_rtx_REG (SImode, exact_log2 (dead & -dead));
4999
5000       /* It would be nice if we could convert the jump into an indirect
5001          jump / far branch right now, and thus exposing all constituent
5002          instructions to further optimization.  However, reorg uses
5003          simplejump_p to determine if there is an unconditional jump where
5004          it should try to schedule instructions from the target of the
5005          branch; simplejump_p fails for indirect jumps even if they have
5006          a JUMP_LABEL.  */
5007       rtx insn = emit_insn_before (gen_indirect_jump_scratch
5008                                    (reg, GEN_INT (INSN_UID (JUMP_LABEL (jump))))
5009                                    , jump);
5010       /* ??? We would like this to have the scope of the jump, but that
5011          scope will change when a delay slot insn of an inner scope is added.
5012          Hence, after delay slot scheduling, we'll have to expect
5013          NOTE_INSN_BLOCK_END notes between the indirect_jump_scratch and
5014          the jump.  */
5015
5016       INSN_LOCATOR (insn) = INSN_LOCATOR (jump);
5017       INSN_CODE (insn) = CODE_FOR_indirect_jump_scratch;
5018       return insn;
5019     }
5020   else if (need_block)
5021     /* We can't use JUMP_LABEL here because it might be undefined
5022        when not optimizing.  */
5023     return emit_insn_before (gen_block_branch_redirect
5024                       (GEN_INT (INSN_UID (XEXP (SET_SRC (PATTERN (jump)), 0))))
5025                       , jump);
5026   return prev;
5027 }
5028
5029 #define CONDJUMP_MIN -252
5030 #define CONDJUMP_MAX 262
5031 struct far_branch
5032 {
5033   /* A label (to be placed) in front of the jump
5034      that jumps to our ultimate destination.  */
5035   rtx near_label;
5036   /* Where we are going to insert it if we cannot move the jump any farther,
5037      or the jump itself if we have picked up an existing jump.  */
5038   rtx insert_place;
5039   /* The ultimate destination.  */
5040   rtx far_label;
5041   struct far_branch *prev;
5042   /* If the branch has already been created, its address;
5043      else the address of its first prospective user.  */
5044   int address;
5045 };
5046
5047 static void gen_far_branch (struct far_branch *);
5048 enum mdep_reorg_phase_e mdep_reorg_phase;
5049 static void
5050 gen_far_branch (struct far_branch *bp)
5051 {
5052   rtx insn = bp->insert_place;
5053   rtx jump;
5054   rtx label = gen_label_rtx ();
5055   int ok;
5056
5057   emit_label_after (label, insn);
5058   if (bp->far_label)
5059     {
5060       jump = emit_jump_insn_after (gen_jump (bp->far_label), insn);
5061       LABEL_NUSES (bp->far_label)++;
5062     }
5063   else
5064     jump = emit_jump_insn_after (gen_return (), insn);
5065   /* Emit a barrier so that reorg knows that any following instructions
5066      are not reachable via a fall-through path.
5067      But don't do this when not optimizing, since we wouldn't suppress the
5068      alignment for the barrier then, and could end up with out-of-range
5069      pc-relative loads.  */
5070   if (optimize)
5071     emit_barrier_after (jump);
5072   emit_label_after (bp->near_label, insn);
5073   JUMP_LABEL (jump) = bp->far_label;
5074   ok = invert_jump (insn, label, 1);
5075   gcc_assert (ok);
5076
5077   /* If we are branching around a jump (rather than a return), prevent
5078      reorg from using an insn from the jump target as the delay slot insn -
5079      when reorg did this, it pessimized code (we rather hide the delay slot)
5080      and it could cause branches to go out of range.  */
5081   if (bp->far_label)
5082     (emit_insn_after
5083      (gen_stuff_delay_slot
5084       (GEN_INT (INSN_UID (XEXP (SET_SRC (PATTERN (jump)), 0))),
5085        GEN_INT (recog_memoized (insn) == CODE_FOR_branch_false)),
5086       insn));
5087   /* Prevent reorg from undoing our splits.  */
5088   gen_block_redirect (jump, bp->address += 2, 2);
5089 }
5090
5091 /* Fix up ADDR_DIFF_VECs.  */
5092 void
5093 fixup_addr_diff_vecs (rtx first)
5094 {
5095   rtx insn;
5096
5097   for (insn = first; insn; insn = NEXT_INSN (insn))
5098     {
5099       rtx vec_lab, pat, prev, prevpat, x, braf_label;
5100
5101       if (!JUMP_P (insn)
5102           || GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
5103         continue;
5104       pat = PATTERN (insn);
5105       vec_lab = XEXP (XEXP (pat, 0), 0);
5106
5107       /* Search the matching casesi_jump_2.  */
5108       for (prev = vec_lab; ; prev = PREV_INSN (prev))
5109         {
5110           if (!JUMP_P (prev))
5111             continue;
5112           prevpat = PATTERN (prev);
5113           if (GET_CODE (prevpat) != PARALLEL || XVECLEN (prevpat, 0) != 2)
5114             continue;
5115           x = XVECEXP (prevpat, 0, 1);
5116           if (GET_CODE (x) != USE)
5117             continue;
5118           x = XEXP (x, 0);
5119           if (GET_CODE (x) == LABEL_REF && XEXP (x, 0) == vec_lab)
5120             break;
5121         }
5122       /* FIXME: This is a bug in the optimizer, but it seems harmless
5123          to just avoid panicing.  */
5124       if (!prev)
5125         continue;
5126
5127       /* Emit the reference label of the braf where it belongs, right after
5128          the casesi_jump_2 (i.e. braf).  */
5129       braf_label = XEXP (XEXP (SET_SRC (XVECEXP (prevpat, 0, 0)), 1), 0);
5130       emit_label_after (braf_label, prev);
5131
5132       /* Fix up the ADDR_DIF_VEC to be relative
5133          to the reference address of the braf.  */
5134       XEXP (XEXP (pat, 0), 0) = braf_label;
5135     }
5136 }
5137
5138 /* BARRIER_OR_LABEL is either a BARRIER or a CODE_LABEL immediately following
5139    a barrier.  Return the base 2 logarithm of the desired alignment.  */
5140 int
5141 barrier_align (rtx barrier_or_label)
5142 {
5143   rtx next = next_real_insn (barrier_or_label), pat, prev;
5144   int slot, credit, jump_to_next = 0;
5145
5146   if (! next)
5147     return 0;
5148
5149   pat = PATTERN (next);
5150
5151   if (GET_CODE (pat) == ADDR_DIFF_VEC)
5152     return 2;
5153
5154   if (GET_CODE (pat) == UNSPEC_VOLATILE && XINT (pat, 1) == UNSPECV_ALIGN)
5155     /* This is a barrier in front of a constant table.  */
5156     return 0;
5157
5158   prev = prev_real_insn (barrier_or_label);
5159   if (GET_CODE (PATTERN (prev)) == ADDR_DIFF_VEC)
5160     {
5161       pat = PATTERN (prev);
5162       /* If this is a very small table, we want to keep the alignment after
5163          the table to the minimum for proper code alignment.  */
5164       return ((TARGET_SMALLCODE
5165                || ((unsigned) XVECLEN (pat, 1) * GET_MODE_SIZE (GET_MODE (pat))
5166                    <= (unsigned) 1 << (CACHE_LOG - 2)))
5167               ? 1 << TARGET_SHMEDIA : align_jumps_log);
5168     }
5169
5170   if (TARGET_SMALLCODE)
5171     return 0;
5172
5173   if (! TARGET_SH2 || ! optimize)
5174     return align_jumps_log;
5175
5176   /* When fixing up pcloads, a constant table might be inserted just before
5177      the basic block that ends with the barrier.  Thus, we can't trust the
5178      instruction lengths before that.  */
5179   if (mdep_reorg_phase > SH_FIXUP_PCLOAD)
5180     {
5181       /* Check if there is an immediately preceding branch to the insn beyond
5182          the barrier.  We must weight the cost of discarding useful information
5183          from the current cache line when executing this branch and there is
5184          an alignment, against that of fetching unneeded insn in front of the
5185          branch target when there is no alignment.  */
5186
5187       /* There are two delay_slot cases to consider.  One is the simple case
5188          where the preceding branch is to the insn beyond the barrier (simple
5189          delay slot filling), and the other is where the preceding branch has
5190          a delay slot that is a duplicate of the insn after the barrier
5191          (fill_eager_delay_slots) and the branch is to the insn after the insn
5192          after the barrier.  */
5193
5194       /* PREV is presumed to be the JUMP_INSN for the barrier under
5195          investigation.  Skip to the insn before it.  */
5196       prev = prev_real_insn (prev);
5197
5198       for (slot = 2, credit = (1 << (CACHE_LOG - 2)) + 2;
5199            credit >= 0 && prev && NONJUMP_INSN_P (prev);
5200            prev = prev_real_insn (prev))
5201         {
5202           jump_to_next = 0;
5203           if (GET_CODE (PATTERN (prev)) == USE
5204               || GET_CODE (PATTERN (prev)) == CLOBBER)
5205             continue;
5206           if (GET_CODE (PATTERN (prev)) == SEQUENCE)
5207             {
5208               prev = XVECEXP (PATTERN (prev), 0, 1);
5209               if (INSN_UID (prev) == INSN_UID (next))
5210                 {
5211                   /* Delay slot was filled with insn at jump target.  */
5212                   jump_to_next = 1;
5213                   continue;
5214                 }
5215             }
5216
5217           if (slot &&
5218               get_attr_in_delay_slot (prev) == IN_DELAY_SLOT_YES)
5219             slot = 0;
5220           credit -= get_attr_length (prev);
5221         }
5222       if (prev
5223           && JUMP_P (prev)
5224           && JUMP_LABEL (prev))
5225         {
5226           rtx x;
5227           if (jump_to_next
5228               || next_real_insn (JUMP_LABEL (prev)) == next
5229               /* If relax_delay_slots() decides NEXT was redundant
5230                  with some previous instruction, it will have
5231                  redirected PREV's jump to the following insn.  */
5232               || JUMP_LABEL (prev) == next_nonnote_insn (next)
5233               /* There is no upper bound on redundant instructions
5234                  that might have been skipped, but we must not put an
5235                  alignment where none had been before.  */
5236               || (x = (NEXT_INSN (NEXT_INSN (PREV_INSN (prev)))),
5237                   (INSN_P (x)
5238                    && (INSN_CODE (x) == CODE_FOR_block_branch_redirect
5239                        || INSN_CODE (x) == CODE_FOR_indirect_jump_scratch
5240                        || INSN_CODE (x) == CODE_FOR_stuff_delay_slot))))
5241             {
5242               rtx pat = PATTERN (prev);
5243               if (GET_CODE (pat) == PARALLEL)
5244                 pat = XVECEXP (pat, 0, 0);
5245               if (credit - slot >= (GET_CODE (SET_SRC (pat)) == PC ? 2 : 0))
5246                 return 0;
5247             }
5248         }
5249     }
5250
5251   return align_jumps_log;
5252 }
5253
5254 /* If we are inside a phony loop, almost any kind of label can turn up as the
5255    first one in the loop.  Aligning a braf label causes incorrect switch
5256    destination addresses; we can detect braf labels because they are
5257    followed by a BARRIER.
5258    Applying loop alignment to small constant or switch tables is a waste
5259    of space, so we suppress this too.  */
5260 int
5261 sh_loop_align (rtx label)
5262 {
5263   rtx next = label;
5264
5265   do
5266     next = next_nonnote_insn (next);
5267   while (next && LABEL_P (next));
5268
5269   if (! next
5270       || ! INSN_P (next)
5271       || GET_CODE (PATTERN (next)) == ADDR_DIFF_VEC
5272       || recog_memoized (next) == CODE_FOR_consttable_2)
5273     return 0;
5274
5275   return align_loops_log;
5276 }
5277
5278 /* Do a final pass over the function, just before delayed branch
5279    scheduling.  */
5280
5281 static void
5282 sh_reorg (void)
5283 {
5284   rtx first, insn, mova = NULL_RTX;
5285   int num_mova;
5286   rtx r0_rtx = gen_rtx_REG (Pmode, 0);
5287   rtx r0_inc_rtx = gen_rtx_POST_INC (Pmode, r0_rtx);
5288
5289   first = get_insns ();
5290   max_labelno_before_reorg = max_label_num ();
5291
5292   /* We must split call insns before introducing `mova's.  If we're
5293      optimizing, they'll have already been split.  Otherwise, make
5294      sure we don't split them too late.  */
5295   if (! optimize)
5296     split_all_insns_noflow ();
5297
5298   if (TARGET_SHMEDIA)
5299     return;
5300
5301   /* If relaxing, generate pseudo-ops to associate function calls with
5302      the symbols they call.  It does no harm to not generate these
5303      pseudo-ops.  However, when we can generate them, it enables to
5304      linker to potentially relax the jsr to a bsr, and eliminate the
5305      register load and, possibly, the constant pool entry.  */
5306
5307   mdep_reorg_phase = SH_INSERT_USES_LABELS;
5308   if (TARGET_RELAX)
5309     {
5310       /* Remove all REG_LABEL_OPERAND notes.  We want to use them for our
5311          own purposes.  This works because none of the remaining passes
5312          need to look at them.
5313
5314          ??? But it may break in the future.  We should use a machine
5315          dependent REG_NOTE, or some other approach entirely.  */
5316       for (insn = first; insn; insn = NEXT_INSN (insn))
5317         {
5318           if (INSN_P (insn))
5319             {
5320               rtx note;
5321
5322               while ((note = find_reg_note (insn, REG_LABEL_OPERAND,
5323                                             NULL_RTX)) != 0)
5324                 remove_note (insn, note);
5325             }
5326         }
5327
5328       for (insn = first; insn; insn = NEXT_INSN (insn))
5329         {
5330           rtx pattern, reg, link, set, scan, dies, label;
5331           int rescan = 0, foundinsn = 0;
5332
5333           if (CALL_P (insn))
5334             {
5335               pattern = PATTERN (insn);
5336
5337               if (GET_CODE (pattern) == PARALLEL)
5338                 pattern = XVECEXP (pattern, 0, 0);
5339               if (GET_CODE (pattern) == SET)
5340                 pattern = SET_SRC (pattern);
5341
5342               if (GET_CODE (pattern) != CALL
5343                   || !MEM_P (XEXP (pattern, 0)))
5344                 continue;
5345
5346               reg = XEXP (XEXP (pattern, 0), 0);
5347             }
5348           else
5349             {
5350               reg = sfunc_uses_reg (insn);
5351               if (! reg)
5352                 continue;
5353             }
5354
5355           if (!REG_P (reg))
5356             continue;
5357
5358           /* Try scanning backward to find where the register is set.  */
5359           link = NULL;
5360           for (scan = PREV_INSN (insn);
5361                scan && !LABEL_P (scan);
5362                scan = PREV_INSN (scan))
5363             {
5364               if (! INSN_P (scan))
5365                 continue;
5366
5367               if (! reg_mentioned_p (reg, scan))
5368                 continue;
5369
5370               if (noncall_uses_reg (reg, scan, &set))
5371                 break;
5372
5373               if (set)
5374                 {
5375                   link = scan;
5376                   break;
5377                 }
5378             }
5379
5380           if (! link)
5381             continue;
5382
5383           /* The register is set at LINK.  */
5384
5385           /* We can only optimize the function call if the register is
5386              being set to a symbol.  In theory, we could sometimes
5387              optimize calls to a constant location, but the assembler
5388              and linker do not support that at present.  */
5389           if (GET_CODE (SET_SRC (set)) != SYMBOL_REF
5390               && GET_CODE (SET_SRC (set)) != LABEL_REF)
5391             continue;
5392
5393           /* Scan forward from LINK to the place where REG dies, and
5394              make sure that the only insns which use REG are
5395              themselves function calls.  */
5396
5397           /* ??? This doesn't work for call targets that were allocated
5398              by reload, since there may not be a REG_DEAD note for the
5399              register.  */
5400
5401           dies = NULL_RTX;
5402           for (scan = NEXT_INSN (link); scan; scan = NEXT_INSN (scan))
5403             {
5404               rtx scanset;
5405
5406               /* Don't try to trace forward past a CODE_LABEL if we haven't
5407                  seen INSN yet.  Ordinarily, we will only find the setting insn
5408                  if it is in the same basic block.  However,
5409                  cross-jumping can insert code labels in between the load and
5410                  the call, and can result in situations where a single call
5411                  insn may have two targets depending on where we came from.  */
5412
5413               if (LABEL_P (scan) && ! foundinsn)
5414                 break;
5415
5416               if (! INSN_P (scan))
5417                 continue;
5418
5419               /* Don't try to trace forward past a JUMP.  To optimize
5420                  safely, we would have to check that all the
5421                  instructions at the jump destination did not use REG.  */
5422
5423               if (JUMP_P (scan))
5424                 break;
5425
5426               if (! reg_mentioned_p (reg, scan))
5427                 continue;
5428
5429               if (noncall_uses_reg (reg, scan, &scanset))
5430                 break;
5431
5432               if (scan == insn)
5433                 foundinsn = 1;
5434
5435               if (scan != insn
5436                   && (CALL_P (scan) || sfunc_uses_reg (scan)))
5437                 {
5438                   /* There is a function call to this register other
5439                      than the one we are checking.  If we optimize
5440                      this call, we need to rescan again below.  */
5441                   rescan = 1;
5442                 }
5443
5444               /* ??? We shouldn't have to worry about SCANSET here.
5445                  We should just be able to check for a REG_DEAD note
5446                  on a function call.  However, the REG_DEAD notes are
5447                  apparently not dependable around libcalls; c-torture
5448                  execute/920501-2 is a test case.  If SCANSET is set,
5449                  then this insn sets the register, so it must have
5450                  died earlier.  Unfortunately, this will only handle
5451                  the cases in which the register is, in fact, set in a
5452                  later insn.  */
5453
5454               /* ??? We shouldn't have to use FOUNDINSN here.
5455                  This dates back to when we used LOG_LINKS to find
5456                  the most recent insn which sets the register.  */
5457
5458               if (foundinsn
5459                   && (scanset
5460                       || find_reg_note (scan, REG_DEAD, reg)))
5461                 {
5462                   dies = scan;
5463                   break;
5464                 }
5465             }
5466
5467           if (! dies)
5468             {
5469               /* Either there was a branch, or some insn used REG
5470                  other than as a function call address.  */
5471               continue;
5472             }
5473
5474           /* Create a code label, and put it in a REG_LABEL_OPERAND note
5475              on the insn which sets the register, and on each call insn
5476              which uses the register.  In final_prescan_insn we look for
5477              the REG_LABEL_OPERAND notes, and output the appropriate label
5478              or pseudo-op.  */
5479
5480           label = gen_label_rtx ();
5481           add_reg_note (link, REG_LABEL_OPERAND, label);
5482           add_reg_note (insn, REG_LABEL_OPERAND, label);
5483           if (rescan)
5484             {
5485               scan = link;
5486               do
5487                 {
5488                   rtx reg2;
5489
5490                   scan = NEXT_INSN (scan);
5491                   if (scan != insn
5492                       && ((CALL_P (scan)
5493                            && reg_mentioned_p (reg, scan))
5494                           || ((reg2 = sfunc_uses_reg (scan))
5495                               && REGNO (reg2) == REGNO (reg))))
5496                     add_reg_note (scan, REG_LABEL_OPERAND, label);
5497                 }
5498               while (scan != dies);
5499             }
5500         }
5501     }
5502
5503   if (TARGET_SH2)
5504     fixup_addr_diff_vecs (first);
5505
5506   if (optimize)
5507     {
5508       mdep_reorg_phase = SH_SHORTEN_BRANCHES0;
5509       shorten_branches (first);
5510     }
5511
5512   /* Scan the function looking for move instructions which have to be
5513      changed to pc-relative loads and insert the literal tables.  */
5514   label_ref_list_pool = create_alloc_pool ("label references list",
5515                                            sizeof (struct label_ref_list_d),
5516                                            30);
5517   mdep_reorg_phase = SH_FIXUP_PCLOAD;
5518   for (insn = first, num_mova = 0; insn; insn = NEXT_INSN (insn))
5519     {
5520       if (mova_p (insn))
5521         {
5522           /* ??? basic block reordering can move a switch table dispatch
5523              below the switch table.  Check if that has happened.
5524              We only have the addresses available when optimizing; but then,
5525              this check shouldn't be needed when not optimizing.  */
5526           if (!untangle_mova (&num_mova, &mova, insn))
5527             {
5528               insn = mova;
5529               num_mova = 0;
5530             }
5531         }
5532       else if (JUMP_P (insn)
5533                && GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC
5534                && num_mova
5535                /* ??? loop invariant motion can also move a mova out of a
5536                   loop.  Since loop does this code motion anyway, maybe we
5537                   should wrap UNSPEC_MOVA into a CONST, so that reload can
5538                   move it back.  */
5539                && ((num_mova > 1
5540                     && GET_MODE (prev_nonnote_insn (insn)) == VOIDmode)
5541                    || (prev_nonnote_insn (insn)
5542                        == XEXP (MOVA_LABELREF (mova), 0))))
5543         {
5544           rtx scan;
5545           int total;
5546
5547           num_mova--;
5548
5549           /* Some code might have been inserted between the mova and
5550              its ADDR_DIFF_VEC.  Check if the mova is still in range.  */
5551           for (scan = mova, total = 0; scan != insn; scan = NEXT_INSN (scan))
5552             total += get_attr_length (scan);
5553
5554           /* range of mova is 1020, add 4 because pc counts from address of
5555              second instruction after this one, subtract 2 in case pc is 2
5556              byte aligned.  Possible alignment needed for the ADDR_DIFF_VEC
5557              cancels out with alignment effects of the mova itself.  */
5558           if (total > 1022)
5559             {
5560               /* Change the mova into a load, and restart scanning
5561                  there.  broken_move will then return true for mova.  */
5562               fixup_mova (mova);
5563               insn = mova;
5564             }
5565         }
5566       if (broken_move (insn)
5567           || (NONJUMP_INSN_P (insn)
5568               && recog_memoized (insn) == CODE_FOR_casesi_worker_2))
5569         {
5570           rtx scan;
5571           /* Scan ahead looking for a barrier to stick the constant table
5572              behind.  */
5573           rtx barrier = find_barrier (num_mova, mova, insn);
5574           rtx last_float_move = NULL_RTX, last_float = 0, *last_float_addr = NULL;
5575           int need_aligned_label = 0;
5576
5577           if (num_mova && ! mova_p (mova))
5578             {
5579               /* find_barrier had to change the first mova into a
5580                  pcload; thus, we have to start with this new pcload.  */
5581               insn = mova;
5582               num_mova = 0;
5583             }
5584           /* Now find all the moves between the points and modify them.  */
5585           for (scan = insn; scan != barrier; scan = NEXT_INSN (scan))
5586             {
5587               if (LABEL_P (scan))
5588                 last_float = 0;
5589               if (NONJUMP_INSN_P (scan)
5590                   && recog_memoized (scan) == CODE_FOR_casesi_worker_2)
5591                 need_aligned_label = 1;
5592               if (broken_move (scan))
5593                 {
5594                   rtx *patp = &PATTERN (scan), pat = *patp;
5595                   rtx src, dst;
5596                   rtx lab;
5597                   rtx newsrc;
5598                   enum machine_mode mode;
5599
5600                   if (GET_CODE (pat) == PARALLEL)
5601                     patp = &XVECEXP (pat, 0, 0), pat = *patp;
5602                   src = SET_SRC (pat);
5603                   dst = SET_DEST (pat);
5604                   mode = GET_MODE (dst);
5605
5606                   if (mode == SImode && hi_const (src)
5607                       && REGNO (dst) != FPUL_REG)
5608                     {
5609                       int offset = 0;
5610
5611                       mode = HImode;
5612                       while (GET_CODE (dst) == SUBREG)
5613                         {
5614                           offset += subreg_regno_offset (REGNO (SUBREG_REG (dst)),
5615                                                          GET_MODE (SUBREG_REG (dst)),
5616                                                          SUBREG_BYTE (dst),
5617                                                          GET_MODE (dst));
5618                           dst = SUBREG_REG (dst);
5619                         }
5620                       dst = gen_rtx_REG (HImode, REGNO (dst) + offset);
5621                     }
5622                   if (REG_P (dst) && FP_ANY_REGISTER_P (REGNO (dst)))
5623                     {
5624                       /* This must be an insn that clobbers r0.  */
5625                       rtx *clobberp = &XVECEXP (PATTERN (scan), 0,
5626                                                 XVECLEN (PATTERN (scan), 0)
5627                                                 - 1);
5628                       rtx clobber = *clobberp;
5629
5630                       gcc_assert (GET_CODE (clobber) == CLOBBER
5631                                   && rtx_equal_p (XEXP (clobber, 0), r0_rtx));
5632
5633                       if (last_float
5634                           && reg_set_between_p (r0_rtx, last_float_move, scan))
5635                         last_float = 0;
5636                       if (last_float
5637                           && TARGET_SHCOMPACT
5638                           && GET_MODE_SIZE (mode) != 4
5639                           && GET_MODE_SIZE (GET_MODE (last_float)) == 4)
5640                         last_float = 0;
5641                       lab = add_constant (src, mode, last_float);
5642                       if (lab)
5643                         emit_insn_before (gen_mova (lab), scan);
5644                       else
5645                         {
5646                           /* There will be a REG_UNUSED note for r0 on
5647                              LAST_FLOAT_MOVE; we have to change it to REG_INC,
5648                              lest reorg:mark_target_live_regs will not
5649                              consider r0 to be used, and we end up with delay
5650                              slot insn in front of SCAN that clobbers r0.  */
5651                           rtx note
5652                             = find_regno_note (last_float_move, REG_UNUSED, 0);
5653
5654                           /* If we are not optimizing, then there may not be
5655                              a note.  */
5656                           if (note)
5657                             PUT_REG_NOTE_KIND (note, REG_INC);
5658
5659                           *last_float_addr = r0_inc_rtx;
5660                         }
5661                       last_float_move = scan;
5662                       last_float = src;
5663                       newsrc = gen_const_mem (mode,
5664                                         (((TARGET_SH4 && ! TARGET_FMOVD)
5665                                           || REGNO (dst) == FPUL_REG)
5666                                          ? r0_inc_rtx
5667                                          : r0_rtx));
5668                       last_float_addr = &XEXP (newsrc, 0);
5669
5670                       /* Remove the clobber of r0.  */
5671                       *clobberp = gen_rtx_CLOBBER (GET_MODE (clobber),
5672                                                    gen_rtx_SCRATCH (Pmode));
5673                     }
5674                   /* This is a mova needing a label.  Create it.  */
5675                   else if (GET_CODE (src) == UNSPEC
5676                            && XINT (src, 1) == UNSPEC_MOVA
5677                            && GET_CODE (XVECEXP (src, 0, 0)) == CONST)
5678                     {
5679                       lab = add_constant (XVECEXP (src, 0, 0), mode, 0);
5680                       newsrc = gen_rtx_LABEL_REF (VOIDmode, lab);
5681                       newsrc = gen_rtx_UNSPEC (SImode,
5682                                                gen_rtvec (1, newsrc),
5683                                                UNSPEC_MOVA);
5684                     }
5685                   else
5686                     {
5687                       lab = add_constant (src, mode, 0);
5688                       newsrc = gen_rtx_LABEL_REF (VOIDmode, lab);
5689                       newsrc = gen_const_mem (mode, newsrc);
5690                     }
5691                   *patp = gen_rtx_SET (VOIDmode, dst, newsrc);
5692                   INSN_CODE (scan) = -1;
5693                 }
5694             }
5695           dump_table (need_aligned_label ? insn : 0, barrier);
5696           insn = barrier;
5697         }
5698     }
5699   free_alloc_pool (label_ref_list_pool);
5700   for (insn = first; insn; insn = NEXT_INSN (insn))
5701     PUT_MODE (insn, VOIDmode);
5702
5703   mdep_reorg_phase = SH_SHORTEN_BRANCHES1;
5704   INSN_ADDRESSES_FREE ();
5705   split_branches (first);
5706
5707   /* The INSN_REFERENCES_ARE_DELAYED in sh.h is problematic because it
5708      also has an effect on the register that holds the address of the sfunc.
5709      Insert an extra dummy insn in front of each sfunc that pretends to
5710      use this register.  */
5711   if (flag_delayed_branch)
5712     {
5713       for (insn = first; insn; insn = NEXT_INSN (insn))
5714         {
5715           rtx reg = sfunc_uses_reg (insn);
5716
5717           if (! reg)
5718             continue;
5719           emit_insn_before (gen_use_sfunc_addr (reg), insn);
5720         }
5721     }
5722 #if 0
5723   /* fpscr is not actually a user variable, but we pretend it is for the
5724      sake of the previous optimization passes, since we want it handled like
5725      one.  However, we don't have any debugging information for it, so turn
5726      it into a non-user variable now.  */
5727   if (TARGET_SH4)
5728     REG_USERVAR_P (get_fpscr_rtx ()) = 0;
5729 #endif
5730   mdep_reorg_phase = SH_AFTER_MDEP_REORG;
5731 }
5732
5733 int
5734 get_dest_uid (rtx label, int max_uid)
5735 {
5736   rtx dest = next_real_insn (label);
5737   int dest_uid;
5738   if (! dest)
5739     /* This can happen for an undefined label.  */
5740     return 0;
5741   dest_uid = INSN_UID (dest);
5742   /* If this is a newly created branch redirection blocking instruction,
5743      we cannot index the branch_uid or insn_addresses arrays with its
5744      uid.  But then, we won't need to, because the actual destination is
5745      the following branch.  */
5746   while (dest_uid >= max_uid)
5747     {
5748       dest = NEXT_INSN (dest);
5749       dest_uid = INSN_UID (dest);
5750     }
5751   if (JUMP_P (dest) && GET_CODE (PATTERN (dest)) == RETURN)
5752     return 0;
5753   return dest_uid;
5754 }
5755
5756 /* Split condbranches that are out of range.  Also add clobbers for
5757    scratch registers that are needed in far jumps.
5758    We do this before delay slot scheduling, so that it can take our
5759    newly created instructions into account.  It also allows us to
5760    find branches with common targets more easily.  */
5761
5762 static void
5763 split_branches (rtx first)
5764 {
5765   rtx insn;
5766   struct far_branch **uid_branch, *far_branch_list = 0;
5767   int max_uid = get_max_uid ();
5768   int ok;
5769
5770   /* Find out which branches are out of range.  */
5771   shorten_branches (first);
5772
5773   uid_branch = (struct far_branch **) alloca (max_uid * sizeof *uid_branch);
5774   memset ((char *) uid_branch, 0, max_uid * sizeof *uid_branch);
5775
5776   for (insn = first; insn; insn = NEXT_INSN (insn))
5777     if (! INSN_P (insn))
5778       continue;
5779     else if (INSN_DELETED_P (insn))
5780       {
5781         /* Shorten_branches would split this instruction again,
5782            so transform it into a note.  */
5783         SET_INSN_DELETED (insn);
5784       }
5785     else if (JUMP_P (insn)
5786              /* Don't mess with ADDR_DIFF_VEC */
5787              && (GET_CODE (PATTERN (insn)) == SET
5788                  || GET_CODE (PATTERN (insn)) == RETURN))
5789       {
5790         enum attr_type type = get_attr_type (insn);
5791         if (type == TYPE_CBRANCH)
5792           {
5793             rtx next, beyond;
5794
5795             if (get_attr_length (insn) > 4)
5796               {
5797                 rtx src = SET_SRC (PATTERN (insn));
5798                 rtx olabel = XEXP (XEXP (src, 1), 0);
5799                 int addr = INSN_ADDRESSES (INSN_UID (insn));
5800                 rtx label = 0;
5801                 int dest_uid = get_dest_uid (olabel, max_uid);
5802                 struct far_branch *bp = uid_branch[dest_uid];
5803
5804                 /* redirect_jump needs a valid JUMP_LABEL, and it might delete
5805                    the label if the LABEL_NUSES count drops to zero.  There is
5806                    always a jump_optimize pass that sets these values, but it
5807                    proceeds to delete unreferenced code, and then if not
5808                    optimizing, to un-delete the deleted instructions, thus
5809                    leaving labels with too low uses counts.  */
5810                 if (! optimize)
5811                   {
5812                     JUMP_LABEL (insn) = olabel;
5813                     LABEL_NUSES (olabel)++;
5814                   }
5815                 if (! bp)
5816                   {
5817                     bp = (struct far_branch *) alloca (sizeof *bp);
5818                     uid_branch[dest_uid] = bp;
5819                     bp->prev = far_branch_list;
5820                     far_branch_list = bp;
5821                     bp->far_label
5822                       = XEXP (XEXP (SET_SRC (PATTERN (insn)), 1), 0);
5823                     LABEL_NUSES (bp->far_label)++;
5824                   }
5825                 else
5826                   {
5827                     label = bp->near_label;
5828                     if (! label && bp->address - addr >= CONDJUMP_MIN)
5829                       {
5830                         rtx block = bp->insert_place;
5831
5832                         if (GET_CODE (PATTERN (block)) == RETURN)
5833                           block = PREV_INSN (block);
5834                         else
5835                           block = gen_block_redirect (block,
5836                                                       bp->address, 2);
5837                         label = emit_label_after (gen_label_rtx (),
5838                                                   PREV_INSN (block));
5839                         bp->near_label = label;
5840                       }
5841                     else if (label && ! NEXT_INSN (label))
5842                       {
5843                         if (addr + 2 - bp->address <= CONDJUMP_MAX)
5844                           bp->insert_place = insn;
5845                         else
5846                           gen_far_branch (bp);
5847                       }
5848                   }
5849                 if (! label
5850                     || (NEXT_INSN (label) && bp->address - addr < CONDJUMP_MIN))
5851                   {
5852                     bp->near_label = label = gen_label_rtx ();
5853                     bp->insert_place = insn;
5854                     bp->address = addr;
5855                   }
5856                 ok = redirect_jump (insn, label, 0);
5857                 gcc_assert (ok);
5858               }
5859             else
5860               {
5861                 /* get_attr_length (insn) == 2 */
5862                 /* Check if we have a pattern where reorg wants to redirect
5863                    the branch to a label from an unconditional branch that
5864                    is too far away.  */
5865                 /* We can't use JUMP_LABEL here because it might be undefined
5866                    when not optimizing.  */
5867                 /* A syntax error might cause beyond to be NULL_RTX.  */
5868                 beyond
5869                   = next_active_insn (XEXP (XEXP (SET_SRC (PATTERN (insn)), 1),
5870                                             0));
5871
5872                 if (beyond
5873                     && (JUMP_P (beyond)
5874                         || ((beyond = next_active_insn (beyond))
5875                             && JUMP_P (beyond)))
5876                     && GET_CODE (PATTERN (beyond)) == SET
5877                     && recog_memoized (beyond) == CODE_FOR_jump_compact
5878                     && ((INSN_ADDRESSES
5879                          (INSN_UID (XEXP (SET_SRC (PATTERN (beyond)), 0)))
5880                          - INSN_ADDRESSES (INSN_UID (insn)) + (unsigned) 252)
5881                         > 252 + 258 + 2))
5882                   gen_block_redirect (beyond,
5883                                       INSN_ADDRESSES (INSN_UID (beyond)), 1);
5884               }
5885
5886             next = next_active_insn (insn);
5887
5888             if (next
5889                 && (JUMP_P (next)
5890                     || ((next = next_active_insn (next))
5891                         && JUMP_P (next)))
5892                 && GET_CODE (PATTERN (next)) == SET
5893                 && recog_memoized (next) == CODE_FOR_jump_compact
5894                 && ((INSN_ADDRESSES
5895                      (INSN_UID (XEXP (SET_SRC (PATTERN (next)), 0)))
5896                      - INSN_ADDRESSES (INSN_UID (insn)) + (unsigned) 252)
5897                     > 252 + 258 + 2))
5898               gen_block_redirect (next, INSN_ADDRESSES (INSN_UID (next)), 1);
5899           }
5900         else if (type == TYPE_JUMP || type == TYPE_RETURN)
5901           {
5902             int addr = INSN_ADDRESSES (INSN_UID (insn));
5903             rtx far_label = 0;
5904             int dest_uid = 0;
5905             struct far_branch *bp;
5906
5907             if (type == TYPE_JUMP)
5908               {
5909                 far_label = XEXP (SET_SRC (PATTERN (insn)), 0);
5910                 dest_uid = get_dest_uid (far_label, max_uid);
5911                 if (! dest_uid)
5912                   {
5913                     /* Parse errors can lead to labels outside
5914                       the insn stream.  */
5915                     if (! NEXT_INSN (far_label))
5916                       continue;
5917
5918                     if (! optimize)
5919                       {
5920                         JUMP_LABEL (insn) = far_label;
5921                         LABEL_NUSES (far_label)++;
5922                       }
5923                     redirect_jump (insn, NULL_RTX, 1);
5924                     far_label = 0;
5925                   }
5926               }
5927             bp = uid_branch[dest_uid];
5928             if (! bp)
5929               {
5930                 bp = (struct far_branch *) alloca (sizeof *bp);
5931                 uid_branch[dest_uid] = bp;
5932                 bp->prev = far_branch_list;
5933                 far_branch_list = bp;
5934                 bp->near_label = 0;
5935                 bp->far_label = far_label;
5936                 if (far_label)
5937                   LABEL_NUSES (far_label)++;
5938               }
5939             else if (bp->near_label && ! NEXT_INSN (bp->near_label))
5940               if (addr - bp->address <= CONDJUMP_MAX)
5941                 emit_label_after (bp->near_label, PREV_INSN (insn));
5942               else
5943                 {
5944                   gen_far_branch (bp);
5945                   bp->near_label = 0;
5946                 }
5947             else
5948               bp->near_label = 0;
5949             bp->address = addr;
5950             bp->insert_place = insn;
5951             if (! far_label)
5952               emit_insn_before (gen_block_branch_redirect (const0_rtx), insn);
5953             else
5954               gen_block_redirect (insn, addr, bp->near_label ? 2 : 0);
5955           }
5956       }
5957   /* Generate all pending far branches,
5958      and free our references to the far labels.  */
5959   while (far_branch_list)
5960     {
5961       if (far_branch_list->near_label
5962           && ! NEXT_INSN (far_branch_list->near_label))
5963         gen_far_branch (far_branch_list);
5964       if (optimize
5965           && far_branch_list->far_label
5966           && ! --LABEL_NUSES (far_branch_list->far_label))
5967         delete_insn (far_branch_list->far_label);
5968       far_branch_list = far_branch_list->prev;
5969     }
5970
5971   /* Instruction length information is no longer valid due to the new
5972      instructions that have been generated.  */
5973   init_insn_lengths ();
5974 }
5975
5976 /* Dump out instruction addresses, which is useful for debugging the
5977    constant pool table stuff.
5978
5979    If relaxing, output the label and pseudo-ops used to link together
5980    calls and the instruction which set the registers.  */
5981
5982 /* ??? The addresses printed by this routine for insns are nonsense for
5983    insns which are inside of a sequence where none of the inner insns have
5984    variable length.  This is because the second pass of shorten_branches
5985    does not bother to update them.  */
5986
5987 void
5988 final_prescan_insn (rtx insn, rtx *opvec ATTRIBUTE_UNUSED,
5989                     int noperands ATTRIBUTE_UNUSED)
5990 {
5991   if (TARGET_DUMPISIZE)
5992     fprintf (asm_out_file, "\n! at %04x\n", INSN_ADDRESSES (INSN_UID (insn)));
5993
5994   if (TARGET_RELAX)
5995     {
5996       rtx note;
5997
5998       note = find_reg_note (insn, REG_LABEL_OPERAND, NULL_RTX);
5999       if (note)
6000         {
6001           rtx pattern;
6002
6003           pattern = PATTERN (insn);
6004           if (GET_CODE (pattern) == PARALLEL)
6005             pattern = XVECEXP (pattern, 0, 0);
6006           switch (GET_CODE (pattern))
6007             {
6008             case SET:
6009               if (GET_CODE (SET_SRC (pattern)) != CALL
6010                   && get_attr_type (insn) != TYPE_SFUNC)
6011                 {
6012                   targetm.asm_out.internal_label
6013                     (asm_out_file, "L", CODE_LABEL_NUMBER (XEXP (note, 0)));
6014                   break;
6015                 }
6016               /* else FALLTHROUGH */
6017             case CALL:
6018               asm_fprintf (asm_out_file, "\t.uses %LL%d\n",
6019                            CODE_LABEL_NUMBER (XEXP (note, 0)));
6020               break;
6021
6022             default:
6023               gcc_unreachable ();
6024             }
6025         }
6026     }
6027 }
6028
6029 /* Dump out any constants accumulated in the final pass.  These will
6030    only be labels.  */
6031
6032 const char *
6033 output_jump_label_table (void)
6034 {
6035   int i;
6036
6037   if (pool_size)
6038     {
6039       fprintf (asm_out_file, "\t.align 2\n");
6040       for (i = 0; i < pool_size; i++)
6041         {
6042           pool_node *p = &pool_vector[i];
6043
6044           (*targetm.asm_out.internal_label) (asm_out_file, "L",
6045                                      CODE_LABEL_NUMBER (p->label));
6046           output_asm_insn (".long       %O0", &p->value);
6047         }
6048       pool_size = 0;
6049     }
6050
6051   return "";
6052 }
6053 \f
6054 /* A full frame looks like:
6055
6056    arg-5
6057    arg-4
6058    [ if current_function_anonymous_args
6059    arg-3
6060    arg-2
6061    arg-1
6062    arg-0 ]
6063    saved-fp
6064    saved-r10
6065    saved-r11
6066    saved-r12
6067    saved-pr
6068    local-n
6069    ..
6070    local-1
6071    local-0        <- fp points here.  */
6072
6073 /* Number of bytes pushed for anonymous args, used to pass information
6074    between expand_prologue and expand_epilogue.  */
6075
6076 /* Adjust the stack by SIZE bytes.  REG holds the rtl of the register to be
6077    adjusted.  If epilogue_p is zero, this is for a prologue; otherwise, it's
6078    for an epilogue and a negative value means that it's for a sibcall
6079    epilogue.  If LIVE_REGS_MASK is nonzero, it points to a HARD_REG_SET of
6080    all the registers that are about to be restored, and hence dead.  */
6081
6082 static void
6083 output_stack_adjust (int size, rtx reg, int epilogue_p,
6084                      HARD_REG_SET *live_regs_mask, bool frame_p)
6085 {
6086   rtx (*emit_fn) (rtx) = frame_p ? &frame_insn : &emit_insn;
6087   if (size)
6088     {
6089       HOST_WIDE_INT align = STACK_BOUNDARY / BITS_PER_UNIT;
6090
6091 /* This test is bogus, as output_stack_adjust is used to re-align the
6092    stack.  */
6093 #if 0
6094       gcc_assert (!(size % align));
6095 #endif
6096
6097       if (CONST_OK_FOR_ADD (size))
6098         emit_fn (GEN_ADD3 (reg, reg, GEN_INT (size)));
6099       /* Try to do it with two partial adjustments; however, we must make
6100          sure that the stack is properly aligned at all times, in case
6101          an interrupt occurs between the two partial adjustments.  */
6102       else if (CONST_OK_FOR_ADD (size / 2 & -align)
6103                && CONST_OK_FOR_ADD (size - (size / 2 & -align)))
6104         {
6105           emit_fn (GEN_ADD3 (reg, reg, GEN_INT (size / 2 & -align)));
6106           emit_fn (GEN_ADD3 (reg, reg, GEN_INT (size - (size / 2 & -align))));
6107         }
6108       else
6109         {
6110           rtx const_reg;
6111           rtx insn;
6112           int temp = epilogue_p ? 7 : (TARGET_SH5 ? 0 : 1);
6113           int i;
6114
6115           /* If TEMP is invalid, we could temporarily save a general
6116              register to MACL.  However, there is currently no need
6117              to handle this case, so just die when we see it.  */
6118           if (epilogue_p < 0
6119               || current_function_interrupt
6120               || ! call_really_used_regs[temp] || fixed_regs[temp])
6121             temp = -1;
6122           if (temp < 0 && ! current_function_interrupt
6123               && (TARGET_SHMEDIA || epilogue_p >= 0))
6124             {
6125               HARD_REG_SET temps;
6126               COPY_HARD_REG_SET (temps, call_used_reg_set);
6127               AND_COMPL_HARD_REG_SET (temps, call_fixed_reg_set);
6128               if (epilogue_p > 0)
6129                 {
6130                   int nreg = 0;
6131                   if (crtl->return_rtx)
6132                     {
6133                       enum machine_mode mode;
6134                       mode = GET_MODE (crtl->return_rtx);
6135                       if (BASE_RETURN_VALUE_REG (mode) == FIRST_RET_REG)
6136                         nreg = HARD_REGNO_NREGS (FIRST_RET_REG, mode);
6137                     }
6138                   for (i = 0; i < nreg; i++)
6139                     CLEAR_HARD_REG_BIT (temps, FIRST_RET_REG + i);
6140                   if (crtl->calls_eh_return)
6141                     {
6142                       CLEAR_HARD_REG_BIT (temps, EH_RETURN_STACKADJ_REGNO);
6143                       for (i = 0; i <= 3; i++)
6144                         CLEAR_HARD_REG_BIT (temps, EH_RETURN_DATA_REGNO (i));
6145                     }
6146                 }
6147               if (TARGET_SHMEDIA && epilogue_p < 0)
6148                 for (i = FIRST_TARGET_REG; i <= LAST_TARGET_REG; i++)
6149                   CLEAR_HARD_REG_BIT (temps, i);
6150               if (epilogue_p <= 0)
6151                 {
6152                   for (i = FIRST_PARM_REG;
6153                        i < FIRST_PARM_REG + NPARM_REGS (SImode); i++)
6154                     CLEAR_HARD_REG_BIT (temps, i);
6155                   if (cfun->static_chain_decl != NULL)
6156                     CLEAR_HARD_REG_BIT (temps, STATIC_CHAIN_REGNUM);
6157                 }
6158               temp = scavenge_reg (&temps);
6159             }
6160           if (temp < 0 && live_regs_mask)
6161             {
6162               HARD_REG_SET temps;
6163
6164               COPY_HARD_REG_SET (temps, *live_regs_mask);
6165               CLEAR_HARD_REG_BIT (temps, REGNO (reg));
6166               temp = scavenge_reg (&temps);
6167             }
6168           if (temp < 0)
6169             {
6170               rtx adj_reg, tmp_reg, mem;
6171
6172               /* If we reached here, the most likely case is the (sibcall)
6173                  epilogue for non SHmedia.  Put a special push/pop sequence
6174                  for such case as the last resort.  This looks lengthy but
6175                  would not be problem because it seems to be very
6176                  rare.  */
6177
6178               gcc_assert (!TARGET_SHMEDIA && epilogue_p);
6179
6180
6181                /* ??? There is still the slight possibility that r4 or
6182                   r5 have been reserved as fixed registers or assigned
6183                   as global registers, and they change during an
6184                   interrupt.  There are possible ways to handle this:
6185
6186                   - If we are adjusting the frame pointer (r14), we can do
6187                     with a single temp register and an ordinary push / pop
6188                     on the stack.
6189                   - Grab any call-used or call-saved registers (i.e. not
6190                     fixed or globals) for the temps we need.  We might
6191                     also grab r14 if we are adjusting the stack pointer.
6192                     If we can't find enough available registers, issue
6193                     a diagnostic and die - the user must have reserved
6194                     way too many registers.
6195                  But since all this is rather unlikely to happen and
6196                  would require extra testing, we just die if r4 / r5
6197                  are not available.  */
6198               gcc_assert (!fixed_regs[4] && !fixed_regs[5]
6199                           && !global_regs[4] && !global_regs[5]);
6200
6201               adj_reg = gen_rtx_REG (GET_MODE (reg), 4);
6202               tmp_reg = gen_rtx_REG (GET_MODE (reg), 5);
6203               emit_move_insn (gen_tmp_stack_mem (Pmode, reg), adj_reg);
6204               emit_insn (GEN_MOV (adj_reg, GEN_INT (size)));
6205               emit_insn (GEN_ADD3 (adj_reg, adj_reg, reg));
6206               mem = gen_tmp_stack_mem (Pmode, gen_rtx_PRE_DEC (Pmode, adj_reg));
6207               emit_move_insn (mem, tmp_reg);
6208               emit_move_insn (tmp_reg, gen_tmp_stack_mem (Pmode, reg));
6209               mem = gen_tmp_stack_mem (Pmode, gen_rtx_PRE_DEC (Pmode, adj_reg));
6210               emit_move_insn (mem, tmp_reg);
6211               emit_move_insn (reg, adj_reg);
6212               mem = gen_tmp_stack_mem (Pmode, gen_rtx_POST_INC (Pmode, reg));
6213               emit_move_insn (adj_reg, mem);
6214               mem = gen_tmp_stack_mem (Pmode, gen_rtx_POST_INC (Pmode, reg));
6215               emit_move_insn (tmp_reg, mem);
6216               /* Tell flow the insns that pop r4/r5 aren't dead.  */
6217               emit_use (tmp_reg);
6218               emit_use (adj_reg);
6219               return;
6220             }
6221           const_reg = gen_rtx_REG (GET_MODE (reg), temp);
6222
6223           /* If SIZE is negative, subtract the positive value.
6224              This sometimes allows a constant pool entry to be shared
6225              between prologue and epilogue code.  */
6226           if (size < 0)
6227             {
6228               emit_insn (GEN_MOV (const_reg, GEN_INT (-size)));
6229               insn = emit_fn (GEN_SUB3 (reg, reg, const_reg));
6230             }
6231           else
6232             {
6233               emit_insn (GEN_MOV (const_reg, GEN_INT (size)));
6234               insn = emit_fn (GEN_ADD3 (reg, reg, const_reg));
6235             }
6236           if (! epilogue_p)
6237             add_reg_note (insn, REG_FRAME_RELATED_EXPR,
6238                           gen_rtx_SET (VOIDmode, reg,
6239                                        gen_rtx_PLUS (SImode, reg,
6240                                                      GEN_INT (size))));
6241         }
6242     }
6243 }
6244
6245 static rtx
6246 frame_insn (rtx x)
6247 {
6248   x = emit_insn (x);
6249   RTX_FRAME_RELATED_P (x) = 1;
6250   return x;
6251 }
6252
6253 /* Output RTL to push register RN onto the stack.  */
6254
6255 static rtx
6256 push (int rn)
6257 {
6258   rtx x;
6259   if (rn == FPUL_REG)
6260     x = gen_push_fpul ();
6261   else if (rn == FPSCR_REG)
6262     x = gen_push_fpscr ();
6263   else if ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && TARGET_FMOVD && ! TARGET_FPU_SINGLE
6264            && FP_OR_XD_REGISTER_P (rn))
6265     {
6266       if (FP_REGISTER_P (rn) && (rn - FIRST_FP_REG) & 1)
6267         return NULL_RTX;
6268       x = gen_push_4 (gen_rtx_REG (DFmode, rn));
6269     }
6270   else if (TARGET_SH2E && FP_REGISTER_P (rn))
6271     x = gen_push_e (gen_rtx_REG (SFmode, rn));
6272   else
6273     x = gen_push (gen_rtx_REG (SImode, rn));
6274
6275   x = frame_insn (x);
6276   add_reg_note (x, REG_INC, gen_rtx_REG (SImode, STACK_POINTER_REGNUM));
6277   return x;
6278 }
6279
6280 /* Output RTL to pop register RN from the stack.  */
6281
6282 static void
6283 pop (int rn)
6284 {
6285   rtx x;
6286   if (rn == FPUL_REG)
6287     x = gen_pop_fpul ();
6288   else if (rn == FPSCR_REG)
6289     x = gen_pop_fpscr ();
6290   else if ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && TARGET_FMOVD && ! TARGET_FPU_SINGLE
6291            && FP_OR_XD_REGISTER_P (rn))
6292     {
6293       if (FP_REGISTER_P (rn) && (rn - FIRST_FP_REG) & 1)
6294         return;
6295       x = gen_pop_4 (gen_rtx_REG (DFmode, rn));
6296     }
6297   else if (TARGET_SH2E && FP_REGISTER_P (rn))
6298     x = gen_pop_e (gen_rtx_REG (SFmode, rn));
6299   else
6300     x = gen_pop (gen_rtx_REG (SImode, rn));
6301
6302   x = emit_insn (x);
6303   add_reg_note (x, REG_INC, gen_rtx_REG (SImode, STACK_POINTER_REGNUM));
6304 }
6305
6306 /* Generate code to push the regs specified in the mask.  */
6307
6308 static void
6309 push_regs (HARD_REG_SET *mask, int interrupt_handler)
6310 {
6311   int i = interrupt_handler ? LAST_BANKED_REG + 1 : 0;
6312   int skip_fpscr = 0;
6313
6314   /* Push PR last; this gives better latencies after the prologue, and
6315      candidates for the return delay slot when there are no general
6316      registers pushed.  */
6317   for (; i < FIRST_PSEUDO_REGISTER; i++)
6318     {
6319       /* If this is an interrupt handler, and the SZ bit varies,
6320          and we have to push any floating point register, we need
6321          to switch to the correct precision first.  */
6322       if (i == FIRST_FP_REG && interrupt_handler && TARGET_FMOVD
6323           && hard_reg_set_intersect_p (*mask, reg_class_contents[DF_REGS]))
6324         {
6325           HARD_REG_SET unsaved;
6326
6327           push (FPSCR_REG);
6328           COMPL_HARD_REG_SET (unsaved, *mask);
6329           fpscr_set_from_mem (NORMAL_MODE (FP_MODE), unsaved);
6330           skip_fpscr = 1;
6331         }
6332       if (i != PR_REG
6333           && (i != FPSCR_REG || ! skip_fpscr)
6334           && TEST_HARD_REG_BIT (*mask, i))
6335            {
6336         /* If the ISR has RESBANK attribute assigned, don't push any of
6337            the following registers - R0-R14, MACH, MACL and GBR.  */
6338       if (! (sh_cfun_resbank_handler_p ()
6339              && ((i >= FIRST_GENERAL_REG && i < LAST_GENERAL_REG)
6340                  || i == MACH_REG
6341                  || i == MACL_REG
6342                  || i == GBR_REG)))
6343           push (i);
6344         }
6345     }
6346
6347   /* Push banked registers last to improve delay slot opportunities.  */
6348   if (interrupt_handler)
6349     for (i = FIRST_BANKED_REG; i <= LAST_BANKED_REG; i++)
6350       if (TEST_HARD_REG_BIT (*mask, i))
6351         push (i);
6352
6353   /* Don't push PR register for an ISR with RESBANK attribute assigned.  */
6354   if (TEST_HARD_REG_BIT (*mask, PR_REG) && !sh_cfun_resbank_handler_p ())
6355     push (PR_REG);
6356 }
6357
6358 /* Calculate how much extra space is needed to save all callee-saved
6359    target registers.
6360    LIVE_REGS_MASK is the register mask calculated by calc_live_regs.  */
6361
6362 static int
6363 shmedia_target_regs_stack_space (HARD_REG_SET *live_regs_mask)
6364 {
6365   int reg;
6366   int stack_space = 0;
6367   int interrupt_handler = sh_cfun_interrupt_handler_p ();
6368
6369   for (reg = LAST_TARGET_REG; reg >= FIRST_TARGET_REG; reg--)
6370     if ((! call_really_used_regs[reg] || interrupt_handler)
6371         && ! TEST_HARD_REG_BIT (*live_regs_mask, reg))
6372       /* Leave space to save this target register on the stack,
6373          in case target register allocation wants to use it.  */
6374       stack_space += GET_MODE_SIZE (REGISTER_NATURAL_MODE (reg));
6375   return stack_space;
6376 }
6377
6378 /* Decide whether we should reserve space for callee-save target registers,
6379    in case target register allocation wants to use them.  REGS_SAVED is
6380    the space, in bytes, that is already required for register saves.
6381    LIVE_REGS_MASK is the register mask calculated by calc_live_regs.  */
6382
6383 static int
6384 shmedia_reserve_space_for_target_registers_p (int regs_saved,
6385                                               HARD_REG_SET *live_regs_mask)
6386 {
6387   if (optimize_size)
6388     return 0;
6389   return shmedia_target_regs_stack_space (live_regs_mask) <= regs_saved;
6390 }
6391
6392 /* Decide how much space to reserve for callee-save target registers
6393    in case target register allocation wants to use them.
6394    LIVE_REGS_MASK is the register mask calculated by calc_live_regs.  */
6395
6396 static int
6397 shmedia_target_regs_stack_adjust (HARD_REG_SET *live_regs_mask)
6398 {
6399   if (shmedia_space_reserved_for_target_registers)
6400     return shmedia_target_regs_stack_space (live_regs_mask);
6401   else
6402     return 0;
6403 }
6404
6405 /* Work out the registers which need to be saved, both as a mask and a
6406    count of saved words.  Return the count.
6407
6408    If doing a pragma interrupt function, then push all regs used by the
6409    function, and if we call another function (we can tell by looking at PR),
6410    make sure that all the regs it clobbers are safe too.  */
6411
6412 static int
6413 calc_live_regs (HARD_REG_SET *live_regs_mask)
6414 {
6415   unsigned int reg;
6416   int count;
6417   tree attrs;
6418   bool interrupt_or_trapa_handler, trapa_handler, interrupt_handler;
6419   bool nosave_low_regs;
6420   int pr_live, has_call;
6421
6422   attrs = DECL_ATTRIBUTES (current_function_decl);
6423   interrupt_or_trapa_handler = sh_cfun_interrupt_handler_p ();
6424   trapa_handler = lookup_attribute ("trapa_handler", attrs) != NULL_TREE;
6425   interrupt_handler = interrupt_or_trapa_handler && ! trapa_handler;
6426   nosave_low_regs = lookup_attribute ("nosave_low_regs", attrs) != NULL_TREE;
6427
6428   CLEAR_HARD_REG_SET (*live_regs_mask);
6429   if ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && TARGET_FMOVD && interrupt_handler
6430       && df_regs_ever_live_p (FPSCR_REG))
6431     target_flags &= ~MASK_FPU_SINGLE;
6432   /* If we can save a lot of saves by switching to double mode, do that.  */
6433   else if ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && TARGET_FMOVD && TARGET_FPU_SINGLE)
6434     for (count = 0, reg = FIRST_FP_REG; reg <= LAST_FP_REG; reg += 2)
6435       if (df_regs_ever_live_p (reg) && df_regs_ever_live_p (reg+1)
6436           && (! call_really_used_regs[reg]
6437               || interrupt_handler)
6438           && ++count > 2)
6439         {
6440           target_flags &= ~MASK_FPU_SINGLE;
6441           break;
6442         }
6443   /* PR_MEDIA_REG is a general purpose register, thus global_alloc already
6444      knows how to use it.  That means the pseudo originally allocated for
6445      the initial value can become the PR_MEDIA_REG hard register, as seen for
6446      execute/20010122-1.c:test9.  */
6447   if (TARGET_SHMEDIA)
6448     /* ??? this function is called from initial_elimination_offset, hence we
6449        can't use the result of sh_media_register_for_return here.  */
6450     pr_live = sh_pr_n_sets ();
6451   else
6452     {
6453       rtx pr_initial = has_hard_reg_initial_val (Pmode, PR_REG);
6454       pr_live = (pr_initial
6455                  ? (!REG_P (pr_initial)
6456                     || REGNO (pr_initial) != (PR_REG))
6457                  : df_regs_ever_live_p (PR_REG));
6458       /* For Shcompact, if not optimizing, we end up with a memory reference
6459          using the return address pointer for __builtin_return_address even
6460          though there is no actual need to put the PR register on the stack.  */
6461       pr_live |= df_regs_ever_live_p (RETURN_ADDRESS_POINTER_REGNUM);
6462     }
6463   /* Force PR to be live if the prologue has to call the SHmedia
6464      argument decoder or register saver.  */
6465   if (TARGET_SHCOMPACT
6466       && ((crtl->args.info.call_cookie
6467            & ~ CALL_COOKIE_RET_TRAMP (1))
6468           || crtl->saves_all_registers))
6469     pr_live = 1;
6470   has_call = TARGET_SHMEDIA ? ! leaf_function_p () : pr_live;
6471   for (count = 0, reg = FIRST_PSEUDO_REGISTER; reg-- != 0; )
6472     {
6473       if (reg == (TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG)
6474           ? pr_live
6475           : interrupt_handler
6476           ? (/* Need to save all the regs ever live.  */
6477              (df_regs_ever_live_p (reg)
6478               || (call_really_used_regs[reg]
6479                   && (! fixed_regs[reg] || reg == MACH_REG || reg == MACL_REG
6480                       || reg == PIC_OFFSET_TABLE_REGNUM)
6481                   && has_call)
6482               || (TARGET_SHMEDIA && has_call
6483                   && REGISTER_NATURAL_MODE (reg) == SImode
6484                   && (GENERAL_REGISTER_P (reg) || TARGET_REGISTER_P (reg))))
6485              && reg != STACK_POINTER_REGNUM && reg != ARG_POINTER_REGNUM
6486              && reg != RETURN_ADDRESS_POINTER_REGNUM
6487              && reg != T_REG && reg != GBR_REG
6488              /* Push fpscr only on targets which have FPU */
6489              && (reg != FPSCR_REG || TARGET_FPU_ANY))
6490           : (/* Only push those regs which are used and need to be saved.  */
6491              (TARGET_SHCOMPACT
6492               && flag_pic
6493               && crtl->args.info.call_cookie
6494               && reg == PIC_OFFSET_TABLE_REGNUM)
6495              || (df_regs_ever_live_p (reg)
6496                  && ((!call_really_used_regs[reg]
6497                       && !(reg != PIC_OFFSET_TABLE_REGNUM
6498                            && fixed_regs[reg] && call_used_regs[reg]))
6499                      || (trapa_handler && reg == FPSCR_REG && TARGET_FPU_ANY)))
6500              || (crtl->calls_eh_return
6501                  && (reg == EH_RETURN_DATA_REGNO (0)
6502                      || reg == EH_RETURN_DATA_REGNO (1)
6503                      || reg == EH_RETURN_DATA_REGNO (2)
6504                      || reg == EH_RETURN_DATA_REGNO (3)))
6505              || ((reg == MACL_REG || reg == MACH_REG)
6506                  && df_regs_ever_live_p (reg)
6507                  && sh_cfun_attr_renesas_p ())
6508              ))
6509         {
6510           SET_HARD_REG_BIT (*live_regs_mask, reg);
6511           count += GET_MODE_SIZE (REGISTER_NATURAL_MODE (reg));
6512
6513           if ((TARGET_SH4 || TARGET_SH2A_DOUBLE || TARGET_SH5) && TARGET_FMOVD
6514               && GET_MODE_CLASS (REGISTER_NATURAL_MODE (reg)) == MODE_FLOAT)
6515             {
6516               if (FP_REGISTER_P (reg))
6517                 {
6518                   if (! TARGET_FPU_SINGLE && ! df_regs_ever_live_p (reg ^ 1))
6519                     {
6520                       SET_HARD_REG_BIT (*live_regs_mask, (reg ^ 1));
6521                       count += GET_MODE_SIZE (REGISTER_NATURAL_MODE (reg ^ 1));
6522                     }
6523                 }
6524               else if (XD_REGISTER_P (reg))
6525                 {
6526                   /* Must switch to double mode to access these registers.  */
6527                   target_flags &= ~MASK_FPU_SINGLE;
6528                 }
6529             }
6530         }
6531       if (nosave_low_regs && reg == R8_REG)
6532         break;
6533     }
6534   /* If we have a target register optimization pass after prologue / epilogue
6535      threading, we need to assume all target registers will be live even if
6536      they aren't now.  */
6537   if (flag_branch_target_load_optimize2
6538       && TARGET_SAVE_ALL_TARGET_REGS
6539       && shmedia_space_reserved_for_target_registers)
6540     for (reg = LAST_TARGET_REG; reg >= FIRST_TARGET_REG; reg--)
6541       if ((! call_really_used_regs[reg] || interrupt_handler)
6542           && ! TEST_HARD_REG_BIT (*live_regs_mask, reg))
6543         {
6544           SET_HARD_REG_BIT (*live_regs_mask, reg);
6545           count += GET_MODE_SIZE (REGISTER_NATURAL_MODE (reg));
6546         }
6547   /* If this is an interrupt handler, we don't have any call-clobbered
6548      registers we can conveniently use for target register save/restore.
6549      Make sure we save at least one general purpose register when we need
6550      to save target registers.  */
6551   if (interrupt_handler
6552       && hard_reg_set_intersect_p (*live_regs_mask,
6553                                    reg_class_contents[TARGET_REGS])
6554       && ! hard_reg_set_intersect_p (*live_regs_mask,
6555                                      reg_class_contents[GENERAL_REGS]))
6556     {
6557       SET_HARD_REG_BIT (*live_regs_mask, R0_REG);
6558       count += GET_MODE_SIZE (REGISTER_NATURAL_MODE (R0_REG));
6559     }
6560
6561   return count;
6562 }
6563
6564 /* Code to generate prologue and epilogue sequences */
6565
6566 /* PUSHED is the number of bytes that are being pushed on the
6567    stack for register saves.  Return the frame size, padded
6568    appropriately so that the stack stays properly aligned.  */
6569 static HOST_WIDE_INT
6570 rounded_frame_size (int pushed)
6571 {
6572   HOST_WIDE_INT size = get_frame_size ();
6573   HOST_WIDE_INT align = STACK_BOUNDARY / BITS_PER_UNIT;
6574
6575   return ((size + pushed + align - 1) & -align) - pushed;
6576 }
6577
6578 /* Choose a call-clobbered target-branch register that remains
6579    unchanged along the whole function.  We set it up as the return
6580    value in the prologue.  */
6581 int
6582 sh_media_register_for_return (void)
6583 {
6584   int regno;
6585   int tr0_used;
6586
6587   if (! current_function_is_leaf)
6588     return -1;
6589   if (lookup_attribute ("interrupt_handler",
6590                         DECL_ATTRIBUTES (current_function_decl)))
6591     return -1;
6592   if (sh_cfun_interrupt_handler_p ())
6593     return -1;
6594
6595   tr0_used = flag_pic && df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM);
6596
6597   for (regno = FIRST_TARGET_REG + tr0_used; regno <= LAST_TARGET_REG; regno++)
6598     if (call_really_used_regs[regno] && ! df_regs_ever_live_p (regno))
6599       return regno;
6600
6601   return -1;
6602 }
6603
6604 /* The maximum registers we need to save are:
6605    - 62 general purpose registers (r15 is stack pointer, r63 is zero)
6606    - 32 floating point registers (for each pair, we save none,
6607          one single precision value, or a double precision value).
6608    -  8 target registers
6609    -  add 1 entry for a delimiter.  */
6610 #define MAX_SAVED_REGS (62+32+8)
6611
6612 typedef struct save_entry_s
6613 {
6614   unsigned char reg;
6615   unsigned char mode;
6616   short offset;
6617 } save_entry;
6618
6619 #define MAX_TEMPS 4
6620
6621 /* There will be a delimiter entry with VOIDmode both at the start and the
6622    end of a filled in schedule.  The end delimiter has the offset of the
6623    save with the smallest (i.e. most negative) offset.  */
6624 typedef struct save_schedule_s
6625 {
6626   save_entry entries[MAX_SAVED_REGS + 2];
6627   int temps[MAX_TEMPS+1];
6628 } save_schedule;
6629
6630 /* Fill in SCHEDULE according to LIVE_REGS_MASK.  If RESTORE is nonzero,
6631    use reverse order.  Returns the last entry written to (not counting
6632    the delimiter).  OFFSET_BASE is a number to be added to all offset
6633    entries.  */
6634
6635 static save_entry *
6636 sh5_schedule_saves (HARD_REG_SET *live_regs_mask, save_schedule *schedule,
6637                     int offset_base)
6638 {
6639   int align, i;
6640   save_entry *entry = schedule->entries;
6641   int tmpx = 0;
6642   int offset;
6643
6644   if (! current_function_interrupt)
6645     for (i = FIRST_GENERAL_REG; tmpx < MAX_TEMPS && i <= LAST_GENERAL_REG; i++)
6646       if (call_really_used_regs[i] && ! fixed_regs[i] && i != PR_MEDIA_REG
6647           && ! FUNCTION_ARG_REGNO_P (i)
6648           && i != FIRST_RET_REG
6649           && ! (cfun->static_chain_decl != NULL && i == STATIC_CHAIN_REGNUM)
6650           && ! (crtl->calls_eh_return
6651                 && (i == EH_RETURN_STACKADJ_REGNO
6652                     || ((unsigned) i >= EH_RETURN_DATA_REGNO (0)
6653                         && (unsigned) i <= EH_RETURN_DATA_REGNO (3)))))
6654         schedule->temps[tmpx++] = i;
6655   entry->reg = -1;
6656   entry->mode = VOIDmode;
6657   entry->offset = offset_base;
6658   entry++;
6659   /* We loop twice: first, we save 8-byte aligned registers in the
6660      higher addresses, that are known to be aligned.  Then, we
6661      proceed to saving 32-bit registers that don't need 8-byte
6662      alignment.
6663      If this is an interrupt function, all registers that need saving
6664      need to be saved in full.  moreover, we need to postpone saving
6665      target registers till we have saved some general purpose registers
6666      we can then use as scratch registers.  */
6667   offset = offset_base;
6668   for (align = 1; align >= 0; align--)
6669     {
6670       for (i = FIRST_PSEUDO_REGISTER - 1; i >= 0; i--)
6671         if (TEST_HARD_REG_BIT (*live_regs_mask, i))
6672           {
6673             enum machine_mode mode = REGISTER_NATURAL_MODE (i);
6674             int reg = i;
6675
6676             if (current_function_interrupt)
6677               {
6678                 if (TARGET_REGISTER_P (i))
6679                   continue;
6680                 if (GENERAL_REGISTER_P (i))
6681                   mode = DImode;
6682               }
6683             if (mode == SFmode && (i % 2) == 1
6684                 && ! TARGET_FPU_SINGLE && FP_REGISTER_P (i)
6685                 && (TEST_HARD_REG_BIT (*live_regs_mask, (i ^ 1))))
6686               {
6687                 mode = DFmode;
6688                 i--;
6689                 reg--;
6690               }
6691
6692             /* If we're doing the aligned pass and this is not aligned,
6693                or we're doing the unaligned pass and this is aligned,
6694                skip it.  */
6695             if ((GET_MODE_SIZE (mode) % (STACK_BOUNDARY / BITS_PER_UNIT) == 0)
6696                 != align)
6697               continue;
6698
6699             if (current_function_interrupt
6700                 && GENERAL_REGISTER_P (i)
6701                 && tmpx < MAX_TEMPS)
6702               schedule->temps[tmpx++] = i;
6703
6704             offset -= GET_MODE_SIZE (mode);
6705             entry->reg = i;
6706             entry->mode = mode;
6707             entry->offset = offset;
6708             entry++;
6709           }
6710       if (align && current_function_interrupt)
6711         for (i = LAST_TARGET_REG; i >= FIRST_TARGET_REG; i--)
6712           if (TEST_HARD_REG_BIT (*live_regs_mask, i))
6713             {
6714               offset -= GET_MODE_SIZE (DImode);
6715               entry->reg = i;
6716               entry->mode = DImode;
6717               entry->offset = offset;
6718               entry++;
6719             }
6720     }
6721   entry->reg = -1;
6722   entry->mode = VOIDmode;
6723   entry->offset = offset;
6724   schedule->temps[tmpx] = -1;
6725   return entry - 1;
6726 }
6727
6728 void
6729 sh_expand_prologue (void)
6730 {
6731   HARD_REG_SET live_regs_mask;
6732   int d, i;
6733   int d_rounding = 0;
6734   int save_flags = target_flags;
6735   int pretend_args;
6736   tree sp_switch_attr
6737     = lookup_attribute ("sp_switch", DECL_ATTRIBUTES (current_function_decl));
6738
6739   current_function_interrupt = sh_cfun_interrupt_handler_p ();
6740
6741   /* We have pretend args if we had an object sent partially in registers
6742      and partially on the stack, e.g. a large structure.  */
6743   pretend_args = crtl->args.pretend_args_size;
6744   if (TARGET_VARARGS_PRETEND_ARGS (current_function_decl)
6745       && (NPARM_REGS(SImode)
6746           > crtl->args.info.arg_count[(int) SH_ARG_INT]))
6747     pretend_args = 0;
6748   /* Dwarf2 module doesn't expect frame related insns here.  */
6749   output_stack_adjust (-pretend_args
6750                        - crtl->args.info.stack_regs * 8,
6751                        stack_pointer_rtx, 0, NULL, false);
6752
6753   if (TARGET_SHCOMPACT && flag_pic && crtl->args.info.call_cookie)
6754     /* We're going to use the PIC register to load the address of the
6755        incoming-argument decoder and/or of the return trampoline from
6756        the GOT, so make sure the PIC register is preserved and
6757        initialized.  */
6758     df_set_regs_ever_live (PIC_OFFSET_TABLE_REGNUM, true);
6759
6760   if (TARGET_SHCOMPACT
6761       && (crtl->args.info.call_cookie & ~ CALL_COOKIE_RET_TRAMP(1)))
6762     {
6763       int reg;
6764
6765       /* First, make all registers with incoming arguments that will
6766          be pushed onto the stack live, so that register renaming
6767          doesn't overwrite them.  */
6768       for (reg = 0; reg < NPARM_REGS (SImode); reg++)
6769         if (CALL_COOKIE_STACKSEQ_GET (crtl->args.info.call_cookie)
6770             >= NPARM_REGS (SImode) - reg)
6771           for (; reg < NPARM_REGS (SImode); reg++)
6772             emit_insn (gen_shcompact_preserve_incoming_args
6773                        (gen_rtx_REG (SImode, FIRST_PARM_REG + reg)));
6774         else if (CALL_COOKIE_INT_REG_GET
6775                  (crtl->args.info.call_cookie, reg) == 1)
6776           emit_insn (gen_shcompact_preserve_incoming_args
6777                      (gen_rtx_REG (SImode, FIRST_PARM_REG + reg)));
6778
6779       emit_move_insn (gen_rtx_REG (Pmode, MACL_REG),
6780                       stack_pointer_rtx);
6781       emit_move_insn (gen_rtx_REG (SImode, R0_REG),
6782                       GEN_INT (crtl->args.info.call_cookie));
6783       emit_move_insn (gen_rtx_REG (SImode, MACH_REG),
6784                       gen_rtx_REG (SImode, R0_REG));
6785     }
6786   else if (TARGET_SHMEDIA)
6787     {
6788       int tr = sh_media_register_for_return ();
6789
6790       if (tr >= 0)
6791         emit_move_insn (gen_rtx_REG (DImode, tr),
6792                         gen_rtx_REG (DImode, PR_MEDIA_REG));
6793     }
6794
6795   /* Emit the code for SETUP_VARARGS.  */
6796   if (cfun->stdarg)
6797     {
6798       if (TARGET_VARARGS_PRETEND_ARGS (current_function_decl))
6799         {
6800           /* Push arg regs as if they'd been provided by caller in stack.  */
6801           for (i = 0; i < NPARM_REGS(SImode); i++)
6802             {
6803               int rn = NPARM_REGS(SImode) + FIRST_PARM_REG - i - 1;
6804               rtx insn;
6805
6806               if (i >= (NPARM_REGS(SImode)
6807                         - crtl->args.info.arg_count[(int) SH_ARG_INT]
6808                         ))
6809                 break;
6810               insn = push (rn);
6811             }
6812         }
6813     }
6814
6815   /* If we're supposed to switch stacks at function entry, do so now.  */
6816   if (sp_switch_attr)
6817     {
6818       rtx lab, newsrc;
6819       /* The argument specifies a variable holding the address of the
6820          stack the interrupt function should switch to/from at entry/exit.  */
6821       tree arg = TREE_VALUE ( TREE_VALUE (sp_switch_attr));
6822       const char *s
6823         = ggc_strdup (TREE_STRING_POINTER (arg));
6824       rtx sp_switch = gen_rtx_SYMBOL_REF (Pmode, s);
6825
6826       lab = add_constant (sp_switch, SImode, 0);
6827       newsrc = gen_rtx_LABEL_REF (VOIDmode, lab);
6828       newsrc = gen_const_mem (SImode, newsrc);
6829
6830       emit_insn (gen_sp_switch_1 (newsrc));
6831     }
6832
6833   d = calc_live_regs (&live_regs_mask);
6834   /* ??? Maybe we could save some switching if we can move a mode switch
6835      that already happens to be at the function start into the prologue.  */
6836   if (target_flags != save_flags && ! current_function_interrupt)
6837     emit_insn (gen_toggle_sz ());
6838
6839   if (TARGET_SH5)
6840     {
6841       int offset_base, offset;
6842       rtx r0 = NULL_RTX;
6843       int offset_in_r0 = -1;
6844       int sp_in_r0 = 0;
6845       int tregs_space = shmedia_target_regs_stack_adjust (&live_regs_mask);
6846       int total_size, save_size;
6847       save_schedule schedule;
6848       save_entry *entry;
6849       int *tmp_pnt;
6850
6851       if (call_really_used_regs[R0_REG] && ! fixed_regs[R0_REG]
6852           && ! current_function_interrupt)
6853         r0 = gen_rtx_REG (Pmode, R0_REG);
6854
6855       /* D is the actual number of bytes that we need for saving registers,
6856          however, in initial_elimination_offset we have committed to using
6857          an additional TREGS_SPACE amount of bytes - in order to keep both
6858          addresses to arguments supplied by the caller and local variables
6859          valid, we must keep this gap.  Place it between the incoming
6860          arguments and the actually saved registers in a bid to optimize
6861          locality of reference.  */
6862       total_size = d + tregs_space;
6863       total_size += rounded_frame_size (total_size);
6864       save_size = total_size - rounded_frame_size (d);
6865       if (save_size % (STACK_BOUNDARY / BITS_PER_UNIT))
6866         d_rounding = ((STACK_BOUNDARY / BITS_PER_UNIT)
6867                         - save_size % (STACK_BOUNDARY / BITS_PER_UNIT));
6868
6869       /* If adjusting the stack in a single step costs nothing extra, do so.
6870          I.e. either if a single addi is enough, or we need a movi anyway,
6871          and we don't exceed the maximum offset range (the test for the
6872          latter is conservative for simplicity).  */
6873       if (TARGET_SHMEDIA
6874           && (CONST_OK_FOR_I10 (-total_size)
6875               || (! CONST_OK_FOR_I10 (-(save_size + d_rounding))
6876                   && total_size <= 2044)))
6877         d_rounding = total_size - save_size;
6878
6879       offset_base = d + d_rounding;
6880
6881       output_stack_adjust (-(save_size + d_rounding), stack_pointer_rtx,
6882                            0, NULL, true);
6883
6884       sh5_schedule_saves (&live_regs_mask, &schedule, offset_base);
6885       tmp_pnt = schedule.temps;
6886       for (entry = &schedule.entries[1]; entry->mode != VOIDmode; entry++)
6887         {
6888           enum machine_mode mode = (enum machine_mode) entry->mode;
6889           unsigned int reg = entry->reg;
6890           rtx reg_rtx, mem_rtx, pre_dec = NULL_RTX;
6891           rtx orig_reg_rtx;
6892
6893           offset = entry->offset;
6894
6895           reg_rtx = gen_rtx_REG (mode, reg);
6896
6897           mem_rtx = gen_frame_mem (mode,
6898                                    gen_rtx_PLUS (Pmode,
6899                                                  stack_pointer_rtx,
6900                                                  GEN_INT (offset)));
6901
6902           if (!memory_address_p (mode, XEXP (mem_rtx, 0)))
6903             {
6904               gcc_assert (r0);
6905               mem_rtx = NULL_RTX;
6906             }
6907
6908           if (HAVE_PRE_DECREMENT
6909               && (offset_in_r0 - offset == GET_MODE_SIZE (mode)
6910                   || mem_rtx == NULL_RTX
6911                   || reg == PR_REG || SPECIAL_REGISTER_P (reg)))
6912             {
6913               pre_dec = gen_frame_mem (mode, gen_rtx_PRE_DEC (Pmode, r0));
6914
6915               if (!memory_address_p (mode, XEXP (pre_dec, 0)))
6916                 pre_dec = NULL_RTX;
6917               else
6918                 {
6919                   mem_rtx = NULL_RTX;
6920                   offset += GET_MODE_SIZE (mode);
6921                 }
6922             }
6923
6924           if (mem_rtx != NULL_RTX)
6925             goto addr_ok;
6926
6927           if (offset_in_r0 == -1)
6928             {
6929               emit_move_insn (r0, GEN_INT (offset));
6930               offset_in_r0 = offset;
6931             }
6932           else if (offset != offset_in_r0)
6933             {
6934               emit_move_insn (r0,
6935                               gen_rtx_PLUS
6936                               (Pmode, r0,
6937                                GEN_INT (offset - offset_in_r0)));
6938               offset_in_r0 += offset - offset_in_r0;
6939             }
6940
6941           if (pre_dec != NULL_RTX)
6942             {
6943               if (! sp_in_r0)
6944                 {
6945                   emit_move_insn (r0,
6946                                   gen_rtx_PLUS
6947                                   (Pmode, r0, stack_pointer_rtx));
6948                   sp_in_r0 = 1;
6949                 }
6950
6951               offset -= GET_MODE_SIZE (mode);
6952               offset_in_r0 -= GET_MODE_SIZE (mode);
6953
6954               mem_rtx = pre_dec;
6955             }
6956           else if (sp_in_r0)
6957             mem_rtx = gen_frame_mem (mode, r0);
6958           else
6959             mem_rtx = gen_frame_mem (mode,
6960                                      gen_rtx_PLUS (Pmode,
6961                                                    stack_pointer_rtx,
6962                                                    r0));
6963
6964           /* We must not use an r0-based address for target-branch
6965              registers or for special registers without pre-dec
6966              memory addresses, since we store their values in r0
6967              first.  */
6968           gcc_assert (!TARGET_REGISTER_P (reg)
6969                       && ((reg != PR_REG && !SPECIAL_REGISTER_P (reg))
6970                           || mem_rtx == pre_dec));
6971
6972         addr_ok:
6973           orig_reg_rtx = reg_rtx;
6974           if (TARGET_REGISTER_P (reg)
6975               || ((reg == PR_REG || SPECIAL_REGISTER_P (reg))
6976                   && mem_rtx != pre_dec))
6977             {
6978               rtx tmp_reg = gen_rtx_REG (GET_MODE (reg_rtx), *tmp_pnt);
6979
6980               emit_move_insn (tmp_reg, reg_rtx);
6981
6982               if (REGNO (tmp_reg) == R0_REG)
6983                 {
6984                   offset_in_r0 = -1;
6985                   sp_in_r0 = 0;
6986                   gcc_assert (!refers_to_regno_p
6987                               (R0_REG, R0_REG+1, mem_rtx, (rtx *) 0));
6988                 }
6989
6990               if (*++tmp_pnt <= 0)
6991                 tmp_pnt = schedule.temps;
6992
6993               reg_rtx = tmp_reg;
6994             }
6995           {
6996             rtx insn;
6997
6998             /* Mark as interesting for dwarf cfi generator */
6999             insn = emit_move_insn (mem_rtx, reg_rtx);
7000             RTX_FRAME_RELATED_P (insn) = 1;
7001             /* If we use an intermediate register for the save, we can't
7002                describe this exactly in cfi as a copy of the to-be-saved
7003                register into the temporary register and then the temporary
7004                register on the stack, because the temporary register can
7005                have a different natural size than the to-be-saved register.
7006                Thus, we gloss over the intermediate copy and pretend we do
7007                a direct save from the to-be-saved register.  */
7008             if (REGNO (reg_rtx) != reg)
7009               {
7010                 rtx set;
7011
7012                 set = gen_rtx_SET (VOIDmode, mem_rtx, orig_reg_rtx);
7013                 add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
7014               }
7015
7016             if (TARGET_SHCOMPACT && (offset_in_r0 != -1))
7017               {
7018                 rtx reg_rtx = gen_rtx_REG (mode, reg);
7019                 rtx set;
7020                 rtx mem_rtx = gen_frame_mem (mode,
7021                                              gen_rtx_PLUS (Pmode,
7022                                                            stack_pointer_rtx,
7023                                                            GEN_INT (offset)));
7024
7025                 set = gen_rtx_SET (VOIDmode, mem_rtx, reg_rtx);
7026                 add_reg_note (insn, REG_FRAME_RELATED_EXPR, set);
7027               }
7028           }
7029         }
7030
7031       gcc_assert (entry->offset == d_rounding);
7032     }
7033   else
7034     push_regs (&live_regs_mask, current_function_interrupt);
7035
7036   if (flag_pic && df_regs_ever_live_p (PIC_OFFSET_TABLE_REGNUM))
7037     emit_insn (gen_GOTaddr2picreg ());
7038
7039   if (SHMEDIA_REGS_STACK_ADJUST ())
7040     {
7041       /* This must NOT go through the PLT, otherwise mach and macl
7042          may be clobbered.  */
7043       function_symbol (gen_rtx_REG (Pmode, R0_REG),
7044                        (TARGET_FPU_ANY
7045                         ? "__GCC_push_shmedia_regs"
7046                         : "__GCC_push_shmedia_regs_nofpu"), SFUNC_GOT);
7047       emit_insn (gen_shmedia_save_restore_regs_compact
7048                  (GEN_INT (-SHMEDIA_REGS_STACK_ADJUST ())));
7049     }
7050
7051   if (target_flags != save_flags && ! current_function_interrupt)
7052     emit_insn (gen_toggle_sz ());
7053
7054   target_flags = save_flags;
7055
7056   output_stack_adjust (-rounded_frame_size (d) + d_rounding,
7057                        stack_pointer_rtx, 0, NULL, true);
7058
7059   if (frame_pointer_needed)
7060     frame_insn (GEN_MOV (hard_frame_pointer_rtx, stack_pointer_rtx));
7061
7062   if (TARGET_SHCOMPACT
7063       && (crtl->args.info.call_cookie & ~ CALL_COOKIE_RET_TRAMP(1)))
7064     {
7065       /* This must NOT go through the PLT, otherwise mach and macl
7066          may be clobbered.  */
7067       function_symbol (gen_rtx_REG (Pmode, R0_REG),
7068                       "__GCC_shcompact_incoming_args", SFUNC_GOT);
7069       emit_insn (gen_shcompact_incoming_args ());
7070     }
7071 }
7072
7073 void
7074 sh_expand_epilogue (bool sibcall_p)
7075 {
7076   HARD_REG_SET live_regs_mask;
7077   int d, i;
7078   int d_rounding = 0;
7079
7080   int save_flags = target_flags;
7081   int frame_size, save_size;
7082   int fpscr_deferred = 0;
7083   int e = sibcall_p ? -1 : 1;
7084
7085   d = calc_live_regs (&live_regs_mask);
7086
7087   save_size = d;
7088   frame_size = rounded_frame_size (d);
7089
7090   if (TARGET_SH5)
7091     {
7092       int tregs_space = shmedia_target_regs_stack_adjust (&live_regs_mask);
7093       int total_size;
7094       if (d % (STACK_BOUNDARY / BITS_PER_UNIT))
7095       d_rounding = ((STACK_BOUNDARY / BITS_PER_UNIT)
7096                     - d % (STACK_BOUNDARY / BITS_PER_UNIT));
7097
7098       total_size = d + tregs_space;
7099       total_size += rounded_frame_size (total_size);
7100       save_size = total_size - frame_size;
7101
7102       /* If adjusting the stack in a single step costs nothing extra, do so.
7103          I.e. either if a single addi is enough, or we need a movi anyway,
7104          and we don't exceed the maximum offset range (the test for the
7105          latter is conservative for simplicity).  */
7106       if (TARGET_SHMEDIA
7107           && ! frame_pointer_needed
7108           && (CONST_OK_FOR_I10 (total_size)
7109               || (! CONST_OK_FOR_I10 (save_size + d_rounding)
7110                   && total_size <= 2044)))
7111         d_rounding = frame_size;
7112
7113       frame_size -= d_rounding;
7114     }
7115
7116   if (frame_pointer_needed)
7117     {
7118       /* We must avoid scheduling the epilogue with previous basic blocks.
7119          See PR/18032 and PR/40313.  */
7120       emit_insn (gen_blockage ());
7121       output_stack_adjust (frame_size, hard_frame_pointer_rtx, e,
7122                            &live_regs_mask, false);
7123
7124       /* We must avoid moving the stack pointer adjustment past code
7125          which reads from the local frame, else an interrupt could
7126          occur after the SP adjustment and clobber data in the local
7127          frame.  */
7128       emit_insn (gen_blockage ());
7129       emit_insn (GEN_MOV (stack_pointer_rtx, hard_frame_pointer_rtx));
7130     }
7131   else if (frame_size)
7132     {
7133       /* We must avoid moving the stack pointer adjustment past code
7134          which reads from the local frame, else an interrupt could
7135          occur after the SP adjustment and clobber data in the local
7136          frame.  */
7137       emit_insn (gen_blockage ());
7138       output_stack_adjust (frame_size, stack_pointer_rtx, e,
7139                            &live_regs_mask, false);
7140     }
7141
7142   if (SHMEDIA_REGS_STACK_ADJUST ())
7143     {
7144       function_symbol (gen_rtx_REG (Pmode, R0_REG),
7145                        (TARGET_FPU_ANY
7146                         ? "__GCC_pop_shmedia_regs"
7147                         : "__GCC_pop_shmedia_regs_nofpu"), SFUNC_GOT);
7148       /* This must NOT go through the PLT, otherwise mach and macl
7149          may be clobbered.  */
7150       emit_insn (gen_shmedia_save_restore_regs_compact
7151                  (GEN_INT (SHMEDIA_REGS_STACK_ADJUST ())));
7152     }
7153
7154   /* Pop all the registers.  */
7155
7156   if (target_flags != save_flags && ! current_function_interrupt)
7157     emit_insn (gen_toggle_sz ());
7158   if (TARGET_SH5)
7159     {
7160       int offset_base, offset;
7161       int offset_in_r0 = -1;
7162       int sp_in_r0 = 0;
7163       rtx r0 = gen_rtx_REG (Pmode, R0_REG);
7164       save_schedule schedule;
7165       save_entry *entry;
7166       int *tmp_pnt;
7167
7168       entry = sh5_schedule_saves (&live_regs_mask, &schedule, d_rounding);
7169       offset_base = -entry[1].offset + d_rounding;
7170       tmp_pnt = schedule.temps;
7171       for (; entry->mode != VOIDmode; entry--)
7172         {
7173           enum machine_mode mode = (enum machine_mode) entry->mode;
7174           int reg = entry->reg;
7175           rtx reg_rtx, mem_rtx, post_inc = NULL_RTX, insn;
7176
7177           offset = offset_base + entry->offset;
7178           reg_rtx = gen_rtx_REG (mode, reg);
7179
7180           mem_rtx = gen_frame_mem (mode,
7181                                    gen_rtx_PLUS (Pmode,
7182                                                  stack_pointer_rtx,
7183                                                  GEN_INT (offset)));
7184
7185           if (!memory_address_p (mode, XEXP (mem_rtx, 0)))
7186             mem_rtx = NULL_RTX;
7187
7188           if (HAVE_POST_INCREMENT
7189               && (offset == offset_in_r0
7190                   || (offset + GET_MODE_SIZE (mode) != d + d_rounding
7191                       && mem_rtx == NULL_RTX)
7192                   || reg == PR_REG || SPECIAL_REGISTER_P (reg)))
7193             {
7194               post_inc = gen_frame_mem (mode, gen_rtx_POST_INC (Pmode, r0));
7195
7196               if (!memory_address_p (mode, XEXP (post_inc, 0)))
7197                 post_inc = NULL_RTX;
7198               else
7199                 mem_rtx = NULL_RTX;
7200             }
7201
7202           if (mem_rtx != NULL_RTX)
7203             goto addr_ok;
7204
7205           if (offset_in_r0 == -1)
7206             {
7207               emit_move_insn (r0, GEN_INT (offset));
7208               offset_in_r0 = offset;
7209             }
7210           else if (offset != offset_in_r0)
7211             {
7212               emit_move_insn (r0,
7213                               gen_rtx_PLUS
7214                               (Pmode, r0,
7215                                GEN_INT (offset - offset_in_r0)));
7216               offset_in_r0 += offset - offset_in_r0;
7217             }
7218
7219           if (post_inc != NULL_RTX)
7220             {
7221               if (! sp_in_r0)
7222                 {
7223                   emit_move_insn (r0,
7224                                   gen_rtx_PLUS
7225                                   (Pmode, r0, stack_pointer_rtx));
7226                   sp_in_r0 = 1;
7227                 }
7228
7229               mem_rtx = post_inc;
7230
7231               offset_in_r0 += GET_MODE_SIZE (mode);
7232             }
7233           else if (sp_in_r0)
7234             mem_rtx = gen_frame_mem (mode, r0);
7235           else
7236             mem_rtx = gen_frame_mem (mode,
7237                                      gen_rtx_PLUS (Pmode,
7238                                                    stack_pointer_rtx,
7239                                                    r0));
7240
7241           gcc_assert ((reg != PR_REG && !SPECIAL_REGISTER_P (reg))
7242                       || mem_rtx == post_inc);
7243
7244         addr_ok:
7245           if ((reg == PR_REG || SPECIAL_REGISTER_P (reg))
7246               && mem_rtx != post_inc)
7247             {
7248               insn = emit_move_insn (r0, mem_rtx);
7249               mem_rtx = r0;
7250             }
7251           else if (TARGET_REGISTER_P (reg))
7252             {
7253               rtx tmp_reg = gen_rtx_REG (mode, *tmp_pnt);
7254
7255               /* Give the scheduler a bit of freedom by using up to
7256                  MAX_TEMPS registers in a round-robin fashion.  */
7257               insn = emit_move_insn (tmp_reg, mem_rtx);
7258               mem_rtx = tmp_reg;
7259               if (*++tmp_pnt < 0)
7260                 tmp_pnt = schedule.temps;
7261             }
7262
7263           insn = emit_move_insn (reg_rtx, mem_rtx);
7264         }
7265
7266       gcc_assert (entry->offset + offset_base == d + d_rounding);
7267     }
7268   else /* ! TARGET_SH5 */
7269     {
7270       int last_reg;
7271
7272       save_size = 0;
7273         /* For an ISR with RESBANK attribute assigned, don't pop PR
7274            register.  */
7275       if (TEST_HARD_REG_BIT (live_regs_mask, PR_REG)
7276           && !sh_cfun_resbank_handler_p ())
7277         {
7278           if (!frame_pointer_needed)
7279             emit_insn (gen_blockage ());
7280           pop (PR_REG);
7281         }
7282
7283       /* Banked registers are popped first to avoid being scheduled in the
7284          delay slot. RTE switches banks before the ds instruction.  */
7285       if (current_function_interrupt)
7286         {
7287           for (i = LAST_BANKED_REG; i >= FIRST_BANKED_REG; i--)
7288             if (TEST_HARD_REG_BIT (live_regs_mask, i))
7289               pop (i);
7290
7291           last_reg = FIRST_PSEUDO_REGISTER - LAST_BANKED_REG - 1;
7292         }
7293       else
7294         last_reg = FIRST_PSEUDO_REGISTER;
7295
7296       for (i = 0; i < last_reg; i++)
7297         {
7298           int j = (FIRST_PSEUDO_REGISTER - 1) - i;
7299
7300           if (j == FPSCR_REG && current_function_interrupt && TARGET_FMOVD
7301               && hard_reg_set_intersect_p (live_regs_mask,
7302                                           reg_class_contents[DF_REGS]))
7303             fpscr_deferred = 1;
7304           /* For an ISR with RESBANK attribute assigned, don't pop
7305              following registers, R0-R14, MACH, MACL and GBR.  */
7306           else if (j != PR_REG && TEST_HARD_REG_BIT (live_regs_mask, j)
7307                    && ! (sh_cfun_resbank_handler_p ()
7308                          && ((j >= FIRST_GENERAL_REG
7309                               && j < LAST_GENERAL_REG)
7310                               || j == MACH_REG
7311                               || j == MACL_REG
7312                               || j == GBR_REG)))
7313             pop (j);
7314
7315           if (j == FIRST_FP_REG && fpscr_deferred)
7316             pop (FPSCR_REG);
7317         }
7318     }
7319   if (target_flags != save_flags && ! current_function_interrupt)
7320     emit_insn (gen_toggle_sz ());
7321   target_flags = save_flags;
7322
7323   output_stack_adjust (crtl->args.pretend_args_size
7324                        + save_size + d_rounding
7325                        + crtl->args.info.stack_regs * 8,
7326                        stack_pointer_rtx, e, NULL, false);
7327
7328   if (crtl->calls_eh_return)
7329     emit_insn (GEN_ADD3 (stack_pointer_rtx, stack_pointer_rtx,
7330                          EH_RETURN_STACKADJ_RTX));
7331
7332   /* Switch back to the normal stack if necessary.  */
7333   if (lookup_attribute ("sp_switch", DECL_ATTRIBUTES (current_function_decl)))
7334     emit_insn (gen_sp_switch_2 ());
7335
7336   /* Tell flow the insn that pops PR isn't dead.  */
7337   /* PR_REG will never be live in SHmedia mode, and we don't need to
7338      USE PR_MEDIA_REG, since it will be explicitly copied to TR0_REG
7339      by the return pattern.  */
7340   if (TEST_HARD_REG_BIT (live_regs_mask, PR_REG))
7341     emit_use (gen_rtx_REG (SImode, PR_REG));
7342 }
7343
7344 static int sh_need_epilogue_known = 0;
7345
7346 int
7347 sh_need_epilogue (void)
7348 {
7349   if (! sh_need_epilogue_known)
7350     {
7351       rtx epilogue;
7352
7353       start_sequence ();
7354       sh_expand_epilogue (0);
7355       epilogue = get_insns ();
7356       end_sequence ();
7357       sh_need_epilogue_known = (epilogue == NULL ? -1 : 1);
7358     }
7359   return sh_need_epilogue_known > 0;
7360 }
7361
7362 /* Emit code to change the current function's return address to RA.
7363    TEMP is available as a scratch register, if needed.  */
7364
7365 void
7366 sh_set_return_address (rtx ra, rtx tmp)
7367 {
7368   HARD_REG_SET live_regs_mask;
7369   int d;
7370   int pr_reg = TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG;
7371   int pr_offset;
7372
7373   d = calc_live_regs (&live_regs_mask);
7374
7375   /* If pr_reg isn't life, we can set it (or the register given in
7376      sh_media_register_for_return) directly.  */
7377   if (! TEST_HARD_REG_BIT (live_regs_mask, pr_reg))
7378     {
7379       rtx rr;
7380
7381       if (TARGET_SHMEDIA)
7382         {
7383           int rr_regno = sh_media_register_for_return ();
7384
7385           if (rr_regno < 0)
7386             rr_regno = pr_reg;
7387
7388           rr = gen_rtx_REG (DImode, rr_regno);
7389         }
7390       else
7391         rr = gen_rtx_REG (SImode, pr_reg);
7392
7393       emit_insn (GEN_MOV (rr, ra));
7394       /* Tell flow the register for return isn't dead.  */
7395       emit_use (rr);
7396       return;
7397     }
7398
7399   if (TARGET_SH5)
7400     {
7401       int offset;
7402       save_schedule schedule;
7403       save_entry *entry;
7404
7405       entry = sh5_schedule_saves (&live_regs_mask, &schedule, 0);
7406       offset = entry[1].offset;
7407       for (; entry->mode != VOIDmode; entry--)
7408         if (entry->reg == pr_reg)
7409           goto found;
7410
7411       /* We can't find pr register.  */
7412       gcc_unreachable ();
7413
7414     found:
7415       offset = entry->offset - offset;
7416       pr_offset = (rounded_frame_size (d) + offset
7417                    + SHMEDIA_REGS_STACK_ADJUST ());
7418     }
7419   else
7420     pr_offset = rounded_frame_size (d);
7421
7422   emit_insn (GEN_MOV (tmp, GEN_INT (pr_offset)));
7423   emit_insn (GEN_ADD3 (tmp, tmp, hard_frame_pointer_rtx));
7424
7425   tmp = gen_frame_mem (Pmode, tmp);
7426   emit_insn (GEN_MOV (tmp, ra));
7427   /* Tell this store isn't dead.  */
7428   emit_use (tmp);
7429 }
7430
7431 /* Clear variables at function end.  */
7432
7433 static void
7434 sh_output_function_epilogue (FILE *file ATTRIBUTE_UNUSED,
7435                              HOST_WIDE_INT size ATTRIBUTE_UNUSED)
7436 {
7437   sh_need_epilogue_known = 0;
7438 }
7439
7440 static rtx
7441 sh_builtin_saveregs (void)
7442 {
7443   /* First unnamed integer register.  */
7444   int first_intreg = crtl->args.info.arg_count[(int) SH_ARG_INT];
7445   /* Number of integer registers we need to save.  */
7446   int n_intregs = MAX (0, NPARM_REGS (SImode) - first_intreg);
7447   /* First unnamed SFmode float reg */
7448   int first_floatreg = crtl->args.info.arg_count[(int) SH_ARG_FLOAT];
7449   /* Number of SFmode float regs to save.  */
7450   int n_floatregs = MAX (0, NPARM_REGS (SFmode) - first_floatreg);
7451   rtx regbuf, fpregs;
7452   int bufsize, regno;
7453   alias_set_type alias_set;
7454
7455   if (TARGET_SH5)
7456     {
7457       if (n_intregs)
7458         {
7459           int pushregs = n_intregs;
7460
7461           while (pushregs < NPARM_REGS (SImode) - 1
7462                  && (CALL_COOKIE_INT_REG_GET
7463                         (crtl->args.info.call_cookie,
7464                          NPARM_REGS (SImode) - pushregs)
7465                      == 1))
7466             {
7467               crtl->args.info.call_cookie
7468                 &= ~ CALL_COOKIE_INT_REG (NPARM_REGS (SImode)
7469                                           - pushregs, 1);
7470               pushregs++;
7471             }
7472
7473           if (pushregs == NPARM_REGS (SImode))
7474             crtl->args.info.call_cookie
7475               |= (CALL_COOKIE_INT_REG (0, 1)
7476                   | CALL_COOKIE_STACKSEQ (pushregs - 1));
7477           else
7478             crtl->args.info.call_cookie
7479               |= CALL_COOKIE_STACKSEQ (pushregs);
7480
7481           crtl->args.pretend_args_size += 8 * n_intregs;
7482         }
7483       if (TARGET_SHCOMPACT)
7484         return const0_rtx;
7485     }
7486
7487   if (! TARGET_SH2E && ! TARGET_SH4 && ! TARGET_SH5)
7488     {
7489       error ("__builtin_saveregs not supported by this subtarget");
7490       return const0_rtx;
7491     }
7492
7493   if (TARGET_SHMEDIA)
7494     n_floatregs = 0;
7495
7496   /* Allocate block of memory for the regs.  */
7497   /* ??? If n_intregs + n_floatregs == 0, should we allocate at least 1 byte?
7498      Or can assign_stack_local accept a 0 SIZE argument?  */
7499   bufsize = (n_intregs * UNITS_PER_WORD) + (n_floatregs * UNITS_PER_WORD);
7500
7501   if (TARGET_SHMEDIA)
7502     regbuf = gen_frame_mem (BLKmode, gen_rtx_REG (Pmode, ARG_POINTER_REGNUM));
7503   else if (n_floatregs & 1)
7504     {
7505       rtx addr;
7506
7507       regbuf = assign_stack_local (BLKmode, bufsize + UNITS_PER_WORD, 0);
7508       addr = copy_to_mode_reg (Pmode, XEXP (regbuf, 0));
7509       emit_insn (gen_iorsi3 (addr, addr, GEN_INT (UNITS_PER_WORD)));
7510       regbuf = change_address (regbuf, BLKmode, addr);
7511     }
7512   else if (STACK_BOUNDARY < 64 && TARGET_FPU_DOUBLE && n_floatregs)
7513     {
7514       rtx addr, mask;
7515
7516       regbuf = assign_stack_local (BLKmode, bufsize + UNITS_PER_WORD, 0);
7517       addr = copy_to_mode_reg (Pmode, plus_constant (XEXP (regbuf, 0), 4));
7518       mask = copy_to_mode_reg (Pmode, GEN_INT (-8));
7519       emit_insn (gen_andsi3 (addr, addr, mask));
7520       regbuf = change_address (regbuf, BLKmode, addr);
7521     }
7522   else
7523     regbuf = assign_stack_local (BLKmode, bufsize, TARGET_FPU_DOUBLE ? 64 : 0);
7524   alias_set = get_varargs_alias_set ();
7525   set_mem_alias_set (regbuf, alias_set);
7526
7527   /* Save int args.
7528      This is optimized to only save the regs that are necessary.  Explicitly
7529      named args need not be saved.  */
7530   if (n_intregs > 0)
7531     move_block_from_reg (BASE_ARG_REG (SImode) + first_intreg,
7532                          adjust_address (regbuf, BLKmode,
7533                                          n_floatregs * UNITS_PER_WORD),
7534                          n_intregs);
7535
7536   if (TARGET_SHMEDIA)
7537     /* Return the address of the regbuf.  */
7538     return XEXP (regbuf, 0);
7539
7540   /* Save float args.
7541      This is optimized to only save the regs that are necessary.  Explicitly
7542      named args need not be saved.
7543      We explicitly build a pointer to the buffer because it halves the insn
7544      count when not optimizing (otherwise the pointer is built for each reg
7545      saved).
7546      We emit the moves in reverse order so that we can use predecrement.  */
7547
7548   fpregs = copy_to_mode_reg (Pmode,
7549                              plus_constant (XEXP (regbuf, 0),
7550                                             n_floatregs * UNITS_PER_WORD));
7551   if (TARGET_SH4 || TARGET_SH2A_DOUBLE)
7552     {
7553       rtx mem;
7554       for (regno = NPARM_REGS (DFmode) - 2; regno >= first_floatreg; regno -= 2)
7555         {
7556           emit_insn (gen_addsi3 (fpregs, fpregs,
7557                                  GEN_INT (-2 * UNITS_PER_WORD)));
7558           mem = change_address (regbuf, DFmode, fpregs);
7559           emit_move_insn (mem,
7560                           gen_rtx_REG (DFmode, BASE_ARG_REG (DFmode) + regno));
7561         }
7562       regno = first_floatreg;
7563       if (regno & 1)
7564         {
7565           emit_insn (gen_addsi3 (fpregs, fpregs, GEN_INT (-UNITS_PER_WORD)));
7566           mem = change_address (regbuf, SFmode, fpregs);
7567           emit_move_insn (mem,
7568                           gen_rtx_REG (SFmode, BASE_ARG_REG (SFmode) + regno
7569                                                 - (TARGET_LITTLE_ENDIAN != 0)));
7570         }
7571     }
7572   else
7573     for (regno = NPARM_REGS (SFmode) - 1; regno >= first_floatreg; regno--)
7574       {
7575         rtx mem;
7576
7577         emit_insn (gen_addsi3 (fpregs, fpregs, GEN_INT (-UNITS_PER_WORD)));
7578         mem = change_address (regbuf, SFmode, fpregs);
7579         emit_move_insn (mem,
7580                         gen_rtx_REG (SFmode, BASE_ARG_REG (SFmode) + regno));
7581       }
7582
7583   /* Return the address of the regbuf.  */
7584   return XEXP (regbuf, 0);
7585 }
7586
7587 /* Define the `__builtin_va_list' type for the ABI.  */
7588
7589 static tree
7590 sh_build_builtin_va_list (void)
7591 {
7592   tree f_next_o, f_next_o_limit, f_next_fp, f_next_fp_limit, f_next_stack;
7593   tree record;
7594
7595   if (TARGET_SH5 || (! TARGET_SH2E && ! TARGET_SH4)
7596       || TARGET_HITACHI || sh_cfun_attr_renesas_p ())
7597     return ptr_type_node;
7598
7599   record = (*lang_hooks.types.make_type) (RECORD_TYPE);
7600
7601   f_next_o = build_decl (BUILTINS_LOCATION,
7602                          FIELD_DECL, get_identifier ("__va_next_o"),
7603                          ptr_type_node);
7604   f_next_o_limit = build_decl (BUILTINS_LOCATION,
7605                                FIELD_DECL,
7606                                get_identifier ("__va_next_o_limit"),
7607                                ptr_type_node);
7608   f_next_fp = build_decl (BUILTINS_LOCATION,
7609                           FIELD_DECL, get_identifier ("__va_next_fp"),
7610                           ptr_type_node);
7611   f_next_fp_limit = build_decl (BUILTINS_LOCATION,
7612                                 FIELD_DECL,
7613                                 get_identifier ("__va_next_fp_limit"),
7614                                 ptr_type_node);
7615   f_next_stack = build_decl (BUILTINS_LOCATION,
7616                              FIELD_DECL, get_identifier ("__va_next_stack"),
7617                              ptr_type_node);
7618
7619   DECL_FIELD_CONTEXT (f_next_o) = record;
7620   DECL_FIELD_CONTEXT (f_next_o_limit) = record;
7621   DECL_FIELD_CONTEXT (f_next_fp) = record;
7622   DECL_FIELD_CONTEXT (f_next_fp_limit) = record;
7623   DECL_FIELD_CONTEXT (f_next_stack) = record;
7624
7625   TYPE_FIELDS (record) = f_next_o;
7626   TREE_CHAIN (f_next_o) = f_next_o_limit;
7627   TREE_CHAIN (f_next_o_limit) = f_next_fp;
7628   TREE_CHAIN (f_next_fp) = f_next_fp_limit;
7629   TREE_CHAIN (f_next_fp_limit) = f_next_stack;
7630
7631   layout_type (record);
7632
7633   return record;
7634 }
7635
7636 /* Implement `va_start' for varargs and stdarg.  */
7637
7638 static void
7639 sh_va_start (tree valist, rtx nextarg)
7640 {
7641   tree f_next_o, f_next_o_limit, f_next_fp, f_next_fp_limit, f_next_stack;
7642   tree next_o, next_o_limit, next_fp, next_fp_limit, next_stack;
7643   tree t, u;
7644   int nfp, nint;
7645
7646   if (TARGET_SH5)
7647     {
7648       expand_builtin_saveregs ();
7649       std_expand_builtin_va_start (valist, nextarg);
7650       return;
7651     }
7652
7653   if ((! TARGET_SH2E && ! TARGET_SH4)
7654       || TARGET_HITACHI || sh_cfun_attr_renesas_p ())
7655     {
7656       std_expand_builtin_va_start (valist, nextarg);
7657       return;
7658     }
7659
7660   f_next_o = TYPE_FIELDS (va_list_type_node);
7661   f_next_o_limit = TREE_CHAIN (f_next_o);
7662   f_next_fp = TREE_CHAIN (f_next_o_limit);
7663   f_next_fp_limit = TREE_CHAIN (f_next_fp);
7664   f_next_stack = TREE_CHAIN (f_next_fp_limit);
7665
7666   next_o = build3 (COMPONENT_REF, TREE_TYPE (f_next_o), valist, f_next_o,
7667                    NULL_TREE);
7668   next_o_limit = build3 (COMPONENT_REF, TREE_TYPE (f_next_o_limit),
7669                          valist, f_next_o_limit, NULL_TREE);
7670   next_fp = build3 (COMPONENT_REF, TREE_TYPE (f_next_fp), valist, f_next_fp,
7671                     NULL_TREE);
7672   next_fp_limit = build3 (COMPONENT_REF, TREE_TYPE (f_next_fp_limit),
7673                           valist, f_next_fp_limit, NULL_TREE);
7674   next_stack = build3 (COMPONENT_REF, TREE_TYPE (f_next_stack),
7675                        valist, f_next_stack, NULL_TREE);
7676
7677   /* Call __builtin_saveregs.  */
7678   u = make_tree (sizetype, expand_builtin_saveregs ());
7679   u = fold_convert (ptr_type_node, u);
7680   t = build2 (MODIFY_EXPR, ptr_type_node, next_fp, u);
7681   TREE_SIDE_EFFECTS (t) = 1;
7682   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7683
7684   nfp = crtl->args.info.arg_count[SH_ARG_FLOAT];
7685   if (nfp < 8)
7686     nfp = 8 - nfp;
7687   else
7688     nfp = 0;
7689   u = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, u,
7690                    size_int (UNITS_PER_WORD * nfp));
7691   t = build2 (MODIFY_EXPR, ptr_type_node, next_fp_limit, u);
7692   TREE_SIDE_EFFECTS (t) = 1;
7693   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7694
7695   t = build2 (MODIFY_EXPR, ptr_type_node, next_o, u);
7696   TREE_SIDE_EFFECTS (t) = 1;
7697   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7698
7699   nint = crtl->args.info.arg_count[SH_ARG_INT];
7700   if (nint < 4)
7701     nint = 4 - nint;
7702   else
7703     nint = 0;
7704   u = fold_build2 (POINTER_PLUS_EXPR, ptr_type_node, u,
7705                    size_int (UNITS_PER_WORD * nint));
7706   t = build2 (MODIFY_EXPR, ptr_type_node, next_o_limit, u);
7707   TREE_SIDE_EFFECTS (t) = 1;
7708   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7709
7710   u = make_tree (ptr_type_node, nextarg);
7711   t = build2 (MODIFY_EXPR, ptr_type_node, next_stack, u);
7712   TREE_SIDE_EFFECTS (t) = 1;
7713   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
7714 }
7715
7716 /* TYPE is a RECORD_TYPE.  If there is only a single nonzero-sized
7717    member, return it.  */
7718 static tree
7719 find_sole_member (tree type)
7720 {
7721   tree field, member = NULL_TREE;
7722
7723   for (field = TYPE_FIELDS (type); field; field = TREE_CHAIN (field))
7724     {
7725       if (TREE_CODE (field) != FIELD_DECL)
7726         continue;
7727       if (!DECL_SIZE (field))
7728         return NULL_TREE;
7729       if (integer_zerop (DECL_SIZE (field)))
7730         continue;
7731       if (member)
7732         return NULL_TREE;
7733       member = field;
7734     }
7735   return member;
7736 }
7737 /* Implement `va_arg'.  */
7738
7739 static tree
7740 sh_gimplify_va_arg_expr (tree valist, tree type, gimple_seq *pre_p,
7741                          gimple_seq *post_p ATTRIBUTE_UNUSED)
7742 {
7743   HOST_WIDE_INT size, rsize;
7744   tree tmp, pptr_type_node;
7745   tree addr, lab_over = NULL, result = NULL;
7746   int pass_by_ref = targetm.calls.must_pass_in_stack (TYPE_MODE (type), type);
7747   tree eff_type;
7748
7749   if (pass_by_ref)
7750     type = build_pointer_type (type);
7751
7752   size = int_size_in_bytes (type);
7753   rsize = (size + UNITS_PER_WORD - 1) & -UNITS_PER_WORD;
7754   pptr_type_node = build_pointer_type (ptr_type_node);
7755
7756   if (! TARGET_SH5 && (TARGET_SH2E || TARGET_SH4)
7757       && ! (TARGET_HITACHI || sh_cfun_attr_renesas_p ()))
7758     {
7759       tree f_next_o, f_next_o_limit, f_next_fp, f_next_fp_limit, f_next_stack;
7760       tree next_o, next_o_limit, next_fp, next_fp_limit, next_stack;
7761       int pass_as_float;
7762       tree lab_false;
7763       tree member;
7764
7765       f_next_o = TYPE_FIELDS (va_list_type_node);
7766       f_next_o_limit = TREE_CHAIN (f_next_o);
7767       f_next_fp = TREE_CHAIN (f_next_o_limit);
7768       f_next_fp_limit = TREE_CHAIN (f_next_fp);
7769       f_next_stack = TREE_CHAIN (f_next_fp_limit);
7770
7771       next_o = build3 (COMPONENT_REF, TREE_TYPE (f_next_o), valist, f_next_o,
7772                        NULL_TREE);
7773       next_o_limit = build3 (COMPONENT_REF, TREE_TYPE (f_next_o_limit),
7774                              valist, f_next_o_limit, NULL_TREE);
7775       next_fp = build3 (COMPONENT_REF, TREE_TYPE (f_next_fp),
7776                         valist, f_next_fp, NULL_TREE);
7777       next_fp_limit = build3 (COMPONENT_REF, TREE_TYPE (f_next_fp_limit),
7778                               valist, f_next_fp_limit, NULL_TREE);
7779       next_stack = build3 (COMPONENT_REF, TREE_TYPE (f_next_stack),
7780                            valist, f_next_stack, NULL_TREE);
7781
7782       /* Structures with a single member with a distinct mode are passed
7783          like their member.  This is relevant if the latter has a REAL_TYPE
7784          or COMPLEX_TYPE type.  */
7785       eff_type = type;
7786       while (TREE_CODE (eff_type) == RECORD_TYPE
7787              && (member = find_sole_member (eff_type))
7788              && (TREE_CODE (TREE_TYPE (member)) == REAL_TYPE
7789                  || TREE_CODE (TREE_TYPE (member)) == COMPLEX_TYPE
7790                  || TREE_CODE (TREE_TYPE (member)) == RECORD_TYPE))
7791         {
7792           tree field_type = TREE_TYPE (member);
7793
7794           if (TYPE_MODE (eff_type) == TYPE_MODE (field_type))
7795             eff_type = field_type;
7796           else
7797             {
7798               gcc_assert ((TYPE_ALIGN (eff_type)
7799                            < GET_MODE_ALIGNMENT (TYPE_MODE (field_type)))
7800                           || (TYPE_ALIGN (eff_type)
7801                               > GET_MODE_BITSIZE (TYPE_MODE (field_type))));
7802               break;
7803             }
7804         }
7805
7806       if (TARGET_SH4 || TARGET_SH2A_DOUBLE)
7807         {
7808           pass_as_float = ((TREE_CODE (eff_type) == REAL_TYPE && size <= 8)
7809                            || (TREE_CODE (eff_type) == COMPLEX_TYPE
7810                                && TREE_CODE (TREE_TYPE (eff_type)) == REAL_TYPE
7811                                && size <= 16));
7812         }
7813       else
7814         {
7815           pass_as_float = (TREE_CODE (eff_type) == REAL_TYPE && size == 4);
7816         }
7817
7818       addr = create_tmp_var (pptr_type_node, NULL);
7819       lab_false = create_artificial_label (UNKNOWN_LOCATION);
7820       lab_over = create_artificial_label (UNKNOWN_LOCATION);
7821
7822       valist = build1 (INDIRECT_REF, ptr_type_node, addr);
7823
7824       if (pass_as_float)
7825         {
7826           tree next_fp_tmp = create_tmp_var (TREE_TYPE (f_next_fp), NULL);
7827           tree cmp;
7828           bool is_double = size == 8 && TREE_CODE (eff_type) == REAL_TYPE;
7829
7830           tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_fp));
7831           gimplify_assign (unshare_expr (addr), tmp, pre_p);
7832
7833           gimplify_assign (unshare_expr (next_fp_tmp), valist, pre_p);
7834           tmp = next_fp_limit;
7835           if (size > 4 && !is_double)
7836             tmp = build2 (POINTER_PLUS_EXPR, TREE_TYPE (tmp),
7837                           unshare_expr (tmp), size_int (4 - size));
7838           tmp = build2 (GE_EXPR, boolean_type_node,
7839                         unshare_expr (next_fp_tmp), unshare_expr (tmp));
7840           cmp = build3 (COND_EXPR, void_type_node, tmp,
7841                         build1 (GOTO_EXPR, void_type_node,
7842                                 unshare_expr (lab_false)), NULL_TREE);
7843           if (!is_double)
7844             gimplify_and_add (cmp, pre_p);
7845
7846           if (TYPE_ALIGN (eff_type) > BITS_PER_WORD
7847               || (is_double || size == 16))
7848             {
7849               tmp = fold_convert (sizetype, next_fp_tmp);
7850               tmp = build2 (BIT_AND_EXPR, sizetype, tmp,
7851                             size_int (UNITS_PER_WORD));
7852               tmp = build2 (POINTER_PLUS_EXPR, ptr_type_node,
7853                             unshare_expr (next_fp_tmp), tmp);
7854               gimplify_assign (unshare_expr (next_fp_tmp), tmp, pre_p);
7855             }
7856           if (is_double)
7857             gimplify_and_add (cmp, pre_p);
7858
7859 #ifdef FUNCTION_ARG_SCmode_WART
7860           if (TYPE_MODE (eff_type) == SCmode
7861               && TARGET_SH4 && TARGET_LITTLE_ENDIAN)
7862             {
7863               tree subtype = TREE_TYPE (eff_type);
7864               tree real, imag;
7865
7866               imag
7867                 = std_gimplify_va_arg_expr (next_fp_tmp, subtype, pre_p, NULL);
7868               imag = get_initialized_tmp_var (imag, pre_p, NULL);
7869
7870               real
7871                 = std_gimplify_va_arg_expr (next_fp_tmp, subtype, pre_p, NULL);
7872               real = get_initialized_tmp_var (real, pre_p, NULL);
7873
7874               result = build2 (COMPLEX_EXPR, eff_type, real, imag);
7875               if (type != eff_type)
7876                 result = build1 (VIEW_CONVERT_EXPR, type, result);
7877               result = get_initialized_tmp_var (result, pre_p, NULL);
7878             }
7879 #endif /* FUNCTION_ARG_SCmode_WART */
7880
7881           tmp = build1 (GOTO_EXPR, void_type_node, unshare_expr (lab_over));
7882           gimplify_and_add (tmp, pre_p);
7883
7884           tmp = build1 (LABEL_EXPR, void_type_node, unshare_expr (lab_false));
7885           gimplify_and_add (tmp, pre_p);
7886
7887           tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_stack));
7888           gimplify_assign (unshare_expr (addr), tmp, pre_p);
7889           gimplify_assign (unshare_expr (next_fp_tmp),
7890                            unshare_expr (valist), pre_p);
7891
7892           gimplify_assign (unshare_expr (valist),
7893                            unshare_expr (next_fp_tmp), post_p);
7894           valist = next_fp_tmp;
7895         }
7896       else
7897         {
7898           tmp = build2 (POINTER_PLUS_EXPR, ptr_type_node,
7899                         unshare_expr (next_o), size_int (rsize));
7900           tmp = build2 (GT_EXPR, boolean_type_node, tmp,
7901                         unshare_expr (next_o_limit));
7902           tmp = build3 (COND_EXPR, void_type_node, tmp,
7903                         build1 (GOTO_EXPR, void_type_node,
7904                                 unshare_expr (lab_false)),
7905                         NULL_TREE);
7906           gimplify_and_add (tmp, pre_p);
7907
7908           tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_o));
7909           gimplify_assign (unshare_expr (addr), tmp, pre_p);
7910
7911           tmp = build1 (GOTO_EXPR, void_type_node, unshare_expr (lab_over));
7912           gimplify_and_add (tmp, pre_p);
7913
7914           tmp = build1 (LABEL_EXPR, void_type_node, unshare_expr (lab_false));
7915           gimplify_and_add (tmp, pre_p);
7916
7917           if (size > 4 && ! (TARGET_SH4 || TARGET_SH2A))
7918             gimplify_assign (unshare_expr (next_o),
7919                              unshare_expr (next_o_limit), pre_p);
7920
7921           tmp = build1 (ADDR_EXPR, pptr_type_node, unshare_expr (next_stack));
7922           gimplify_assign (unshare_expr (addr), tmp, pre_p);
7923         }
7924
7925       if (!result)
7926         {
7927           tmp = build1 (LABEL_EXPR, void_type_node, unshare_expr (lab_over));
7928           gimplify_and_add (tmp, pre_p);
7929         }
7930     }
7931
7932   /* ??? In va-sh.h, there had been code to make values larger than
7933      size 8 indirect.  This does not match the FUNCTION_ARG macros.  */
7934
7935   tmp = std_gimplify_va_arg_expr (valist, type, pre_p, NULL);
7936   if (result)
7937     {
7938       gimplify_assign (result, tmp, pre_p);
7939       result = build1 (NOP_EXPR, TREE_TYPE (result), result);
7940       tmp = build1 (LABEL_EXPR, void_type_node, unshare_expr (lab_over));
7941       gimplify_and_add (tmp, pre_p);
7942     }
7943   else
7944     result = tmp;
7945
7946   if (pass_by_ref)
7947     result = build_va_arg_indirect_ref (result);
7948
7949   return result;
7950 }
7951
7952 /* 64 bit floating points memory transfers are paired single precision loads
7953    or store. So DWARF information needs fixing in little endian (unless
7954    PR=SZ=1 in FPSCR).  */
7955 rtx
7956 sh_dwarf_register_span (rtx reg)
7957 {
7958   unsigned regno = REGNO (reg);
7959
7960   if (WORDS_BIG_ENDIAN || GET_MODE (reg) != DFmode)
7961     return NULL_RTX;
7962
7963   return
7964     gen_rtx_PARALLEL (VOIDmode,
7965                       gen_rtvec (2,
7966                                  gen_rtx_REG (SFmode,
7967                                               DBX_REGISTER_NUMBER (regno+1)),
7968                                  gen_rtx_REG (SFmode,
7969                                               DBX_REGISTER_NUMBER (regno))));
7970 }
7971
7972 static enum machine_mode
7973 sh_promote_function_mode (const_tree type, enum machine_mode mode,
7974                           int *punsignedp, const_tree funtype,
7975                           int for_return ATTRIBUTE_UNUSED)
7976 {
7977   if (sh_promote_prototypes (funtype))
7978     return promote_mode (type, mode, punsignedp);
7979   else
7980     return mode;
7981 }
7982
7983 static bool
7984 sh_promote_prototypes (const_tree type)
7985 {
7986   if (TARGET_HITACHI)
7987     return 0;
7988   if (! type)
7989     return 1;
7990   return ! sh_attr_renesas_p (type);
7991 }
7992
7993 /* Whether an argument must be passed by reference.  On SHcompact, we
7994    pretend arguments wider than 32-bits that would have been passed in
7995    registers are passed by reference, so that an SHmedia trampoline
7996    loads them into the full 64-bits registers.  */
7997
7998 static int
7999 shcompact_byref (const CUMULATIVE_ARGS *cum, enum machine_mode mode,
8000                  const_tree type, bool named)
8001 {
8002   unsigned HOST_WIDE_INT size;
8003
8004   if (type)
8005     size = int_size_in_bytes (type);
8006   else
8007     size = GET_MODE_SIZE (mode);
8008
8009   if (cum->arg_count[SH_ARG_INT] < NPARM_REGS (SImode)
8010       && (!named
8011           || GET_SH_ARG_CLASS (mode) == SH_ARG_INT
8012           || (GET_SH_ARG_CLASS (mode) == SH_ARG_FLOAT
8013               && cum->arg_count[SH_ARG_FLOAT] >= NPARM_REGS (SFmode)))
8014       && size > 4
8015       && !SHCOMPACT_FORCE_ON_STACK (mode, type)
8016       && !SH5_WOULD_BE_PARTIAL_NREGS (*cum, mode, type, named))
8017     return size;
8018   else
8019     return 0;
8020 }
8021
8022 static bool
8023 sh_pass_by_reference (CUMULATIVE_ARGS *cum, enum machine_mode mode,
8024                       const_tree type, bool named)
8025 {
8026   if (targetm.calls.must_pass_in_stack (mode, type))
8027     return true;
8028
8029   /* ??? std_gimplify_va_arg_expr passes NULL for cum.  That function
8030      wants to know about pass-by-reference semantics for incoming
8031      arguments.  */
8032   if (! cum)
8033     return false;
8034
8035   if (TARGET_SHCOMPACT)
8036     {
8037       cum->byref = shcompact_byref (cum, mode, type, named);
8038       return cum->byref != 0;
8039     }
8040
8041   return false;
8042 }
8043
8044 static bool
8045 sh_callee_copies (CUMULATIVE_ARGS *cum, enum machine_mode mode,
8046                   const_tree type, bool named ATTRIBUTE_UNUSED)
8047 {
8048   /* ??? How can it possibly be correct to return true only on the
8049      caller side of the equation?  Is there someplace else in the
8050      sh backend that's magically producing the copies?  */
8051   return (cum->outgoing
8052           && ((mode == BLKmode ? TYPE_ALIGN (type) : GET_MODE_ALIGNMENT (mode))
8053               % SH_MIN_ALIGN_FOR_CALLEE_COPY == 0));
8054 }
8055
8056 static int
8057 sh_arg_partial_bytes (CUMULATIVE_ARGS *cum, enum machine_mode mode,
8058                       tree type, bool named ATTRIBUTE_UNUSED)
8059 {
8060   int words = 0;
8061
8062   if (!TARGET_SH5
8063       && PASS_IN_REG_P (*cum, mode, type)
8064       && !(TARGET_SH4 || TARGET_SH2A_DOUBLE)
8065       && (ROUND_REG (*cum, mode)
8066           + (mode != BLKmode
8067              ? ROUND_ADVANCE (GET_MODE_SIZE (mode))
8068              : ROUND_ADVANCE (int_size_in_bytes (type)))
8069           > NPARM_REGS (mode)))
8070     words = NPARM_REGS (mode) - ROUND_REG (*cum, mode);
8071
8072   else if (!TARGET_SHCOMPACT
8073            && SH5_WOULD_BE_PARTIAL_NREGS (*cum, mode, type, named))
8074     words = NPARM_REGS (SImode) - cum->arg_count[SH_ARG_INT];
8075
8076   return words * UNITS_PER_WORD;
8077 }
8078
8079
8080 /* Define where to put the arguments to a function.
8081    Value is zero to push the argument on the stack,
8082    or a hard register in which to store the argument.
8083
8084    MODE is the argument's machine mode.
8085    TYPE is the data type of the argument (as a tree).
8086     This is null for libcalls where that information may
8087     not be available.
8088    CUM is a variable of type CUMULATIVE_ARGS which gives info about
8089     the preceding args and about the function being called.
8090    NAMED is nonzero if this argument is a named parameter
8091     (otherwise it is an extra parameter matching an ellipsis).
8092
8093    On SH the first args are normally in registers
8094    and the rest are pushed.  Any arg that starts within the first
8095    NPARM_REGS words is at least partially passed in a register unless
8096    its data type forbids.  */
8097
8098
8099 rtx
8100 sh_function_arg (CUMULATIVE_ARGS *ca, enum machine_mode mode,
8101                  tree type, int named)
8102 {
8103   if (! TARGET_SH5 && mode == VOIDmode)
8104     return GEN_INT (ca->renesas_abi ? 1 : 0);
8105
8106   if (! TARGET_SH5
8107       && PASS_IN_REG_P (*ca, mode, type)
8108       && (named || ! (TARGET_HITACHI || ca->renesas_abi)))
8109     {
8110       int regno;
8111
8112       if (mode == SCmode && TARGET_SH4 && TARGET_LITTLE_ENDIAN
8113           && (! FUNCTION_ARG_SCmode_WART || (ROUND_REG (*ca, mode) & 1)))
8114         {
8115           rtx r1 = gen_rtx_EXPR_LIST (VOIDmode,
8116                                       gen_rtx_REG (SFmode,
8117                                                    BASE_ARG_REG (mode)
8118                                                    + (ROUND_REG (*ca, mode) ^ 1)),
8119                                       const0_rtx);
8120           rtx r2 = gen_rtx_EXPR_LIST (VOIDmode,
8121                                       gen_rtx_REG (SFmode,
8122                                                    BASE_ARG_REG (mode)
8123                                                    + ((ROUND_REG (*ca, mode) + 1) ^ 1)),
8124                                       GEN_INT (4));
8125           return gen_rtx_PARALLEL(SCmode, gen_rtvec(2, r1, r2));
8126         }
8127
8128      /* If the alignment of a DF value causes an SF register to be
8129         skipped, we will use that skipped register for the next SF
8130         value.  */
8131       if ((TARGET_HITACHI || ca->renesas_abi)
8132           && ca->free_single_fp_reg
8133           && mode == SFmode)
8134         return gen_rtx_REG (mode, ca->free_single_fp_reg);
8135
8136       regno = (BASE_ARG_REG (mode) + ROUND_REG (*ca, mode))
8137                ^ (mode == SFmode && TARGET_SH4
8138                   && TARGET_LITTLE_ENDIAN != 0
8139                   && ! TARGET_HITACHI && ! ca->renesas_abi);
8140       return gen_rtx_REG (mode, regno);
8141
8142     }
8143
8144   if (TARGET_SH5)
8145     {
8146       if (mode == VOIDmode && TARGET_SHCOMPACT)
8147         return GEN_INT (ca->call_cookie);
8148
8149       /* The following test assumes unnamed arguments are promoted to
8150          DFmode.  */
8151       if (mode == SFmode && ca->free_single_fp_reg)
8152         return SH5_PROTOTYPED_FLOAT_ARG (*ca, mode, ca->free_single_fp_reg);
8153
8154       if ((GET_SH_ARG_CLASS (mode) == SH_ARG_FLOAT)
8155           && (named || ! ca->prototype_p)
8156           && ca->arg_count[(int) SH_ARG_FLOAT] < NPARM_REGS (SFmode))
8157         {
8158           if (! ca->prototype_p && TARGET_SHMEDIA)
8159             return SH5_PROTOTYPELESS_FLOAT_ARG (*ca, mode);
8160
8161           return SH5_PROTOTYPED_FLOAT_ARG (*ca, mode,
8162                                            FIRST_FP_PARM_REG
8163                                            + ca->arg_count[(int) SH_ARG_FLOAT]);
8164         }
8165
8166       if (ca->arg_count[(int) SH_ARG_INT] < NPARM_REGS (SImode)
8167           && (! TARGET_SHCOMPACT
8168               || (! SHCOMPACT_FORCE_ON_STACK (mode, type)
8169                   && ! SH5_WOULD_BE_PARTIAL_NREGS (*ca, mode,
8170                                                    type, named))))
8171         {
8172           return gen_rtx_REG (mode, (FIRST_PARM_REG
8173                                        + ca->arg_count[(int) SH_ARG_INT]));
8174         }
8175
8176       return 0;
8177     }
8178
8179   return 0;
8180 }
8181
8182 /* Update the data in CUM to advance over an argument
8183    of mode MODE and data type TYPE.
8184    (TYPE is null for libcalls where that information may not be
8185    available.)  */
8186
8187 void
8188 sh_function_arg_advance (CUMULATIVE_ARGS *ca, enum machine_mode mode,
8189                          tree type, int named)
8190 {
8191   if (ca->force_mem)
8192     ca->force_mem = 0;
8193   else if (TARGET_SH5)
8194     {
8195       tree type2 = (ca->byref && type
8196                     ? TREE_TYPE (type)
8197                     : type);
8198       enum machine_mode mode2 = (ca->byref && type
8199                                  ? TYPE_MODE (type2)
8200                                  : mode);
8201       int dwords = ((ca->byref
8202                      ? ca->byref
8203                      : mode2 == BLKmode
8204                      ? int_size_in_bytes (type2)
8205                      : GET_MODE_SIZE (mode2)) + 7) / 8;
8206       int numregs = MIN (dwords, NPARM_REGS (SImode)
8207                          - ca->arg_count[(int) SH_ARG_INT]);
8208
8209       if (numregs)
8210         {
8211           ca->arg_count[(int) SH_ARG_INT] += numregs;
8212           if (TARGET_SHCOMPACT
8213               && SHCOMPACT_FORCE_ON_STACK (mode2, type2))
8214             {
8215               ca->call_cookie
8216                 |= CALL_COOKIE_INT_REG (ca->arg_count[(int) SH_ARG_INT]
8217                                         - numregs, 1);
8218               /* N.B. We want this also for outgoing.  */
8219               ca->stack_regs += numregs;
8220             }
8221           else if (ca->byref)
8222             {
8223               if (! ca->outgoing)
8224                 ca->stack_regs += numregs;
8225               ca->byref_regs += numregs;
8226               ca->byref = 0;
8227               do
8228                 ca->call_cookie
8229                   |= CALL_COOKIE_INT_REG (ca->arg_count[(int) SH_ARG_INT]
8230                                           - numregs, 2);
8231               while (--numregs);
8232               ca->call_cookie
8233                 |= CALL_COOKIE_INT_REG (ca->arg_count[(int) SH_ARG_INT]
8234                                         - 1, 1);
8235             }
8236           else if (dwords > numregs)
8237             {
8238               int pushregs = numregs;
8239
8240               if (TARGET_SHCOMPACT)
8241                 ca->stack_regs += numregs;
8242               while (pushregs < NPARM_REGS (SImode) - 1
8243                      && (CALL_COOKIE_INT_REG_GET
8244                          (ca->call_cookie,
8245                           NPARM_REGS (SImode) - pushregs)
8246                          == 1))
8247                 {
8248                   ca->call_cookie
8249                     &= ~ CALL_COOKIE_INT_REG (NPARM_REGS (SImode)
8250                                               - pushregs, 1);
8251                   pushregs++;
8252                 }
8253               if (numregs == NPARM_REGS (SImode))
8254                 ca->call_cookie
8255                   |= CALL_COOKIE_INT_REG (0, 1)
8256                   | CALL_COOKIE_STACKSEQ (numregs - 1);
8257               else
8258                 ca->call_cookie
8259                   |= CALL_COOKIE_STACKSEQ (numregs);
8260             }
8261         }
8262       if (GET_SH_ARG_CLASS (mode2) == SH_ARG_FLOAT
8263           && (named || ! ca->prototype_p))
8264         {
8265           if (mode2 == SFmode && ca->free_single_fp_reg)
8266             ca->free_single_fp_reg = 0;
8267           else if (ca->arg_count[(int) SH_ARG_FLOAT]
8268                    < NPARM_REGS (SFmode))
8269             {
8270               int numfpregs
8271                 = MIN ((GET_MODE_SIZE (mode2) + 7) / 8 * 2,
8272                        NPARM_REGS (SFmode)
8273                        - ca->arg_count[(int) SH_ARG_FLOAT]);
8274
8275               ca->arg_count[(int) SH_ARG_FLOAT] += numfpregs;
8276
8277               if (TARGET_SHCOMPACT && ! ca->prototype_p)
8278                 {
8279                   if (ca->outgoing && numregs > 0)
8280                     do
8281                       {
8282                         ca->call_cookie
8283                           |= (CALL_COOKIE_INT_REG
8284                               (ca->arg_count[(int) SH_ARG_INT]
8285                                - numregs + ((numfpregs - 2) / 2),
8286                                4 + (ca->arg_count[(int) SH_ARG_FLOAT]
8287                                     - numfpregs) / 2));
8288                       }
8289                     while (numfpregs -= 2);
8290                 }
8291               else if (mode2 == SFmode && (named)
8292                        && (ca->arg_count[(int) SH_ARG_FLOAT]
8293                            < NPARM_REGS (SFmode)))
8294                 ca->free_single_fp_reg
8295                   = FIRST_FP_PARM_REG - numfpregs
8296                   + ca->arg_count[(int) SH_ARG_FLOAT] + 1;
8297             }
8298         }
8299       return;
8300     }
8301
8302   if ((TARGET_HITACHI || ca->renesas_abi) && TARGET_FPU_DOUBLE)
8303     {
8304       /* Note that we've used the skipped register.  */
8305       if (mode == SFmode && ca->free_single_fp_reg)
8306         {
8307           ca->free_single_fp_reg = 0;
8308           return;
8309         }
8310       /* When we have a DF after an SF, there's an SF register that get
8311          skipped in order to align the DF value.  We note this skipped
8312          register, because the next SF value will use it, and not the
8313          SF that follows the DF.  */
8314       if (mode == DFmode
8315           && ROUND_REG (*ca, DFmode) != ROUND_REG (*ca, SFmode))
8316         {
8317           ca->free_single_fp_reg = (ROUND_REG (*ca, SFmode)
8318                                     + BASE_ARG_REG (mode));
8319         }
8320     }
8321
8322   if (! ((TARGET_SH4 || TARGET_SH2A) || ca->renesas_abi)
8323       || PASS_IN_REG_P (*ca, mode, type))
8324     (ca->arg_count[(int) GET_SH_ARG_CLASS (mode)]
8325      = (ROUND_REG (*ca, mode)
8326         + (mode == BLKmode
8327            ? ROUND_ADVANCE (int_size_in_bytes (type))
8328            : ROUND_ADVANCE (GET_MODE_SIZE (mode)))));
8329 }
8330
8331 /* The Renesas calling convention doesn't quite fit into this scheme since
8332    the address is passed like an invisible argument, but one that is always
8333    passed in memory.  */
8334 static rtx
8335 sh_struct_value_rtx (tree fndecl, int incoming ATTRIBUTE_UNUSED)
8336 {
8337   if (TARGET_HITACHI || sh_attr_renesas_p (fndecl))
8338     return 0;
8339   return gen_rtx_REG (Pmode, 2);
8340 }
8341
8342 /* Worker function for TARGET_FUNCTION_VALUE.
8343
8344    For the SH, this is like LIBCALL_VALUE, except that we must change the
8345    mode like PROMOTE_MODE does.
8346    ??? PROMOTE_MODE is ignored for non-scalar types.  The set of types
8347    tested here has to be kept in sync with the one in explow.c:promote_mode.
8348 */
8349
8350 static rtx
8351 sh_function_value (const_tree valtype,
8352                    const_tree fn_decl_or_type,
8353                    bool outgoing ATTRIBUTE_UNUSED)
8354 {
8355   if (fn_decl_or_type
8356       && !DECL_P (fn_decl_or_type))
8357     fn_decl_or_type = NULL;
8358
8359   return gen_rtx_REG (
8360            ((GET_MODE_CLASS (TYPE_MODE (valtype)) == MODE_INT
8361              && GET_MODE_SIZE (TYPE_MODE (valtype)) < 4
8362              && (TREE_CODE (valtype) == INTEGER_TYPE
8363                  || TREE_CODE (valtype) == ENUMERAL_TYPE
8364                  || TREE_CODE (valtype) == BOOLEAN_TYPE
8365                  || TREE_CODE (valtype) == REAL_TYPE
8366                  || TREE_CODE (valtype) == OFFSET_TYPE))
8367             && sh_promote_prototypes (fn_decl_or_type)
8368             ? (TARGET_SHMEDIA64 ? DImode : SImode) : TYPE_MODE (valtype)),
8369            BASE_RETURN_VALUE_REG (TYPE_MODE (valtype)));
8370 }
8371
8372 /* Worker function for TARGET_LIBCALL_VALUE.  */
8373
8374 static rtx
8375 sh_libcall_value (enum machine_mode mode, const_rtx fun ATTRIBUTE_UNUSED)
8376 {
8377   return gen_rtx_REG (mode, BASE_RETURN_VALUE_REG (mode));
8378 }
8379
8380 /* Worker function for FUNCTION_VALUE_REGNO_P.  */
8381
8382 bool
8383 sh_function_value_regno_p (const unsigned int regno)
8384 {
8385   return ((regno) == FIRST_RET_REG
8386           || (TARGET_SH2E && (regno) == FIRST_FP_RET_REG)
8387           || (TARGET_SHMEDIA_FPU && (regno) == FIRST_FP_RET_REG));
8388 }
8389
8390 /* Worker function for TARGET_RETURN_IN_MEMORY.  */
8391
8392 static bool
8393 sh_return_in_memory (const_tree type, const_tree fndecl)
8394 {
8395   if (TARGET_SH5)
8396     {
8397       if (TYPE_MODE (type) == BLKmode)
8398         return ((unsigned HOST_WIDE_INT) int_size_in_bytes (type)) > 8;
8399       else
8400         return GET_MODE_SIZE (TYPE_MODE (type)) > 8;
8401     }
8402   else
8403     {
8404       return (TYPE_MODE (type) == BLKmode
8405               || ((TARGET_HITACHI || sh_attr_renesas_p (fndecl))
8406                   && TREE_CODE (type) == RECORD_TYPE));
8407     }
8408 }
8409
8410 /* We actually emit the code in sh_expand_prologue.  We used to use
8411    a static variable to flag that we need to emit this code, but that
8412    doesn't when inlining, when functions are deferred and then emitted
8413    later.  Fortunately, we already have two flags that are part of struct
8414    function that tell if a function uses varargs or stdarg.  */
8415 static void
8416 sh_setup_incoming_varargs (CUMULATIVE_ARGS *ca,
8417                            enum machine_mode mode,
8418                            tree type,
8419                            int *pretend_arg_size,
8420                            int second_time ATTRIBUTE_UNUSED)
8421 {
8422   gcc_assert (cfun->stdarg);
8423   if (TARGET_VARARGS_PRETEND_ARGS (current_function_decl))
8424     {
8425       int named_parm_regs, anon_parm_regs;
8426
8427       named_parm_regs = (ROUND_REG (*ca, mode)
8428                          + (mode == BLKmode
8429                             ? ROUND_ADVANCE (int_size_in_bytes (type))
8430                             : ROUND_ADVANCE (GET_MODE_SIZE (mode))));
8431       anon_parm_regs = NPARM_REGS (SImode) - named_parm_regs;
8432       if (anon_parm_regs > 0)
8433         *pretend_arg_size = anon_parm_regs * 4;
8434     }
8435 }
8436
8437 static bool
8438 sh_strict_argument_naming (CUMULATIVE_ARGS *ca ATTRIBUTE_UNUSED)
8439 {
8440   return TARGET_SH5;
8441 }
8442
8443 static bool
8444 sh_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *ca)
8445 {
8446   return ! (TARGET_HITACHI || ca->renesas_abi) && ! TARGET_SH5;
8447 }
8448
8449
8450 /* Define the offset between two registers, one to be eliminated, and
8451    the other its replacement, at the start of a routine.  */
8452
8453 int
8454 initial_elimination_offset (int from, int to)
8455 {
8456   int regs_saved;
8457   int regs_saved_rounding = 0;
8458   int total_saved_regs_space;
8459   int total_auto_space;
8460   int save_flags = target_flags;
8461   int copy_flags;
8462   HARD_REG_SET live_regs_mask;
8463
8464   shmedia_space_reserved_for_target_registers = false;
8465   regs_saved = calc_live_regs (&live_regs_mask);
8466   regs_saved += SHMEDIA_REGS_STACK_ADJUST ();
8467
8468   if (shmedia_reserve_space_for_target_registers_p (regs_saved, &live_regs_mask))
8469     {
8470       shmedia_space_reserved_for_target_registers = true;
8471       regs_saved += shmedia_target_regs_stack_adjust (&live_regs_mask);
8472     }
8473
8474   if (TARGET_SH5 && regs_saved % (STACK_BOUNDARY / BITS_PER_UNIT))
8475     regs_saved_rounding = ((STACK_BOUNDARY / BITS_PER_UNIT)
8476                            - regs_saved % (STACK_BOUNDARY / BITS_PER_UNIT));
8477
8478   total_auto_space = rounded_frame_size (regs_saved) - regs_saved_rounding;
8479   copy_flags = target_flags;
8480   target_flags = save_flags;
8481
8482   total_saved_regs_space = regs_saved + regs_saved_rounding;
8483
8484   if (from == ARG_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
8485     return total_saved_regs_space + total_auto_space
8486       + crtl->args.info.byref_regs * 8;
8487
8488   if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
8489     return total_saved_regs_space + total_auto_space
8490       + crtl->args.info.byref_regs * 8;
8491
8492   /* Initial gap between fp and sp is 0.  */
8493   if (from == HARD_FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
8494     return 0;
8495
8496   if (from == FRAME_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
8497     return rounded_frame_size (0);
8498
8499   if (from == FRAME_POINTER_REGNUM && to == HARD_FRAME_POINTER_REGNUM)
8500     return rounded_frame_size (0);
8501
8502   gcc_assert (from == RETURN_ADDRESS_POINTER_REGNUM
8503               && (to == HARD_FRAME_POINTER_REGNUM
8504                   || to == STACK_POINTER_REGNUM));
8505   if (TARGET_SH5)
8506     {
8507       int n = total_saved_regs_space;
8508       int pr_reg = TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG;
8509       save_schedule schedule;
8510       save_entry *entry;
8511
8512       n += total_auto_space;
8513
8514       /* If it wasn't saved, there's not much we can do.  */
8515       if (! TEST_HARD_REG_BIT (live_regs_mask, pr_reg))
8516         return n;
8517
8518       target_flags = copy_flags;
8519
8520       sh5_schedule_saves (&live_regs_mask, &schedule, n);
8521       for (entry = &schedule.entries[1]; entry->mode != VOIDmode; entry++)
8522         if (entry->reg == pr_reg)
8523           {
8524             target_flags = save_flags;
8525             return entry->offset;
8526           }
8527       gcc_unreachable ();
8528     }
8529   else
8530     return total_auto_space;
8531 }
8532
8533 /* Parse the -mfixed-range= option string.  */
8534 void
8535 sh_fix_range (const char *const_str)
8536 {
8537   int i, first, last;
8538   char *str, *dash, *comma;
8539
8540   /* str must be of the form REG1'-'REG2{,REG1'-'REG} where REG1 and
8541      REG2 are either register names or register numbers.  The effect
8542      of this option is to mark the registers in the range from REG1 to
8543      REG2 as ``fixed'' so they won't be used by the compiler.  */
8544
8545   i = strlen (const_str);
8546   str = (char *) alloca (i + 1);
8547   memcpy (str, const_str, i + 1);
8548
8549   while (1)
8550     {
8551       dash = strchr (str, '-');
8552       if (!dash)
8553         {
8554           warning (0, "value of -mfixed-range must have form REG1-REG2");
8555           return;
8556         }
8557       *dash = '\0';
8558       comma = strchr (dash + 1, ',');
8559       if (comma)
8560         *comma = '\0';
8561
8562       first = decode_reg_name (str);
8563       if (first < 0)
8564         {
8565           warning (0, "unknown register name: %s", str);
8566           return;
8567         }
8568
8569       last = decode_reg_name (dash + 1);
8570       if (last < 0)
8571         {
8572           warning (0, "unknown register name: %s", dash + 1);
8573           return;
8574         }
8575
8576       *dash = '-';
8577
8578       if (first > last)
8579         {
8580           warning (0, "%s-%s is an empty range", str, dash + 1);
8581           return;
8582         }
8583
8584       for (i = first; i <= last; ++i)
8585         fixed_regs[i] = call_used_regs[i] = 1;
8586
8587       if (!comma)
8588         break;
8589
8590       *comma = ',';
8591       str = comma + 1;
8592     }
8593 }
8594 \f
8595 /* Insert any deferred function attributes from earlier pragmas.  */
8596 static void
8597 sh_insert_attributes (tree node, tree *attributes)
8598 {
8599   tree attrs;
8600
8601   if (TREE_CODE (node) != FUNCTION_DECL)
8602     return;
8603
8604   /* We are only interested in fields.  */
8605   if (!DECL_P (node))
8606     return;
8607
8608   /* Append the attributes to the deferred attributes.  */
8609   *sh_deferred_function_attributes_tail = *attributes;
8610   attrs = sh_deferred_function_attributes;
8611   if (!attrs)
8612     return;
8613
8614   /* Some attributes imply or require the interrupt attribute.  */
8615   if (!lookup_attribute ("interrupt_handler", attrs)
8616       && !lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (node)))
8617     {
8618       /* If we have a trapa_handler, but no interrupt_handler attribute,
8619          insert an interrupt_handler attribute.  */
8620       if (lookup_attribute ("trapa_handler", attrs) != NULL_TREE)
8621         /* We can't use sh_pr_interrupt here because that's not in the
8622            java frontend.  */
8623         attrs
8624           = tree_cons (get_identifier("interrupt_handler"), NULL_TREE, attrs);
8625       /* However, for sp_switch, trap_exit, nosave_low_regs and resbank,
8626          if the interrupt attribute is missing, we ignore the attribute
8627          and warn.  */
8628       else if (lookup_attribute ("sp_switch", attrs)
8629                || lookup_attribute ("trap_exit", attrs)
8630                || lookup_attribute ("nosave_low_regs", attrs)
8631                || lookup_attribute ("resbank", attrs))
8632         {
8633           tree *tail;
8634
8635           for (tail = attributes; attrs; attrs = TREE_CHAIN (attrs))
8636             {
8637               if (is_attribute_p ("sp_switch", TREE_PURPOSE (attrs))
8638                   || is_attribute_p ("trap_exit", TREE_PURPOSE (attrs))
8639                   || is_attribute_p ("nosave_low_regs", TREE_PURPOSE (attrs))
8640                   || is_attribute_p ("resbank", TREE_PURPOSE (attrs)))
8641                 warning (OPT_Wattributes,
8642                          "%qE attribute only applies to interrupt functions",
8643                          TREE_PURPOSE (attrs));
8644               else
8645                 {
8646                   *tail = tree_cons (TREE_PURPOSE (attrs), NULL_TREE,
8647                                      NULL_TREE);
8648                   tail = &TREE_CHAIN (*tail);
8649                 }
8650             }
8651           attrs = *attributes;
8652         }
8653     }
8654
8655   /* Install the processed list.  */
8656   *attributes = attrs;
8657
8658   /* Clear deferred attributes.  */
8659   sh_deferred_function_attributes = NULL_TREE;
8660   sh_deferred_function_attributes_tail = &sh_deferred_function_attributes;
8661
8662   return;
8663 }
8664
8665 /* Supported attributes:
8666
8667    interrupt_handler -- specifies this function is an interrupt handler.
8668
8669    trapa_handler - like above, but don't save all registers.
8670
8671    sp_switch -- specifies an alternate stack for an interrupt handler
8672    to run on.
8673
8674    trap_exit -- use a trapa to exit an interrupt function instead of
8675    an rte instruction.
8676
8677    nosave_low_regs - don't save r0..r7 in an interrupt handler.
8678      This is useful on the SH3 and upwards,
8679      which has a separate set of low regs for User and Supervisor modes.
8680      This should only be used for the lowest level of interrupts.  Higher levels
8681      of interrupts must save the registers in case they themselves are
8682      interrupted.
8683
8684    renesas -- use Renesas calling/layout conventions (functions and
8685    structures).
8686
8687    resbank -- In case of an ISR, use a register bank to save registers
8688    R0-R14, MACH, MACL, GBR and PR.  This is useful only on SH2A targets.
8689 */
8690
8691 /* Handle a 'resbank' attribute.  */
8692 static tree
8693 sh_handle_resbank_handler_attribute (tree * node, tree name,
8694                                      tree args ATTRIBUTE_UNUSED,
8695                                      int flags ATTRIBUTE_UNUSED,
8696                                      bool * no_add_attrs)
8697 {
8698   if (!TARGET_SH2A)
8699     {
8700       warning (OPT_Wattributes, "%qE attribute is supported only for SH2A",
8701                name);
8702       *no_add_attrs = true;
8703     }
8704   if (TREE_CODE (*node) != FUNCTION_DECL)
8705     {
8706       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8707                name);
8708       *no_add_attrs = true;
8709     }
8710
8711   return NULL_TREE;
8712 }
8713
8714 /* Handle an "interrupt_handler" attribute; arguments as in
8715    struct attribute_spec.handler.  */
8716 static tree
8717 sh_handle_interrupt_handler_attribute (tree *node, tree name,
8718                                        tree args ATTRIBUTE_UNUSED,
8719                                        int flags ATTRIBUTE_UNUSED,
8720                                        bool *no_add_attrs)
8721 {
8722   if (TREE_CODE (*node) != FUNCTION_DECL)
8723     {
8724       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8725                name);
8726       *no_add_attrs = true;
8727     }
8728   else if (TARGET_SHCOMPACT)
8729     {
8730       error ("attribute interrupt_handler is not compatible with -m5-compact");
8731       *no_add_attrs = true;
8732     }
8733
8734   return NULL_TREE;
8735 }
8736
8737 /* Handle an 'function_vector' attribute; arguments as in
8738    struct attribute_spec.handler.  */
8739 static tree
8740 sh2a_handle_function_vector_handler_attribute (tree * node, tree name,
8741                                                tree args ATTRIBUTE_UNUSED,
8742                                                int flags ATTRIBUTE_UNUSED,
8743                                                bool * no_add_attrs)
8744 {
8745   if (!TARGET_SH2A)
8746     {
8747       warning (OPT_Wattributes, "%qE attribute only applies to SH2A",
8748                name);
8749       *no_add_attrs = true;
8750     }
8751   else if (TREE_CODE (*node) != FUNCTION_DECL)
8752     {
8753       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8754                name);
8755       *no_add_attrs = true;
8756     }
8757   else if (TREE_CODE (TREE_VALUE (args)) != INTEGER_CST)
8758     {
8759       /* The argument must be a constant integer.  */
8760       warning (OPT_Wattributes,
8761                "%qE attribute argument not an integer constant",
8762                name);
8763       *no_add_attrs = true;
8764     }
8765   else if (TREE_INT_CST_LOW (TREE_VALUE (args)) > 255)
8766     {
8767       /* The argument value must be between 0 to 255.  */
8768       warning (OPT_Wattributes,
8769                "%qE attribute argument should be between 0 to 255",
8770                name);
8771       *no_add_attrs = true;
8772     }
8773   return NULL_TREE;
8774 }
8775
8776 /* Returns 1 if current function has been assigned the attribute
8777    'function_vector'.  */
8778 int
8779 sh2a_is_function_vector_call (rtx x)
8780 {
8781   if (GET_CODE (x) == SYMBOL_REF
8782       && (SYMBOL_REF_FLAGS (x) & SYMBOL_FLAG_FUNCVEC_FUNCTION))
8783     {
8784       tree tr = SYMBOL_REF_DECL (x);
8785
8786       if (sh2a_function_vector_p (tr))
8787         return 1;
8788     }
8789
8790   return 0;
8791 }
8792
8793 /* Returns the function vector number, if the the attribute
8794    'function_vector' is assigned, otherwise returns zero.  */
8795 int
8796 sh2a_get_function_vector_number (rtx x)
8797 {
8798   int num;
8799   tree list, t;
8800
8801   if ((GET_CODE (x) == SYMBOL_REF)
8802       && (SYMBOL_REF_FLAGS (x) & SYMBOL_FLAG_FUNCVEC_FUNCTION))
8803     {
8804       t = SYMBOL_REF_DECL (x);
8805
8806       if (TREE_CODE (t) != FUNCTION_DECL)
8807         return 0;
8808
8809       list = SH_ATTRIBUTES (t);
8810       while (list)
8811         {
8812           if (is_attribute_p ("function_vector", TREE_PURPOSE (list)))
8813             {
8814               num = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list)));
8815               return num;
8816             }
8817
8818           list = TREE_CHAIN (list);
8819         }
8820
8821       return 0;
8822     }
8823   else
8824     return 0;
8825 }
8826
8827 /* Handle an "sp_switch" attribute; arguments as in
8828    struct attribute_spec.handler.  */
8829 static tree
8830 sh_handle_sp_switch_attribute (tree *node, tree name, tree args,
8831                                int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
8832 {
8833   if (TREE_CODE (*node) != FUNCTION_DECL)
8834     {
8835       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8836                name);
8837       *no_add_attrs = true;
8838     }
8839   else if (TREE_CODE (TREE_VALUE (args)) != STRING_CST)
8840     {
8841       /* The argument must be a constant string.  */
8842       warning (OPT_Wattributes, "%qE attribute argument not a string constant",
8843                name);
8844       *no_add_attrs = true;
8845     }
8846
8847   return NULL_TREE;
8848 }
8849
8850 /* Handle an "trap_exit" attribute; arguments as in
8851    struct attribute_spec.handler.  */
8852 static tree
8853 sh_handle_trap_exit_attribute (tree *node, tree name, tree args,
8854                                int flags ATTRIBUTE_UNUSED, bool *no_add_attrs)
8855 {
8856   if (TREE_CODE (*node) != FUNCTION_DECL)
8857     {
8858       warning (OPT_Wattributes, "%qE attribute only applies to functions",
8859                name);
8860       *no_add_attrs = true;
8861     }
8862   /* The argument specifies a trap number to be used in a trapa instruction
8863      at function exit (instead of an rte instruction).  */
8864   else if (TREE_CODE (TREE_VALUE (args)) != INTEGER_CST)
8865     {
8866       /* The argument must be a constant integer.  */
8867       warning (OPT_Wattributes, "%qE attribute argument not an "
8868                "integer constant", name);
8869       *no_add_attrs = true;
8870     }
8871
8872   return NULL_TREE;
8873 }
8874
8875 static tree
8876 sh_handle_renesas_attribute (tree *node ATTRIBUTE_UNUSED,
8877                              tree name ATTRIBUTE_UNUSED,
8878                              tree args ATTRIBUTE_UNUSED,
8879                              int flags ATTRIBUTE_UNUSED,
8880                              bool *no_add_attrs ATTRIBUTE_UNUSED)
8881 {
8882   return NULL_TREE;
8883 }
8884
8885 /* True if __attribute__((renesas)) or -mrenesas.  */
8886 int
8887 sh_attr_renesas_p (const_tree td)
8888 {
8889   if (TARGET_HITACHI)
8890     return 1;
8891   if (td == 0)
8892     return 0;
8893   if (DECL_P (td))
8894     td = TREE_TYPE (td);
8895   if (td == error_mark_node)
8896     return 0;
8897   return (lookup_attribute ("renesas", TYPE_ATTRIBUTES (td))
8898           != NULL_TREE);
8899 }
8900
8901 /* True if __attribute__((renesas)) or -mrenesas, for the current
8902    function.  */
8903 int
8904 sh_cfun_attr_renesas_p (void)
8905 {
8906   return sh_attr_renesas_p (current_function_decl);
8907 }
8908
8909 int
8910 sh_cfun_interrupt_handler_p (void)
8911 {
8912   return (lookup_attribute ("interrupt_handler",
8913                             DECL_ATTRIBUTES (current_function_decl))
8914           != NULL_TREE);
8915 }
8916
8917 /* Returns 1 if FUNC has been assigned the attribute
8918    "function_vector".  */
8919 int
8920 sh2a_function_vector_p (tree func)
8921 {
8922   tree list;
8923   if (TREE_CODE (func) != FUNCTION_DECL)
8924     return 0;
8925
8926   list = SH_ATTRIBUTES (func);
8927   while (list)
8928     {
8929       if (is_attribute_p ("function_vector", TREE_PURPOSE (list)))
8930         return 1;
8931
8932       list = TREE_CHAIN (list);
8933     }
8934   return 0;
8935 }
8936
8937 /* Returns TRUE if given tree has the "resbank" attribute.  */
8938
8939 int
8940 sh_cfun_resbank_handler_p (void)
8941 {
8942   return ((lookup_attribute ("resbank",
8943                              DECL_ATTRIBUTES (current_function_decl))
8944            != NULL_TREE)
8945           && (lookup_attribute ("interrupt_handler",
8946                                 DECL_ATTRIBUTES (current_function_decl))
8947               != NULL_TREE) && TARGET_SH2A);
8948 }
8949
8950 /* Implement TARGET_CHECK_PCH_TARGET_FLAGS.  */
8951
8952 static const char *
8953 sh_check_pch_target_flags (int old_flags)
8954 {
8955   if ((old_flags ^ target_flags) & (MASK_SH1 | MASK_SH2 | MASK_SH3
8956                                     | MASK_SH_E | MASK_HARD_SH4
8957                                     | MASK_FPU_SINGLE | MASK_SH4))
8958     return _("created and used with different architectures / ABIs");
8959   if ((old_flags ^ target_flags) & MASK_HITACHI)
8960     return _("created and used with different ABIs");
8961   if ((old_flags ^ target_flags) & MASK_LITTLE_ENDIAN)
8962     return _("created and used with different endianness");
8963   return NULL;
8964 }
8965 \f
8966 /* Predicates used by the templates.  */
8967
8968 /* Returns 1 if OP is MACL, MACH or PR.  The input must be a REG rtx.
8969    Used only in general_movsrc_operand.  */
8970
8971 int
8972 system_reg_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
8973 {
8974   switch (REGNO (op))
8975     {
8976     case PR_REG:
8977     case MACL_REG:
8978     case MACH_REG:
8979       return 1;
8980     }
8981   return 0;
8982 }
8983
8984 /* Nonzero if OP is a floating point value with value 0.0.  */
8985
8986 int
8987 fp_zero_operand (rtx op)
8988 {
8989   REAL_VALUE_TYPE r;
8990
8991   if (GET_MODE (op) != SFmode)
8992     return 0;
8993
8994   REAL_VALUE_FROM_CONST_DOUBLE (r, op);
8995   return REAL_VALUES_EQUAL (r, dconst0) && ! REAL_VALUE_MINUS_ZERO (r);
8996 }
8997
8998 /* Nonzero if OP is a floating point value with value 1.0.  */
8999
9000 int
9001 fp_one_operand (rtx op)
9002 {
9003   REAL_VALUE_TYPE r;
9004
9005   if (GET_MODE (op) != SFmode)
9006     return 0;
9007
9008   REAL_VALUE_FROM_CONST_DOUBLE (r, op);
9009   return REAL_VALUES_EQUAL (r, dconst1);
9010 }
9011
9012 /* In general mode switching is used.  If we are
9013    compiling without -mfmovd, movsf_ie isn't taken into account for
9014    mode switching.  We could check in machine_dependent_reorg for
9015    cases where we know we are in single precision mode, but there is
9016    interface to find that out during reload, so we must avoid
9017    choosing an fldi alternative during reload and thus failing to
9018    allocate a scratch register for the constant loading.  */
9019 int
9020 fldi_ok (void)
9021 {
9022   return 1;
9023 }
9024
9025 int
9026 tertiary_reload_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
9027 {
9028   enum rtx_code code = GET_CODE (op);
9029   return code == MEM || (TARGET_SH4 && code == CONST_DOUBLE);
9030 }
9031
9032 /* Return the TLS type for TLS symbols, 0 for otherwise.  */
9033 enum tls_model
9034 tls_symbolic_operand (rtx op, enum machine_mode mode ATTRIBUTE_UNUSED)
9035 {
9036   if (GET_CODE (op) != SYMBOL_REF)
9037     return TLS_MODEL_NONE;
9038   return SYMBOL_REF_TLS_MODEL (op);
9039 }
9040 \f
9041 /* Return the destination address of a branch.  */
9042
9043 static int
9044 branch_dest (rtx branch)
9045 {
9046   rtx dest = SET_SRC (PATTERN (branch));
9047   int dest_uid;
9048
9049   if (GET_CODE (dest) == IF_THEN_ELSE)
9050     dest = XEXP (dest, 1);
9051   dest = XEXP (dest, 0);
9052   dest_uid = INSN_UID (dest);
9053   return INSN_ADDRESSES (dest_uid);
9054 }
9055 \f
9056 /* Return nonzero if REG is not used after INSN.
9057    We assume REG is a reload reg, and therefore does
9058    not live past labels.  It may live past calls or jumps though.  */
9059 int
9060 reg_unused_after (rtx reg, rtx insn)
9061 {
9062   enum rtx_code code;
9063   rtx set;
9064
9065   /* If the reg is set by this instruction, then it is safe for our
9066      case.  Disregard the case where this is a store to memory, since
9067      we are checking a register used in the store address.  */
9068   set = single_set (insn);
9069   if (set && !MEM_P (SET_DEST (set))
9070       && reg_overlap_mentioned_p (reg, SET_DEST (set)))
9071     return 1;
9072
9073   while ((insn = NEXT_INSN (insn)))
9074     {
9075       rtx set;
9076       if (!INSN_P (insn))
9077         continue;
9078
9079       code = GET_CODE (insn);
9080
9081 #if 0
9082       /* If this is a label that existed before reload, then the register
9083          if dead here.  However, if this is a label added by reorg, then
9084          the register may still be live here.  We can't tell the difference,
9085          so we just ignore labels completely.  */
9086       if (code == CODE_LABEL)
9087         return 1;
9088       /* else */
9089 #endif
9090
9091       if (code == JUMP_INSN)
9092         return 0;
9093
9094       /* If this is a sequence, we must handle them all at once.
9095          We could have for instance a call that sets the target register,
9096          and an insn in a delay slot that uses the register.  In this case,
9097          we must return 0.  */
9098       else if (code == INSN && GET_CODE (PATTERN (insn)) == SEQUENCE)
9099         {
9100           int i;
9101           int retval = 0;
9102
9103           for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
9104             {
9105               rtx this_insn = XVECEXP (PATTERN (insn), 0, i);
9106               rtx set = single_set (this_insn);
9107
9108               if (CALL_P (this_insn))
9109                 code = CALL_INSN;
9110               else if (JUMP_P (this_insn))
9111                 {
9112                   if (INSN_ANNULLED_BRANCH_P (this_insn))
9113                     return 0;
9114                   code = JUMP_INSN;
9115                 }
9116
9117               if (set && reg_overlap_mentioned_p (reg, SET_SRC (set)))
9118                 return 0;
9119               if (set && reg_overlap_mentioned_p (reg, SET_DEST (set)))
9120                 {
9121                   if (!MEM_P (SET_DEST (set)))
9122                     retval = 1;
9123                   else
9124                     return 0;
9125                 }
9126               if (set == 0
9127                   && reg_overlap_mentioned_p (reg, PATTERN (this_insn)))
9128                 return 0;
9129             }
9130           if (retval == 1)
9131             return 1;
9132           else if (code == JUMP_INSN)
9133             return 0;
9134         }
9135
9136       set = single_set (insn);
9137       if (set && reg_overlap_mentioned_p (reg, SET_SRC (set)))
9138         return 0;
9139       if (set && reg_overlap_mentioned_p (reg, SET_DEST (set)))
9140         return !MEM_P (SET_DEST (set));
9141       if (set == 0 && reg_overlap_mentioned_p (reg, PATTERN (insn)))
9142         return 0;
9143
9144       if (code == CALL_INSN && call_really_used_regs[REGNO (reg)])
9145         return 1;
9146     }
9147   return 1;
9148 }
9149 \f
9150 #include "ggc.h"
9151
9152 static GTY(()) rtx fpscr_rtx;
9153 rtx
9154 get_fpscr_rtx (void)
9155 {
9156   if (! fpscr_rtx)
9157     {
9158       fpscr_rtx = gen_rtx_REG (PSImode, FPSCR_REG);
9159       REG_USERVAR_P (fpscr_rtx) = 1;
9160       mark_user_reg (fpscr_rtx);
9161     }
9162   if (! reload_completed || mdep_reorg_phase != SH_AFTER_MDEP_REORG)
9163     mark_user_reg (fpscr_rtx);
9164   return fpscr_rtx;
9165 }
9166
9167 static GTY(()) tree fpscr_values;
9168
9169 static void
9170 emit_fpu_switch (rtx scratch, int index)
9171 {
9172   rtx dst, src;
9173
9174   if (fpscr_values == NULL)
9175     {
9176       tree t;
9177
9178       t = build_index_type (integer_one_node);
9179       t = build_array_type (integer_type_node, t);
9180       t = build_decl (BUILTINS_LOCATION,
9181                       VAR_DECL, get_identifier ("__fpscr_values"), t);
9182       DECL_ARTIFICIAL (t) = 1;
9183       DECL_IGNORED_P (t) = 1;
9184       DECL_EXTERNAL (t) = 1;
9185       TREE_STATIC (t) = 1;
9186       TREE_PUBLIC (t) = 1;
9187       TREE_USED (t) = 1;
9188
9189       fpscr_values = t;
9190     }
9191
9192   src = DECL_RTL (fpscr_values);
9193   if (!can_create_pseudo_p ())
9194     {
9195       emit_move_insn (scratch, XEXP (src, 0));
9196       if (index != 0)
9197         emit_insn (gen_addsi3 (scratch, scratch, GEN_INT (index * 4)));
9198       src = adjust_automodify_address (src, PSImode, scratch, index * 4);
9199     }
9200   else
9201     src = adjust_address (src, PSImode, index * 4);
9202
9203   dst = get_fpscr_rtx ();
9204   emit_move_insn (dst, src);
9205 }
9206
9207 void
9208 emit_sf_insn (rtx pat)
9209 {
9210   emit_insn (pat);
9211 }
9212
9213 void
9214 emit_df_insn (rtx pat)
9215 {
9216   emit_insn (pat);
9217 }
9218
9219 void
9220 expand_sf_unop (rtx (*fun) (rtx, rtx, rtx), rtx *operands)
9221 {
9222   emit_sf_insn ((*fun) (operands[0], operands[1], get_fpscr_rtx ()));
9223 }
9224
9225 void
9226 expand_sf_binop (rtx (*fun) (rtx, rtx, rtx, rtx), rtx *operands)
9227 {
9228   emit_sf_insn ((*fun) (operands[0], operands[1], operands[2],
9229                          get_fpscr_rtx ()));
9230 }
9231
9232 void
9233 expand_df_unop (rtx (*fun) (rtx, rtx, rtx), rtx *operands)
9234 {
9235   emit_df_insn ((*fun) (operands[0], operands[1], get_fpscr_rtx ()));
9236 }
9237
9238 void
9239 expand_df_binop (rtx (*fun) (rtx, rtx, rtx, rtx), rtx *operands)
9240 {
9241   emit_df_insn ((*fun) (operands[0], operands[1], operands[2],
9242                         get_fpscr_rtx ()));
9243 }
9244 \f
9245 static rtx get_free_reg (HARD_REG_SET);
9246
9247 /* This function returns a register to use to load the address to load
9248    the fpscr from.  Currently it always returns r1 or r7, but when we are
9249    able to use pseudo registers after combine, or have a better mechanism
9250    for choosing a register, it should be done here.  */
9251 /* REGS_LIVE is the liveness information for the point for which we
9252    need this allocation.  In some bare-bones exit blocks, r1 is live at the
9253    start.  We can even have all of r0..r3 being live:
9254 __complex__ long long f (double d) { if (d == 0) return 2; else return 3; }
9255    INSN before which new insns are placed with will clobber the register
9256    we return.  If a basic block consists only of setting the return value
9257    register to a pseudo and using that register, the return value is not
9258    live before or after this block, yet we we'll insert our insns right in
9259    the middle.  */
9260
9261 static rtx
9262 get_free_reg (HARD_REG_SET regs_live)
9263 {
9264   if (! TEST_HARD_REG_BIT (regs_live, 1))
9265     return gen_rtx_REG (Pmode, 1);
9266
9267   /* Hard reg 1 is live; since this is a SMALL_REGISTER_CLASSES target,
9268      there shouldn't be anything but a jump before the function end.  */
9269   gcc_assert (!TEST_HARD_REG_BIT (regs_live, 7));
9270   return gen_rtx_REG (Pmode, 7);
9271 }
9272
9273 /* This function will set the fpscr from memory.
9274    MODE is the mode we are setting it to.  */
9275 void
9276 fpscr_set_from_mem (int mode, HARD_REG_SET regs_live)
9277 {
9278   enum attr_fp_mode fp_mode = (enum attr_fp_mode) mode;
9279   enum attr_fp_mode norm_mode = ACTUAL_NORMAL_MODE (FP_MODE);
9280   rtx addr_reg;
9281
9282   addr_reg = !can_create_pseudo_p () ? get_free_reg (regs_live) : NULL_RTX;
9283   emit_fpu_switch (addr_reg, fp_mode == norm_mode);
9284 }
9285
9286 /* Is the given character a logical line separator for the assembler?  */
9287 #ifndef IS_ASM_LOGICAL_LINE_SEPARATOR
9288 #define IS_ASM_LOGICAL_LINE_SEPARATOR(C, STR) ((C) == ';')
9289 #endif
9290
9291 int
9292 sh_insn_length_adjustment (rtx insn)
9293 {
9294   /* Instructions with unfilled delay slots take up an extra two bytes for
9295      the nop in the delay slot.  */
9296   if (((NONJUMP_INSN_P (insn)
9297         && GET_CODE (PATTERN (insn)) != USE
9298         && GET_CODE (PATTERN (insn)) != CLOBBER)
9299        || CALL_P (insn)
9300        || (JUMP_P (insn) && !JUMP_TABLE_DATA_P (insn)))
9301       && GET_CODE (PATTERN (NEXT_INSN (PREV_INSN (insn)))) != SEQUENCE
9302       && get_attr_needs_delay_slot (insn) == NEEDS_DELAY_SLOT_YES)
9303     return 2;
9304
9305   /* SH2e has a bug that prevents the use of annulled branches, so if
9306      the delay slot is not filled, we'll have to put a NOP in it.  */
9307   if (sh_cpu_attr == CPU_SH2E
9308       && JUMP_P (insn) && !JUMP_TABLE_DATA_P (insn)
9309       && get_attr_type (insn) == TYPE_CBRANCH
9310       && GET_CODE (PATTERN (NEXT_INSN (PREV_INSN (insn)))) != SEQUENCE)
9311     return 2;
9312
9313   /* sh-dsp parallel processing insn take four bytes instead of two.  */
9314
9315   if (NONJUMP_INSN_P (insn))
9316     {
9317       int sum = 0;
9318       rtx body = PATTERN (insn);
9319       const char *templ;
9320       char c;
9321       int maybe_label = 1;
9322
9323       if (GET_CODE (body) == ASM_INPUT)
9324         templ = XSTR (body, 0);
9325       else if (asm_noperands (body) >= 0)
9326         templ
9327           = decode_asm_operands (body, NULL, NULL, NULL, NULL, NULL);
9328       else
9329         return 0;
9330       do
9331         {
9332           int ppi_adjust = 0;
9333
9334           do
9335             c = *templ++;
9336           while (c == ' ' || c == '\t');
9337           /* all sh-dsp parallel-processing insns start with p.
9338              The only non-ppi sh insn starting with p is pref.
9339              The only ppi starting with pr is prnd.  */
9340           if ((c == 'p' || c == 'P') && strncasecmp ("re", templ, 2))
9341             ppi_adjust = 2;
9342           /* The repeat pseudo-insn expands two three insns, a total of
9343              six bytes in size.  */
9344           else if ((c == 'r' || c == 'R')
9345                    && ! strncasecmp ("epeat", templ, 5))
9346             ppi_adjust = 4;
9347           while (c && c != '\n'
9348                  && ! IS_ASM_LOGICAL_LINE_SEPARATOR (c, templ))
9349             {
9350               /* If this is a label, it is obviously not a ppi insn.  */
9351               if (c == ':' && maybe_label)
9352                 {
9353                   ppi_adjust = 0;
9354                   break;
9355                 }
9356               else if (c == '\'' || c == '"')
9357                 maybe_label = 0;
9358               c = *templ++;
9359             }
9360           sum += ppi_adjust;
9361           maybe_label = c != ':';
9362         }
9363       while (c);
9364       return sum;
9365     }
9366   return 0;
9367 }
9368 \f
9369 /* Return TRUE for a valid displacement for the REG+disp addressing
9370    with MODE.  */
9371
9372 /* ??? The SH2e does not have the REG+disp addressing mode when loading values
9373    into the FRx registers.  We implement this by setting the maximum offset
9374    to zero when the value is SFmode.  This also restricts loading of SFmode
9375    values into the integer registers, but that can't be helped.  */
9376
9377 /* The SH allows a displacement in a QI or HI amode, but only when the
9378    other operand is R0. GCC doesn't handle this very well, so we forgot
9379    all of that.
9380
9381    A legitimate index for a QI or HI is 0, SI can be any number 0..63,
9382    DI can be any number 0..60.  */
9383
9384 bool
9385 sh_legitimate_index_p (enum machine_mode mode, rtx op)
9386 {
9387   if (CONST_INT_P (op))
9388     {
9389       if (TARGET_SHMEDIA)
9390         {
9391           int size;
9392
9393           /* Check if this the address of an unaligned load / store.  */
9394           if (mode == VOIDmode)
9395             return CONST_OK_FOR_I06 (INTVAL (op));
9396
9397           size = GET_MODE_SIZE (mode);
9398           return (!(INTVAL (op) & (size - 1))
9399                   && INTVAL (op) >= -512 * size
9400                   && INTVAL (op) < 512 * size);
9401         }
9402
9403       if (TARGET_SH2A)
9404         {
9405           if (GET_MODE_SIZE (mode) == 1
9406                 && (unsigned) INTVAL (op) < 4096)
9407             return true;
9408         }
9409
9410       if ((GET_MODE_SIZE (mode) == 4
9411            && (unsigned) INTVAL (op) < 64
9412            && !(INTVAL (op) & 3)
9413            && !(TARGET_SH2E && mode == SFmode))
9414           || (GET_MODE_SIZE (mode) == 4
9415               && (unsigned) INTVAL (op) < 16383
9416               && !(INTVAL (op) & 3) && TARGET_SH2A))
9417         return true;
9418
9419       if ((GET_MODE_SIZE (mode) == 8
9420            && (unsigned) INTVAL (op) < 60
9421            && !(INTVAL (op) & 3)
9422            && !((TARGET_SH4 || TARGET_SH2A) && mode == DFmode))
9423           || ((GET_MODE_SIZE (mode)==8)
9424               && (unsigned) INTVAL (op) < 8192
9425               && !(INTVAL (op) & (TARGET_SH2A_DOUBLE ? 7 : 3))
9426               && (TARGET_SH2A && mode == DFmode)))
9427         return true;
9428     }
9429
9430   return false;
9431 }
9432
9433 /* Recognize an RTL expression that is a valid memory address for
9434    an instruction.
9435    The MODE argument is the machine mode for the MEM expression
9436    that wants to use this address.
9437    Allow  REG
9438           REG+disp
9439           REG+r0
9440           REG++
9441           --REG  */
9442
9443 static bool
9444 sh_legitimate_address_p (enum machine_mode mode, rtx x, bool strict)
9445 {
9446   if (MAYBE_BASE_REGISTER_RTX_P (x, strict))
9447     return true;
9448   else if ((GET_CODE (x) == POST_INC || GET_CODE (x) == PRE_DEC)
9449            && ! TARGET_SHMEDIA
9450            && MAYBE_BASE_REGISTER_RTX_P (XEXP (x, 0), strict))
9451     return true;
9452   else if (GET_CODE (x) == PLUS
9453            && (mode != PSImode || reload_completed))
9454     {
9455       rtx xop0 = XEXP (x, 0);
9456       rtx xop1 = XEXP (x, 1);
9457
9458       if (GET_MODE_SIZE (mode) <= 8
9459           && MAYBE_BASE_REGISTER_RTX_P (xop0, strict)
9460           && sh_legitimate_index_p (mode, xop1))
9461         return true;
9462
9463       if ((ALLOW_INDEXED_ADDRESS || GET_MODE (x) == DImode
9464            || ((xop0 == stack_pointer_rtx
9465                 || xop0 == hard_frame_pointer_rtx)
9466                && REG_P (xop1) && REGNO (xop1) == R0_REG)
9467            || ((xop1 == stack_pointer_rtx
9468                 || xop1 == hard_frame_pointer_rtx)
9469                && REG_P (xop0) && REGNO (xop0) == R0_REG))
9470           && ((!TARGET_SHMEDIA && GET_MODE_SIZE (mode) <= 4)
9471               || (TARGET_SHMEDIA && GET_MODE_SIZE (mode) <= 8)
9472               || ((TARGET_SH4 || TARGET_SH2A_DOUBLE)
9473                   && TARGET_FMOVD && mode == DFmode)))
9474         {
9475           if (MAYBE_BASE_REGISTER_RTX_P (xop1, strict)
9476               && MAYBE_INDEX_REGISTER_RTX_P (xop0, strict))
9477             return true;
9478           if (MAYBE_INDEX_REGISTER_RTX_P (xop1, strict)
9479               && MAYBE_BASE_REGISTER_RTX_P (xop0, strict))
9480             return true;
9481         }
9482     }
9483
9484   return false;
9485 }
9486 \f
9487 /* Return TRUE if X references a SYMBOL_REF or LABEL_REF whose symbol
9488    isn't protected by a PIC unspec.  */
9489 int
9490 nonpic_symbol_mentioned_p (rtx x)
9491 {
9492   register const char *fmt;
9493   register int i;
9494
9495   if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF
9496       || GET_CODE (x) == PC)
9497     return 1;
9498
9499   /* We don't want to look into the possible MEM location of a
9500      CONST_DOUBLE, since we're not going to use it, in general.  */
9501   if (GET_CODE (x) == CONST_DOUBLE)
9502     return 0;
9503
9504   if (GET_CODE (x) == UNSPEC
9505       && (XINT (x, 1) == UNSPEC_PIC
9506           || XINT (x, 1) == UNSPEC_GOT
9507           || XINT (x, 1) == UNSPEC_GOTOFF
9508           || XINT (x, 1) == UNSPEC_GOTPLT
9509           || XINT (x, 1) == UNSPEC_GOTTPOFF
9510           || XINT (x, 1) == UNSPEC_DTPOFF
9511           || XINT (x, 1) == UNSPEC_TPOFF
9512           || XINT (x, 1) == UNSPEC_PLT
9513           || XINT (x, 1) == UNSPEC_SYMOFF
9514           || XINT (x, 1) == UNSPEC_PCREL_SYMOFF))
9515     return 0;
9516
9517   fmt = GET_RTX_FORMAT (GET_CODE (x));
9518   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
9519     {
9520       if (fmt[i] == 'E')
9521         {
9522           register int j;
9523
9524           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
9525             if (nonpic_symbol_mentioned_p (XVECEXP (x, i, j)))
9526               return 1;
9527         }
9528       else if (fmt[i] == 'e' && nonpic_symbol_mentioned_p (XEXP (x, i)))
9529         return 1;
9530     }
9531
9532   return 0;
9533 }
9534
9535 /* Convert a non-PIC address in `orig' to a PIC address using @GOT or
9536    @GOTOFF in `reg'.  */
9537 rtx
9538 legitimize_pic_address (rtx orig, enum machine_mode mode ATTRIBUTE_UNUSED,
9539                         rtx reg)
9540 {
9541   if (tls_symbolic_operand (orig, Pmode) != TLS_MODEL_NONE)
9542     return orig;
9543
9544   if (GET_CODE (orig) == LABEL_REF
9545       || (GET_CODE (orig) == SYMBOL_REF && SYMBOL_REF_LOCAL_P (orig)))
9546     {
9547       if (reg == 0)
9548         reg = gen_reg_rtx (Pmode);
9549
9550       emit_insn (gen_symGOTOFF2reg (reg, orig));
9551       return reg;
9552     }
9553   else if (GET_CODE (orig) == SYMBOL_REF)
9554     {
9555       if (reg == 0)
9556         reg = gen_reg_rtx (Pmode);
9557
9558       emit_insn (gen_symGOT2reg (reg, orig));
9559       return reg;
9560     }
9561   return orig;
9562 }
9563
9564 /* Try machine-dependent ways of modifying an illegitimate address
9565    to be legitimate.  If we find one, return the new, valid address.
9566    Otherwise, return X.
9567
9568    For the SH, if X is almost suitable for indexing, but the offset is
9569    out of range, convert it into a normal form so that CSE has a chance
9570    of reducing the number of address registers used.  */
9571
9572 static rtx
9573 sh_legitimize_address (rtx x, rtx oldx, enum machine_mode mode)
9574 {
9575   if (flag_pic)
9576     x = legitimize_pic_address (oldx, mode, NULL_RTX);
9577
9578   if (GET_CODE (x) == PLUS
9579       && (GET_MODE_SIZE (mode) == 4
9580           || GET_MODE_SIZE (mode) == 8)
9581       && CONST_INT_P (XEXP (x, 1))
9582       && BASE_REGISTER_RTX_P (XEXP (x, 0))
9583       && ! TARGET_SHMEDIA
9584       && ! ((TARGET_SH4 || TARGET_SH2A_DOUBLE) && mode == DFmode)
9585       && ! (TARGET_SH2E && mode == SFmode))
9586     {
9587       rtx index_rtx = XEXP (x, 1);
9588       HOST_WIDE_INT offset = INTVAL (index_rtx), offset_base;
9589       rtx sum;
9590
9591       /* On rare occasions, we might get an unaligned pointer
9592          that is indexed in a way to give an aligned address.
9593          Therefore, keep the lower two bits in offset_base.  */
9594       /* Instead of offset_base 128..131 use 124..127, so that
9595          simple add suffices.  */
9596       if (offset > 127)
9597         offset_base = ((offset + 4) & ~60) - 4;
9598       else
9599         offset_base = offset & ~60;
9600
9601       /* Sometimes the normal form does not suit DImode.  We
9602          could avoid that by using smaller ranges, but that
9603          would give less optimized code when SImode is
9604          prevalent.  */
9605       if (GET_MODE_SIZE (mode) + offset - offset_base <= 64)
9606         {
9607           sum = expand_binop (Pmode, add_optab, XEXP (x, 0),
9608                               GEN_INT (offset_base), NULL_RTX, 0,
9609                               OPTAB_LIB_WIDEN);
9610
9611           return gen_rtx_PLUS (Pmode, sum, GEN_INT (offset - offset_base));
9612         }
9613     }
9614
9615   return x;
9616 }
9617
9618 /* Mark the use of a constant in the literal table. If the constant
9619    has multiple labels, make it unique.  */
9620 static rtx
9621 mark_constant_pool_use (rtx x)
9622 {
9623   rtx insn, lab, pattern;
9624
9625   if (x == NULL)
9626     return x;
9627
9628   switch (GET_CODE (x))
9629     {
9630     case LABEL_REF:
9631       x = XEXP (x, 0);
9632     case CODE_LABEL:
9633       break;
9634     default:
9635       return x;
9636     }
9637
9638   /* Get the first label in the list of labels for the same constant
9639      and delete another labels in the list.  */
9640   lab = x;
9641   for (insn = PREV_INSN (x); insn; insn = PREV_INSN (insn))
9642     {
9643       if (!LABEL_P (insn)
9644           || LABEL_REFS (insn) != NEXT_INSN (insn))
9645         break;
9646       lab = insn;
9647     }
9648
9649   for (insn = LABEL_REFS (lab); insn; insn = LABEL_REFS (insn))
9650     INSN_DELETED_P (insn) = 1;
9651
9652   /* Mark constants in a window.  */
9653   for (insn = NEXT_INSN (x); insn; insn = NEXT_INSN (insn))
9654     {
9655       if (!NONJUMP_INSN_P (insn))
9656         continue;
9657
9658       pattern = PATTERN (insn);
9659       if (GET_CODE (pattern) != UNSPEC_VOLATILE)
9660         continue;
9661
9662       switch (XINT (pattern, 1))
9663         {
9664         case UNSPECV_CONST2:
9665         case UNSPECV_CONST4:
9666         case UNSPECV_CONST8:
9667           XVECEXP (pattern, 0, 1) = const1_rtx;
9668           break;
9669         case UNSPECV_WINDOW_END:
9670           if (XVECEXP (pattern, 0, 0) == x)
9671             return lab;
9672           break;
9673         case UNSPECV_CONST_END:
9674           return lab;
9675         default:
9676           break;
9677         }
9678     }
9679
9680   return lab;
9681 }
9682 \f
9683 /* Return true if it's possible to redirect BRANCH1 to the destination
9684    of an unconditional jump BRANCH2.  We only want to do this if the
9685    resulting branch will have a short displacement.  */
9686 int
9687 sh_can_redirect_branch (rtx branch1, rtx branch2)
9688 {
9689   if (flag_expensive_optimizations && simplejump_p (branch2))
9690     {
9691       rtx dest = XEXP (SET_SRC (single_set (branch2)), 0);
9692       rtx insn;
9693       int distance;
9694
9695       for (distance = 0, insn = NEXT_INSN (branch1);
9696            insn && distance < 256;
9697            insn = PREV_INSN (insn))
9698         {
9699           if (insn == dest)
9700             return 1;
9701           else
9702             distance += get_attr_length (insn);
9703         }
9704       for (distance = 0, insn = NEXT_INSN (branch1);
9705            insn && distance < 256;
9706            insn = NEXT_INSN (insn))
9707         {
9708           if (insn == dest)
9709             return 1;
9710           else
9711             distance += get_attr_length (insn);
9712         }
9713     }
9714   return 0;
9715 }
9716
9717 /* Return nonzero if register old_reg can be renamed to register new_reg.  */
9718 int
9719 sh_hard_regno_rename_ok (unsigned int old_reg ATTRIBUTE_UNUSED,
9720                          unsigned int new_reg)
9721 {
9722   /* Interrupt functions can only use registers that have already been
9723      saved by the prologue, even if they would normally be
9724      call-clobbered.  */
9725
9726   if (sh_cfun_interrupt_handler_p () && !df_regs_ever_live_p (new_reg))
9727     return 0;
9728
9729   return 1;
9730 }
9731
9732 /* Function to update the integer COST
9733    based on the relationship between INSN that is dependent on
9734    DEP_INSN through the dependence LINK.  The default is to make no
9735    adjustment to COST.  This can be used for example to specify to
9736    the scheduler that an output- or anti-dependence does not incur
9737    the same cost as a data-dependence.  The return value should be
9738    the new value for COST.  */
9739 static int
9740 sh_adjust_cost (rtx insn, rtx link ATTRIBUTE_UNUSED, rtx dep_insn, int cost)
9741 {
9742   rtx reg, use_pat;
9743
9744   if (TARGET_SHMEDIA)
9745     {
9746       /* On SHmedia, if the dependence is an anti-dependence or
9747          output-dependence, there is no cost.  */
9748       if (REG_NOTE_KIND (link) != 0)
9749         {
9750           /* However, dependencies between target register loads and
9751              uses of the register in a subsequent block that are separated
9752              by a conditional branch are not modelled - we have to do with
9753              the anti-dependency between the target register load and the
9754              conditional branch that ends the current block.  */
9755           if (REG_NOTE_KIND (link) == REG_DEP_ANTI
9756               && GET_CODE (PATTERN (dep_insn)) == SET
9757               && (get_attr_type (dep_insn) == TYPE_PT_MEDIA
9758                   || get_attr_type (dep_insn) == TYPE_PTABS_MEDIA)
9759               && get_attr_type (insn) == TYPE_CBRANCH_MEDIA)
9760             {
9761               int orig_cost = cost;
9762               rtx note = find_reg_note (insn, REG_BR_PROB, 0);
9763               rtx target = ((! note
9764                              || INTVAL (XEXP (note, 0)) * 2 < REG_BR_PROB_BASE)
9765                             ? insn : JUMP_LABEL (insn));
9766               /* On the likely path, the branch costs 1, on the unlikely path,
9767                  it costs 3.  */
9768               cost--;
9769               do
9770                 target = next_active_insn (target);
9771               while (target && ! flow_dependent_p (target, dep_insn)
9772                      && --cost > 0);
9773               /* If two branches are executed in immediate succession, with the
9774                  first branch properly predicted, this causes a stall at the
9775                  second branch, hence we won't need the target for the
9776                  second branch for two cycles after the launch of the first
9777                  branch.  */
9778               if (cost > orig_cost - 2)
9779                 cost = orig_cost - 2;
9780             }
9781           else
9782             cost = 0;
9783         }
9784
9785       else if (get_attr_is_mac_media (insn)
9786                && get_attr_is_mac_media (dep_insn))
9787         cost = 1;
9788
9789       else if (! reload_completed
9790                && GET_CODE (PATTERN (insn)) == SET
9791                && GET_CODE (SET_SRC (PATTERN (insn))) == FLOAT
9792                && GET_CODE (PATTERN (dep_insn)) == SET
9793                && fp_arith_reg_operand (SET_SRC (PATTERN (dep_insn)), VOIDmode)
9794                && cost < 4)
9795         cost = 4;
9796       /* Schedule the ptabs for a casesi_jump_media in preference to stuff
9797          that is needed at the target.  */
9798       else if (get_attr_type (insn) == TYPE_JUMP_MEDIA
9799                && ! flow_dependent_p (insn, dep_insn))
9800         cost--;
9801     }
9802   else if (REG_NOTE_KIND (link) == 0)
9803     {
9804       enum attr_type type;
9805       rtx dep_set;
9806
9807       if (recog_memoized (insn) < 0
9808           || recog_memoized (dep_insn) < 0)
9809         return cost;
9810
9811       dep_set = single_set (dep_insn);
9812
9813       /* The latency that we specify in the scheduling description refers
9814          to the actual output, not to an auto-increment register; for that,
9815          the latency is one.  */
9816       if (dep_set && MEM_P (SET_SRC (dep_set)) && cost > 1)
9817         {
9818           rtx set = single_set (insn);
9819
9820           if (set
9821               && !reg_mentioned_p (SET_DEST (dep_set), SET_SRC (set))
9822               && (!MEM_P (SET_DEST (set))
9823                   || !reg_mentioned_p (SET_DEST (dep_set),
9824                                        XEXP (SET_DEST (set), 0))))
9825             cost = 1;
9826         }
9827       /* The only input for a call that is timing-critical is the
9828          function's address.  */
9829       if (CALL_P (insn))
9830         {
9831           rtx call = PATTERN (insn);
9832
9833           if (GET_CODE (call) == PARALLEL)
9834             call = XVECEXP (call, 0 ,0);
9835           if (GET_CODE (call) == SET)
9836             call = SET_SRC (call);
9837           if (GET_CODE (call) == CALL && MEM_P (XEXP (call, 0))
9838                   /* sibcalli_thunk uses a symbol_ref in an unspec.  */
9839               && (GET_CODE (XEXP (XEXP (call, 0), 0)) == UNSPEC
9840                   || ! reg_set_p (XEXP (XEXP (call, 0), 0), dep_insn)))
9841             cost -= TARGET_SH4_300 ? 3 : 6;
9842         }
9843       /* Likewise, the most timing critical input for an sfuncs call
9844          is the function address.  However, sfuncs typically start
9845          using their arguments pretty quickly.
9846          Assume a four cycle delay for SH4 before they are needed.
9847          Cached ST40-300 calls are quicker, so assume only a one
9848          cycle delay there.
9849          ??? Maybe we should encode the delays till input registers
9850          are needed by sfuncs into the sfunc call insn.  */
9851       /* All sfunc calls are parallels with at least four components.
9852          Exploit this to avoid unnecessary calls to sfunc_uses_reg.  */
9853       else if (GET_CODE (PATTERN (insn)) == PARALLEL
9854                && XVECLEN (PATTERN (insn), 0) >= 4
9855                && (reg = sfunc_uses_reg (insn)))
9856         {
9857           if (! reg_set_p (reg, dep_insn))
9858             cost -= TARGET_SH4_300 ? 1 : 4;
9859         }
9860       if (TARGET_HARD_SH4 && !TARGET_SH4_300)
9861         {
9862           enum attr_type dep_type = get_attr_type (dep_insn);
9863
9864           if (dep_type == TYPE_FLOAD || dep_type == TYPE_PCFLOAD)
9865             cost--;
9866           else if ((dep_type == TYPE_LOAD_SI || dep_type == TYPE_PCLOAD_SI)
9867                    && (type = get_attr_type (insn)) != TYPE_CALL
9868                    && type != TYPE_SFUNC)
9869             cost--;
9870           /* When the preceding instruction loads the shift amount of
9871              the following SHAD/SHLD, the latency of the load is increased
9872              by 1 cycle.  */
9873           if (get_attr_type (insn) == TYPE_DYN_SHIFT
9874               && get_attr_any_int_load (dep_insn) == ANY_INT_LOAD_YES
9875               && reg_overlap_mentioned_p (SET_DEST (dep_set),
9876                                           XEXP (SET_SRC (single_set (insn)),
9877                                                 1)))
9878             cost++;
9879           /* When an LS group instruction with a latency of less than
9880              3 cycles is followed by a double-precision floating-point
9881              instruction, FIPR, or FTRV, the latency of the first
9882              instruction is increased to 3 cycles.  */
9883           else if (cost < 3
9884                    && get_attr_insn_class (dep_insn) == INSN_CLASS_LS_GROUP
9885                    && get_attr_dfp_comp (insn) == DFP_COMP_YES)
9886             cost = 3;
9887           /* The lsw register of a double-precision computation is ready one
9888              cycle earlier.  */
9889           else if (reload_completed
9890                    && get_attr_dfp_comp (dep_insn) == DFP_COMP_YES
9891                    && (use_pat = single_set (insn))
9892                    && ! regno_use_in (REGNO (SET_DEST (single_set (dep_insn))),
9893                                       SET_SRC (use_pat)))
9894             cost -= 1;
9895
9896           if (get_attr_any_fp_comp (dep_insn) == ANY_FP_COMP_YES
9897               && get_attr_late_fp_use (insn) == LATE_FP_USE_YES)
9898             cost -= 1;
9899         }
9900       else if (TARGET_SH4_300)
9901         {
9902           /* Stores need their input register two cycles later.  */
9903           if (dep_set && cost >= 1
9904               && ((type = get_attr_type (insn)) == TYPE_STORE
9905                   || type == TYPE_PSTORE
9906                   || type == TYPE_FSTORE || type == TYPE_MAC_MEM))
9907             {
9908               rtx set = single_set (insn);
9909
9910               if (!reg_mentioned_p (SET_SRC (set), XEXP (SET_DEST (set), 0))
9911                   && rtx_equal_p (SET_SRC (set), SET_DEST (dep_set)))
9912                 {
9913                   cost -= 2;
9914                   /* But don't reduce the cost below 1 if the address depends
9915                      on a side effect of dep_insn.  */
9916                   if (cost < 1
9917                       && modified_in_p (XEXP (SET_DEST (set), 0), dep_insn))
9918                     cost = 1;
9919                 }
9920             }
9921         }
9922     }
9923   /* An anti-dependence penalty of two applies if the first insn is a double
9924      precision fadd / fsub / fmul.  */
9925   else if (!TARGET_SH4_300
9926            && REG_NOTE_KIND (link) == REG_DEP_ANTI
9927            && recog_memoized (dep_insn) >= 0
9928            && (get_attr_type (dep_insn) == TYPE_DFP_ARITH
9929                || get_attr_type (dep_insn) == TYPE_DFP_MUL)
9930            /* A lot of alleged anti-flow dependences are fake,
9931               so check this one is real.  */
9932            && flow_dependent_p (dep_insn, insn))
9933     cost = 2;
9934
9935   return cost;
9936 }
9937
9938 /* Check if INSN is flow-dependent on DEP_INSN.  Can also be used to check
9939    if DEP_INSN is anti-flow dependent on INSN.  */
9940 static int
9941 flow_dependent_p (rtx insn, rtx dep_insn)
9942 {
9943   rtx tmp = PATTERN (insn);
9944
9945   note_stores (PATTERN (dep_insn), flow_dependent_p_1, &tmp);
9946   return tmp == NULL_RTX;
9947 }
9948
9949 /* A helper function for flow_dependent_p called through note_stores.  */
9950 static void
9951 flow_dependent_p_1 (rtx x, const_rtx pat ATTRIBUTE_UNUSED, void *data)
9952 {
9953   rtx * pinsn = (rtx *) data;
9954
9955   if (*pinsn && reg_referenced_p (x, *pinsn))
9956     *pinsn = NULL_RTX;
9957 }
9958
9959 /* For use by sh_allocate_initial_value.  Note that sh.md contains some
9960    'special function' patterns (type sfunc) that clobber pr, but that
9961    do not look like function calls to leaf_function_p.  Hence we must
9962    do this extra check.  */
9963 static int
9964 sh_pr_n_sets (void)
9965 {
9966   return DF_REG_DEF_COUNT (TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG);
9967 }
9968
9969 /* Return where to allocate pseudo for a given hard register initial
9970    value.  */
9971 static rtx
9972 sh_allocate_initial_value (rtx hard_reg)
9973 {
9974   rtx x;
9975
9976   if (REGNO (hard_reg) == (TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG))
9977     {
9978       if (current_function_is_leaf
9979           && ! sh_pr_n_sets ()
9980           && ! (TARGET_SHCOMPACT
9981                 && ((crtl->args.info.call_cookie
9982                      & ~ CALL_COOKIE_RET_TRAMP (1))
9983                     || crtl->saves_all_registers)))
9984         x = hard_reg;
9985       else
9986         x = gen_frame_mem (Pmode, return_address_pointer_rtx);
9987     }
9988   else
9989     x = NULL_RTX;
9990
9991   return x;
9992 }
9993
9994 /* This function returns "2" to indicate dual issue for the SH4
9995    processor.  To be used by the DFA pipeline description.  */
9996 static int
9997 sh_issue_rate (void)
9998 {
9999   if (TARGET_SUPERSCALAR)
10000     return 2;
10001   else
10002     return 1;
10003 }
10004
10005 /* Functions for ready queue reordering for sched1.  */
10006
10007 /* Get weight for mode for a set x.  */
10008 static short
10009 find_set_regmode_weight (rtx x, enum machine_mode mode)
10010 {
10011   if (GET_CODE (x) == CLOBBER && register_operand (SET_DEST (x), mode))
10012     return 1;
10013   if (GET_CODE (x) == SET && register_operand (SET_DEST (x), mode))
10014     {
10015       if (REG_P (SET_DEST (x)))
10016         {
10017           if (!reg_mentioned_p (SET_DEST (x), SET_SRC (x)))
10018             return 1;
10019           else
10020             return 0;
10021         }
10022       return 1;
10023     }
10024   return 0;
10025 }
10026
10027 /* Get regmode weight for insn.  */
10028 static short
10029 find_insn_regmode_weight (rtx insn, enum machine_mode mode)
10030 {
10031   short reg_weight = 0;
10032   rtx x;
10033
10034   /* Increment weight for each register born here.  */
10035   x = PATTERN (insn);
10036   reg_weight += find_set_regmode_weight (x, mode);
10037   if (GET_CODE (x) == PARALLEL)
10038     {
10039       int j;
10040       for (j = XVECLEN (x, 0) - 1; j >= 0; j--)
10041         {
10042           x = XVECEXP (PATTERN (insn), 0, j);
10043           reg_weight += find_set_regmode_weight (x, mode);
10044         }
10045     }
10046   /* Decrement weight for each register that dies here.  */
10047   for (x = REG_NOTES (insn); x; x = XEXP (x, 1))
10048     {
10049       if (REG_NOTE_KIND (x) == REG_DEAD || REG_NOTE_KIND (x) == REG_UNUSED)
10050         {
10051           rtx note = XEXP (x, 0);
10052           if (REG_P (note) && GET_MODE (note) == mode)
10053             reg_weight--;
10054         }
10055     }
10056   return reg_weight;
10057 }
10058
10059 /* Calculate regmode weights for all insns of a basic block.  */
10060 static void
10061 find_regmode_weight (basic_block b, enum machine_mode mode)
10062 {
10063   rtx insn, next_tail, head, tail;
10064
10065   get_ebb_head_tail (b, b, &head, &tail);
10066   next_tail = NEXT_INSN (tail);
10067
10068   for (insn = head; insn != next_tail; insn = NEXT_INSN (insn))
10069     {
10070       /* Handle register life information.  */
10071       if (!INSN_P (insn))
10072         continue;
10073
10074       if (mode == SFmode)
10075         INSN_REGMODE_WEIGHT (insn, mode) =
10076           find_insn_regmode_weight (insn, mode) + 2 * find_insn_regmode_weight (insn, DFmode);
10077       else if (mode == SImode)
10078         INSN_REGMODE_WEIGHT (insn, mode) =
10079           find_insn_regmode_weight (insn, mode) + 2 * find_insn_regmode_weight (insn, DImode);
10080     }
10081 }
10082
10083 /* Comparison function for ready queue sorting.  */
10084 static int
10085 rank_for_reorder (const void *x, const void *y)
10086 {
10087   rtx tmp = *(const rtx *) y;
10088   rtx tmp2 = *(const rtx *) x;
10089
10090   /* The insn in a schedule group should be issued the first.  */
10091   if (SCHED_GROUP_P (tmp) != SCHED_GROUP_P (tmp2))
10092     return SCHED_GROUP_P (tmp2) ? 1 : -1;
10093
10094   /* If insns are equally good, sort by INSN_LUID (original insn order), This
10095      minimizes instruction movement, thus minimizing sched's effect on
10096      register pressure.  */
10097   return INSN_LUID (tmp) - INSN_LUID (tmp2);
10098 }
10099
10100 /* Resort the array A in which only element at index N may be out of order.  */
10101 static void
10102 swap_reorder (rtx *a, int n)
10103 {
10104   rtx insn = a[n - 1];
10105   int i = n - 2;
10106
10107   while (i >= 0 && rank_for_reorder (a + i, &insn) >= 0)
10108     {
10109       a[i + 1] = a[i];
10110       i -= 1;
10111     }
10112   a[i + 1] = insn;
10113 }
10114
10115 #define SCHED_REORDER(READY, N_READY)                                   \
10116   do                                                                    \
10117     {                                                                   \
10118       if ((N_READY) == 2)                                               \
10119         swap_reorder (READY, N_READY);                                  \
10120       else if ((N_READY) > 2)                                           \
10121         qsort (READY, N_READY, sizeof (rtx), rank_for_reorder);         \
10122     }                                                                   \
10123   while (0)
10124
10125 /* Sort the ready list READY by ascending priority, using the SCHED_REORDER
10126    macro.  */
10127 static void
10128 ready_reorder (rtx *ready, int nready)
10129 {
10130   SCHED_REORDER (ready, nready);
10131 }
10132
10133 /* Count life regions of r0 for a block.  */
10134 static int
10135 find_r0_life_regions (basic_block b)
10136 {
10137   rtx end, insn;
10138   rtx pset;
10139   rtx r0_reg;
10140   int live;
10141   int set;
10142   int death = 0;
10143
10144   if (REGNO_REG_SET_P (df_get_live_in (b), R0_REG))
10145     {
10146       set = 1;
10147       live = 1;
10148     }
10149   else
10150     {
10151       set = 0;
10152       live = 0;
10153     }
10154
10155   insn = BB_HEAD (b);
10156   end = BB_END (b);
10157   r0_reg = gen_rtx_REG (SImode, R0_REG);
10158   while (1)
10159     {
10160       if (INSN_P (insn))
10161         {
10162           if (find_regno_note (insn, REG_DEAD, R0_REG))
10163             {
10164               death++;
10165               live = 0;
10166             }
10167           if (!live
10168               && (pset = single_set (insn))
10169               && reg_overlap_mentioned_p (r0_reg, SET_DEST (pset))
10170               && !find_regno_note (insn, REG_UNUSED, R0_REG))
10171             {
10172               set++;
10173               live = 1;
10174             }
10175         }
10176       if (insn == end)
10177         break;
10178       insn = NEXT_INSN (insn);
10179     }
10180   return set - death;
10181 }
10182
10183 /* Calculate regmode weights for all insns of all basic block.  */
10184 static void
10185 sh_md_init_global (FILE *dump ATTRIBUTE_UNUSED,
10186                    int verbose ATTRIBUTE_UNUSED,
10187                    int old_max_uid)
10188 {
10189   basic_block b;
10190
10191   regmode_weight[0] = (short *) xcalloc (old_max_uid, sizeof (short));
10192   regmode_weight[1] = (short *) xcalloc (old_max_uid, sizeof (short));
10193   r0_life_regions = 0;
10194
10195   FOR_EACH_BB_REVERSE (b)
10196   {
10197     find_regmode_weight (b, SImode);
10198     find_regmode_weight (b, SFmode);
10199     if (!reload_completed)
10200       r0_life_regions += find_r0_life_regions (b);
10201   }
10202
10203   CURR_REGMODE_PRESSURE (SImode) = 0;
10204   CURR_REGMODE_PRESSURE (SFmode) = 0;
10205
10206 }
10207
10208 /* Cleanup.  */
10209 static void
10210 sh_md_finish_global (FILE *dump ATTRIBUTE_UNUSED,
10211                      int verbose ATTRIBUTE_UNUSED)
10212 {
10213   if (regmode_weight[0])
10214     {
10215       free (regmode_weight[0]);
10216       regmode_weight[0] = NULL;
10217     }
10218   if (regmode_weight[1])
10219     {
10220       free (regmode_weight[1]);
10221       regmode_weight[1] = NULL;
10222     }
10223 }
10224
10225 /* The scalar modes supported differs from the default version in TImode
10226    for 32-bit SHMEDIA.  */
10227 static bool
10228 sh_scalar_mode_supported_p (enum machine_mode mode)
10229 {
10230   if (TARGET_SHMEDIA32 && mode == TImode)
10231     return false;
10232
10233   return default_scalar_mode_supported_p (mode);
10234 }
10235
10236 /* Cache the can_issue_more so that we can return it from reorder2. Also,
10237    keep count of register pressures on SImode and SFmode. */
10238 static int
10239 sh_variable_issue (FILE *dump ATTRIBUTE_UNUSED,
10240                    int sched_verbose ATTRIBUTE_UNUSED,
10241                    rtx insn,
10242                    int can_issue_more)
10243 {
10244   if (GET_CODE (PATTERN (insn)) != USE
10245       && GET_CODE (PATTERN (insn)) != CLOBBER)
10246     cached_can_issue_more = can_issue_more - 1;
10247   else
10248     cached_can_issue_more = can_issue_more;
10249
10250   if (reload_completed)
10251     return cached_can_issue_more;
10252
10253   CURR_REGMODE_PRESSURE (SImode) += INSN_REGMODE_WEIGHT (insn, SImode);
10254   CURR_REGMODE_PRESSURE (SFmode) += INSN_REGMODE_WEIGHT (insn, SFmode);
10255
10256   return cached_can_issue_more;
10257 }
10258
10259 static void
10260 sh_md_init (FILE *dump ATTRIBUTE_UNUSED,
10261             int verbose ATTRIBUTE_UNUSED,
10262             int veclen ATTRIBUTE_UNUSED)
10263 {
10264   CURR_REGMODE_PRESSURE (SImode) = 0;
10265   CURR_REGMODE_PRESSURE (SFmode) = 0;
10266 }
10267
10268 /* Some magic numbers.  */
10269 /* Pressure on register r0 can lead to spill failures. so avoid sched1 for
10270    functions that already have high pressure on r0. */
10271 #define R0_MAX_LIFE_REGIONS 2
10272 /* Register Pressure thresholds for SImode and SFmode registers.  */
10273 #define SIMODE_MAX_WEIGHT 5
10274 #define SFMODE_MAX_WEIGHT 10
10275
10276 /* Return true if the pressure is high for MODE.  */
10277 static short
10278 high_pressure (enum machine_mode mode)
10279 {
10280   /* Pressure on register r0 can lead to spill failures. so avoid sched1 for
10281      functions that already have high pressure on r0. */
10282    if (r0_life_regions >= R0_MAX_LIFE_REGIONS)
10283      return 1;
10284
10285   if (mode == SFmode)
10286     return (CURR_REGMODE_PRESSURE (SFmode) > SFMODE_MAX_WEIGHT);
10287   else
10288     return (CURR_REGMODE_PRESSURE (SImode) > SIMODE_MAX_WEIGHT);
10289 }
10290
10291 /* Reorder ready queue if register pressure is high.  */
10292 static int
10293 sh_reorder (FILE *dump ATTRIBUTE_UNUSED,
10294             int sched_verbose ATTRIBUTE_UNUSED,
10295             rtx *ready,
10296             int *n_readyp,
10297             int clock_var ATTRIBUTE_UNUSED)
10298 {
10299   if (reload_completed)
10300     return sh_issue_rate ();
10301
10302   if (high_pressure (SFmode) || high_pressure (SImode))
10303     {
10304       ready_reorder (ready, *n_readyp);
10305     }
10306
10307   return sh_issue_rate ();
10308 }
10309
10310 /* Skip cycles if the current register pressure is high.  */
10311 static int
10312 sh_reorder2 (FILE *dump ATTRIBUTE_UNUSED,
10313              int sched_verbose ATTRIBUTE_UNUSED,
10314              rtx *ready ATTRIBUTE_UNUSED,
10315              int *n_readyp ATTRIBUTE_UNUSED,
10316              int clock_var ATTRIBUTE_UNUSED)
10317 {
10318   if (reload_completed)
10319     return cached_can_issue_more;
10320
10321   if (high_pressure(SFmode) || high_pressure (SImode))
10322     skip_cycles = 1;
10323
10324   return cached_can_issue_more;
10325 }
10326
10327 /* Skip cycles without sorting the ready queue. This will move insn from
10328    Q->R. If this is the last cycle we are skipping; allow sorting of ready
10329    queue by sh_reorder.  */
10330
10331 /* Generally, skipping these many cycles are sufficient for all insns to move
10332    from Q -> R.  */
10333 #define MAX_SKIPS 8
10334
10335 static int
10336 sh_dfa_new_cycle (FILE *sched_dump ATTRIBUTE_UNUSED,
10337                   int sched_verbose ATTRIBUTE_UNUSED,
10338                   rtx insn ATTRIBUTE_UNUSED,
10339                   int last_clock_var,
10340                   int clock_var,
10341                   int *sort_p)
10342 {
10343   if (reload_completed)
10344     return 0;
10345
10346   if (skip_cycles)
10347     {
10348       if ((clock_var - last_clock_var) < MAX_SKIPS)
10349         {
10350           *sort_p = 0;
10351           return 1;
10352         }
10353       /* If this is the last cycle we are skipping, allow reordering of R.  */
10354       if ((clock_var - last_clock_var) == MAX_SKIPS)
10355         {
10356           *sort_p = 1;
10357           return 1;
10358         }
10359     }
10360
10361   skip_cycles = 0;
10362
10363   return 0;
10364 }
10365
10366 /* SHmedia requires registers for branches, so we can't generate new
10367    branches past reload.  */
10368 static bool
10369 sh_cannot_modify_jumps_p (void)
10370 {
10371   return (TARGET_SHMEDIA && (reload_in_progress || reload_completed));
10372 }
10373
10374 static enum reg_class
10375 sh_target_reg_class (void)
10376 {
10377   return TARGET_SHMEDIA ? TARGET_REGS : NO_REGS;
10378 }
10379
10380 static bool
10381 sh_optimize_target_register_callee_saved (bool after_prologue_epilogue_gen)
10382 {
10383   HARD_REG_SET dummy;
10384 #if 0
10385   rtx insn;
10386 #endif
10387
10388   if (! shmedia_space_reserved_for_target_registers)
10389     return 0;
10390   if (after_prologue_epilogue_gen && ! TARGET_SAVE_ALL_TARGET_REGS)
10391     return 0;
10392   if (calc_live_regs (&dummy) >= 6 * 8)
10393     return 1;
10394   return 0;
10395 }
10396
10397 static bool
10398 sh_ms_bitfield_layout_p (const_tree record_type ATTRIBUTE_UNUSED)
10399 {
10400   return (TARGET_SH5 || TARGET_HITACHI || sh_attr_renesas_p (record_type));
10401 }
10402 \f
10403 /*
10404    On the SH1..SH4, the trampoline looks like
10405    2 0002 D202                  mov.l   l2,r2
10406    1 0000 D301                  mov.l   l1,r3
10407    3 0004 422B                  jmp     @r2
10408    4 0006 0009                  nop
10409    5 0008 00000000      l1:     .long   area
10410    6 000c 00000000      l2:     .long   function
10411
10412    SH5 (compact) uses r1 instead of r3 for the static chain.  */
10413
10414
10415 /* Emit RTL insns to initialize the variable parts of a trampoline.
10416    FNADDR is an RTX for the address of the function's pure code.
10417    CXT is an RTX for the static chain value for the function.  */
10418
10419 static void
10420 sh_trampoline_init (rtx tramp_mem, tree fndecl, rtx cxt)
10421 {
10422   rtx fnaddr = XEXP (DECL_RTL (fndecl), 0);
10423   rtx tramp = force_reg (Pmode, XEXP (tramp_mem, 0));
10424
10425   if (TARGET_SHMEDIA64)
10426     {
10427       rtx tramp_templ;
10428       int fixed_len;
10429
10430       rtx movi1 = GEN_INT (0xcc000010);
10431       rtx shori1 = GEN_INT (0xc8000010);
10432       rtx src, dst;
10433
10434       /* The following trampoline works within a +- 128 KB range for cxt:
10435          ptb/u cxt,tr1; movi fnaddr >> 48,r0; shori fnaddr >> 32,r0;
10436          shori fnaddr >> 16,r0; shori fnaddr,r0; ptabs/l r0,tr0
10437          gettr tr1,r1; blink tr0,r63  */
10438       /* Address rounding makes it hard to compute the exact bounds of the
10439          offset for this trampoline, but we have a rather generous offset
10440          range, so frame_offset should do fine as an upper bound.  */
10441       if (cxt == virtual_stack_vars_rtx && frame_offset < 0x20000)
10442         {
10443           /* ??? could optimize this trampoline initialization
10444              by writing DImode words with two insns each.  */
10445           rtx mask = force_reg (DImode, GEN_INT (0x3fffc00));
10446           rtx insn = gen_rtx_MINUS (DImode, cxt, tramp);
10447           insn = gen_rtx_ASHIFT (DImode, insn, GEN_INT (10-2));
10448           insn = gen_rtx_AND (DImode, insn, mask);
10449           /* Or in ptb/u .,tr1 pattern */
10450           insn = gen_rtx_IOR (DImode, insn, gen_int_mode (0xec000010, SImode));
10451           insn = force_operand (insn, NULL_RTX);
10452           insn = gen_lowpart (SImode, insn);
10453           emit_move_insn (change_address (tramp_mem, SImode, NULL_RTX), insn);
10454           insn = gen_rtx_LSHIFTRT (DImode, fnaddr, GEN_INT (38));
10455           insn = gen_rtx_AND (DImode, insn, mask);
10456           insn = force_operand (gen_rtx_IOR (DImode, movi1, insn), NULL_RTX);
10457           insn = gen_lowpart (SImode, insn);
10458           emit_move_insn (adjust_address (tramp_mem, SImode, 4), insn);
10459           insn = gen_rtx_LSHIFTRT (DImode, fnaddr, GEN_INT (22));
10460           insn = gen_rtx_AND (DImode, insn, mask);
10461           insn = force_operand (gen_rtx_IOR (DImode, shori1, insn), NULL_RTX);
10462           insn = gen_lowpart (SImode, insn);
10463           emit_move_insn (adjust_address (tramp_mem, SImode, 8), insn);
10464           insn = gen_rtx_LSHIFTRT (DImode, fnaddr, GEN_INT (6));
10465           insn = gen_rtx_AND (DImode, insn, mask);
10466           insn = force_operand (gen_rtx_IOR (DImode, shori1, insn), NULL_RTX);
10467           insn = gen_lowpart (SImode, insn);
10468           emit_move_insn (adjust_address (tramp_mem, SImode, 12), insn);
10469           insn = gen_rtx_ASHIFT (DImode, fnaddr, GEN_INT (10));
10470           insn = gen_rtx_AND (DImode, insn, mask);
10471           insn = force_operand (gen_rtx_IOR (DImode, shori1, insn), NULL_RTX);
10472           insn = gen_lowpart (SImode, insn);
10473           emit_move_insn (adjust_address (tramp_mem, SImode, 16), insn);
10474           emit_move_insn (adjust_address (tramp_mem, SImode, 20),
10475                           GEN_INT (0x6bf10600));
10476           emit_move_insn (adjust_address (tramp_mem, SImode, 24),
10477                           GEN_INT (0x4415fc10));
10478           emit_move_insn (adjust_address (tramp_mem, SImode, 28),
10479                           GEN_INT (0x4401fff0));
10480           emit_insn (gen_ic_invalidate_line (tramp));
10481           return;
10482         }
10483       tramp_templ = gen_rtx_SYMBOL_REF (Pmode,"__GCC_nested_trampoline");
10484       fixed_len = TRAMPOLINE_SIZE - 2 * GET_MODE_SIZE (Pmode);
10485
10486       tramp_templ = gen_datalabel_ref (tramp_templ);
10487       dst = tramp_mem;
10488       src = gen_const_mem (BLKmode, tramp_templ);
10489       set_mem_align (dst, 256);
10490       set_mem_align (src, 64);
10491       emit_block_move (dst, src, GEN_INT (fixed_len), BLOCK_OP_NORMAL);
10492
10493       emit_move_insn (adjust_address (tramp_mem, Pmode, fixed_len), fnaddr);
10494       emit_move_insn (adjust_address (tramp_mem, Pmode,
10495                                       fixed_len + GET_MODE_SIZE (Pmode)),
10496                       cxt);
10497       emit_insn (gen_ic_invalidate_line (tramp));
10498       return;
10499     }
10500   else if (TARGET_SHMEDIA)
10501     {
10502       /* movi fnaddr >> 16,r1; shori fnaddr,r1; ptabs/l r1,tr0
10503          movi cxt >> 16,r1; shori cxt,r1; blink tr0,r63  */
10504       rtx quad0 = gen_reg_rtx (DImode), cxtload = gen_reg_rtx (DImode);
10505       rtx quad1 = gen_reg_rtx (DImode), quad2 = gen_reg_rtx (DImode);
10506       /* movi 0,r1: 0xcc000010 shori 0,r1: c8000010  concatenated,
10507          rotated 10 right, and higher 16 bit of every 32 selected.  */
10508       rtx movishori
10509         = force_reg (V2HImode, (simplify_gen_subreg
10510                                 (V2HImode, GEN_INT (0x4330432), SImode, 0)));
10511       rtx ptabs = force_reg (DImode, GEN_INT (0x6bf10600));
10512       rtx blink = force_reg (DImode, GEN_INT (0x4401fff0));
10513
10514       fnaddr = force_reg (SImode, fnaddr);
10515       cxt = force_reg (SImode, cxt);
10516       emit_insn (gen_mshflo_w_x (gen_rtx_SUBREG (V4HImode, quad0, 0),
10517                                  gen_rtx_SUBREG (V2HImode, fnaddr, 0),
10518                                  movishori));
10519       emit_insn (gen_rotrdi3_mextr (quad0, quad0,
10520                                     GEN_INT (TARGET_LITTLE_ENDIAN ? 24 : 56)));
10521       emit_insn (gen_ashldi3_media (quad0, quad0, const2_rtx));
10522       emit_move_insn (change_address (tramp_mem, DImode, NULL_RTX), quad0);
10523       emit_insn (gen_mshflo_w_x (gen_rtx_SUBREG (V4HImode, cxtload, 0),
10524                                  gen_rtx_SUBREG (V2HImode, cxt, 0),
10525                                  movishori));
10526       emit_insn (gen_rotrdi3_mextr (cxtload, cxtload,
10527                                     GEN_INT (TARGET_LITTLE_ENDIAN ? 24 : 56)));
10528       emit_insn (gen_ashldi3_media (cxtload, cxtload, const2_rtx));
10529       if (TARGET_LITTLE_ENDIAN)
10530         {
10531           emit_insn (gen_mshflo_l_di (quad1, ptabs, cxtload));
10532           emit_insn (gen_mextr4 (quad2, cxtload, blink));
10533         }
10534       else
10535         {
10536           emit_insn (gen_mextr4 (quad1, cxtload, ptabs));
10537           emit_insn (gen_mshflo_l_di (quad2, blink, cxtload));
10538         }
10539       emit_move_insn (adjust_address (tramp_mem, DImode, 8), quad1);
10540       emit_move_insn (adjust_address (tramp_mem, DImode, 16), quad2);
10541       emit_insn (gen_ic_invalidate_line (tramp));
10542       return;
10543     }
10544   else if (TARGET_SHCOMPACT)
10545     {
10546       emit_insn (gen_initialize_trampoline (tramp, cxt, fnaddr));
10547       return;
10548     }
10549   emit_move_insn (change_address (tramp_mem, SImode, NULL_RTX),
10550                   gen_int_mode (TARGET_LITTLE_ENDIAN ? 0xd301d202 : 0xd202d301,
10551                                 SImode));
10552   emit_move_insn (adjust_address (tramp_mem, SImode, 4),
10553                   gen_int_mode (TARGET_LITTLE_ENDIAN ? 0x0009422b : 0x422b0009,
10554                                 SImode));
10555   emit_move_insn (adjust_address (tramp_mem, SImode, 8), cxt);
10556   emit_move_insn (adjust_address (tramp_mem, SImode, 12), fnaddr);
10557   if (TARGET_HARVARD)
10558     {
10559       if (!TARGET_INLINE_IC_INVALIDATE
10560           || (!(TARGET_SH4A_ARCH || TARGET_SH4_300) && TARGET_USERMODE))
10561         emit_library_call (function_symbol (NULL, "__ic_invalidate",
10562                                             FUNCTION_ORDINARY),
10563                            LCT_NORMAL, VOIDmode, 1, tramp, SImode);
10564       else
10565         emit_insn (gen_ic_invalidate_line (tramp));
10566     }
10567 }
10568
10569 /* On SH5, trampolines are SHmedia code, so add 1 to the address.  */
10570
10571 static rtx
10572 sh_trampoline_adjust_address (rtx tramp)
10573 {
10574   if (TARGET_SHMEDIA)
10575     tramp = expand_simple_binop (Pmode, PLUS, tramp, const1_rtx,
10576                                  gen_reg_rtx (Pmode), 0, OPTAB_LIB_WIDEN);
10577   return tramp;
10578 }
10579
10580 /* FIXME: This is overly conservative.  A SHcompact function that
10581    receives arguments ``by reference'' will have them stored in its
10582    own stack frame, so it must not pass pointers or references to
10583    these arguments to other functions by means of sibling calls.  */
10584 /* If PIC, we cannot make sibling calls to global functions
10585    because the PLT requires r12 to be live.  */
10586 static bool
10587 sh_function_ok_for_sibcall (tree decl, tree exp ATTRIBUTE_UNUSED)
10588 {
10589   return (1
10590           && (! TARGET_SHCOMPACT
10591               || crtl->args.info.stack_regs == 0)
10592           && ! sh_cfun_interrupt_handler_p ()
10593           && (! flag_pic
10594               || (decl && ! TREE_PUBLIC (decl))
10595               || (decl && DECL_VISIBILITY (decl) != VISIBILITY_DEFAULT)));
10596 }
10597 \f
10598 /* Machine specific built-in functions.  */
10599
10600 struct builtin_description
10601 {
10602   const enum insn_code icode;
10603   const char *const name;
10604   int signature;
10605   tree fndecl;
10606 };
10607
10608 /* describe number and signedness of arguments; arg[0] == result
10609    (1: unsigned, 2: signed, 4: don't care, 8: pointer 0: no argument */
10610 /* 9: 64-bit pointer, 10: 32-bit pointer */
10611 static const char signature_args[][4] =
10612 {
10613 #define SH_BLTIN_V2SI2 0
10614   { 4, 4 },
10615 #define SH_BLTIN_V4HI2 1
10616   { 4, 4 },
10617 #define SH_BLTIN_V2SI3 2
10618   { 4, 4, 4 },
10619 #define SH_BLTIN_V4HI3 3
10620   { 4, 4, 4 },
10621 #define SH_BLTIN_V8QI3 4
10622   { 4, 4, 4 },
10623 #define SH_BLTIN_MAC_HISI 5
10624   { 1, 4, 4, 1 },
10625 #define SH_BLTIN_SH_HI 6
10626   { 4, 4, 1 },
10627 #define SH_BLTIN_SH_SI 7
10628   { 4, 4, 1 },
10629 #define SH_BLTIN_V4HI2V2SI 8
10630   { 4, 4, 4 },
10631 #define SH_BLTIN_V4HI2V8QI 9
10632   { 4, 4, 4 },
10633 #define SH_BLTIN_SISF 10
10634   { 4, 2 },
10635 #define SH_BLTIN_LDUA_L 11
10636   { 2, 10 },
10637 #define SH_BLTIN_LDUA_Q 12
10638   { 1, 10 },
10639 #define SH_BLTIN_STUA_L 13
10640   { 0, 10, 2 },
10641 #define SH_BLTIN_STUA_Q 14
10642   { 0, 10, 1 },
10643 #define SH_BLTIN_LDUA_L64 15
10644   { 2, 9 },
10645 #define SH_BLTIN_LDUA_Q64 16
10646   { 1, 9 },
10647 #define SH_BLTIN_STUA_L64 17
10648   { 0, 9, 2 },
10649 #define SH_BLTIN_STUA_Q64 18
10650   { 0, 9, 1 },
10651 #define SH_BLTIN_NUM_SHARED_SIGNATURES 19
10652 #define SH_BLTIN_2 19
10653 #define SH_BLTIN_SU 19
10654   { 1, 2 },
10655 #define SH_BLTIN_3 20
10656 #define SH_BLTIN_SUS 20
10657   { 2, 2, 1 },
10658 #define SH_BLTIN_PSSV 21
10659   { 0, 8, 2, 2 },
10660 #define SH_BLTIN_XXUU 22
10661 #define SH_BLTIN_UUUU 22
10662   { 1, 1, 1, 1 },
10663 #define SH_BLTIN_PV 23
10664   { 0, 8 },
10665 };
10666 /* mcmv: operands considered unsigned.  */
10667 /* mmulsum_wq, msad_ubq: result considered unsigned long long.  */
10668 /* mperm: control value considered unsigned int.  */
10669 /* mshalds, mshard, mshards, mshlld, mshlrd: shift count is unsigned int.  */
10670 /* mshards_q: returns signed short.  */
10671 /* nsb: takes long long arg, returns unsigned char.  */
10672 static struct builtin_description bdesc[] =
10673 {
10674   { CODE_FOR_absv2si2,  "__builtin_absv2si2", SH_BLTIN_V2SI2, 0 },
10675   { CODE_FOR_absv4hi2,  "__builtin_absv4hi2", SH_BLTIN_V4HI2, 0 },
10676   { CODE_FOR_addv2si3,  "__builtin_addv2si3", SH_BLTIN_V2SI3, 0 },
10677   { CODE_FOR_addv4hi3,  "__builtin_addv4hi3", SH_BLTIN_V4HI3, 0 },
10678   { CODE_FOR_ssaddv2si3,"__builtin_ssaddv2si3", SH_BLTIN_V2SI3, 0 },
10679   { CODE_FOR_usaddv8qi3,"__builtin_usaddv8qi3", SH_BLTIN_V8QI3, 0 },
10680   { CODE_FOR_ssaddv4hi3,"__builtin_ssaddv4hi3", SH_BLTIN_V4HI3, 0 },
10681   { CODE_FOR_alloco_i,  "__builtin_sh_media_ALLOCO", SH_BLTIN_PV, 0 },
10682   { CODE_FOR_negcmpeqv8qi,"__builtin_sh_media_MCMPEQ_B", SH_BLTIN_V8QI3, 0 },
10683   { CODE_FOR_negcmpeqv2si,"__builtin_sh_media_MCMPEQ_L", SH_BLTIN_V2SI3, 0 },
10684   { CODE_FOR_negcmpeqv4hi,"__builtin_sh_media_MCMPEQ_W", SH_BLTIN_V4HI3, 0 },
10685   { CODE_FOR_negcmpgtuv8qi,"__builtin_sh_media_MCMPGT_UB", SH_BLTIN_V8QI3, 0 },
10686   { CODE_FOR_negcmpgtv2si,"__builtin_sh_media_MCMPGT_L", SH_BLTIN_V2SI3, 0 },
10687   { CODE_FOR_negcmpgtv4hi,"__builtin_sh_media_MCMPGT_W", SH_BLTIN_V4HI3, 0 },
10688   { CODE_FOR_mcmv,      "__builtin_sh_media_MCMV", SH_BLTIN_UUUU, 0 },
10689   { CODE_FOR_mcnvs_lw,  "__builtin_sh_media_MCNVS_LW", SH_BLTIN_3, 0 },
10690   { CODE_FOR_mcnvs_wb,  "__builtin_sh_media_MCNVS_WB", SH_BLTIN_V4HI2V8QI, 0 },
10691   { CODE_FOR_mcnvs_wub, "__builtin_sh_media_MCNVS_WUB", SH_BLTIN_V4HI2V8QI, 0 },
10692   { CODE_FOR_mextr1,    "__builtin_sh_media_MEXTR1", SH_BLTIN_V8QI3, 0 },
10693   { CODE_FOR_mextr2,    "__builtin_sh_media_MEXTR2", SH_BLTIN_V8QI3, 0 },
10694   { CODE_FOR_mextr3,    "__builtin_sh_media_MEXTR3", SH_BLTIN_V8QI3, 0 },
10695   { CODE_FOR_mextr4,    "__builtin_sh_media_MEXTR4", SH_BLTIN_V8QI3, 0 },
10696   { CODE_FOR_mextr5,    "__builtin_sh_media_MEXTR5", SH_BLTIN_V8QI3, 0 },
10697   { CODE_FOR_mextr6,    "__builtin_sh_media_MEXTR6", SH_BLTIN_V8QI3, 0 },
10698   { CODE_FOR_mextr7,    "__builtin_sh_media_MEXTR7", SH_BLTIN_V8QI3, 0 },
10699   { CODE_FOR_mmacfx_wl, "__builtin_sh_media_MMACFX_WL", SH_BLTIN_MAC_HISI, 0 },
10700   { CODE_FOR_mmacnfx_wl,"__builtin_sh_media_MMACNFX_WL", SH_BLTIN_MAC_HISI, 0 },
10701   { CODE_FOR_mulv2si3,  "__builtin_mulv2si3", SH_BLTIN_V2SI3, 0 },
10702   { CODE_FOR_mulv4hi3,  "__builtin_mulv4hi3", SH_BLTIN_V4HI3, 0 },
10703   { CODE_FOR_mmulfx_l,  "__builtin_sh_media_MMULFX_L", SH_BLTIN_V2SI3, 0 },
10704   { CODE_FOR_mmulfx_w,  "__builtin_sh_media_MMULFX_W", SH_BLTIN_V4HI3, 0 },
10705   { CODE_FOR_mmulfxrp_w,"__builtin_sh_media_MMULFXRP_W", SH_BLTIN_V4HI3, 0 },
10706   { CODE_FOR_mmulhi_wl, "__builtin_sh_media_MMULHI_WL", SH_BLTIN_V4HI2V2SI, 0 },
10707   { CODE_FOR_mmullo_wl, "__builtin_sh_media_MMULLO_WL", SH_BLTIN_V4HI2V2SI, 0 },
10708   { CODE_FOR_mmulsum_wq,"__builtin_sh_media_MMULSUM_WQ", SH_BLTIN_XXUU, 0 },
10709   { CODE_FOR_mperm_w,   "__builtin_sh_media_MPERM_W", SH_BLTIN_SH_HI, 0 },
10710   { CODE_FOR_msad_ubq,  "__builtin_sh_media_MSAD_UBQ", SH_BLTIN_XXUU, 0 },
10711   { CODE_FOR_mshalds_l, "__builtin_sh_media_MSHALDS_L", SH_BLTIN_SH_SI, 0 },
10712   { CODE_FOR_mshalds_w, "__builtin_sh_media_MSHALDS_W", SH_BLTIN_SH_HI, 0 },
10713   { CODE_FOR_ashrv2si3, "__builtin_ashrv2si3", SH_BLTIN_SH_SI, 0 },
10714   { CODE_FOR_ashrv4hi3, "__builtin_ashrv4hi3", SH_BLTIN_SH_HI, 0 },
10715   { CODE_FOR_mshards_q, "__builtin_sh_media_MSHARDS_Q", SH_BLTIN_SUS, 0 },
10716   { CODE_FOR_mshfhi_b,  "__builtin_sh_media_MSHFHI_B", SH_BLTIN_V8QI3, 0 },
10717   { CODE_FOR_mshfhi_l,  "__builtin_sh_media_MSHFHI_L", SH_BLTIN_V2SI3, 0 },
10718   { CODE_FOR_mshfhi_w,  "__builtin_sh_media_MSHFHI_W", SH_BLTIN_V4HI3, 0 },
10719   { CODE_FOR_mshflo_b,  "__builtin_sh_media_MSHFLO_B", SH_BLTIN_V8QI3, 0 },
10720   { CODE_FOR_mshflo_l,  "__builtin_sh_media_MSHFLO_L", SH_BLTIN_V2SI3, 0 },
10721   { CODE_FOR_mshflo_w,  "__builtin_sh_media_MSHFLO_W", SH_BLTIN_V4HI3, 0 },
10722   { CODE_FOR_ashlv2si3, "__builtin_ashlv2si3", SH_BLTIN_SH_SI, 0 },
10723   { CODE_FOR_ashlv4hi3, "__builtin_ashlv4hi3", SH_BLTIN_SH_HI, 0 },
10724   { CODE_FOR_lshrv2si3, "__builtin_lshrv2si3", SH_BLTIN_SH_SI, 0 },
10725   { CODE_FOR_lshrv4hi3, "__builtin_lshrv4hi3", SH_BLTIN_SH_HI, 0 },
10726   { CODE_FOR_subv2si3,  "__builtin_subv2si3", SH_BLTIN_V2SI3, 0 },
10727   { CODE_FOR_subv4hi3,  "__builtin_subv4hi3", SH_BLTIN_V4HI3, 0 },
10728   { CODE_FOR_sssubv2si3,"__builtin_sssubv2si3", SH_BLTIN_V2SI3, 0 },
10729   { CODE_FOR_ussubv8qi3,"__builtin_ussubv8qi3", SH_BLTIN_V8QI3, 0 },
10730   { CODE_FOR_sssubv4hi3,"__builtin_sssubv4hi3", SH_BLTIN_V4HI3, 0 },
10731   { CODE_FOR_fcosa_s,   "__builtin_sh_media_FCOSA_S", SH_BLTIN_SISF, 0 },
10732   { CODE_FOR_fsina_s,   "__builtin_sh_media_FSINA_S", SH_BLTIN_SISF, 0 },
10733   { CODE_FOR_fipr,      "__builtin_sh_media_FIPR_S", SH_BLTIN_3, 0 },
10734   { CODE_FOR_ftrv,      "__builtin_sh_media_FTRV_S", SH_BLTIN_3, 0 },
10735   { CODE_FOR_mac_media, "__builtin_sh_media_FMAC_S", SH_BLTIN_3, 0 },
10736   { CODE_FOR_sqrtdf2,   "__builtin_sh_media_FSQRT_D", SH_BLTIN_2, 0 },
10737   { CODE_FOR_sqrtsf2,   "__builtin_sh_media_FSQRT_S", SH_BLTIN_2, 0 },
10738   { CODE_FOR_fsrra_s,   "__builtin_sh_media_FSRRA_S", SH_BLTIN_2, 0 },
10739   { CODE_FOR_ldhi_l,    "__builtin_sh_media_LDHI_L", SH_BLTIN_LDUA_L, 0 },
10740   { CODE_FOR_ldhi_q,    "__builtin_sh_media_LDHI_Q", SH_BLTIN_LDUA_Q, 0 },
10741   { CODE_FOR_ldlo_l,    "__builtin_sh_media_LDLO_L", SH_BLTIN_LDUA_L, 0 },
10742   { CODE_FOR_ldlo_q,    "__builtin_sh_media_LDLO_Q", SH_BLTIN_LDUA_Q, 0 },
10743   { CODE_FOR_sthi_l,    "__builtin_sh_media_STHI_L", SH_BLTIN_STUA_L, 0 },
10744   { CODE_FOR_sthi_q,    "__builtin_sh_media_STHI_Q", SH_BLTIN_STUA_Q, 0 },
10745   { CODE_FOR_stlo_l,    "__builtin_sh_media_STLO_L", SH_BLTIN_STUA_L, 0 },
10746   { CODE_FOR_stlo_q,    "__builtin_sh_media_STLO_Q", SH_BLTIN_STUA_Q, 0 },
10747   { CODE_FOR_ldhi_l64,  "__builtin_sh_media_LDHI_L", SH_BLTIN_LDUA_L64, 0 },
10748   { CODE_FOR_ldhi_q64,  "__builtin_sh_media_LDHI_Q", SH_BLTIN_LDUA_Q64, 0 },
10749   { CODE_FOR_ldlo_l64,  "__builtin_sh_media_LDLO_L", SH_BLTIN_LDUA_L64, 0 },
10750   { CODE_FOR_ldlo_q64,  "__builtin_sh_media_LDLO_Q", SH_BLTIN_LDUA_Q64, 0 },
10751   { CODE_FOR_sthi_l64,  "__builtin_sh_media_STHI_L", SH_BLTIN_STUA_L64, 0 },
10752   { CODE_FOR_sthi_q64,  "__builtin_sh_media_STHI_Q", SH_BLTIN_STUA_Q64, 0 },
10753   { CODE_FOR_stlo_l64,  "__builtin_sh_media_STLO_L", SH_BLTIN_STUA_L64, 0 },
10754   { CODE_FOR_stlo_q64,  "__builtin_sh_media_STLO_Q", SH_BLTIN_STUA_Q64, 0 },
10755   { CODE_FOR_nsb,       "__builtin_sh_media_NSB", SH_BLTIN_SU, 0 },
10756   { CODE_FOR_byterev,   "__builtin_sh_media_BYTEREV", SH_BLTIN_2, 0 },
10757   { CODE_FOR_prefetch,  "__builtin_sh_media_PREFO", SH_BLTIN_PSSV, 0 },
10758 };
10759
10760 static void
10761 sh_media_init_builtins (void)
10762 {
10763   tree shared[SH_BLTIN_NUM_SHARED_SIGNATURES];
10764   struct builtin_description *d;
10765
10766   memset (shared, 0, sizeof shared);
10767   for (d = bdesc; d - bdesc < (int) ARRAY_SIZE (bdesc); d++)
10768     {
10769       tree type, arg_type = 0;
10770       int signature = d->signature;
10771       int i;
10772
10773       if (signature < SH_BLTIN_NUM_SHARED_SIGNATURES && shared[signature])
10774         type = shared[signature];
10775       else
10776         {
10777           int has_result = signature_args[signature][0] != 0;
10778
10779           if ((signature_args[signature][1] & 8)
10780               && (((signature_args[signature][1] & 1) && TARGET_SHMEDIA32)
10781                   || ((signature_args[signature][1] & 2) && TARGET_SHMEDIA64)))
10782             continue;
10783           if (! TARGET_FPU_ANY
10784               && FLOAT_MODE_P (insn_data[d->icode].operand[0].mode))
10785             continue;
10786           type = void_list_node;
10787           for (i = 3; ; i--)
10788             {
10789               int arg = signature_args[signature][i];
10790               int opno = i - 1 + has_result;
10791
10792               if (arg & 8)
10793                 arg_type = ptr_type_node;
10794               else if (arg)
10795                 arg_type = (*lang_hooks.types.type_for_mode)
10796                   (insn_data[d->icode].operand[opno].mode,
10797                    (arg & 1));
10798               else if (i)
10799                 continue;
10800               else
10801                 arg_type = void_type_node;
10802               if (i == 0)
10803                 break;
10804               type = tree_cons (NULL_TREE, arg_type, type);
10805             }
10806           type = build_function_type (arg_type, type);
10807           if (signature < SH_BLTIN_NUM_SHARED_SIGNATURES)
10808             shared[signature] = type;
10809         }
10810       d->fndecl =
10811         add_builtin_function (d->name, type, d - bdesc, BUILT_IN_MD,
10812                               NULL, NULL_TREE);
10813     }
10814 }
10815
10816 /* Returns the shmedia builtin decl for CODE.  */
10817
10818 static tree
10819 sh_media_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
10820 {
10821   if (code >= ARRAY_SIZE (bdesc))
10822     return error_mark_node;
10823
10824   return bdesc[code].fndecl;
10825 }
10826
10827 /* Implements target hook vector_mode_supported_p.  */
10828 bool
10829 sh_vector_mode_supported_p (enum machine_mode mode)
10830 {
10831   if (TARGET_FPU_ANY
10832       && ((mode == V2SFmode)
10833           || (mode == V4SFmode)
10834           || (mode == V16SFmode)))
10835     return true;
10836
10837   else if (TARGET_SHMEDIA
10838            && ((mode == V8QImode)
10839                || (mode == V2HImode)
10840                || (mode == V4HImode)
10841                || (mode == V2SImode)))
10842     return true;
10843
10844   return false;
10845 }
10846
10847 /* Implements target hook dwarf_calling_convention.  Return an enum
10848    of dwarf_calling_convention.  */
10849 int
10850 sh_dwarf_calling_convention (const_tree func)
10851 {
10852   if (sh_attr_renesas_p (func))
10853     return DW_CC_GNU_renesas_sh;
10854
10855   return DW_CC_normal;
10856 }
10857
10858 static void
10859 sh_init_builtins (void)
10860 {
10861   if (TARGET_SHMEDIA)
10862     sh_media_init_builtins ();
10863 }
10864
10865 /* Returns the sh builtin decl for CODE.  */
10866
10867 static tree
10868 sh_builtin_decl (unsigned code, bool initialize_p ATTRIBUTE_UNUSED)
10869 {
10870   if (TARGET_SHMEDIA)
10871     return sh_media_builtin_decl (code, initialize_p);
10872
10873   return error_mark_node;
10874 }
10875
10876 /* Expand an expression EXP that calls a built-in function,
10877    with result going to TARGET if that's convenient
10878    (and in mode MODE if that's convenient).
10879    SUBTARGET may be used as the target for computing one of EXP's operands.
10880    IGNORE is nonzero if the value is to be ignored.  */
10881
10882 static rtx
10883 sh_expand_builtin (tree exp, rtx target, rtx subtarget ATTRIBUTE_UNUSED,
10884                    enum machine_mode mode ATTRIBUTE_UNUSED, int ignore)
10885 {
10886   tree fndecl = TREE_OPERAND (CALL_EXPR_FN (exp), 0);
10887   unsigned int fcode = DECL_FUNCTION_CODE (fndecl);
10888   const struct builtin_description *d = &bdesc[fcode];
10889   enum insn_code icode = d->icode;
10890   int signature = d->signature;
10891   enum machine_mode tmode = VOIDmode;
10892   int nop = 0, i;
10893   rtx op[4];
10894   rtx pat = 0;
10895
10896   if (signature_args[signature][0])
10897     {
10898       if (ignore)
10899         return 0;
10900
10901       tmode = insn_data[icode].operand[0].mode;
10902       if (! target
10903           || GET_MODE (target) != tmode
10904           || ! (*insn_data[icode].operand[0].predicate) (target, tmode))
10905         target = gen_reg_rtx (tmode);
10906       op[nop++] = target;
10907     }
10908   else
10909     target = 0;
10910
10911   for (i = 1; i <= 3; i++, nop++)
10912     {
10913       tree arg;
10914       enum machine_mode opmode, argmode;
10915       tree optype;
10916
10917       if (! signature_args[signature][i])
10918         break;
10919       arg = CALL_EXPR_ARG (exp, i - 1);
10920       if (arg == error_mark_node)
10921         return const0_rtx;
10922       if (signature_args[signature][i] & 8)
10923         {
10924           opmode = ptr_mode;
10925           optype = ptr_type_node;
10926         }
10927       else
10928         {
10929           opmode = insn_data[icode].operand[nop].mode;
10930           optype = (*lang_hooks.types.type_for_mode) (opmode, 0);
10931         }
10932       argmode = TYPE_MODE (TREE_TYPE (arg));
10933       if (argmode != opmode)
10934         arg = build1 (NOP_EXPR, optype, arg);
10935       op[nop] = expand_expr (arg, NULL_RTX, opmode, EXPAND_NORMAL);
10936       if (! (*insn_data[icode].operand[nop].predicate) (op[nop], opmode))
10937         op[nop] = copy_to_mode_reg (opmode, op[nop]);
10938     }
10939
10940   switch (nop)
10941     {
10942     case 1:
10943       pat = (*insn_data[d->icode].genfun) (op[0]);
10944       break;
10945     case 2:
10946       pat = (*insn_data[d->icode].genfun) (op[0], op[1]);
10947       break;
10948     case 3:
10949       pat = (*insn_data[d->icode].genfun) (op[0], op[1], op[2]);
10950       break;
10951     case 4:
10952       pat = (*insn_data[d->icode].genfun) (op[0], op[1], op[2], op[3]);
10953       break;
10954     default:
10955       gcc_unreachable ();
10956     }
10957   if (! pat)
10958     return 0;
10959   emit_insn (pat);
10960   return target;
10961 }
10962
10963 void
10964 sh_expand_unop_v2sf (enum rtx_code code, rtx op0, rtx op1)
10965 {
10966   rtx sel0 = const0_rtx;
10967   rtx sel1 = const1_rtx;
10968   rtx (*fn) (rtx, rtx, rtx, rtx, rtx) = gen_unary_sf_op;
10969   rtx op = gen_rtx_fmt_e (code, SFmode, op1);
10970
10971   emit_insn ((*fn) (op0, op1, op, sel0, sel0));
10972   emit_insn ((*fn) (op0, op1, op, sel1, sel1));
10973 }
10974
10975 void
10976 sh_expand_binop_v2sf (enum rtx_code code, rtx op0, rtx op1, rtx op2)
10977 {
10978   rtx op = gen_rtx_fmt_ee (code, SFmode, op1, op2);
10979
10980   emit_insn (gen_binary_sf_op0 (op0, op1, op2, op));
10981   emit_insn (gen_binary_sf_op1 (op0, op1, op2, op));
10982 }
10983
10984 /* Return true if hard register REGNO can hold a value of machine-mode MODE.
10985    We can allow any mode in any general register.  The special registers
10986    only allow SImode.  Don't allow any mode in the PR.
10987
10988    We cannot hold DCmode values in the XD registers because alter_reg
10989    handles subregs of them incorrectly.  We could work around this by
10990    spacing the XD registers like the DR registers, but this would require
10991    additional memory in every compilation to hold larger register vectors.
10992    We could hold SFmode / SCmode values in XD registers, but that
10993    would require a tertiary reload when reloading from / to memory,
10994    and a secondary reload to reload from / to general regs; that
10995    seems to be a loosing proposition.
10996
10997    We want to allow TImode FP regs so that when V4SFmode is loaded as TImode,
10998    it won't be ferried through GP registers first.  */
10999
11000 bool
11001 sh_hard_regno_mode_ok (unsigned int regno, enum machine_mode mode)
11002 {
11003   if (SPECIAL_REGISTER_P (regno))
11004     return mode == SImode;
11005
11006   if (regno == FPUL_REG)
11007     return (mode == SImode || mode == SFmode);
11008
11009   if (FP_REGISTER_P (regno) && mode == SFmode)
11010     return true;
11011
11012   if (mode == V2SFmode)
11013     {
11014       if (((FP_REGISTER_P (regno) && (regno - FIRST_FP_REG) % 2 == 0)
11015            || GENERAL_REGISTER_P (regno)))
11016         return true;
11017       else
11018         return false;
11019     }
11020
11021   if (mode == V4SFmode)
11022     {
11023       if ((FP_REGISTER_P (regno) && (regno - FIRST_FP_REG) % 4 == 0)
11024           || GENERAL_REGISTER_P (regno))
11025         return true;
11026       else
11027         return false;
11028     }
11029
11030   if (mode == V16SFmode)
11031     {
11032       if (TARGET_SHMEDIA)
11033         {
11034           if (FP_REGISTER_P (regno) && (regno - FIRST_FP_REG) % 16 == 0)
11035             return true;
11036           else
11037             return false;
11038         }
11039       else
11040         return regno == FIRST_XD_REG;
11041     }
11042
11043   if (FP_REGISTER_P (regno))
11044     {
11045       if (mode == SFmode
11046           || mode == SImode
11047           || ((TARGET_SH2E || TARGET_SHMEDIA) && mode == SCmode)
11048           || ((((TARGET_SH4 || TARGET_SH2A_DOUBLE) && mode == DFmode)
11049                || mode == DCmode
11050                || (TARGET_SHMEDIA
11051                    && (mode == DFmode || mode == DImode
11052                        || mode == V2SFmode || mode == TImode)))
11053               && ((regno - FIRST_FP_REG) & 1) == 0)
11054           || ((TARGET_SH4 || TARGET_SHMEDIA) && mode == TImode
11055               && ((regno - FIRST_FP_REG) & 3) == 0))
11056         return true;
11057       else
11058         return false;
11059     }
11060
11061   if (XD_REGISTER_P (regno))
11062     return mode == DFmode;
11063
11064   if (TARGET_REGISTER_P (regno))
11065     return (mode == DImode || mode == SImode || mode == PDImode);
11066
11067   if (regno == PR_REG)
11068     return mode == SImode;
11069
11070   if (regno == FPSCR_REG)
11071     return mode == PSImode;
11072
11073   /* FIXME.  This works around PR target/37633 for -O0.  */
11074   if (!optimize && TARGET_SHMEDIA32 && GET_MODE_SIZE (mode) > 4)
11075     {
11076       unsigned int n = GET_MODE_SIZE (mode) / 8;
11077
11078       if (regno >= FIRST_GENERAL_REG + 10 - n + 1
11079           && regno <= FIRST_GENERAL_REG + 14)
11080         return false;
11081     }
11082
11083   return true;
11084 }
11085
11086 /* Return the class of registers for which a mode change from FROM to TO
11087    is invalid.  */
11088 bool
11089 sh_cannot_change_mode_class (enum machine_mode from, enum machine_mode to,
11090                              enum reg_class rclass)
11091 {
11092   /* We want to enable the use of SUBREGs as a means to
11093      VEC_SELECT a single element of a vector.  */
11094   if (to == SFmode && VECTOR_MODE_P (from) && GET_MODE_INNER (from) == SFmode)
11095     return (reg_classes_intersect_p (GENERAL_REGS, rclass));
11096
11097   if (GET_MODE_SIZE (from) != GET_MODE_SIZE (to))
11098     {
11099       if (TARGET_LITTLE_ENDIAN)
11100         {
11101           if (GET_MODE_SIZE (to) < 8 || GET_MODE_SIZE (from) < 8)
11102             return reg_classes_intersect_p (DF_REGS, rclass);
11103         }
11104       else
11105         {
11106           if (GET_MODE_SIZE (from) < 8)
11107             return reg_classes_intersect_p (DF_HI_REGS, rclass);
11108         }
11109     }
11110   return 0;
11111 }
11112
11113
11114 /* If ADDRESS refers to a CODE_LABEL, add NUSES to the number of times
11115    that label is used.  */
11116
11117 void
11118 sh_mark_label (rtx address, int nuses)
11119 {
11120   if (GOTOFF_P (address))
11121     {
11122       /* Extract the label or symbol.  */
11123       address = XEXP (address, 0);
11124       if (GET_CODE (address) == PLUS)
11125         address = XEXP (address, 0);
11126       address = XVECEXP (address, 0, 0);
11127     }
11128   if (GET_CODE (address) == LABEL_REF
11129       && LABEL_P (XEXP (address, 0)))
11130     LABEL_NUSES (XEXP (address, 0)) += nuses;
11131 }
11132
11133 /* Compute extra cost of moving data between one register class
11134    and another.  */
11135
11136 /* If SECONDARY*_RELOAD_CLASS says something about the src/dst pair, regclass
11137    uses this information.  Hence, the general register <-> floating point
11138    register information here is not used for SFmode.  */
11139
11140 int
11141 sh_register_move_cost (enum machine_mode mode,
11142                        enum reg_class srcclass, enum reg_class dstclass)
11143 {
11144   if (dstclass == T_REGS || dstclass == PR_REGS)
11145     return 10;
11146
11147   if (dstclass == MAC_REGS && srcclass == MAC_REGS)
11148     return 4;
11149
11150   if (mode == SImode && ! TARGET_SHMEDIA && TARGET_FMOVD
11151       && REGCLASS_HAS_FP_REG (srcclass)
11152       && REGCLASS_HAS_FP_REG (dstclass))
11153     return 4;
11154
11155   if (REGCLASS_HAS_FP_REG (dstclass) && srcclass == T_REGS)
11156     return ((TARGET_HARD_SH4 && !optimize_size) ? 10 : 7);
11157
11158   if ((REGCLASS_HAS_FP_REG (dstclass) && srcclass == MAC_REGS)
11159       || (dstclass == MAC_REGS && REGCLASS_HAS_FP_REG (srcclass)))
11160     return 9;
11161
11162   if ((REGCLASS_HAS_FP_REG (dstclass)
11163        && REGCLASS_HAS_GENERAL_REG (srcclass))
11164       || (REGCLASS_HAS_GENERAL_REG (dstclass)
11165           && REGCLASS_HAS_FP_REG (srcclass)))
11166     return ((TARGET_SHMEDIA ? 4 : TARGET_FMOVD ? 8 : 12)
11167             * ((GET_MODE_SIZE (mode) + 7) / 8U));
11168
11169   if ((dstclass == FPUL_REGS
11170        && REGCLASS_HAS_GENERAL_REG (srcclass))
11171       || (srcclass == FPUL_REGS
11172           && REGCLASS_HAS_GENERAL_REG (dstclass)))
11173     return 5;
11174
11175   if ((dstclass == FPUL_REGS
11176        && (srcclass == PR_REGS || srcclass == MAC_REGS || srcclass == T_REGS))
11177       || (srcclass == FPUL_REGS
11178           && (dstclass == PR_REGS || dstclass == MAC_REGS)))
11179     return 7;
11180
11181   if ((srcclass == TARGET_REGS && ! REGCLASS_HAS_GENERAL_REG (dstclass))
11182       || ((dstclass) == TARGET_REGS && ! REGCLASS_HAS_GENERAL_REG (srcclass)))
11183     return 20;
11184
11185   /* ??? ptabs faults on (value & 0x3) == 0x3  */
11186   if (TARGET_SHMEDIA
11187       && ((srcclass) == TARGET_REGS || (srcclass) == SIBCALL_REGS))
11188     {
11189       if (sh_gettrcost >= 0)
11190         return sh_gettrcost;
11191       else if (!TARGET_PT_FIXED)
11192         return 100;
11193     }
11194
11195   if ((srcclass == FPSCR_REGS && ! REGCLASS_HAS_GENERAL_REG (dstclass))
11196       || (dstclass == FPSCR_REGS && ! REGCLASS_HAS_GENERAL_REG (srcclass)))
11197   return 4;
11198
11199   if (TARGET_SHMEDIA
11200       || (TARGET_FMOVD
11201           && ! REGCLASS_HAS_GENERAL_REG (srcclass)
11202           && ! REGCLASS_HAS_GENERAL_REG (dstclass)))
11203     return 2 * ((GET_MODE_SIZE (mode) + 7) / 8U);
11204
11205   return 2 * ((GET_MODE_SIZE (mode) + 3) / 4U);
11206 }
11207
11208 static rtx emit_load_ptr (rtx, rtx);
11209
11210 static rtx
11211 emit_load_ptr (rtx reg, rtx addr)
11212 {
11213   rtx mem = gen_const_mem (ptr_mode, addr);
11214
11215   if (Pmode != ptr_mode)
11216     mem = gen_rtx_SIGN_EXTEND (Pmode, mem);
11217   return emit_move_insn (reg, mem);
11218 }
11219
11220 static void
11221 sh_output_mi_thunk (FILE *file, tree thunk_fndecl ATTRIBUTE_UNUSED,
11222                     HOST_WIDE_INT delta, HOST_WIDE_INT vcall_offset,
11223                     tree function)
11224 {
11225   CUMULATIVE_ARGS cum;
11226   int structure_value_byref = 0;
11227   rtx this_rtx, this_value, sibcall, insns, funexp;
11228   tree funtype = TREE_TYPE (function);
11229   int simple_add = CONST_OK_FOR_ADD (delta);
11230   int did_load = 0;
11231   rtx scratch0, scratch1, scratch2;
11232   unsigned i;
11233
11234   reload_completed = 1;
11235   epilogue_completed = 1;
11236   current_function_uses_only_leaf_regs = 1;
11237
11238   emit_note (NOTE_INSN_PROLOGUE_END);
11239
11240   /* Find the "this" pointer.  We have such a wide range of ABIs for the
11241      SH that it's best to do this completely machine independently.
11242      "this" is passed as first argument, unless a structure return pointer
11243      comes first, in which case "this" comes second.  */
11244   INIT_CUMULATIVE_ARGS (cum, funtype, NULL_RTX, 0, 1);
11245 #ifndef PCC_STATIC_STRUCT_RETURN
11246   if (aggregate_value_p (TREE_TYPE (TREE_TYPE (function)), function))
11247     structure_value_byref = 1;
11248 #endif /* not PCC_STATIC_STRUCT_RETURN */
11249   if (structure_value_byref && sh_struct_value_rtx (function, 0) == 0)
11250     {
11251       tree ptype = build_pointer_type (TREE_TYPE (funtype));
11252
11253       FUNCTION_ARG_ADVANCE (cum, Pmode, ptype, 1);
11254     }
11255   this_rtx = FUNCTION_ARG (cum, Pmode, ptr_type_node, 1);
11256
11257   /* For SHcompact, we only have r0 for a scratch register: r1 is the
11258      static chain pointer (even if you can't have nested virtual functions
11259      right now, someone might implement them sometime), and the rest of the
11260      registers are used for argument passing, are callee-saved, or reserved.  */
11261   /* We need to check call_used_regs / fixed_regs in case -fcall_saved-reg /
11262      -ffixed-reg has been used.  */
11263   if (! call_used_regs[0] || fixed_regs[0])
11264     error ("r0 needs to be available as a call-clobbered register");
11265   scratch0 = scratch1 = scratch2 = gen_rtx_REG (Pmode, 0);
11266   if (! TARGET_SH5)
11267     {
11268       if (call_used_regs[1] && ! fixed_regs[1])
11269         scratch1 = gen_rtx_REG (ptr_mode, 1);
11270       /* N.B., if not TARGET_HITACHI, register 2 is used to pass the pointer
11271          pointing where to return struct values.  */
11272       if (call_used_regs[3] && ! fixed_regs[3])
11273         scratch2 = gen_rtx_REG (Pmode, 3);
11274     }
11275   else if (TARGET_SHMEDIA)
11276     {
11277       for (i = FIRST_GENERAL_REG; i <= LAST_GENERAL_REG; i++)
11278         if (i != REGNO (scratch0) &&
11279             call_used_regs[i] && ! fixed_regs[i] && ! FUNCTION_ARG_REGNO_P (i))
11280           {
11281             scratch1 = gen_rtx_REG (ptr_mode, i);
11282             break;
11283           }
11284       if (scratch1 == scratch0)
11285         error ("Need a second call-clobbered general purpose register");
11286       for (i = FIRST_TARGET_REG; i <= LAST_TARGET_REG; i++)
11287         if (call_used_regs[i] && ! fixed_regs[i])
11288           {
11289             scratch2 = gen_rtx_REG (Pmode, i);
11290             break;
11291           }
11292       if (scratch2 == scratch0)
11293         error ("Need a call-clobbered target register");
11294     }
11295
11296   this_value = plus_constant (this_rtx, delta);
11297   if (vcall_offset
11298       && (simple_add || scratch0 != scratch1)
11299       && strict_memory_address_p (ptr_mode, this_value))
11300     {
11301       emit_load_ptr (scratch0, this_value);
11302       did_load = 1;
11303     }
11304
11305   if (!delta)
11306     ; /* Do nothing.  */
11307   else if (simple_add)
11308     emit_move_insn (this_rtx, this_value);
11309   else
11310     {
11311       emit_move_insn (scratch1, GEN_INT (delta));
11312       emit_insn (gen_add2_insn (this_rtx, scratch1));
11313     }
11314
11315   if (vcall_offset)
11316     {
11317       rtx offset_addr;
11318
11319       if (!did_load)
11320         emit_load_ptr (scratch0, this_rtx);
11321
11322       offset_addr = plus_constant (scratch0, vcall_offset);
11323       if (strict_memory_address_p (ptr_mode, offset_addr))
11324         ; /* Do nothing.  */
11325       else if (! TARGET_SH5 && scratch0 != scratch1)
11326         {
11327           /* scratch0 != scratch1, and we have indexed loads.  Get better
11328              schedule by loading the offset into r1 and using an indexed
11329              load - then the load of r1 can issue before the load from
11330              (this_rtx + delta) finishes.  */
11331           emit_move_insn (scratch1, GEN_INT (vcall_offset));
11332           offset_addr = gen_rtx_PLUS (Pmode, scratch0, scratch1);
11333         }
11334       else if (CONST_OK_FOR_ADD (vcall_offset))
11335         {
11336           emit_insn (gen_add2_insn (scratch0, GEN_INT (vcall_offset)));
11337           offset_addr = scratch0;
11338         }
11339       else if (scratch0 != scratch1)
11340         {
11341           emit_move_insn (scratch1, GEN_INT (vcall_offset));
11342           emit_insn (gen_add2_insn (scratch0, scratch1));
11343           offset_addr = scratch0;
11344         }
11345       else
11346         gcc_unreachable (); /* FIXME */
11347       emit_load_ptr (scratch0, offset_addr);
11348
11349       if (Pmode != ptr_mode)
11350         scratch0 = gen_rtx_TRUNCATE (ptr_mode, scratch0);
11351       emit_insn (gen_add2_insn (this_rtx, scratch0));
11352     }
11353
11354   /* Generate a tail call to the target function.  */
11355   if (! TREE_USED (function))
11356     {
11357       assemble_external (function);
11358       TREE_USED (function) = 1;
11359     }
11360   funexp = XEXP (DECL_RTL (function), 0);
11361   /* If the function is overridden, so is the thunk, hence we don't
11362      need GOT addressing even if this is a public symbol.  */
11363 #if 0
11364   if (TARGET_SH1 && ! flag_weak)
11365     sibcall = gen_sibcalli_thunk (funexp, const0_rtx);
11366   else
11367 #endif
11368   if (TARGET_SH2 && flag_pic)
11369     {
11370       sibcall = gen_sibcall_pcrel (funexp, const0_rtx);
11371       XEXP (XVECEXP (sibcall, 0, 2), 0) = scratch2;
11372     }
11373   else
11374     {
11375       if (TARGET_SHMEDIA && flag_pic)
11376         {
11377           funexp = gen_sym2PIC (funexp);
11378           PUT_MODE (funexp, Pmode);
11379         }
11380       emit_move_insn (scratch2, funexp);
11381       funexp = gen_rtx_MEM (FUNCTION_MODE, scratch2);
11382       sibcall = gen_sibcall (funexp, const0_rtx, NULL_RTX);
11383     }
11384   sibcall = emit_call_insn (sibcall);
11385   SIBLING_CALL_P (sibcall) = 1;
11386   use_reg (&CALL_INSN_FUNCTION_USAGE (sibcall), this_rtx);
11387   emit_barrier ();
11388
11389   /* Run just enough of rest_of_compilation to do scheduling and get
11390      the insns emitted.  Note that use_thunk calls
11391      assemble_start_function and assemble_end_function.  */
11392
11393   insn_locators_alloc ();
11394   insns = get_insns ();
11395
11396   if (optimize > 0)
11397     {
11398       if (! cfun->cfg)
11399         init_flow (cfun);
11400       split_all_insns_noflow ();
11401     }
11402
11403   sh_reorg ();
11404
11405   if (optimize > 0 && flag_delayed_branch)
11406     dbr_schedule (insns);
11407
11408   shorten_branches (insns);
11409   final_start_function (insns, file, 1);
11410   final (insns, file, 1);
11411   final_end_function ();
11412
11413   reload_completed = 0;
11414   epilogue_completed = 0;
11415 }
11416
11417 rtx
11418 function_symbol (rtx target, const char *name, enum sh_function_kind kind)
11419 {
11420   rtx sym;
11421
11422   /* If this is not an ordinary function, the name usually comes from a
11423      string literal or an sprintf buffer.  Make sure we use the same
11424      string consistently, so that cse will be able to unify address loads.  */
11425   if (kind != FUNCTION_ORDINARY)
11426     name = IDENTIFIER_POINTER (get_identifier (name));
11427   sym = gen_rtx_SYMBOL_REF (Pmode, name);
11428   SYMBOL_REF_FLAGS (sym) = SYMBOL_FLAG_FUNCTION;
11429   if (flag_pic)
11430     switch (kind)
11431       {
11432       case FUNCTION_ORDINARY:
11433         break;
11434       case SFUNC_GOT:
11435         {
11436           rtx reg = target ? target : gen_reg_rtx (Pmode);
11437
11438           emit_insn (gen_symGOT2reg (reg, sym));
11439           sym = reg;
11440           break;
11441         }
11442       case SFUNC_STATIC:
11443         {
11444           /* ??? To allow cse to work, we use GOTOFF relocations.
11445              we could add combiner patterns to transform this into
11446              straight pc-relative calls with sym2PIC / bsrf when
11447              label load and function call are still 1:1 and in the
11448              same basic block during combine.  */
11449           rtx reg = target ? target : gen_reg_rtx (Pmode);
11450
11451           emit_insn (gen_symGOTOFF2reg (reg, sym));
11452           sym = reg;
11453           break;
11454         }
11455       }
11456   if (target && sym != target)
11457     {
11458       emit_move_insn (target, sym);
11459       return target;
11460     }
11461   return sym;
11462 }
11463
11464 /* Find the number of a general purpose register in S.  */
11465 static int
11466 scavenge_reg (HARD_REG_SET *s)
11467 {
11468   int r;
11469   for (r = FIRST_GENERAL_REG; r <= LAST_GENERAL_REG; r++)
11470     if (TEST_HARD_REG_BIT (*s, r))
11471       return r;
11472   return -1;
11473 }
11474
11475 rtx
11476 sh_get_pr_initial_val (void)
11477 {
11478   rtx val;
11479
11480   /* ??? Unfortunately, get_hard_reg_initial_val doesn't always work for the
11481      PR register on SHcompact, because it might be clobbered by the prologue.
11482      We check first if that is known to be the case.  */
11483   if (TARGET_SHCOMPACT
11484       && ((crtl->args.info.call_cookie
11485            & ~ CALL_COOKIE_RET_TRAMP (1))
11486           || crtl->saves_all_registers))
11487     return gen_frame_mem (SImode, return_address_pointer_rtx);
11488
11489   /* If we haven't finished rtl generation, there might be a nonlocal label
11490      that we haven't seen yet.
11491      ??? get_hard_reg_initial_val fails if it is called after register
11492      allocation has started, unless it has been called before for the
11493      same register.  And even then, we end in trouble if we didn't use
11494      the register in the same basic block before.  So call
11495      get_hard_reg_initial_val now and wrap it in an unspec if we might
11496      need to replace it.  */
11497   /* ??? We also must do this for TARGET_SH1 in general, because otherwise
11498      combine can put the pseudo returned by get_hard_reg_initial_val into
11499      instructions that need a general purpose registers, which will fail to
11500      be recognized when the pseudo becomes allocated to PR.  */
11501   val
11502     = get_hard_reg_initial_val (Pmode, TARGET_SHMEDIA ? PR_MEDIA_REG : PR_REG);
11503   if (TARGET_SH1)
11504     return gen_rtx_UNSPEC (SImode, gen_rtvec (1, val), UNSPEC_RA);
11505   return val;
11506 }
11507
11508 int
11509 sh_expand_t_scc (rtx operands[])
11510 {
11511   enum rtx_code code = GET_CODE (operands[1]);
11512   rtx target = operands[0];
11513   rtx op0 = operands[2];
11514   rtx op1 = operands[3];
11515   rtx result = target;
11516   HOST_WIDE_INT val;
11517
11518   if (!REG_P (op0) || REGNO (op0) != T_REG
11519       || !CONST_INT_P (op1))
11520     return 0;
11521   if (!REG_P (result))
11522     result = gen_reg_rtx (SImode);
11523   val = INTVAL (op1);
11524   if ((code == EQ && val == 1) || (code == NE && val == 0))
11525     emit_insn (gen_movt (result));
11526   else if (TARGET_SH2A && ((code == EQ && val == 0)
11527                             || (code == NE && val == 1)))
11528     emit_insn (gen_xorsi3_movrt (result));
11529   else if ((code == EQ && val == 0) || (code == NE && val == 1))
11530     {
11531       emit_clobber (result);
11532       emit_insn (gen_subc (result, result, result));
11533       emit_insn (gen_addsi3 (result, result, const1_rtx));
11534     }
11535   else if (code == EQ || code == NE)
11536     emit_insn (gen_move_insn (result, GEN_INT (code == NE)));
11537   else
11538     return 0;
11539   if (result != target)
11540     emit_move_insn (target, result);
11541   return 1;
11542 }
11543
11544 /* INSN is an sfunc; return the rtx that describes the address used.  */
11545 static rtx
11546 extract_sfunc_addr (rtx insn)
11547 {
11548   rtx pattern, part = NULL_RTX;
11549   int len, i;
11550
11551   pattern = PATTERN (insn);
11552   len = XVECLEN (pattern, 0);
11553   for (i = 0; i < len; i++)
11554     {
11555       part = XVECEXP (pattern, 0, i);
11556       if (GET_CODE (part) == USE && GET_MODE (XEXP (part, 0)) == Pmode
11557           && GENERAL_REGISTER_P (true_regnum (XEXP (part, 0))))
11558         return XEXP (part, 0);
11559     }
11560   gcc_assert (GET_CODE (XVECEXP (pattern, 0, 0)) == UNSPEC_VOLATILE);
11561   return XVECEXP (XVECEXP (pattern, 0, 0), 0, 1);
11562 }
11563
11564 /* Verify that the register in use_sfunc_addr still agrees with the address
11565    used in the sfunc.  This prevents fill_slots_from_thread from changing
11566    use_sfunc_addr.
11567    INSN is the use_sfunc_addr instruction, and REG is the register it
11568    guards.  */
11569 int
11570 check_use_sfunc_addr (rtx insn, rtx reg)
11571 {
11572   /* Search for the sfunc.  It should really come right after INSN.  */
11573   while ((insn = NEXT_INSN (insn)))
11574     {
11575       if (LABEL_P (insn) || JUMP_P (insn))
11576         break;
11577       if (! INSN_P (insn))
11578         continue;
11579
11580       if (GET_CODE (PATTERN (insn)) == SEQUENCE)
11581         insn = XVECEXP (PATTERN (insn), 0, 0);
11582       if (GET_CODE (PATTERN (insn)) != PARALLEL
11583           || get_attr_type (insn) != TYPE_SFUNC)
11584         continue;
11585       return rtx_equal_p (extract_sfunc_addr (insn), reg);
11586     }
11587   gcc_unreachable ();
11588 }
11589
11590 /* This function returns a constant rtx that represents pi / 2**15 in
11591    SFmode.  it's used to scale SFmode angles, in radians, to a
11592    fixed-point signed 16.16-bit fraction of a full circle, i.e., 2*pi
11593    maps to 0x10000).  */
11594
11595 static GTY(()) rtx sh_fsca_sf2int_rtx;
11596
11597 rtx
11598 sh_fsca_sf2int (void)
11599 {
11600   if (! sh_fsca_sf2int_rtx)
11601     {
11602       REAL_VALUE_TYPE rv;
11603
11604       real_from_string (&rv, "10430.378350470453");
11605       sh_fsca_sf2int_rtx = const_double_from_real_value (rv, SFmode);
11606     }
11607
11608   return sh_fsca_sf2int_rtx;
11609 }
11610
11611 /* This function returns a constant rtx that represents pi / 2**15 in
11612    DFmode.  it's used to scale DFmode angles, in radians, to a
11613    fixed-point signed 16.16-bit fraction of a full circle, i.e., 2*pi
11614    maps to 0x10000).  */
11615
11616 static GTY(()) rtx sh_fsca_df2int_rtx;
11617
11618 rtx
11619 sh_fsca_df2int (void)
11620 {
11621   if (! sh_fsca_df2int_rtx)
11622     {
11623       REAL_VALUE_TYPE rv;
11624
11625       real_from_string (&rv, "10430.378350470453");
11626       sh_fsca_df2int_rtx = const_double_from_real_value (rv, DFmode);
11627     }
11628
11629   return sh_fsca_df2int_rtx;
11630 }
11631
11632 /* This function returns a constant rtx that represents 2**15 / pi in
11633    SFmode.  it's used to scale a fixed-point signed 16.16-bit fraction
11634    of a full circle back to a SFmode value, i.e., 0x10000 maps to
11635    2*pi).  */
11636
11637 static GTY(()) rtx sh_fsca_int2sf_rtx;
11638
11639 rtx
11640 sh_fsca_int2sf (void)
11641 {
11642   if (! sh_fsca_int2sf_rtx)
11643     {
11644       REAL_VALUE_TYPE rv;
11645
11646       real_from_string (&rv, "9.587379924285257e-5");
11647       sh_fsca_int2sf_rtx = const_double_from_real_value (rv, SFmode);
11648     }
11649
11650   return sh_fsca_int2sf_rtx;
11651 }
11652
11653 /* Initialize the CUMULATIVE_ARGS structure.  */
11654
11655 void
11656 sh_init_cumulative_args (CUMULATIVE_ARGS *  pcum,
11657                          tree               fntype,
11658                          rtx                libname ATTRIBUTE_UNUSED,
11659                          tree               fndecl,
11660                          signed int         n_named_args,
11661                          enum machine_mode  mode)
11662 {
11663   pcum->arg_count [(int) SH_ARG_FLOAT] = 0;
11664   pcum->free_single_fp_reg = 0;
11665   pcum->stack_regs = 0;
11666   pcum->byref_regs = 0;
11667   pcum->byref = 0;
11668   pcum->outgoing = (n_named_args == -1) ? 0 : 1;
11669
11670   /* XXX - Should we check TARGET_HITACHI here ???  */
11671   pcum->renesas_abi = sh_attr_renesas_p (fntype) ? 1 : 0;
11672
11673   if (fntype)
11674     {
11675       pcum->force_mem = ((TARGET_HITACHI || pcum->renesas_abi)
11676                          && aggregate_value_p (TREE_TYPE (fntype), fndecl));
11677       pcum->prototype_p = TYPE_ARG_TYPES (fntype) ? TRUE : FALSE;
11678       pcum->arg_count [(int) SH_ARG_INT]
11679         = TARGET_SH5 && aggregate_value_p (TREE_TYPE (fntype), fndecl);
11680
11681       pcum->call_cookie
11682         = CALL_COOKIE_RET_TRAMP (TARGET_SHCOMPACT
11683                                  && pcum->arg_count [(int) SH_ARG_INT] == 0
11684                                  && (TYPE_MODE (TREE_TYPE (fntype)) == BLKmode
11685                                      ? int_size_in_bytes (TREE_TYPE (fntype))
11686                                      : GET_MODE_SIZE (TYPE_MODE (TREE_TYPE (fntype)))) > 4
11687                                  && (BASE_RETURN_VALUE_REG (TYPE_MODE (TREE_TYPE (fntype)))
11688                                      == FIRST_RET_REG));
11689     }
11690   else
11691     {
11692       pcum->arg_count [(int) SH_ARG_INT] = 0;
11693       pcum->prototype_p = FALSE;
11694       if (mode != VOIDmode)
11695         {
11696           pcum->call_cookie =
11697             CALL_COOKIE_RET_TRAMP (TARGET_SHCOMPACT
11698                                    && GET_MODE_SIZE (mode) > 4
11699                                    && BASE_RETURN_VALUE_REG (mode) == FIRST_RET_REG);
11700
11701           /* If the default ABI is the Renesas ABI then all library
11702              calls must assume that the library will be using the
11703              Renesas ABI.  So if the function would return its result
11704              in memory then we must force the address of this memory
11705              block onto the stack.  Ideally we would like to call
11706              targetm.calls.return_in_memory() here but we do not have
11707              the TYPE or the FNDECL available so we synthesize the
11708              contents of that function as best we can.  */
11709           pcum->force_mem =
11710             (TARGET_DEFAULT & MASK_HITACHI)
11711             && (mode == BLKmode
11712                 || (GET_MODE_SIZE (mode) > 4
11713                     && !(mode == DFmode
11714                          && TARGET_FPU_DOUBLE)));
11715         }
11716       else
11717         {
11718           pcum->call_cookie = 0;
11719           pcum->force_mem = FALSE;
11720         }
11721     }
11722 }
11723
11724 /* Replace any occurrence of FROM(n) in X with TO(n).  The function does
11725    not enter into CONST_DOUBLE for the replace.
11726
11727    Note that copying is not done so X must not be shared unless all copies
11728    are to be modified.
11729
11730    This is like replace_rtx, except that we operate on N_REPLACEMENTS
11731    replacements simultaneously - FROM(n) is replacements[n*2] and to(n) is
11732    replacements[n*2+1] - and that we take mode changes into account.
11733
11734    If a replacement is ambiguous, return NULL_RTX.
11735
11736    If MODIFY is zero, don't modify any rtl in place,
11737    just return zero or nonzero for failure / success.  */
11738
11739 rtx
11740 replace_n_hard_rtx (rtx x, rtx *replacements, int n_replacements, int modify)
11741 {
11742   int i, j;
11743   const char *fmt;
11744
11745   /* The following prevents loops occurrence when we change MEM in
11746      CONST_DOUBLE onto the same CONST_DOUBLE.  */
11747   if (x != 0 && GET_CODE (x) == CONST_DOUBLE)
11748     return x;
11749
11750   for (i = n_replacements - 1; i >= 0 ; i--)
11751   if (x == replacements[i*2] && GET_MODE (x) == GET_MODE (replacements[i*2+1]))
11752     return replacements[i*2+1];
11753
11754   /* Allow this function to make replacements in EXPR_LISTs.  */
11755   if (x == 0)
11756     return 0;
11757
11758   if (GET_CODE (x) == SUBREG)
11759     {
11760       rtx new_rtx = replace_n_hard_rtx (SUBREG_REG (x), replacements,
11761                                     n_replacements, modify);
11762
11763       if (CONST_INT_P (new_rtx))
11764         {
11765           x = simplify_subreg (GET_MODE (x), new_rtx,
11766                                GET_MODE (SUBREG_REG (x)),
11767                                SUBREG_BYTE (x));
11768           if (! x)
11769             abort ();
11770         }
11771       else if (modify)
11772         SUBREG_REG (x) = new_rtx;
11773
11774       return x;
11775     }
11776   else if (REG_P (x))
11777     {
11778       unsigned regno = REGNO (x);
11779       unsigned nregs = (regno < FIRST_PSEUDO_REGISTER
11780                         ? HARD_REGNO_NREGS (regno, GET_MODE (x)) : 1);
11781       rtx result = NULL_RTX;
11782
11783       for (i = n_replacements - 1; i >= 0; i--)
11784         {
11785           rtx from = replacements[i*2];
11786           rtx to = replacements[i*2+1];
11787           unsigned from_regno, from_nregs, to_regno, new_regno;
11788
11789           if (!REG_P (from))
11790             continue;
11791           from_regno = REGNO (from);
11792           from_nregs = (from_regno < FIRST_PSEUDO_REGISTER
11793                         ? HARD_REGNO_NREGS (from_regno, GET_MODE (from)) : 1);
11794           if (regno < from_regno + from_nregs && regno + nregs > from_regno)
11795             {
11796               if (regno < from_regno
11797                   || regno + nregs > from_regno + nregs
11798                   || !REG_P (to)
11799                   || result)
11800                 return NULL_RTX;
11801               to_regno = REGNO (to);
11802               if (to_regno < FIRST_PSEUDO_REGISTER)
11803                 {
11804                   new_regno = regno + to_regno - from_regno;
11805                   if ((unsigned) HARD_REGNO_NREGS (new_regno, GET_MODE (x))
11806                       != nregs)
11807                     return NULL_RTX;
11808                   result = gen_rtx_REG (GET_MODE (x), new_regno);
11809                 }
11810               else if (GET_MODE (x) <= GET_MODE (to))
11811                 result = gen_lowpart_common (GET_MODE (x), to);
11812               else
11813                 result = gen_lowpart_SUBREG (GET_MODE (x), to);
11814             }
11815         }
11816       return result ? result : x;
11817     }
11818   else if (GET_CODE (x) == ZERO_EXTEND)
11819     {
11820       rtx new_rtx = replace_n_hard_rtx (XEXP (x, 0), replacements,
11821                                     n_replacements, modify);
11822
11823       if (CONST_INT_P (new_rtx))
11824         {
11825           x = simplify_unary_operation (ZERO_EXTEND, GET_MODE (x),
11826                                         new_rtx, GET_MODE (XEXP (x, 0)));
11827           if (! x)
11828             abort ();
11829         }
11830       else if (modify)
11831         XEXP (x, 0) = new_rtx;
11832
11833       return x;
11834     }
11835
11836   fmt = GET_RTX_FORMAT (GET_CODE (x));
11837   for (i = GET_RTX_LENGTH (GET_CODE (x)) - 1; i >= 0; i--)
11838     {
11839       rtx new_rtx;
11840
11841       if (fmt[i] == 'e')
11842         {
11843           new_rtx = replace_n_hard_rtx (XEXP (x, i), replacements,
11844                                     n_replacements, modify);
11845           if (!new_rtx)
11846             return NULL_RTX;
11847           if (modify)
11848             XEXP (x, i) = new_rtx;
11849         }
11850       else if (fmt[i] == 'E')
11851         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
11852           {
11853             new_rtx = replace_n_hard_rtx (XVECEXP (x, i, j), replacements,
11854                                       n_replacements, modify);
11855           if (!new_rtx)
11856             return NULL_RTX;
11857             if (modify)
11858               XVECEXP (x, i, j) = new_rtx;
11859           }
11860     }
11861
11862   return x;
11863 }
11864
11865 rtx
11866 sh_gen_truncate (enum machine_mode mode, rtx x, int need_sign_ext)
11867 {
11868   enum rtx_code code = TRUNCATE;
11869
11870   if (GET_CODE (x) == ZERO_EXTEND || GET_CODE (x) == SIGN_EXTEND)
11871     {
11872       rtx inner = XEXP (x, 0);
11873       enum machine_mode inner_mode = GET_MODE (inner);
11874
11875       if (inner_mode == mode)
11876         return inner;
11877       else if (GET_MODE_SIZE (inner_mode) >= GET_MODE_SIZE (mode))
11878         x = inner;
11879       else if (GET_MODE_SIZE (inner_mode) < GET_MODE_SIZE (mode)
11880                && (! need_sign_ext || GET_CODE (x) == SIGN_EXTEND))
11881         {
11882           code = GET_CODE (x);
11883           x = inner;
11884         }
11885     }
11886   return gen_rtx_fmt_e (code, mode, x);
11887 }
11888
11889 /* called via for_each_rtx after reload, to clean up truncates of
11890    registers that span multiple actual hard registers.  */
11891 int
11892 shmedia_cleanup_truncate (rtx *p, void *n_changes)
11893 {
11894   rtx x = *p, reg;
11895
11896   if (GET_CODE (x) != TRUNCATE)
11897     return 0;
11898   reg = XEXP (x, 0);
11899   if (GET_MODE_SIZE (GET_MODE (reg)) > 8 && REG_P (reg))
11900     {
11901       enum machine_mode reg_mode = GET_MODE (reg);
11902       XEXP (x, 0) = simplify_subreg (DImode, reg, reg_mode,
11903                                      subreg_lowpart_offset (DImode, reg_mode));
11904       *(int*) n_changes += 1;
11905       return -1;
11906     }
11907   return 0;
11908 }
11909
11910 /* Load and store depend on the highpart of the address.  However,
11911    set_attr_alternative does not give well-defined results before reload,
11912    so we must look at the rtl ourselves to see if any of the feeding
11913    registers is used in a memref.  */
11914
11915 /* Called by sh_contains_memref_p via for_each_rtx.  */
11916 static int
11917 sh_contains_memref_p_1 (rtx *loc, void *data ATTRIBUTE_UNUSED)
11918 {
11919   return (MEM_P (*loc));
11920 }
11921
11922 /* Return nonzero iff INSN contains a MEM.  */
11923 int
11924 sh_contains_memref_p (rtx insn)
11925 {
11926   return for_each_rtx (&PATTERN (insn), &sh_contains_memref_p_1, NULL);
11927 }
11928
11929 /* Return nonzero iff INSN loads a banked register.  */
11930 int
11931 sh_loads_bankedreg_p (rtx insn)
11932 {
11933   if (GET_CODE (PATTERN (insn)) == SET)
11934     {
11935       rtx op = SET_DEST (PATTERN(insn));
11936       if (REG_P (op) && BANKED_REGISTER_P (REGNO (op)))
11937         return 1;
11938     }
11939
11940   return 0;
11941 }
11942
11943 /* FNADDR is the MEM expression from a call expander.  Return an address
11944    to use in an SHmedia insn pattern.  */
11945 rtx
11946 shmedia_prepare_call_address (rtx fnaddr, int is_sibcall)
11947 {
11948   int is_sym;
11949
11950   fnaddr = XEXP (fnaddr, 0);
11951   is_sym = GET_CODE (fnaddr) == SYMBOL_REF;
11952   if (flag_pic && is_sym)
11953     {
11954       if (! SYMBOL_REF_LOCAL_P (fnaddr))
11955         {
11956           rtx reg = gen_reg_rtx (Pmode);
11957
11958           /* We must not use GOTPLT for sibcalls, because PIC_REG
11959              must be restored before the PLT code gets to run.  */
11960           if (is_sibcall)
11961             emit_insn (gen_symGOT2reg (reg, fnaddr));
11962           else
11963             emit_insn (gen_symGOTPLT2reg (reg, fnaddr));
11964           fnaddr = reg;
11965         }
11966       else
11967         {
11968           fnaddr = gen_sym2PIC (fnaddr);
11969           PUT_MODE (fnaddr, Pmode);
11970         }
11971     }
11972   /* If ptabs might trap, make this visible to the rest of the compiler.
11973      We generally assume that symbols pertain to valid locations, but
11974      it is possible to generate invalid symbols with asm or linker tricks.
11975      In a list of functions where each returns its successor, an invalid
11976      symbol might denote an empty list.  */
11977   if (!TARGET_PT_FIXED
11978       && (!is_sym || TARGET_INVALID_SYMBOLS)
11979       && (!REG_P (fnaddr) || ! TARGET_REGISTER_P (REGNO (fnaddr))))
11980     {
11981       rtx tr = gen_reg_rtx (PDImode);
11982
11983       emit_insn (gen_ptabs (tr, fnaddr));
11984       fnaddr = tr;
11985     }
11986   else if (! target_reg_operand (fnaddr, Pmode))
11987     fnaddr = copy_to_mode_reg (Pmode, fnaddr);
11988   return fnaddr;
11989 }
11990
11991 enum reg_class
11992 sh_secondary_reload (bool in_p, rtx x, enum reg_class rclass,
11993                      enum machine_mode mode, secondary_reload_info *sri)
11994 {
11995   if (in_p)
11996     {
11997       if (REGCLASS_HAS_FP_REG (rclass)
11998           && ! TARGET_SHMEDIA
11999           && immediate_operand ((x), mode)
12000           && ! ((fp_zero_operand (x) || fp_one_operand (x))
12001                 && mode == SFmode && fldi_ok ()))
12002         switch (mode)
12003           {
12004           case SFmode:
12005             sri->icode = CODE_FOR_reload_insf__frn;
12006             return NO_REGS;
12007           case DFmode:
12008             sri->icode = CODE_FOR_reload_indf__frn;
12009             return NO_REGS;
12010           case SImode:
12011             /* ??? If we knew that we are in the appropriate mode -
12012                single precision - we could use a reload pattern directly.  */
12013             return FPUL_REGS;
12014           default:
12015             abort ();
12016           }
12017       if (rclass == FPUL_REGS
12018           && ((REG_P (x)
12019                && (REGNO (x) == MACL_REG || REGNO (x) == MACH_REG
12020                    || REGNO (x) == T_REG))
12021               || GET_CODE (x) == PLUS))
12022         return GENERAL_REGS;
12023       if (rclass == FPUL_REGS && immediate_operand (x, mode))
12024         {
12025           if (satisfies_constraint_I08 (x) || fp_zero_operand (x))
12026             return GENERAL_REGS;
12027           else if (mode == SFmode)
12028             return FP_REGS;
12029           sri->icode = CODE_FOR_reload_insi__i_fpul;
12030           return NO_REGS;
12031         }
12032       if (rclass == FPSCR_REGS
12033           && ((REG_P (x) && REGNO (x) >= FIRST_PSEUDO_REGISTER)
12034               || (MEM_P (x) && GET_CODE (XEXP (x, 0)) == PLUS)))
12035         return GENERAL_REGS;
12036       if (REGCLASS_HAS_FP_REG (rclass)
12037           && TARGET_SHMEDIA
12038           && immediate_operand (x, mode)
12039           && x != CONST0_RTX (GET_MODE (x))
12040           && GET_MODE (x) != V4SFmode)
12041         return GENERAL_REGS;
12042       if ((mode == QImode || mode == HImode)
12043           && TARGET_SHMEDIA && inqhi_operand (x, mode))
12044         {
12045           sri->icode = ((mode == QImode)
12046                         ? CODE_FOR_reload_inqi : CODE_FOR_reload_inhi);
12047           return NO_REGS;
12048         }
12049       if (TARGET_SHMEDIA && rclass == GENERAL_REGS
12050           && (GET_CODE (x) == LABEL_REF || PIC_ADDR_P (x)))
12051         return TARGET_REGS;
12052     } /* end of input-only processing.  */
12053
12054   if (((REGCLASS_HAS_FP_REG (rclass)
12055         && (REG_P (x)
12056             && (GENERAL_OR_AP_REGISTER_P (REGNO (x))
12057                 || (FP_REGISTER_P (REGNO (x)) && mode == SImode
12058                     && TARGET_FMOVD))))
12059        || (REGCLASS_HAS_GENERAL_REG (rclass)
12060            && REG_P (x)
12061            && FP_REGISTER_P (REGNO (x))))
12062       && ! TARGET_SHMEDIA
12063       && (mode == SFmode || mode == SImode))
12064     return FPUL_REGS;
12065   if ((rclass == FPUL_REGS
12066        || (REGCLASS_HAS_FP_REG (rclass)
12067            && ! TARGET_SHMEDIA && mode == SImode))
12068       && (MEM_P (x)
12069           || (REG_P (x)
12070               && (REGNO (x) >= FIRST_PSEUDO_REGISTER
12071                   || REGNO (x) == T_REG
12072                   || system_reg_operand (x, VOIDmode)))))
12073     {
12074       if (rclass == FPUL_REGS)
12075         return GENERAL_REGS;
12076       return FPUL_REGS;
12077     }
12078   if ((rclass == TARGET_REGS
12079        || (TARGET_SHMEDIA && rclass == SIBCALL_REGS))
12080       && !satisfies_constraint_Csy (x)
12081       && (!REG_P (x) || ! GENERAL_REGISTER_P (REGNO (x))))
12082     return GENERAL_REGS;
12083   if ((rclass == MAC_REGS || rclass == PR_REGS)
12084       && REG_P (x) && ! GENERAL_REGISTER_P (REGNO (x))
12085       && rclass != REGNO_REG_CLASS (REGNO (x)))
12086     return GENERAL_REGS;
12087   if (rclass != GENERAL_REGS && REG_P (x)
12088       && TARGET_REGISTER_P (REGNO (x)))
12089     return GENERAL_REGS;
12090   return NO_REGS;
12091 }
12092
12093 enum sh_divide_strategy_e sh_div_strategy = SH_DIV_STRATEGY_DEFAULT;
12094
12095 #include "gt-sh.h"