gcc/config/sh/sh.c

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