OSDN Git Service

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