OSDN Git Service

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