OSDN Git Service

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