OSDN Git Service

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