OSDN Git Service

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