OSDN Git Service

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