OSDN Git Service

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