OSDN Git Service

* config/sh/sh.c (prepare_cbranch_operands): Use
[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 == LAST_AND_UNUSED_RTX_CODE)
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     add_reg_note (jump, REG_BR_PROB, GEN_INT (probability));
1482
1483 }
1484
1485 /* ??? How should we distribute probabilities when more than one branch
1486    is generated.  So far we only have soem ad-hoc observations:
1487    - If the operands are random, they are likely to differ in both parts.
1488    - If comparing items in a hash chain, the operands are random or equal;
1489      operation should be EQ or NE.
1490    - If items are searched in an ordered tree from the root, we can expect
1491      the highpart to be unequal about half of the time; operation should be
1492      an inequality comparison, operands non-constant, and overall probability
1493      about 50%.  Likewise for quicksort.
1494    - Range checks will be often made against constants.  Even if we assume for
1495      simplicity an even distribution of the non-constant operand over a
1496      sub-range here, the same probability could be generated with differently
1497      wide sub-ranges - as long as the ratio of the part of the subrange that
1498      is before the threshold to the part that comes after the threshold stays
1499      the same.  Thus, we can't really tell anything here;
1500      assuming random distribution is at least simple.
1501  */
1502
1503 bool
1504 expand_cbranchdi4 (rtx *operands, enum rtx_code comparison)
1505 {
1506   enum rtx_code msw_taken, msw_skip, lsw_taken;
1507   rtx skip_label = NULL_RTX;
1508   rtx op1h, op1l, op2h, op2l;
1509   int num_branches;
1510   int prob, rev_prob;
1511   int msw_taken_prob = -1, msw_skip_prob = -1, lsw_taken_prob = -1;
1512   rtx scratch = operands[4];
1513
1514   comparison = prepare_cbranch_operands (operands, DImode, comparison);
1515   op1h = gen_highpart_mode (SImode, DImode, operands[1]);
1516   op2h = gen_highpart_mode (SImode, DImode, operands[2]);
1517   op1l = gen_lowpart (SImode, operands[1]);
1518   op2l = gen_lowpart (SImode, operands[2]);
1519   msw_taken = msw_skip = lsw_taken = LAST_AND_UNUSED_RTX_CODE;
1520   prob = split_branch_probability;
1521   rev_prob = REG_BR_PROB_BASE - prob;
1522   switch (comparison)
1523     {
1524     /* ??? Should we use the cmpeqdi_t pattern for equality comparisons?
1525        That costs 1 cycle more when the first branch can be predicted taken,
1526        but saves us mispredicts because only one branch needs prediction.
1527        It also enables generating the cmpeqdi_t-1 pattern.  */
1528     case EQ:
1529       if (TARGET_CMPEQDI_T)
1530         {
1531           emit_insn (gen_cmpeqdi_t (operands[1], operands[2]));
1532           emit_jump_insn (gen_branch_true (operands[3]));
1533           return true;
1534         }
1535       msw_skip = NE;
1536       lsw_taken = EQ;
1537       if (prob >= 0)
1538         {
1539           /* If we had more precision, we'd use rev_prob - (rev_prob >> 32) .
1540            */
1541           msw_skip_prob = rev_prob;
1542           if (REG_BR_PROB_BASE <= 65535)
1543             lsw_taken_prob = prob ? REG_BR_PROB_BASE : 0;
1544           else
1545             {
1546               gcc_assert (HOST_BITS_PER_WIDEST_INT >= 64);
1547               lsw_taken_prob
1548                 = (prob
1549                    ? (REG_BR_PROB_BASE
1550                       - ((HOST_WIDEST_INT) REG_BR_PROB_BASE * rev_prob
1551                          / ((HOST_WIDEST_INT) prob << 32)))
1552                    : 0);
1553             }
1554         }
1555       break;
1556     case NE:
1557       if (TARGET_CMPEQDI_T)
1558         {
1559           emit_insn (gen_cmpeqdi_t (operands[1], operands[2]));
1560           emit_jump_insn (gen_branch_false (operands[3]));
1561           return true;
1562         }
1563       msw_taken = NE;
1564       msw_taken_prob = prob;
1565       lsw_taken = NE;
1566       lsw_taken_prob = 0;
1567       break;
1568     case GTU: case GT:
1569       msw_taken = comparison;
1570       if (GET_CODE (op2l) == CONST_INT && INTVAL (op2l) == -1)
1571         break;
1572       if (comparison != GTU || op2h != CONST0_RTX (SImode))
1573         msw_skip = swap_condition (msw_taken);
1574       lsw_taken = GTU;
1575       break;
1576     case GEU: case GE:
1577       if (op2l == CONST0_RTX (SImode))
1578         msw_taken = comparison;
1579       else
1580         {
1581           msw_taken = comparison == GE ? GT : GTU;
1582           msw_skip = swap_condition (msw_taken);
1583           lsw_taken = GEU;
1584         }
1585       break;
1586     case LTU: case LT:
1587       msw_taken = comparison;
1588       if (op2l == CONST0_RTX (SImode))
1589         break;
1590       msw_skip = swap_condition (msw_taken);
1591       lsw_taken = LTU;
1592       break;
1593     case LEU: case LE:
1594       if (GET_CODE (op2l) == CONST_INT && INTVAL (op2l) == -1)
1595         msw_taken = comparison;
1596       else
1597         {
1598           lsw_taken = LEU;
1599           if (comparison == LE)
1600             msw_taken = LT;
1601           else if (op2h != CONST0_RTX (SImode))
1602             msw_taken = LTU;
1603           else
1604             break;
1605           msw_skip = swap_condition (msw_taken);
1606         }
1607       break;
1608     default: return false;
1609     }
1610   num_branches = ((msw_taken != LAST_AND_UNUSED_RTX_CODE)
1611                   + (msw_skip != LAST_AND_UNUSED_RTX_CODE)
1612                   + (lsw_taken != LAST_AND_UNUSED_RTX_CODE));
1613   if (comparison != EQ && comparison != NE && num_branches > 1)
1614     {
1615       if (!CONSTANT_P (operands[2])
1616           && prob >= (int) (REG_BR_PROB_BASE * 3 / 8U)
1617           && prob <= (int) (REG_BR_PROB_BASE * 5 / 8U))
1618         {
1619           msw_taken_prob = prob / 2U;
1620           msw_skip_prob
1621             = REG_BR_PROB_BASE * rev_prob / (REG_BR_PROB_BASE + rev_prob);
1622           lsw_taken_prob = prob;
1623         }
1624       else
1625         {
1626           msw_taken_prob = prob;
1627           msw_skip_prob = REG_BR_PROB_BASE;
1628           /* ??? If we have a constant op2h, should we use that when
1629              calculating lsw_taken_prob?  */
1630           lsw_taken_prob = prob;
1631         }
1632     }
1633   operands[1] = op1h;
1634   operands[2] = op2h;
1635   operands[4] = NULL_RTX;
1636   if (reload_completed
1637       && ! arith_reg_or_0_operand (op2h, SImode) && true_regnum (op1h)
1638       && (msw_taken != LAST_AND_UNUSED_RTX_CODE
1639           || msw_skip != LAST_AND_UNUSED_RTX_CODE))
1640     {
1641       emit_move_insn (scratch, operands[2]);
1642       operands[2] = scratch;
1643     }
1644   if (msw_taken != LAST_AND_UNUSED_RTX_CODE)
1645     expand_cbranchsi4 (operands, msw_taken, msw_taken_prob);
1646   if (msw_skip != LAST_AND_UNUSED_RTX_CODE)
1647     {
1648       rtx taken_label = operands[3];
1649
1650       /* Operands were possibly modified, but msw_skip doesn't expect this.
1651          Always use the original ones.  */
1652       if (msw_taken != LAST_AND_UNUSED_RTX_CODE)
1653         {
1654           operands[1] = op1h;
1655           operands[2] = op2h;
1656         }
1657
1658       operands[3] = skip_label = gen_label_rtx ();
1659       expand_cbranchsi4 (operands, msw_skip, msw_skip_prob);
1660       operands[3] = taken_label;
1661     }
1662   operands[1] = op1l;
1663   operands[2] = op2l;
1664   if (lsw_taken != LAST_AND_UNUSED_RTX_CODE)
1665     {
1666       if (reload_completed
1667           && ! arith_reg_or_0_operand (op2l, SImode) && true_regnum (op1l))
1668         operands[4] = scratch;
1669       expand_cbranchsi4 (operands, lsw_taken, lsw_taken_prob);
1670     }
1671   if (msw_skip != LAST_AND_UNUSED_RTX_CODE)
1672     emit_label (skip_label);
1673   return true;
1674 }
1675
1676 /* Prepare the operands for an scc instruction; make sure that the
1677    compare has been done.  */
1678 rtx
1679 prepare_scc_operands (enum rtx_code code)
1680 {
1681   rtx t_reg = gen_rtx_REG (SImode, T_REG);
1682   enum rtx_code oldcode = code;
1683   enum machine_mode mode;
1684
1685   /* First need a compare insn.  */
1686   switch (code)
1687     {
1688     case NE:
1689       /* It isn't possible to handle this case.  */
1690       gcc_unreachable ();
1691     case LT:
1692       code = GT;
1693       break;
1694     case LE:
1695       code = GE;
1696       break;
1697     case LTU:
1698       code = GTU;
1699       break;
1700     case LEU:
1701       code = GEU;
1702       break;
1703     default:
1704       break;
1705     }
1706   if (code != oldcode)
1707     {
1708       rtx tmp = sh_compare_op0;
1709       sh_compare_op0 = sh_compare_op1;
1710       sh_compare_op1 = tmp;
1711     }
1712
1713   mode = GET_MODE (sh_compare_op0);
1714   if (mode == VOIDmode)
1715     mode = GET_MODE (sh_compare_op1);
1716
1717   sh_compare_op0 = force_reg (mode, sh_compare_op0);
1718   if ((code != EQ && code != NE
1719        && (sh_compare_op1 != const0_rtx
1720            || code == GTU  || code == GEU || code == LTU || code == LEU))
1721       || (mode == DImode && sh_compare_op1 != const0_rtx)
1722       || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1723     sh_compare_op1 = force_reg (mode, sh_compare_op1);
1724
1725   if ((TARGET_SH4 || TARGET_SH2A) && GET_MODE_CLASS (mode) == MODE_FLOAT)
1726     (mode == SFmode ? emit_sf_insn : emit_df_insn)
1727      (gen_rtx_PARALLEL (VOIDmode, gen_rtvec (2,
1728                 gen_rtx_SET (VOIDmode, t_reg,
1729                              gen_rtx_fmt_ee (code, SImode,
1730                                              sh_compare_op0, sh_compare_op1)),
1731                 gen_rtx_USE (VOIDmode, get_fpscr_rtx ()))));
1732   else
1733     emit_insn (gen_rtx_SET (VOIDmode, t_reg,
1734                             gen_rtx_fmt_ee (code, SImode,
1735                                             sh_compare_op0, sh_compare_op1)));
1736
1737   return t_reg;
1738 }
1739
1740 /* Called from the md file, set up the operands of a compare instruction.  */
1741
1742 void
1743 from_compare (rtx *operands, int code)
1744 {
1745   enum machine_mode mode = GET_MODE (sh_compare_op0);
1746   rtx insn;
1747   if (mode == VOIDmode)
1748     mode = GET_MODE (sh_compare_op1);
1749   if (code != EQ
1750       || mode == DImode
1751       || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1752     {
1753       /* Force args into regs, since we can't use constants here.  */
1754       sh_compare_op0 = force_reg (mode, sh_compare_op0);
1755       if (sh_compare_op1 != const0_rtx
1756           || code == GTU  || code == GEU
1757           || (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT))
1758         sh_compare_op1 = force_reg (mode, sh_compare_op1);
1759     }
1760   if (TARGET_SH2E && GET_MODE_CLASS (mode) == MODE_FLOAT && code == GE)
1761     {
1762       from_compare (operands, GT);
1763       insn = gen_ieee_ccmpeqsf_t (sh_compare_op0, sh_compare_op1);
1764     }
1765   else
1766     insn = gen_rtx_SET (VOIDmode,
1767                         gen_rtx_REG (SImode, T_REG),
1768                         gen_rtx_fmt_ee ((enum rtx_code) code, SImode,
1769                                         sh_compare_op0, sh_compare_op1));
1770   if ((TARGET_SH4 || TARGET_SH2A) && GET_MODE_CLASS (mode) == MODE_FLOAT)
1771     {
1772       insn = gen_rtx_PARALLEL (VOIDmode,
1773                       gen_rtvec (2, insn,
1774                                  gen_rtx_USE (VOIDmode, get_fpscr_rtx ())));
1775       (mode == SFmode ? emit_sf_insn : emit_df_insn) (insn);
1776     }
1777   else
1778     emit_insn (insn);
1779 }
1780 \f
1781 /* Functions to output assembly code.  */
1782
1783 /* Return a sequence of instructions to perform DI or DF move.
1784
1785    Since the SH cannot move a DI or DF in one instruction, we have
1786    to take care when we see overlapping source and dest registers.  */
1787
1788 const char *
1789 output_movedouble (rtx insn ATTRIBUTE_UNUSED, rtx operands[],
1790                    enum machine_mode mode)
1791 {
1792   rtx dst = operands[0];
1793   rtx src = operands[1];
1794
1795   if (GET_CODE (dst) == MEM
1796       && GET_CODE (XEXP (dst, 0)) == PRE_DEC)
1797     return "mov.l       %T1,%0\n\tmov.l %1,%0";
1798
1799   if (register_operand (dst, mode)
1800       && register_operand (src, mode))
1801     {
1802       if (REGNO (src) == MACH_REG)
1803         return "sts     mach,%S0\n\tsts macl,%R0";
1804
1805       /* When mov.d r1,r2 do r2->r3 then r1->r2;
1806          when mov.d r1,r0 do r1->r0 then r2->r1.  */
1807
1808       if (REGNO (src) + 1 == REGNO (dst))
1809         return "mov     %T1,%T0\n\tmov  %1,%0";
1810       else
1811         return "mov     %1,%0\n\tmov    %T1,%T0";
1812     }
1813   else if (GET_CODE (src) == CONST_INT)
1814     {
1815       if (INTVAL (src) < 0)
1816         output_asm_insn ("mov   #-1,%S0", operands);
1817       else
1818         output_asm_insn ("mov   #0,%S0", operands);
1819
1820       return "mov       %1,%R0";
1821     }
1822   else if (GET_CODE (src) == MEM)
1823     {
1824       int ptrreg = -1;
1825       int dreg = REGNO (dst);
1826       rtx inside = XEXP (src, 0);
1827
1828       switch (GET_CODE (inside))
1829         {
1830         case REG:
1831           ptrreg = REGNO (inside);
1832           break;
1833
1834         case SUBREG:
1835           ptrreg = subreg_regno (inside);
1836           break;
1837
1838         case PLUS:
1839           ptrreg = REGNO (XEXP (inside, 0));
1840           /* ??? A r0+REG address shouldn't be possible here, because it isn't
1841              an offsettable address.  Unfortunately, offsettable addresses use
1842              QImode to check the offset, and a QImode offsettable address
1843              requires r0 for the other operand, which is not currently
1844              supported, so we can't use the 'o' constraint.
1845              Thus we must check for and handle r0+REG addresses here.
1846              We punt for now, since this is likely very rare.  */
1847           gcc_assert (GET_CODE (XEXP (inside, 1)) != REG);
1848           break;
1849           
1850         case LABEL_REF:
1851           return "mov.l %1,%0\n\tmov.l  %1+4,%T0";
1852         case POST_INC:
1853           return "mov.l %1,%0\n\tmov.l  %1,%T0";
1854         default:
1855           gcc_unreachable ();
1856         }
1857
1858       /* Work out the safe way to copy.  Copy into the second half first.  */
1859       if (dreg == ptrreg)
1860         return "mov.l   %T1,%T0\n\tmov.l        %1,%0";
1861     }
1862
1863   return "mov.l %1,%0\n\tmov.l  %T1,%T0";
1864 }
1865
1866 /* Print an instruction which would have gone into a delay slot after
1867    another instruction, but couldn't because the other instruction expanded
1868    into a sequence where putting the slot insn at the end wouldn't work.  */
1869
1870 static void
1871 print_slot (rtx insn)
1872 {
1873   final_scan_insn (XVECEXP (insn, 0, 1), asm_out_file, optimize, 1, NULL);
1874
1875   INSN_DELETED_P (XVECEXP (insn, 0, 1)) = 1;
1876 }
1877
1878 const char *
1879 output_far_jump (rtx insn, rtx op)
1880 {
1881   struct { rtx lab, reg, op; } this_jmp;
1882   rtx braf_base_lab = NULL_RTX;
1883   const char *jump;
1884   int far;
1885   int offset = branch_dest (insn) - INSN_ADDRESSES (INSN_UID (insn));
1886   rtx prev;
1887
1888   this_jmp.lab = gen_label_rtx ();
1889
1890   if (TARGET_SH2
1891       && offset >= -32764
1892       && offset - get_attr_length (insn) <= 32766)
1893     {
1894       far = 0;
1895       jump = "mov.w     %O0,%1; braf    %1";
1896     }
1897   else
1898     {
1899       far = 1;
1900       if (flag_pic)
1901         {
1902           if (TARGET_SH2)
1903             jump = "mov.l       %O0,%1; braf    %1";
1904           else
1905             jump = "mov.l       r0,@-r15; mova  %O0,r0; mov.l   @r0,%1; add     r0,%1; mov.l    @r15+,r0; jmp   @%1";
1906         }
1907       else
1908         jump = "mov.l   %O0,%1; jmp     @%1";
1909     }
1910   /* If we have a scratch register available, use it.  */
1911   if (GET_CODE ((prev = prev_nonnote_insn (insn))) == INSN
1912       && INSN_CODE (prev) == CODE_FOR_indirect_jump_scratch)
1913     {
1914       this_jmp.reg = SET_DEST (XVECEXP (PATTERN (prev), 0, 0));
1915       if (REGNO (this_jmp.reg) == R0_REG && flag_pic && ! TARGET_SH2)
1916         jump = "mov.l   r1,@-r15; mova  %O0,r0; mov.l   @r0,r1; add     r1,r0; mov.l    @r15+,r1; jmp   @%1";
1917       output_asm_insn (jump, &this_jmp.lab);
1918       if (dbr_sequence_length ())
1919         print_slot (final_sequence);
1920       else
1921         output_asm_insn ("nop", 0);
1922     }
1923   else
1924     {
1925       /* Output the delay slot insn first if any.  */
1926       if (dbr_sequence_length ())
1927         print_slot (final_sequence);
1928
1929       this_jmp.reg = gen_rtx_REG (SImode, 13);
1930       /* We must keep the stack aligned to 8-byte boundaries on SH5.
1931          Fortunately, MACL is fixed and call-clobbered, and we never
1932          need its value across jumps, so save r13 in it instead of in
1933          the stack.  */
1934       if (TARGET_SH5)
1935         output_asm_insn ("lds   r13, macl", 0);
1936       else
1937         output_asm_insn ("mov.l r13,@-r15", 0);
1938       output_asm_insn (jump, &this_jmp.lab);
1939       if (TARGET_SH5)
1940         output_asm_insn ("sts   macl, r13", 0);
1941       else
1942         output_asm_insn ("mov.l @r15+,r13", 0);
1943     }
1944   if (far && flag_pic && TARGET_SH2)
1945     {
1946       braf_base_lab = gen_label_rtx ();
1947       (*targetm.asm_out.internal_label) (asm_out_file, "L",
1948                                  CODE_LABEL_NUMBER (braf_base_lab));
1949     }
1950   if (far)
1951     output_asm_insn (".align    2", 0);
1952   (*targetm.asm_out.internal_label) (asm_out_file, "L", CODE_LABEL_NUMBER (this_jmp.lab));
1953   this_jmp.op = op;
1954   if (far && flag_pic)
1955     {
1956       if (TARGET_SH2)
1957         this_jmp.lab = braf_base_lab;
1958       output_asm_insn (".long   %O2-%O0", &this_jmp.lab);
1959     }
1960   else
1961     output_asm_insn (far ? ".long       %O2" : ".word %O2-%O0", &this_jmp.lab);
1962   return "";
1963 }
1964
1965 /* Local label counter, used for constants in the pool and inside
1966    pattern branches.  */
1967
1968 static int lf = 100;
1969
1970 /* Output code for ordinary branches.  */
1971
1972 const char *
1973 output_branch (int logic, rtx insn, rtx *operands)
1974 {
1975   switch (get_attr_length (insn))
1976     {
1977     case 6:
1978       /* This can happen if filling the delay slot has caused a forward
1979          branch to exceed its range (we could reverse it, but only
1980          when we know we won't overextend other branches; this should
1981          best be handled by relaxation).
1982          It can also happen when other condbranches hoist delay slot insn
1983          from their destination, thus leading to code size increase.
1984          But the branch will still be in the range -4092..+4098 bytes.  */
1985
1986       if (! TARGET_RELAX)
1987         {
1988           int label = lf++;
1989           /* The call to print_slot will clobber the operands.  */
1990           rtx op0 = operands[0];
1991
1992           /* If the instruction in the delay slot is annulled (true), then
1993              there is no delay slot where we can put it now.  The only safe
1994              place for it is after the label.  final will do that by default.  */
1995
1996           if (final_sequence
1997               && ! INSN_ANNULLED_BRANCH_P (XVECEXP (final_sequence, 0, 0))
1998               && get_attr_length (XVECEXP (final_sequence, 0, 1)))
1999             {
2000               asm_fprintf (asm_out_file, "\tb%s%ss\t%LLF%d\n", logic ? "f" : "t",
2001                            ASSEMBLER_DIALECT ? "/" : ".", label);
2002               print_slot (final_sequence);
2003             }
2004           else
2005             asm_fprintf (asm_out_file, "\tb%s\t%LLF%d\n", logic ? "f" : "t", label);
2006
2007           output_asm_insn ("bra\t%l0", &op0);
2008           fprintf (asm_out_file, "\tnop\n");
2009           (*targetm.asm_out.internal_label) (asm_out_file, "LF", label);
2010
2011           return "";
2012         }
2013       /* When relaxing, handle this like a short branch.  The linker
2014          will fix it up if it still doesn't fit after relaxation.  */
2015     case 2:
2016       return logic ? "bt%.\t%l0" : "bf%.\t%l0";
2017
2018       /* These are for SH2e, in which we have to account for the
2019          extra nop because of the hardware bug in annulled branches.  */
2020     case 8:
2021       if (! TARGET_RELAX)
2022         {
2023           int label = lf++;
2024
2025           gcc_assert (!final_sequence
2026                       || !(INSN_ANNULLED_BRANCH_P
2027                            (XVECEXP (final_sequence, 0, 0))));
2028           asm_fprintf (asm_out_file, "b%s%ss\t%LLF%d\n",
2029                        logic ? "f" : "t",
2030                        ASSEMBLER_DIALECT ? "/" : ".", label);
2031           fprintf (asm_out_file, "\tnop\n");
2032           output_asm_insn ("bra\t%l0", operands);
2033           fprintf (asm_out_file, "\tnop\n");
2034           (*targetm.asm_out.internal_label) (asm_out_file, "LF", label);
2035
2036           return "";
2037         }
2038       /* When relaxing, fall through.  */
2039     case 4:
2040       {
2041         char buffer[10];
2042
2043         sprintf (buffer, "b%s%ss\t%%l0",
2044                  logic ? "t" : "f",
2045                  ASSEMBLER_DIALECT ? "/" : ".");
2046         output_asm_insn (buffer, &operands[0]);
2047         return "nop";
2048       }
2049
2050     default:
2051       /* There should be no longer branches now - that would
2052          indicate that something has destroyed the branches set
2053          up in machine_dependent_reorg.  */
2054       gcc_unreachable ();
2055     }
2056 }
2057
2058 /* Output a code sequence for INSN using TEMPL with OPERANDS; but before,
2059    fill in operands 9 as a label to the successor insn.
2060    We try to use jump threading where possible.
2061    IF CODE matches the comparison in the IF_THEN_ELSE of a following jump,
2062    we assume the jump is taken.  I.e. EQ means follow jmp and bf, NE means
2063    follow jmp and bt, if the address is in range.  */
2064 const char *
2065 output_branchy_insn (enum rtx_code code, const char *templ,
2066                      rtx insn, rtx *operands)
2067 {
2068   rtx next_insn = NEXT_INSN (insn);
2069
2070   if (next_insn && GET_CODE (next_insn) == JUMP_INSN && condjump_p (next_insn))
2071     {
2072       rtx src = SET_SRC (PATTERN (next_insn));
2073       if (GET_CODE (src) == IF_THEN_ELSE && GET_CODE (XEXP (src, 0)) != code)
2074         {
2075           /* Following branch not taken */
2076           operands[9] = gen_label_rtx ();
2077           emit_label_after (operands[9], next_insn);
2078           INSN_ADDRESSES_NEW (operands[9],
2079                               INSN_ADDRESSES (INSN_UID (next_insn))
2080                               + get_attr_length (next_insn));
2081           return templ;
2082         }
2083       else
2084         {
2085           int offset = (branch_dest (next_insn)
2086                         - INSN_ADDRESSES (INSN_UID (next_insn)) + 4);
2087           if (offset >= -252 && offset <= 258)
2088             {
2089               if (GET_CODE (src) == IF_THEN_ELSE)
2090                 /* branch_true */
2091                 src = XEXP (src, 1);
2092               operands[9] = src;
2093               return templ;
2094             }
2095         }
2096     }
2097   operands[9] = gen_label_rtx ();
2098   emit_label_after (operands[9], insn);
2099   INSN_ADDRESSES_NEW (operands[9],
2100                       INSN_ADDRESSES (INSN_UID (insn))
2101                       + get_attr_length (insn));
2102   return templ;
2103 }
2104
2105 const char *
2106 output_ieee_ccmpeq (rtx insn, rtx *operands)
2107 {
2108   return output_branchy_insn (NE, "bt\t%l9\n\tfcmp/eq\t%1,%0",
2109                               insn, operands);
2110 }
2111 \f
2112 /* Output the start of the assembler file.  */
2113
2114 static void
2115 sh_file_start (void)
2116 {
2117   default_file_start ();
2118
2119 #ifdef SYMBIAN
2120   /* Declare the .directive section before it is used.  */
2121   fputs ("\t.section .directive, \"SM\", @progbits, 1\n", asm_out_file);
2122   fputs ("\t.asciz \"#<SYMEDIT>#\\n\"\n", asm_out_file);
2123 #endif
2124
2125   if (TARGET_ELF)
2126     /* We need to show the text section with the proper
2127        attributes as in TEXT_SECTION_ASM_OP, before dwarf2out
2128        emits it without attributes in TEXT_SECTION_ASM_OP, else GAS
2129        will complain.  We can teach GAS specifically about the
2130        default attributes for our choice of text section, but
2131        then we would have to change GAS again if/when we change
2132        the text section name.  */
2133     fprintf (asm_out_file, "%s\n", TEXT_SECTION_ASM_OP);
2134   else
2135     /* Switch to the data section so that the coffsem symbol
2136        isn't in the text section.  */
2137     switch_to_section (data_section);
2138
2139   if (TARGET_LITTLE_ENDIAN)
2140     fputs ("\t.little\n", asm_out_file);
2141
2142   if (!TARGET_ELF)
2143     {
2144       if (TARGET_SHCOMPACT)
2145         fputs ("\t.mode\tSHcompact\n", asm_out_file);
2146       else if (TARGET_SHMEDIA)
2147         fprintf (asm_out_file, "\t.mode\tSHmedia\n\t.abi\t%i\n",
2148                  TARGET_SHMEDIA64 ? 64 : 32);
2149     }
2150 }
2151 \f
2152 /* Check if PAT includes UNSPEC_CALLER unspec pattern.  */
2153
2154 static bool
2155 unspec_caller_rtx_p (rtx pat)
2156 {
2157   rtx base, offset;
2158   int i;
2159
2160   split_const (pat, &base, &offset);
2161   if (GET_CODE (base) == UNSPEC)
2162     {
2163       if (XINT (base, 1) == UNSPEC_CALLER)
2164         return true;
2165       for (i = 0; i < XVECLEN (base, 0); i++)
2166         if (unspec_caller_rtx_p (XVECEXP (base, 0, i)))
2167           return true;
2168     }
2169   return false;
2170 }
2171
2172 /* Indicate that INSN cannot be duplicated.  This is true for insn
2173    that generates a unique label.  */
2174
2175 static bool
2176 sh_cannot_copy_insn_p (rtx insn)
2177 {
2178   rtx pat;
2179
2180   if (!reload_completed || !flag_pic)
2181     return false;
2182
2183   if (GET_CODE (insn) != INSN)
2184     return false;
2185   if (asm_noperands (insn) >= 0)
2186     return false;
2187
2188   pat = PATTERN (insn);
2189   if (GET_CODE (pat) != SET)
2190     return false;
2191   pat = SET_SRC (pat);
2192
2193   if (unspec_caller_rtx_p (pat))
2194     return true;
2195
2196   return false;
2197 }
2198 \f
2199 /* Actual number of instructions used to make a shift by N.  */
2200 static const char ashiftrt_insns[] =
2201   { 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};
2202
2203 /* Left shift and logical right shift are the same.  */
2204 static const char shift_insns[]    =
2205   { 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};
2206
2207 /* Individual shift amounts needed to get the above length sequences.
2208    One bit right shifts clobber the T bit, so when possible, put one bit
2209    shifts in the middle of the sequence, so the ends are eligible for
2210    branch delay slots.  */
2211 static const short shift_amounts[32][5] = {
2212   {0}, {1}, {2}, {2, 1},
2213   {2, 2}, {2, 1, 2}, {2, 2, 2}, {2, 2, 1, 2},
2214   {8}, {8, 1}, {8, 2}, {8, 1, 2},
2215   {8, 2, 2}, {8, 2, 1, 2}, {8, -2, 8}, {8, -1, 8},
2216   {16}, {16, 1}, {16, 2}, {16, 1, 2},
2217   {16, 2, 2}, {16, 2, 1, 2}, {16, -2, 8}, {16, -1, 8},
2218   {16, 8}, {16, 1, 8}, {16, 8, 2}, {16, 8, 1, 2},
2219   {16, 8, 2, 2}, {16, -1, -2, 16}, {16, -2, 16}, {16, -1, 16}};
2220
2221 /* Likewise, but for shift amounts < 16, up to three highmost bits
2222    might be clobbered.  This is typically used when combined with some
2223    kind of sign or zero extension.  */
2224
2225 static const char ext_shift_insns[]    =
2226   { 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};
2227
2228 static const short ext_shift_amounts[32][4] = {
2229   {0}, {1}, {2}, {2, 1},
2230   {2, 2}, {2, 1, 2}, {8, -2}, {8, -1},
2231   {8}, {8, 1}, {8, 2}, {8, 1, 2},
2232   {8, 2, 2}, {16, -2, -1}, {16, -2}, {16, -1},
2233   {16}, {16, 1}, {16, 2}, {16, 1, 2},
2234   {16, 2, 2}, {16, 2, 1, 2}, {16, -2, 8}, {16, -1, 8},
2235   {16, 8}, {16, 1, 8}, {16, 8, 2}, {16, 8, 1, 2},
2236   {16, 8, 2, 2}, {16, -1, -2, 16}, {16, -2, 16}, {16, -1, 16}};
2237
2238 /* Assuming we have a value that has been sign-extended by at least one bit,
2239    can we use the ext_shift_amounts with the last shift turned to an arithmetic shift
2240    to shift it by N without data loss, and quicker than by other means?  */
2241 #define EXT_SHIFT_SIGNED(n) (((n) | 8) == 15)
2242
2243 /* This is used in length attributes in sh.md to help compute the length
2244    of arbitrary constant shift instructions.  */
2245
2246 int
2247 shift_insns_rtx (rtx insn)
2248 {
2249   rtx set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
2250   int shift_count = INTVAL (XEXP (set_src, 1));
2251   enum rtx_code shift_code = GET_CODE (set_src);
2252
2253   switch (shift_code)
2254     {
2255     case ASHIFTRT:
2256       return ashiftrt_insns[shift_count];
2257     case LSHIFTRT:
2258     case ASHIFT:
2259       return shift_insns[shift_count];
2260     default:
2261       gcc_unreachable ();
2262     }
2263 }
2264
2265 /* Return the cost of a shift.  */
2266
2267 static inline int
2268 shiftcosts (rtx x)
2269 {
2270   int value;
2271
2272   if (TARGET_SHMEDIA)
2273     return 1;
2274
2275   if (GET_MODE_SIZE (GET_MODE (x)) > UNITS_PER_WORD)
2276     {
2277       if (GET_MODE (x) == DImode
2278           && GET_CODE (XEXP (x, 1)) == CONST_INT
2279           && INTVAL (XEXP (x, 1)) == 1)
2280         return 2;
2281
2282       /* Everything else is invalid, because there is no pattern for it.  */
2283       return MAX_COST;
2284     }
2285   /* If shift by a non constant, then this will be expensive.  */
2286   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2287     return SH_DYNAMIC_SHIFT_COST;
2288
2289   value = INTVAL (XEXP (x, 1));
2290
2291   /* Otherwise, return the true cost in instructions.  */
2292   if (GET_CODE (x) == ASHIFTRT)
2293     {
2294       int cost = ashiftrt_insns[value];
2295       /* If SH3, then we put the constant in a reg and use shad.  */
2296       if (cost > 1 + SH_DYNAMIC_SHIFT_COST)
2297         cost = 1 + SH_DYNAMIC_SHIFT_COST;
2298       return cost;
2299     }
2300   else
2301     return shift_insns[value];
2302 }
2303
2304 /* Return the cost of an AND operation.  */
2305
2306 static inline int
2307 andcosts (rtx x)
2308 {
2309   int i;
2310
2311   /* Anding with a register is a single cycle and instruction.  */
2312   if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2313     return 1;
2314
2315   i = INTVAL (XEXP (x, 1));
2316
2317   if (TARGET_SHMEDIA)
2318     {
2319       if (satisfies_constraint_I10 (XEXP (x, 1))
2320           || satisfies_constraint_J16 (XEXP (x, 1)))
2321         return 1;
2322       else
2323         return 1 + rtx_cost (XEXP (x, 1), AND, !optimize_size);
2324     }
2325
2326   /* These constants are single cycle extu.[bw] instructions.  */
2327   if (i == 0xff || i == 0xffff)
2328     return 1;
2329   /* Constants that can be used in an and immediate instruction in a single
2330      cycle, but this requires r0, so make it a little more expensive.  */
2331   if (CONST_OK_FOR_K08 (i))
2332     return 2;
2333   /* Constants that can be loaded with a mov immediate and an and.
2334      This case is probably unnecessary.  */
2335   if (CONST_OK_FOR_I08 (i))
2336     return 2;
2337   /* Any other constants requires a 2 cycle pc-relative load plus an and.
2338      This case is probably unnecessary.  */
2339   return 3;
2340 }
2341
2342 /* Return the cost of an addition or a subtraction.  */
2343
2344 static inline int
2345 addsubcosts (rtx x)
2346 {
2347   /* Adding a register is a single cycle insn.  */
2348   if (GET_CODE (XEXP (x, 1)) == REG
2349       || GET_CODE (XEXP (x, 1)) == SUBREG)
2350     return 1;
2351
2352   /* Likewise for small constants.  */
2353   if (GET_CODE (XEXP (x, 1)) == CONST_INT
2354       && CONST_OK_FOR_ADD (INTVAL (XEXP (x, 1))))
2355     return 1;
2356
2357   if (TARGET_SHMEDIA)
2358     switch (GET_CODE (XEXP (x, 1)))
2359       {
2360       case CONST:
2361       case LABEL_REF:
2362       case SYMBOL_REF:
2363         return TARGET_SHMEDIA64 ? 5 : 3;
2364
2365       case CONST_INT:
2366         if (CONST_OK_FOR_I16 (INTVAL (XEXP (x, 1))))
2367           return 2;
2368         else if (CONST_OK_FOR_I16 (INTVAL (XEXP (x, 1)) >> 16))
2369           return 3;
2370         else if (CONST_OK_FOR_I16 ((INTVAL (XEXP (x, 1)) >> 16) >> 16))
2371           return 4;
2372
2373         /* Fall through.  */
2374       default:
2375         return 5;
2376       }
2377
2378   /* Any other constant requires a 2 cycle pc-relative load plus an
2379      addition.  */
2380   return 3;
2381 }
2382
2383 /* Return the cost of a multiply.  */
2384 static inline int
2385 multcosts (rtx x ATTRIBUTE_UNUSED)
2386 {
2387   if (sh_multcost >= 0)
2388     return sh_multcost;
2389   if (TARGET_SHMEDIA)
2390     /* ??? We have a mul insn, but it has a latency of three, and doesn't
2391        accept constants.  Ideally, we would use a cost of one or two and
2392        add the cost of the operand, but disregard the latter when inside loops
2393        and loop invariant code motion is still to follow.
2394        Using a multiply first and splitting it later if it's a loss
2395        doesn't work because of different sign / zero extension semantics
2396        of multiplies vs. shifts.  */
2397     return TARGET_SMALLCODE ? 2 : 3;
2398
2399   if (TARGET_SH2)
2400     {
2401       /* We have a mul insn, so we can never take more than the mul and the
2402          read of the mac reg, but count more because of the latency and extra
2403          reg usage.  */
2404       if (TARGET_SMALLCODE)
2405         return 2;
2406       return 3;
2407     }
2408
2409   /* If we're aiming at small code, then just count the number of
2410      insns in a multiply call sequence.  */
2411   if (TARGET_SMALLCODE)
2412     return 5;
2413
2414   /* Otherwise count all the insns in the routine we'd be calling too.  */
2415   return 20;
2416 }
2417
2418 /* Compute a (partial) cost for rtx X.  Return true if the complete
2419    cost has been computed, and false if subexpressions should be
2420    scanned.  In either case, *TOTAL contains the cost result.  */
2421
2422 static bool
2423 sh_rtx_costs (rtx x, int code, int outer_code, int *total,
2424               bool speed ATTRIBUTE_UNUSED)
2425 {
2426   switch (code)
2427     {
2428     case CONST_INT:
2429       if (TARGET_SHMEDIA)
2430         {
2431           if (INTVAL (x) == 0)
2432             *total = 0;
2433           else if (outer_code == AND && and_operand ((x), DImode))
2434             *total = 0;
2435           else if ((outer_code == IOR || outer_code == XOR
2436                     || outer_code == PLUS)
2437                    && CONST_OK_FOR_I10 (INTVAL (x)))
2438             *total = 0;
2439           else if (CONST_OK_FOR_I16 (INTVAL (x)))
2440             *total = COSTS_N_INSNS (outer_code != SET);
2441           else if (CONST_OK_FOR_I16 (INTVAL (x) >> 16))
2442             *total = COSTS_N_INSNS ((outer_code != SET) + 1);
2443           else if (CONST_OK_FOR_I16 ((INTVAL (x) >> 16) >> 16))
2444             *total = COSTS_N_INSNS ((outer_code != SET) + 2);
2445           else
2446             *total = COSTS_N_INSNS ((outer_code != SET) + 3);
2447           return true;
2448         }
2449       if (CONST_OK_FOR_I08 (INTVAL (x)))
2450         *total = 0;
2451       else if ((outer_code == AND || outer_code == IOR || outer_code == XOR)
2452                && CONST_OK_FOR_K08 (INTVAL (x)))
2453         *total = 1;
2454       /* prepare_cmp_insn will force costly constants int registers before
2455          the cbranch[sd]i4 patterns can see them, so preserve potentially
2456          interesting ones not covered by I08 above.  */
2457       else if (outer_code == COMPARE
2458                && ((unsigned HOST_WIDE_INT) INTVAL (x)
2459                     == (unsigned HOST_WIDE_INT) 0x7fffffff + 1
2460                     || INTVAL (x) == 0x7fffffff
2461                    || INTVAL (x) == 0x80 || INTVAL (x) == -0x81))
2462         *total = 1;
2463       else
2464         *total = 8;
2465       return true;
2466
2467     case CONST:
2468     case LABEL_REF:
2469     case SYMBOL_REF:
2470       if (TARGET_SHMEDIA64)
2471         *total = COSTS_N_INSNS (4);
2472       else if (TARGET_SHMEDIA32)
2473         *total = COSTS_N_INSNS (2);
2474       else
2475         *total = 5;
2476       return true;
2477
2478     case CONST_DOUBLE:
2479       if (TARGET_SHMEDIA)
2480         *total = COSTS_N_INSNS (4);
2481       /* prepare_cmp_insn will force costly constants int registers before
2482          the cbranchdi4 pattern can see them, so preserve potentially
2483          interesting ones.  */
2484       else if (outer_code == COMPARE && GET_MODE (x) == DImode)
2485         *total = 1;
2486       else
2487         *total = 10;
2488       return true;
2489     case CONST_VECTOR:
2490       if (x == CONST0_RTX (GET_MODE (x)))
2491         *total = 0;
2492       else if (sh_1el_vec (x, VOIDmode))
2493         *total = outer_code != SET;
2494       if (sh_rep_vec (x, VOIDmode))
2495         *total = ((GET_MODE_UNIT_SIZE (GET_MODE (x)) + 3) / 4
2496                   + (outer_code != SET));
2497       *total = COSTS_N_INSNS (3) + (outer_code != SET);
2498       return true;
2499
2500     case PLUS:
2501     case MINUS:
2502       *total = COSTS_N_INSNS (addsubcosts (x));
2503       return true;
2504
2505     case AND:
2506       *total = COSTS_N_INSNS (andcosts (x));
2507       return true;
2508
2509     case MULT:
2510       *total = COSTS_N_INSNS (multcosts (x));
2511       return true;
2512
2513     case ASHIFT:
2514     case ASHIFTRT:
2515     case LSHIFTRT:
2516       *total = COSTS_N_INSNS (shiftcosts (x));
2517       return true;
2518
2519     case DIV:
2520     case UDIV:
2521     case MOD:
2522     case UMOD:
2523       *total = COSTS_N_INSNS (20);
2524       return true;
2525
2526     case PARALLEL:
2527       if (sh_1el_vec (x, VOIDmode))
2528         *total = outer_code != SET;
2529       if (sh_rep_vec (x, VOIDmode))
2530         *total = ((GET_MODE_UNIT_SIZE (GET_MODE (x)) + 3) / 4
2531                   + (outer_code != SET));
2532       *total = COSTS_N_INSNS (3) + (outer_code != SET);
2533       return true;
2534
2535     case FLOAT:
2536     case FIX:
2537       *total = 100;
2538       return true;
2539
2540     default:
2541       return false;
2542     }
2543 }
2544
2545 /* Compute the cost of an address.  For the SH, all valid addresses are
2546    the same cost.  Use a slightly higher cost for reg + reg addressing,
2547    since it increases pressure on r0.  */
2548
2549 static int
2550 sh_address_cost (rtx X,
2551                  bool speed ATTRIBUTE_UNUSED)
2552 {
2553   return (GET_CODE (X) == PLUS
2554           && ! CONSTANT_P (XEXP (X, 1))
2555           && ! TARGET_SHMEDIA ? 1 : 0);
2556 }
2557
2558 /* Code to expand a shift.  */
2559
2560 void
2561 gen_ashift (int type, int n, rtx reg)
2562 {
2563   /* Negative values here come from the shift_amounts array.  */
2564   if (n < 0)
2565     {
2566       if (type == ASHIFT)
2567         type = LSHIFTRT;
2568       else
2569         type = ASHIFT;
2570       n = -n;
2571     }
2572
2573   switch (type)
2574     {
2575     case ASHIFTRT:
2576       emit_insn (gen_ashrsi3_k (reg, reg, GEN_INT (n)));
2577       break;
2578     case LSHIFTRT:
2579       if (n == 1)
2580         emit_insn (gen_lshrsi3_m (reg, reg, GEN_INT (n)));
2581       else
2582         emit_insn (gen_lshrsi3_k (reg, reg, GEN_INT (n)));
2583       break;
2584     case ASHIFT:
2585       emit_insn (gen_ashlsi3_std (reg, reg, GEN_INT (n)));
2586       break;
2587     }
2588 }
2589
2590 /* Same for HImode */
2591
2592 void
2593 gen_ashift_hi (int type, int n, rtx reg)
2594 {
2595   /* Negative values here come from the shift_amounts array.  */
2596   if (n < 0)
2597     {
2598       if (type == ASHIFT)
2599         type = LSHIFTRT;
2600       else
2601         type = ASHIFT;
2602       n = -n;
2603     }
2604
2605   switch (type)
2606     {
2607     case ASHIFTRT:
2608     case LSHIFTRT:
2609       /* We don't have HImode right shift operations because using the
2610          ordinary 32 bit shift instructions for that doesn't generate proper
2611          zero/sign extension.
2612          gen_ashift_hi is only called in contexts where we know that the
2613          sign extension works out correctly.  */
2614       {
2615         int offset = 0;
2616         if (GET_CODE (reg) == SUBREG)
2617           {
2618             offset = SUBREG_BYTE (reg);
2619             reg = SUBREG_REG (reg);
2620           }
2621         gen_ashift (type, n, gen_rtx_SUBREG (SImode, reg, offset));
2622         break;
2623       }
2624     case ASHIFT:
2625       emit_insn (gen_ashlhi3_k (reg, reg, GEN_INT (n)));
2626       break;
2627     }
2628 }
2629
2630 /* Output RTL to split a constant shift into its component SH constant
2631    shift instructions.  */
2632
2633 void
2634 gen_shifty_op (int code, rtx *operands)
2635 {
2636   int value = INTVAL (operands[2]);
2637   int max, i;
2638
2639   /* Truncate the shift count in case it is out of bounds.  */
2640   value = value & 0x1f;
2641
2642   if (value == 31)
2643     {
2644       if (code == LSHIFTRT)
2645         {
2646           emit_insn (gen_rotlsi3_1 (operands[0], operands[0]));
2647           emit_insn (gen_movt (operands[0]));
2648           return;
2649         }
2650       else if (code == ASHIFT)
2651         {
2652           /* There is a two instruction sequence for 31 bit left shifts,
2653              but it requires r0.  */
2654           if (GET_CODE (operands[0]) == REG && REGNO (operands[0]) == 0)
2655             {
2656               emit_insn (gen_andsi3 (operands[0], operands[0], const1_rtx));
2657               emit_insn (gen_rotlsi3_31 (operands[0], operands[0]));
2658               return;
2659             }
2660         }
2661     }
2662   else if (value == 0)
2663     {
2664       /* This can happen even when optimizing, if there were subregs before
2665          reload.  Don't output a nop here, as this is never optimized away;
2666          use a no-op move instead.  */
2667       emit_insn (gen_rtx_SET (VOIDmode, operands[0], operands[0]));
2668       return;
2669     }
2670
2671   max = shift_insns[value];
2672   for (i = 0; i < max; i++)
2673     gen_ashift (code, shift_amounts[value][i], operands[0]);
2674 }
2675
2676 /* Same as above, but optimized for values where the topmost bits don't
2677    matter.  */
2678
2679 void
2680 gen_shifty_hi_op (int code, rtx *operands)
2681 {
2682   int value = INTVAL (operands[2]);
2683   int max, i;
2684   void (*gen_fun) (int, int, rtx);
2685
2686   /* This operation is used by and_shl for SImode values with a few
2687      high bits known to be cleared.  */
2688   value &= 31;
2689   if (value == 0)
2690     {
2691       emit_insn (gen_nop ());
2692       return;
2693     }
2694
2695   gen_fun = GET_MODE (operands[0]) == HImode ? gen_ashift_hi : gen_ashift;
2696   if (code == ASHIFT)
2697     {
2698       max = ext_shift_insns[value];
2699       for (i = 0; i < max; i++)
2700         gen_fun (code, ext_shift_amounts[value][i], operands[0]);
2701     }
2702   else
2703     /* When shifting right, emit the shifts in reverse order, so that
2704        solitary negative values come first.  */
2705     for (i = ext_shift_insns[value] - 1; i >= 0; i--)
2706       gen_fun (code, ext_shift_amounts[value][i], operands[0]);
2707 }
2708
2709 /* Output RTL for an arithmetic right shift.  */
2710
2711 /* ??? Rewrite to use super-optimizer sequences.  */
2712
2713 int
2714 expand_ashiftrt (rtx *operands)
2715 {
2716   rtx wrk;
2717   char func[18];
2718   int value;
2719
2720   if (TARGET_SH3)
2721     {
2722       if (GET_CODE (operands[2]) != CONST_INT)
2723         {
2724           rtx count = copy_to_mode_reg (SImode, operands[2]);
2725           emit_insn (gen_negsi2 (count, count));
2726           emit_insn (gen_ashrsi3_d (operands[0], operands[1], count));
2727           return 1;
2728         }
2729       else if (ashiftrt_insns[INTVAL (operands[2]) & 31]
2730                > 1 + SH_DYNAMIC_SHIFT_COST)
2731         {
2732           rtx count
2733             = force_reg (SImode, GEN_INT (- (INTVAL (operands[2]) & 31)));
2734           emit_insn (gen_ashrsi3_d (operands[0], operands[1], count));
2735           return 1;
2736         }
2737     }
2738   if (GET_CODE (operands[2]) != CONST_INT)
2739     return 0;
2740
2741   value = INTVAL (operands[2]) & 31;
2742
2743   if (value == 31)
2744     {
2745       /* If we are called from abs expansion, arrange things so that we
2746          we can use a single MT instruction that doesn't clobber the source,
2747          if LICM can hoist out the load of the constant zero.  */
2748       if (currently_expanding_to_rtl)
2749         {
2750           emit_insn (gen_cmpgtsi_t (force_reg (SImode, CONST0_RTX (SImode)),
2751                                     operands[1]));
2752           emit_insn (gen_mov_neg_si_t (operands[0]));
2753           return 1;
2754         }
2755       emit_insn (gen_ashrsi2_31 (operands[0], operands[1]));
2756       return 1;
2757     }
2758   else if (value >= 16 && value <= 19)
2759     {
2760       wrk = gen_reg_rtx (SImode);
2761       emit_insn (gen_ashrsi2_16 (wrk, operands[1]));
2762       value -= 16;
2763       while (value--)
2764         gen_ashift (ASHIFTRT, 1, wrk);
2765       emit_move_insn (operands[0], wrk);
2766       return 1;
2767     }
2768   /* Expand a short sequence inline, longer call a magic routine.  */
2769   else if (value <= 5)
2770     {
2771       wrk = gen_reg_rtx (SImode);
2772       emit_move_insn (wrk, operands[1]);
2773       while (value--)
2774         gen_ashift (ASHIFTRT, 1, wrk);
2775       emit_move_insn (operands[0], wrk);
2776       return 1;
2777     }
2778
2779   wrk = gen_reg_rtx (Pmode);
2780
2781   /* Load the value into an arg reg and call a helper.  */
2782   emit_move_insn (gen_rtx_REG (SImode, 4), operands[1]);
2783   sprintf (func, "__ashiftrt_r4_%d", value);
2784   function_symbol (wrk, func, SFUNC_STATIC);
2785   emit_insn (gen_ashrsi3_n (GEN_INT (value), wrk));
2786   emit_move_insn (operands[0], gen_rtx_REG (SImode, 4));
2787   return 1;
2788 }
2789
2790 int
2791 sh_dynamicalize_shift_p (rtx count)
2792 {
2793   return shift_insns[INTVAL (count)] > 1 + SH_DYNAMIC_SHIFT_COST;
2794 }
2795
2796 /* Try to find a good way to implement the combiner pattern
2797   [(set (match_operand:SI 0 "register_operand" "r")
2798         (and:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
2799                            (match_operand:SI 2 "const_int_operand" "n"))
2800                 (match_operand:SI 3 "const_int_operand" "n"))) .
2801   LEFT_RTX is operand 2 in the above pattern, and MASK_RTX is operand 3.
2802   return 0 for simple right / left or left/right shift combination.
2803   return 1 for a combination of shifts with zero_extend.
2804   return 2 for a combination of shifts with an AND that needs r0.
2805   return 3 for a combination of shifts with an AND that needs an extra
2806     scratch register, when the three highmost bits of the AND mask are clear.
2807   return 4 for a combination of shifts with an AND that needs an extra
2808     scratch register, when any of the three highmost bits of the AND mask
2809     is set.
2810   If ATTRP is set, store an initial right shift width in ATTRP[0],
2811   and the instruction length in ATTRP[1] .  These values are not valid
2812   when returning 0.
2813   When ATTRP is set and returning 1, ATTRP[2] gets set to the index into
2814   shift_amounts for the last shift value that is to be used before the
2815   sign extend.  */
2816 int
2817 shl_and_kind (rtx left_rtx, rtx mask_rtx, int *attrp)
2818 {
2819   unsigned HOST_WIDE_INT mask, lsb, mask2, lsb2;
2820   int left = INTVAL (left_rtx), right;
2821   int best = 0;
2822   int cost, best_cost = 10000;
2823   int best_right = 0, best_len = 0;
2824   int i;
2825   int can_ext;
2826
2827   if (left < 0 || left > 31)
2828     return 0;
2829   if (GET_CODE (mask_rtx) == CONST_INT)
2830     mask = (unsigned HOST_WIDE_INT) INTVAL (mask_rtx) >> left;
2831   else
2832     mask = (unsigned HOST_WIDE_INT) GET_MODE_MASK (SImode) >> left;
2833   /* Can this be expressed as a right shift / left shift pair?  */
2834   lsb = ((mask ^ (mask - 1)) >> 1) + 1;
2835   right = exact_log2 (lsb);
2836   mask2 = ~(mask + lsb - 1);
2837   lsb2 = ((mask2 ^ (mask2 - 1)) >> 1) + 1;
2838   /* mask has no zeroes but trailing zeroes <==> ! mask2 */
2839   if (! mask2)
2840     best_cost = shift_insns[right] + shift_insns[right + left];
2841   /* mask has no trailing zeroes <==> ! right */
2842   else if (! right && mask2 == ~(lsb2 - 1))
2843     {
2844       int late_right = exact_log2 (lsb2);
2845       best_cost = shift_insns[left + late_right] + shift_insns[late_right];
2846     }
2847   /* Try to use zero extend.  */
2848   if (mask2 == ~(lsb2 - 1))
2849     {
2850       int width, first;
2851
2852       for (width = 8; width <= 16; width += 8)
2853         {
2854           /* Can we zero-extend right away?  */
2855           if (lsb2 == (unsigned HOST_WIDE_INT) 1 << width)
2856             {
2857               cost
2858                 = 1 + ext_shift_insns[right] + ext_shift_insns[left + right];
2859               if (cost < best_cost)
2860                 {
2861                   best = 1;
2862                   best_cost = cost;
2863                   best_right = right;
2864                   best_len = cost;
2865                   if (attrp)
2866                     attrp[2] = -1;
2867                 }
2868               continue;
2869             }
2870           /* ??? Could try to put zero extend into initial right shift,
2871              or even shift a bit left before the right shift.  */
2872           /* Determine value of first part of left shift, to get to the
2873              zero extend cut-off point.  */
2874           first = width - exact_log2 (lsb2) + right;
2875           if (first >= 0 && right + left - first >= 0)
2876             {
2877               cost = ext_shift_insns[right] + ext_shift_insns[first] + 1
2878                 + ext_shift_insns[right + left - first];
2879               if (cost < best_cost)
2880                 {
2881                   best = 1;
2882                   best_cost = cost;
2883                   best_right = right;
2884                   best_len = cost;
2885                   if (attrp)
2886                     attrp[2] = first;
2887                 }
2888             }
2889         }
2890     }
2891   /* Try to use r0 AND pattern */
2892   for (i = 0; i <= 2; i++)
2893     {
2894       if (i > right)
2895         break;
2896       if (! CONST_OK_FOR_K08 (mask >> i))
2897         continue;
2898       cost = (i != 0) + 2 + ext_shift_insns[left + i];
2899       if (cost < best_cost)
2900         {
2901           best = 2;
2902           best_cost = cost;
2903           best_right = i;
2904           best_len = cost - 1;
2905         }
2906     }
2907   /* Try to use a scratch register to hold the AND operand.  */
2908   can_ext = ((mask << left) & ((unsigned HOST_WIDE_INT) 3 << 30)) == 0;
2909   for (i = 0; i <= 2; i++)
2910     {
2911       if (i > right)
2912         break;
2913       cost = (i != 0) + (CONST_OK_FOR_I08 (mask >> i) ? 2 : 3)
2914         + (can_ext ? ext_shift_insns : shift_insns)[left + i];
2915       if (cost < best_cost)
2916         {
2917           best = 4 - can_ext;
2918           best_cost = cost;
2919           best_right = i;
2920           best_len = cost - 1 - ! CONST_OK_FOR_I08 (mask >> i);
2921         }
2922     }
2923
2924   if (attrp)
2925     {
2926       attrp[0] = best_right;
2927       attrp[1] = best_len;
2928     }
2929   return best;
2930 }
2931
2932 /* This is used in length attributes of the unnamed instructions
2933    corresponding to shl_and_kind return values of 1 and 2.  */
2934 int
2935 shl_and_length (rtx insn)
2936 {
2937   rtx set_src, left_rtx, mask_rtx;
2938   int attributes[3];
2939
2940   set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
2941   left_rtx = XEXP (XEXP (set_src, 0), 1);
2942   mask_rtx = XEXP (set_src, 1);
2943   shl_and_kind (left_rtx, mask_rtx, attributes);
2944   return attributes[1];
2945 }
2946
2947 /* This is used in length attribute of the and_shl_scratch instruction.  */
2948
2949 int
2950 shl_and_scr_length (rtx insn)
2951 {
2952   rtx set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
2953   int len = shift_insns[INTVAL (XEXP (set_src, 1))];
2954   rtx op = XEXP (set_src, 0);
2955   len += shift_insns[INTVAL (XEXP (op, 1))] + 1;
2956   op = XEXP (XEXP (op, 0), 0);
2957   return len + shift_insns[INTVAL (XEXP (op, 1))];
2958 }
2959
2960 /* Generate rtl for instructions for which shl_and_kind advised a particular
2961    method of generating them, i.e. returned zero.  */
2962
2963 int
2964 gen_shl_and (rtx dest, rtx left_rtx, rtx mask_rtx, rtx source)
2965 {
2966   int attributes[3];
2967   unsigned HOST_WIDE_INT mask;
2968   int kind = shl_and_kind (left_rtx, mask_rtx, attributes);
2969   int right, total_shift;
2970   void (*shift_gen_fun) (int, rtx *) = gen_shifty_hi_op;
2971
2972   right = attributes[0];
2973   total_shift = INTVAL (left_rtx) + right;
2974   mask = (unsigned HOST_WIDE_INT) INTVAL (mask_rtx) >> total_shift;
2975   switch (kind)
2976     {
2977     default:
2978       return -1;
2979     case 1:
2980       {
2981         int first = attributes[2];
2982         rtx operands[3];
2983
2984         if (first < 0)
2985           {
2986             emit_insn ((mask << right) <= 0xff
2987                        ? gen_zero_extendqisi2 (dest,
2988                                                gen_lowpart (QImode, source))
2989                        : gen_zero_extendhisi2 (dest,
2990                                                gen_lowpart (HImode, source)));
2991             source = dest;
2992           }
2993         if (source != dest)
2994           emit_insn (gen_movsi (dest, source));
2995         operands[0] = dest;
2996         if (right)
2997           {
2998             operands[2] = GEN_INT (right);
2999             gen_shifty_hi_op (LSHIFTRT, operands);
3000           }
3001         if (first > 0)
3002           {
3003             operands[2] = GEN_INT (first);
3004             gen_shifty_hi_op (ASHIFT, operands);
3005             total_shift -= first;
3006             mask <<= first;
3007           }
3008         if (first >= 0)
3009           emit_insn (mask <= 0xff
3010                      ? gen_zero_extendqisi2 (dest, gen_lowpart (QImode, dest))
3011                      : gen_zero_extendhisi2 (dest, gen_lowpart (HImode, dest)));
3012         if (total_shift > 0)
3013           {
3014             operands[2] = GEN_INT (total_shift);
3015             gen_shifty_hi_op (ASHIFT, operands);
3016           }
3017         break;
3018       }
3019     case 4:
3020       shift_gen_fun = gen_shifty_op;
3021     case 3:
3022       /* If the topmost bit that matters is set, set the topmost bits
3023          that don't matter.  This way, we might be able to get a shorter
3024          signed constant.  */
3025       if (mask & ((HOST_WIDE_INT) 1 << (31 - total_shift)))
3026         mask |= (HOST_WIDE_INT) ~0 << (31 - total_shift);
3027     case 2:
3028       /* Don't expand fine-grained when combining, because that will
3029          make the pattern fail.  */
3030       if (currently_expanding_to_rtl
3031           || reload_in_progress || reload_completed)
3032         {
3033           rtx operands[3];
3034
3035           /* Cases 3 and 4 should be handled by this split
3036              only while combining  */
3037           gcc_assert (kind <= 2);
3038           if (right)
3039             {
3040               emit_insn (gen_lshrsi3 (dest, source, GEN_INT (right)));
3041               source = dest;
3042             }
3043           emit_insn (gen_andsi3 (dest, source, GEN_INT (mask)));
3044           if (total_shift)
3045             {
3046               operands[0] = dest;
3047               operands[1] = dest;
3048               operands[2] = GEN_INT (total_shift);
3049               shift_gen_fun (ASHIFT, operands);
3050             }
3051           break;
3052         }
3053       else
3054         {
3055           int neg = 0;
3056           if (kind != 4 && total_shift < 16)
3057             {
3058               neg = -ext_shift_amounts[total_shift][1];
3059               if (neg > 0)
3060                 neg -= ext_shift_amounts[total_shift][2];
3061               else
3062                 neg = 0;
3063             }
3064           emit_insn (gen_and_shl_scratch (dest, source,
3065                                           GEN_INT (right),
3066                                           GEN_INT (mask),
3067                                           GEN_INT (total_shift + neg),
3068                                           GEN_INT (neg)));
3069           emit_insn (gen_movsi (dest, dest));
3070           break;
3071         }
3072     }
3073   return 0;
3074 }
3075
3076 /* Try to find a good way to implement the combiner pattern
3077   [(set (match_operand:SI 0 "register_operand" "=r")
3078         (sign_extract:SI (ashift:SI (match_operand:SI 1 "register_operand" "r")
3079                                     (match_operand:SI 2 "const_int_operand" "n")
3080                          (match_operand:SI 3 "const_int_operand" "n")
3081                          (const_int 0)))
3082    (clobber (reg:SI T_REG))]
3083   LEFT_RTX is operand 2 in the above pattern, and SIZE_RTX is operand 3.
3084   return 0 for simple left / right shift combination.
3085   return 1 for left shift / 8 bit sign extend / left shift.
3086   return 2 for left shift / 16 bit sign extend / left shift.
3087   return 3 for left shift / 8 bit sign extend / shift / sign extend.
3088   return 4 for left shift / 16 bit sign extend / shift / sign extend.
3089   return 5 for left shift / 16 bit sign extend / right shift
3090   return 6 for < 8 bit sign extend / left shift.
3091   return 7 for < 8 bit sign extend / left shift / single right shift.
3092   If COSTP is nonzero, assign the calculated cost to *COSTP.  */
3093
3094 int
3095 shl_sext_kind (rtx left_rtx, rtx size_rtx, int *costp)
3096 {
3097   int left, size, insize, ext;
3098   int cost = 0, best_cost;
3099   int kind;
3100
3101   left = INTVAL (left_rtx);
3102   size = INTVAL (size_rtx);
3103   insize = size - left;
3104   gcc_assert (insize > 0);
3105   /* Default to left / right shift.  */
3106   kind = 0;
3107   best_cost = shift_insns[32 - insize] + ashiftrt_insns[32 - size];
3108   if (size <= 16)
3109     {
3110       /* 16 bit shift / sign extend / 16 bit shift */
3111       cost = shift_insns[16 - insize] + 1 + ashiftrt_insns[16 - size];
3112       /* If ashiftrt_insns[16 - size] is 8, this choice will be overridden
3113          below, by alternative 3 or something even better.  */
3114       if (cost < best_cost)
3115         {
3116           kind = 5;
3117           best_cost = cost;
3118         }
3119     }
3120   /* Try a plain sign extend between two shifts.  */
3121   for (ext = 16; ext >= insize; ext -= 8)
3122     {
3123       if (ext <= size)
3124         {
3125           cost = ext_shift_insns[ext - insize] + 1 + shift_insns[size - ext];
3126           if (cost < best_cost)
3127             {
3128               kind = ext / (unsigned) 8;
3129               best_cost = cost;
3130             }
3131         }
3132       /* Check if we can do a sloppy shift with a final signed shift
3133          restoring the sign.  */
3134       if (EXT_SHIFT_SIGNED (size - ext))
3135         cost = ext_shift_insns[ext - insize] + ext_shift_insns[size - ext] + 1;
3136       /* If not, maybe it's still cheaper to do the second shift sloppy,
3137          and do a final sign extend?  */
3138       else if (size <= 16)
3139         cost = ext_shift_insns[ext - insize] + 1
3140           + ext_shift_insns[size > ext ? size - ext : ext - size] + 1;
3141       else
3142         continue;
3143       if (cost < best_cost)
3144         {
3145           kind = ext / (unsigned) 8 + 2;
3146           best_cost = cost;
3147         }
3148     }
3149   /* Check if we can sign extend in r0 */
3150   if (insize < 8)
3151     {
3152       cost = 3 + shift_insns[left];
3153       if (cost < best_cost)
3154         {
3155           kind = 6;
3156           best_cost = cost;
3157         }
3158       /* Try the same with a final signed shift.  */
3159       if (left < 31)
3160         {
3161           cost = 3 + ext_shift_insns[left + 1] + 1;
3162           if (cost < best_cost)
3163             {
3164               kind = 7;
3165               best_cost = cost;
3166             }
3167         }
3168     }
3169   if (TARGET_SH3)
3170     {
3171       /* Try to use a dynamic shift.  */
3172       cost = shift_insns[32 - insize] + 1 + SH_DYNAMIC_SHIFT_COST;
3173       if (cost < best_cost)
3174         {
3175           kind = 0;
3176           best_cost = cost;
3177         }
3178     }
3179   if (costp)
3180     *costp = cost;
3181   return kind;
3182 }
3183
3184 /* Function to be used in the length attribute of the instructions
3185    implementing this pattern.  */
3186
3187 int
3188 shl_sext_length (rtx insn)
3189 {
3190   rtx set_src, left_rtx, size_rtx;
3191   int cost;
3192
3193   set_src = SET_SRC (XVECEXP (PATTERN (insn), 0, 0));
3194   left_rtx = XEXP (XEXP (set_src, 0), 1);
3195   size_rtx = XEXP (set_src, 1);
3196   shl_sext_kind (left_rtx, size_rtx, &cost);
3197   return cost;
3198 }
3199
3200 /* Generate rtl for this pattern */
3201
3202 int
3203 gen_shl_sext (rtx dest, rtx left_rtx, rtx size_rtx, rtx source)
3204 {
3205   int kind;
3206   int left, size, insize, cost;
3207   rtx operands[3];
3208
3209   kind = shl_sext_kind (left_rtx, size_rtx, &cost);
3210   left = INTVAL (left_rtx);
3211   size = INTVAL (size_rtx);
3212   insize = size - left;
3213   switch (kind)
3214     {
3215     case 1:
3216     case 2:
3217     case 3:
3218     case 4:
3219       {
3220         int ext = kind & 1 ? 8 : 16;
3221         int shift2 = size - ext;
3222
3223         /* Don't expand fine-grained when combining, because that will
3224            make the pattern fail.  */
3225         if (! currently_expanding_to_rtl
3226             && ! reload_in_progress && ! reload_completed)
3227           {
3228             emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
3229             emit_insn (gen_movsi (dest, source));
3230             break;
3231           }
3232         if (dest != source)
3233           emit_insn (gen_movsi (dest, source));
3234         operands[0] = dest;
3235         if (ext - insize)
3236           {
3237             operands[2] = GEN_INT (ext - insize);
3238             gen_shifty_hi_op (ASHIFT, operands);
3239           }
3240         emit_insn (kind & 1
3241                    ? gen_extendqisi2 (dest, gen_lowpart (QImode, dest))
3242                    : gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
3243         if (kind <= 2)
3244           {
3245             if (shift2)
3246               {
3247                 operands[2] = GEN_INT (shift2);
3248                 gen_shifty_op (ASHIFT, operands);
3249               }
3250           }
3251         else
3252           {
3253             if (shift2 > 0)
3254               {
3255                 if (EXT_SHIFT_SIGNED (shift2))
3256                   {
3257                     operands[2] = GEN_INT (shift2 + 1);
3258                     gen_shifty_op (ASHIFT, operands);
3259                     operands[2] = const1_rtx;
3260                     gen_shifty_op (ASHIFTRT, operands);
3261                     break;
3262                   }
3263                 operands[2] = GEN_INT (shift2);
3264                 gen_shifty_hi_op (ASHIFT, operands);
3265               }
3266             else if (shift2)
3267               {
3268                 operands[2] = GEN_INT (-shift2);
3269                 gen_shifty_hi_op (LSHIFTRT, operands);
3270               }
3271             emit_insn (size <= 8
3272                        ? gen_extendqisi2 (dest, gen_lowpart (QImode, dest))
3273                        : gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
3274           }
3275         break;
3276       }
3277     case 5:
3278       {
3279         int i = 16 - size;
3280         if (! currently_expanding_to_rtl
3281             && ! reload_in_progress && ! reload_completed)
3282           emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
3283         else
3284           {
3285             operands[0] = dest;
3286             operands[2] = GEN_INT (16 - insize);
3287             gen_shifty_hi_op (ASHIFT, operands);
3288             emit_insn (gen_extendhisi2 (dest, gen_lowpart (HImode, dest)));
3289           }
3290         /* Don't use gen_ashrsi3 because it generates new pseudos.  */
3291         while (--i >= 0)
3292           gen_ashift (ASHIFTRT, 1, dest);
3293         break;
3294       }
3295     case 6:
3296     case 7:
3297       /* Don't expand fine-grained when combining, because that will
3298          make the pattern fail.  */
3299       if (! currently_expanding_to_rtl
3300           && ! reload_in_progress && ! reload_completed)
3301         {
3302           emit_insn (gen_shl_sext_ext (dest, source, left_rtx, size_rtx));
3303           emit_insn (gen_movsi (dest, source));
3304           break;
3305         }
3306       emit_insn (gen_andsi3 (dest, source, GEN_INT ((1 << insize) - 1)));
3307       emit_insn (gen_xorsi3 (dest, dest, GEN_INT (1 << (insize - 1))));
3308       emit_insn (gen_addsi3 (dest, dest, GEN_INT (-1 << (insize - 1))));
3309       operands[0] = dest;
3310       operands[2] = kind == 7 ? GEN_INT (left + 1) : left_rtx;
3311       gen_shifty_op (ASHIFT, operands);
3312       if (kind == 7)
3313         emit_insn (gen_ashrsi3_k (dest, dest, const1_rtx));
3314       break;
3315     default:
3316       return -1;
3317     }
3318   return 0;
3319 }
3320
3321 /* Prefix a symbol_ref name with "datalabel".  */
3322
3323 rtx
3324 gen_datalabel_ref (rtx sym)
3325 {
3326   const char *str;
3327
3328   if (GET_CODE (sym) == LABEL_REF)
3329     return gen_rtx_CONST (GET_MODE (sym),
3330                           gen_rtx_UNSPEC (GET_MODE (sym),
3331                                           gen_rtvec (1, sym),
3332                                           UNSPEC_DATALABEL));
3333
3334   gcc_assert (GET_CODE (sym) == SYMBOL_REF);
3335
3336   str = XSTR (sym, 0);
3337   /* Share all SYMBOL_REF strings with the same value - that is important
3338      for cse.  */
3339   str = IDENTIFIER_POINTER (get_identifier (str));
3340   XSTR (sym, 0) = str;
3341
3342   return sym;
3343 }
3344
3345 \f
3346 static alloc_pool label_ref_list_pool;
3347
3348 typedef struct label_ref_list_d
3349 {
3350   rtx label;
3351   struct label_ref_list_d *next;
3352 } *label_ref_list_t;
3353
3354 /* The SH cannot load a large constant into a register, constants have to
3355    come from a pc relative load.  The reference of a pc relative load
3356    instruction must be less than 1k in front of the instruction.  This
3357    means that we often have to dump a constant inside a function, and
3358    generate code to branch around it.
3359
3360    It is important to minimize this, since the branches will slow things
3361    down and make things bigger.
3362
3363    Worst case code looks like:
3364
3365    mov.l L1,rn
3366    bra   L2
3367    nop
3368    align
3369    L1:   .long value
3370    L2:
3371    ..
3372
3373    mov.l L3,rn
3374    bra   L4
3375    nop
3376    align
3377    L3:   .long value
3378    L4:
3379    ..
3380
3381    We fix this by performing a scan before scheduling, which notices which
3382    instructions need to have their operands fetched from the constant table
3383    and builds the table.
3384
3385    The algorithm is:
3386
3387    scan, find an instruction which needs a pcrel move.  Look forward, find the
3388    last barrier which is within MAX_COUNT bytes of the requirement.
3389    If there isn't one, make one.  Process all the instructions between
3390    the find and the barrier.
3391
3392    In the above example, we can tell that L3 is within 1k of L1, so
3393    the first move can be shrunk from the 3 insn+constant sequence into
3394    just 1 insn, and the constant moved to L3 to make:
3395
3396    mov.l        L1,rn
3397    ..
3398    mov.l        L3,rn
3399    bra          L4
3400    nop
3401    align
3402    L3:.long value
3403    L4:.long value
3404
3405    Then the second move becomes the target for the shortening process.  */
3406
3407 typedef struct
3408 {
3409   rtx value;                    /* Value in table.  */
3410   rtx label;                    /* Label of value.  */
3411   label_ref_list_t wend;        /* End of window.  */
3412   enum machine_mode mode;       /* Mode of value.  */
3413
3414   /* True if this constant is accessed as part of a post-increment
3415      sequence.  Note that HImode constants are never accessed in this way.  */
3416   bool part_of_sequence_p;
3417 } pool_node;
3418
3419 /* The maximum number of constants that can fit into one pool, since
3420    constants in the range 0..510 are at least 2 bytes long, and in the
3421    range from there to 1018 at least 4 bytes.  */
3422
3423 #define MAX_POOL_SIZE 372
3424 static pool_node pool_vector[MAX_POOL_SIZE];
3425 static int pool_size;
3426 static rtx pool_window_label;
3427 static int pool_window_last;
3428
3429 static int max_labelno_before_reorg;
3430
3431 /* ??? If we need a constant in HImode which is the truncated value of a
3432    constant we need in SImode, we could combine the two entries thus saving
3433    two bytes.  Is this common enough to be worth the effort of implementing
3434    it?  */
3435
3436 /* ??? This stuff should be done at the same time that we shorten branches.
3437    As it is now, we must assume that all branches are the maximum size, and
3438    this causes us to almost always output constant pools sooner than
3439    necessary.  */
3440
3441 /* Add a constant to the pool and return its label.  */
3442
3443 static rtx
3444 add_constant (rtx x, enum machine_mode mode, rtx last_value)
3445 {
3446   int i;
3447   rtx lab, new_rtx;
3448   label_ref_list_t ref, newref;
3449
3450   /* First see if we've already got it.  */
3451   for (i = 0; i < pool_size; i++)
3452     {
3453       if (x->code == pool_vector[i].value->code
3454           && mode == pool_vector[i].mode)
3455         {
3456           if (x->code == CODE_LABEL)
3457             {
3458               if (XINT (x, 3) != XINT (pool_vector[i].value, 3))
3459                 continue;
3460             }
3461           if (rtx_equal_p (x, pool_vector[i].value))
3462             {
3463               lab = new_rtx = 0;
3464               if (! last_value
3465                   || ! i
3466                   || ! rtx_equal_p (last_value, pool_vector[i-1].value))
3467                 {
3468                   new_rtx = gen_label_rtx ();
3469                   LABEL_REFS (new_rtx) = pool_vector[i].label;
3470                   pool_vector[i].label = lab = new_rtx;
3471                 }
3472               if (lab && pool_window_label)
3473                 {
3474                   newref = (label_ref_list_t) pool_alloc (label_ref_list_pool);
3475                   newref->label = pool_window_label;
3476                   ref = pool_vector[pool_window_last].wend;
3477                   newref->next = ref;
3478                   pool_vector[pool_window_last].wend = newref;
3479                 }
3480               if (new_rtx)