OSDN Git Service

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