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 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 2, 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 COPYING.  If not, write to
  21 the Free Software Foundation, 51 Franklin Street, Fifth Floor,
  22 Boston, MA 02110-1301, USA.  */
  23
  24 #include "config.h"
  25 #include "system.h"
  26 #include "coretypes.h"
  27 #include "tm.h"
  28 #include "insn-config.h"
  29 #include "rtl.h"
  30 #include "tree.h"
  31 #include "flags.h"
  32 #include "expr.h"
  33 #include "optabs.h"
  34 #include "function.h"
  35 #include "regs.h"
  36 #include "hard-reg-set.h"
  37 #include "output.h"
  38 #include "insn-attr.h"
  39 #include "toplev.h"
  40 #include "recog.h"
  41 #include "c-pragma.h"
  42 #include "integrate.h"
  43 #include "dwarf2.h"
  44 #include "tm_p.h"
  45 #include "target.h"
  46 #include "target-def.h"
  47 #include "real.h"
  48 #include "langhooks.h"
  49 #include "basic-block.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
  57
  58 int code_for_indirect_jump_scratch = CODE_FOR_indirect_jump_scratch;
  59
  60 #define MSW (TARGET_LITTLE_ENDIAN ? 1 : 0)
  61 #define LSW (TARGET_LITTLE_ENDIAN ? 0 : 1)
  62
  63 /* These are some macros to abstract register modes.  */
  64 #define CONST_OK_FOR_ADD(size) \
  65   (TARGET_SHMEDIA ? CONST_OK_FOR_I10 (size) : CONST_OK_FOR_I08 (size))
  66 #define GEN_MOV (*(TARGET_SHMEDIA64 ? gen_movdi : gen_movsi))
  67 #define GEN_ADD3 (*(TARGET_SHMEDIA64 ? gen_adddi3 : gen_addsi3))
  68 #define GEN_SUB3 (*(TARGET_SHMEDIA64 ? gen_subdi3 : gen_subsi3))
  69
  70 /* Set to 1 by expand_prologue() when the function is an interrupt handler.  */
  71 int current_function_interrupt;
  72
  73 /* ??? The pragma interrupt support will not work for SH3.  */
  74 /* This is set by #pragma interrupt and #pragma trapa, and causes gcc to
  75    output code for the next function appropriate for an interrupt handler.  */
  76 int pragma_interrupt;
  77
  78 /* This is set by the trap_exit attribute for functions.   It specifies
  79    a trap number to be used in a trapa instruction at function exit
  80    (instead of an rte instruction).  */
  81 int trap_exit;
  82
  83 /* This is used by the sp_switch attribute for functions.  It specifies
  84    a variable holding the address of the stack the interrupt function
  85    should switch to/from at entry/exit.  */
  86 rtx sp_switch;
  87
  88 /* This is set by #pragma trapa, and is similar to the above, except that
  89    the compiler doesn't emit code to preserve all registers.  */
  90 static int pragma_trapa;
  91
  92 /* This is set by #pragma nosave_low_regs.  This is useful on the SH3,
  93    which has a separate set of low regs for User and Supervisor modes.
  94    This should only be used for the lowest level of interrupts.  Higher levels
  95    of interrupts must save the registers in case they themselves are
  96    interrupted.  */
  97 int pragma_nosave_low_regs;
  98
  99 /* This is used for communication between TARGET_SETUP_INCOMING_VARARGS and
 100    sh_expand_prologue.  */
 101 int current_function_anonymous_args;
 102
 103 /* Global variables for machine-dependent things.  */
 104
 105 /* Which cpu are we scheduling for.  */
 106 enum processor_type sh_cpu;
 107
 108 /* Definitions used in ready queue reordering for first scheduling pass.  */
 109
 110 /* Reg weights arrays for modes SFmode and SImode, indexed by insn LUID.  */
 111 static short *regmode_weight[2];
 112
 113 /* Total SFmode and SImode weights of scheduled insns.  */
 114 static int curr_regmode_pressure[2];
 115
 116 /* If true, skip cycles for Q -> R movement.  */
 117 static int skip_cycles = 0;
 118
 119 /* Cached value of can_issue_more. This is cached in sh_variable_issue hook
 120    and returned from sh_reorder2.  */
 121 static short cached_can_issue_more;
 122
 123 /* Saved operands from the last compare to use when we generate an scc
 124    or bcc insn.  */
 125
 126 rtx sh_compare_op0;
 127 rtx sh_compare_op1;
 128
 129 /* Provides the class number of the smallest class containing
 130    reg number.  */
 131
 132 enum reg_class regno_reg_class[FIRST_PSEUDO_REGISTER] =
 133 {
 134   R0_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 135   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 136   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 137   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 138   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 139   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 140   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 141   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 142   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 143   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 144   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 145   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 146   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 147   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 148   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 149   GENERAL_REGS, GENERAL_REGS, GENERAL_REGS, GENERAL_REGS,
 150   FP0_REGS,FP_REGS, FP_REGS, FP_REGS,
 151   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 152   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 153   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 154   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 155   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 156   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 157   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 158   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 159   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 160   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 161   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 162   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 163   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 164   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 165   FP_REGS, FP_REGS, FP_REGS, FP_REGS,
 166   TARGET_REGS, TARGET_REGS, TARGET_REGS, TARGET_REGS,
 167   TARGET_REGS, TARGET_REGS, TARGET_REGS, TARGET_REGS,
 168   DF_REGS, DF_REGS, DF_REGS, DF_REGS,
 169   DF_REGS, DF_REGS, DF_REGS, DF_REGS,
 170   NO_REGS, GENERAL_REGS, PR_REGS, T_REGS,
 171   MAC_REGS, MAC_REGS, FPUL_REGS, FPSCR_REGS,
 172   GENERAL_REGS,
 173 };
 174
 175 char sh_register_names[FIRST_PSEUDO_REGISTER] \
 176   [MAX_REGISTER_NAME_LENGTH + 1] = SH_REGISTER_NAMES_INITIALIZER;
 177
 178 char sh_additional_register_names[ADDREGNAMES_SIZE] \
 179   [MAX_ADDITIONAL_REGISTER_NAME_LENGTH + 1]
 180   = SH_ADDITIONAL_REGISTER_NAMES_INITIALIZER;
 181
 182 /* Provide reg_class from a letter such as appears in the machine
 183    description.  *: target independently reserved letter.
 184    reg_class_from_letter['e' - 'a'] is set to NO_REGS for TARGET_FMOVD.  */
 185
 186 enum reg_class reg_class_from_letter[] =
 187 {
 188   /* a */ ALL_REGS,  /* b */ TARGET_REGS, /* c */ FPSCR_REGS, /* d */ DF_REGS,
 189   /* e */ FP_REGS,   /* f */ FP_REGS,  /* g **/ NO_REGS,     /* h */ NO_REGS,
 190   /* i **/ NO_REGS,  /* j */ NO_REGS,  /* k */ SIBCALL_REGS, /* l */ PR_REGS,
 191   /* m **/ NO_REGS,  /* n **/ NO_REGS, /* o **/ NO_REGS,     /* p **/ NO_REGS,
 192   /* q */ NO_REGS,   /* r **/ NO_REGS, /* s **/ NO_REGS,     /* t */ T_REGS,
 193   /* u */ NO_REGS,   /* v */ NO_REGS,  /* w */ FP0_REGS,     /* x */ MAC_REGS,
 194   /* y */ FPUL_REGS, /* z */ R0_REGS
 195 };
 196
 197 int assembler_dialect;
 198
 199 static bool shmedia_space_reserved_for_target_registers;
 200
 201 static bool sh_handle_option (size_t, const char *, int);
 202 static void split_branches (rtx);
 203 static int branch_dest (rtx);
 204 static void force_into (rtx, rtx);
 205 static void print_slot (rtx);
 206 static rtx add_constant (rtx, enum machine_mode, rtx);
 207 static void dump_table (rtx, rtx);
 208 static int hi_const (rtx);
 209 static int broken_move (rtx);
 210 static int mova_p (rtx);
 211 static rtx find_barrier (int, rtx, rtx);
 212 static int noncall_uses_reg (rtx, rtx, rtx *);
 213 static rtx gen_block_redirect (rtx, int, int);
 214 static void sh_reorg (void);
 215 static void output_stack_adjust (int, rtx, int, HARD_REG_SET *);
 216 static rtx frame_insn (rtx);
 217 static rtx push (int);
 218 static void pop (int);
 219 static void push_regs (HARD_REG_SET *, int);
 220 static int calc_live_regs (HARD_REG_SET *);
 221 static void mark_use (rtx, rtx *);
 222 static HOST_WIDE_INT rounded_frame_size (int);
 223 static rtx mark_constant_pool_use (rtx);
 224 const struct attribute_spec sh_attribute_table[];
 225 static tree sh_handle_interrupt_handler_attribute (tree *, tree, tree, int, bool *);
 226 static tree sh_handle_sp_switch_attribute (tree *, tree, tree, int, bool *);
 227 static tree sh_handle_trap_exit_attribute (tree *, tree, tree, int, bool *);
 228 static tree sh_handle_renesas_attribute (tree *, tree, tree, int, bool *);
 229 static void sh_output_function_epilogue (FILE *, HOST_WIDE_INT);
 230 static void sh_insert_attributes (tree, tree *);
 231 static const char *sh_check_pch_target_flags (int);
 232 static int sh_adjust_cost (rtx, rtx, rtx, int);
 233 static int sh_issue_rate (void);
 234 static int sh_dfa_new_cycle (FILE *, int, rtx, int, int, int *sort_p);
 235 static short find_set_regmode_weight (rtx, enum machine_mode);
 236 static short find_insn_regmode_weight (rtx, enum machine_mode);
 237 static void find_regmode_weight (int, enum machine_mode);
 238 static void  sh_md_init_global (FILE *, int, int);
 239 static void  sh_md_finish_global (FILE *, int);
 240 static int rank_for_reorder (const void *, const void *);
 241 static void swap_reorder (rtx *, int);
 242 static void ready_reorder (rtx *, int);
 243 static short high_pressure (enum machine_mode);
 244 static int sh_reorder (FILE *, int, rtx *, int *, int);
 245 static int sh_reorder2 (FILE *, int, rtx *, int *, int);
 246 static void sh_md_init (FILE *, int, int);
 247 static int sh_variable_issue (FILE *, int, rtx, int);
 248
 249 static bool sh_function_ok_for_sibcall (tree, tree);
 250
 251 static bool sh_cannot_modify_jumps_p (void);
 252 static int sh_target_reg_class (void);
 253 static bool sh_optimize_target_register_callee_saved (bool);
 254 static bool sh_ms_bitfield_layout_p (tree);
 255
 256 static void sh_init_builtins (void);
 257 static void sh_media_init_builtins (void);
 258 static rtx sh_expand_builtin (tree, rtx, rtx, enum machine_mode, int);
 259 static void sh_output_mi_thunk (FILE *, tree, HOST_WIDE_INT, HOST_WIDE_INT, tree);
 260 static void sh_file_start (void);
 261 static int flow_dependent_p (rtx, rtx);
 262 static void flow_dependent_p_1 (rtx, rtx, void *);
 263 static int shiftcosts (rtx);
 264 static int andcosts (rtx);
 265 static int addsubcosts (rtx);
 266 static int multcosts (rtx);
 267 static bool unspec_caller_rtx_p (rtx);
 268 static bool sh_cannot_copy_insn_p (rtx);
 269 static bool sh_rtx_costs (rtx, int, int, int *);
 270 static int sh_address_cost (rtx);
 271 #ifdef TARGET_ADJUST_UNROLL_MAX
 272 static int sh_adjust_unroll_max (struct loop *, int, int, int, int);
 273 #endif
 274 static int sh_pr_n_sets (void);
 275 static rtx sh_allocate_initial_value (rtx);
 276 static int shmedia_target_regs_stack_space (HARD_REG_SET *);
 277 static int shmedia_reserve_space_for_target_registers_p (int, HARD_REG_SET *);
 278 static int shmedia_target_regs_stack_adjust (HARD_REG_SET *);
 279 static int scavenge_reg (HARD_REG_SET *s);
 280 struct save_schedule_s;
 281 static struct save_entry_s *sh5_schedule_saves (HARD_REG_SET *,
 282                                                 struct save_schedule_s *, int);
 283
 284 static rtx sh_struct_value_rtx (tree, int);
 285 static bool sh_return_in_memory (tree, tree);
 286 static rtx sh_builtin_saveregs (void);
 287 static void sh_setup_incoming_varargs (CUMULATIVE_ARGS *, enum machine_mode, tree, int *, int);
 288 static bool sh_strict_argument_naming (CUMULATIVE_ARGS *);
 289 static bool sh_pretend_outgoing_varargs_named (CUMULATIVE_ARGS *);
 290 static tree sh_build_builtin_va_list (void);
 291 static tree sh_gimplify_va_arg_expr (tree, tree, tree *, tree *);
 292 static bool sh_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
 293                                   tree, bool);
 294 static bool sh_callee_copies (CUMULATIVE_ARGS *, enum machine_mode,
 295                               tree, bool);
 296 static int sh_arg_partial_bytes (CUMULATIVE_ARGS *, enum machine_mode,
 297                                  tree, bool);
 298 static int sh_dwarf_calling_convention (tree);
 299 static int hard_regs_intersect_p (HARD_REG_SET *, HARD_REG_SET *);
 300
 301 \f
 302 /* Initialize the GCC target structure.  */
 303 #undef TARGET_ATTRIBUTE_TABLE
 304 #define TARGET_ATTRIBUTE_TABLE sh_attribute_table
 305
 306 /* The next two are used for debug info when compiling with -gdwarf.  */
 307 #undef TARGET_ASM_UNALIGNED_HI_OP
 308 #define TARGET_ASM_UNALIGNED_HI_OP "\t.uaword\t"
 309 #undef TARGET_ASM_UNALIGNED_SI_OP
 310 #define TARGET_ASM_UNALIGNED_SI_OP "\t.ualong\t"
 311
 312 /* These are NULLed out on non-SH5 in OVERRIDE_OPTIONS.  */
 313 #undef TARGET_ASM_UNALIGNED_DI_OP
 314 #define TARGET_ASM_UNALIGNED_DI_OP "\t.uaquad\t"
 315 #undef TARGET_ASM_ALIGNED_DI_OP
 316 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
 317
 318 #undef TARGET_ASM_FUNCTION_EPILOGUE
 319 #define TARGET_ASM_FUNCTION_EPILOGUE sh_output_function_epilogue
 320
 321 #undef TARGET_ASM_OUTPUT_MI_THUNK
 322 #define TARGET_ASM_OUTPUT_MI_THUNK sh_output_mi_thunk
 323
 324 #undef TARGET_ASM_CAN_OUTPUT_MI_THUNK
 325 #define TARGET_ASM_CAN_OUTPUT_MI_THUNK hook_bool_tree_hwi_hwi_tree_true
 326
 327 #undef TARGET_ASM_FILE_START
 328 #define TARGET_ASM_FILE_START sh_file_start
 329 #undef TARGET_ASM_FILE_START_FILE_DIRECTIVE
 330 #define TARGET_ASM_FILE_START_FILE_DIRECTIVE true
 331
 332 #undef TARGET_DEFAULT_TARGET_FLAGS
 333 #define TARGET_DEFAULT_TARGET_FLAGS TARGET_DEFAULT
 334 #undef TARGET_HANDLE_OPTION
 335 #define TARGET_HANDLE_OPTION sh_handle_option
 336
 337 #undef TARGET_INSERT_ATTRIBUTES
 338 #define TARGET_INSERT_ATTRIBUTES sh_insert_attributes
 339
 340 #undef TARGET_SCHED_ADJUST_COST
 341 #define TARGET_SCHED_ADJUST_COST sh_adjust_cost
 342
 343 #undef TARGET_SCHED_ISSUE_RATE
 344 #define TARGET_SCHED_ISSUE_RATE sh_issue_rate
 345
 346 /* The next 5 hooks have been implemented for reenabling sched1.  With the
 347    help of these macros we are limiting the movement of insns in sched1 to
 348    reduce the register pressure.  The overall idea is to keep count of SImode
 349    and SFmode regs required by already scheduled insns. When these counts
 350    cross some threshold values; give priority to insns that free registers.
 351    The insn that frees registers is most likely to be the insn with lowest
 352    LUID (original insn order); but such an insn might be there in the stalled
 353    queue (Q) instead of the ready queue (R).  To solve this, we skip cycles
 354    upto a max of 8 cycles so that such insns may move from Q -> R.
 355
 356    The description of the hooks are as below:
 357
 358    TARGET_SCHED_INIT_GLOBAL: Added a new target hook in the generic
 359    scheduler; it is called inside the sched_init function just after
 360    find_insn_reg_weights function call. It is used to calculate the SImode
 361    and SFmode weights of insns of basic blocks; much similar to what
 362    find_insn_reg_weights does.
 363    TARGET_SCHED_FINISH_GLOBAL: Corresponding cleanup hook.
 364
 365    TARGET_SCHED_DFA_NEW_CYCLE: Skip cycles if high register pressure is
 366    indicated by TARGET_SCHED_REORDER2; doing this may move insns from
 367    (Q)->(R).
 368
 369    TARGET_SCHED_REORDER: If the register pressure for SImode or SFmode is
 370    high; reorder the ready queue so that the insn with lowest LUID will be
 371    issued next.
 372
 373    TARGET_SCHED_REORDER2: If the register pressure is high, indicate to
 374    TARGET_SCHED_DFA_NEW_CYCLE to skip cycles.
 375
 376    TARGET_SCHED_VARIABLE_ISSUE: Cache the value of can_issue_more so that it
 377    can be returned from TARGET_SCHED_REORDER2.
 378
 379    TARGET_SCHED_INIT: Reset the register pressure counting variables.  */
 380
 381 #undef TARGET_SCHED_DFA_NEW_CYCLE
 382 #define TARGET_SCHED_DFA_NEW_CYCLE sh_dfa_new_cycle
 383
 384 #undef TARGET_SCHED_INIT_GLOBAL
 385 #define TARGET_SCHED_INIT_GLOBAL sh_md_init_global
 386
 387 #undef TARGET_SCHED_FINISH_GLOBAL
 388 #define TARGET_SCHED_FINISH_GLOBAL sh_md_finish_global
 389
 390 #undef TARGET_SCHED_VARIABLE_ISSUE
 391 #define TARGET_SCHED_VARIABLE_ISSUE sh_variable_issue
 392
 393 #undef TARGET_SCHED_REORDER
 394 #define TARGET_SCHED_REORDER sh_reorder
 395
 396 #undef TARGET_SCHED_REORDER2
 397 #define TARGET_SCHED_REORDER2 sh_reorder2
 398
 399 #undef TARGET_SCHED_INIT
 400 #define TARGET_SCHED_INIT sh_md_init
 401
 402 #undef TARGET_CANNOT_MODIFY_JUMPS_P
 403 #define TARGET_CANNOT_MODIFY_JUMPS_P sh_cannot_modify_jumps_p
 404 #undef TARGET_BRANCH_TARGET_REGISTER_CLASS
 405 #define TARGET_BRANCH_TARGET_REGISTER_CLASS sh_target_reg_class
 406 #undef TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED
 407 #define TARGET_BRANCH_TARGET_REGISTER_CALLEE_SAVED \
 408  sh_optimize_target_register_callee_saved
 409
 410 #undef TARGET_MS_BITFIELD_LAYOUT_P
 411 #define TARGET_MS_BITFIELD_LAYOUT_P sh_ms_bitfield_layout_p
 412
 413 #undef TARGET_INIT_BUILTINS
 414 #define TARGET_INIT_BUILTINS sh_init_builtins
 415 #undef TARGET_EXPAND_BUILTIN
 416 #define TARGET_EXPAND_BUILTIN sh_expand_builtin
 417
 418 #undef TARGET_FUNCTION_OK_FOR_SIBCALL
 419 #define TARGET_FUNCTION_OK_FOR_SIBCALL sh_function_ok_for_sibcall
 420
 421 #undef TARGET_CANNOT_COPY_INSN_P
 422 #define TARGET_CANNOT_COPY_INSN_P sh_cannot_copy_insn_p
 423 #undef TARGET_RTX_COSTS
 424 #define TARGET_RTX_COSTS sh_rtx_costs
 425 #undef TARGET_ADDRESS_COST
 426 #define TARGET_ADDRESS_COST sh_address_cost
 427 #undef TARGET_ALLOCATE_INITIAL_VALUE
 428 #define TARGET_ALLOCATE_INITIAL_VALUE sh_allocate_initial_value
 429
 430 #undef TARGET_MACHINE_DEPENDENT_REORG
 431 #define TARGET_MACHINE_DEPENDENT_REORG sh_reorg
 432
 433 #ifdef HAVE_AS_TLS
 434 #undef TARGET_HAVE_TLS
 435 #define TARGET_HAVE_TLS true
 436 #endif
 437
 438 #undef TARGET_PROMOTE_PROTOTYPES
 439 #define TARGET_PROMOTE_PROTOTYPES sh_promote_prototypes
 440 #undef TARGET_PROMOTE_FUNCTION_ARGS
 441 #define TARGET_PROMOTE_FUNCTION_ARGS sh_promote_prototypes
 442 #undef TARGET_PROMOTE_FUNCTION_RETURN
 443 #define TARGET_PROMOTE_FUNCTION_RETURN sh_promote_prototypes
 444
 445 #undef TARGET_STRUCT_VALUE_RTX
 446 #define TARGET_STRUCT_VALUE_RTX sh_struct_value_rtx
 447 #undef TARGET_RETURN_IN_MEMORY
 448 #define TARGET_RETURN_IN_MEMORY sh_return_in_memory
 449
 450 #undef TARGET_EXPAND_BUILTIN_SAVEREGS
 451 #define TARGET_EXPAND_BUILTIN_SAVEREGS sh_builtin_saveregs
 452 #undef TARGET_SETUP_INCOMING_VARARGS
 453 #define TARGET_SETUP_INCOMING_VARARGS sh_setup_incoming_varargs
 454 #undef TARGET_STRICT_ARGUMENT_NAMING
 455 #define TARGET_STRICT_ARGUMENT_NAMING sh_strict_argument_naming
 456 #undef TARGET_PRETEND_OUTGOING_VARARGS_NAMED
 457 #define TARGET_PRETEND_OUTGOING_VARARGS_NAMED sh_pretend_outgoing_varargs_named
 458 #undef TARGET_MUST_PASS_IN_STACK
 459 #define TARGET_MUST_PASS_IN_STACK must_pass_in_stack_var_size
 460 #undef TARGET_PASS_BY_REFERENCE
 461 #define TARGET_PASS_BY_REFERENCE sh_pass_by_reference
 462 #undef TARGET_CALLEE_COPIES
 463 #define TARGET_CALLEE_COPIES sh_callee_copies
 464 #undef TARGET_ARG_PARTIAL_BYTES
 465 #define TARGET_ARG_PARTIAL_BYTES sh_arg_partial_bytes
 466
 467 #undef TARGET_BUILD_BUILTIN_VA_LIST
 468 #define TARGET_BUILD_BUILTIN_VA_LIST sh_build_builtin_va_list
 469 #undef TARGET_GIMPLIFY_VA_ARG_EXPR
 470 #define TARGET_GIMPLIFY_VA_ARG_EXPR sh_gimplify_va_arg_expr
 471
 472 #undef TARGET_VECTOR_MODE_SUPPORTED_P
 473 #define TARGET_VECTOR_MODE_SUPPORTED_P sh_vector_mode_supported_p
 474
 475 #undef TARGET_CHECK_PCH_TARGET_FLAGS
 476 #define TARGET_CHECK_PCH_TARGET_FLAGS sh_check_pch_target_flags
 477
 478 #undef TARGET_DWARF_CALLING_CONVENTION
 479 #define TARGET_DWARF_CALLING_CONVENTION sh_dwarf_calling_convention
 480
 481 /* Return regmode weight for insn.  */
 482 #define INSN_REGMODE_WEIGHT(INSN, MODE)  regmode_weight[((MODE) == SImode) ? 0 : 1][INSN_UID (INSN)]
 483
 484 /* Return current register pressure for regmode.  */
 485 #define CURR_REGMODE_PRESSURE(MODE)     curr_regmode_pressure[((MODE) == SImode) ? 0 : 1]
 486
 487 #ifdef SYMBIAN
 488
 489 #undef  TARGET_ENCODE_SECTION_INFO
 490 #define TARGET_ENCODE_SECTION_INFO      sh_symbian_encode_section_info
 491 #undef  TARGET_STRIP_NAME_ENCODING
 492 #define TARGET_STRIP_NAME_ENCODING      sh_symbian_strip_name_encoding
 493 #undef  TARGET_CXX_IMPORT_EXPORT_CLASS
 494 #define TARGET_CXX_IMPORT_EXPORT_CLASS  symbian_import_export_class
 495
 496 #endif /* SYMBIAN */
 497
 498 #ifdef TARGET_ADJUST_UNROLL_MAX
 499 #undef TARGET_ADJUST_UNROLL_MAX
 500 #define TARGET_ADJUST_UNROLL_MAX sh_adjust_unroll_max
 501 #endif
 502
 503 struct gcc_target targetm = TARGET_INITIALIZER;
 504 \f
 505 /* Implement TARGET_HANDLE_OPTION.  */
 506
 507 static bool
 508 sh_handle_option (size_t code, const char *arg ATTRIBUTE_UNUSED,
 509                   int value ATTRIBUTE_UNUSED)
 510 {
 511   switch (code)
 512     {
 513     case OPT_m1:
 514       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH1;
 515       return true;
 516
 517     case OPT_m2:
 518       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2;
 519       return true;
 520
 521     case OPT_m2a:
 522       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2A;
 523       return true;
 524
 525     case OPT_m2a_nofpu:
 526       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2A_NOFPU;
 527       return true;
 528
 529     case OPT_m2a_single:
 530       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2A_SINGLE;
 531       return true;
 532
 533     case OPT_m2a_single_only:
 534       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2A_SINGLE_ONLY;
 535       return true;
 536
 537     case OPT_m2e:
 538       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH2E;
 539       return true;
 540
 541     case OPT_m3:
 542       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH3;
 543       return true;
 544
 545     case OPT_m3e:
 546       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH3E;
 547       return true;
 548
 549     case OPT_m4:
 550       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4;
 551       return true;
 552
 553     case OPT_m4_nofpu:
 554       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4_NOFPU;
 555       return true;
 556
 557     case OPT_m4_single:
 558       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4_SINGLE;
 559       return true;
 560
 561     case OPT_m4_single_only:
 562       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4_SINGLE_ONLY;
 563       return true;
 564
 565     case OPT_m4a:
 566       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4A;
 567       return true;
 568
 569     case OPT_m4a_nofpu:
 570     case OPT_m4al:
 571       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4A_NOFPU;
 572       return true;
 573
 574     case OPT_m4a_single:
 575       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4A_SINGLE;
 576       return true;
 577
 578     case OPT_m4a_single_only:
 579       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH4A_SINGLE_ONLY;
 580       return true;
 581
 582     case OPT_m5_32media:
 583       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_32MEDIA;
 584       return true;
 585
 586     case OPT_m5_32media_nofpu:
 587       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_32MEDIA_NOFPU;
 588       return true;
 589
 590     case OPT_m5_64media:
 591       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_64MEDIA;
 592       return true;
 593
 594     case OPT_m5_64media_nofpu:
 595       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_64MEDIA_NOFPU;
 596       return true;
 597
 598     case OPT_m5_compact:
 599       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_COMPACT;
 600       return true;
 601
 602     case OPT_m5_compact_nofpu:
 603       target_flags = (target_flags & ~MASK_ARCH) | SELECT_SH5_COMPACT_NOFPU;
 604       return true;
 605
 606     default:
 607       return true;
 608     }
 609 }
 610 \f
 611 /* Print the operand address in x to the stream.  */
 612
 613 void
 614 print_operand_address (FILE *stream, rtx x)
 615 {
 616   switch (GET_CODE (x))
 617     {
 618     case REG:
 619     case SUBREG:
 620       fprintf (stream, "@%s", reg_names[true_regnum (x)]);
 621       break;
 622
 623     case PLUS:
 624       {
 625         rtx base = XEXP (x, 0);
 626         rtx index = XEXP (x, 1);
 627
 628         switch (GET_CODE (index))
 629           {
 630           case CONST_INT:
 631             fprintf (stream, "@(%d,%s)", (int) INTVAL (index),
 632                      reg_names[true_regnum (base)]);
 633             break;
 634
 635           case REG:
 636           case SUBREG:
 637             {
 638               int base_num = true_regnum (base);
 639               int index_num = true_regnum (index);
 640
 641               fprintf (stream, "@(r0,%s)",
 642                        reg_names[MAX (base_num, index_num)]);
 643               break;
 644             }
 645
 646           default:
 647             gcc_unreachable ();
 648           }
 649       }
 650       break;
 651
 652     case PRE_DEC:
 653       fprintf (stream, "@-%s", reg_names[true_regnum (XEXP (x, 0))]);
 654       break;
 655
 656     case POST_INC:
 657       fprintf (stream, "@%s+", reg_names[true_regnum (XEXP (x, 0))]);
 658       break;
 659
 660     default:
 661       x = mark_constant_pool_use (x);
 662       output_addr_const (stream, x);
 663       break;
 664     }
 665 }
 666
 667 /* Print operand x (an rtx) in assembler syntax to file stream
 668    according to modifier code.
 669
 670    '.'  print a .s if insn needs delay slot
 671    ','  print LOCAL_LABEL_PREFIX
 672    '@'  print trap, rte or rts depending upon pragma interruptness
 673    '#'  output a nop if there is nothing to put in the delay slot
 674    '''  print likelihood suffix (/u for unlikely).
 675    '>'  print branch target if -fverbose-asm
 676    'O'  print a constant without the #
 677    'R'  print the LSW of a dp value - changes if in little endian
 678    'S'  print the MSW of a dp value - changes if in little endian
 679    'T'  print the next word of a dp value - same as 'R' in big endian mode.
 680    'M'  print an `x' if `m' will print `base,index'.
 681    'N'  print 'r63' if the operand is (const_int 0).
 682    'd'  print a V2SF reg as dN instead of fpN.
 683    'm'  print a pair `base,offset' or `base,index', for LD and ST.
 684    'U'  Likewise for {LD,ST}{HI,LO}.
 685    'u'  prints the lowest 16 bits of CONST_INT, as an unsigned value.
 686    'o'  output an operator.  */
 687
 688 void
 689 print_operand (FILE *stream, rtx x, int code)
 690 {
 691   int regno;
 692   enum machine_mode mode;
 693
 694   switch (code)
 695     {
 696     case '.':
 697       if (final_sequence
 698           && ! INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
 699           && get_attr_length (XVECEXP (final_sequence, 0, 1)))
 700         fprintf (stream, ASSEMBLER_DIALECT ? "/s" : ".s");
 701       break;
 702     case ',':
 703       fprintf (stream, "%s", LOCAL_LABEL_PREFIX);
 704       break;
 705     case '@':
 706       if (trap_exit)
 707         fprintf (stream, "trapa #%d", trap_exit);
 708       else if (sh_cfun_interrupt_handler_p ())
 709         fprintf (stream, "rte");
 710       else
 711         fprintf (stream, "rts");
 712       break;
 713     case '#':
 714       /* Output a nop if there's nothing in the delay slot.  */
 715       if (dbr_sequence_length () == 0)
 716         fprintf (stream, "\n\tnop");
 717       break;
 718     case '\'':
 719       {
 720         rtx note = find_reg_note (current_output_insn, REG_BR_PROB, 0);
 721
 722         if (note && INTVAL (XEXP (note, 0)) * 2 < REG_BR_PROB_BASE)
 723           fputs ("/u", stream);
 724         break;
 725       }
 726     case '>':
 727       if (flag_verbose_asm && JUMP_LABEL (current_output_insn))
 728         {
 729           fputs ("\t! target: ", stream);
 730           output_addr_const (stream, JUMP_LABEL (current_output_insn));
 731         }
 732       break;
 733     case 'O':
 734       x = mark_constant_pool_use (x);
 735       output_addr_const (stream, x);
 736       break;
 737     case 'R':
 738       fputs (reg_names[REGNO (x) + LSW], (stream));
 739       break;
 740     case 'S':
 741       fputs (reg_names[REGNO (x) + MSW], (stream));
 742       break;
 743     case 'T':
 744       /* Next word of a double.  */
 745       switch (GET_CODE (x))
 746         {
 747         case REG:
 748           fputs (reg_names[REGNO (x) + 1], (stream));
 749           break;
 750         case MEM:
 751           if (GET_CODE (XEXP (x, 0)) != PRE_DEC
 752               && GET_CODE (XEXP (x, 0)) != POST_INC)
 753             x = adjust_address (x, SImode, 4);
 754           print_operand_address (stream, XEXP (x, 0));
 755           break;
 756         default:
 757           break;
 758         }
 759       break;
 760     case 'o':
 761       switch (GET_CODE (x))
 762         {
 763         case PLUS:  fputs ("add", stream); break;
 764         case MINUS: fputs ("sub", stream); break;
 765         case MULT:  fputs ("mul", stream); break;
 766         case DIV:   fputs ("div", stream); break;
 767         case EQ:    fputs ("eq",  stream); break;
 768         case NE:    fputs ("ne",  stream); break;
 769         case GT:  case LT:  fputs ("gt",  stream); break;
 770         case GE:  case LE:  fputs ("ge",  stream); break;
 771         case GTU: case LTU: fputs ("gtu", stream); break;
 772         case GEU: case LEU: fputs ("geu", stream); break;
 773         default:
 774           break;
 775         }
 776       break;
 777     case 'M':
 778       if (GET_CODE (x) == MEM
 779           && GET_CODE (XEXP (x, 0)) == PLUS
 780           && (GET_CODE (XEXP (XEXP (x, 0), 1)) == REG
 781               || GET_CODE (XEXP (XEXP (x, 0), 1)) == SUBREG))
 782         fputc ('x', stream);
 783       break;
 784
 785     case 'm':
 786       gcc_assert (GET_CODE (x) == MEM);
 787       x = XEXP (x, 0);
 788       /* Fall through.  */
 789     case 'U':
 790       switch (GET_CODE (x))
 791         {
 792         case REG:
 793         case SUBREG:
 794           print_operand (stream, x, 0);
 795           fputs (", 0", stream);
 796           break;
 797
 798         case PLUS:
 799           print_operand (stream, XEXP (x, 0), 0);
 800           fputs (", ", stream);
 801           print_operand (stream, XEXP (x, 1), 0);
 802           break;
 803
 804         default:
 805           gcc_unreachable ();
 806         }
 807       break;
 808
 809     case 'd':
 810       gcc_assert (GET_CODE (x) == REG && GET_MODE (x) == V2SFmode);
 811
 812       fprintf ((stream), "d%s", reg_names[REGNO (x)] + 1);
 813       break;
 814
 815     case 'N':
 816       if (x == CONST0_RTX (GET_MODE (x)))
 817         {
 818           fprintf ((stream), "r63");
 819           break;
 820         }
 821       goto default_output;
 822     case 'u':
 823       if (GET_CODE (x) == CONST_INT)
 824         {
 825           fprintf ((stream), "%u", (unsigned) INTVAL (x) & (0x10000 - 1));
 826           break;
 827         }
 828       /* Fall through.  */
 829
 830     default_output:
 831     default:
 832       regno = 0;
 833       mode = GET_MODE (x);
 834
 835       switch (GET_CODE (x))
 836         {
 837         case TRUNCATE:
 838           {
 839             rtx inner = XEXP (x, 0);
 840             int offset = 0;
 841             enum machine_mode inner_mode;
 842
 843             /* We might see SUBREGs with vector mode registers inside.  */
 844             if (GET_CODE (inner) == SUBREG
 845                 && (GET_MODE_SIZE (GET_MODE (inner))
 846                     == GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner))))
 847                 && subreg_lowpart_p (inner))
 848               inner = SUBREG_REG (inner);
 849             if (GET_CODE (inner) == CONST_INT)
 850               {
 851                 x = GEN_INT (trunc_int_for_mode (INTVAL (inner), GET_MODE (x)));
 852                 goto default_output;
 853               }
 854             inner_mode = GET_MODE (inner);
 855             if (GET_CODE (inner) == SUBREG
 856                 && (GET_MODE_SIZE (GET_MODE (inner))
 857                     < GET_MODE_SIZE (GET_MODE (SUBREG_REG (inner))))
 858                 && GET_CODE (SUBREG_REG (inner)) == REG)
 859               {
 860                 offset = subreg_regno_offset (REGNO (SUBREG_REG (inner)),
 861                                               GET_MODE (SUBREG_REG (inner)),
 862                                               SUBREG_BYTE (inner),
 863                                               GET_MODE (inner));
 864                 inner = SUBREG_REG (inner);
 865               }
 866             if (GET_CODE (inner) != REG || GET_MODE_SIZE (inner_mode) > 8)
 867               abort ();
 868             /* Floating point register pairs are always big endian;
 869                general purpose registers are 64 bit wide.  */
 870             regno = REGNO (inner);
 871             regno = (HARD_REGNO_NREGS (regno, inner_mode)
 872                      - HARD_REGNO_NREGS (regno, mode))
 873                      + offset;
 874             x = inner;
 875             goto reg;
 876           }
 877         case SIGN_EXTEND:
 878           x = XEXP (x, 0);
 879           goto reg;
 880           /* FIXME: We need this on SHmedia32 because reload generates
 881              some sign-extended HI or QI loads into DImode registers
 882              but, because Pmode is SImode, the address ends up with a
 883              subreg:SI of the DImode register.  Maybe reload should be
 884              fixed so as to apply alter_subreg to such loads?  */
 885         case IF_THEN_ELSE:
 886           gcc_assert (trapping_target_operand (x, VOIDmode));
 887           x = XEXP (XEXP (x, 2), 0);
 888           goto default_output;
 889         case SUBREG:
 890           gcc_assert (SUBREG_BYTE (x) == 0
 891                       && GET_CODE (SUBREG_REG (x)) == REG);
 892
 893           x = SUBREG_REG (x);
 894           /* Fall through.  */
 895
 896         reg:
 897         case REG:
 898           regno += REGNO (x);
 899           if (FP_REGISTER_P (regno)
 900               && mode == V16SFmode)
 901             fprintf ((stream), "mtrx%s", reg_names[regno] + 2);
 902           else if (FP_REGISTER_P (REGNO (x))
 903                    && mode == V4SFmode)
 904             fprintf ((stream), "fv%s", reg_names[regno] + 2);
 905           else if (GET_CODE (x) == REG
 906                    && mode == V2SFmode)
 907             fprintf ((stream), "fp%s", reg_names[regno] + 2);
 908           else if (FP_REGISTER_P (REGNO (x))
 909                    && GET_MODE_SIZE (mode) > 4)
 910             fprintf ((stream), "d%s", reg_names[regno] + 1);
 911           else
 912             fputs (reg_names[regno], (stream));
 913           break;
 914
 915         case MEM:
 916           output_address (XEXP (x, 0));
 917           break;
 918
 919         case CONST:
 920           if (TARGET_SHMEDIA
 921               && GET_CODE (XEXP (x, 0)) == SIGN_EXTEND
 922               && (GET_MODE (XEXP (x, 0)) == DImode
 923                   || GET_MODE (XEXP (x, 0)) == SImode)
 924               && GET_CODE (XEXP (XEXP (x, 0), 0)) == TRUNCATE
 925               && GET_MODE (XEXP (XEXP (x, 0), 0)) == HImode)
 926             {
 927               rtx val = XEXP (XEXP (XEXP (x, 0), 0), 0);
 928
 929               fputc ('(', stream);
 930               if (GET_CODE (val) == ASHIFTRT)
 931                 {
 932                   fputc ('(', stream);
 933                   if (GET_CODE (XEXP (val, 0)) == CONST)
 934                     fputc ('(', stream);
 935                   output_addr_const (stream, XEXP (val, 0));
 936                   if (GET_CODE (XEXP (val, 0)) == CONST)
 937                     fputc (')', stream);
 938                   fputs (" >> ", stream);
 939                   output_addr_const (stream, XEXP (val, 1));
 940                   fputc (')', stream);
 941                 }
 942               else
 943                 {
 944                   if (GET_CODE (val) == CONST)
 945                     fputc ('(', stream);
 946                   output_addr_const (stream, val);
 947                   if (GET_CODE (val) == CONST)
 948                     fputc (')', stream);
 949                 }
 950               fputs (" & 65535)", stream);
 951               break;
 952             }
 953
 954           /* Fall through.  */
 955         default:
 956           if (TARGET_SH1)
 957             fputc ('#', stream);
 958           output_addr_const (stream, x);
 959           break;
 960         }
 961       break;
 962     }
 963 }
 964 \f
 965 /* Like force_operand, but guarantees that VALUE ends up in TARGET.  */
 966 static void
 967 force_into (rtx value, rtx target)
 968 {
 969   value = force_operand (value, target);
 970   if (! rtx_equal_p (value, target))
 971     emit_insn (gen_move_insn (target, value));
 972 }
 973
 974 /* Emit code to perform a block move.  Choose the best method.
 975
 976    OPERANDS[0] is the destination.
 977    OPERANDS[1] is the source.
 978    OPERANDS[2] is the size.
 979    OPERANDS[3] is the alignment safe to use.  */
 980
 981 int
 982 expand_block_move (rtx *operands)
 983 {
 984   int align = INTVAL (operands[3]);
 985   int constp = (GET_CODE (operands[2]) == CONST_INT);
 986   int bytes = (constp ? INTVAL (operands[2]) : 0);
 987
 988   if (! constp)
 989     return 0;
 990
 991   /* If we could use mov.l to move words and dest is word-aligned, we
 992      can use movua.l for loads and still generate a relatively short
 993      and efficient sequence.  */
 994   if (TARGET_SH4A_ARCH && align < 4
 995       && MEM_ALIGN (operands[0]) >= 32
 996       && can_move_by_pieces (bytes, 32))
 997     {
 998       rtx dest = copy_rtx (operands[0]);
 999       rtx src = copy_rtx (operands[1]);
1000       /* We could use different pseudos for each copied word, but
1001          since movua can only load into r0, it's kind of
1002          pointless.  */
1003       rtx temp = gen_reg_rtx (SImode);
1004       rtx src_addr = copy_addr_to_reg (XEXP (src, 0));
1005       int copied = 0;
1006
1007       while (copied + 4 <= bytes)
1008         {
1009           rtx to = adjust_address (dest, SImode, copied);
1010           rtx from = adjust_automodify_address (src, SImode, src_addr, copied);
1011
1012           emit_insn (gen_movua (temp, from));
1013           emit_move_insn (src_addr, plus_constant (src_addr, 4));
1014           emit_move_insn (to, temp);
1015           copied += 4;
1016         }
1017
1018       if (copied < bytes)
1019         move_by_pieces (adjust_address (dest, BLKmode, copied),
1020                         adjust_automodify_address (src, BLKmode,
1021                                                    src_addr, copied),
1022                         bytes - copied, align, 0);
1023
1024       return 1;
1025     }
1026
1027   /* If it isn't a constant number of bytes, or if it doesn't have 4 byte
1028      alignment, or if it isn't a multiple of 4 bytes, then fail.  */
1029   if (align < 4 || (bytes % 4 != 0))
1030     return 0;
1031
1032   if (TARGET_HARD_SH4)
1033     {
1034       if (bytes < 12)
1035         return 0;
1036       else if (bytes == 12)
1037         {
1038           rtx func_addr_rtx = gen_reg_rtx (Pmode);
1039           rtx r4 = gen_rtx_REG (SImode, 4);
1040           rtx r5 = gen_rtx_REG (SImode, 5);
1041
1042           function_symbol (func_addr_rtx, "__movmemSI12_i4", SFUNC_STATIC);
1043           force_into (XEXP (operands[0], 0), r4);
1044           force_into (XEXP (operands[1], 0), r5);
1045           emit_insn (gen_block_move_real_i4 (func_addr_rtx));
1046           return 1;
1047         }
1048       else if (! TARGET_SMALLCODE)
1049         {
1050           const char *entry_name;
1051           rtx func_addr_rtx = gen_reg_rtx (Pmode);
1052           int dwords;
1053           rtx r4 = gen_rtx_REG (SImode, 4);
1054           rtx r5 = gen_rtx_REG (SImode, 5);
1055           rtx r6 = gen_rtx_REG (SImode, 6);
1056
1057           entry_name = (bytes & 4 ? "__movmem_i4_odd" : "__movmem_i4_even");
1058           function_symbol (func_addr_rtx, entry_name, SFUNC_STATIC);
1059           force_into (XEXP (operands[0], 0), r4);
1060           force_into (XEXP (operands[1], 0), r5);
1061
1062           dwords = bytes >> 3;
1063           emit_insn (gen_move_insn (r6, GEN_INT (dwords - 1)));
1064           emit_insn (gen_block_lump_real_i4 (func_addr_rtx));
1065           return 1;
1066         }
1067       else
1068         return 0;
1069     }
1070   if (bytes < 64)
1071     {
1072       char entry[30];
1073       rtx func_addr_rtx = gen_reg_rtx (Pmode);
1074       rtx r4 = gen_rtx_REG (SImode, 4);
1075       rtx r5 = gen_rtx_REG (SImode, 5);
1076
1077       sprintf (entry, "__movmemSI%d", bytes);
1078       function_symbol (func_addr_rtx, entry, SFUNC_STATIC);
1079       force_into (XEXP (operands[0], 0), r4);
1080       force_into (XEXP (operands[1], 0), r5);
1081       emit_insn (gen_block_move_real (func_addr_rtx));
1082       return 1;
1083     }
1084
1085   /* This is the same number of bytes as a memcpy call, but to a different
1086      less common function name, so this will occasionally use more space.  */
1087   if (! TARGET_SMALLCODE)
1088     {
1089       rtx func_addr_rtx = gen_reg_rtx (Pmode);
1090       int final_switch, while_loop;
1091       rtx r4 = gen_rtx_REG (SImode, 4);
1092       rtx r5 = gen_rtx_REG (SImode, 5);
1093       rtx r6 = gen_rtx_REG (SImode, 6);
1094
1095       function_symbol (func_addr_rtx, "__movmem", SFUNC_STATIC);
1096       force_into (XEXP (operands[0], 0), r4);
1097       force_into (XEXP (operands[1], 0), r5);
1098
1099       /* r6 controls the size of the move.  16 is decremented from it
1100          for each 64 bytes moved.  Then the negative bit left over is used
1101          as an index into a list of move instructions.  e.g., a 72 byte move
1102          would be set up with size(r6) = 14, for one iteration through the
1103          big while loop, and a switch of -2 for the last part.  */
1104
1105       final_switch = 16 - ((bytes / 4) % 16);
1106       while_loop = ((bytes / 4) / 16 - 1) * 16;
1107       emit_insn (gen_move_insn (r6, GEN_INT (while_loop + final_switch)));
1108       emit_insn (gen_block_lump_real (func_addr_rtx));
1109       return 1;
1110     }
1111
1112   return 0;
1113 }
1114
1115 /* Prepare operands for a move define_expand; specifically, one of the
1116    operands must be in a register.  */
1117
1118 int
1119 prepare_move_operands (rtx operands[], enum machine_mode mode)
1120 {
1121   if ((mode == SImode || mode == DImode)
1122       && flag_pic
1123       && ! ((mode == Pmode || mode == ptr_mode)
1124             && tls_symbolic_operand (operands[1], Pmode) != 0))
1125     {
1126       rtx temp;
1127       if (SYMBOLIC_CONST_P (operands[1]))
1128         {
1129           if (GET_CODE (operands[0]) == MEM)
1130             operands[1] = force_reg (Pmode, operands[1]);
1131           else if (TARGET_SHMEDIA
1132                    && GET_CODE (operands[1]) == LABEL_REF
1133                    && target_reg_operand (operands[0], mode))
1134             /* It's ok.  */;
1135           else
1136             {
1137               temp = no_new_pseudos ? operands[0] : gen_reg_rtx (Pmode);
1138               operands[1] = legitimize_pic_address (operands[1], mode, temp);
1139             }
1140         }
1141       else if (GET_CODE (operands[1]) == CONST
1142                && GET_CODE (XEXP (operands[1], 0)) == PLUS
1143                && SYMBOLIC_CONST_P (XEXP (XEXP (operands[1], 0), 0)))
1144         {
1145           temp = no_new_pseudos ? operands[0] : gen_reg_rtx (Pmode);
1146           temp = legitimize_pic_address (XEXP (XEXP (operands[1], 0), 0),
1147                                          mode, temp);
1148           operands[1] = expand_binop (mode, add_optab, temp,
1149                                       XEXP (XEXP (operands[1], 0), 1),
1150                                       no_new_pseudos ? temp
1151                                       : gen_reg_rtx (Pmode),
1152                                       0, OPTAB_LIB_WIDEN);
1153         }
1154     }
1155
1156   if (! reload_in_progress && ! reload_completed)
1157     {
1158       /* Copy the source to a register if both operands aren't registers.  */
1159       if (! register_operand (operands[0], mode)
1160           && ! sh_register_operand (operands[1], mode))
1161         operands[1] = copy_to_mode_reg (mode, operands[1]);
1162
1163       if (GET_CODE (operands[0]) == MEM && ! memory_operand (operands[0], mode))
1164         {
1165           /* This is like change_address_1 (operands[0], mode, 0, 1) ,
1166              except that we can't use that function because it is static.  */
1167           rtx new = change_address (operands[0], mode, 0);
1168           MEM_COPY_ATTRIBUTES (new, operands[0]);
1169           operands[0] = new;
1170         }
1171
1172       /* This case can happen while generating code to move the result
1173          of a library call to the target.  Reject `st r0,@(rX,rY)' because
1174          reload will fail to find a spill register for rX, since r0 is already
1175          being used for the source.  */
1176       else if (TARGET_SH1
1177                && refers_to_regno_p (R0_REG, R0_REG + 1, operands[1], (rtx *)0)
1178                && GET_CODE (operands[0]) == MEM
1179                && GET_CODE (XEXP (operands[0], 0)) == PLUS
1180                && GET_CODE (XEXP (XEXP (operands[0], 0), 1)) == REG)
1181         operands[1] = copy_to_mode_reg (mode, operands[1]);
1182     }
1183
1184   if (mode == Pmode || mode == ptr_mode)
1185     {
1186       rtx op0, op1;
1187       enum tls_model tls_kind;
1188
1189       op0 = operands[0];
1190       op1 = operands[1];
1191       if ((tls_kind = tls_symbolic_operand (op1, Pmode)))
1192         {
1193           rtx tga_op1, tga_ret, tmp, tmp2;
1194
1195           switch (tls_kind)
1196             {
1197             case TLS_MODEL_GLOBAL_DYNAMIC:
1198               tga_ret = gen_rtx_REG (Pmode, R0_REG);
1199               emit_call_insn (gen_tls_global_dynamic (tga_ret, op1));
1200               op1 = tga_ret;
1201               break;
1202
1203             case TLS_MODEL_LOCAL_DYNAMIC:
1204               tga_ret = gen_rtx_REG (Pmode, R0_REG);
1205               emit_call_insn (gen_tls_local_dynamic (tga_ret, op1));
1206
1207               tmp = gen_reg_rtx (Pmode);
1208               emit_move_insn (tmp, tga_ret);
1209
1210               if (register_operand (op0, Pmode))
1211                 tmp2 = op0;
1212               else
1213                 tmp2 = gen_reg_rtx (Pmode);
1214
1215               emit_insn (gen_symDTPOFF2reg (tmp2, op1, tmp));
1216               op1 = tmp2;
1217               break;
1218
1219             case TLS_MODEL_INITIAL_EXEC:
1220               if (! flag_pic)
1221                 {
1222                   /* Don't schedule insns for getting GOT address when
1223                      the first scheduling is enabled, to avoid spill
1224                      failures for R0.  */
1225                   if (flag_schedule_insns)
1226                     emit_insn (gen_blockage ());
1227                   emit_insn (gen_GOTaddr2picreg ());
1228                   emit_insn (gen_rtx_USE (VOIDmode, gen_rtx_REG (SImode,
1229                                                                  PIC_REG)));
1230                   if (flag_schedule_insns)
1231                     emit_insn (gen_blockage ());
1232                 }
1233               tga_op1 = no_new_pseudos ? op0 : gen_reg_rtx (Pmode);
1234               tmp = gen_sym2GOTTPOFF (op1);
1235               emit_insn (gen_tls_initial_exec (tga_op1, tmp));
1236               op1 = tga_op1;
1237               break;
1238
1239             case TLS_MODEL_LOCAL_EXEC:
1240               tmp2 = gen_reg_rtx (Pmode);
1241               emit_insn (gen_load_gbr (tmp2));
1242               tmp = gen_reg_rtx (Pmode);
1243               emit_insn (gen_symTPOFF2reg (tmp, op1));
1244
1245               if (register_operand (op0, Pmode))
1246                 op1 = op0;
1247               else
1248                 op1 = gen_reg_rtx (Pmode);
1249
1250               emit_insn (gen_addsi3 (op1, tmp, tmp2));
1251               break;
1252
1253             default:
1254               gcc_unreachable ();
1255             }
1256           operands[1] = op1;
1257         }
1258     }
1259
1260   return 0;
1261 }
1262
1263 /* Prepare the operands for an scc instruction; make sure that the
1264    compare has been done.  */
1265 rtx
1266 prepare_scc_operands (enum rtx_code code)
1267 {
1268   rtx t_reg = gen_rtx_REG (SImode, T_REG);
1269   enum rtx_code oldcode = code;
1270   enum machine_mode mode;
1271
1272   /* First need a compare insn.  */
1273   switch (code)
1274     {
1275     case NE:
1276       /* It isn't possible to handle this case.  */
1277       gcc_unreachable ();
1278     case LT:
1279       code = GT;
1280       break;
1281     case LE:
1282       code = GE;
1283       break;
1284     case LTU:
1285       code = GTU;
1286       break;
1287     case LEU:
1288       code = GEU;
1289       break;
1290     default:
1291       break;
1292     }
1293   if (code != oldcode)
1294     {
1295       rtx tmp = sh_compare_op0;
1296       sh_compare_op0 = sh_compare_op1;
1297       sh_compare_op1 = tmp;
1298     }
1299
1300   mode = GET_MODE (sh_compare_op0);
1301   if (mode == VOIDmode)
1302     mode = GET_MODE (sh_compare_op1);
1303
1304   sh_compare_op0 = force_reg (mode, sh_compare_op0);
1305   if ((code != EQ && code != NE
1306        && (sh_compare_op1 != const0_rtx
1307            || code == GTU  || code == GEU || code == LTU || code == LEU))
1308       || (mode == DImode && sh_compare_op1 != const0_rtx)
1309       || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1310     sh_compare_op1 = force_reg (mode, sh_compare_op1);
1311
1312   if ((TARGET_SH4 || TARGET_SH2A) && GET_MODE_CLASS (mode) == MODE_FLOAT)
1313     (mode == SFmode ? emit_sf_insn : emit_df_insn)
1314      (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2,
1315                 gen_rtx_SET (VOIDmode, t_reg,
1316                              gen_rtx_fmt_ee (code, SImode,
1317                                              sh_compare_op0, sh_compare_op1)),
1318                 gen_rtx_USE (VOIDmode, get_fpscr_rtx ()))));
1319   else
1320     emit_insn (gen_rtx_SET (VOIDmode, t_reg,
1321                             gen_rtx_fmt_ee (code, SImode,
1322                                             sh_compare_op0, sh_compare_op1)));
1323
1324   return t_reg;
1325 }
1326
1327 /* Called from the md file, set up the operands of a compare instruction.  */
1328
1329 void
1330 from_compare (rtx *operands, int code)
1331 {
1332   enum machine_mode mode = GET_MODE (sh_compare_op0);
1333   rtx insn;
1334   if (mode == VOIDmode)
1335     mode = GET_MODE (sh_compare_op1);
1336   if (code != EQ
1337       || mode == DImode
1338       || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1339     {
1340       /* Force args into regs, since we can't use constants here.  */
1341       sh_compare_op0 = force_reg (mode, sh_compare_op0);
1342       if (sh_compare_op1 != const0_rtx
1343           || code == GTU  || code == GEU
1344           || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1345         sh_compare_op1 = force_reg (mode, sh_compare_op1);
1346     }
1347   if (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT && code == GE)
1348     {
1349       from_compare (operands, GT);
1350       insn = gen_ieee_ccmpeqsf_t (sh_compare_op0, sh_compare_op1);
1351     }
1352   else
1353     insn = gen_rtx_SET (VOIDmode,
1354                         gen_rtx_REG (SImode, T_REG),
1355                         gen_rtx_fmt_ee (code, SImode,
1356                                         sh_compare_op0, sh_compare_op1));
1357   if ((TARGET_SH4 || TARGET_SH2A) && GET_MODE_CLASS (mode) == MODE_FLOAT)
1358     {
1359       insn = gen_rtx_PARALLEL (VOIDmode,
1360                       gen_rtvec (2, insn,
1361                                  gen_rtx_USE (VOIDmode, get_fpscr_rtx ())));
1362       (mode == SFmode ? emit_sf_insn : emit_df_insn) (insn);
1363     }
1364   else
1365     emit_insn (insn);
1366 }
1367 \f
1368 /* Functions to output assembly code.  */
1369
1370 /* Return a sequence of instructions to perform DI or DF move.
1371
1372    Since the SH cannot move a DI or DF in one instruction, we have
1373    to take care when we see overlapping source and dest registers.  */
1374
1375 const char *
1376 output_movedouble (rtx insn ATTRIBUTE_UNUSED, rtx operands[],
1377                    enum machine_mode mode)
1378 {
1379   rtx dst = operands[0];
1380   rtx src = operands[1];
1381
1382   if (GET_CODE (dst) == MEM
1383       && GET_CODE (XEXP (dst, 0)) == PRE_DEC)
1384     return "mov.l       %T1,%0\n\tmov.l %1,%0";
1385
1386   if (register_operand (dst, mode)
1387       && register_operand (src, mode))
1388     {
1389       if (REGNO (src) == MACH_REG)
1390         return "sts     mach,%S0\n\tsts macl,%R0";
1391
1392       /* When mov.d r1,r2 do r2->r3 then r1->r2;
1393          when mov.d r1,r0 do r1->r0 then r2->r1.  */
1394
1395       if (REGNO (src) + 1 == REGNO (dst))
1396         return "mov     %T1,%T0\n\tmov  %1,%0";
1397       else
1398         return "mov     %1,%0\n\tmov    %T1,%T0";
1399     }
1400   else if (GET_CODE (src) == CONST_INT)
1401     {
1402       if (INTVAL (src) < 0)
1403         output_asm_insn ("mov   #-1,%S0", operands);
1404       else
1405         output_asm_insn ("mov   #0,%S0", operands);
1406
1407       return "mov       %1,%R0";
1408     }
1409   else if (GET_CODE (src) == MEM)
1410     {
1411       int ptrreg = -1;
1412       int dreg = REGNO (dst);
1413       rtx inside = XEXP (src, 0);
1414
1415       switch (GET_CODE (inside))
1416         {
1417         case REG:
1418           ptrreg = REGNO (inside);
1419           break;
1420
1421         case SUBREG:
1422           ptrreg = subreg_regno (inside);
1423           break;
1424
1425         case PLUS:
1426           ptrreg = REGNO (XEXP (inside, 0));
1427           /* ??? A r0+REG address shouldn't be possible here, because it isn't
1428              an offsettable address.  Unfortunately, offsettable addresses use
1429              QImode to check the offset, and a QImode offsettable address
1430              requires r0 for the other operand, which is not currently
1431              supported, so we can't use the 'o' constraint.
1432              Thus we must check for and handle r0+REG addresses here.
1433              We punt for now, since this is likely very rare.  */
1434           gcc_assert (GET_CODE (XEXP (inside, 1)) != REG);
1435           break;
1436
1437         case LABEL_REF:
1438           return "mov.l %1,%0\n\tmov.l  %1+4,%T0";
1439         case POST_INC:
1440           return "mov.l %1,%0\n\tmov.l  %1,%T0";
1441         default:
1442           gcc_unreachable ();
1443         }
1444
1445       /* Work out the safe way to copy.  Copy into the second half first.  */
1446       if (dreg == ptrreg)
1447         return "mov.l   %T1,%T0\n\tmov.l        %1,%0";
1448     }
1449
1450   return "mov.l %1,%0\n\tmov.l  %T1,%T0";
1451 }
1452
1453 /* Print an instruction which would have gone into a delay slot after
1454    another instruction, but couldn't because the other instruction expanded
1455    into a sequence where putting the slot insn at the end wouldn't work.  */
1456
1457 static void
1458 print_slot (rtx insn)
1459 {
1460   final_scan_insn (XVECEXP (insn, 0, 1), asm_out_file, optimize, 1, NULL);
1461
1462   INSN_DELETED_P (XVECEXP (insn, 0, 1)) = 1;
1463 }
1464
1465 const char *
1466 output_far_jump (rtx insn, rtx op)
1467 {
1468   struct { rtx lab, reg, op; } this;
1469   rtx braf_base_lab = NULL_RTX;
1470   const char *jump;
1471   int far;
1472   int offset = branch_dest (insn) - INSN_ADDRESSES (INSN_UID (insn));
1473   rtx prev;
1474
1475   this.lab = gen_label_rtx ();
1476
1477   if (TARGET_SH2
1478       && offset >= -32764
1479       && offset - get_attr_length (insn) <= 32766)
1480     {
1481       far = 0;
1482       jump = "mov.w     %O0,%1; braf    %1";
1483     }
1484   else
1485     {
1486       far = 1;
1487       if (flag_pic)
1488         {
1489           if (TARGET_SH2)
1490             jump = "mov.l       %O0,%1; braf    %1";
1491           else
1492             jump = "mov.l       r0,@-r15; mova  %O0,r0; mov.l   @r0,%1; add     r0,%1; mov.l    @r15+,r0; jmp   @%1";
1493         }
1494       else
1495         jump = "mov.l   %O0,%1; jmp     @%1";
1496     }
1497   /* If we have a scratch register available, use it.  */
1498   if (GET_CODE ((prev = prev_nonnote_insn (insn))) == INSN
1499       && INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch)
1500     {
1501       this.reg = SET_DEST (XVECEXP (PATTERN (prev), 0, 0));
1502       if (REGNO (this.reg) == R0_REG && flag_pic && ! TARGET_SH2)
1503         jump = "mov.l   r1,@-r15; mova  %O0,r0; mov.l   @r0,r1; add     r1,r0; mov.l    @r15+,r1; jmp   @%1";
1504       output_asm_insn (jump, &this.lab);
1505       if (dbr_sequence_length ())
1506         print_slot (final_sequence);
1507       else
1508         output_asm_insn ("nop", 0);
1509     }
1510   else
1511     {
1512       /* Output the delay slot insn first if any.  */
1513       if (dbr_sequence_length ())
1514         print_slot (final_sequence);
1515
1516       this.reg = gen_rtx_REG (SImode, 13);
1517       /* We must keep the stack aligned to 8-byte boundaries on SH5.
1518          Fortunately, MACL is fixed and call-clobbered, and we never
1519          need its value across jumps, so save r13 in it instead of in
1520          the stack.  */
1521       if (TARGET_SH5)
1522         output_asm_insn ("lds   r13, macl", 0);
1523       else
1524         output_asm_insn ("mov.l r13,@-r15", 0);
1525       output_asm_insn (jump, &this.lab);
1526       if (TARGET_SH5)
1527         output_asm_insn ("sts   macl, r13", 0);
1528       else
1529         output_asm_insn ("mov.l @r15+,r13", 0);
1530     }
1531   if (far && flag_pic && TARGET_SH2)
1532     {
1533       braf_base_lab = gen_label_rtx ();
1534       (*targetm.asm_out.internal_label) (asm_out_file, "L",
1535                                  CODE_LABEL_NUMBER (braf_base_lab));
1536     }
1537   if (far)
1538     output_asm_insn (".align    2", 0);
1539   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (this.lab));
1540   this.op = op;
1541   if (far && flag_pic)
1542     {
1543       if (TARGET_SH2)
1544         this.lab = braf_base_lab;
1545       output_asm_insn (".long   %O2-%O0", &this.lab);
1546     }
1547   else
1548     output_asm_insn (far ? ".long       %O2" : ".word %O2-%O0", &this.lab);
1549   return "";
1550 }
1551
1552 /* Local label counter, used for constants in the pool and inside
1553    pattern branches.  */
1554
1555 static int lf = 100;
1556
1557 /* Output code for ordinary branches.  */
1558
1559 const char *
1560 output_branch (int logic, rtx insn, rtx *operands)
1561 {
1562   switch (get_attr_length (insn))
1563     {
1564     case 6:
1565       /* This can happen if filling the delay slot has caused a forward
1566          branch to exceed its range (we could reverse it, but only
1567          when we know we won't overextend other branches; this should
1568          best be handled by relaxation).
1569          It can also happen when other condbranches hoist delay slot insn
1570          from their destination, thus leading to code size increase.
1571          But the branch will still be in the range -4092..+4098 bytes.  */
1572
1573       if (! TARGET_RELAX)
1574         {
1575           int label = lf++;
1576           /* The call to print_slot will clobber the operands.  */
1577           rtx op0 = operands[0];
1578
1579           /* If the instruction in the delay slot is annulled (true), then
1580              there is no delay slot where we can put it now.  The only safe
1581              place for it is after the label.  final will do that by default.  */
1582
1583           if (final_sequence
1584               && ! INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1585               && get_attr_length (XVECEXP (final_sequence, 0, 1)))
1586             {
1587               asm_fprintf (asm_out_file, "\tb%s%ss\t%LLF%d\n", logic ? "f" : "t",
1588                            ASSEMBLER_DIALECT ? "/" : ".", label);
1589               print_slot (final_sequence);
1590             }
1591           else
1592             asm_fprintf (asm_out_file, "\tb%s\t%LLF%d\n", logic ? "f" : "t", label);
1593
1594           output_asm_insn ("bra\t%l0", &op0);
1595           fprintf (asm_out_file, "\tnop\n");
1596           (*targetm.asm_out.internal_label) (asm_out_file, "LF", label);
1597
1598           return "";
1599         }
1600       /* When relaxing, handle this like a short branch.  The linker
1601          will fix it up if it still doesn't fit after relaxation.  */
1602     case 2:
1603       return logic ? "bt%.\t%l0" : "bf%.\t%l0";
1604
1605       /* These are for SH2e, in which we have to account for the
1606          extra nop because of the hardware bug in annulled branches.  */
1607     case 8:
1608       if (! TARGET_RELAX)
1609         {
1610           int label = lf++;
1611
1612           gcc_assert (!final_sequence
1613                       || !(INSN_ANNULLED_BRANCH_P
1614                            (XVECEXP (final_sequence, 0, 0))));
1615           asm_fprintf (asm_out_file, "b%s%ss\t%LLF%d\n",
1616                        logic ? "f" : "t",
1617                        ASSEMBLER_DIALECT ? "/" : ".", label);
1618           fprintf (asm_out_file, "\tnop\n");
1619           output_asm_insn ("bra\t%l0", operands);
1620           fprintf (asm_out_file, "\tnop\n");
1621           (*targetm.asm_out.internal_label) (asm_out_file, "LF", label);
1622
1623           return "";
1624         }
1625       /* When relaxing, fall through.  */
1626     case 4:
1627       {
1628         char buffer[10];
1629
1630         sprintf (buffer, "b%s%ss\t%%l0",
1631                  logic ? "t" : "f",
1632                  ASSEMBLER_DIALECT ? "/" : ".");
1633         output_asm_insn (buffer, &operands[0]);
1634         return "nop";
1635       }
1636
1637     default:
1638       /* There should be no longer branches now - that would
1639          indicate that something has destroyed the branches set
1640          up in machine_dependent_reorg.  */
1641       gcc_unreachable ();
1642     }
1643 }
1644
1645 const char *
1646 output_branchy_insn (enum rtx_code code, const char *template,
1647                      rtx insn, rtx *operands)
1648 {
1649   rtx next_insn = NEXT_INSN (insn);
1650
1651   if (next_insn && GET_CODE (next_insn) == JUMP_INSN && condjump_p (next_insn))
1652     {
1653       rtx src = SET_SRC (PATTERN (next_insn));
1654       if (GET_CODE (src) == IF_THEN_ELSE && GET_CODE (XEXP (src, 0)) != code)
1655         {
1656           /* Following branch not taken */
1657           operands[9] = gen_label_rtx ();
1658           emit_label_after (operands[9], next_insn);
1659           INSN_ADDRESSES_NEW (operands[9],
1660                               INSN_ADDRESSES (INSN_UID (next_insn))
1661                               + get_attr_length (next_insn));
1662           return template;
1663         }
1664       else
1665         {
1666           int offset = (branch_dest (next_insn)
1667                         - INSN_ADDRESSES (INSN_UID (next_insn)) + 4);
1668           if (offset >= -252 && offset <= 258)
1669             {
1670               if (GET_CODE (src) == IF_THEN_ELSE)
1671                 /* branch_true */
1672                 src = XEXP (src, 1);
1673               operands[9] = src;
1674               return template;
1675             }
1676         }
1677     }
1678   operands[9] = gen_label_rtx ();
1679   emit_label_after (operands[9], insn);
1680   INSN_ADDRESSES_NEW (operands[9],
1681                       INSN_ADDRESSES (INSN_UID (insn))
1682                       + get_attr_length (insn));
1683   return template;
1684 }
1685
1686 const char *
1687 output_ieee_ccmpeq (rtx insn, rtx *operands)
1688 {
1689   return output_branchy_insn (NE, "bt\t%l9\\;fcmp/eq\t%1,%0", insn, operands);
1690 }
1691 \f
1692 /* Output the start of the assembler file.  */
1693
1694 static void
1695 sh_file_start (void)
1696 {
1697   default_file_start ();
1698
1699 #ifdef SYMBIAN
1700   /* Declare the .directive section before it is used.  */
1701   fputs ("\t.section .directive, \"SM\", @progbits, 1\n", asm_out_file);
1702   fputs ("\t.asciz \"#<SYMEDIT>#\\n\"\n", asm_out_file);
1703 #endif
1704
1705   if (TARGET_ELF)
1706     /* We need to show the text section with the proper
1707        attributes as in TEXT_SECTION_ASM_OP, before dwarf2out
1708        emits it without attributes in TEXT_SECTION_ASM_OP, else GAS
1709        will complain.  We can teach GAS specifically about the
1710        default attributes for our choice of text section, but
1711        then we would have to change GAS again if/when we change
1712        the text section name.  */
1713     fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
1714   else
1715     /* Switch to the data section so that the coffsem symbol
1716        isn't in the text section.  */
1717     data_section ();
1718
1719   if (TARGET_LITTLE_ENDIAN)
1720     fputs ("\t.little\n", asm_out_file);
1721
1722   if (!TARGET_ELF)
1723     {
1724       if (TARGET_SHCOMPACT)
1725         fputs ("\t.mode\tSHcompact\n", asm_out_file);
1726       else if (TARGET_SHMEDIA)
1727         fprintf (asm_out_file, "\t.mode\tSHmedia\n\t.abi\t%i\n",
1728                  TARGET_SHMEDIA64 ? 64 : 32);
1729     }
1730 }
1731 \f
1732 /* Check if PAT includes UNSPEC_CALLER unspec pattern.  */
1733
1734 static bool
1735 unspec_caller_rtx_p (rtx pat)
1736 {
1737   switch (GET_CODE (pat))
1738     {
1739     case CONST:
1740       return unspec_caller_rtx_p (XEXP (pat, 0));
1741     case PLUS:
1742     case MINUS:
1743       if (unspec_caller_rtx_p (XEXP (pat, 0)))
1744         return true;
1745       return unspec_caller_rtx_p (XEXP (pat, 1));
1746     case UNSPEC:
1747       if (XINT (pat, 1) == UNSPEC_CALLER)
1748         return true;
1749     default:
1750       break;
1751     }
1752
1753   return false;
1754 }
1755
1756 /* Indicate that INSN cannot be duplicated.  This is true for insn
1757    that generates an unique label.  */
1758
1759 static bool
1760 sh_cannot_copy_insn_p (rtx insn)
1761 {
1762   rtx pat;
1763
1764   if (!reload_completed || !flag_pic)
1765     return false;
1766
1767   if (GET_CODE (insn) != INSN)
1768     return false;
1769   if (asm_noperands (insn) >= 0)
1770     return false;
1771
1772   pat = PATTERN (insn);
1773   if (GET_CODE (pat) != SET)
1774     return false;
1775   pat = SET_SRC (pat);
1776
1777   if (unspec_caller_rtx_p (pat))
1778     return true;
1779
1780   return false;
1781 }
1782 \f
1783 /* Actual number of instructions used to make a shift by N.  */
1784 static const char ashiftrt_insns[] =
1785   { 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};
1786
1787 /* Left shift and logical right shift are the same.  */
1788 static const char shift_insns[]    =
1789   { 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};
1790
1791 /* Individual shift amounts needed to get the above length sequences.
1792    One bit right shifts clobber the T bit, so when possible, put one bit
1793    shifts in the middle of the sequence, so the ends are eligible for
1794    branch delay slots.  */
1795 static const short shift_amounts[32][5] = {
1796   {0}, {1}, {2}, {2, 1},
1797   {2, 2}, {2, 1, 2}, {2, 2, 2}, {2, 2, 1, 2},
1798   {8}, {8, 1}, {8, 2}, {8, 1, 2},
1799   {8, 2, 2}, {8, 2, 1, 2}, {8, -2, 8}, {8, -1, 8},
1800   {16}, {16, 1}, {16, 2}, {16, 1, 2},
1801   {16, 2, 2}, {16, 2, 1, 2}, {16, -2, 8}, {16, -1, 8},
1802   {16, 8}, {16, 1, 8}, {16, 8, 2}, {16, 8, 1, 2},
1803   {16, 8, 2, 2}, {16, -1, -2, 16}, {16, -2, 16}, {16, -1, 16}};
1804
1805 /* Likewise, but for shift amounts < 16, up to three highmost bits
1806    might be clobbered.  This is typically used when combined with some
1807    kind of sign or zero extension.  */
1808
1809 static const char ext_shift_insns[]    =
1810   { 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};
1811
1812 static const short ext_shift_amounts[32][4] = {
1813   {0}, {1}, {2}, {2, 1},
1814   {2, 2}, {2, 1, 2}, {8, -2}, {8, -1},
1815   {8}, {8, 1}, {8, 2}, {8, 1, 2},
1816   {8, 2, 2}, {16, -2, -1}, {16, -2}, {16, -1},
1817   {16}, {16, 1}, {16, 2}, {16, 1, 2},
1818   {16, 2, 2}, {16, 2, 1, 2}, {16, -2, 8}, {16, -1, 8},
1819   {16, 8}, {16, 1, 8}, {16, 8, 2}, {16, 8, 1, 2},
1820   {16, 8, 2, 2}, {16, -1, -2, 16}, {16, -2, 16}, {16, -1, 16}};
1821
1822 /* Assuming we have a value that has been sign-extended by at least one bit,
1823    can we use the ext_shift_amounts with the last shift turned to an arithmetic shift
1824    to shift it by N without data loss, and quicker than by other means?  */
1825 #define EXT_SHIFT_SIGNED(n) (((n) | 8) == 15)
1826
1827 /* This is used in length attributes in sh.md to help compute the length
1828    of arbitrary constant shift instructions.  */
1829
1830 int
1831 shift_insns_rtx (rtx insn)
1832 {
1833   rtx set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
1834   int shift_count = INTVAL (XEXP (set_src, 1));
1835   enum rtx_code shift_code = GET_CODE (set_src);
1836
1837   switch (shift_code)
1838     {
1839     case ASHIFTRT:
1840       return ashiftrt_insns[shift_count];
1841     case LSHIFTRT:
1842     case ASHIFT:
1843       return shift_insns[shift_count];
1844     default:
1845       gcc_unreachable ();
1846     }
1847 }
1848
1849 /* Return the cost of a shift.  */
1850
1851 static inline int
1852 shiftcosts (rtx x)
1853 {
1854   int value;
1855
1856   if (TARGET_SHMEDIA)
1857     return 1;
1858
1859   if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
1860     {
1861       if (GET_MODE (x) == DImode
1862           && GET_CODE (XEXP (x, 1)) == CONST_INT
1863           && INTVAL (XEXP (x, 1)) == 1)
1864         return 2;
1865
1866       /* Everything else is invalid, because there is no pattern for it.  */
1867       return 10000;
1868     }
1869   /* If shift by a non constant, then this will be expensive.  */
1870   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
1871     return SH_DYNAMIC_SHIFT_COST;
1872
1873   value = INTVAL (XEXP (x, 1));
1874
1875   /* Otherwise, return the true cost in instructions.  */
1876   if (GET_CODE (x) == ASHIFTRT)
1877     {
1878       int cost = ashiftrt_insns[value];
1879       /* If SH3, then we put the constant in a reg and use shad.  */
1880       if (cost > 1 + SH_DYNAMIC_SHIFT_COST)
1881         cost = 1 + SH_DYNAMIC_SHIFT_COST;
1882       return cost;
1883     }
1884   else
1885     return shift_insns[value];
1886 }
1887
1888 /* Return the cost of an AND operation.  */
1889
1890 static inline int
1891 andcosts (rtx x)
1892 {
1893   int i;
1894
1895   /* Anding with a register is a single cycle and instruction.  */
1896   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
1897     return 1;
1898
1899   i = INTVAL (XEXP (x, 1));
1900
1901   if (TARGET_SHMEDIA)
1902     {
1903       if ((GET_CODE (XEXP (x, 1)) == CONST_INT
1904            && CONST_OK_FOR_I16 (INTVAL (XEXP (x, 1))))
1905           || EXTRA_CONSTRAINT_C16 (XEXP (x, 1)))
1906         return 1;
1907       else
1908         return 2;
1909     }
1910
1911   /* These constants are single cycle extu.[bw] instructions.  */
1912   if (i == 0xff || i == 0xffff)
1913     return 1;
1914   /* Constants that can be used in an and immediate instruction in a single
1915      cycle, but this requires r0, so make it a little more expensive.  */
1916   if (CONST_OK_FOR_K08 (i))
1917     return 2;
1918   /* Constants that can be loaded with a mov immediate and an and.
1919      This case is probably unnecessary.  */
1920   if (CONST_OK_FOR_I08 (i))
1921     return 2;
1922   /* Any other constants requires a 2 cycle pc-relative load plus an and.
1923      This case is probably unnecessary.  */
1924   return 3;
1925 }
1926
1927 /* Return the cost of an addition or a subtraction.  */
1928
1929 static inline int
1930 addsubcosts (rtx x)
1931 {
1932   /* Adding a register is a single cycle insn.  */
1933   if (GET_CODE (XEXP (x, 1)) == REG
1934       || GET_CODE (XEXP (x, 1)) == SUBREG)
1935     return 1;
1936
1937   /* Likewise for small constants.  */
1938   if (GET_CODE (XEXP (x, 1)) == CONST_INT
1939       && CONST_OK_FOR_ADD (INTVAL (XEXP (x, 1))))
1940     return 1;
1941
1942   if (TARGET_SHMEDIA)
1943     switch (GET_CODE (XEXP (x, 1)))
1944       {
1945       case CONST:
1946       case LABEL_REF:
1947       case SYMBOL_REF:
1948         return TARGET_SHMEDIA64 ? 5 : 3;
1949
1950       case CONST_INT:
1951         if (CONST_OK_FOR_I16 (INTVAL (XEXP (x, 1))))
1952           return 2;
1953         else if (CONST_OK_FOR_I16 (INTVAL (XEXP (x, 1)) >> 16))
1954           return 3;
1955         else if (CONST_OK_FOR_I16 ((INTVAL (XEXP (x, 1)) >> 16) >> 16))
1956           return 4;
1957
1958         /* Fall through.  */
1959       default:
1960         return 5;
1961       }
1962
1963   /* Any other constant requires a 2 cycle pc-relative load plus an
1964      addition.  */
1965   return 3;
1966 }
1967
1968 /* Return the cost of a multiply.  */
1969 static inline int
1970 multcosts (rtx x ATTRIBUTE_UNUSED)
1971 {
1972   if (sh_multcost >= 0)
1973     return sh_multcost;
1974   if (TARGET_SHMEDIA)
1975     /* ??? We have a mul insn, but it has a latency of three, and doesn't
1976        accept constants.  Ideally, we would use a cost of one or two and
1977        add the cost of the operand, but disregard the latter when inside loops
1978        and loop invariant code motion is still to follow.
1979        Using a multiply first and splitting it later if it's a loss
1980        doesn't work because of different sign / zero extension semantics
1981        of multiplies vs. shifts.  */
1982     return TARGET_SMALLCODE ? 2 : 3;
1983
1984   if (TARGET_SH2)
1985     {
1986       /* We have a mul insn, so we can never take more than the mul and the
1987          read of the mac reg, but count more because of the latency and extra
1988          reg usage.  */
1989       if (TARGET_SMALLCODE)
1990         return 2;
1991       return 3;
1992     }
1993
1994   /* If we're aiming at small code, then just count the number of
1995      insns in a multiply call sequence.  */
1996   if (TARGET_SMALLCODE)
1997     return 5;
1998
1999   /* Otherwise count all the insns in the routine we'd be calling too.  */
2000   return 20;
2001 }
2002
2003 /* Compute a (partial) cost for rtx X.  Return true if the complete
2004    cost has been computed, and false if subexpressions should be
2005    scanned.  In either case, *TOTAL contains the cost result.  */
2006
2007 static bool
2008 sh_rtx_costs (rtx x, int code, int outer_code, int *total)
2009 {
2010   switch (code)
2011     {
2012     case CONST_INT:
2013       if (TARGET_SHMEDIA)
2014         {
2015           if (INTVAL (x) == 0)
2016             *total = 0;
2017           else if (outer_code == AND && and_operand ((x), DImode))
2018             *total = 0;
2019           else if ((outer_code == IOR || outer_code == XOR
2020                     || outer_code == PLUS)
2021                    && CONST_OK_FOR_I10 (INTVAL (x)))
2022             *total = 0;
2023           else if (CONST_OK_FOR_I16 (INTVAL (x)))
2024             *total = COSTS_N_INSNS (outer_code != SET);
2025           else if (CONST_OK_FOR_I16 (INTVAL (x) >> 16))
2026             *total = COSTS_N_INSNS ((outer_code != SET) + 1);
2027           else if (CONST_OK_FOR_I16 ((INTVAL (x) >> 16) >> 16))
2028             *total = COSTS_N_INSNS (3);
2029           else
2030             *total = COSTS_N_INSNS (4);
2031           return true;
2032         }
2033       if (CONST_OK_FOR_I08 (INTVAL (x)))
2034         *total = 0;
2035       else if ((outer_code == AND || outer_code == IOR || outer_code == XOR)
2036                && CONST_OK_FOR_K08 (INTVAL (x)))
2037         *total = 1;
2038       else
2039         *total = 8;
2040       return true;
2041
2042     case CONST:
2043     case LABEL_REF:
2044     case SYMBOL_REF:
2045       if (TARGET_SHMEDIA64)
2046         *total = COSTS_N_INSNS (4);
2047       else if (TARGET_SHMEDIA32)
2048         *total = COSTS_N_INSNS (2);
2049       else
2050         *total = 5;
2051       return true;
2052
2053     case CONST_DOUBLE:
2054       if (TARGET_SHMEDIA)
2055         *total = COSTS_N_INSNS (4);
2056       else
2057         *total = 10;
2058       return true;
2059     case CONST_VECTOR:
2060       if (x == CONST0_RTX (GET_MODE (x)))
2061         *total = 0;
2062       else if (sh_1el_vec (x, VOIDmode))
2063         *total = outer_code != SET;
2064       if (sh_rep_vec (x, VOIDmode))
2065         *total = ((GET_MODE_UNIT_SIZE (GET_MODE (x)) + 3) / 4
2066                   + (outer_code != SET));
2067       *total = COSTS_N_INSNS (3) + (outer_code != SET);
2068       return true;
2069
2070     case PLUS:
2071     case MINUS:
2072       *total = COSTS_N_INSNS (addsubcosts (x));
2073       return true;
2074
2075     case AND:
2076       *total = COSTS_N_INSNS (andcosts (x));
2077       return true;
2078
2079     case MULT:
2080       *total = COSTS_N_INSNS (multcosts (x));
2081       return true;
2082
2083     case ASHIFT:
2084     case ASHIFTRT:
2085     case LSHIFTRT:
2086       *total = COSTS_N_INSNS (shiftcosts (x));
2087       return true;
2088
2089     case DIV:
2090     case UDIV:
2091     case MOD:
2092     case UMOD:
2093       *total = COSTS_N_INSNS (20);
2094       return true;
2095
2096     case PARALLEL:
2097       if (sh_1el_vec (x, VOIDmode))
2098         *total = outer_code != SET;
2099       if (sh_rep_vec (x, VOIDmode))
2100         *total = ((GET_MODE_UNIT_SIZE (GET_MODE (x)) + 3) / 4
2101                   + (outer_code != SET));
2102       *total = COSTS_N_INSNS (3) + (outer_code != SET);
2103       return true;
2104
2105     case FLOAT:
2106     case FIX:
2107       *total = 100;
2108       return true;
2109
2110     default:
2111       return false;
2112     }
2113 }
2114
2115 /* Compute the cost of an address.  For the SH, all valid addresses are
2116    the same cost.  Use a slightly higher cost for reg + reg addressing,
2117    since it increases pressure on r0.  */
2118
2119 static int
2120 sh_address_cost (rtx X)
2121 {
2122   return (GET_CODE (X) == PLUS
2123           && ! CONSTANT_P (XEXP (X, 1))
2124           && ! TARGET_SHMEDIA ? 1 : 0);
2125 }
2126
2127 /* Code to expand a shift.  */
2128
2129 void
2130 gen_ashift (int type, int n, rtx reg)
2131 {
2132   /* Negative values here come from the shift_amounts array.  */
2133   if (n < 0)
2134     {
2135       if (type == ASHIFT)
2136         type = LSHIFTRT;
2137       else
2138         type = ASHIFT;
2139       n = -n;
2140     }
2141
2142   switch (type)
2143     {
2144     case ASHIFTRT:
2145       emit_insn (gen_ashrsi3_k (reg, reg, GEN_INT (n)));
2146       break;
2147     case LSHIFTRT:
2148       if (n == 1)
2149         emit_insn (gen_lshrsi3_m (reg, reg, GEN_INT (n)));
2150       else
2151         emit_insn (gen_lshrsi3_k (reg, reg, GEN_INT (n)));
2152       break;
2153     case ASHIFT:
2154       emit_insn (gen_ashlsi3_std (reg, reg, GEN_INT (n)));
2155       break;
2156     }
2157 }
2158
2159 /* Same for HImode */
2160
2161 void
2162 gen_ashift_hi (int type, int n, rtx reg)
2163 {
2164   /* Negative values here come from the shift_amounts array.  */
2165   if (n < 0)
2166     {
2167       if (type == ASHIFT)
2168         type = LSHIFTRT;
2169       else
2170         type = ASHIFT;
2171       n = -n;
2172     }
2173
2174   switch (type)
2175     {
2176     case ASHIFTRT:
2177     case LSHIFTRT:
2178       /* We don't have HImode right shift operations because using the
2179          ordinary 32 bit shift instructions for that doesn't generate proper
2180          zero/sign extension.
2181          gen_ashift_hi is only called in contexts where we know that the
2182          sign extension works out correctly.  */
2183       {
2184         int offset = 0;
2185         if (GET_CODE (reg) == SUBREG)
2186           {
2187             offset = SUBREG_BYTE (reg);
2188             reg = SUBREG_REG (reg);
2189           }
2190         gen_ashift (type, n, gen_rtx_SUBREG (SImode, reg, offset));
2191         break;
2192       }
2193     case ASHIFT:
2194       emit_insn (gen_ashlhi3_k (reg, reg, GEN_INT (n)));
2195       break;
2196     }
2197 }
2198
2199 /* Output RTL to split a constant shift into its component SH constant
2200    shift instructions.  */
2201
2202 void
2203 gen_shifty_op (int code, rtx *operands)
2204 {
2205   int value = INTVAL (operands[2]);
2206   int max, i;
2207
2208   /* Truncate the shift count in case it is out of bounds.  */
2209   value = value & 0x1f;
2210
2211   if (value == 31)
2212     {
2213       if (code == LSHIFTRT)
2214         {
2215           emit_insn (gen_rotlsi3_1 (operands[0], operands[0]));
2216           emit_insn (gen_movt (operands[0]));
2217           return;
2218         }
2219       else if (code == ASHIFT)
2220         {
2221           /* There is a two instruction sequence for 31 bit left shifts,
2222              but it requires r0.  */
2223           if (GET_CODE (operands[0]) == REG && REGNO (operands[0]) == 0)
2224             {
2225               emit_insn (gen_andsi3 (operands[0], operands[0], const1_rtx));
2226               emit_insn (gen_rotlsi3_31 (operands[0], operands[0]));
2227               return;
2228             }
2229         }
2230     }
2231   else if (value == 0)
2232     {
2233       /* This can happen even when optimizing, if there were subregs before
2234          reload.  Don't output a nop here, as this is never optimized away;
2235          use a no-op move instead.  */
2236       emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[0]));
2237       return;
2238     }
2239
2240   max = shift_insns[value];
2241   for (i = 0; i < max; i++)
2242     gen_ashift (code, shift_amounts[value][i], operands[0]);
2243 }
2244
2245 /* Same as above, but optimized for values where the topmost bits don't
2246    matter.  */
2247
2248 void
2249 gen_shifty_hi_op (int code, rtx *operands)
2250 {
2251   int value = INTVAL (operands[2]);
2252   int max, i;
2253   void (*gen_fun) (int, int, rtx);
2254
2255   /* This operation is used by and_shl for SImode values with a few
2256      high bits known to be cleared.  */
2257   value &= 31;
2258   if (value == 0)
2259     {
2260       emit_insn (gen_nop ());
2261       return;
2262     }
2263
2264   gen_fun = GET_MODE (operands[0]) == HImode ? gen_ashift_hi : gen_ashift;
2265   if (code == ASHIFT)
2266     {
2267       max = ext_shift_insns[value];
2268       for (i = 0; i < max; i++)
2269         gen_fun (code, ext_shift_amounts[value][i], operands[0]);
2270     }
2271   else
2272     /* When shifting right, emit the shifts in reverse order, so that
2273        solitary negative values come first.  */
2274     for (i = ext_shift_insns[value] - 1; i >= 0; i--)
2275       gen_fun (code, ext_shift_amounts[value][i], operands[0]);
2276 }
2277
2278 /* Output RTL for an arithmetic right shift.  */
2279
2280 /* ??? Rewrite to use super-optimizer sequences.  */
2281
2282 int
2283 expand_ashiftrt (rtx *operands)
2284 {
2285   rtx wrk;
2286   char func[18];
2287   int value;
2288
2289   if (TARGET_SH3)
2290     {
2291       if (GET_CODE (operands[2]) != CONST_INT)
2292         {
2293           rtx count = copy_to_mode_reg (SImode, operands[2]);
2294           emit_insn (gen_negsi2 (count, count));
2295           emit_insn (gen_ashrsi3_d (operands[0], operands[1], count));
2296           return 1;
2297         }
2298       else if (ashiftrt_insns[INTVAL (operands[2]) & 31]
2299                > 1 + SH_DYNAMIC_SHIFT_COST)
2300         {
2301           rtx count
2302             = force_reg (SImode, GEN_INT (- (INTVAL (operands[2]) & 31)));
2303           emit_insn (gen_ashrsi3_d (operands[0], operands[1], count));
2304           return 1;
2305         }
2306     }
2307   if (GET_CODE (operands[2]) != CONST_INT)
2308     return 0;
2309
2310   value = INTVAL (operands[2]) & 31;
2311
2312   if (value == 31)
2313     {
2314       /* If we are called from abs expansion, arrange things so that we
2315          we can use a single MT instruction that doesn't clobber the source,
2316          if LICM can hoist out the load of the constant zero.  */
2317       if (currently_expanding_to_rtl)
2318         {
2319           emit_insn (gen_cmpgtsi_t (force_reg (SImode, CONST0_RTX (SImode)),
2320                                     operands[1]));
2321           emit_insn (gen_mov_neg_si_t (operands[0]));
2322           return 1;
2323         }
2324       emit_insn (gen_ashrsi2_31 (operands[0], operands[1]));
2325       return 1;
2326     }
2327   else if (value >= 16 && value <= 19)
2328     {
2329       wrk = gen_reg_rtx (SImode);
2330       emit_insn (gen_ashrsi2_16 (wrk, operands[1]));
2331       value -= 16;
2332       while (value--)
2333         gen_ashift (ASHIFTRT, 1, wrk);
2334       emit_move_insn (operands[0], wrk);
2335       return 1;
2336     }
2337   /* Expand a short sequence inline, longer call a magic routine.  */
2338   else if (value <= 5)
2339     {
2340       wrk = gen_reg_rtx (SImode);
2341       emit_move_insn (wrk, operands[1]);
2342       while (value--)
2343         gen_ashift (ASHIFTRT, 1, wrk);
2344       emit_move_insn (operands[0], wrk);
2345       return 1;
2346     }
2347
2348   wrk = gen_reg_rtx (Pmode);
2349
2350   /* Load the value into an arg reg and call a helper.  */
2351   emit_move_insn (gen_rtx_REG (SImode, 4), operands[1]);
2352   sprintf (func, "__ashiftrt_r4_%d", value);
2353   function_symbol (wrk, func, SFUNC_STATIC);
2354   emit_insn (gen_ashrsi3_n (GEN_INT (value), wrk));
2355   emit_move_insn (operands[0], gen_rtx_REG (SImode, 4));
2356   return 1;
2357 }
2358
2359 int
2360 sh_dynamicalize_shift_p (rtx count)
2361 {
2362   return shift_insns[INTVAL (count)] > 1 + SH_DYNAMIC_SHIFT_COST;
2363 }
2364
2365 /* Try to find a good way to implement the combiner pattern
2366   [(set (match_operand:SI 0 "register_operand" "r")
2367         (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
2368                            (match_operand:SI 2 "const_int_operand" "n"))
2369                 (match_operand:SI 3 "const_int_operand" "n"))) .
2370   LEFT_RTX is operand 2 in the above pattern, and MASK_RTX is operand 3.
2371   return 0 for simple right / left or left/right shift combination.
2372   return 1 for a combination of shifts with zero_extend.
2373   return 2 for a combination of shifts with an AND that needs r0.
2374   return 3 for a combination of shifts with an AND that needs an extra
2375     scratch register, when the three highmost bits of the AND mask are clear.
2376   return 4 for a combination of shifts with an AND that needs an extra
2377     scratch register, when any of the three highmost bits of the AND mask
2378     is set.
2379   If ATTRP is set, store an initial right shift width in ATTRP[0],
2380   and the instruction length in ATTRP[1] .  These values are not valid
2381   when returning 0.
2382   When ATTRP is set and returning 1, ATTRP[2] gets set to the index into
2383   shift_amounts for the last shift value that is to be used before the
2384   sign extend.  */
2385 int
2386 shl_and_kind (rtx left_rtx, rtx mask_rtx, int *attrp)
2387 {
2388   unsigned HOST_WIDE_INT mask, lsb, mask2, lsb2;
2389   int left = INTVAL (left_rtx), right;
2390   int best = 0;
2391   int cost, best_cost = 10000;
2392   int best_right = 0, best_len = 0;
2393   int i;
2394   int can_ext;
2395
2396   if (left < 0 || left > 31)
2397     return 0;
2398   if (GET_CODE (mask_rtx) == CONST_INT)
2399     mask = (unsigned HOST_WIDE_INT) INTVAL (mask_rtx) >> left;
2400   else
2401     mask = (unsigned HOST_WIDE_INT) GET_MODE_MASK (SImode) >> left;
2402   /* Can this be expressed as a right shift / left shift pair?  */
2403   lsb = ((mask ^ (mask - 1)) >> 1) + 1;
2404   right = exact_log2 (lsb);
2405   mask2 = ~(mask + lsb - 1);
2406   lsb2 = ((mask2 ^ (mask2 - 1)) >> 1) + 1;
2407   /* mask has no zeroes but trailing zeroes <==> ! mask2 */
2408   if (! mask2)
2409     best_cost = shift_insns[right] + shift_insns[right + left];
2410   /* mask has no trailing zeroes <==> ! right */
2411   else if (! right && mask2 == ~(lsb2 - 1))
2412     {
2413       int late_right = exact_log2 (lsb2);
2414       best_cost = shift_insns[left + late_right] + shift_insns[late_right];
2415     }
2416   /* Try to use zero extend.  */
2417   if (mask2 == ~(lsb2 - 1))
2418     {
2419       int width, first;
2420
2421       for (width = 8; width <= 16; width += 8)
2422         {
2423           /* Can we zero-extend right away?  */
2424           if (lsb2 == (unsigned HOST_WIDE_INT) 1 << width)
2425             {
2426               cost
2427                 = 1 + ext_shift_insns[right] + ext_shift_insns[left + right];
2428               if (cost < best_cost)
2429                 {
2430                   best = 1;
2431                   best_cost = cost;
2432                   best_right = right;
2433                   best_len = cost;
2434                   if (attrp)
2435                     attrp[2] = -1;
2436                 }
2437               continue;
2438             }
2439           /* ??? Could try to put zero extend into initial right shift,
2440              or even shift a bit left before the right shift.  */
2441           /* Determine value of first part of left shift, to get to the
2442              zero extend cut-off point.  */
2443           first = width - exact_log2 (lsb2) + right;
2444           if (first >= 0 && right + left - first >= 0)
2445             {
2446               cost = ext_shift_insns[right] + ext_shift_insns[first] + 1
2447                 + ext_shift_insns[right + left - first];
2448               if (cost < best_cost)
2449                 {
2450                   best = 1;
2451                   best_cost = cost;
2452                   best_right = right;
2453                   best_len = cost;
2454                   if (attrp)
2455                     attrp[2] = first;
2456                 }
2457             }
2458         }
2459     }
2460   /* Try to use r0 AND pattern */
2461   for (i = 0; i <= 2; i++)
2462     {
2463       if (i > right)
2464         break;
2465       if (! CONST_OK_FOR_K08 (mask >> i))
2466         continue;
2467       cost = (i != 0) + 2 + ext_shift_insns[left + i];
2468       if (cost < best_cost)
2469         {
2470           best = 2;
2471           best_cost = cost;
2472           best_right = i;
2473           best_len = cost - 1;
2474         }
2475     }
2476   /* Try to use a scratch register to hold the AND operand.  */
2477   can_ext = ((mask << left) & ((unsigned HOST_WIDE_INT) 3 << 30)) == 0;
2478   for (i = 0; i <= 2; i++)
2479     {
2480       if (i > right)
2481         break;
2482       cost = (i != 0) + (CONST_OK_FOR_I08 (mask >> i) ? 2 : 3)
2483         + (can_ext ? ext_shift_insns : shift_insns)[left + i];
2484       if (cost < best_cost)
2485         {
2486           best = 4 - can_ext;
2487           best_cost = cost;
2488           best_right = i;
2489           best_len = cost - 1 - ! CONST_OK_FOR_I08 (mask >> i);
2490         }
2491     }
2492
2493   if (attrp)
2494     {
2495       attrp[0] = best_right;
2496       attrp[1] = best_len;
2497     }
2498   return best;
2499 }
2500
2501 /* This is used in length attributes of the unnamed instructions
2502    corresponding to shl_and_kind return values of 1 and 2.  */
2503 int
2504 shl_and_length (rtx insn)
2505 {
2506   rtx set_src, left_rtx, mask_rtx;
2507   int attributes[3];
2508
2509   set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
2510   left_rtx = XEXP (XEXP (set_src, 0), 1);
2511   mask_rtx = XEXP (set_src, 1);
2512   shl_and_kind (left_rtx, mask_rtx, attributes);
2513   return attributes[1];
2514 }
2515
2516 /* This is used in length attribute of the and_shl_scratch instruction.  */
2517
2518 int
2519 shl_and_scr_length (rtx insn)
2520 {
2521   rtx set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
2522   int len = shift_insns[INTVAL (XEXP (set_src, 1))];
2523   rtx op = XEXP (set_src, 0);
2524   len += shift_insns[INTVAL (XEXP (op, 1))] + 1;
2525   op = XEXP (XEXP (op, 0), 0);
2526   return len + shift_insns[INTVAL (XEXP (op, 1))];
2527 }
2528
2529 /* Generate rtl for instructions for which shl_and_kind advised a particular
2530    method of generating them, i.e. returned zero.  */
2531
2532 int
2533 gen_shl_and (rtx dest, rtx left_rtx, rtx mask_rtx, rtx source)
2534 {
2535   int attributes[3];
2536   unsigned HOST_WIDE_INT mask;
2537   int kind = shl_and_kind (left_rtx, mask_rtx, attributes);
2538   int right, total_shift;
2539   void (*shift_gen_fun) (int, rtx *) = gen_shifty_hi_op;
2540
2541   right = attributes[0];
2542   total_shift = INTVAL (left_rtx) + right;
2543   mask = (unsigned HOST_WIDE_INT) INTVAL (mask_rtx) >> total_shift;
2544   switch (kind)
2545     {
2546     default:
2547       return -1;
2548     case 1:
2549       {
2550         int first = attributes[2];
2551         rtx operands[3];
2552
2553         if (first < 0)
2554           {
2555             emit_insn ((mask << right) <= 0xff
2556                        ? gen_zero_extendqisi2 (dest,
2557                                                gen_lowpart (QImode, source))
2558                        : gen_zero_extendhisi2 (dest,
2559                                                gen_lowpart (HImode, source)));
2560             source = dest;
2561           }
2562         if (source != dest)
2563           emit_insn (gen_movsi (dest, source));
2564         operands[0] = dest;
2565         if (right)
2566           {
2567             operands[2] = GEN_INT (right);
2568             gen_shifty_hi_op (LSHIFTRT, operands);
2569           }
2570         if (first > 0)
2571           {
2572             operands[2] = GEN_INT (first);
2573             gen_shifty_hi_op (ASHIFT, operands);
2574             total_shift -= first;
2575             mask <<= first;
2576           }
2577         if (first >= 0)
2578           emit_insn (mask <= 0xff
2579                      ? gen_zero_extendqisi2 (dest, gen_lowpart (QImode, dest))
2580                      : gen_zero_extendhisi2 (dest, gen_lowpart (HImode, dest)));
2581         if (total_shift > 0)
2582           {
2583             operands[2] = GEN_INT (total_shift);
2584             gen_shifty_hi_op (ASHIFT, operands);
2585           }
2586         break;
2587       }
2588     case 4:
2589       shift_gen_fun = gen_shifty_op;
2590     case 3:
2591       /* If the topmost bit that matters is set, set the topmost bits
2592          that don't matter.  This way, we might be able to get a shorter
2593          signed constant.  */
2594       if (mask & ((HOST_WIDE_INT) 1 << (31 - total_shift)))
2595         mask |= (HOST_WIDE_INT) ~0 << (31 - total_shift);
2596     case 2:
2597       /* Don't expand fine-grained when combining, because that will
2598          make the pattern fail.  */
2599       if (currently_expanding_to_rtl
2600           || reload_in_progress || reload_completed)
2601         {
2602           rtx operands[3];
2603
2604           /* Cases 3 and 4 should be handled by this split
2605              only while combining  */
2606           gcc_assert (kind <= 2);
2607           if (right)
2608             {
2609               emit_insn (gen_lshrsi3 (dest, source, GEN_INT (right)));
2610               source = dest;
2611             }
2612           emit_insn (gen_andsi3 (dest, source, GEN_INT (mask)));
2613           if (total_shift)
2614             {
2615               operands[0] = dest;
2616               operands[1] = dest;
2617               operands[2] = GEN_INT (total_shift);
2618               shift_gen_fun (ASHIFT, operands);
2619             }
2620           break;
2621         }
2622       else
2623         {
2624           int neg = 0;
2625           if (kind != 4 && total_shift < 16)
2626             {
2627               neg = -ext_shift_amounts[total_shift][1];
2628               if (neg > 0)
2629                 neg -= ext_shift_amounts[total_shift][2];
2630               else
2631                 neg = 0;
2632             }
2633           emit_insn (gen_and_shl_scratch (dest, source,
2634                                           GEN_INT (right),
2635                                           GEN_INT (mask),
2636                                           GEN_INT (total_shift + neg),
2637                                           GEN_INT (neg)));
2638           emit_insn (gen_movsi (dest, dest));
2639           break;
2640         }
2641     }
2642   return 0;
2643 }
2644
2645 /* Try to find a good way to implement the combiner pattern
2646   [(set (match_operand:SI 0 "register_operand" "=r")
2647         (sign_extract:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
2648                                     (match_operand:SI 2 "const_int_operand" "n")
2649                          (match_operand:SI 3 "const_int_operand" "n")
2650                          (const_int 0)))
2651    (clobber (reg:SI T_REG))]
2652   LEFT_RTX is operand 2 in the above pattern, and SIZE_RTX is operand 3.
2653   return 0 for simple left / right shift combination.
2654   return 1 for left shift / 8 bit sign extend / left shift.
2655   return 2 for left shift / 16 bit sign extend / left shift.
2656   return 3 for left shift / 8 bit sign extend / shift / sign extend.
2657   return 4 for left shift / 16 bit sign extend / shift / sign extend.
2658   return 5 for left shift / 16 bit sign extend / right shift
2659   return 6 for < 8 bit sign extend / left shift.
2660   return 7 for < 8 bit sign extend / left shift / single right shift.
2661   If COSTP is nonzero, assign the calculated cost to *COSTP.  */
2662
2663 int
2664 shl_sext_kind (rtx left_rtx, rtx size_rtx, int *costp)
2665 {
2666   int left, size, insize, ext;
2667   int cost = 0, best_cost;
2668   int kind;
2669
2670   left = INTVAL (left_rtx);
2671   size = INTVAL (size_rtx);
2672   insize = size - left;
2673   gcc_assert (insize > 0);
2674   /* Default to left / right shift.  */
2675   kind = 0;
2676   best_cost = shift_insns[32 - insize] + ashiftrt_insns[32 - size];
2677   if (size <= 16)
2678     {
2679       /* 16 bit shift / sign extend / 16 bit shift */
2680       cost = shift_insns[16 - insize] + 1 + ashiftrt_insns[16 - size];
2681       /* If ashiftrt_insns[16 - size] is 8, this choice will be overridden
2682          below, by alternative 3 or something even better.  */
2683       if (cost < best_cost)
2684         {
2685           kind = 5;
2686           best_cost = cost;
2687         }
2688     }
2689   /* Try a plain sign extend between two shifts.  */
2690   for (ext = 16; ext >= insize; ext -= 8)
2691     {
2692       if (ext <= size)
2693         {
2694           cost = ext_shift_insns[ext - insize] + 1 + shift_insns[size - ext];
2695           if (cost < best_cost)
2696             {
2697               kind = ext / (unsigned) 8;
2698               best_cost = cost;
2699             }
2700         }
2701       /* Check if we can do a sloppy shift with a final signed shift
2702          restoring the sign.  */
2703       if (EXT_SHIFT_SIGNED (size - ext))
2704         cost = ext_shift_insns[ext - insize] + ext_shift_insns[size - ext] + 1;
2705       /* If not, maybe it's still cheaper to do the second shift sloppy,
2706          and do a final sign extend?  */
2707       else if (size <= 16)
2708         cost = ext_shift_insns[ext - insize] + 1
2709           + ext_shift_insns[size > ext ? size - ext : ext - size] + 1;
2710       else
2711         continue;
2712       if (cost < best_cost)
2713         {
2714           kind = ext / (unsigned) 8 + 2;
2715           best_cost = cost;
2716         }
2717     }
2718   /* Check if we can sign extend in r0 */
2719   if (insize < 8)
2720     {
2721       cost = 3 + shift_insns[left];
2722       if (cost < best_cost)
2723         {
2724           kind = 6;
2725           best_cost = cost;
2726         }
2727       /* Try the same with a final signed shift.  */
2728       if (left < 31)
2729         {
2730           cost = 3 + ext_shift_insns[left + 1] + 1;
2731           if (cost < best_cost)
2732             {
2733               kind = 7;
2734               best_cost = cost;
2735             }
2736         }
2737     }
2738   if (TARGET_SH3)
2739     {
2740       /* Try to use a dynamic shift.  */
2741       cost = shift_insns[32 - insize] + 1 + SH_DYNAMIC_SHIFT_COST;
2742       if (cost < best_cost)
2743         {
2744           kind = 0;
2745           best_cost = cost;
2746         }
2747     }
2748   if (costp)
2749     *costp = cost;
2750   return kind;
2751 }
2752
2753 /* Function to be used in the length attribute of the instructions
2754    implementing this pattern.  */
2755
2756 int
2757 shl_sext_length (rtx insn)
2758 {
2759   rtx set_src, left_rtx, size_rtx;
2760   int cost;
2761
2762   set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
2763   left_rtx = XEXP (XEXP (set_src, 0), 1);
2764   size_rtx = XEXP (set_src, 1);
2765   shl_sext_kind (left_rtx, size_rtx, &cost);
2766   return cost;
2767 }
2768
2769 /* Generate rtl for this pattern */
2770
2771 int
2772 gen_shl_sext (rtx dest, rtx left_rtx, rtx size_rtx, rtx source)
2773 {
2774   int kind;
2775   int left, size, insize, cost;
2776   rtx operands[3];
2777
2778   kind = shl_sext_kind (left_rtx, size_rtx, &cost);
2779   left = INTVAL (left_rtx);
2780   size = INTVAL (size_rtx);
2781   insize = size - left;
2782   switch (kind)
2783     {
2784     case 1:
2785     case 2:
2786     case 3:
2787     case 4:
2788       {
2789         int ext = kind & 1 ? 8 : 16;
2790         int shift2 = size - ext;
2791
2792         /* Don't expand fine-grained when combining, because that will
2793            make the pattern fail.  */
2794         if (! currently_expanding_to_rtl
2795             && ! reload_in_progress && ! reload_completed)
2796           {
2797             emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
2798             emit_insn (gen_movsi (dest, source));
2799             break;
2800           }
2801         if (dest != source)
2802           emit_insn (gen_movsi (dest, source));
2803         operands[0] = dest;
2804         if (ext - insize)
2805           {
2806             operands[2] = GEN_INT (ext - insize);
2807             gen_shifty_hi_op (ASHIFT, operands);
2808           }
2809         emit_insn (kind & 1
2810                    ? gen_extendqisi2 (dest, gen_lowpart (QImode, dest))
2811                    : gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
2812         if (kind <= 2)
2813           {
2814             if (shift2)
2815               {
2816                 operands[2] = GEN_INT (shift2);
2817                 gen_shifty_op (ASHIFT, operands);
2818               }
2819           }
2820         else
2821           {
2822             if (shift2 > 0)
2823               {
2824                 if (EXT_SHIFT_SIGNED (shift2))
2825                   {
2826                     operands[2] = GEN_INT (shift2 + 1);
2827                     gen_shifty_op (ASHIFT, operands);
2828                     operands[2] = const1_rtx;
2829                     gen_shifty_op (ASHIFTRT, operands);
2830                     break;
2831                   }
2832                 operands[2] = GEN_INT (shift2);
2833                 gen_shifty_hi_op (ASHIFT, operands);
2834               }
2835             else if (shift2)
2836               {
2837                 operands[2] = GEN_INT (-shift2);
2838                 gen_shifty_hi_op (LSHIFTRT, operands);
2839               }
2840             emit_insn (size <= 8
2841                        ? gen_extendqisi2 (dest, gen_lowpart (QImode, dest))
2842                        : gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
2843           }
2844         break;
2845       }
2846     case 5:
2847       {
2848         int i = 16 - size;
2849         if (! currently_expanding_to_rtl
2850             && ! reload_in_progress && ! reload_completed)
2851           emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
2852         else
2853           {
2854             operands[0] = dest;
2855             operands[2] = GEN_INT (16 - insize);
2856             gen_shifty_hi_op (ASHIFT, operands);
2857             emit_insn (gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
2858           }
2859         /* Don't use gen_ashrsi3 because it generates new pseudos.  */
2860         while (--i >= 0)
2861           gen_ashift (ASHIFTRT, 1, dest);
2862         break;
2863       }
2864     case 6:
2865     case 7:
2866       /* Don't expand fine-grained when combining, because that will
2867          make the pattern fail.  */
2868       if (! currently_expanding_to_rtl
2869           && ! reload_in_progress && ! reload_completed)
2870         {
2871           emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
2872           emit_insn (gen_movsi (dest, source));
2873           break;
2874         }
2875       emit_insn (gen_andsi3 (dest, source, GEN_INT ((1 << insize) - 1)));
2876       emit_insn (gen_xorsi3 (dest, dest, GEN_INT (1 << (insize - 1))));
2877       emit_insn (gen_addsi3 (dest, dest, GEN_INT (-1 << (insize - 1))));
2878       operands[0] = dest;
2879       operands[2] = kind == 7 ? GEN_INT (left + 1) : left_rtx;
2880       gen_shifty_op (ASHIFT, operands);
2881       if (kind == 7)
2882         emit_insn (gen_ashrsi3_k (dest, dest, const1_rtx));
2883       break;
2884     default:
2885       return -1;
2886     }
2887   return 0;
2888 }
2889
2890 /* Prefix a symbol_ref name with "datalabel".  */
2891
2892 rtx
2893 gen_datalabel_ref (rtx sym)
2894 {
2895   const char *str;
2896
2897   if (GET_CODE (sym) == LABEL_REF)
2898     return gen_rtx_CONST (GET_MODE (sym),
2899                           gen_rtx_UNSPEC (GET_MODE (sym),
2900                                           gen_rtvec (1, sym),
2901                                           UNSPEC_DATALABEL));
2902
2903   gcc_assert (GET_CODE (sym) == SYMBOL_REF);
2904
2905   str = XSTR (sym, 0);
2906   /* Share all SYMBOL_REF strings with the same value - that is important
2907      for cse.  */
2908   str = IDENTIFIER_POINTER (get_identifier (str));
2909   XSTR (sym, 0) = str;
2910
2911   return sym;
2912 }
2913
2914 \f
2915 /* The SH cannot load a large constant into a register, constants have to
2916    come from a pc relative load.  The reference of a pc relative load
2917    instruction must be less than 1k in front of the instruction.  This
2918    means that we often have to dump a constant inside a function, and
2919    generate code to branch around it.
2920
2921    It is important to minimize this, since the branches will slow things
2922    down and make things bigger.
2923
2924    Worst case code looks like:
2925
2926    mov.l L1,rn
2927    bra   L2
2928    nop
2929    align
2930    L1:   .long value
2931    L2:
2932    ..
2933
2934    mov.l L3,rn
2935    bra   L4
2936    nop
2937    align
2938    L3:   .long value
2939    L4:
2940    ..
2941
2942    We fix this by performing a scan before scheduling, which notices which
2943    instructions need to have their operands fetched from the constant table
2944    and builds the table.
2945
2946    The algorithm is:
2947
2948    scan, find an instruction which needs a pcrel move.  Look forward, find the
2949    last barrier which is within MAX_COUNT bytes of the requirement.
2950    If there isn't one, make one.  Process all the instructions between
2951    the find and the barrier.
2952
2953    In the above example, we can tell that L3 is within 1k of L1, so
2954    the first move can be shrunk from the 3 insn+constant sequence into
2955    just 1 insn, and the constant moved to L3 to make:
2956
2957    mov.l        L1,rn
2958    ..
2959    mov.l        L3,rn
2960    bra          L4
2961    nop
2962    align
2963    L3:.long value
2964    L4:.long value
2965
2966    Then the second move becomes the target for the shortening process.  */
2967
2968 typedef struct
2969 {
2970   rtx value;                    /* Value in table.  */
2971   rtx label;                    /* Label of value.  */
2972   rtx wend;                     /* End of window.  */
2973   enum machine_mode mode;       /* Mode of value.  */
2974
2975   /* True if this constant is accessed as part of a post-increment
2976      sequence.  Note that HImode constants are never accessed in this way.  */
2977   bool part_of_sequence_p;
2978 } pool_node;
2979
2980 /* The maximum number of constants that can fit into one pool, since
2981    constants in the range 0..510 are at least 2 bytes long, and in the
2982    range from there to 1018 at least 4 bytes.  */
2983
2984 #define MAX_POOL_SIZE 372
2985 static pool_node pool_vector[MAX_POOL_SIZE];
2986 static int pool_size;
2987 static rtx pool_window_label;
2988 static int pool_window_last;
2989
2990 /* ??? If we need a constant in HImode which is the truncated value of a
2991    constant we need in SImode, we could combine the two entries thus saving
2992    two bytes.  Is this common enough to be worth the effort of implementing
2993    it?  */
2994
2995 /* ??? This stuff should be done at the same time that we shorten branches.
2996    As it is now, we must assume that all branches are the maximum size, and
2997    this causes us to almost always output constant pools sooner than
2998    necessary.  */
2999
3000 /* Add a constant to the pool and return its label.  */
3001
3002 static rtx
3003 add_constant (rtx x, enum machine_mode mode, rtx last_value)
3004 {
3005   int i;
3006   rtx lab, new, ref, newref;
3007
3008   /* First see if we've already got it.  */
3009   for (i = 0; i < pool_size; i++)
3010     {
3011       if (x->code == pool_vector[i].value->code
3012           && mode == pool_vector[i].mode)
3013         {
3014           if (x->code == CODE_LABEL)
3015             {
3016               if (XINT (x, 3) != XINT (pool_vector[i].value, 3))
3017                 continue;
3018             }
3019           if (rtx_equal_p (x, pool_vector[i].value))
3020             {
3021               lab = new = 0;
3022               if (! last_value
3023                   || ! i
3024                   || ! rtx_equal_p (last_value, pool_vector[i-1].value))
3025                 {
3026                   new = gen_label_rtx ();
3027                   LABEL_REFS (new) = pool_vector[i].label;
3028                   pool_vector[i].label = lab = new;
3029                 }
3030               if (lab && pool_window_label)
3031                 {
3032                   newref = gen_rtx_LABEL_REF (VOIDmode, pool_window_label);
3033                   ref = pool_vector[pool_window_last].wend;
3034                   LABEL_NEXTREF (newref) = ref;
3035                   pool_vector[pool_window_last].wend = newref;
3036                 }
3037               if (new)
3038                 pool_window_label = new;
3039               pool_window_last = i;
3040               return lab;
3041             }
3042         }
3043     }
3044
3045   /* Need a new one.  */
3046   pool_vector[pool_size].value = x;
3047   if (last_value && rtx_equal_p (last_value, pool_vector[pool_size - 1].value))
3048     {
3049       lab = 0;
3050       pool_vector[pool_size - 1].part_of_sequence_p = true;
3051     }
3052   else
3053     lab = gen_label_rtx ();
3054   pool_vector[pool_size].mode = mode;
3055   pool_vector[pool_size].label = lab;
3056   pool_vector[pool_size].wend = NULL_RTX;
3057   pool_vector[pool_size].part_of_sequence_p = (lab == 0);
3058   if (lab && pool_window_label)
3059     {
3060       newref = gen_rtx_LABEL_REF (VOIDmode, pool_window_label);
3061       ref = pool_vector[pool_window_last].wend;
3062       LABEL_NEXTREF (newref) = ref;
3063       pool_vector[pool_window_last].wend = newref;
3064     }
3065   if (lab)
3066     pool_window_label = lab;
3067   pool_window_last = pool_size;
3068   pool_size++;
3069   return lab;
3070 }
3071
3072 /* Output the literal table.  START, if nonzero, is the first instruction
3073    this table is needed for, and also indicates that there is at least one
3074    casesi_worker_2 instruction; We have to emit the operand3 labels from
3075    these insns at a 4-byte  aligned position.  BARRIER is the barrier
3076    after which we are to place the table.  */
3077
3078 static void
3079 dump_table (rtx start, rtx barrier)
3080 {
3081   rtx scan = barrier;
3082   int i;
3083   int need_align = 1;
3084   rtx lab, ref;
3085   int have_df = 0;
3086
3087   /* Do two passes, first time dump out the HI sized constants.  */
3088
3089   for (i = 0; i < pool_size; i++)
3090     {
3091       pool_node *p = &pool_vector[i];
3092
3093       if (p->mode == HImode)
3094         {
3095           if (need_align)
3096             {
3097               scan = emit_insn_after (gen_align_2 (), scan);
3098               need_align = 0;
3099             }
3100           for (lab = p->label; lab; lab = LABEL_REFS (lab))
3101             scan = emit_label_after (lab, scan);
3102           scan = emit_insn_after (gen_consttable_2 (p->value, const0_rtx),
3103                                   scan);
3104           for (ref = p->wend; ref; ref = LABEL_NEXTREF (ref))
3105             {
3106               lab = XEXP (ref, 0);
3107               scan = emit_insn_after (gen_consttable_window_end (lab), scan);
3108             }
3109         }
3110       else if (p->mode == DFmode)
3111         have_df = 1;
3112     }
3113
3114   need_align = 1;
3115
3116   if (start)
3117     {
3118       scan = emit_insn_after (gen_align_4 (), scan);
3119       need_align = 0;
3120       for (; start != barrier; start = NEXT_INSN (start))
3121         if (GET_CODE (start) == INSN
3122             && recog_memoized (start) == CODE_FOR_casesi_worker_2)
3123           {
3124             rtx src = SET_SRC (XVECEXP (PATTERN (start), 0, 0));
3125             rtx lab = XEXP (XVECEXP (src, 0, 3), 0);
3126
3127             scan = emit_label_after (lab, scan);
3128           }
3129     }
3130   if (TARGET_FMOVD && TARGET_ALIGN_DOUBLE && have_df)
3131     {
3132       rtx align_insn = NULL_RTX;
3133
3134       scan = emit_label_after (gen_label_rtx (), scan);
3135       scan = emit_insn_after (gen_align_log (GEN_INT (3)), scan);
3136       need_align = 0;
3137
3138       for (i = 0; i < pool_size; i++)
3139         {
3140           pool_node *p = &pool_vector[i];
3141
3142           switch (p->mode)
3143             {
3144             case HImode:
3145               break;
3146             case SImode:
3147             case SFmode:
3148               if (align_insn && !p->part_of_sequence_p)
3149                 {
3150                   for (lab = p->label; lab; lab = LABEL_REFS (lab))
3151                     emit_label_before (lab, align_insn);
3152                   emit_insn_before (gen_consttable_4 (p->value, const0_rtx),
3153                                     align_insn);
3154                   for (ref = p->wend; ref; ref = LABEL_NEXTREF (ref))
3155                     {
3156                       lab = XEXP (ref, 0);
3157                       emit_insn_before (gen_consttable_window_end (lab),
3158                                         align_insn);
3159                     }
3160                   delete_insn (align_insn);
3161                   align_insn = NULL_RTX;
3162                   continue;
3163                 }
3164               else
3165                 {
3166                   for (lab = p->label; lab; lab = LABEL_REFS (lab))
3167                     scan = emit_label_after (lab, scan);
3168                   scan = emit_insn_after (gen_consttable_4 (p->value,
3169                                                             const0_rtx), scan);
3170                   need_align = ! need_align;
3171                 }
3172               break;
3173             case DFmode:
3174               if (need_align)
3175                 {
3176                   scan = emit_insn_after (gen_align_log (GEN_INT (3)), scan);
3177                   align_insn = scan;
3178                   need_align = 0;
3179                 }
3180             case DImode:
3181               for (lab = p->label; lab; lab = LABEL_REFS (lab))
3182                 scan = emit_label_after (lab, scan);
3183               scan = emit_insn_after (gen_consttable_8 (p->value, const0_rtx),
3184                                       scan);
3185               break;
3186             default:
3187               gcc_unreachable ();
3188             }
3189
3190           if (p->mode != HImode)
3191             {
3192               for (ref = p->wend; ref; ref = LABEL_NEXTREF (ref))
3193                 {
3194                   lab = XEXP (ref, 0);
3195                   scan = emit_insn_after (gen_consttable_window_end (lab),
3196                                           scan);
3197                 }
3198             }
3199         }
3200
3201       pool_size = 0;
3202     }
3203
3204   for (i = 0; i < pool_size; i++)
3205     {
3206       pool_node *p = &pool_vector[i];
3207
3208       switch (p->mode)
3209         {
3210         case HImode:
3211           break;
3212         case SImode:
3213         case SFmode:
3214           if (need_align)
3215             {
3216               need_align = 0;
3217               scan = emit_label_after (gen_label_rtx (), scan);
3218               scan = emit_insn_after (gen_align_4 (), scan);
3219             }
3220           for (lab = p->label; lab; lab = LABEL_REFS (lab))
3221             scan = emit_label_after (lab, scan);
3222           scan = emit_insn_after (gen_consttable_4 (p->value, const0_rtx),
3223                                   scan);
3224           break;
3225         case DFmode:
3226         case DImode:
3227           if (need_align)
3228             {
3229               need_align = 0;
3230               scan = emit_label_after (gen_label_rtx (), scan);
3231               scan = emit_insn_after (gen_align_4 (), scan);
3232             }
3233           for (lab = p->label; lab; lab = LABEL_REFS (lab))
3234             scan = emit_label_after (lab, scan);
3235           scan = emit_insn_after (gen_consttable_8 (p->value, const0_rtx),
3236                                   scan);
3237           break;
3238         default:
3239           gcc_unreachable ();
3240         }
3241
3242       if (p->mode != HImode)
3243         {
3244           for (ref = p->wend; ref; ref = LABEL_NEXTREF (ref))
3245             {
3246               lab = XEXP (ref, 0);
3247               scan = emit_insn_after (gen_consttable_window_end (lab), scan);
3248             }
3249         }
3250     }
3251
3252   scan = emit_insn_after (gen_consttable_end (), scan);
3253   scan = emit_barrier_after (scan);
3254   pool_size = 0;
3255   pool_window_label = NULL_RTX;
3256   pool_window_last = 0;
3257 }
3258
3259 /* Return nonzero if constant would be an ok source for a
3260    mov.w instead of a mov.l.  */
3261
3262 static int
3263 hi_const (rtx src)
3264 {
3265   return (GET_CODE (src) == CONST_INT
3266           && INTVAL (src) >= -32768
3267           && INTVAL (src) <= 32767);
3268 }
3269
3270 /* Nonzero if the insn is a move instruction which needs to be fixed.  */
3271
3272 /* ??? For a DImode/DFmode moves, we don't need to fix it if each half of the
3273    CONST_DOUBLE input value is CONST_OK_FOR_I08.  For a SFmode move, we don't
3274    need to fix it if the input value is CONST_OK_FOR_I08.  */
3275
3276 static int
3277 broken_move (rtx insn)
3278 {
3279   if (GET_CODE (insn) == INSN)
3280     {
3281       rtx pat = PATTERN (insn);
3282       if (GET_CODE (pat) == PARALLEL)
3283         pat = XVECEXP (pat, 0, 0);
3284       if (GET_CODE (pat) == SET
3285           /* We can load any 8 bit value if we don't care what the high
3286              order bits end up as.  */
3287           && GET_MODE (SET_DEST (pat)) != QImode
3288           && (CONSTANT_P (SET_SRC (pat))
3289               /* Match mova_const.  */
3290               || (GET_CODE (SET_SRC (pat)) == UNSPEC
3291                   && XINT (SET_SRC (pat), 1) == UNSPEC_MOVA
3292                   && GET_CODE (XVECEXP (SET_SRC (pat), 0, 0)) == CONST))
3293           && ! (TARGET_SH2E
3294                 && GET_CODE (SET_SRC (pat)) == CONST_DOUBLE
3295                 && (fp_zero_operand (SET_SRC (pat))
3296                     || fp_one_operand (SET_SRC (pat)))
3297                 /* ??? If this is a -m4 or -m4-single compilation, in general
3298                    we don't know the current setting of fpscr, so disable fldi.
3299                    There is an exception if this was a register-register move
3300                    before reload - and hence it was ascertained that we have
3301                    single precision setting - and in a post-reload optimization
3302                    we changed this to do a constant load.  In that case
3303                    we don't have an r0 clobber, hence we must use fldi.  */
3304                 && (! TARGET_SH4 || TARGET_FMOVD
3305                     || (GET_CODE (XEXP (XVECEXP (PATTERN (insn), 0, 2), 0))
3306                         == SCRATCH))
3307                 && GET_CODE (SET_DEST (pat)) == REG
3308                 && FP_REGISTER_P (REGNO (SET_DEST (pat))))
3309           && ! (TARGET_SH2A
3310                 && GET_MODE (SET_DEST (pat)) == SImode
3311                 && GET_CODE (SET_SRC (pat)) == CONST_INT
3312                 && CONST_OK_FOR_I20 (INTVAL (SET_SRC (pat))))
3313           && (GET_CODE (SET_SRC (pat)) != CONST_INT
3314               || ! CONST_OK_FOR_I08 (INTVAL (SET_SRC (pat)))))
3315         return 1;
3316     }
3317
3318   return 0;
3319 }
3320
3321 static int
3322 mova_p (rtx insn)
3323 {
3324   return (GET_CODE (insn) == INSN
3325           && GET_CODE (PATTERN (insn)) == SET
3326           && GET_CODE (SET_SRC (PATTERN (insn))) == UNSPEC
3327           && XINT (SET_SRC (PATTERN (insn)), 1) == UNSPEC_MOVA
3328           /* Don't match mova_const.  */
3329           && GET_CODE (XVECEXP (SET_SRC (PATTERN (insn)), 0, 0)) == LABEL_REF);
3330 }
3331
3332 /* Fix up a mova from a switch that went out of range.  */
3333 static void
3334 fixup_mova (rtx mova)
3335 {
3336   if (! flag_pic)
3337     {
3338       SET_SRC (PATTERN (mova)) = XVECEXP (SET_SRC (PATTERN (mova)), 0, 0);
3339       INSN_CODE (mova) = -1;
3340     }
3341   else
3342     {
3343       rtx worker = mova;
3344       rtx lab = gen_label_rtx ();
3345       rtx wpat, wpat0, wpat1, wsrc, diff;
3346
3347       do
3348         {
3349           worker = NEXT_INSN (worker);
3350           gcc_assert (worker
3351                       && GET_CODE (worker) != CODE_LABEL
3352                       && GET_CODE (worker) != JUMP_INSN);
3353         } while (recog_memoized (worker) != CODE_FOR_casesi_worker_1);
3354       wpat = PATTERN (worker);
3355       wpat0 = XVECEXP (wpat, 0, 0);
3356       wpat1 = XVECEXP (wpat, 0, 1);
3357       wsrc = SET_SRC (wpat0);
3358       PATTERN (worker) = (gen_casesi_worker_2
3359                           (SET_DEST (wpat0), XVECEXP (wsrc, 0, 1),
3360                            XEXP (XVECEXP (wsrc, 0, 2), 0), lab,
3361                            XEXP (wpat1, 0)));
3362       INSN_CODE (worker) = -1;
3363       diff = gen_rtx_MINUS (Pmode, XVECEXP (SET_SRC (PATTERN (mova)), 0, 0),
3364                             gen_rtx_LABEL_REF (Pmode, lab));
3365       diff = gen_rtx_UNSPEC (Pmode, gen_rtvec (1, diff), UNSPEC_PIC);
3366       SET_SRC (PATTERN (mova)) = gen_rtx_CONST (Pmode, diff);
3367       INSN_CODE (mova) = -1;
3368     }
3369 }
3370
3371 /* Find the last barrier from insn FROM which is close enough to hold the
3372    constant pool.  If we can't find one, then create one near the end of
3373    the range.  */
3374
3375 static rtx
3376 find_barrier (int num_mova, rtx mova, rtx from)
3377 {
3378   int count_si = 0;
3379   int count_hi = 0;
3380   int found_hi = 0;
3381   int found_si = 0;
3382   int found_di = 0;
3383   int hi_align = 2;
3384   int si_align = 2;
3385   int leading_mova = num_mova;
3386   rtx barrier_before_mova = 0, found_barrier = 0, good_barrier = 0;
3387   int si_limit;
3388   int hi_limit;
3389
3390   /* For HImode: range is 510, add 4 because pc counts from address of
3391      second instruction after this one, subtract 2 for the jump instruction
3392      that we may need to emit before the table, subtract 2 for the instruction
3393      that fills the jump delay slot (in very rare cases, reorg will take an
3394      instruction from after the constant pool or will leave the delay slot
3395      empty).  This gives 510.
3396      For SImode: range is 1020, add 4 because pc counts from address of
3397      second instruction after this one, subtract 2 in case pc is 2 byte
3398      aligned, subtract 2 for the jump instruction that we may need to emit
3399      before the table, subtract 2 for the instruction that fills the jump
3400      delay slot.  This gives 1018.  */
3401
3402   /* The branch will always be shortened now that the reference address for
3403      forward branches is the successor address, thus we need no longer make
3404      adjustments to the [sh]i_limit for -O0.  */
3405
3406   si_limit = 1018;
3407   hi_limit = 510;
3408
3409   while (from && count_si < si_limit && count_hi < hi_limit)
3410     {
3411       int inc = get_attr_length (from);
3412       int new_align = 1;
3413
3414       if (GET_CODE (from) == CODE_LABEL)
3415         {
3416           if (optimize)
3417             new_align = 1 << label_to_alignment (from);
3418           else if (GET_CODE (prev_nonnote_insn (from)) == BARRIER)
3419             new_align = 1 << barrier_align (from);
3420           else
3421             new_align = 1;
3422           inc = 0;
3423         }
3424
3425       if (GET_CODE (from) == BARRIER)
3426         {
3427
3428           found_barrier = from;
3429
3430           /* If we are at the end of the function, or in front of an alignment
3431              instruction, we need not insert an extra alignment.  We prefer
3432              this kind of barrier.  */
3433           if (barrier_align (from) > 2)
3434             good_barrier = from;
3435         }
3436
3437       if (broken_move (from))
3438         {
3439           rtx pat, src, dst;
3440           enum machine_mode mode;
3441
3442           pat = PATTERN (from);
3443           if (GET_CODE (pat) == PARALLEL)
3444             pat = XVECEXP (pat, 0, 0);
3445           src = SET_SRC (pat);
3446           dst = SET_DEST (pat);
3447           mode = GET_MODE (dst);
3448
3449           /* We must explicitly check the mode, because sometimes the
3450              front end will generate code to load unsigned constants into
3451              HImode targets without properly sign extending them.  */
3452           if (mode == HImode
3453               || (mode == SImode && hi_const (src) && REGNO (dst) != FPUL_REG))
3454             {
3455               found_hi += 2;
3456               /* We put the short constants before the long constants, so
3457                  we must count the length of short constants in the range
3458                  for the long constants.  */
3459               /* ??? This isn't optimal, but is easy to do.  */
3460               si_limit -= 2;
3461             }
3462           else
3463             {
3464               /* We dump DF/DI constants before SF/SI ones, because
3465                  the limit is the same, but the alignment requirements
3466                  are higher.  We may waste up to 4 additional bytes
3467                  for alignment, and the DF/DI constant may have
3468                  another SF/SI constant placed before it.  */
3469               if (TARGET_SHCOMPACT
3470                   && ! found_di
3471                   && (mode == DFmode || mode == DImode))
3472                 {
3473                   found_di = 1;
3474                   si_limit -= 8;
3475                 }
3476               while (si_align > 2 && found_si + si_align - 2 > count_si)
3477                 si_align >>= 1;
3478               if (found_si > count_si)
3479                 count_si = found_si;
3480               found_si += GET_MODE_SIZE (mode);
3481               if (num_mova)
3482                 si_limit -= GET_MODE_SIZE (mode);
3483             }
3484         }
3485
3486       if (mova_p (from))
3487         {
3488           if (! num_mova++)
3489             {
3490               leading_mova = 0;
3491               mova = from;
3492               barrier_before_mova = good_barrier ? good_barrier : found_barrier;
3493             }
3494           if (found_si > count_si)
3495             count_si = found_si;
3496         }
3497       else if (GET_CODE (from) == JUMP_INSN
3498                && (GET_CODE (PATTERN (from)) == ADDR_VEC
3499                    || GET_CODE (PATTERN (from)) == ADDR_DIFF_VEC))
3500         {
3501           if (num_mova)
3502             num_mova--;
3503           if (barrier_align (next_real_insn (from)) == align_jumps_log)
3504             {
3505               /* We have just passed the barrier in front of the
3506                  ADDR_DIFF_VEC, which is stored in found_barrier.  Since
3507                  the ADDR_DIFF_VEC is accessed as data, just like our pool
3508                  constants, this is a good opportunity to accommodate what
3509                  we have gathered so far.
3510                  If we waited any longer, we could end up at a barrier in
3511                  front of code, which gives worse cache usage for separated
3512                  instruction / data caches.  */
3513               good_barrier = found_barrier;
3514               break;
3515             }
3516           else
3517             {
3518               rtx body = PATTERN (from);
3519               inc = XVECLEN (body, 1) * GET_MODE_SIZE (GET_MODE (body));
3520             }
3521         }
3522       /* For the SH1, we generate alignments even after jumps-around-jumps.  */
3523       else if (GET_CODE (from) == JUMP_INSN
3524                && ! TARGET_SH2
3525                && ! TARGET_SMALLCODE)
3526         new_align = 4;
3527
3528       if (found_si)
3529         {
3530           count_si += inc;
3531           if (new_align > si_align)
3532             {
3533               si_limit -= (count_si - 1) & (new_align - si_align);
3534               si_align = new_align;
3535             }
3536           count_si = (count_si + new_align - 1) & -new_align;
3537         }
3538       if (found_hi)
3539         {
3540           count_hi += inc;
3541           if (new_align > hi_align)
3542             {
3543               hi_limit -= (count_hi - 1) & (new_align - hi_align);
3544               hi_align = new_align;
3545             }
3546           count_hi = (count_hi + new_align - 1) & -new_align;
3547         }
3548       from = NEXT_INSN (from);
3549     }
3550
3551   if (num_mova)
3552     {
3553       if (leading_mova)
3554         {
3555           /* Try as we might, the leading mova is out of range.  Change
3556              it into a load (which will become a pcload) and retry.  */
3557           fixup_mova (mova);
3558           return find_barrier (0, 0, mova);
3559         }
3560       else
3561         {
3562           /* Insert the constant pool table before the mova instruction,
3563              to prevent the mova label reference from going out of range.  */
3564           from = mova;
3565           good_barrier = found_barrier = barrier_before_mova;
3566         }
3567     }
3568
3569   if (found_barrier)
3570     {
3571       if (good_barrier && next_real_insn (found_barrier))
3572         found_barrier = good_barrier;
3573     }
3574   else
3575     {
3576       /* We didn't find a barrier in time to dump our stuff,
3577          so we'll make one.  */
3578       rtx label = gen_label_rtx ();
3579
3580       /* If we exceeded the range, then we must back up over the last
3581          instruction we looked at.  Otherwise, we just need to undo the
3582          NEXT_INSN at the end of the loop.  */
3583       if (count_hi > hi_limit || count_si > si_limit)
3584         from = PREV_INSN (PREV_INSN (from));
3585       else
3586         from = PREV_INSN (from);
3587
3588       /* Walk back to be just before any jump or label.
3589          Putting it before a label reduces the number of times the branch
3590          around the constant pool table will be hit.  Putting it before
3591          a jump makes it more likely that the bra delay slot will be
3592          filled.  */
3593       while (GET_CODE (from) == JUMP_INSN || GET_CODE (from) == NOTE
3594              || GET_CODE (from) == CODE_LABEL)
3595         from = PREV_INSN (from);
3596
3597       from = emit_jump_insn_after (gen_jump (label), from);
3598       JUMP_LABEL (from) = label;
3599       LABEL_NUSES (label) = 1;
3600       found_barrier = emit_barrier_after (from);
3601       emit_label_after (label, found_barrier);
3602     }
3603
3604   return found_barrier;
3605 }
3606
3607 /* If the instruction INSN is implemented by a special function, and we can
3608    positively find the register that is used to call the sfunc, and this
3609    register is not used anywhere else in this instruction - except as the
3610    destination of a set, return this register; else, return 0.  */
3611 rtx
3612 sfunc_uses_reg (rtx insn)
3613 {
3614   int i;
3615   rtx pattern, part, reg_part, reg;
3616
3617   if (GET_CODE (insn) != INSN)
3618     return 0;
3619   pattern = PATTERN (insn);
3620   if (GET_CODE (pattern) != PARALLEL || get_attr_type (insn) != TYPE_SFUNC)
3621     return 0;
3622
3623   for (reg_part = 0, i = XVECLEN (pattern, 0) - 1; i >= 1; i--)
3624     {
3625       part = XVECEXP (pattern, 0, i);
3626       if (GET_CODE (part) == USE && GET_MODE (XEXP (part, 0)) == SImode)
3627         reg_part = part;
3628     }
3629   if (! reg_part)
3630     return 0;
3631   reg = XEXP (reg_part, 0);
3632   for (i = XVECLEN (pattern, 0) - 1; i >= 0; i--)
3633     {
3634       part = XVECEXP (pattern, 0, i);
3635       if (part == reg_part || GET_CODE (part) == CLOBBER)
3636         continue;
3637       if (reg_mentioned_p (reg, ((GET_CODE (part) == SET
3638                                   && GET_CODE (SET_DEST (part)) == REG)
3639                                  ? SET_SRC (part) : part)))
3640         return 0;
3641     }
3642   return reg;
3643 }
3644
3645 /* See if the only way in which INSN uses REG is by calling it, or by
3646    setting it while calling it.  Set *SET to a SET rtx if the register
3647    is set by INSN.  */
3648
3649 static int
3650 noncall_uses_reg (rtx reg, rtx insn, rtx *set)
3651 {
3652   rtx pattern, reg2;
3653
3654   *set = NULL_RTX;
3655
3656   reg2 = sfunc_uses_reg (insn);
3657   if (reg2 && REGNO (reg2) == REGNO (reg))
3658     {
3659       pattern = single_set (insn);
3660       if (pattern
3661           && GET_CODE (SET_DEST (pattern)) == REG
3662           && REGNO (reg) == REGNO (SET_DEST (pattern)))
3663         *set = pattern;
3664       return 0;
3665     }
3666   if (GET_CODE (insn) != CALL_INSN)
3667     {
3668       /* We don't use rtx_equal_p because we don't care if the mode is
3669          different.  */
3670       pattern = single_set (insn);
3671       if (pattern
3672           && GET_CODE (SET_DEST (pattern)) == REG
3673           && REGNO (reg) == REGNO (SET_DEST (pattern)))
3674         {
3675           rtx par, part;
3676           int i;
3677
3678           *set = pattern;
3679           par = PATTERN (insn);
3680           if (GET_CODE (par) == PARALLEL)
3681             for (i = XVECLEN (par, 0) - 1; i >= 0; i--)
3682               {
3683                 part = XVECEXP (par, 0, i);
3684                 if (GET_CODE (part) != SET && reg_mentioned_p (reg, part))
3685                   return 1;
3686               }
3687           return reg_mentioned_p (reg, SET_SRC (pattern));
3688         }
3689
3690       return 1;
3691     }
3692
3693   pattern = PATTERN (insn);
3694
3695   if (GET_CODE (pattern) == PARALLEL)
3696     {
3697       int i;
3698
3699       for (i = XVECLEN (pattern, 0) - 1; i >= 1; i--)
3700         if (reg_mentioned_p (reg, XVECEXP (pattern, 0, i)))
3701           return 1;
3702       pattern = XVECEXP (pattern, 0, 0);
3703     }
3704
3705   if (GET_CODE (pattern) == SET)
3706     {
3707       if (reg_mentioned_p (reg, SET_DEST (pattern)))
3708         {
3709           /* We don't use rtx_equal_p, because we don't care if the
3710              mode is different.  */
3711           if (GET_CODE (SET_DEST (pattern)) != REG
3712               || REGNO (reg) != REGNO (SET_DEST (pattern)))
3713             return 1;
3714
3715           *set = pattern;
3716         }
3717
3718       pattern = SET_SRC (pattern);
3719     }
3720
3721   if (GET_CODE (pattern) != CALL
3722       || GET_CODE (XEXP (pattern, 0)) != MEM
3723       || ! rtx_equal_p (reg, XEXP (XEXP (pattern, 0), 0)))
3724     return 1;
3725
3726   return 0;
3727 }
3728
3729 /* Given a X, a pattern of an insn or a part of it, return a mask of used
3730    general registers.  Bits 0..15 mean that the respective registers
3731    are used as inputs in the instruction.  Bits 16..31 mean that the
3732    registers 0..15, respectively, are used as outputs, or are clobbered.
3733    IS_DEST should be set to 16 if X is the destination of a SET, else to 0.  */
3734 int
3735 regs_used (rtx x, int is_dest)
3736 {
3737   enum rtx_code code;
3738   const char *fmt;
3739   int i, used = 0;
3740
3741   if (! x)
3742     return used;
3743   code = GET_CODE (x);
3744   switch (code)
3745     {
3746     case REG:
3747       if (REGNO (x) < 16)
3748         return (((1 << HARD_REGNO_NREGS (0, GET_MODE (x))) - 1)
3749                 << (REGNO (x) + is_dest));
3750       return 0;
3751     case SUBREG:
3752       {
3753         rtx y = SUBREG_REG (x);
3754
3755         if (GET_CODE (y) != REG)
3756           break;
3757         if (REGNO (y) < 16)
3758           return (((1 << HARD_REGNO_NREGS (0, GET_MODE (x))) - 1)
3759                   << (REGNO (y) +
3760                       subreg_regno_offset (REGNO (y),
3761                                            GET_MODE (y),
3762                                            SUBREG_BYTE (x),
3763                                            GET_MODE (x)) + is_dest));
3764         return 0;
3765       }
3766     case SET:
3767       return regs_used (SET_SRC (x), 0) | regs_used (SET_DEST (x), 16);
3768     case RETURN:
3769       /* If there was a return value, it must have been indicated with USE.  */
3770       return 0x00ffff00;
3771     case CLOBBER:
3772       is_dest = 1;
3773       break;
3774     case MEM:
3775       is_dest = 0;
3776       break;
3777     case CALL:
3778       used |= 0x00ff00f0;
3779       break;
3780     default:
3781       break;
3782     }
3783
3784   fmt = GET_RTX_FORMAT (code);
3785
3786   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
3787     {
3788       if (fmt[i] == 'E')
3789         {
3790           register int j;
3791           for (j = XVECLEN (x, i) - 1; j >= 0; j--)
3792             used |= regs_used (XVECEXP (x, i, j), is_dest);
3793         }
3794       else if (fmt[i] == 'e')
3795         used |= regs_used (XEXP (x, i), is_dest);
3796     }
3797   return used;
3798 }
3799
3800 /* Create an instruction that prevents redirection of a conditional branch
3801    to the destination of the JUMP with address ADDR.
3802    If the branch needs to be implemented as an indirect jump, try to find
3803    a scratch register for it.
3804    If NEED_BLOCK is 0, don't do anything unless we need a scratch register.
3805    If any preceding insn that doesn't fit into a delay slot is good enough,
3806    pass 1.  Pass 2 if a definite blocking insn is needed.
3807    -1 is used internally to avoid deep recursion.
3808    If a blocking instruction is made or recognized, return it.  */
3809
3810 static rtx
3811 gen_block_redirect (rtx jump, int addr, int need_block)
3812 {
3813   int dead = 0;
3814   rtx prev = prev_nonnote_insn (jump);
3815   rtx dest;
3816
3817   /* First, check if we already have an instruction that satisfies our need.  */
3818   if (prev && GET_CODE (prev) == INSN && ! INSN_DELETED_P (prev))
3819     {
3820       if (INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch)
3821         return prev;
3822       if (GET_CODE (PATTERN (prev)) == USE
3823           || GET_CODE (PATTERN (prev)) == CLOBBER
3824           || get_attr_in_delay_slot (prev) == IN_DELAY_SLOT_YES)
3825         prev = jump;
3826       else if ((need_block &= ~1) < 0)
3827         return prev;
3828       else if (recog_memoized (prev) == CODE_FOR_block_branch_redirect)
3829         need_block = 0;
3830     }
3831   if (GET_CODE (PATTERN (jump)) == RETURN)
3832     {
3833       if (! need_block)
3834         return prev;
3835       /* Reorg even does nasty things with return insns that cause branches
3836          to go out of range - see find_end_label and callers.  */
3837       return emit_insn_before (gen_block_branch_redirect (const0_rtx) , jump);
3838     }
3839   /* We can't use JUMP_LABEL here because it might be undefined
3840      when not optimizing.  */
3841   dest = XEXP (SET_SRC (PATTERN (jump)), 0);
3842   /* If the branch is out of range, try to find a scratch register for it.  */
3843   if (optimize
3844       && (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092
3845           > 4092 + 4098))
3846     {
3847       rtx scan;
3848       /* Don't look for the stack pointer as a scratch register,
3849          it would cause trouble if an interrupt occurred.  */
3850       unsigned try = 0x7fff, used;
3851       int jump_left = flag_expensive_optimizations + 1;
3852
3853       /* It is likely that the most recent eligible instruction is wanted for
3854          the delay slot.  Therefore, find out which registers it uses, and
3855          try to avoid using them.  */
3856
3857       for (scan = jump; (scan = PREV_INSN (scan)); )
3858         {
3859           enum rtx_code code;
3860
3861           if (INSN_DELETED_P (scan))
3862             continue;
3863           code = GET_CODE (scan);
3864           if (code == CODE_LABEL || code == JUMP_INSN)
3865             break;
3866           if (code == INSN
3867               && GET_CODE (PATTERN (scan)) != USE
3868               && GET_CODE (PATTERN (scan)) != CLOBBER
3869               && get_attr_in_delay_slot (scan) == IN_DELAY_SLOT_YES)
3870             {
3871               try &= ~regs_used (PATTERN (scan), 0);
3872               break;
3873             }
3874         }
3875       for (used = dead = 0, scan = JUMP_LABEL (jump);
3876            (scan = NEXT_INSN (scan)); )
3877         {
3878           enum rtx_code code;
3879
3880           if (INSN_DELETED_P (scan))
3881             continue;
3882           code = GET_CODE (scan);
3883           if (INSN_P (scan))
3884             {
3885               used |= regs_used (PATTERN (scan), 0);
3886               if (code == CALL_INSN)
3887                 used |= regs_used (CALL_INSN_FUNCTION_USAGE (scan), 0);
3888               dead |= (used >> 16) & ~used;
3889               if (dead & try)
3890                 {
3891                   dead &= try;
3892                   break;
3893                 }
3894               if (code == JUMP_INSN)
3895                 {
3896                   if (jump_left-- && simplejump_p (scan))
3897                     scan = JUMP_LABEL (scan);
3898                   else
3899                     break;
3900                 }
3901             }
3902         }
3903       /* Mask out the stack pointer again, in case it was
3904          the only 'free' register we have found.  */
3905       dead &= 0x7fff;
3906     }
3907   /* If the immediate destination is still in range, check for possible
3908      threading with a jump beyond the delay slot insn.
3909      Don't check if we are called recursively; the jump has been or will be
3910      checked in a different invocation then.  */
3911
3912   else if (optimize && need_block >= 0)
3913     {
3914       rtx next = next_active_insn (next_active_insn (dest));
3915       if (next && GET_CODE (next) == JUMP_INSN
3916           && GET_CODE (PATTERN (next)) == SET
3917           && recog_memoized (next) == CODE_FOR_jump_compact)
3918         {
3919           dest = JUMP_LABEL (next);
3920           if (dest
3921               && (INSN_ADDRESSES (INSN_UID (dest)) - addr + (unsigned) 4092
3922                   > 4092 + 4098))
3923             gen_block_redirect (next, INSN_ADDRESSES (INSN_UID (next)), -1);
3924         }
3925     }
3926
3927   if (dead)
3928     {
3929       rtx reg = gen_rtx_REG (SImode, exact_log2 (dead & -dead));
3930
3931       /* It would be nice if we could convert the jump into an indirect
3932          jump / far branch right now, and thus exposing all constituent
3933          instructions to further optimization.  However, reorg uses
3934          simplejump_p to determine if there is an unconditional jump where
3935          it should try to schedule instructions from the target of the
3936          branch; simplejump_p fails for indirect jumps even if they have
3937          a JUMP_LABEL.  */
3938       rtx insn = emit_insn_before (gen_indirect_jump_scratch
3939                                    (reg, GEN_INT (INSN_UID (JUMP_LABEL (jump))))
3940                                    , jump);
3941       /* ??? We would like this to have the scope of the jump, but that
3942          scope will change when a delay slot insn of an inner scope is added.
3943          Hence, after delay slot scheduling, we'll have to expect
3944          NOTE_INSN_BLOCK_END notes between the indirect_jump_scratch and
3945          the jump.  */
3946
3947       INSN_LOCATOR (insn) = INSN_LOCATOR (jump);
3948       INSN_CODE (insn) = CODE_FOR_indirect_jump_scratch;
3949       return insn;
3950     }
3951   else if (need_block)
3952     /* We can't use JUMP_LABEL here because it might be undefined
3953        when not optimizing.  */
3954     return emit_insn_before (gen_block_branch_redirect
3955                       (GEN_INT (INSN_UID (XEXP (SET_SRC (PATTERN (jump)), 0))))
3956                       , jump);
3957   return prev;
3958 }
3959
3960 #define CONDJUMP_MIN -252
3961 #define CONDJUMP_MAX 262
3962 struct far_branch
3963 {
3964   /* A label (to be placed) in front of the jump
3965      that jumps to our ultimate destination.  */
3966   rtx near_label;
3967   /* Where we are going to insert it if we cannot move the jump any farther,
3968      or the jump itself if we have picked up an existing jump.  */
3969   rtx insert_place;
3970   /* The ultimate destination.  */
3971   rtx far_label;
3972   struct far_branch *prev;
3973   /* If the branch has already been created, its address;
3974      else the address of its first prospective user.  */
3975   int address;
3976 };
3977
3978 static void gen_far_branch (struct far_branch *);
3979 enum mdep_reorg_phase_e mdep_reorg_phase;
3980 static void
3981 gen_far_branch (struct far_branch *bp)
3982 {
3983   rtx insn = bp->insert_place;
3984   rtx jump;
3985   rtx label = gen_label_rtx ();
3986   int ok;
3987
3988   emit_label_after (label, insn);
3989   if (bp->far_label)
3990     {
3991       jump = emit_jump_insn_after (gen_jump (bp->far_label), insn);
3992       LABEL_NUSES (bp->far_label)++;
3993     }
3994   else
3995     jump = emit_jump_insn_after (gen_return (), insn);
3996   /* Emit a barrier so that reorg knows that any following instructions
3997      are not reachable via a fall-through path.
3998      But don't do this when not optimizing, since we wouldn't suppress the
3999      alignment for the barrier then, and could end up with out-of-range
4000      pc-relative loads.  */
4001   if (optimize)
4002     emit_barrier_after (jump);
4003   emit_label_after (bp->near_label, insn);
4004   JUMP_LABEL (jump) = bp->far_label;
4005   ok = invert_jump (insn, label, 1);
4006   gcc_assert (ok);
4007
4008   /* If we are branching around a jump (rather than a return), prevent
4009      reorg from using an insn from the jump target as the delay slot insn -
4010      when reorg did this, it pessimized code (we rather hide the delay slot)
4011      and it could cause branches to go out of range.  */
4012   if (bp->far_label)
4013     (emit_insn_after
4014      (gen_stuff_delay_slot
4015       (GEN_INT (INSN_UID (XEXP (SET_SRC (PATTERN (jump)), 0))),
4016        GEN_INT (recog_memoized (insn) == CODE_FOR_branch_false)),
4017       insn));
4018   /* Prevent reorg from undoing our splits.  */
4019   gen_block_redirect (jump, bp->address += 2, 2);
4020 }
4021
4022 /* Fix up ADDR_DIFF_VECs.  */
4023 void
4024 fixup_addr_diff_vecs (rtx first)
4025 {
4026   rtx insn;
4027
4028   for (insn = first; insn; insn = NEXT_INSN (insn))
4029     {
4030       rtx vec_lab, pat, prev, prevpat, x, braf_label;
4031
4032       if (GET_CODE (insn) != JUMP_INSN
4033           || GET_CODE (PATTERN (insn)) != ADDR_DIFF_VEC)
4034         continue;
4035       pat = PATTERN (insn);
4036       vec_lab = XEXP (XEXP (pat, 0), 0);
4037
4038       /* Search the matching casesi_jump_2.  */
4039       for (prev = vec_lab; ; prev = PREV_INSN (prev))
4040         {
4041           if (GET_CODE (prev) != JUMP_INSN)
4042             continue;
4043           prevpat = PATTERN (prev);
4044           if (GET_CODE (prevpat) != PARALLEL || XVECLEN (prevpat, 0) != 2)
4045             continue;
4046           x = XVECEXP (prevpat, 0, 1);
4047