OSDN Git Service

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