OSDN Git Service

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