OSDN Git Service

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