OSDN Git Service

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