OSDN Git Service

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