OSDN Git Service

e27b57252834c4dfe5ac4fdec5d687aa54746e0a
[pf3gnuchains/gcc-fork.git] / gcc / config / h8300 / h8300.c
1 /* Subroutines for insn-output.c for Hitachi H8/300.
2    Copyright (C) 1992, 1993, 1994, 1995, 1996, 1997, 1998, 1999, 2000, 2001
3    Free Software Foundation, Inc. 
4    Contributed by Steve Chamberlain (sac@cygnus.com),
5    Jim Wilson (wilson@cygnus.com), and Doug Evans (dje@cygnus.com).
6
7 This file is part of GNU CC.
8
9 GNU CC 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 GNU CC 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 GNU CC; 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 "rtl.h"
27 #include "tree.h"
28 #include "regs.h"
29 #include "hard-reg-set.h"
30 #include "real.h"
31 #include "insn-config.h"
32 #include "conditions.h"
33 #include "output.h"
34 #include "insn-attr.h"
35 #include "flags.h"
36 #include "recog.h"
37 #include "expr.h"
38 #include "function.h"
39 #include "toplev.h"
40 #include "c-pragma.h"
41 #include "tm_p.h"
42 #include "ggc.h"
43 #include "target.h"
44 #include "target-def.h"
45
46 /* Forward declarations.  */
47 static int h8300_interrupt_function_p PARAMS ((tree));
48 static int h8300_monitor_function_p PARAMS ((tree));
49 static int h8300_os_task_function_p PARAMS ((tree));
50 static void dosize PARAMS ((FILE *, const char *, unsigned int));
51 static int round_frame_size PARAMS ((int));
52 static unsigned int compute_saved_regs PARAMS ((void));
53 static void push PARAMS ((FILE *, int));
54 static void pop PARAMS ((FILE *, int));
55 static const char *cond_string PARAMS ((enum rtx_code));
56 const struct attribute_spec h8300_attribute_table[];
57 static tree h8300_handle_fndecl_attribute PARAMS ((tree *, tree, tree, int, bool *));
58 static tree h8300_handle_eightbit_data_attribute PARAMS ((tree *, tree, tree, int, bool *));
59 static tree h8300_handle_tiny_data_attribute PARAMS ((tree *, tree, tree, int, bool *));
60 static void h8300_output_function_prologue PARAMS ((FILE *, HOST_WIDE_INT));
61 static void h8300_output_function_epilogue PARAMS ((FILE *, HOST_WIDE_INT));
62 static void h8300_asm_named_section PARAMS ((const char *, unsigned int));
63
64 /* CPU_TYPE, says what cpu we're compiling for.  */
65 int cpu_type;
66
67 /* True if the current function is an interrupt handler
68    (either via #pragma or an attribute specification).  */
69 int interrupt_handler;
70
71 /* True if the current function is an OS Task
72    (via an attribute specification).  */
73 int os_task;
74
75 /* True if the current function is a monitor
76    (via an attribute specification).  */
77 int monitor;
78
79 /* True if a #pragma saveall has been seen for the current function.  */
80 int pragma_saveall;
81
82 static const char *const names_big[] =
83 { "r0", "r1", "r2", "r3", "r4", "r5", "r6", "r7" };
84
85 static const char *const names_extended[] =
86 { "er0", "er1", "er2", "er3", "er4", "er5", "er6", "er7" };
87
88 static const char *const names_upper_extended[] =
89 { "e0", "e1", "e2", "e3", "e4", "e5", "e6", "e7" };
90
91 /* Points to one of the above.  */
92 /* ??? The above could be put in an array indexed by CPU_TYPE.  */
93 const char * const *h8_reg_names;
94
95 /* Various operations needed by the following, indexed by CPU_TYPE.  */
96
97 static const char *const h8_push_ops[2] = { "push", "push.l" };
98 static const char *const h8_pop_ops[2] = { "pop", "pop.l" };
99 static const char *const h8_mov_ops[2] = { "mov.w", "mov.l" };
100
101 const char *h8_push_op, *h8_pop_op, *h8_mov_op;
102 \f
103 /* Initialize the GCC target structure.  */
104 #undef TARGET_ATTRIBUTE_TABLE
105 #define TARGET_ATTRIBUTE_TABLE h8300_attribute_table
106
107 #undef TARGET_ASM_FUNCTION_PROLOGUE
108 #define TARGET_ASM_FUNCTION_PROLOGUE h8300_output_function_prologue
109 #undef TARGET_ASM_FUNCTION_EPILOGUE
110 #define TARGET_ASM_FUNCTION_EPILOGUE h8300_output_function_epilogue
111
112 struct gcc_target targetm = TARGET_INITIALIZER;
113 \f
114 /* Initialize various cpu specific globals at start up.  */
115
116 void
117 h8300_init_once ()
118 {
119   if (TARGET_H8300)
120     {
121       cpu_type = (int) CPU_H8300;
122       h8_reg_names = names_big;
123     }
124   else
125     {
126       /* For this we treat the H8/300H and H8/S the same.  */
127       cpu_type = (int) CPU_H8300H;
128       h8_reg_names = names_extended;
129     }
130   h8_push_op = h8_push_ops[cpu_type];
131   h8_pop_op = h8_pop_ops[cpu_type];
132   h8_mov_op = h8_mov_ops[cpu_type];
133
134   if (!TARGET_H8300S && TARGET_MAC)
135     {
136       error ("-ms2600 is used without -ms.");
137       target_flags |= 1;
138     }
139 }
140
141 const char *
142 byte_reg (x, b)
143      rtx x;
144      int b;
145 {
146   static const char *const names_small[] =
147   {"r0l", "r0h", "r1l", "r1h", "r2l", "r2h", "r3l", "r3h",
148    "r4l", "r4h", "r5l", "r5h", "r6l", "r6h", "r7l", "r7h"};
149
150   return names_small[REGNO (x) * 2 + b];
151 }
152
153 /* REGNO must be saved/restored across calls if this macro is true.  */
154
155 #define WORD_REG_USED(regno)                                    \
156   (regno < 7                                                    \
157    /* No need to save registers if this function will not return.  */\
158    && ! TREE_THIS_VOLATILE (current_function_decl)              \
159    && (pragma_saveall                                           \
160        /* Save any call saved register that was used.  */       \
161        || (regs_ever_live[regno] && !call_used_regs[regno])     \
162        /* Save the frame pointer if it was used.  */            \
163        || (regno == FRAME_POINTER_REGNUM && regs_ever_live[regno])\
164        /* Save any register used in an interrupt handler.  */   \
165        || (interrupt_handler && regs_ever_live[regno])          \
166        /* Save call clobbered registers in non-leaf interrupt   \
167           handlers.  */                                         \
168        || (interrupt_handler                                    \
169            && call_used_regs[regno]                             \
170            && !current_function_is_leaf)))
171
172 /* Output assembly language to FILE for the operation OP with operand size
173    SIZE to adjust the stack pointer.  */
174
175 static void
176 dosize (file, op, size)
177      FILE *file;
178      const char *op;
179      unsigned int size;
180 {
181   /* On the H8/300H and H8/S, for sizes <= 8 bytes, it is as good or
182      better to use adds/subs insns rather than add.l/sub.l with an
183      immediate value.
184
185      Also, on the H8/300, if we don't have a temporary to hold the
186      size of the frame in the prologue, we simply emit a sequence of
187      subs since this shouldn't happen often.  */
188   if ((TARGET_H8300 && size <= 4)
189       || ((TARGET_H8300H || TARGET_H8300S) && size <= 8)
190       || (TARGET_H8300 && current_function_needs_context
191           && ! strcmp (op, "sub")))
192     {
193       unsigned HOST_WIDE_INT amount;
194
195       /* Try different amounts in descending order.  */
196       for (amount = (TARGET_H8300H || TARGET_H8300S) ? 4 : 2;
197            amount > 0;
198            amount /= 2)
199         {
200           for (; size >= amount; size -= amount)
201             fprintf (file, "\t%ss\t#%d,sp\n", op, amount);
202         }
203     }
204   else
205     {
206       if (TARGET_H8300)
207         fprintf (file, "\tmov.w\t#%d,r3\n\t%s.w\tr3,sp\n", size, op);
208       else
209         fprintf (file, "\t%s.l\t#%d,sp\n", op, size);
210     }
211 }
212
213 /* Round up frame size SIZE.  */
214
215 static int
216 round_frame_size (size)
217      int size;
218 {
219   return (size + STACK_BOUNDARY / 8 - 1) & -STACK_BOUNDARY / 8;
220 }
221
222 /* Compute which registers to push/pop.
223    Return a bit vector of registers.  */
224
225 static unsigned int
226 compute_saved_regs ()
227 {
228   unsigned int saved_regs = 0;
229   int regno;
230
231   /* Construct a bit vector of registers to be pushed/popped.  */
232   for (regno = 0; regno <= 6; regno++)
233     {
234       if (WORD_REG_USED (regno))
235         saved_regs |= 1 << regno;
236     }
237
238   /* Don't push/pop the frame pointer as it is treated separately.  */
239   if (frame_pointer_needed)
240     saved_regs &= ~(1 << FRAME_POINTER_REGNUM);
241
242   return saved_regs;
243 }
244
245 /* Output assembly language code to push register RN.  */
246
247 static void
248 push (file, rn)
249      FILE *file;
250      int rn;
251 {
252   fprintf (file, "\t%s\t%s\n", h8_push_op, h8_reg_names[rn]);
253 }
254
255 /* Output assembly language code to pop register RN.  */
256
257 static void
258 pop (file, rn)
259      FILE *file;
260      int rn;
261 {
262   fprintf (file, "\t%s\t%s\n", h8_pop_op, h8_reg_names[rn]);
263 }
264
265 /* This is what the stack looks like after the prolog of 
266    a function with a frame has been set up:
267
268    <args>
269    PC
270    FP                   <- fp
271    <locals>
272    <saved registers>    <- sp
273
274    This is what the stack looks like after the prolog of
275    a function which doesn't have a frame:
276
277    <args>
278    PC
279    <locals>
280    <saved registers>    <- sp
281 */
282
283 /* Output assembly language code for the function prologue.  */
284
285 static void
286 h8300_output_function_prologue (file, size)
287      FILE *file;
288      HOST_WIDE_INT size;
289 {
290   int fsize = round_frame_size (size);
291   int idx;
292   int saved_regs;
293   int n_regs;
294
295   /* Note a function with the interrupt attribute and set interrupt_handler
296      accordingly.  */
297   if (h8300_interrupt_function_p (current_function_decl))
298     interrupt_handler = 1;
299
300   /* If the current function has the OS_Task attribute set, then
301      we have a naked prologue.  */
302   if (h8300_os_task_function_p (current_function_decl))
303     {
304       fprintf (file, ";OS_Task prologue\n");
305       os_task = 1;
306       return;
307     }
308
309   if (h8300_monitor_function_p (current_function_decl))
310     {
311       /* My understanding of monitor functions is they act just
312          like interrupt functions, except the prologue must
313          mask interrupts.  */
314       fprintf (file, ";monitor prologue\n");
315       interrupt_handler = 1;
316       monitor = 1;
317       if (TARGET_H8300)
318         {
319           fprintf (file, "\tsubs\t#2,sp\n");
320           push (file, 0);
321           fprintf (file, "\tstc\tccr,r0l\n");
322           fprintf (file, "\tmov.b\tr0l,@(2,sp)\n");
323           pop (file, 0);
324           fprintf (file, "\torc\t#128,ccr\n");
325         }
326       else if (TARGET_H8300H)
327         {
328           push (file, 0);
329           fprintf (file, "\tstc\tccr,r0l\n");
330           fprintf (file, "\tmov.b\tr0l,@(4,sp)\n");
331           pop (file, 0);
332           fprintf (file, "\torc\t#128,ccr\n");
333         }
334       else if (TARGET_H8300S)
335         {
336           fprintf (file, "\tstc\texr,@-sp\n");
337           push (file, 0);
338           fprintf (file, "\tstc\tccr,r0l\n");
339           fprintf (file, "\tmov.b\tr0l,@(6,sp)\n");
340           pop (file, 0);
341           fprintf (file, "\torc\t#128,ccr\n");
342         }
343       else
344         abort ();
345     }
346
347   if (frame_pointer_needed)
348     {
349       /* Push fp.  */
350       push (file, FRAME_POINTER_REGNUM);
351       fprintf (file, "\t%s\t%s,%s\n", h8_mov_op,
352                h8_reg_names[STACK_POINTER_REGNUM],
353                h8_reg_names[FRAME_POINTER_REGNUM]);
354     }
355
356   /* Leave room for locals.  */
357   dosize (file, "sub", fsize);
358
359   /* Push the rest of the registers in ascending order.  */
360   saved_regs = compute_saved_regs ();
361   for (idx = 0; idx < FIRST_PSEUDO_REGISTER; idx += n_regs)
362     {
363       int regno = idx;
364
365       n_regs = 1;
366       if (saved_regs & (1 << regno))
367         {
368           if (TARGET_H8300S)
369             {
370               /* See how many registers we can push at the same time.  */
371               if ((regno == 0 || regno == 4)
372                   && ((saved_regs >> regno) & 0x0f) == 0x0f)
373                 n_regs = 4;
374
375               else if ((regno == 0 || regno == 4)
376                        && ((saved_regs >> regno) & 0x07) == 0x07)
377                 n_regs = 3;
378
379               else if ((regno == 0 || regno == 2 || regno == 4 || regno == 6)
380                        && ((saved_regs >> regno) & 0x03) == 0x03)
381                 n_regs = 2;
382             }
383
384           if (n_regs == 1)
385             push (file, regno);
386           else
387             fprintf (file, "\tstm.l\t%s-%s,@-sp\n",
388                      h8_reg_names[regno],
389                      h8_reg_names[regno + (n_regs - 1)]);
390         }
391     }
392 }
393
394 /* Output assembly language code for the function epilogue.  */
395
396 static void
397 h8300_output_function_epilogue (file, size)
398      FILE *file;
399      HOST_WIDE_INT size;
400 {
401   int fsize = round_frame_size (size);
402   int idx;
403   rtx insn = get_last_insn ();
404   int saved_regs;
405   int n_regs;
406
407   if (os_task)
408     {
409       /* OS_Task epilogues are nearly naked -- they just have an
410          rts instruction.  */
411       fprintf (file, ";OS_task epilogue\n");
412       fprintf (file, "\trts\n");
413       goto out;
414     }
415
416   /* Monitor epilogues are the same as interrupt function epilogues.
417      Just make a note that we're in an monitor epilogue.  */
418   if (monitor)
419     fprintf (file, ";monitor epilogue\n");
420
421   /* If the last insn was a BARRIER, we don't have to write any code.  */
422   if (GET_CODE (insn) == NOTE)
423     insn = prev_nonnote_insn (insn);
424   if (insn && GET_CODE (insn) == BARRIER)
425     goto out;
426
427   /* Pop the saved registers in descending order.  */
428   saved_regs = compute_saved_regs ();
429   for (idx = 0; idx < FIRST_PSEUDO_REGISTER; idx += n_regs)
430     {
431       int regno = (FIRST_PSEUDO_REGISTER - 1) - idx;
432
433       n_regs = 1;
434       if (saved_regs & (1 << regno))
435         {
436           if (TARGET_H8300S)
437             {
438               /* See how many registers we can pop at the same time.  */
439               if ((regno == 7 || regno == 3)
440                   && ((saved_regs >> (regno - 3)) & 0x0f) == 0x0f)
441                 n_regs = 4;
442
443               else if ((regno == 6 || regno == 2)
444                        && ((saved_regs >> (regno - 2)) & 0x07) == 0x07)
445                 n_regs = 3;
446
447               else if ((regno == 7 || regno == 5 || regno == 3 || regno == 1)
448                        && ((saved_regs >> (regno - 1)) & 0x03) == 0x03)
449                 n_regs = 2;
450             }
451
452           if (n_regs == 1)
453             pop (file, regno);
454           else
455             fprintf (file, "\tldm.l\t@sp+,%s-%s\n",
456                      h8_reg_names[regno - (n_regs - 1)],
457                      h8_reg_names[regno]);
458         }
459     }
460
461   /* Deallocate locals.  */
462   dosize (file, "add", fsize);
463
464   /* Pop frame pointer if we had one.  */
465   if (frame_pointer_needed)
466     pop (file, FRAME_POINTER_REGNUM);
467
468   if (interrupt_handler)
469     fprintf (file, "\trte\n");
470   else
471     fprintf (file, "\trts\n");
472
473  out:
474   interrupt_handler = 0;
475   os_task = 0;
476   monitor = 0;
477   pragma_saveall = 0;
478 }
479
480 /* Output assembly code for the start of the file.  */
481
482 void
483 asm_file_start (file)
484      FILE *file;
485 {
486   fprintf (file, ";\tGCC For the Hitachi H8/300\n");
487   fprintf (file, ";\tBy Hitachi America Ltd and Cygnus Support\n");
488   if (optimize)
489     fprintf (file, "; -O%d\n", optimize);
490   if (TARGET_H8300H)
491     fprintf (file, "\n\t.h8300h\n");
492   else if (TARGET_H8300S)
493     fprintf (file, "\n\t.h8300s\n");
494   else
495     fprintf (file, "\n\n");
496   output_file_directive (file, main_input_filename);
497 }
498
499 /* Output assembly language code for the end of file.  */
500
501 void
502 asm_file_end (file)
503      FILE *file;
504 {
505   fprintf (file, "\t.end\n");
506 }
507 \f
508 /* Return true if VALUE is a valid constant for constraint 'P'.
509    IE: VALUE is a power of two <= 2**15.  */
510
511 int
512 small_power_of_two (value)
513      HOST_WIDE_INT value;
514 {
515   int power = exact_log2 (value);
516   return power >= 0 && power <= 15;
517 }
518
519 /* Return true if VALUE is a valid constant for constraint 'O', which
520    means that the constant would be ok to use as a bit for a bclr
521    instruction.  */
522
523 int
524 ok_for_bclr (value)
525      HOST_WIDE_INT value;
526 {
527   return small_power_of_two ((~value) & 0xff);
528 }
529
530 /* Return true if OP is a valid source operand for an integer move
531    instruction.  */
532
533 int
534 general_operand_src (op, mode)
535      rtx op;
536      enum machine_mode mode;
537 {
538   if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == POST_INC)
539     return 1;
540   return general_operand (op, mode);
541 }
542
543 /* Return true if OP is a valid destination operand for an integer move
544    instruction.  */
545
546 int
547 general_operand_dst (op, mode)
548      rtx op;
549      enum machine_mode mode;
550 {
551   if (GET_CODE (op) == MEM && GET_CODE (XEXP (op, 0)) == PRE_DEC)
552     return 1;
553   return general_operand (op, mode);
554 }
555
556 /* Return true if OP is a const valid for a bit clear instruction.  */
557
558 int
559 o_operand (operand, mode)
560      rtx operand;
561      enum machine_mode mode ATTRIBUTE_UNUSED;
562 {
563   return (GET_CODE (operand) == CONST_INT
564           && CONST_OK_FOR_O (INTVAL (operand)));
565 }
566
567 /* Return true if OP is a const valid for a bit set or bit xor instruction.  */
568
569 int
570 p_operand (operand, mode)
571      rtx operand;
572      enum machine_mode mode ATTRIBUTE_UNUSED;
573 {
574   return (GET_CODE (operand) == CONST_INT
575           && CONST_OK_FOR_P (INTVAL (operand)));
576 }
577
578 /* Return true if OP is a valid call operand.  */
579
580 int
581 call_insn_operand (op, mode)
582      rtx op;
583      enum machine_mode mode ATTRIBUTE_UNUSED;
584 {
585   if (GET_CODE (op) == MEM)
586     {
587       rtx inside = XEXP (op, 0);
588       if (register_operand (inside, Pmode))
589         return 1;
590       if (CONSTANT_ADDRESS_P (inside))
591         return 1;
592     }
593   return 0;
594 }
595
596 /* Return 1 if an addition/subtraction of a constant integer can be
597    transformed into two consecutive adds/subs that are faster than the
598    straightforward way.  Otherwise, return 0.  */
599
600 int
601 two_insn_adds_subs_operand (op, mode)
602      rtx op;
603      enum machine_mode mode;
604 {
605   if (GET_CODE (op) == CONST_INT)
606     {
607       HOST_WIDE_INT value = INTVAL (op);
608
609       /* Force VALUE to be positive so that we do not have to consider
610          the negative case.  */
611       if (value < 0)
612         value = -value;
613       if (TARGET_H8300H || TARGET_H8300S)
614         {
615           /* A constant addition/subtraction takes 2 states in QImode,
616              4 states in HImode, and 6 states in SImode.  Thus, the
617              only case we can win is when SImode is used, in which
618              case, two adds/subs are used, taking 4 states.  */
619           if (mode == SImode
620               && (value == 2 + 1
621                   || value == 4 + 1
622                   || value == 4 + 2
623                   || value == 4 + 4))
624             return 1;
625         }
626       else
627         {
628           /* A constant addition/subtraction takes 2 states in
629              QImode. It takes 6 states in HImode, requiring the
630              constant to be loaded to a register first, and a lot more
631              in SImode.  Thus the only case we can win is when either
632              HImode or SImode is used.  */
633           if (mode != QImode
634               && (value == 2 + 1
635                   || value == 2 + 2))
636             return 1;
637         }
638     }
639
640   return 0;
641 }
642
643 /* Split an add of a small constant into two adds/subs insns.  */
644
645 void
646 split_adds_subs (mode, operands)
647      enum machine_mode mode;
648      rtx *operands;
649 {
650   HOST_WIDE_INT val = INTVAL (operands[1]);
651   rtx reg = operands[0];
652   HOST_WIDE_INT sign = 1;
653   HOST_WIDE_INT amount;
654
655   /* Force VAL to be positive so that we do not have to consider the
656      sign.  */
657   if (val < 0)
658     {
659       val = -val;
660       sign = -1;
661     }
662
663   /* Try different amounts in descending order.  */
664   for (amount = (TARGET_H8300H || TARGET_H8300S) ? 4 : 2;
665        amount > 0;
666        amount /= 2)
667     {
668       for (; val >= amount; val -= amount)
669         {
670           rtx tmp = gen_rtx_PLUS (mode, reg, GEN_INT (sign * amount));
671           emit_insn (gen_rtx_SET (VOIDmode, reg, tmp));
672         }
673     }
674
675   return;
676 }
677
678 /* Return true if OP is a valid call operand, and OP represents
679    an operand for a small call (4 bytes instead of 6 bytes).  */
680
681 int
682 small_call_insn_operand (op, mode)
683      rtx op;
684      enum machine_mode mode ATTRIBUTE_UNUSED;
685 {
686   if (GET_CODE (op) == MEM)
687     {
688       rtx inside = XEXP (op, 0);
689
690       /* Register indirect is a small call.  */
691       if (register_operand (inside, Pmode))
692         return 1;
693
694       /* A call through the function vector is a small
695          call too.  */
696       if (GET_CODE (inside) == SYMBOL_REF
697           && SYMBOL_REF_FLAG (inside))
698         return 1;
699     }
700   /* Otherwise it's a large call.  */
701   return 0;
702 }
703
704 /* Return true if OP is a valid jump operand.  */
705
706 int
707 jump_address_operand (op, mode)
708      rtx op;
709      enum machine_mode mode;
710 {
711   if (GET_CODE (op) == REG)
712     return mode == Pmode;
713
714   if (GET_CODE (op) == MEM)
715     {
716       rtx inside = XEXP (op, 0);
717       if (register_operand (inside, Pmode))
718         return 1;
719       if (CONSTANT_ADDRESS_P (inside))
720         return 1;
721     }
722   return 0;
723 }
724
725 /* Recognize valid operands for bitfield instructions.  */
726
727 extern int rtx_equal_function_value_matters;
728
729 int
730 bit_operand (op, mode)
731      rtx op;
732      enum machine_mode mode;
733 {
734   /* We can except any general operand, expept that MEM operands must
735      be limited to those that use addresses valid for the 'U' constraint.  */
736   if (!general_operand (op, mode))
737     return 0;
738
739   /* Accept any mem during RTL generation.  Otherwise, the code that does
740      insv and extzv will think that we can not handle memory.  However,
741      to avoid reload problems, we only accept 'U' MEM operands after RTL
742      generation.  This means that any named pattern which uses this predicate
743      must force its operands to match 'U' before emitting RTL.  */
744
745   if (GET_CODE (op) == REG)
746     return 1;
747   if (GET_CODE (op) == SUBREG)
748     return 1;
749   if (!rtx_equal_function_value_matters)
750     /* We're building rtl.  */
751     return GET_CODE (op) == MEM;
752   else
753     return (GET_CODE (op) == MEM
754             && EXTRA_CONSTRAINT (op, 'U'));
755 }
756
757 int
758 bit_memory_operand (op, mode)
759      rtx op;
760      enum machine_mode mode ATTRIBUTE_UNUSED;
761 {
762   return (GET_CODE (op) == MEM
763           && EXTRA_CONSTRAINT (op, 'U'));
764 }
765
766 /* Recognize valid operators for bit test.  */
767
768 int
769 eq_operator (x, mode)
770      rtx x;
771      enum machine_mode mode ATTRIBUTE_UNUSED;
772 {
773   return (GET_CODE (x) == EQ || GET_CODE (x) == NE);
774 }
775
776 /* Handle machine specific pragmas for compatibility with existing
777    compilers for the H8/300.
778
779    pragma saveall generates prolog/epilog code which saves and
780    restores all the registers on function entry.
781
782    pragma interrupt saves and restores all registers, and exits with
783    an rte instruction rather than an rts.  A pointer to a function
784    with this attribute may be safely used in an interrupt vector.  */
785
786 void
787 h8300_pr_interrupt (pfile)
788      cpp_reader *pfile ATTRIBUTE_UNUSED;
789 {
790   interrupt_handler = 1;
791 }
792
793 void
794 h8300_pr_saveall (pfile)
795      cpp_reader *pfile ATTRIBUTE_UNUSED;
796 {
797   pragma_saveall = 1;
798 }
799
800 /* If the next arg with MODE and TYPE is to be passed in a register, return
801    the rtx to represent where it is passed.  CUM represents the state after
802    the last argument.  NAMED is not used.  */
803
804 static const char *const hand_list[] =
805 {
806   "__main",
807   "__cmpsi2",
808   "__divhi3",
809   "__modhi3",
810   "__udivhi3",
811   "__umodhi3",
812   "__divsi3",
813   "__modsi3",
814   "__udivsi3",
815   "__umodsi3",
816   "__mulhi3",
817   "__mulsi3",
818   "__reg_memcpy",
819   "__reg_memset",
820   "__ucmpsi2",
821   0,
822 };
823
824 /* Return an RTX to represent where a value with mode MODE will be returned
825    from a function.  If the result is 0, the argument is pushed.  */
826
827 rtx
828 function_arg (cum, mode, type, named)
829      CUMULATIVE_ARGS *cum;
830      enum machine_mode mode;
831      tree type;
832      int named;
833 {
834   rtx result = 0;
835   const char *fname;
836   int regpass = 0;
837
838   /* Never pass unnamed arguments in registers.  */
839   if (!named)
840     return 0;
841
842   /* Pass 3 regs worth of data in regs when user asked on the command line.  */
843   if (TARGET_QUICKCALL)
844     regpass = 3;
845
846   /* If calling hand written assembler, use 4 regs of args.  */
847
848   if (cum->libcall)
849     {
850       const char * const *p;
851
852       fname = XSTR (cum->libcall, 0);
853
854       /* See if this libcall is one of the hand coded ones.  */
855
856       for (p = hand_list; *p && strcmp (*p, fname) != 0; p++)
857         ;
858
859       if (*p)
860         regpass = 4;
861     }
862
863   if (regpass)
864     {
865       int size;
866
867       if (mode == BLKmode)
868         size = int_size_in_bytes (type);
869       else
870         size = GET_MODE_SIZE (mode);
871
872       if (size + cum->nbytes > regpass * UNITS_PER_WORD)
873         {
874           result = 0;
875         }
876       else
877         {
878           switch (cum->nbytes / UNITS_PER_WORD)
879             {
880             case 0:
881               result = gen_rtx_REG (mode, 0);
882               break;
883             case 1:
884               result = gen_rtx_REG (mode, 1);
885               break;
886             case 2:
887               result = gen_rtx_REG (mode, 2);
888               break;
889             case 3:
890               result = gen_rtx_REG (mode, 3);
891               break;
892             default:
893               result = 0;
894             }
895         }
896     }
897
898   return result;
899 }
900 \f
901 /* Return the cost of the rtx R with code CODE.  */
902
903 int
904 const_costs (r, c)
905      rtx r;
906      enum rtx_code c;
907 {
908   switch (c)
909     {
910     case CONST_INT:
911       switch (INTVAL (r))
912         {
913         case 0:
914         case 1:
915         case 2:
916         case -1:
917         case -2:
918           return 0;
919         case 4:
920         case -4:
921           if (TARGET_H8300H || TARGET_H8300S)
922             return 0;
923           else
924             return 1;
925         default:
926           return 1;
927         }
928
929     case CONST:
930     case LABEL_REF:
931     case SYMBOL_REF:
932       return 3;
933
934     case CONST_DOUBLE:
935       return 20;
936
937     default:
938       return 4;
939     }
940 }
941 \f
942 /* Documentation for the machine specific operand escapes:
943
944    'A' print rn in H8/300 mode, erN in H8/300H mode
945    'C' print (operand - 2).
946    'E' like s but negative.
947    'F' like t but negative.
948    'G' constant just the negative
949    'M' turn a 'M' constant into its negative mod 2.
950    'P' if operand is incing/decing sp, print .w, otherwise .b.
951    'R' print operand as a byte:8 address if appropriate, else fall back to
952        'X' handling.
953    'S' print operand as a long word
954    'T' print operand as a word
955    'U' if operand is incing/decing sp, print l, otherwise nothing.
956    'V' find the set bit, and print its number.
957    'W' find the clear bit, and print its number.
958    'X' print operand as a byte
959    'Y' print either l or h depending on whether last 'Z' operand < 8 or >= 8.
960        If this operand isn't a register, fall back to 'R' handling.
961    'Z' print int & 7.
962    'b' print the bit opcode
963    'c' print the ibit opcode
964    'd' bcc if EQ, bcs if NE
965    'e' first word of 32 bit value - if reg, then least reg. if mem
966        then least. if const then most sig word
967    'f' second word of 32 bit value - if reg, then biggest reg. if mem
968        then +2. if const then least sig word
969    'g' bcs if EQ, bcc if NE
970    'j' print operand as condition code.
971    'k' print operand as reverse condition code.
972    's' print as low byte of 16 bit value
973    't' print as high byte of 16 bit value
974    'w' print as low byte of 32 bit value
975    'x' print as 2nd byte of 32 bit value
976    'y' print as 3rd byte of 32 bit value
977    'z' print as msb of 32 bit value
978 */
979
980 /* Return assembly language string which identifies a comparison type.  */
981
982 static const char *
983 cond_string (code)
984      enum rtx_code code;
985 {
986   switch (code)
987     {
988     case NE:
989       return "ne";
990     case EQ:
991       return "eq";
992     case GE:
993       return "ge";
994     case GT:
995       return "gt";
996     case LE:
997       return "le";
998     case LT:
999       return "lt";
1000     case GEU:
1001       return "hs";
1002     case GTU:
1003       return "hi";
1004     case LEU:
1005       return "ls";
1006     case LTU:
1007       return "lo";
1008     default:
1009       abort ();
1010     }
1011 }
1012
1013 /* Print operand X using operand code CODE to assembly language output file
1014    FILE.  */
1015
1016 void
1017 print_operand (file, x, code)
1018      FILE *file;
1019      rtx x;
1020      int code;
1021 {
1022   /* This is used for communication between the 'P' and 'U' codes.  */
1023   static const char *last_p;
1024
1025   /* This is used for communication between codes V,W,Z and Y.  */
1026   static int bitint;
1027
1028   switch (code)
1029     {
1030     case 'A':
1031       if (GET_CODE (x) == REG)
1032         fprintf (file, "%s", h8_reg_names[REGNO (x)]);
1033       else
1034         goto def;
1035       break;
1036     case 'C':
1037       fprintf (file, "#%d", INTVAL (x) - 2);
1038       break;
1039     case 'E':
1040       switch (GET_CODE (x))
1041         {
1042         case REG:
1043           fprintf (file, "%sl", names_big[REGNO (x)]);
1044           break;
1045         case CONST_INT:
1046           fprintf (file, "#%d", (-INTVAL (x)) & 0xff);
1047           break;
1048         default:
1049           abort ();
1050         }
1051       break;
1052     case 'F':
1053       switch (GET_CODE (x))
1054         {
1055         case REG:
1056           fprintf (file, "%sh", names_big[REGNO (x)]);
1057           break;
1058         case CONST_INT:
1059           fprintf (file, "#%d", ((-INTVAL (x)) & 0xff00) >> 8);
1060           break;
1061         default:
1062           abort ();
1063         }
1064       break;
1065     case 'G':
1066       if (GET_CODE (x) != CONST_INT)
1067         abort ();
1068       fprintf (file, "#%d", 0xff & (-INTVAL (x)));
1069       break;
1070     case 'M':
1071       /* For 3/-3 and 4/-4, the other 2 is handled separately.  */
1072       switch (INTVAL (x))
1073         {
1074         case 2:
1075         case 4:
1076         case -2:
1077         case -4:
1078           fprintf (file, "#2");
1079           break;
1080         case 1:
1081         case 3:
1082         case -1:
1083         case -3:
1084           fprintf (file, "#1");
1085           break;
1086         default:
1087           abort ();
1088         }
1089       break;
1090     case 'P':
1091       if (REGNO (XEXP (XEXP (x, 0), 0)) == STACK_POINTER_REGNUM)
1092         {
1093           last_p = "";
1094           fprintf (file, ".w");
1095         }
1096       else
1097         {
1098           last_p = "l";
1099           fprintf (file, ".b");
1100         }
1101       break;
1102     case 'S':
1103       if (GET_CODE (x) == REG)
1104         fprintf (file, "%s", names_extended[REGNO (x)]);
1105       else
1106         goto def;
1107       break;
1108     case 'T':
1109       if (GET_CODE (x) == REG)
1110         fprintf (file, "%s", names_big[REGNO (x)]);
1111       else
1112         goto def;
1113       break;
1114     case 'U':
1115       fprintf (file, "%s%s", names_big[REGNO (x)], last_p);
1116       break;
1117     case 'V':
1118       bitint = exact_log2 (INTVAL (x));
1119       if (bitint == -1)
1120         abort ();
1121       fprintf (file, "#%d", bitint & 7);
1122       break;
1123     case 'W':
1124       bitint = exact_log2 ((~INTVAL (x)) & 0xff);
1125       if (bitint == -1)
1126         abort ();
1127       fprintf (file, "#%d", bitint & 7);
1128       break;
1129     case 'R':
1130     case 'X':
1131       if (GET_CODE (x) == REG)
1132         fprintf (file, "%s", byte_reg (x, 0));
1133       else
1134         goto def;
1135       break;
1136     case 'Y':
1137       if (bitint == -1)
1138         abort ();
1139       if (GET_CODE (x) == REG)
1140         fprintf (file, "%s%c", names_big[REGNO (x)], bitint > 7 ? 'h' : 'l');
1141       else
1142         print_operand (file, x, 'R');
1143       bitint = -1;
1144       break;
1145     case 'Z':
1146       bitint = INTVAL (x);
1147       fprintf (file, "#%d", bitint & 7);
1148       break;
1149     case 'b':
1150       switch (GET_CODE (x))
1151         {
1152         case IOR:
1153           fprintf (file, "bor");
1154           break;
1155         case XOR:
1156           fprintf (file, "bxor");
1157           break;
1158         case AND:
1159           fprintf (file, "band");
1160           break;
1161         default:
1162           break;
1163         }
1164       break;
1165     case 'c':
1166       switch (GET_CODE (x))
1167         {
1168         case IOR:
1169           fprintf (file, "bior");
1170           break;
1171         case XOR:
1172           fprintf (file, "bixor");
1173           break;
1174         case AND:
1175           fprintf (file, "biand");
1176           break;
1177         default:
1178           break;
1179         }
1180       break;
1181     case 'd':
1182       switch (GET_CODE (x))
1183         {
1184         case EQ:
1185           fprintf (file, "bcc");
1186           break;
1187         case NE:
1188           fprintf (file, "bcs");
1189           break;
1190         default:
1191           abort ();
1192         }
1193       break;
1194     case 'e':
1195       switch (GET_CODE (x))
1196         {
1197         case REG:
1198           if (TARGET_H8300)
1199             fprintf (file, "%s", names_big[REGNO (x)]);
1200           else
1201             fprintf (file, "%s", names_upper_extended[REGNO (x)]);
1202           break;
1203         case MEM:
1204           print_operand (file, x, 0);
1205           break;
1206         case CONST_INT:
1207           fprintf (file, "#%d", ((INTVAL (x) >> 16) & 0xffff));
1208           break;
1209         case CONST_DOUBLE:
1210           {
1211             long val;
1212             REAL_VALUE_TYPE rv;
1213             REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
1214             REAL_VALUE_TO_TARGET_SINGLE (rv, val);
1215             fprintf (file, "#%ld", ((val >> 16) & 0xffff));
1216             break;
1217           }
1218         default:
1219           abort ();
1220           break;
1221         }
1222       break;
1223     case 'f':
1224       switch (GET_CODE (x))
1225         {
1226         case REG:
1227           if (TARGET_H8300)
1228             fprintf (file, "%s", names_big[REGNO (x) + 1]);
1229           else
1230             fprintf (file, "%s", names_big[REGNO (x)]);
1231           break;
1232         case MEM:
1233           x = adjust_address (x, HImode, 2);
1234           print_operand (file, x, 0);
1235           break;
1236         case CONST_INT:
1237           fprintf (file, "#%d", INTVAL (x) & 0xffff);
1238           break;
1239         case CONST_DOUBLE:
1240           {
1241             long val;
1242             REAL_VALUE_TYPE rv;
1243             REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
1244             REAL_VALUE_TO_TARGET_SINGLE (rv, val);
1245             fprintf (file, "#%ld", (val & 0xffff));
1246             break;
1247           }
1248         default:
1249           abort ();
1250         }
1251       break;
1252     case 'g':
1253       switch (GET_CODE (x))
1254         {
1255         case NE:
1256           fprintf (file, "bcc");
1257           break;
1258         case EQ:
1259           fprintf (file, "bcs");
1260           break;
1261         default:
1262           abort ();
1263         }
1264       break;
1265     case 'j':
1266       asm_fprintf (file, cond_string (GET_CODE (x)));
1267       break;
1268     case 'k':
1269       asm_fprintf (file, cond_string (reverse_condition (GET_CODE (x))));
1270       break;
1271     case 's':
1272       if (GET_CODE (x) == CONST_INT)
1273         fprintf (file, "#%d", (INTVAL (x)) & 0xff);
1274       else
1275         fprintf (file, "%s", byte_reg (x, 0));
1276       break;
1277     case 't':
1278       if (GET_CODE (x) == CONST_INT)
1279         fprintf (file, "#%d", (INTVAL (x) >> 8) & 0xff);
1280       else
1281         fprintf (file, "%s", byte_reg (x, 1));
1282       break;
1283     case 'u':
1284       if (GET_CODE (x) != CONST_INT)
1285         abort ();
1286       fprintf (file, "%d", INTVAL (x));
1287       break;
1288     case 'w':
1289       if (GET_CODE (x) == CONST_INT)
1290         fprintf (file, "#%d", INTVAL (x) & 0xff);
1291       else
1292         fprintf (file, "%s",
1293                  byte_reg (x, TARGET_H8300 ? 2 : 0));
1294       break;
1295     case 'x':
1296       if (GET_CODE (x) == CONST_INT)
1297         fprintf (file, "#%d", (INTVAL (x) >> 8) & 0xff);
1298       else
1299         fprintf (file, "%s",
1300                  byte_reg (x, TARGET_H8300 ? 3 : 1));
1301       break;
1302     case 'y':
1303       if (GET_CODE (x) == CONST_INT)
1304         fprintf (file, "#%d", (INTVAL (x) >> 16) & 0xff);
1305       else
1306         fprintf (file, "%s", byte_reg (x, 0));
1307       break;
1308     case 'z':
1309       if (GET_CODE (x) == CONST_INT)
1310         fprintf (file, "#%d", (INTVAL (x) >> 24) & 0xff);
1311       else
1312         fprintf (file, "%s", byte_reg (x, 1));
1313       break;
1314
1315     default:
1316     def:
1317       switch (GET_CODE (x))
1318         {
1319         case REG:
1320           switch (GET_MODE (x))
1321             {
1322             case QImode:
1323 #if 0 /* Is it asm ("mov.b %0,r2l", ...) */
1324               fprintf (file, "%s", byte_reg (x, 0));
1325 #else /* ... or is it asm ("mov.b %0l,r2l", ...) */
1326               fprintf (file, "%s", names_big[REGNO (x)]);
1327 #endif
1328               break;
1329             case HImode:
1330               fprintf (file, "%s", names_big[REGNO (x)]);
1331               break;
1332             case SImode:
1333             case SFmode:
1334               fprintf (file, "%s", names_extended[REGNO (x)]);
1335               break;
1336             default:
1337               abort ();
1338             }
1339           break;
1340
1341         case MEM:
1342           fprintf (file, "@");
1343           output_address (XEXP (x, 0));
1344
1345           /* If this is an 'R' operand (reference into the 8-bit
1346              area), then specify a symbolic address as "foo:8",
1347              otherwise if operand is still in eight bit section, use
1348              "foo:16".  */
1349           if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
1350               && SYMBOL_REF_FLAG (XEXP (x, 0)))
1351             fprintf (file, (code == 'R' ? ":8" : ":16"));
1352           else if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
1353                    && TINY_DATA_NAME_P (XSTR (XEXP (x, 0), 0)))
1354             fprintf (file, ":16");
1355           else if ((code == 'R')
1356                    && EIGHTBIT_CONSTANT_ADDRESS_P (XEXP (x, 0)))
1357             fprintf (file, ":8");
1358           break;
1359
1360         case CONST_INT:
1361         case SYMBOL_REF:
1362         case CONST:
1363         case LABEL_REF:
1364           fprintf (file, "#");
1365           print_operand_address (file, x);
1366           break;
1367         case CONST_DOUBLE:
1368           {
1369             long val;
1370             REAL_VALUE_TYPE rv;
1371             REAL_VALUE_FROM_CONST_DOUBLE (rv, x);
1372             REAL_VALUE_TO_TARGET_SINGLE (rv, val);
1373             fprintf (file, "#%ld", val);
1374             break;
1375           }
1376         default:
1377           break;
1378         }
1379     }
1380 }
1381
1382 /* Output assembly language output for the address ADDR to FILE.  */
1383
1384 void
1385 print_operand_address (file, addr)
1386      FILE *file;
1387      rtx addr;
1388 {
1389   switch (GET_CODE (addr))
1390     {
1391     case REG:
1392       fprintf (file, "%s", h8_reg_names[REGNO (addr)]);
1393       break;
1394
1395     case PRE_DEC:
1396       fprintf (file, "-%s", h8_reg_names[REGNO (XEXP (addr, 0))]);
1397       break;
1398
1399     case POST_INC:
1400       fprintf (file, "%s+", h8_reg_names[REGNO (XEXP (addr, 0))]);
1401       break;
1402
1403     case PLUS:
1404       fprintf (file, "(");
1405       if (GET_CODE (XEXP (addr, 0)) == REG)
1406         {
1407           /* reg,foo */
1408           print_operand_address (file, XEXP (addr, 1));
1409           fprintf (file, ",");
1410           print_operand_address (file, XEXP (addr, 0));
1411         }
1412       else
1413         {
1414           /* foo+k */
1415           print_operand_address (file, XEXP (addr, 0));
1416           fprintf (file, "+");
1417           print_operand_address (file, XEXP (addr, 1));
1418         }
1419       fprintf (file, ")");
1420       break;
1421
1422     case CONST_INT:
1423       {
1424         /* Since the H8/300 only has 16 bit pointers, negative values are also
1425            those >= 32768.  This happens for example with pointer minus a
1426            constant.  We don't want to turn (char *p - 2) into
1427            (char *p + 65534) because loop unrolling can build upon this
1428            (IE: char *p + 131068).  */
1429         int n = INTVAL (addr);
1430         if (TARGET_H8300)
1431           n = (int) (short) n;
1432         if (n < 0)
1433           /* ??? Why the special case for -ve values?  */
1434           fprintf (file, "-%d", -n);
1435         else
1436           fprintf (file, "%d", n);
1437         break;
1438       }
1439
1440     default:
1441       output_addr_const (file, addr);
1442       break;
1443     }
1444 }
1445 \f
1446 /* Output all insn addresses and their sizes into the assembly language
1447    output file.  This is helpful for debugging whether the length attributes
1448    in the md file are correct.  This is not meant to be a user selectable
1449    option.  */
1450
1451 void
1452 final_prescan_insn (insn, operand, num_operands)
1453      rtx insn, *operand ATTRIBUTE_UNUSED;
1454      int num_operands ATTRIBUTE_UNUSED;
1455 {
1456   /* This holds the last insn address.  */
1457   static int last_insn_address = 0;
1458
1459   int uid = INSN_UID (insn);
1460
1461   if (TARGET_RTL_DUMP)
1462     {
1463       fprintf (asm_out_file, "\n****************");
1464       print_rtl (asm_out_file, PATTERN (insn));
1465       fprintf (asm_out_file, "\n");
1466     }
1467
1468   if (TARGET_ADDRESSES)
1469     {
1470       fprintf (asm_out_file, "; 0x%x %d\n", INSN_ADDRESSES (uid),
1471                INSN_ADDRESSES (uid) - last_insn_address);
1472       last_insn_address = INSN_ADDRESSES (uid);
1473     }
1474 }
1475
1476 /* Prepare for an SI sized move.  */
1477
1478 int
1479 do_movsi (operands)
1480      rtx operands[];
1481 {
1482   rtx src = operands[1];
1483   rtx dst = operands[0];
1484   if (!reload_in_progress && !reload_completed)
1485     {
1486       if (!register_operand (dst, GET_MODE (dst)))
1487         {
1488           rtx tmp = gen_reg_rtx (GET_MODE (dst));
1489           emit_move_insn (tmp, src);
1490           operands[1] = tmp;
1491         }
1492     }
1493   return 0;
1494 }
1495
1496 /* Function for INITIAL_ELIMINATION_OFFSET(FROM, TO, OFFSET).
1497    Define the offset between two registers, one to be eliminated, and
1498    the other its replacement, at the start of a routine.  */
1499
1500 int
1501 initial_offset (from, to)
1502      int from, to;
1503 {
1504   int offset = 0;
1505
1506   if (from == ARG_POINTER_REGNUM && to == FRAME_POINTER_REGNUM)
1507     offset = UNITS_PER_WORD + frame_pointer_needed * UNITS_PER_WORD;
1508   else if (from == RETURN_ADDRESS_POINTER_REGNUM && to == FRAME_POINTER_REGNUM)
1509     offset = frame_pointer_needed * UNITS_PER_WORD;
1510   else
1511     {
1512       int regno;
1513
1514       for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1515         if (WORD_REG_USED (regno))
1516           offset += UNITS_PER_WORD;
1517
1518       /* See the comments for get_frame_size.  We need to round it up to
1519          STACK_BOUNDARY.  */
1520
1521       offset += ((get_frame_size () + STACK_BOUNDARY / BITS_PER_UNIT - 1)
1522                  & ~(STACK_BOUNDARY / BITS_PER_UNIT - 1));
1523
1524       if (from == ARG_POINTER_REGNUM && to == STACK_POINTER_REGNUM)
1525         offset += UNITS_PER_WORD;       /* Skip saved PC */
1526     }
1527   return offset;
1528 }
1529
1530 rtx
1531 h8300_return_addr_rtx (count, frame)
1532      int count;
1533      rtx frame;
1534 {
1535   rtx ret;
1536
1537   if (count == 0)
1538     ret = gen_rtx_MEM (Pmode,
1539                        gen_rtx_REG (Pmode, RETURN_ADDRESS_POINTER_REGNUM));
1540   else if (flag_omit_frame_pointer)
1541     return (rtx) 0;
1542   else
1543     ret = gen_rtx_MEM (Pmode,
1544                        memory_address (Pmode,
1545                                        plus_constant (frame, UNITS_PER_WORD)));
1546   set_mem_alias_set (ret, get_frame_alias_set ());
1547   return ret;
1548 }
1549
1550 /* Update the condition code from the insn.  */
1551
1552 void
1553 notice_update_cc (body, insn)
1554      rtx body;
1555      rtx insn;
1556 {
1557   switch (get_attr_cc (insn))
1558     {
1559     case CC_NONE:
1560       /* Insn does not affect CC at all.  */
1561       break;
1562
1563     case CC_NONE_0HIT:
1564       /* Insn does not change CC, but the 0'th operand has been changed.  */
1565       if (cc_status.value1 != 0
1566           && reg_overlap_mentioned_p (recog_data.operand[0], cc_status.value1))
1567         cc_status.value1 = 0;
1568       break;
1569
1570     case CC_SET_ZN:
1571       /* Insn sets the Z,N flags of CC to recog_data.operand[0].
1572          The V flag is unusable.  The C flag may or may not be known but
1573          that's ok because alter_cond will change tests to use EQ/NE.  */
1574       CC_STATUS_INIT;
1575       cc_status.flags |= CC_OVERFLOW_UNUSABLE | CC_NO_CARRY;
1576       cc_status.value1 = recog_data.operand[0];
1577       break;
1578
1579     case CC_SET_ZNV:
1580       /* Insn sets the Z,N,V flags of CC to recog_data.operand[0].
1581          The C flag may or may not be known but that's ok because
1582          alter_cond will change tests to use EQ/NE.  */
1583       CC_STATUS_INIT;
1584       cc_status.flags |= CC_NO_CARRY;
1585       cc_status.value1 = recog_data.operand[0];
1586       break;
1587
1588     case CC_COMPARE:
1589       /* The insn is a compare instruction.  */
1590       CC_STATUS_INIT;
1591       cc_status.value1 = SET_SRC (body);
1592       break;
1593
1594     case CC_CLOBBER:
1595       /* Insn doesn't leave CC in a usable state.  */
1596       CC_STATUS_INIT;
1597       break;
1598     }
1599 }
1600
1601 /* Recognize valid operators for bit instructions.  */
1602
1603 int
1604 bit_operator (x, mode)
1605      rtx x;
1606      enum machine_mode mode ATTRIBUTE_UNUSED;
1607 {
1608   enum rtx_code code = GET_CODE (x);
1609
1610   return (code == XOR
1611           || code == AND
1612           || code == IOR);
1613 }
1614 \f
1615 const char *
1616 output_logical_op (mode, code, operands)
1617      enum machine_mode mode;
1618      int code;
1619      rtx *operands;
1620 {
1621   /* Pretend that every byte is affected if both operands are registers.  */
1622   unsigned HOST_WIDE_INT intval =
1623     (unsigned HOST_WIDE_INT) ((GET_CODE (operands[2]) == CONST_INT)
1624                               ? INTVAL (operands[2]) : 0x55555555);
1625   /* The determinant of the algorithm.  If we perform an AND, 0
1626      affects a bit.  Otherwise, 1 affects a bit.  */
1627   unsigned HOST_WIDE_INT det = (code != AND) ? intval : ~intval;
1628   /* The name of an insn.  */
1629   const char *opname;
1630   char insn_buf[100];
1631
1632   switch (code)
1633     {
1634     case AND:
1635       opname = "and";
1636       break;
1637     case IOR:
1638       opname = "or";
1639       break;
1640     case XOR:
1641       opname = "xor";
1642       break;
1643     default:
1644       abort ();
1645     }
1646
1647   switch (mode)
1648     {
1649     case HImode:
1650       /* First, see if we can finish with one insn.  */
1651       if ((TARGET_H8300H || TARGET_H8300S)
1652           && ((det & 0x00ff) != 0)
1653           && ((det & 0xff00) != 0))
1654         {
1655           sprintf (insn_buf, "%s.w\t%%T2,%%T0", opname);
1656           output_asm_insn (insn_buf, operands);
1657         }
1658       else
1659         {
1660           /* Take care of the lower byte.  */
1661           if ((det & 0x00ff) != 0)
1662             {
1663               sprintf (insn_buf, "%s\t%%s2,%%s0", opname);
1664               output_asm_insn (insn_buf, operands);
1665             }
1666           /* Take care of the upper byte.  */
1667           if ((det & 0xff00) != 0)
1668             {
1669               sprintf (insn_buf, "%s\t%%t2,%%t0", opname);
1670               output_asm_insn (insn_buf, operands);
1671             }
1672         }
1673       break;
1674     case SImode:
1675       /* First, see if we can finish with one insn.
1676
1677          If code is either AND or XOR, we exclude two special cases,
1678          0xffffff00 and 0xffff00ff, because insns like sub.w or neg.w
1679          can do a better job.  */
1680       if ((TARGET_H8300H || TARGET_H8300S)
1681           && ((det & 0x0000ffff) != 0)
1682           && ((det & 0xffff0000) != 0)
1683           && (code == IOR || det != 0xffffff00)
1684           && (code == IOR || det != 0xffff00ff))
1685         {
1686           sprintf (insn_buf, "%s.l\t%%S2,%%S0", opname);
1687           output_asm_insn (insn_buf, operands);
1688         }
1689       else
1690         {
1691           /* Take care of the lower and upper words individually.  For
1692              each word, we try different methods in the order of
1693
1694              1) the special insn (in case of AND or XOR),
1695              2) the word-wise insn, and
1696              3) The byte-wise insn.  */
1697           if ((TARGET_H8300H || TARGET_H8300S)
1698               && ((det & 0x0000ffff) == 0x0000ffff)
1699               && code != IOR)
1700             output_asm_insn ((code == AND)
1701                              ? "sub.w\t%f0,%f0" : "neg.w\t%f0",
1702                              operands);
1703           else if ((TARGET_H8300H || TARGET_H8300S)
1704                    && ((det & 0x000000ff) != 0)
1705                    && ((det & 0x0000ff00) != 0))
1706             {
1707               sprintf (insn_buf, "%s.w\t%%f2,%%f0", opname);
1708               output_asm_insn (insn_buf, operands);
1709             }
1710           else
1711             {
1712               if ((det & 0x000000ff) != 0)
1713                 {
1714                   sprintf (insn_buf, "%s\t%%w2,%%w0", opname);
1715                   output_asm_insn (insn_buf, operands);
1716                 }
1717               if ((det & 0x0000ff00) != 0)
1718                 {
1719                   sprintf (insn_buf, "%s\t%%x2,%%x0", opname);
1720                   output_asm_insn (insn_buf, operands);
1721                 }
1722             }
1723
1724           if ((TARGET_H8300H || TARGET_H8300S)
1725               && ((det & 0xffff0000) == 0xffff0000)
1726               && code != IOR)
1727             output_asm_insn ((code == AND)
1728                              ? "sub.w\t%e0,%e0" : "neg.w\t%e0",
1729                              operands);
1730           else if (TARGET_H8300H || TARGET_H8300S)
1731             {
1732               if ((det & 0xffff0000) != 0)
1733                 {
1734                   sprintf (insn_buf, "%s.w\t%%e2,%%e0", opname);
1735                   output_asm_insn (insn_buf, operands);
1736                 }
1737             }
1738           else
1739             {
1740               if ((det & 0x00ff0000) != 0)
1741                 {
1742                   sprintf (insn_buf, "%s\t%%y2,%%y0", opname);
1743                   output_asm_insn (insn_buf, operands);
1744                 }
1745               if ((det & 0xff000000) != 0)
1746                 {
1747                   sprintf (insn_buf, "%s\t%%z2,%%z0", opname);
1748                   output_asm_insn (insn_buf, operands);
1749                 }
1750             }
1751         }
1752       break;
1753     default:
1754       abort ();
1755     }
1756   return "";
1757 }
1758 \f
1759 /* Shifts.
1760
1761    We devote a fair bit of code to getting efficient shifts since we can only
1762    shift one bit at a time on the H8/300 and H8/300H and only one or two
1763    bits at a time on the H8/S.
1764
1765    The basic shift methods:
1766
1767      * loop shifts -- emit a loop using one (or two on H8/S) bit shifts;
1768      this is the default.  SHIFT_LOOP
1769
1770      * inlined shifts -- emit straight line code for the shift; this is
1771      used when a straight line shift is about the same size or smaller
1772      than a loop.  We allow the inline version to be slightly longer in
1773      some cases as it saves a register.  SHIFT_INLINE
1774
1775      * rotate + and -- rotate the value the opposite direction, then
1776      mask off the values we don't need.  This is used when only a few
1777      of the bits in the original value will survive in the shifted value.
1778      Again, this is used when it's about the same size or smaller than
1779      a loop.  We allow this version to be slightly longer as it is usually
1780      much faster than a loop.  SHIFT_ROT_AND
1781
1782      * swap (+ shifts) -- often it's possible to swap bytes/words to
1783      simulate a shift by 8/16.  Once swapped a few inline shifts can be
1784      added if the shift count is slightly more than 8 or 16.  This is used
1785      when it's about the same size or smaller than a loop.  We allow this
1786      version to be slightly longer as it is usually much faster than a loop.
1787      SHIFT_SPECIAL
1788
1789      * There other oddballs.  Not worth explaining.  SHIFT_SPECIAL
1790
1791    Here are some thoughts on what the absolutely positively best code is.
1792    "Best" here means some rational trade-off between code size and speed,
1793    where speed is more preferred but not at the expense of generating 20 insns.
1794
1795    A trailing '*' after the shift count indicates the "best" mode isn't
1796    implemented.
1797    
1798    H8/300 QImode shifts
1799    1-4    - do them inline
1800    5-6    - ASHIFT | LSHIFTRT: rotate, mask off other bits
1801             ASHIFTRT: loop
1802    7      - ASHIFT | LSHIFTRT: rotate, mask off other bits
1803             ASHIFTRT: shll, subx (propagate carry bit to all bits)
1804
1805    H8/300 HImode shifts
1806    1-4    - do them inline
1807    5-6    - loop
1808    7      - shift 2nd half other way into carry.
1809             copy 1st half into 2nd half
1810             rotate 2nd half other way with carry
1811             rotate 1st half other way (no carry)
1812             mask off bits in 1st half (ASHIFT | LSHIFTRT).
1813             sign extend 1st half (ASHIFTRT)
1814    8      - move byte, zero (ASHIFT | LSHIFTRT) or sign extend other (ASHIFTRT)
1815    9-12   - do shift by 8, inline remaining shifts
1816    13-14* - ASHIFT | LSHIFTRT: rotate 3/2, mask, move byte, set other byte to 0
1817           - ASHIFTRT: loop
1818    15     - ASHIFT | LSHIFTRT: rotate 1, mask, move byte, set other byte to 0
1819           - ASHIFTRT: shll, subx, set other byte
1820
1821    H8/300 SImode shifts
1822    1-2    - do them inline
1823    3-6    - loop
1824    7*     - shift other way once, move bytes into place,
1825             move carry into place (possibly with sign extension)
1826    8      - move bytes into place, zero or sign extend other
1827    9-14   - loop
1828    15*    - shift other way once, move word into place, move carry into place
1829    16     - move word, zero or sign extend other
1830    17-23  - loop
1831    24*    - move bytes into place, zero or sign extend other
1832    25-27  - loop
1833    28-30* - ASHIFT | LSHIFTRT: rotate top byte, mask, move byte into place,
1834                                zero others
1835             ASHIFTRT: loop
1836    31     - ASHIFT | LSHIFTRT: rotate top byte, mask, move byte into place,
1837                                zero others
1838             ASHIFTRT: shll top byte, subx, copy to other bytes
1839
1840    H8/300H QImode shifts (same as H8/300 QImode shifts)
1841    1-4    - do them inline
1842    5-6    - ASHIFT | LSHIFTRT: rotate, mask off other bits
1843             ASHIFTRT: loop
1844    7      - ASHIFT | LSHIFTRT: rotate, mask off other bits
1845             ASHIFTRT: shll, subx (propagate carry bit to all bits)
1846
1847    H8/300H HImode shifts
1848    1-4    - do them inline
1849    5-6    - loop
1850    7      - shift 2nd half other way into carry.
1851             copy 1st half into 2nd half
1852             rotate entire word other way using carry
1853             mask off remaining bits  (ASHIFT | LSHIFTRT)
1854             sign extend remaining bits (ASHIFTRT)
1855    8      - move byte, zero (ASHIFT | LSHIFTRT) or sign extend other (ASHIFTRT)
1856    9-12   - do shift by 8, inline remaining shifts
1857    13-14  - ASHIFT | LSHIFTRT: rotate 3/2, mask, move byte, set other byte to 0
1858           - ASHIFTRT: loop
1859    15     - ASHIFT | LSHIFTRT: rotate 1, mask, move byte, set other byte to 0
1860           - ASHIFTRT: shll, subx, set other byte
1861
1862    H8/300H SImode shifts
1863    (These are complicated by the fact that we don't have byte level access to
1864    the top word.)
1865    A word is: bytes 3,2,1,0 (msb -> lsb), word 1,0 (msw -> lsw)
1866    1-4    - do them inline
1867    5-14   - loop
1868    15*    - shift other way once, move word into place, move carry into place
1869             (with sign extension for ASHIFTRT)
1870    16     - move word into place, zero or sign extend other
1871    17-20  - do 16bit shift, then inline remaining shifts
1872    20-23  - loop
1873    24*    - ASHIFT: move byte 0(msb) to byte 1, zero byte 0,
1874                     move word 0 to word 1, zero word 0
1875             LSHIFTRT: move word 1 to word 0, move byte 1 to byte 0,
1876                       zero word 1, zero byte 1
1877             ASHIFTRT: move word 1 to word 0, move byte 1 to byte 0,
1878                       sign extend byte 0, sign extend word 0
1879    25-27* - either loop, or
1880             do 24 bit shift, inline rest
1881    28-30  - ASHIFT: rotate 4/3/2, mask
1882             LSHIFTRT: rotate 4/3/2, mask
1883             ASHIFTRT: loop
1884    31     - shll, subx byte 0, sign extend byte 0, sign extend word 0
1885
1886    H8/S QImode shifts
1887    1-6    - do them inline
1888    7      - ASHIFT | LSHIFTRT: rotate, mask off other bits
1889             ASHIFTRT: shll, subx (propagate carry bit to all bits)
1890
1891    H8/S HImode shifts
1892    1-7    - do them inline
1893    8      - move byte, zero (ASHIFT | LSHIFTRT) or sign extend other (ASHIFTRT)
1894    9-12   - do shift by 8, inline remaining shifts
1895    13-14  - ASHIFT | LSHIFTRT: rotate 3/2, mask, move byte, set other byte to 0
1896           - ASHIFTRT: loop
1897    15     - ASHIFT | LSHIFTRT: rotate 1, mask, move byte, set other byte to 0
1898           - ASHIFTRT: shll, subx, set other byte
1899
1900    H8/S SImode shifts
1901    (These are complicated by the fact that we don't have byte level access to
1902    the top word.)
1903    A word is: bytes 3,2,1,0 (msb -> lsb), word 1,0 (msw -> lsw)
1904    1-10   - do them inline
1905    11-14  - loop
1906    15*    - shift other way once, move word into place, move carry into place
1907             (with sign extension for ASHIFTRT)
1908    16     - move word into place, zero or sign extend other
1909    17-20  - do 16bit shift, then inline remaining shifts
1910    21-23  - loop
1911    24*    - ASHIFT: move byte 0(msb) to byte 1, zero byte 0,
1912                     move word 0 to word 1, zero word 0
1913             LSHIFTRT: move word 1 to word 0, move byte 1 to byte 0,
1914                       zero word 1, zero byte 1
1915             ASHIFTRT: move word 1 to word 0, move byte 1 to byte 0,
1916                       sign extend byte 0, sign extend word 0
1917    25-27* - either loop, or
1918             do 24 bit shift, inline rest
1919    28-30  - ASHIFT: rotate 4/3/2, mask
1920             LSHIFTRT: rotate 4/3/2, mask
1921             ASHIFTRT: loop
1922    31     - shll, subx byte 0, sign extend byte 0, sign extend word 0
1923
1924    Panic!!!  */
1925
1926 int
1927 nshift_operator (x, mode)
1928      rtx x;
1929      enum machine_mode mode ATTRIBUTE_UNUSED;
1930 {
1931   switch (GET_CODE (x))
1932     {
1933     case ASHIFTRT:
1934     case LSHIFTRT:
1935     case ASHIFT:
1936       return 1;
1937
1938     default:
1939       return 0;
1940     }
1941 }
1942
1943 /* Called from the .md file to emit code to do shifts.
1944    Return a boolean indicating success.
1945    (Currently this is always TRUE).  */
1946
1947 int
1948 expand_a_shift (mode, code, operands)
1949      enum machine_mode mode;
1950      int code;
1951      rtx operands[];
1952 {
1953   emit_move_insn (operands[0], operands[1]);
1954
1955   /* Need a loop to get all the bits we want  - we generate the
1956      code at emit time, but need to allocate a scratch reg now.  */
1957
1958   emit_insn (gen_rtx_PARALLEL
1959              (VOIDmode,
1960               gen_rtvec (2,
1961                          gen_rtx_SET (VOIDmode, operands[0],
1962                                       gen_rtx (code, mode, operands[0],
1963                                                operands[2])),
1964                          gen_rtx_CLOBBER (VOIDmode,
1965                                           gen_rtx_SCRATCH (QImode)))));
1966
1967   return 1;
1968 }
1969
1970 /* Shift algorithm determination.
1971
1972    There are various ways of doing a shift:
1973    SHIFT_INLINE: If the amount is small enough, just generate as many one-bit
1974                  shifts as we need.
1975    SHIFT_ROT_AND: If the amount is large but close to either end, rotate the
1976                   necessary bits into position and then set the rest to zero.
1977    SHIFT_SPECIAL: Hand crafted assembler.
1978    SHIFT_LOOP:    If the above methods fail, just loop.  */
1979
1980 enum shift_alg
1981 {
1982   SHIFT_INLINE,
1983   SHIFT_ROT_AND,
1984   SHIFT_SPECIAL,
1985   SHIFT_LOOP
1986 };
1987
1988 /* Symbols of the various shifts which can be used as indices.  */
1989
1990 enum shift_type
1991 {
1992   SHIFT_ASHIFT, SHIFT_LSHIFTRT, SHIFT_ASHIFTRT
1993 };
1994
1995 /* Symbols of the various modes which can be used as indices.  */
1996
1997 enum shift_mode
1998 {
1999   QIshift, HIshift, SIshift
2000 };
2001
2002 /* For single bit shift insns, record assembler and what bits of the
2003    condition code are valid afterwards (represented as various CC_FOO
2004    bits, 0 means CC isn't left in a usable state).  */
2005
2006 struct shift_insn
2007 {
2008   const char *const assembler;
2009   const int cc_valid;
2010 };
2011
2012 /* Assembler instruction shift table.
2013
2014    These tables are used to look up the basic shifts.
2015    They are indexed by cpu, shift_type, and mode.  */
2016
2017 static const struct shift_insn shift_one[2][3][3] =
2018 {
2019 /* H8/300 */
2020   {
2021 /* SHIFT_ASHIFT */
2022     {
2023       { "shll\t%X0", CC_NO_CARRY },
2024       { "add.w\t%T0,%T0", CC_OVERFLOW_UNUSABLE | CC_NO_CARRY },
2025       { "add.w\t%f0,%f0\n\taddx\t%y0,%y0\n\taddx\t%z0,%z0", 0 }
2026     },
2027 /* SHIFT_LSHIFTRT */
2028     {
2029       { "shlr\t%X0", CC_NO_CARRY },
2030       { "shlr\t%t0\n\trotxr\t%s0", 0 },
2031       { "shlr\t%z0\n\trotxr\t%y0\n\trotxr\t%x0\n\trotxr\t%w0", 0 }
2032     },
2033 /* SHIFT_ASHIFTRT */
2034     {
2035       { "shar\t%X0", CC_OVERFLOW_UNUSABLE | CC_NO_CARRY },
2036       { "shar\t%t0\n\trotxr\t%s0", 0 },
2037       { "shar\t%z0\n\trotxr\t%y0\n\trotxr\t%x0\n\trotxr\t%w0", 0 }
2038     }
2039   },
2040 /* H8/300H */
2041   {
2042 /* SHIFT_ASHIFT */
2043     {
2044       { "shll.b\t%X0", CC_NO_CARRY },
2045       { "shll.w\t%T0", CC_NO_CARRY },
2046       { "shll.l\t%S0", CC_NO_CARRY }
2047     },
2048 /* SHIFT_LSHIFTRT */
2049     {
2050       { "shlr.b\t%X0", CC_NO_CARRY },
2051       { "shlr.w\t%T0", CC_NO_CARRY },
2052       { "shlr.l\t%S0", CC_NO_CARRY }
2053     },
2054 /* SHIFT_ASHIFTRT */
2055     {
2056       { "shar.b\t%X0", CC_OVERFLOW_UNUSABLE | CC_NO_CARRY },
2057       { "shar.w\t%T0", CC_OVERFLOW_UNUSABLE | CC_NO_CARRY },
2058       { "shar.l\t%S0", CC_OVERFLOW_UNUSABLE | CC_NO_CARRY }
2059     }
2060   }
2061 };
2062
2063 static const struct shift_insn shift_two[3][3] =
2064 {
2065 /* SHIFT_ASHIFT */
2066     {
2067       { "shll.b\t#2,%X0", CC_NO_CARRY },
2068       { "shll.w\t#2,%T0", CC_NO_CARRY },
2069       { "shll.l\t#2,%S0", CC_NO_CARRY }
2070     },
2071 /* SHIFT_LSHIFTRT */
2072     {
2073       { "shlr.b\t#2,%X0", CC_NO_CARRY },
2074       { "shlr.w\t#2,%T0", CC_NO_CARRY },
2075       { "shlr.l\t#2,%S0", CC_NO_CARRY }
2076     },
2077 /* SHIFT_ASHIFTRT */
2078     {
2079       { "shar.b\t#2,%X0", CC_OVERFLOW_UNUSABLE | CC_NO_CARRY },
2080       { "shar.w\t#2,%T0", CC_OVERFLOW_UNUSABLE | CC_NO_CARRY },
2081       { "shar.l\t#2,%S0", CC_OVERFLOW_UNUSABLE | CC_NO_CARRY }
2082     }
2083 };
2084
2085 /* Rotates are organized by which shift they'll be used in implementing.
2086    There's no need to record whether the cc is valid afterwards because
2087    it is the AND insn that will decide this.  */
2088
2089 static const char *const rotate_one[2][3][3] =
2090 {
2091 /* H8/300 */
2092   {
2093 /* SHIFT_ASHIFT */
2094     {
2095       "rotr\t%X0",
2096       "shlr\t%t0\n\trotxr\t%s0\n\tbst\t#7,%t0",
2097       0
2098     },
2099 /* SHIFT_LSHIFTRT */
2100     {
2101       "rotl\t%X0",
2102       "shll\t%s0\n\trotxl\t%t0\n\tbst\t#0,%s0",
2103       0
2104     },
2105 /* SHIFT_ASHIFTRT */
2106     {
2107       "rotl\t%X0",
2108       "shll\t%s0\n\trotxl\t%t0\n\tbst\t#0,%s0",
2109       0
2110     }
2111   },
2112 /* H8/300H */
2113   {
2114 /* SHIFT_ASHIFT */
2115     {
2116       "rotr.b\t%X0",
2117       "rotr.w\t%T0",
2118       "rotr.l\t%S0"
2119     },
2120 /* SHIFT_LSHIFTRT */
2121     {
2122       "rotl.b\t%X0",
2123       "rotl.w\t%T0",
2124       "rotl.l\t%S0"
2125     },
2126 /* SHIFT_ASHIFTRT */
2127     {
2128       "rotl.b\t%X0",
2129       "rotl.w\t%T0",
2130       "rotl.l\t%S0"
2131     }
2132   }
2133 };
2134
2135 static const char *const rotate_two[3][3] =
2136 {
2137 /* SHIFT_ASHIFT */
2138     {
2139       "rotr.b\t#2,%X0",
2140       "rotr.w\t#2,%T0",
2141       "rotr.l\t#2,%S0"
2142     },
2143 /* SHIFT_LSHIFTRT */
2144     {
2145       "rotl.b\t#2,%X0",
2146       "rotl.w\t#2,%T0",
2147       "rotl.l\t#2,%S0"
2148     },
2149 /* SHIFT_ASHIFTRT */
2150     {
2151       "rotl.b\t#2,%X0",
2152       "rotl.w\t#2,%T0",
2153       "rotl.l\t#2,%S0"
2154     }
2155 };
2156
2157 /* Macros to keep the shift algorithm tables small.  */
2158 #define INL SHIFT_INLINE
2159 #define ROT SHIFT_ROT_AND
2160 #define LOP SHIFT_LOOP
2161 #define SPC SHIFT_SPECIAL
2162
2163 /* The shift algorithms for each machine, mode, shift type, and shift
2164    count are defined below.  The three tables below correspond to
2165    QImode, HImode, and SImode, respectively.  Each table is organized
2166    by, in the order of indecies, machine, shift type, and shift count.  */
2167
2168 static const enum shift_alg shift_alg_qi[3][3][8] = {
2169   {
2170     /* TARGET_H8300  */
2171     /* 0    1    2    3    4    5    6    7  */
2172     { INL, INL, INL, INL, INL, ROT, ROT, ROT }, /* SHIFT_ASHIFT   */
2173     { INL, INL, INL, INL, INL, ROT, ROT, ROT }, /* SHIFT_LSHIFTRT */
2174     { INL, INL, INL, INL, INL, LOP, LOP, SPC }  /* SHIFT_ASHIFTRT */
2175   },
2176   {
2177     /* TARGET_H8300H  */
2178     /* 0    1    2    3    4    5    6    7  */
2179     { INL, INL, INL, INL, INL, ROT, ROT, ROT }, /* SHIFT_ASHIFT   */
2180     { INL, INL, INL, INL, INL, ROT, ROT, ROT }, /* SHIFT_LSHIFTRT */
2181     { INL, INL, INL, INL, INL, LOP, LOP, SPC }  /* SHIFT_ASHIFTRT */
2182   },
2183   {
2184     /* TARGET_H8300S  */
2185     /*  0    1    2    3    4    5    6    7  */
2186     { INL, INL, INL, INL, INL, INL, INL, ROT }, /* SHIFT_ASHIFT   */
2187     { INL, INL, INL, INL, INL, INL, INL, ROT }, /* SHIFT_LSHIFTRT */
2188     { INL, INL, INL, INL, INL, INL, INL, SPC }  /* SHIFT_ASHIFTRT */
2189   }
2190 };
2191
2192 static const enum shift_alg shift_alg_hi[3][3][16] = {
2193   {
2194     /* TARGET_H8300  */
2195     /*  0    1    2    3    4    5    6    7  */
2196     /*  8    9   10   11   12   13   14   15  */
2197     { INL, INL, INL, INL, INL, LOP, LOP, SPC,
2198       SPC, SPC, SPC, SPC, SPC, LOP, LOP, ROT }, /* SHIFT_ASHIFT   */
2199     { INL, INL, INL, INL, INL, LOP, LOP, SPC,
2200       SPC, SPC, SPC, SPC, SPC, LOP, LOP, ROT }, /* SHIFT_LSHIFTRT */
2201     { INL, INL, INL, INL, INL, LOP, LOP, SPC,
2202       SPC, SPC, SPC, SPC, SPC, LOP, LOP, SPC }, /* SHIFT_ASHIFTRT */
2203   },
2204   {
2205     /* TARGET_H8300H  */
2206     /*  0    1    2    3    4    5    6    7  */
2207     /*  8    9   10   11   12   13   14   15  */
2208     { INL, INL, INL, INL, INL, LOP, LOP, SPC,
2209       SPC, SPC, SPC, SPC, SPC, ROT, ROT, ROT }, /* SHIFT_ASHIFT   */
2210     { INL, INL, INL, INL, INL, LOP, LOP, SPC,
2211       SPC, SPC, SPC, SPC, SPC, ROT, ROT, ROT }, /* SHIFT_LSHIFTRT */
2212     { INL, INL, INL, INL, INL, LOP, LOP, SPC,
2213       SPC, SPC, SPC, SPC, SPC, LOP, LOP, SPC }, /* SHIFT_ASHIFTRT */
2214   },
2215   {
2216     /* TARGET_H8300S  */
2217     /*  0    1    2    3    4    5    6    7  */
2218     /*  8    9   10   11   12   13   14   15  */
2219     { INL, INL, INL, INL, INL, INL, INL, INL,
2220       SPC, SPC, SPC, SPC, SPC, ROT, ROT, ROT }, /* SHIFT_ASHIFT   */
2221     { INL, INL, INL, INL, INL, INL, INL, INL,
2222       SPC, SPC, SPC, SPC, SPC, ROT, ROT, ROT }, /* SHIFT_LSHIFTRT */
2223     { INL, INL, INL, INL, INL, INL, INL, INL,
2224       SPC, SPC, SPC, SPC, SPC, LOP, LOP, SPC }, /* SHIFT_ASHIFTRT */
2225   }
2226 };
2227
2228 static const enum shift_alg shift_alg_si[3][3][32] = {
2229   {
2230     /* TARGET_H8300  */
2231     /*  0    1    2    3    4    5    6    7  */
2232     /*  8    9   10   11   12   13   14   15  */
2233     /* 16   17   18   19   20   21   22   23  */
2234     /* 24   25   26   27   28   29   30   31  */
2235     { INL, INL, INL, LOP, LOP, LOP, LOP, LOP,
2236       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2237       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2238       LOP, LOP, LOP, LOP, LOP, LOP, LOP, SPC }, /* SHIFT_ASHIFT   */
2239     { INL, INL, INL, LOP, LOP, LOP, LOP, LOP,
2240       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2241       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2242       LOP, LOP, LOP, LOP, LOP, LOP, LOP, SPC }, /* SHIFT_LSHIFTRT */
2243     { INL, INL, INL, LOP, LOP, LOP, LOP, LOP,
2244       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2245       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2246       LOP, LOP, LOP, LOP, LOP, LOP, LOP, SPC }, /* SHIFT_ASHIFTRT */
2247   },
2248   {
2249     /* TARGET_H8300H  */
2250     /*  0    1    2    3    4    5    6    7  */
2251     /*  8    9   10   11   12   13   14   15  */
2252     /* 16   17   18   19   20   21   22   23  */
2253     /* 24   25   26   27   28   29   30   31  */
2254     { INL, INL, INL, INL, INL, LOP, LOP, LOP,
2255       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2256       SPC, SPC, SPC, SPC, LOP, LOP, LOP, LOP,
2257       SPC, LOP, LOP, LOP, ROT, ROT, ROT, ROT }, /* SHIFT_ASHIFT   */
2258     { INL, INL, INL, INL, INL, LOP, LOP, LOP,
2259       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2260       SPC, SPC, SPC, SPC, LOP, LOP, LOP, LOP,
2261       SPC, LOP, LOP, LOP, ROT, ROT, ROT, ROT }, /* SHIFT_LSHIFTRT */
2262     { INL, INL, INL, INL, INL, LOP, LOP, LOP,
2263       SPC, LOP, LOP, LOP, LOP, LOP, LOP, LOP,
2264       SPC, SPC, SPC, SPC, LOP, LOP, LOP, LOP,
2265       SPC, LOP, LOP, LOP, LOP, LOP, LOP, SPC }, /* SHIFT_ASHIFTRT */
2266   },
2267   {
2268     /* TARGET_H8300S  */
2269     /*  0    1    2    3    4    5    6    7  */
2270     /*  8    9   10   11   12   13   14   15  */
2271     /* 16   17   18   19   20   21   22   23  */
2272     /* 24   25   26   27   28   29   30   31  */
2273     { INL, INL, INL, INL, INL, INL, INL, INL,
2274       INL, INL, INL, LOP, LOP, LOP, LOP, LOP,
2275       SPC, SPC, SPC, SPC, SPC, LOP, LOP, LOP,
2276       SPC, LOP, LOP, LOP, ROT, ROT, ROT, ROT }, /* SHIFT_ASHIFT   */
2277     { INL, INL, INL, INL, INL, INL, INL, INL,
2278       INL, INL, INL, LOP, LOP, LOP, LOP, LOP,
2279       SPC, SPC, SPC, SPC, SPC, LOP, LOP, LOP,
2280       SPC, LOP, LOP, LOP, ROT, ROT, ROT, ROT }, /* SHIFT_LSHIFTRT */
2281     { INL, INL, INL, INL, INL, INL, INL, INL,
2282       INL, INL, INL, LOP, LOP, LOP, LOP, LOP,
2283       SPC, SPC, SPC, SPC, SPC, LOP, LOP, LOP,
2284       SPC, LOP, LOP, LOP, LOP, LOP, LOP, SPC }, /* SHIFT_ASHIFTRT */
2285   }
2286 };
2287
2288 #undef INL
2289 #undef ROT
2290 #undef LOP
2291 #undef SPC
2292
2293 struct shift_info {
2294   /* Shift algorithm.  */
2295   enum shift_alg alg;
2296
2297   /* The number of bits to be shifted by shift1 and shift2.  Valid
2298      when ALG is SHIFT_SPECIAL.  */
2299   unsigned int remainder;
2300
2301   /* Special insn for a shift.  Valid when ALG is SHIFT_SPECIAL.  */
2302   const char *special;
2303
2304   /* Insn for a one-bit shift.  Valid when ALG is either SHIFT_INLINE
2305      or SHIFT_SPECIAL, and REMAINDER is non-zero.  */
2306   const char *shift1;
2307
2308   /* Insn for a two-bit shift.  Valid when ALG is either SHIFT_INLINE
2309      or SHIFT_SPECIAL, and REMAINDER is non-zero.  */
2310   const char *shift2;
2311
2312   /* Valid CC flags.  */
2313   int cc_valid_p;
2314 };
2315
2316 static void get_shift_alg PARAMS ((enum shift_type,
2317                                    enum shift_mode, unsigned int,
2318                                    struct shift_info *));
2319
2320 /* Given SHIFT_TYPE, SHIFT_MODE, and shift count COUNT, determine the
2321    best algorithm for doing the shift.  The assembler code is stored
2322    in the pointers in INFO.  We don't achieve maximum efficiency in
2323    all cases, but the hooks are here to do so.
2324
2325    For now we just use lots of switch statements.  Since we don't even come
2326    close to supporting all the cases, this is simplest.  If this function ever
2327    gets too big, perhaps resort to a more table based lookup.  Of course,
2328    at this point you may just wish to do it all in rtl.
2329
2330    WARNING: The constraints on insns shiftbyn_QI/HI/SI assume shifts of
2331    1,2,3,4 will be inlined (1,2 for SI).  */
2332
2333 static void
2334 get_shift_alg (shift_type, shift_mode, count, info)
2335      enum shift_type shift_type;
2336      enum shift_mode shift_mode;
2337      unsigned int count;
2338      struct shift_info *info;
2339 {
2340   int cpu;
2341
2342   /* Find the target CPU.  */
2343   if (TARGET_H8300)
2344     cpu = 0;
2345   else if (TARGET_H8300H)
2346     cpu = 1;
2347   else
2348     cpu = 2;
2349
2350   /* Find the shift algorithm.  */
2351   switch (shift_mode)
2352     {
2353     case QIshift:
2354       if (GET_MODE_BITSIZE (QImode) <= count)
2355         info->alg = SHIFT_LOOP;
2356       else
2357         info->alg = shift_alg_qi[cpu][shift_type][count];
2358       break;
2359
2360     case HIshift:
2361       if (GET_MODE_BITSIZE (HImode) <= count)
2362         info->alg = SHIFT_LOOP;
2363       else
2364         info->alg = shift_alg_hi[cpu][shift_type][count];
2365       break;
2366
2367     case SIshift:
2368       if (GET_MODE_BITSIZE (SImode) <= count)
2369         info->alg = SHIFT_LOOP;
2370       else
2371         info->alg = shift_alg_si[cpu][shift_type][count];
2372       break;
2373
2374     default:
2375       abort ();
2376     }
2377
2378   /* Fill in INFO.  Return unless we have SHIFT_SPECIAL.  */
2379   switch (info->alg)
2380     {
2381     case SHIFT_INLINE:
2382       info->remainder = count;
2383       /* Fall through.  */
2384
2385     case SHIFT_LOOP:
2386       /* It is up to the caller to know that looping clobbers cc.  */
2387       info->shift1 = shift_one[cpu_type][shift_type][shift_mode].assembler;
2388       info->shift2 = shift_two[shift_type][shift_mode].assembler;
2389       info->cc_valid_p = shift_one[cpu_type][shift_type][shift_mode].cc_valid;
2390       goto end;
2391
2392     case SHIFT_ROT_AND:
2393       info->shift1 = rotate_one[cpu_type][shift_type][shift_mode];
2394       info->shift2 = rotate_two[shift_type][shift_mode];
2395       info->cc_valid_p = 0;
2396       goto end;
2397
2398     case SHIFT_SPECIAL:
2399       /* REMAINDER is 0 for most cases, so initialize it to 0.  */
2400       info->remainder = 0;
2401       info->shift1 = shift_one[cpu_type][shift_type][shift_mode].assembler;
2402       info->shift2 = shift_two[shift_type][shift_mode].assembler;
2403       info->cc_valid_p = 0;
2404       break;
2405     }
2406
2407   /* Here we only deal with SHIFT_SPECIAL.  */
2408   switch (shift_mode)
2409     {
2410     case QIshift:
2411       /* For ASHIFTRT by 7 bits, the sign bit is simply replicated
2412          through the entire value.  */
2413       if (shift_type == SHIFT_ASHIFTRT && count == 7)
2414         {
2415           info->special = "shll\t%X0\n\tsubx\t%X0,%X0";
2416           goto return_shift_special;
2417         }
2418       abort ();
2419
2420     case HIshift:
2421       if (count == 7)
2422         {
2423           if (shift_type == SHIFT_ASHIFT && TARGET_H8300)
2424             {
2425               info->special = "shar.b\t%t0\n\tmov.b\t%s0,%t0\n\trotxr.b\t%t0\n\trotr.b\t%s0\n\tand.b\t#0x80,%s0";
2426               goto return_shift_special;
2427             }
2428
2429           if (shift_type == SHIFT_ASHIFT && TARGET_H8300H)
2430             {
2431               info->special = "shar.b\t%t0\n\tmov.b\t%s0,%t0\n\trotxr.w\t%T0\n\tand.b\t#0x80,%s0";
2432               goto return_shift_special;
2433             }
2434
2435           if (shift_type == SHIFT_LSHIFTRT && TARGET_H8300)
2436             {
2437               info->special = "shal.b\t%s0\n\tmov.b\t%t0,%s0\n\trotxl.b\t%s0\n\trotl.b\t%t0\n\tand.b\t#0x01,%t0";
2438               goto return_shift_special;
2439             }
2440
2441           if (shift_type == SHIFT_LSHIFTRT && TARGET_H8300H)
2442             {
2443               info->special = "shal.b\t%s0\n\tmov.b\t%t0,%s0\n\trotxl.w\t%T0\n\tand.b\t#0x01,%t0";
2444               goto return_shift_special;
2445             }
2446
2447           if (shift_type == SHIFT_ASHIFTRT)
2448             {
2449               info->special = "shal.b\t%s0\n\tmov.b\t%t0,%s0\n\trotxl.b\t%s0\n\tsubx\t%t0,%t0";
2450               goto return_shift_special;
2451             }
2452         }
2453       else if (8 <= count && count <= 12)
2454         {
2455           info->remainder = count - 8;
2456
2457           switch (shift_type)
2458             {
2459             case SHIFT_ASHIFT:
2460               info->special = "mov.b\t%s0,%t0\n\tsub.b\t%s0,%s0";
2461               info->shift1  = "shal.b\t%t0";
2462               info->shift2  = "shal.b\t#2,%t0";
2463               goto return_shift_special;
2464             case SHIFT_LSHIFTRT:
2465               info->special = "mov.b\t%t0,%s0\n\tsub.b\t%t0,%t0";
2466               info->shift1  = "shlr.b\t%s0";
2467               info->shift2  = "shlr.b\t#2,%s0";
2468               goto return_shift_special;
2469             case SHIFT_ASHIFTRT:
2470               if (TARGET_H8300)
2471                 info->special = "mov.b\t%t0,%s0\n\tbld\t#7,%s0\n\tsubx\t%t0,%t0";
2472               else
2473                 info->special = "mov.b\t%t0,%s0\n\texts.w\t%T0";
2474               info->shift1 = "shar.b\t%s0";
2475               info->shift2 = "shar.b\t#2,%s0";
2476               goto return_shift_special;
2477             }
2478         }
2479       else if (count == 15 && shift_type == SHIFT_ASHIFTRT)
2480         {
2481           info->special = "shll\t%t0\n\tsubx\t%t0,%t0\n\tmov.b\t%t0,%s0";
2482           goto return_shift_special;
2483         }
2484       abort ();
2485
2486     case SIshift:
2487       if (count == 8 && TARGET_H8300)
2488         {
2489           switch (shift_type)
2490             {
2491             case SHIFT_ASHIFT:
2492               info->special = "mov.b\t%y0,%z0\n\tmov.b\t%x0,%y0\n\tmov.b\t%w0,%x0\n\tsub.b\t%w0,%w0";
2493               goto return_shift_special;
2494             case SHIFT_LSHIFTRT:
2495               info->special = "mov.b\t%x0,%w0\n\tmov.b\t%y0,%x0\n\tmov.b\t%z0,%y0\n\tsub.b\t%z0,%z0";
2496               goto return_shift_special;
2497             case SHIFT_ASHIFTRT:
2498               info->special = "mov.b\t%x0,%w0\n\tmov.b\t%y0,%x0\n\tmov.b\t%z0,%y0\n\tshll\t%z0\n\tsubx\t%z0,%z0";
2499               goto return_shift_special;
2500             }
2501         }
2502       else if (count == 8 && !TARGET_H8300)
2503         {
2504           switch (shift_type)
2505             {
2506             case SHIFT_ASHIFT:
2507               info->special = "mov.w\t%e0,%f4\n\tmov.b\t%s4,%t4\n\tmov.b\t%t0,%s4\n\tmov.b\t%s0,%t0\n\tsub.b\t%s0,%s0\n\tmov.w\t%f4,%e0";
2508               goto return_shift_special;
2509             case SHIFT_LSHIFTRT:
2510               info->special = "mov.w\t%e0,%f4\n\tmov.b\t%t0,%s0\n\tmov.b\t%s4,%t0\n\tmov.b\t%t4,%s4\n\textu.w\t%f4\n\tmov.w\t%f4,%e0";
2511               goto return_shift_special;
2512             case SHIFT_ASHIFTRT:
2513               info->special = "mov.w\t%e0,%f4\n\tmov.b\t%t0,%s0\n\tmov.b\t%s4,%t0\n\tmov.b\t%t4,%s4\n\texts.w\t%f4\n\tmov.w\t%f4,%e0";
2514               goto return_shift_special;
2515             }
2516         }
2517       else if ((TARGET_H8300 && count == 16)
2518                || (TARGET_H8300H && 16 <= count && count <= 19)
2519                || (TARGET_H8300S && 16 <= count && count <= 20))
2520         {
2521           info->remainder = count - 16;
2522
2523           switch (shift_type)
2524             {
2525             case SHIFT_ASHIFT:
2526               info->special = "mov.w\t%f0,%e0\n\tsub.w\t%f0,%f0";
2527               info->shift1  = "shll.l\t%S0";
2528               info->shift2  = "shll.l\t#2,%S0";
2529               goto return_shift_special;
2530             case SHIFT_LSHIFTRT:
2531               info->special = "mov.w\t%e0,%f0\n\tsub.w\t%e0,%e0";
2532               info->shift1  = "shlr.l\t%S0";
2533               info->shift2  = "shlr.l\t#2,%S0";
2534               goto return_shift_special;
2535             case SHIFT_ASHIFTRT:
2536               if (TARGET_H8300)
2537                 info->special = "mov.w\t%e0,%f0\n\tshll\t%z0\n\tsubx\t%z0,%z0\n\tmov.b\t%z0,%y0";
2538               else
2539                 info->special = "mov.w\t%e0,%f0\n\texts.l\t%S0";
2540               info->shift1 = "shar.l\t%S0";
2541               info->shift2 = "shar.l\t#2,%S0";
2542               goto return_shift_special;
2543             }
2544         }
2545       else if (count == 24 && !TARGET_H8300)
2546         {
2547           switch (shift_type)
2548             {
2549             case SHIFT_ASHIFT:
2550               info->special = "mov.b\t%s0,%t0\n\tsub.b\t%s0,%s0\n\tmov.w\t%f0,%e0\n\tsub.w\t%f0,%f0";
2551               goto return_shift_special;
2552             case SHIFT_LSHIFTRT:
2553               info->special = "mov.w\t%e0,%f0\n\tmov.b\t%t0,%s0\n\textu.w\t%f0\n\textu.l\t%S0";
2554               goto return_shift_special;
2555             case SHIFT_ASHIFTRT:
2556               info->special = "mov.w\t%e0,%f0\n\tmov.b\t%t0,%s0\n\texts.w\t%f0\n\texts.l\t%S0";
2557               goto return_shift_special;
2558             }
2559         }
2560       else if (count == 31)
2561         {
2562           if (shift_type == SHIFT_ASHIFTRT)
2563             {
2564               if (TARGET_H8300)
2565                 info->special = "shll\t%z0\n\tsubx\t%w0,%w0\n\tmov.b\t%w0,%x0\n\tmov.w\t%f0,%e0";
2566               else
2567                 info->special = "shll\t%e0\n\tsubx\t%w0,%w0\n\tmov.b\t%w0,%x0\n\tmov.w\t%f0,%e0";
2568               goto return_shift_special;
2569             }
2570           else
2571             {
2572               if (TARGET_H8300)
2573                 {
2574                   if (shift_type == SHIFT_ASHIFT)
2575                     info->special = "sub.w\t%e0,%e0\n\tshlr\t%w0\n\tmov.w\t%e0,%f0\n\trotxr\t%z0";
2576                   else
2577                     info->special = "sub.w\t%f0,%f0\n\tshll\t%z0\n\tmov.w\t%f0,%e0\n\trotxl\t%w0";
2578                   goto return_shift_special;
2579                 }
2580             }
2581         }
2582       abort ();
2583
2584     default:
2585       abort ();
2586     }
2587
2588  return_shift_special:
2589  end:
2590   if (!TARGET_H8300S)
2591     info->shift2 = NULL;
2592 }
2593
2594 /* Emit the assembler code for doing shifts.  */
2595
2596 const char *
2597 emit_a_shift (insn, operands)
2598      rtx insn ATTRIBUTE_UNUSED;
2599      rtx *operands;
2600 {
2601   static int loopend_lab;
2602   rtx shift = operands[3];
2603   enum machine_mode mode = GET_MODE (shift);
2604   enum rtx_code code = GET_CODE (shift);
2605   enum shift_type shift_type;
2606   enum shift_mode shift_mode;
2607   struct shift_info info;
2608
2609   loopend_lab++;
2610
2611   switch (mode)
2612     {
2613     case QImode:
2614       shift_mode = QIshift;
2615       break;
2616     case HImode:
2617       shift_mode = HIshift;
2618       break;
2619     case SImode:
2620       shift_mode = SIshift;
2621       break;
2622     default:
2623       abort ();
2624     }
2625
2626   switch (code)
2627     {
2628     case ASHIFTRT:
2629       shift_type = SHIFT_ASHIFTRT;
2630       break;
2631     case LSHIFTRT:
2632       shift_type = SHIFT_LSHIFTRT;
2633       break;
2634     case ASHIFT:
2635       shift_type = SHIFT_ASHIFT;
2636       break;
2637     default:
2638       abort ();
2639     }
2640
2641   if (GET_CODE (operands[2]) != CONST_INT)
2642     {
2643       /* Indexing by reg, so have to loop and test at top.  */
2644       output_asm_insn ("mov.b   %X2,%X4", operands);
2645       fprintf (asm_out_file, "\tble     .Lle%d\n", loopend_lab);
2646
2647       /* Get the assembler code to do one shift.  */
2648       get_shift_alg (shift_type, shift_mode, 1, &info);
2649
2650       fprintf (asm_out_file, ".Llt%d:\n", loopend_lab);
2651       output_asm_insn (info.shift1, operands);
2652       output_asm_insn ("add     #0xff,%X4", operands);
2653       fprintf (asm_out_file, "\tbne     .Llt%d\n", loopend_lab);
2654       fprintf (asm_out_file, ".Lle%d:\n", loopend_lab);
2655
2656       return "";
2657     }
2658   else
2659     {
2660       int n = INTVAL (operands[2]);
2661
2662       /* If the count is negative, make it 0.  */
2663       if (n < 0)
2664         n = 0;
2665       /* If the count is too big, truncate it.
2666          ANSI says shifts of GET_MODE_BITSIZE are undefined - we choose to
2667          do the intuitive thing.  */
2668       else if ((unsigned int) n > GET_MODE_BITSIZE (mode))
2669         n = GET_MODE_BITSIZE (mode);
2670
2671       get_shift_alg (shift_type, shift_mode, n, &info);
2672
2673       switch (info.alg)
2674         {
2675         case SHIFT_SPECIAL:
2676           output_asm_insn (info.special, operands);
2677           /* Fall through.  */
2678
2679         case SHIFT_INLINE:
2680           n = info.remainder;
2681
2682           /* Emit two bit shifts first.  */
2683           while (n > 1 && info.shift2 != NULL)
2684             {
2685               output_asm_insn (info.shift2, operands);
2686               n -= 2;
2687             }
2688
2689           /* Now emit one bit shifts for any residual.  */
2690           while (n > 0)
2691             {
2692               output_asm_insn (info.shift1, operands);
2693               n -= 1;
2694             }
2695
2696           /* Keep track of CC.  */
2697           if (info.cc_valid_p)
2698             {
2699               cc_status.value1 = operands[0];
2700               cc_status.flags |= info.cc_valid_p;
2701             }
2702           return "";
2703
2704         case SHIFT_ROT_AND:
2705           {
2706             int m = GET_MODE_BITSIZE (mode) - n;
2707             int mask = (shift_type == SHIFT_ASHIFT
2708                         ? ((1 << (GET_MODE_BITSIZE (mode) - n)) - 1) << n
2709                         : (1 << (GET_MODE_BITSIZE (mode) - n)) - 1);
2710             char insn_buf[200];
2711
2712             /* Not all possibilities of rotate are supported.  They shouldn't
2713                be generated, but let's watch for 'em.  */
2714             if (info.shift1 == 0)
2715               abort ();
2716
2717             /* Emit two bit rotates first.  */
2718             while (m > 1 && info.shift2 != NULL)
2719               {
2720                 output_asm_insn (info.shift2, operands);
2721                 m -= 2;
2722               }
2723
2724             /* Now single bit rotates for any residual.  */
2725             while (m > 0)
2726               {
2727                 output_asm_insn (info.shift1, operands);
2728                 m -= 1;
2729               }
2730
2731             /* Now mask off the high bits.  */
2732             if (TARGET_H8300)
2733               {
2734                 switch (mode)
2735                   {
2736                   case QImode:
2737                     sprintf (insn_buf, "and\t#%d,%%X0", mask);
2738                     cc_status.value1 = operands[0];
2739                     cc_status.flags |= CC_NO_CARRY;
2740                     break;
2741                   case HImode:
2742                     sprintf (insn_buf, "and\t#%d,%%s0\n\tand\t#%d,%%t0",
2743                              mask & 255, mask >> 8);
2744                     break;
2745                   case SImode:
2746                     abort ();
2747                   default:
2748                     break;
2749                   }
2750               }
2751             else
2752               {
2753                 sprintf (insn_buf, "and.%c\t#%d,%%%c0",
2754                          "bwl"[shift_mode], mask,
2755                          mode == QImode ? 'X' : mode == HImode ? 'T' : 'S');
2756                 cc_status.value1 = operands[0];
2757                 cc_status.flags |= CC_NO_CARRY;
2758               }
2759             output_asm_insn (insn_buf, operands);
2760             return "";
2761           }
2762
2763         case SHIFT_LOOP:
2764           /* A loop to shift by a "large" constant value.
2765              If we have shift-by-2 insns, use them.  */
2766           if (info.shift2 != NULL)
2767             {
2768               fprintf (asm_out_file, "\tmov.b   #%d,%sl\n", n / 2,
2769                        names_big[REGNO (operands[4])]);
2770               fprintf (asm_out_file, ".Llt%d:\n", loopend_lab);
2771               output_asm_insn (info.shift2, operands);
2772               output_asm_insn ("add     #0xff,%X4", operands);
2773               fprintf (asm_out_file, "\tbne     .Llt%d\n", loopend_lab);
2774               if (n % 2)
2775                 output_asm_insn (info.shift1, operands);
2776             }
2777           else
2778             {
2779               fprintf (asm_out_file, "\tmov.b   #%d,%sl\n", n,
2780                        names_big[REGNO (operands[4])]);
2781               fprintf (asm_out_file, ".Llt%d:\n", loopend_lab);
2782               output_asm_insn (info.shift1, operands);
2783               output_asm_insn ("add     #0xff,%X4", operands);
2784               fprintf (asm_out_file, "\tbne     .Llt%d\n", loopend_lab);
2785             }
2786           return "";
2787
2788         default:
2789           abort ();
2790         }
2791     }
2792 }
2793 \f
2794 /* A rotation by a non-constant will cause a loop to be generated, in
2795    which a rotation by one bit is used.  A rotation by a constant,
2796    including the one in the loop, will be taken care of by
2797    emit_a_rotate () at the insn emit time.  */
2798
2799 int
2800 expand_a_rotate (code, operands)
2801      int code;
2802      rtx operands[];
2803 {
2804   rtx dst = operands[0];
2805   rtx src = operands[1];
2806   rtx rotate_amount = operands[2];
2807   enum machine_mode mode = GET_MODE (dst);
2808   rtx tmp;
2809
2810   /* We rotate in place.  */
2811   emit_move_insn (dst, src);
2812
2813   if (GET_CODE (rotate_amount) != CONST_INT)
2814     {
2815       rtx counter = gen_reg_rtx (QImode);
2816       rtx start_label = gen_label_rtx ();
2817       rtx end_label = gen_label_rtx ();
2818
2819       /* If the rotate amount is less than or equal to 0,
2820          we go out of the loop.  */
2821       emit_cmp_and_jump_insns (rotate_amount, GEN_INT (0),
2822                                LE, NULL_RTX, QImode, 0, 0, end_label);
2823
2824       /* Initialize the loop counter.  */
2825       emit_move_insn (counter, rotate_amount);
2826
2827       emit_label (start_label);
2828
2829       /* Rotate by one bit.  */
2830       tmp = gen_rtx (code, mode, dst, GEN_INT (1));
2831       emit_insn (gen_rtx_SET (mode, dst, tmp));
2832
2833       /* Decrement the counter by 1.  */
2834       tmp = gen_rtx_PLUS (QImode, counter, GEN_INT (-1));
2835       emit_insn (gen_rtx_SET (VOIDmode, counter, tmp));
2836
2837       /* If the loop counter is non-zero, we go back to the beginning
2838          of the loop.  */
2839       emit_cmp_and_jump_insns (counter, GEN_INT (0),
2840                                NE, NULL_RTX, QImode, 1, 0, start_label);
2841
2842       emit_label (end_label);
2843     }
2844   else
2845     {
2846       /* Rotate by AMOUNT bits.  */
2847       tmp = gen_rtx (code, mode, dst, rotate_amount);
2848       emit_insn (gen_rtx_SET (mode, dst, tmp));
2849     }
2850
2851   return 1;
2852 }
2853
2854 /* Emit rotate insns.  */
2855
2856 const char *
2857 emit_a_rotate (code, operands)
2858      int code;
2859      rtx *operands;
2860 {
2861   rtx dst = operands[0];
2862   rtx rotate_amount = operands[2];
2863   enum shift_mode rotate_mode;
2864   enum shift_type rotate_type;
2865   const char *insn_buf;
2866   int bits;
2867   int amount;
2868   enum machine_mode mode = GET_MODE (dst);
2869
2870   if (GET_CODE (rotate_amount) != CONST_INT)
2871     abort ();
2872
2873   switch (mode)
2874     {
2875     case QImode:
2876       rotate_mode = QIshift;
2877       break;
2878     case HImode:
2879       rotate_mode = HIshift;
2880       break;
2881     case SImode:
2882       rotate_mode = SIshift;
2883       break;
2884     default:
2885       abort ();
2886     }
2887
2888   switch (code)
2889     {
2890     case ROTATERT:
2891       rotate_type = SHIFT_ASHIFT;
2892       break;
2893     case ROTATE:
2894       rotate_type = SHIFT_LSHIFTRT;
2895       break;
2896     default:
2897       abort ();
2898     }
2899
2900   amount = INTVAL (rotate_amount);
2901
2902   /* Clean up AMOUNT.  */
2903   if (amount < 0)
2904     amount = 0;
2905   if ((unsigned int) amount > GET_MODE_BITSIZE (mode))
2906     amount = GET_MODE_BITSIZE (mode);
2907
2908   /* Determine the faster direction.  After this phase, amount will be
2909      at most a half of GET_MODE_BITSIZE (mode).  */
2910   if ((unsigned int) amount > GET_MODE_BITSIZE (mode) / 2)
2911     {
2912       /* Flip the direction.  */
2913       amount = GET_MODE_BITSIZE (mode) - amount;
2914       rotate_type =
2915         (rotate_type == SHIFT_ASHIFT) ? SHIFT_LSHIFTRT : SHIFT_ASHIFT;
2916     }
2917
2918   /* See if a byte swap (in HImode) or a word swap (in SImode) can
2919      boost up the rotation.  */
2920   if ((mode == HImode && TARGET_H8300 && amount >= 5)
2921       || (mode == HImode && TARGET_H8300H && amount >= 6)
2922       || (mode == HImode && TARGET_H8300S && amount == 8)
2923       || (mode == SImode && TARGET_H8300H && amount >= 10)
2924       || (mode == SImode && TARGET_H8300S && amount >= 13))
2925     {
2926       switch (mode)
2927         {
2928         case HImode:
2929           /* This code works on any family.  */
2930           insn_buf = "xor.b\t%s0,%t0\n\txor.b\t%t0,%s0\n\txor.b\t%s0,%t0";
2931           output_asm_insn (insn_buf, operands);
2932           break;
2933
2934         case SImode:
2935           /* This code works on the H8/300H and H8/S.  */
2936           insn_buf = "xor.w\t%e0,%f0\n\txor.w\t%f0,%e0\n\txor.w\t%e0,%f0";
2937           output_asm_insn (insn_buf, operands);
2938           break;
2939
2940         default:
2941           abort ();
2942         }
2943
2944       /* Adjust AMOUNT and flip the direction.  */
2945       amount = GET_MODE_BITSIZE (mode) / 2 - amount;
2946       rotate_type =
2947         (rotate_type == SHIFT_ASHIFT) ? SHIFT_LSHIFTRT : SHIFT_ASHIFT;
2948     }
2949
2950   /* Emit rotate insns.  */
2951   for (bits = TARGET_H8300S ? 2 : 1; bits > 0; bits /= 2)
2952     {
2953       if (bits == 2)
2954         insn_buf = rotate_two[rotate_type][rotate_mode];
2955       else
2956         insn_buf = rotate_one[cpu_type][rotate_type][rotate_mode];
2957
2958       for (; amount >= bits; amount -= bits)
2959         output_asm_insn (insn_buf, operands);
2960     }
2961
2962   return "";
2963 }
2964 \f
2965 /* Fix the operands of a gen_xxx so that it could become a bit
2966    operating insn.  */
2967
2968 int
2969 fix_bit_operand (operands, what, type)
2970      rtx *operands;
2971      int what;
2972      enum rtx_code type;
2973 {
2974   /* The bit_operand predicate accepts any memory during RTL generation, but
2975      only 'U' memory afterwards, so if this is a MEM operand, we must force
2976      it to be valid for 'U' by reloading the address.  */
2977
2978   if (GET_CODE (operands[2]) == CONST_INT)
2979     {
2980       if (CONST_OK_FOR_LETTER_P (INTVAL (operands[2]), what))
2981         {
2982           /* Ok to have a memory dest.  */
2983           if (GET_CODE (operands[0]) == MEM
2984               && !EXTRA_CONSTRAINT (operands[0], 'U'))
2985             {
2986               rtx mem = gen_rtx_MEM (GET_MODE (operands[0]),
2987                                      copy_to_mode_reg (Pmode,
2988                                                        XEXP (operands[0], 0)));
2989               MEM_COPY_ATTRIBUTES (mem, operands[0]);
2990               operands[0] = mem;
2991             }
2992
2993           if (GET_CODE (operands[1]) == MEM
2994               && !EXTRA_CONSTRAINT (operands[1], 'U'))
2995             {
2996               rtx mem = gen_rtx_MEM (GET_MODE (operands[1]),
2997                                      copy_to_mode_reg (Pmode,
2998                                                        XEXP (operands[1], 0)));
2999               MEM_COPY_ATTRIBUTES (mem, operands[0]);
3000               operands[1] = mem;
3001             }
3002           return 0;
3003         }
3004     }
3005
3006   /* Dest and src op must be register.  */
3007
3008   operands[1] = force_reg (QImode, operands[1]);
3009   {
3010     rtx res = gen_reg_rtx (QImode);
3011     emit_insn (gen_rtx_SET (VOIDmode, res,
3012                             gen_rtx (type, QImode, operands[1], operands[2])));
3013     emit_insn (gen_rtx_SET (VOIDmode, operands[0], res));
3014   }
3015   return 1;
3016 }
3017
3018 /* Return nonzero if FUNC is an interrupt function as specified
3019    by the "interrupt" attribute.  */
3020
3021 static int
3022 h8300_interrupt_function_p (func)
3023      tree func;
3024 {
3025   tree a;
3026
3027   if (TREE_CODE (func) != FUNCTION_DECL)
3028     return 0;
3029
3030   a = lookup_attribute ("interrupt_handler", DECL_ATTRIBUTES (func));
3031   return a != NULL_TREE;
3032 }
3033
3034 /* Return nonzero if FUNC is an OS_Task function as specified
3035    by the "OS_Task" attribute.  */
3036
3037 static int
3038 h8300_os_task_function_p (func)
3039      tree func;
3040 {
3041   tree a;
3042
3043   if (TREE_CODE (func) != FUNCTION_DECL)
3044     return 0;
3045
3046   a = lookup_attribute ("OS_Task", DECL_ATTRIBUTES (func));
3047   return a != NULL_TREE;
3048 }
3049
3050 /* Return nonzero if FUNC is a monitor function as specified
3051    by the "monitor" attribute.  */
3052
3053 static int
3054 h8300_monitor_function_p (func)
3055      tree func;
3056 {
3057   tree a;
3058
3059   if (TREE_CODE (func) != FUNCTION_DECL)
3060     return 0;
3061
3062   a = lookup_attribute ("monitor", DECL_ATTRIBUTES (func));
3063   return a != NULL_TREE;
3064 }
3065
3066 /* Return nonzero if FUNC is a function that should be called
3067    through the function vector.  */
3068
3069 int
3070 h8300_funcvec_function_p (func)
3071      tree func;
3072 {
3073   tree a;
3074
3075   if (TREE_CODE (func) != FUNCTION_DECL)
3076     return 0;
3077
3078   a = lookup_attribute ("function_vector", DECL_ATTRIBUTES (func));
3079   return a != NULL_TREE;
3080 }
3081
3082 /* Return nonzero if DECL is a variable that's in the eight bit
3083    data area.  */
3084
3085 int
3086 h8300_eightbit_data_p (decl)
3087      tree decl;
3088 {
3089   tree a;
3090
3091   if (TREE_CODE (decl) != VAR_DECL)
3092     return 0;
3093
3094   a = lookup_attribute ("eightbit_data", DECL_ATTRIBUTES (decl));
3095   return a != NULL_TREE;
3096 }
3097
3098 /* Return nonzero if DECL is a variable that's in the tiny
3099    data area.  */
3100
3101 int
3102 h8300_tiny_data_p (decl)
3103      tree decl;
3104 {
3105   tree a;
3106
3107   if (TREE_CODE (decl) != VAR_DECL)
3108     return 0;
3109
3110   a = lookup_attribute ("tiny_data", DECL_ATTRIBUTES (decl));
3111   return a != NULL_TREE;
3112 }
3113
3114 /* Supported attributes:
3115
3116    interrupt_handler: output a prologue and epilogue suitable for an
3117    interrupt handler.
3118
3119    function_vector: This function should be called through the
3120    function vector.
3121
3122    eightbit_data: This variable lives in the 8-bit data area and can
3123    be referenced with 8-bit absolute memory addresses.
3124
3125    tiny_data: This variable lives in the tiny data area and can be
3126    referenced with 16-bit absolute memory references.  */
3127
3128 const struct attribute_spec h8300_attribute_table[] =
3129 {
3130   /* { name, min_len, max_len, decl_req, type_req, fn_type_req, handler } */
3131   { "interrupt_handler", 0, 0, true,  false, false, h8300_handle_fndecl_attribute },
3132   { "OS_Task",           0, 0, true,  false, false, h8300_handle_fndecl_attribute },
3133   { "monitor",           0, 0, true,  false, false, h8300_handle_fndecl_attribute },
3134   { "function_vector",   0, 0, true,  false, false, h8300_handle_fndecl_attribute },
3135   { "eightbit_data",     0, 0, true,  false, false, h8300_handle_eightbit_data_attribute },
3136   { "tiny_data",         0, 0, true,  false, false, h8300_handle_tiny_data_attribute },
3137   { NULL,                0, 0, false, false, false, NULL }
3138 };
3139
3140
3141 /* Handle an attribute requiring a FUNCTION_DECL; arguments as in
3142    struct attribute_spec.handler.  */
3143 static tree
3144 h8300_handle_fndecl_attribute (node, name, args, flags, no_add_attrs)
3145      tree *node;
3146      tree name;
3147      tree args ATTRIBUTE_UNUSED;
3148      int flags ATTRIBUTE_UNUSED;
3149      bool *no_add_attrs;
3150 {
3151   if (TREE_CODE (*node) != FUNCTION_DECL)
3152     {
3153       warning ("`%s' attribute only applies to functions",
3154                IDENTIFIER_POINTER (name));
3155       *no_add_attrs = true;
3156     }
3157
3158   return NULL_TREE;
3159 }
3160
3161 /* Handle an "eightbit_data" attribute; arguments as in
3162    struct attribute_spec.handler.  */
3163 static tree
3164 h8300_handle_eightbit_data_attribute (node, name, args, flags, no_add_attrs)
3165      tree *node;
3166      tree name;
3167      tree args ATTRIBUTE_UNUSED;
3168      int flags ATTRIBUTE_UNUSED;
3169      bool *no_add_attrs;
3170 {
3171   tree decl = *node;
3172
3173   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
3174     {
3175       if (DECL_INITIAL (decl) == NULL_TREE)
3176         {
3177           warning ("Only initialized variables can be placed into the 8-bit area.");
3178           *no_add_attrs = true;
3179         }
3180       else
3181         DECL_SECTION_NAME (decl) = build_string (7, ".eight");
3182     }
3183   else
3184     {
3185       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3186       *no_add_attrs = true;
3187     }
3188
3189   return NULL_TREE;
3190 }
3191
3192 /* Handle an "tiny_data" attribute; arguments as in
3193    struct attribute_spec.handler.  */
3194 static tree
3195 h8300_handle_tiny_data_attribute (node, name, args, flags, no_add_attrs)
3196      tree *node;
3197      tree name;
3198      tree args ATTRIBUTE_UNUSED;
3199      int flags ATTRIBUTE_UNUSED;
3200      bool *no_add_attrs;
3201 {
3202   tree decl = *node;
3203
3204   if (TREE_STATIC (decl) || DECL_EXTERNAL (decl))
3205     {
3206       if (DECL_INITIAL (decl) == NULL_TREE)
3207         {
3208           warning ("Only initialized variables can be placed into the 8-bit area.");
3209           *no_add_attrs = true;
3210         }
3211       else
3212         DECL_SECTION_NAME (decl) = build_string (6, ".tiny");
3213     }
3214   else
3215     {
3216       warning ("`%s' attribute ignored", IDENTIFIER_POINTER (name));
3217       *no_add_attrs = true;
3218     }
3219
3220   return NULL_TREE;
3221 }
3222
3223 void
3224 h8300_encode_label (decl)
3225      tree decl;
3226 {
3227   const char *str = XSTR (XEXP (DECL_RTL (decl), 0), 0);
3228   int len = strlen (str);
3229   char *newstr = alloca (len + 2);
3230
3231   newstr[0] = '&';
3232   strcpy (&newstr[1], str);
3233
3234   XSTR (XEXP (DECL_RTL (decl), 0), 0) =
3235     ggc_alloc_string (newstr, len + 1);
3236 }
3237
3238 const char *
3239 output_simode_bld (bild, log2, operands)
3240      int bild;
3241      int log2;
3242      rtx operands[];
3243 {
3244   /* Clear the destination register.  */
3245   if (TARGET_H8300H || TARGET_H8300S)
3246     output_asm_insn ("sub.l\t%S0,%S0", operands);
3247   else
3248     output_asm_insn ("sub.w\t%e0,%e0\n\tsub.w\t%f0,%f0", operands);
3249
3250   /* Get the bit number we want to load.  */
3251   if (log2)
3252     operands[2] = GEN_INT (exact_log2 (INTVAL (operands[2])));
3253
3254   /* Now output the bit load or bit inverse load, and store it in
3255      the destination.  */
3256   if (bild)
3257     output_asm_insn ("bild\t%Z2,%Y1\n\tbst\t#0,%w0", operands);
3258   else
3259     output_asm_insn ("bld\t%Z2,%Y1\n\tbst\t#0,%w0", operands);
3260
3261   /* All done.  */
3262   return "";
3263 }
3264
3265 /* Given INSN and its current length LENGTH, return the adjustment
3266    (in bytes) to correctly compute INSN's length.
3267
3268    We use this to get the lengths of various memory references correct.  */
3269
3270 int
3271 h8300_adjust_insn_length (insn, length)
3272      rtx insn;
3273      int length ATTRIBUTE_UNUSED;
3274 {
3275   rtx pat;
3276
3277   /* We must filter these ou before calling get_attr_adjust_length.  */
3278   if (GET_CODE (PATTERN (insn)) == USE
3279       || GET_CODE (PATTERN (insn)) == CLOBBER
3280       || GET_CODE (PATTERN (insn)) == SEQUENCE
3281       || GET_CODE (PATTERN (insn)) == ADDR_VEC
3282       || GET_CODE (PATTERN (insn)) == ADDR_DIFF_VEC)
3283     return 0;
3284
3285   if (get_attr_adjust_length (insn) == ADJUST_LENGTH_NO)
3286     return 0;
3287
3288   pat = PATTERN (insn);
3289
3290   /* Adjust length for reg->mem and mem->reg copies.  */
3291   if (GET_CODE (pat) == SET
3292       && (GET_CODE (SET_SRC (pat)) == MEM
3293           || GET_CODE (SET_DEST (pat)) == MEM))
3294     {
3295       /* This insn might need a length adjustment.  */
3296       rtx addr;
3297
3298       if (GET_CODE (SET_SRC (pat)) == MEM)
3299         addr = XEXP (SET_SRC (pat), 0);
3300       else
3301         addr = XEXP (SET_DEST (pat), 0);
3302
3303       /* On the H8/300, only one adjustment is necessary; if the
3304          address mode is register indirect, then this insn is two
3305          bytes shorter than indicated in the machine description.  */
3306       if (TARGET_H8300 && GET_CODE (addr) == REG)
3307         return -2;
3308
3309       /* On the H8/300H and H8/S, register indirect is 6 bytes shorter than
3310          indicated in the machine description.  */
3311       if ((TARGET_H8300H || TARGET_H8300S)
3312           && GET_CODE (addr) == REG)
3313         return -6;
3314
3315       /* On the H8/300H and H8/300S, reg + d, for small displacements is 4
3316          bytes shorter than indicated in the machine description.  */
3317       if ((TARGET_H8300H || TARGET_H8300S)
3318           && GET_CODE (addr) == PLUS
3319           && GET_CODE (XEXP (addr, 0)) == REG
3320           && GET_CODE (XEXP (addr, 1)) == CONST_INT
3321           && INTVAL (XEXP (addr, 1)) > -32768
3322           && INTVAL (XEXP (addr, 1)) < 32767)
3323         return -4;
3324
3325       /* On the H8/300H and H8/300S, abs:16 is two bytes shorter than the
3326          more general abs:24.  */
3327       if ((TARGET_H8300H || TARGET_H8300S)
3328           && GET_CODE (addr) == SYMBOL_REF
3329           && TINY_DATA_NAME_P (XSTR (addr, 0)))
3330         return -2;
3331     }
3332
3333   /* Loading some constants needs adjustment.  */
3334   if (GET_CODE (pat) == SET
3335       && GET_CODE (SET_SRC (pat)) == CONST_INT
3336       && GET_MODE (SET_DEST (pat)) == SImode
3337       && INTVAL (SET_SRC (pat)) != 0)
3338     {
3339       int val = INTVAL (SET_SRC (pat));
3340
3341       if (TARGET_H8300
3342           && ((val & 0xffff) == 0
3343               || ((val >> 16) & 0xffff) == 0))
3344         return -2;
3345
3346       if (TARGET_H8300H || TARGET_H8300S)
3347         {
3348           if (val == (val & 0xff)
3349               || val == (val & 0xff00))
3350             return -6;
3351
3352           if (val == -4 || val == -2 || val == -1)
3353             return -6;
3354         }
3355     }
3356
3357   /* Shifts need various adjustments.  */
3358   if (GET_CODE (pat) == PARALLEL
3359       && GET_CODE (XVECEXP (pat, 0, 0)) == SET
3360       && (GET_CODE (SET_SRC (XVECEXP (pat, 0, 0))) == ASHIFTRT
3361           || GET_CODE (SET_SRC (XVECEXP (pat, 0, 0))) == LSHIFTRT
3362           || GET_CODE (SET_SRC (XVECEXP (pat, 0, 0))) == ASHIFT))
3363     {
3364       rtx src = SET_SRC (XVECEXP (pat, 0, 0));
3365       enum machine_mode mode = GET_MODE (src);
3366       int shift;
3367
3368       if (GET_CODE (XEXP (src, 1)) != CONST_INT)
3369         return 0;
3370
3371       shift = INTVAL (XEXP (src, 1));
3372       /* According to ANSI, negative shift is undefined.  It is
3373          considered to be zero in this case (see function
3374          emit_a_shift above).  */
3375       if (shift < 0)
3376         shift = 0;
3377
3378       /* QImode shifts by small constants take one insn
3379          per shift.  So the adjustment is 20 (md length) -
3380          # shifts * 2.  */
3381       if (mode == QImode && shift <= 4)
3382         return -(20 - shift * 2);
3383
3384       /* Similarly for HImode and SImode shifts by
3385          small constants on the H8/300H and H8/300S.  */
3386       if ((TARGET_H8300H || TARGET_H8300S)
3387           && (mode == HImode || mode == SImode) && shift <= 4)
3388         return -(20 - shift * 2);
3389
3390       /* HImode shifts by small constants for the H8/300.  */
3391       if (mode == HImode && shift <= 4)
3392         return -(20 - (shift * (GET_CODE (src) == ASHIFT ? 2 : 4)));
3393
3394       /* SImode shifts by small constants for the H8/300.  */
3395       if (mode == SImode && shift <= 2)
3396         return -(20 - (shift * (GET_CODE (src) == ASHIFT ? 6 : 8)));
3397
3398       /* XXX ??? Could check for more shift/rotate cases here.  */
3399     }
3400
3401   /* Rotations need various adjustments.  */
3402   if (GET_CODE (pat) == SET
3403       && (GET_CODE (SET_SRC (pat)) == ROTATE
3404           || GET_CODE (SET_SRC (pat)) == ROTATERT))
3405     {
3406       rtx src = SET_SRC (pat);
3407       enum machine_mode mode = GET_MODE (src);
3408       int amount;
3409       int states = 0;
3410
3411       if (GET_CODE (XEXP (src, 1)) != CONST_INT)
3412         return 0;
3413
3414       amount = INTVAL (XEXP (src, 1));
3415
3416       /* Clean up AMOUNT.  */
3417       if (amount < 0)
3418         amount = 0;
3419       if ((unsigned int) amount > GET_MODE_BITSIZE (mode))
3420         amount = GET_MODE_BITSIZE (mode);
3421
3422       /* Determine the faster direction.  After this phase, amount
3423          will be at most a half of GET_MODE_BITSIZE (mode).  */
3424       if ((unsigned int) amount > GET_MODE_BITSIZE (mode) / 2)
3425         /* Flip the direction.  */
3426         amount = GET_MODE_BITSIZE (mode) - amount;
3427
3428       /* See if a byte swap (in HImode) or a word swap (in SImode) can
3429          boost up the rotation.  */
3430       if ((mode == HImode && TARGET_H8300 && amount >= 5)
3431           || (mode == HImode && TARGET_H8300H && amount >= 6)
3432           || (mode == HImode && TARGET_H8300S && amount == 8)
3433           || (mode == SImode && TARGET_H8300H && amount >= 10)
3434           || (mode == SImode && TARGET_H8300S && amount >= 13))
3435         {
3436           /* Adjust AMOUNT and flip the direction.  */
3437           amount = GET_MODE_BITSIZE (mode) / 2 - amount;
3438           states += 6;
3439         }
3440
3441       /* We use 2-bit rotatations on the H8/S.  */
3442       if (TARGET_H8300S)
3443         amount = amount / 2 + amount % 2;
3444
3445       /* The H8/300 uses three insns to rotate one bit, taking 6
3446          states.  */
3447       states += amount * ((TARGET_H8300 && mode == HImode) ? 6 : 2);
3448
3449       return -(20 - states);
3450     }
3451
3452   return 0;
3453 }
3454
3455 static void
3456 h8300_asm_named_section (name, flags)
3457      const char *name;
3458      unsigned int flags ATTRIBUTE_UNUSED;
3459 {
3460   /* ??? Perhaps we should be using default_coff_asm_named_section.  */
3461   fprintf (asm_out_file, "\t.section %s\n", name);
3462 }