OSDN Git Service

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