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