OSDN Git Service

* config/m32c/m32c.h (LIBGCC2_UNITS_PER_WORD): Define if not
[pf3gnuchains/gcc-fork.git] / gcc / config / m32c / m32c.c
1 /* Target Code for R8C/M16C/M32C
2    Copyright (C) 2005, 2006, 2007, 2008
3    Free Software Foundation, Inc.
4    Contributed by Red Hat.
5
6    This file is part of GCC.
7
8    GCC is free software; you can redistribute it and/or modify it
9    under the terms of the GNU General Public License as published
10    by the Free Software Foundation; either version 3, or (at your
11    option) any later version.
12
13    GCC is distributed in the hope that it will be useful, but WITHOUT
14    ANY WARRANTY; without even the implied warranty of MERCHANTABILITY
15    or FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public
16    License for more details.
17
18    You should have received a copy of the GNU General Public License
19    along with GCC; see the file COPYING3.  If not see
20    <http://www.gnu.org/licenses/>.  */
21
22 #include "config.h"
23 #include "system.h"
24 #include "coretypes.h"
25 #include "tm.h"
26 #include "rtl.h"
27 #include "regs.h"
28 #include "hard-reg-set.h"
29 #include "real.h"
30 #include "insn-config.h"
31 #include "conditions.h"
32 #include "insn-flags.h"
33 #include "output.h"
34 #include "insn-attr.h"
35 #include "flags.h"
36 #include "recog.h"
37 #include "reload.h"
38 #include "toplev.h"
39 #include "obstack.h"
40 #include "tree.h"
41 #include "expr.h"
42 #include "optabs.h"
43 #include "except.h"
44 #include "function.h"
45 #include "ggc.h"
46 #include "target.h"
47 #include "target-def.h"
48 #include "tm_p.h"
49 #include "langhooks.h"
50 #include "gimple.h"
51 #include "df.h"
52
53 /* Prototypes */
54
55 /* Used by m32c_pushm_popm.  */
56 typedef enum
57 {
58   PP_pushm,
59   PP_popm,
60   PP_justcount
61 } Push_Pop_Type;
62
63 static tree interrupt_handler (tree *, tree, tree, int, bool *);
64 static tree function_vector_handler (tree *, tree, tree, int, bool *);
65 static int interrupt_p (tree node);
66 static bool m32c_asm_integer (rtx, unsigned int, int);
67 static int m32c_comp_type_attributes (const_tree, const_tree);
68 static bool m32c_fixed_condition_code_regs (unsigned int *, unsigned int *);
69 static struct machine_function *m32c_init_machine_status (void);
70 static void m32c_insert_attributes (tree, tree *);
71 static bool m32c_pass_by_reference (CUMULATIVE_ARGS *, enum machine_mode,
72                                     const_tree, bool);
73 static bool m32c_promote_prototypes (const_tree);
74 static int m32c_pushm_popm (Push_Pop_Type);
75 static bool m32c_strict_argument_naming (CUMULATIVE_ARGS *);
76 static rtx m32c_struct_value_rtx (tree, int);
77 static rtx m32c_subreg (enum machine_mode, rtx, enum machine_mode, int);
78 static int need_to_save (int);
79 int current_function_special_page_vector (rtx);
80
81 #define SYMBOL_FLAG_FUNCVEC_FUNCTION    (SYMBOL_FLAG_MACH_DEP << 0)
82
83 #define streq(a,b) (strcmp ((a), (b)) == 0)
84
85 /* Internal support routines */
86
87 /* Debugging statements are tagged with DEBUG0 only so that they can
88    be easily enabled individually, by replacing the '0' with '1' as
89    needed.  */
90 #define DEBUG0 0
91 #define DEBUG1 1
92
93 #if DEBUG0
94 /* This is needed by some of the commented-out debug statements
95    below.  */
96 static char const *class_names[LIM_REG_CLASSES] = REG_CLASS_NAMES;
97 #endif
98 static int class_contents[LIM_REG_CLASSES][1] = REG_CLASS_CONTENTS;
99
100 /* These are all to support encode_pattern().  */
101 static char pattern[30], *patternp;
102 static GTY(()) rtx patternr[30];
103 #define RTX_IS(x) (streq (pattern, x))
104
105 /* Some macros to simplify the logic throughout this file.  */
106 #define IS_MEM_REGNO(regno) ((regno) >= MEM0_REGNO && (regno) <= MEM7_REGNO)
107 #define IS_MEM_REG(rtx) (GET_CODE (rtx) == REG && IS_MEM_REGNO (REGNO (rtx)))
108
109 #define IS_CR_REGNO(regno) ((regno) >= SB_REGNO && (regno) <= PC_REGNO)
110 #define IS_CR_REG(rtx) (GET_CODE (rtx) == REG && IS_CR_REGNO (REGNO (rtx)))
111
112 /* We do most RTX matching by converting the RTX into a string, and
113    using string compares.  This vastly simplifies the logic in many of
114    the functions in this file.
115
116    On exit, pattern[] has the encoded string (use RTX_IS("...") to
117    compare it) and patternr[] has pointers to the nodes in the RTX
118    corresponding to each character in the encoded string.  The latter
119    is mostly used by print_operand().
120
121    Unrecognized patterns have '?' in them; this shows up when the
122    assembler complains about syntax errors.
123 */
124
125 static void
126 encode_pattern_1 (rtx x)
127 {
128   int i;
129
130   if (patternp == pattern + sizeof (pattern) - 2)
131     {
132       patternp[-1] = '?';
133       return;
134     }
135
136   patternr[patternp - pattern] = x;
137
138   switch (GET_CODE (x))
139     {
140     case REG:
141       *patternp++ = 'r';
142       break;
143     case SUBREG:
144       if (GET_MODE_SIZE (GET_MODE (x)) !=
145           GET_MODE_SIZE (GET_MODE (XEXP (x, 0))))
146         *patternp++ = 'S';
147       encode_pattern_1 (XEXP (x, 0));
148       break;
149     case MEM:
150       *patternp++ = 'm';
151     case CONST:
152       encode_pattern_1 (XEXP (x, 0));
153       break;
154     case PLUS:
155       *patternp++ = '+';
156       encode_pattern_1 (XEXP (x, 0));
157       encode_pattern_1 (XEXP (x, 1));
158       break;
159     case PRE_DEC:
160       *patternp++ = '>';
161       encode_pattern_1 (XEXP (x, 0));
162       break;
163     case POST_INC:
164       *patternp++ = '<';
165       encode_pattern_1 (XEXP (x, 0));
166       break;
167     case LO_SUM:
168       *patternp++ = 'L';
169       encode_pattern_1 (XEXP (x, 0));
170       encode_pattern_1 (XEXP (x, 1));
171       break;
172     case HIGH:
173       *patternp++ = 'H';
174       encode_pattern_1 (XEXP (x, 0));
175       break;
176     case SYMBOL_REF:
177       *patternp++ = 's';
178       break;
179     case LABEL_REF:
180       *patternp++ = 'l';
181       break;
182     case CODE_LABEL:
183       *patternp++ = 'c';
184       break;
185     case CONST_INT:
186     case CONST_DOUBLE:
187       *patternp++ = 'i';
188       break;
189     case UNSPEC:
190       *patternp++ = 'u';
191       *patternp++ = '0' + XCINT (x, 1, UNSPEC);
192       for (i = 0; i < XVECLEN (x, 0); i++)
193         encode_pattern_1 (XVECEXP (x, 0, i));
194       break;
195     case USE:
196       *patternp++ = 'U';
197       break;
198     case PARALLEL:
199       *patternp++ = '|';
200       for (i = 0; i < XVECLEN (x, 0); i++)
201         encode_pattern_1 (XVECEXP (x, 0, i));
202       break;
203     case EXPR_LIST:
204       *patternp++ = 'E';
205       encode_pattern_1 (XEXP (x, 0));
206       if (XEXP (x, 1))
207         encode_pattern_1 (XEXP (x, 1));
208       break;
209     default:
210       *patternp++ = '?';
211 #if DEBUG0
212       fprintf (stderr, "can't encode pattern %s\n",
213                GET_RTX_NAME (GET_CODE (x)));
214       debug_rtx (x);
215       gcc_unreachable ();
216 #endif
217       break;
218     }
219 }
220
221 static void
222 encode_pattern (rtx x)
223 {
224   patternp = pattern;
225   encode_pattern_1 (x);
226   *patternp = 0;
227 }
228
229 /* Since register names indicate the mode they're used in, we need a
230    way to determine which name to refer to the register with.  Called
231    by print_operand().  */
232
233 static const char *
234 reg_name_with_mode (int regno, enum machine_mode mode)
235 {
236   int mlen = GET_MODE_SIZE (mode);
237   if (regno == R0_REGNO && mlen == 1)
238     return "r0l";
239   if (regno == R0_REGNO && (mlen == 3 || mlen == 4))
240     return "r2r0";
241   if (regno == R0_REGNO && mlen == 6)
242     return "r2r1r0";
243   if (regno == R0_REGNO && mlen == 8)
244     return "r3r1r2r0";
245   if (regno == R1_REGNO && mlen == 1)
246     return "r1l";
247   if (regno == R1_REGNO && (mlen == 3 || mlen == 4))
248     return "r3r1";
249   if (regno == A0_REGNO && TARGET_A16 && (mlen == 3 || mlen == 4))
250     return "a1a0";
251   return reg_names[regno];
252 }
253
254 /* How many bytes a register uses on stack when it's pushed.  We need
255    to know this because the push opcode needs to explicitly indicate
256    the size of the register, even though the name of the register
257    already tells it that.  Used by m32c_output_reg_{push,pop}, which
258    is only used through calls to ASM_OUTPUT_REG_{PUSH,POP}.  */
259
260 static int
261 reg_push_size (int regno)
262 {
263   switch (regno)
264     {
265     case R0_REGNO:
266     case R1_REGNO:
267       return 2;
268     case R2_REGNO:
269     case R3_REGNO:
270     case FLG_REGNO:
271       return 2;
272     case A0_REGNO:
273     case A1_REGNO:
274     case SB_REGNO:
275     case FB_REGNO:
276     case SP_REGNO:
277       if (TARGET_A16)
278         return 2;
279       else
280         return 3;
281     default:
282       gcc_unreachable ();
283     }
284 }
285
286 static int *class_sizes = 0;
287
288 /* Given two register classes, find the largest intersection between
289    them.  If there is no intersection, return RETURNED_IF_EMPTY
290    instead.  */
291 static int
292 reduce_class (int original_class, int limiting_class, int returned_if_empty)
293 {
294   int cc = class_contents[original_class][0];
295   int i, best = NO_REGS;
296   int best_size = 0;
297
298   if (original_class == limiting_class)
299     return original_class;
300
301   if (!class_sizes)
302     {
303       int r;
304       class_sizes = (int *) xmalloc (LIM_REG_CLASSES * sizeof (int));
305       for (i = 0; i < LIM_REG_CLASSES; i++)
306         {
307           class_sizes[i] = 0;
308           for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
309             if (class_contents[i][0] & (1 << r))
310               class_sizes[i]++;
311         }
312     }
313
314   cc &= class_contents[limiting_class][0];
315   for (i = 0; i < LIM_REG_CLASSES; i++)
316     {
317       int ic = class_contents[i][0];
318
319       if ((~cc & ic) == 0)
320         if (best_size < class_sizes[i])
321           {
322             best = i;
323             best_size = class_sizes[i];
324           }
325
326     }
327   if (best == NO_REGS)
328     return returned_if_empty;
329   return best;
330 }
331
332 /* Returns TRUE If there are any registers that exist in both register
333    classes.  */
334 static int
335 classes_intersect (int class1, int class2)
336 {
337   return class_contents[class1][0] & class_contents[class2][0];
338 }
339
340 /* Used by m32c_register_move_cost to determine if a move is
341    impossibly expensive.  */
342 static int
343 class_can_hold_mode (int rclass, enum machine_mode mode)
344 {
345   /* Cache the results:  0=untested  1=no  2=yes */
346   static char results[LIM_REG_CLASSES][MAX_MACHINE_MODE];
347   if (results[rclass][mode] == 0)
348     {
349       int r, n, i;
350       results[rclass][mode] = 1;
351       for (r = 0; r < FIRST_PSEUDO_REGISTER; r++)
352         if (class_contents[rclass][0] & (1 << r)
353             && HARD_REGNO_MODE_OK (r, mode))
354           {
355             int ok = 1;
356             n = HARD_REGNO_NREGS (r, mode);
357             for (i = 1; i < n; i++)
358               if (!(class_contents[rclass][0] & (1 << (r + i))))
359                 ok = 0;
360             if (ok)
361               {
362                 results[rclass][mode] = 2;
363                 break;
364               }
365           }
366     }
367 #if DEBUG0
368   fprintf (stderr, "class %s can hold %s? %s\n",
369            class_names[rclass], mode_name[mode],
370            (results[rclass][mode] == 2) ? "yes" : "no");
371 #endif
372   return results[rclass][mode] == 2;
373 }
374
375 /* Run-time Target Specification.  */
376
377 /* Memregs are memory locations that gcc treats like general
378    registers, as there are a limited number of true registers and the
379    m32c families can use memory in most places that registers can be
380    used.
381
382    However, since memory accesses are more expensive than registers,
383    we allow the user to limit the number of memregs available, in
384    order to try to persuade gcc to try harder to use real registers.
385
386    Memregs are provided by m32c-lib1.S.
387 */
388
389 int target_memregs = 16;
390 static bool target_memregs_set = FALSE;
391 int ok_to_change_target_memregs = TRUE;
392
393 #undef  TARGET_HANDLE_OPTION
394 #define TARGET_HANDLE_OPTION m32c_handle_option
395 static bool
396 m32c_handle_option (size_t code,
397                     const char *arg ATTRIBUTE_UNUSED,
398                     int value ATTRIBUTE_UNUSED)
399 {
400   if (code == OPT_memregs_)
401     {
402       target_memregs_set = TRUE;
403       target_memregs = atoi (arg);
404     }
405   return TRUE;
406 }
407
408 /* Implements OVERRIDE_OPTIONS.  We limit memregs to 0..16, and
409    provide a default.  */
410 void
411 m32c_override_options (void)
412 {
413   if (target_memregs_set)
414     {
415       if (target_memregs < 0 || target_memregs > 16)
416         error ("invalid target memregs value '%d'", target_memregs);
417     }
418   else
419     target_memregs = 16;
420 }
421
422 /* Defining data structures for per-function information */
423
424 /* The usual; we set up our machine_function data.  */
425 static struct machine_function *
426 m32c_init_machine_status (void)
427 {
428   struct machine_function *machine;
429   machine =
430     (machine_function *) ggc_alloc_cleared (sizeof (machine_function));
431
432   return machine;
433 }
434
435 /* Implements INIT_EXPANDERS.  We just set up to call the above
436    function.  */
437 void
438 m32c_init_expanders (void)
439 {
440   init_machine_status = m32c_init_machine_status;
441 }
442
443 /* Storage Layout */
444
445 #undef TARGET_PROMOTE_FUNCTION_RETURN
446 #define TARGET_PROMOTE_FUNCTION_RETURN m32c_promote_function_return
447 bool
448 m32c_promote_function_return (const_tree fntype ATTRIBUTE_UNUSED)
449 {
450   return false;
451 }
452
453 /* Register Basics */
454
455 /* Basic Characteristics of Registers */
456
457 /* Whether a mode fits in a register is complex enough to warrant a
458    table.  */
459 static struct
460 {
461   char qi_regs;
462   char hi_regs;
463   char pi_regs;
464   char si_regs;
465   char di_regs;
466 } nregs_table[FIRST_PSEUDO_REGISTER] =
467 {
468   { 1, 1, 2, 2, 4 },            /* r0 */
469   { 0, 1, 0, 0, 0 },            /* r2 */
470   { 1, 1, 2, 2, 0 },            /* r1 */
471   { 0, 1, 0, 0, 0 },            /* r3 */
472   { 0, 1, 1, 0, 0 },            /* a0 */
473   { 0, 1, 1, 0, 0 },            /* a1 */
474   { 0, 1, 1, 0, 0 },            /* sb */
475   { 0, 1, 1, 0, 0 },            /* fb */
476   { 0, 1, 1, 0, 0 },            /* sp */
477   { 1, 1, 1, 0, 0 },            /* pc */
478   { 0, 0, 0, 0, 0 },            /* fl */
479   { 1, 1, 1, 0, 0 },            /* ap */
480   { 1, 1, 2, 2, 4 },            /* mem0 */
481   { 1, 1, 2, 2, 4 },            /* mem1 */
482   { 1, 1, 2, 2, 4 },            /* mem2 */
483   { 1, 1, 2, 2, 4 },            /* mem3 */
484   { 1, 1, 2, 2, 4 },            /* mem4 */
485   { 1, 1, 2, 2, 0 },            /* mem5 */
486   { 1, 1, 2, 2, 0 },            /* mem6 */
487   { 1, 1, 0, 0, 0 },            /* mem7 */
488 };
489
490 /* Implements CONDITIONAL_REGISTER_USAGE.  We adjust the number of
491    available memregs, and select which registers need to be preserved
492    across calls based on the chip family.  */
493
494 void
495 m32c_conditional_register_usage (void)
496 {
497   int i;
498
499   if (0 <= target_memregs && target_memregs <= 16)
500     {
501       /* The command line option is bytes, but our "registers" are
502          16-bit words.  */
503       for (i = target_memregs/2; i < 8; i++)
504         {
505           fixed_regs[MEM0_REGNO + i] = 1;
506           CLEAR_HARD_REG_BIT (reg_class_contents[MEM_REGS], MEM0_REGNO + i);
507         }
508     }
509
510   /* M32CM and M32C preserve more registers across function calls.  */
511   if (TARGET_A24)
512     {
513       call_used_regs[R1_REGNO] = 0;
514       call_used_regs[R2_REGNO] = 0;
515       call_used_regs[R3_REGNO] = 0;
516       call_used_regs[A0_REGNO] = 0;
517       call_used_regs[A1_REGNO] = 0;
518     }
519 }
520
521 /* How Values Fit in Registers */
522
523 /* Implements HARD_REGNO_NREGS.  This is complicated by the fact that
524    different registers are different sizes from each other, *and* may
525    be different sizes in different chip families.  */
526 static int
527 m32c_hard_regno_nregs_1 (int regno, enum machine_mode mode)
528 {
529   if (regno == FLG_REGNO && mode == CCmode)
530     return 1;
531   if (regno >= FIRST_PSEUDO_REGISTER)
532     return ((GET_MODE_SIZE (mode) + UNITS_PER_WORD - 1) / UNITS_PER_WORD);
533
534   if (regno >= MEM0_REGNO && regno <= MEM7_REGNO)
535     return (GET_MODE_SIZE (mode) + 1) / 2;
536
537   if (GET_MODE_SIZE (mode) <= 1)
538     return nregs_table[regno].qi_regs;
539   if (GET_MODE_SIZE (mode) <= 2)
540     return nregs_table[regno].hi_regs;
541   if (regno == A0_REGNO && mode == PSImode && TARGET_A16)
542     return 2;
543   if ((GET_MODE_SIZE (mode) <= 3 || mode == PSImode) && TARGET_A24)
544     return nregs_table[regno].pi_regs;
545   if (GET_MODE_SIZE (mode) <= 4)
546     return nregs_table[regno].si_regs;
547   if (GET_MODE_SIZE (mode) <= 8)
548     return nregs_table[regno].di_regs;
549   return 0;
550 }
551
552 int
553 m32c_hard_regno_nregs (int regno, enum machine_mode mode)
554 {
555   int rv = m32c_hard_regno_nregs_1 (regno, mode);
556   return rv ? rv : 1;
557 }
558
559 /* Implements HARD_REGNO_MODE_OK.  The above function does the work
560    already; just test its return value.  */
561 int
562 m32c_hard_regno_ok (int regno, enum machine_mode mode)
563 {
564   return m32c_hard_regno_nregs_1 (regno, mode) != 0;
565 }
566
567 /* Implements MODES_TIEABLE_P.  In general, modes aren't tieable since
568    registers are all different sizes.  However, since most modes are
569    bigger than our registers anyway, it's easier to implement this
570    function that way, leaving QImode as the only unique case.  */
571 int
572 m32c_modes_tieable_p (enum machine_mode m1, enum machine_mode m2)
573 {
574   if (GET_MODE_SIZE (m1) == GET_MODE_SIZE (m2))
575     return 1;
576
577 #if 0
578   if (m1 == QImode || m2 == QImode)
579     return 0;
580 #endif
581
582   return 1;
583 }
584
585 /* Register Classes */
586
587 /* Implements REGNO_REG_CLASS.  */
588 enum machine_mode
589 m32c_regno_reg_class (int regno)
590 {
591   switch (regno)
592     {
593     case R0_REGNO:
594       return R0_REGS;
595     case R1_REGNO:
596       return R1_REGS;
597     case R2_REGNO:
598       return R2_REGS;
599     case R3_REGNO:
600       return R3_REGS;
601     case A0_REGNO:
602     case A1_REGNO:
603       return A_REGS;
604     case SB_REGNO:
605       return SB_REGS;
606     case FB_REGNO:
607       return FB_REGS;
608     case SP_REGNO:
609       return SP_REGS;
610     case FLG_REGNO:
611       return FLG_REGS;
612     default:
613       if (IS_MEM_REGNO (regno))
614         return MEM_REGS;
615       return ALL_REGS;
616     }
617 }
618
619 /* Implements REG_CLASS_FROM_CONSTRAINT.  Note that some constraints only match
620    for certain chip families.  */
621 int
622 m32c_reg_class_from_constraint (char c ATTRIBUTE_UNUSED, const char *s)
623 {
624   if (memcmp (s, "Rsp", 3) == 0)
625     return SP_REGS;
626   if (memcmp (s, "Rfb", 3) == 0)
627     return FB_REGS;
628   if (memcmp (s, "Rsb", 3) == 0)
629     return SB_REGS;
630   if (memcmp (s, "Rcr", 3) == 0)
631     return TARGET_A16 ? CR_REGS : NO_REGS;
632   if (memcmp (s, "Rcl", 3) == 0)
633     return TARGET_A24 ? CR_REGS : NO_REGS;
634   if (memcmp (s, "R0w", 3) == 0)
635     return R0_REGS;
636   if (memcmp (s, "R1w", 3) == 0)
637     return R1_REGS;
638   if (memcmp (s, "R2w", 3) == 0)
639     return R2_REGS;
640   if (memcmp (s, "R3w", 3) == 0)
641     return R3_REGS;
642   if (memcmp (s, "R02", 3) == 0)
643     return R02_REGS;
644   if (memcmp (s, "R03", 3) == 0)
645     return R03_REGS;
646   if (memcmp (s, "Rdi", 3) == 0)
647     return DI_REGS;
648   if (memcmp (s, "Rhl", 3) == 0)
649     return HL_REGS;
650   if (memcmp (s, "R23", 3) == 0)
651     return R23_REGS;
652   if (memcmp (s, "Ra0", 3) == 0)
653     return A0_REGS;
654   if (memcmp (s, "Ra1", 3) == 0)
655     return A1_REGS;
656   if (memcmp (s, "Raa", 3) == 0)
657     return A_REGS;
658   if (memcmp (s, "Raw", 3) == 0)
659     return TARGET_A16 ? A_REGS : NO_REGS;
660   if (memcmp (s, "Ral", 3) == 0)
661     return TARGET_A24 ? A_REGS : NO_REGS;
662   if (memcmp (s, "Rqi", 3) == 0)
663     return QI_REGS;
664   if (memcmp (s, "Rad", 3) == 0)
665     return AD_REGS;
666   if (memcmp (s, "Rsi", 3) == 0)
667     return SI_REGS;
668   if (memcmp (s, "Rhi", 3) == 0)
669     return HI_REGS;
670   if (memcmp (s, "Rhc", 3) == 0)
671     return HC_REGS;
672   if (memcmp (s, "Rra", 3) == 0)
673     return RA_REGS;
674   if (memcmp (s, "Rfl", 3) == 0)
675     return FLG_REGS;
676   if (memcmp (s, "Rmm", 3) == 0)
677     {
678       if (fixed_regs[MEM0_REGNO])
679         return NO_REGS;
680       return MEM_REGS;
681     }
682
683   /* PSImode registers - i.e. whatever can hold a pointer.  */
684   if (memcmp (s, "Rpi", 3) == 0)
685     {
686       if (TARGET_A16)
687         return HI_REGS;
688       else
689         return RA_REGS; /* r2r0 and r3r1 can hold pointers.  */
690     }
691
692   /* We handle this one as an EXTRA_CONSTRAINT.  */
693   if (memcmp (s, "Rpa", 3) == 0)
694     return NO_REGS;
695
696   if (*s == 'R')
697     {
698       fprintf(stderr, "unrecognized R constraint: %.3s\n", s);
699       gcc_unreachable();
700     }
701
702   return NO_REGS;
703 }
704
705 /* Implements REGNO_OK_FOR_BASE_P.  */
706 int
707 m32c_regno_ok_for_base_p (int regno)
708 {
709   if (regno == A0_REGNO
710       || regno == A1_REGNO || regno >= FIRST_PSEUDO_REGISTER)
711     return 1;
712   return 0;
713 }
714
715 #define DEBUG_RELOAD 0
716
717 /* Implements PREFERRED_RELOAD_CLASS.  In general, prefer general
718    registers of the appropriate size.  */
719 int
720 m32c_preferred_reload_class (rtx x, int rclass)
721 {
722   int newclass = rclass;
723
724 #if DEBUG_RELOAD
725   fprintf (stderr, "\npreferred_reload_class for %s is ",
726            class_names[rclass]);
727 #endif
728   if (rclass == NO_REGS)
729     rclass = GET_MODE (x) == QImode ? HL_REGS : R03_REGS;
730
731   if (classes_intersect (rclass, CR_REGS))
732     {
733       switch (GET_MODE (x))
734         {
735         case QImode:
736           newclass = HL_REGS;
737           break;
738         default:
739           /*      newclass = HI_REGS; */
740           break;
741         }
742     }
743
744   else if (newclass == QI_REGS && GET_MODE_SIZE (GET_MODE (x)) > 2)
745     newclass = SI_REGS;
746   else if (GET_MODE_SIZE (GET_MODE (x)) > 4
747            && ~class_contents[rclass][0] & 0x000f)
748     newclass = DI_REGS;
749
750   rclass = reduce_class (rclass, newclass, rclass);
751
752   if (GET_MODE (x) == QImode)
753     rclass = reduce_class (rclass, HL_REGS, rclass);
754
755 #if DEBUG_RELOAD
756   fprintf (stderr, "%s\n", class_names[rclass]);
757   debug_rtx (x);
758
759   if (GET_CODE (x) == MEM
760       && GET_CODE (XEXP (x, 0)) == PLUS
761       && GET_CODE (XEXP (XEXP (x, 0), 0)) == PLUS)
762     fprintf (stderr, "Glorm!\n");
763 #endif
764   return rclass;
765 }
766
767 /* Implements PREFERRED_OUTPUT_RELOAD_CLASS.  */
768 int
769 m32c_preferred_output_reload_class (rtx x, int rclass)
770 {
771   return m32c_preferred_reload_class (x, rclass);
772 }
773
774 /* Implements LIMIT_RELOAD_CLASS.  We basically want to avoid using
775    address registers for reloads since they're needed for address
776    reloads.  */
777 int
778 m32c_limit_reload_class (enum machine_mode mode, int rclass)
779 {
780 #if DEBUG_RELOAD
781   fprintf (stderr, "limit_reload_class for %s: %s ->",
782            mode_name[mode], class_names[rclass]);
783 #endif
784
785   if (mode == QImode)
786     rclass = reduce_class (rclass, HL_REGS, rclass);
787   else if (mode == HImode)
788     rclass = reduce_class (rclass, HI_REGS, rclass);
789   else if (mode == SImode)
790     rclass = reduce_class (rclass, SI_REGS, rclass);
791
792   if (rclass != A_REGS)
793     rclass = reduce_class (rclass, DI_REGS, rclass);
794
795 #if DEBUG_RELOAD
796   fprintf (stderr, " %s\n", class_names[rclass]);
797 #endif
798   return rclass;
799 }
800
801 /* Implements SECONDARY_RELOAD_CLASS.  QImode have to be reloaded in
802    r0 or r1, as those are the only real QImode registers.  CR regs get
803    reloaded through appropriately sized general or address
804    registers.  */
805 int
806 m32c_secondary_reload_class (int rclass, enum machine_mode mode, rtx x)
807 {
808   int cc = class_contents[rclass][0];
809 #if DEBUG0
810   fprintf (stderr, "\nsecondary reload class %s %s\n",
811            class_names[rclass], mode_name[mode]);
812   debug_rtx (x);
813 #endif
814   if (mode == QImode
815       && GET_CODE (x) == MEM && (cc & ~class_contents[R23_REGS][0]) == 0)
816     return QI_REGS;
817   if (classes_intersect (rclass, CR_REGS)
818       && GET_CODE (x) == REG
819       && REGNO (x) >= SB_REGNO && REGNO (x) <= SP_REGNO)
820     return TARGET_A16 ? HI_REGS : A_REGS;
821   return NO_REGS;
822 }
823
824 /* Implements CLASS_LIKELY_SPILLED_P.  A_REGS is needed for address
825    reloads.  */
826 int
827 m32c_class_likely_spilled_p (int regclass)
828 {
829   if (regclass == A_REGS)
830     return 1;
831   return reg_class_size[regclass] == 1;
832 }
833
834 /* Implements CLASS_MAX_NREGS.  We calculate this according to its
835    documented meaning, to avoid potential inconsistencies with actual
836    class definitions.  */
837 int
838 m32c_class_max_nregs (int regclass, enum machine_mode mode)
839 {
840   int rn, max = 0;
841
842   for (rn = 0; rn < FIRST_PSEUDO_REGISTER; rn++)
843     if (class_contents[regclass][0] & (1 << rn))
844       {
845         int n = m32c_hard_regno_nregs (rn, mode);
846         if (max < n)
847           max = n;
848       }
849   return max;
850 }
851
852 /* Implements CANNOT_CHANGE_MODE_CLASS.  Only r0 and r1 can change to
853    QI (r0l, r1l) because the chip doesn't support QI ops on other
854    registers (well, it does on a0/a1 but if we let gcc do that, reload
855    suffers).  Otherwise, we allow changes to larger modes.  */
856 int
857 m32c_cannot_change_mode_class (enum machine_mode from,
858                                enum machine_mode to, int rclass)
859 {
860   int rn;
861 #if DEBUG0
862   fprintf (stderr, "cannot change from %s to %s in %s\n",
863            mode_name[from], mode_name[to], class_names[rclass]);
864 #endif
865
866   /* If the larger mode isn't allowed in any of these registers, we
867      can't allow the change.  */
868   for (rn = 0; rn < FIRST_PSEUDO_REGISTER; rn++)
869     if (class_contents[rclass][0] & (1 << rn))
870       if (! m32c_hard_regno_ok (rn, to))
871         return 1;
872
873   if (to == QImode)
874     return (class_contents[rclass][0] & 0x1ffa);
875
876   if (class_contents[rclass][0] & 0x0005        /* r0, r1 */
877       && GET_MODE_SIZE (from) > 1)
878     return 0;
879   if (GET_MODE_SIZE (from) > 2) /* all other regs */
880     return 0;
881
882   return 1;
883 }
884
885 /* Helpers for the rest of the file.  */
886 /* TRUE if the rtx is a REG rtx for the given register.  */
887 #define IS_REG(rtx,regno) (GET_CODE (rtx) == REG \
888                            && REGNO (rtx) == regno)
889 /* TRUE if the rtx is a pseudo - specifically, one we can use as a
890    base register in address calculations (hence the "strict"
891    argument).  */
892 #define IS_PSEUDO(rtx,strict) (!strict && GET_CODE (rtx) == REG \
893                                && (REGNO (rtx) == AP_REGNO \
894                                    || REGNO (rtx) >= FIRST_PSEUDO_REGISTER))
895
896 /* Implements CONST_OK_FOR_CONSTRAINT_P.  Currently, all constant
897    constraints start with 'I', with the next two characters indicating
898    the type and size of the range allowed.  */
899 int
900 m32c_const_ok_for_constraint_p (HOST_WIDE_INT value,
901                                 char c ATTRIBUTE_UNUSED, const char *str)
902 {
903   /* s=signed u=unsigned n=nonzero m=minus l=log2able,
904      [sun] bits [SUN] bytes, p=pointer size
905      I[-0-9][0-9] matches that number */
906   if (memcmp (str, "Is3", 3) == 0)
907     {
908       return (-8 <= value && value <= 7);
909     }
910   if (memcmp (str, "IS1", 3) == 0)
911     {
912       return (-128 <= value && value <= 127);
913     }
914   if (memcmp (str, "IS2", 3) == 0)
915     {
916       return (-32768 <= value && value <= 32767);
917     }
918   if (memcmp (str, "IU2", 3) == 0)
919     {
920       return (0 <= value && value <= 65535);
921     }
922   if (memcmp (str, "IU3", 3) == 0)
923     {
924       return (0 <= value && value <= 0x00ffffff);
925     }
926   if (memcmp (str, "In4", 3) == 0)
927     {
928       return (-8 <= value && value && value <= 8);
929     }
930   if (memcmp (str, "In5", 3) == 0)
931     {
932       return (-16 <= value && value && value <= 16);
933     }
934   if (memcmp (str, "In6", 3) == 0)
935     {
936       return (-32 <= value && value && value <= 32);
937     }
938   if (memcmp (str, "IM2", 3) == 0)
939     {
940       return (-65536 <= value && value && value <= -1);
941     }
942   if (memcmp (str, "Ilb", 3) == 0)
943     {
944       int b = exact_log2 (value);
945       return (b >= 0 && b <= 7);
946     }
947   if (memcmp (str, "Imb", 3) == 0)
948     {
949       int b = exact_log2 ((value ^ 0xff) & 0xff);
950       return (b >= 0 && b <= 7);
951     }
952   if (memcmp (str, "ImB", 3) == 0)
953     {
954       int b = exact_log2 ((value ^ 0xffff) & 0xffff);
955       return (b >= 0 && b <= 7);
956     }
957   if (memcmp (str, "Ilw", 3) == 0)
958     {
959       int b = exact_log2 (value);
960       return (b >= 0 && b <= 15);
961     }
962   if (memcmp (str, "Imw", 3) == 0)
963     {
964       int b = exact_log2 ((value ^ 0xffff) & 0xffff);
965       return (b >= 0 && b <= 15);
966     }
967   if (memcmp (str, "I00", 3) == 0)
968     {
969       return (value == 0);
970     }
971   return 0;
972 }
973
974 /* Implements EXTRA_CONSTRAINT_STR (see next function too).  'S' is
975    for memory constraints, plus "Rpa" for PARALLEL rtx's we use for
976    call return values.  */
977 int
978 m32c_extra_constraint_p2 (rtx value, char c ATTRIBUTE_UNUSED, const char *str)
979 {
980   encode_pattern (value);
981   if (memcmp (str, "Sd", 2) == 0)
982     {
983       /* This is the common "src/dest" address */
984       rtx r;
985       if (GET_CODE (value) == MEM && CONSTANT_P (XEXP (value, 0)))
986         return 1;
987       if (RTX_IS ("ms") || RTX_IS ("m+si"))
988         return 1;
989       if (RTX_IS ("m++rii"))
990         {
991           if (REGNO (patternr[3]) == FB_REGNO
992               && INTVAL (patternr[4]) == 0)
993             return 1;
994         }
995       if (RTX_IS ("mr"))
996         r = patternr[1];
997       else if (RTX_IS ("m+ri") || RTX_IS ("m+rs") || RTX_IS ("m+r+si"))
998         r = patternr[2];
999       else
1000         return 0;
1001       if (REGNO (r) == SP_REGNO)
1002         return 0;
1003       return m32c_legitimate_address_p (GET_MODE (value), XEXP (value, 0), 1);
1004     }
1005   else if (memcmp (str, "Sa", 2) == 0)
1006     {
1007       rtx r;
1008       if (RTX_IS ("mr"))
1009         r = patternr[1];
1010       else if (RTX_IS ("m+ri"))
1011         r = patternr[2];
1012       else
1013         return 0;
1014       return (IS_REG (r, A0_REGNO) || IS_REG (r, A1_REGNO));
1015     }
1016   else if (memcmp (str, "Si", 2) == 0)
1017     {
1018       return (RTX_IS ("mi") || RTX_IS ("ms") || RTX_IS ("m+si"));
1019     }
1020   else if (memcmp (str, "Ss", 2) == 0)
1021     {
1022       return ((RTX_IS ("mr")
1023                && (IS_REG (patternr[1], SP_REGNO)))
1024               || (RTX_IS ("m+ri") && (IS_REG (patternr[2], SP_REGNO))));
1025     }
1026   else if (memcmp (str, "Sf", 2) == 0)
1027     {
1028       return ((RTX_IS ("mr")
1029                && (IS_REG (patternr[1], FB_REGNO)))
1030               || (RTX_IS ("m+ri") && (IS_REG (patternr[2], FB_REGNO))));
1031     }
1032   else if (memcmp (str, "Sb", 2) == 0)
1033     {
1034       return ((RTX_IS ("mr")
1035                && (IS_REG (patternr[1], SB_REGNO)))
1036               || (RTX_IS ("m+ri") && (IS_REG (patternr[2], SB_REGNO))));
1037     }
1038   else if (memcmp (str, "Sp", 2) == 0)
1039     {
1040       /* Absolute addresses 0..0x1fff used for bit addressing (I/O ports) */
1041       return (RTX_IS ("mi")
1042               && !(INTVAL (patternr[1]) & ~0x1fff));
1043     }
1044   else if (memcmp (str, "S1", 2) == 0)
1045     {
1046       return r1h_operand (value, QImode);
1047     }
1048
1049   gcc_assert (str[0] != 'S');
1050
1051   if (memcmp (str, "Rpa", 2) == 0)
1052     return GET_CODE (value) == PARALLEL;
1053
1054   return 0;
1055 }
1056
1057 /* This is for when we're debugging the above.  */
1058 int
1059 m32c_extra_constraint_p (rtx value, char c, const char *str)
1060 {
1061   int rv = m32c_extra_constraint_p2 (value, c, str);
1062 #if DEBUG0
1063   fprintf (stderr, "\nconstraint %.*s: %d\n", CONSTRAINT_LEN (c, str), str,
1064            rv);
1065   debug_rtx (value);
1066 #endif
1067   return rv;
1068 }
1069
1070 /* Implements EXTRA_MEMORY_CONSTRAINT.  Currently, we only use strings
1071    starting with 'S'.  */
1072 int
1073 m32c_extra_memory_constraint (char c, const char *str ATTRIBUTE_UNUSED)
1074 {
1075   return c == 'S';
1076 }
1077
1078 /* Implements EXTRA_ADDRESS_CONSTRAINT.  We reserve 'A' strings for these,
1079    but don't currently define any.  */
1080 int
1081 m32c_extra_address_constraint (char c, const char *str ATTRIBUTE_UNUSED)
1082 {
1083   return c == 'A';
1084 }
1085
1086 /* STACK AND CALLING */
1087
1088 /* Frame Layout */
1089
1090 /* Implements RETURN_ADDR_RTX.  Note that R8C and M16C push 24 bits
1091    (yes, THREE bytes) onto the stack for the return address, but we
1092    don't support pointers bigger than 16 bits on those chips.  This
1093    will likely wreak havoc with exception unwinding.  FIXME.  */
1094 rtx
1095 m32c_return_addr_rtx (int count)
1096 {
1097   enum machine_mode mode;
1098   int offset;
1099   rtx ra_mem;
1100
1101   if (count)
1102     return NULL_RTX;
1103   /* we want 2[$fb] */
1104
1105   if (TARGET_A24)
1106     {
1107       /* It's four bytes */
1108       mode = PSImode;
1109       offset = 4;
1110     }
1111   else
1112     {
1113       /* FIXME: it's really 3 bytes */
1114       mode = HImode;
1115       offset = 2;
1116     }
1117
1118   ra_mem =
1119     gen_rtx_MEM (mode, plus_constant (gen_rtx_REG (Pmode, FP_REGNO), offset));
1120   return copy_to_mode_reg (mode, ra_mem);
1121 }
1122
1123 /* Implements INCOMING_RETURN_ADDR_RTX.  See comment above.  */
1124 rtx
1125 m32c_incoming_return_addr_rtx (void)
1126 {
1127   /* we want [sp] */
1128   return gen_rtx_MEM (PSImode, gen_rtx_REG (PSImode, SP_REGNO));
1129 }
1130
1131 /* Exception Handling Support */
1132
1133 /* Implements EH_RETURN_DATA_REGNO.  Choose registers able to hold
1134    pointers.  */
1135 int
1136 m32c_eh_return_data_regno (int n)
1137 {
1138   switch (n)
1139     {
1140     case 0:
1141       return A0_REGNO;
1142     case 1:
1143       if (TARGET_A16)
1144         return R3_REGNO;
1145       else
1146         return R1_REGNO;
1147     default:
1148       return INVALID_REGNUM;
1149     }
1150 }
1151
1152 /* Implements EH_RETURN_STACKADJ_RTX.  Saved and used later in
1153    m32c_emit_eh_epilogue.  */
1154 rtx
1155 m32c_eh_return_stackadj_rtx (void)
1156 {
1157   if (!cfun->machine->eh_stack_adjust)
1158     {
1159       rtx sa;
1160
1161       sa = gen_rtx_REG (Pmode, R0_REGNO);
1162       cfun->machine->eh_stack_adjust = sa;
1163     }
1164   return cfun->machine->eh_stack_adjust;
1165 }
1166
1167 /* Registers That Address the Stack Frame */
1168
1169 /* Implements DWARF_FRAME_REGNUM and DBX_REGISTER_NUMBER.  Note that
1170    the original spec called for dwarf numbers to vary with register
1171    width as well, for example, r0l, r0, and r2r0 would each have
1172    different dwarf numbers.  GCC doesn't support this, and we don't do
1173    it, and gdb seems to like it this way anyway.  */
1174 unsigned int
1175 m32c_dwarf_frame_regnum (int n)
1176 {
1177   switch (n)
1178     {
1179     case R0_REGNO:
1180       return 5;
1181     case R1_REGNO:
1182       return 6;
1183     case R2_REGNO:
1184       return 7;
1185     case R3_REGNO:
1186       return 8;
1187     case A0_REGNO:
1188       return 9;
1189     case A1_REGNO:
1190       return 10;
1191     case FB_REGNO:
1192       return 11;
1193     case SB_REGNO:
1194       return 19;
1195
1196     case SP_REGNO:
1197       return 12;
1198     case PC_REGNO:
1199       return 13;
1200     default:
1201       return DWARF_FRAME_REGISTERS + 1;
1202     }
1203 }
1204
1205 /* The frame looks like this:
1206
1207    ap -> +------------------------------
1208          | Return address (3 or 4 bytes)
1209          | Saved FB (2 or 4 bytes)
1210    fb -> +------------------------------
1211          | local vars
1212          | register saves fb
1213          |        through r0 as needed
1214    sp -> +------------------------------
1215 */
1216
1217 /* We use this to wrap all emitted insns in the prologue.  */
1218 static rtx
1219 F (rtx x)
1220 {
1221   RTX_FRAME_RELATED_P (x) = 1;
1222   return x;
1223 }
1224
1225 /* This maps register numbers to the PUSHM/POPM bitfield, and tells us
1226    how much the stack pointer moves for each, for each cpu family.  */
1227 static struct
1228 {
1229   int reg1;
1230   int bit;
1231   int a16_bytes;
1232   int a24_bytes;
1233 } pushm_info[] =
1234 {
1235   /* These are in reverse push (nearest-to-sp) order.  */
1236   { R0_REGNO, 0x80, 2, 2 },
1237   { R1_REGNO, 0x40, 2, 2 },
1238   { R2_REGNO, 0x20, 2, 2 },
1239   { R3_REGNO, 0x10, 2, 2 },
1240   { A0_REGNO, 0x08, 2, 4 },
1241   { A1_REGNO, 0x04, 2, 4 },
1242   { SB_REGNO, 0x02, 2, 4 },
1243   { FB_REGNO, 0x01, 2, 4 }
1244 };
1245
1246 #define PUSHM_N (sizeof(pushm_info)/sizeof(pushm_info[0]))
1247
1248 /* Returns TRUE if we need to save/restore the given register.  We
1249    save everything for exception handlers, so that any register can be
1250    unwound.  For interrupt handlers, we save everything if the handler
1251    calls something else (because we don't know what *that* function
1252    might do), but try to be a bit smarter if the handler is a leaf
1253    function.  We always save $a0, though, because we use that in the
1254    epilogue to copy $fb to $sp.  */
1255 static int
1256 need_to_save (int regno)
1257 {
1258   if (fixed_regs[regno])
1259     return 0;
1260   if (crtl->calls_eh_return)
1261     return 1;
1262   if (regno == FP_REGNO)
1263     return 0;
1264   if (cfun->machine->is_interrupt
1265       && (!cfun->machine->is_leaf || regno == A0_REGNO))
1266     return 1;
1267   if (df_regs_ever_live_p (regno)
1268       && (!call_used_regs[regno] || cfun->machine->is_interrupt))
1269     return 1;
1270   return 0;
1271 }
1272
1273 /* This function contains all the intelligence about saving and
1274    restoring registers.  It always figures out the register save set.
1275    When called with PP_justcount, it merely returns the size of the
1276    save set (for eliminating the frame pointer, for example).  When
1277    called with PP_pushm or PP_popm, it emits the appropriate
1278    instructions for saving (pushm) or restoring (popm) the
1279    registers.  */
1280 static int
1281 m32c_pushm_popm (Push_Pop_Type ppt)
1282 {
1283   int reg_mask = 0;
1284   int byte_count = 0, bytes;
1285   int i;
1286   rtx dwarf_set[PUSHM_N];
1287   int n_dwarfs = 0;
1288   int nosave_mask = 0;
1289
1290   if (crtl->return_rtx
1291       && GET_CODE (crtl->return_rtx) == PARALLEL
1292       && !(crtl->calls_eh_return || cfun->machine->is_interrupt))
1293     {
1294       rtx exp = XVECEXP (crtl->return_rtx, 0, 0);
1295       rtx rv = XEXP (exp, 0);
1296       int rv_bytes = GET_MODE_SIZE (GET_MODE (rv));
1297
1298       if (rv_bytes > 2)
1299         nosave_mask |= 0x20;    /* PSI, SI */
1300       else
1301         nosave_mask |= 0xf0;    /* DF */
1302       if (rv_bytes > 4)
1303         nosave_mask |= 0x50;    /* DI */
1304     }
1305
1306   for (i = 0; i < (int) PUSHM_N; i++)
1307     {
1308       /* Skip if neither register needs saving.  */
1309       if (!need_to_save (pushm_info[i].reg1))
1310         continue;
1311
1312       if (pushm_info[i].bit & nosave_mask)
1313         continue;
1314
1315       reg_mask |= pushm_info[i].bit;
1316       bytes = TARGET_A16 ? pushm_info[i].a16_bytes : pushm_info[i].a24_bytes;
1317
1318       if (ppt == PP_pushm)
1319         {
1320           enum machine_mode mode = (bytes == 2) ? HImode : SImode;
1321           rtx addr;
1322
1323           /* Always use stack_pointer_rtx instead of calling
1324              rtx_gen_REG ourselves.  Code elsewhere in GCC assumes
1325              that there is a single rtx representing the stack pointer,
1326              namely stack_pointer_rtx, and uses == to recognize it.  */
1327           addr = stack_pointer_rtx;
1328
1329           if (byte_count != 0)
1330             addr = gen_rtx_PLUS (GET_MODE (addr), addr, GEN_INT (byte_count));
1331
1332           dwarf_set[n_dwarfs++] =
1333             gen_rtx_SET (VOIDmode,
1334                          gen_rtx_MEM (mode, addr),
1335                          gen_rtx_REG (mode, pushm_info[i].reg1));
1336           F (dwarf_set[n_dwarfs - 1]);
1337
1338         }
1339       byte_count += bytes;
1340     }
1341
1342   if (cfun->machine->is_interrupt)
1343     {
1344       cfun->machine->intr_pushm = reg_mask & 0xfe;
1345       reg_mask = 0;
1346       byte_count = 0;
1347     }
1348
1349   if (cfun->machine->is_interrupt)
1350     for (i = MEM0_REGNO; i <= MEM7_REGNO; i++)
1351       if (need_to_save (i))
1352         {
1353           byte_count += 2;
1354           cfun->machine->intr_pushmem[i - MEM0_REGNO] = 1;
1355         }
1356
1357   if (ppt == PP_pushm && byte_count)
1358     {
1359       rtx note = gen_rtx_SEQUENCE (VOIDmode, rtvec_alloc (n_dwarfs + 1));
1360       rtx pushm;
1361
1362       if (reg_mask)
1363         {
1364           XVECEXP (note, 0, 0)
1365             = gen_rtx_SET (VOIDmode,
1366                            stack_pointer_rtx,
1367                            gen_rtx_PLUS (GET_MODE (stack_pointer_rtx),
1368                                          stack_pointer_rtx,
1369                                          GEN_INT (-byte_count)));
1370           F (XVECEXP (note, 0, 0));
1371
1372           for (i = 0; i < n_dwarfs; i++)
1373             XVECEXP (note, 0, i + 1) = dwarf_set[i];
1374
1375           pushm = F (emit_insn (gen_pushm (GEN_INT (reg_mask))));
1376
1377           REG_NOTES (pushm) = gen_rtx_EXPR_LIST (REG_FRAME_RELATED_EXPR, note,
1378                                                  REG_NOTES (pushm));
1379         }
1380
1381       if (cfun->machine->is_interrupt)
1382         for (i = MEM0_REGNO; i <= MEM7_REGNO; i++)
1383           if (cfun->machine->intr_pushmem[i - MEM0_REGNO])
1384             {
1385               if (TARGET_A16)
1386                 pushm = emit_insn (gen_pushhi_16 (gen_rtx_REG (HImode, i)));
1387               else
1388                 pushm = emit_insn (gen_pushhi_24 (gen_rtx_REG (HImode, i)));
1389               F (pushm);
1390             }
1391     }
1392   if (ppt == PP_popm && byte_count)
1393     {
1394       if (cfun->machine->is_interrupt)
1395         for (i = MEM7_REGNO; i >= MEM0_REGNO; i--)
1396           if (cfun->machine->intr_pushmem[i - MEM0_REGNO])
1397             {
1398               if (TARGET_A16)
1399                 emit_insn (gen_pophi_16 (gen_rtx_REG (HImode, i)));
1400               else
1401                 emit_insn (gen_pophi_24 (gen_rtx_REG (HImode, i)));
1402             }
1403       if (reg_mask)
1404         emit_insn (gen_popm (GEN_INT (reg_mask)));
1405     }
1406
1407   return byte_count;
1408 }
1409
1410 /* Implements INITIAL_ELIMINATION_OFFSET.  See the comment above that
1411    diagrams our call frame.  */
1412 int
1413 m32c_initial_elimination_offset (int from, int to)
1414 {
1415   int ofs = 0;
1416
1417   if (from == AP_REGNO)
1418     {
1419       if (TARGET_A16)
1420         ofs += 5;
1421       else
1422         ofs += 8;
1423     }
1424
1425   if (to == SP_REGNO)
1426     {
1427       ofs += m32c_pushm_popm (PP_justcount);
1428       ofs += get_frame_size ();
1429     }
1430
1431   /* Account for push rounding.  */
1432   if (TARGET_A24)
1433     ofs = (ofs + 1) & ~1;
1434 #if DEBUG0
1435   fprintf (stderr, "initial_elimination_offset from=%d to=%d, ofs=%d\n", from,
1436            to, ofs);
1437 #endif
1438   return ofs;
1439 }
1440
1441 /* Passing Function Arguments on the Stack */
1442
1443 #undef TARGET_PROMOTE_PROTOTYPES
1444 #define TARGET_PROMOTE_PROTOTYPES m32c_promote_prototypes
1445 static bool
1446 m32c_promote_prototypes (const_tree fntype ATTRIBUTE_UNUSED)
1447 {
1448   return 0;
1449 }
1450
1451 /* Implements PUSH_ROUNDING.  The R8C and M16C have byte stacks, the
1452    M32C has word stacks.  */
1453 int
1454 m32c_push_rounding (int n)
1455 {
1456   if (TARGET_R8C || TARGET_M16C)
1457     return n;
1458   return (n + 1) & ~1;
1459 }
1460
1461 /* Passing Arguments in Registers */
1462
1463 /* Implements FUNCTION_ARG.  Arguments are passed partly in registers,
1464    partly on stack.  If our function returns a struct, a pointer to a
1465    buffer for it is at the top of the stack (last thing pushed).  The
1466    first few real arguments may be in registers as follows:
1467
1468    R8C/M16C:    arg1 in r1 if it's QI or HI (else it's pushed on stack)
1469                 arg2 in r2 if it's HI (else pushed on stack)
1470                 rest on stack
1471    M32C:        arg1 in r0 if it's QI or HI (else it's pushed on stack)
1472                 rest on stack
1473
1474    Structs are not passed in registers, even if they fit.  Only
1475    integer and pointer types are passed in registers.
1476
1477    Note that when arg1 doesn't fit in r1, arg2 may still be passed in
1478    r2 if it fits.  */
1479 rtx
1480 m32c_function_arg (CUMULATIVE_ARGS * ca,
1481                    enum machine_mode mode, tree type, int named)
1482 {
1483   /* Can return a reg, parallel, or 0 for stack */
1484   rtx rv = NULL_RTX;
1485 #if DEBUG0
1486   fprintf (stderr, "func_arg %d (%s, %d)\n",
1487            ca->parm_num, mode_name[mode], named);
1488   debug_tree (type);
1489 #endif
1490
1491   if (mode == VOIDmode)
1492     return GEN_INT (0);
1493
1494   if (ca->force_mem || !named)
1495     {
1496 #if DEBUG0
1497       fprintf (stderr, "func arg: force %d named %d, mem\n", ca->force_mem,
1498                named);
1499 #endif
1500       return NULL_RTX;
1501     }
1502
1503   if (type && INTEGRAL_TYPE_P (type) && POINTER_TYPE_P (type))
1504     return NULL_RTX;
1505
1506   if (type && AGGREGATE_TYPE_P (type))
1507     return NULL_RTX;
1508
1509   switch (ca->parm_num)
1510     {
1511     case 1:
1512       if (GET_MODE_SIZE (mode) == 1 || GET_MODE_SIZE (mode) == 2)
1513         rv = gen_rtx_REG (mode, TARGET_A16 ? R1_REGNO : R0_REGNO);
1514       break;
1515
1516     case 2:
1517       if (TARGET_A16 && GET_MODE_SIZE (mode) == 2)
1518         rv = gen_rtx_REG (mode, R2_REGNO);
1519       break;
1520     }
1521
1522 #if DEBUG0
1523   debug_rtx (rv);
1524 #endif
1525   return rv;
1526 }
1527
1528 #undef TARGET_PASS_BY_REFERENCE
1529 #define TARGET_PASS_BY_REFERENCE m32c_pass_by_reference
1530 static bool
1531 m32c_pass_by_reference (CUMULATIVE_ARGS * ca ATTRIBUTE_UNUSED,
1532                         enum machine_mode mode ATTRIBUTE_UNUSED,
1533                         const_tree type ATTRIBUTE_UNUSED,
1534                         bool named ATTRIBUTE_UNUSED)
1535 {
1536   return 0;
1537 }
1538
1539 /* Implements INIT_CUMULATIVE_ARGS.  */
1540 void
1541 m32c_init_cumulative_args (CUMULATIVE_ARGS * ca,
1542                            tree fntype,
1543                            rtx libname ATTRIBUTE_UNUSED,
1544                            tree fndecl,
1545                            int n_named_args ATTRIBUTE_UNUSED)
1546 {
1547   if (fntype && aggregate_value_p (TREE_TYPE (fntype), fndecl))
1548     ca->force_mem = 1;
1549   else
1550     ca->force_mem = 0;
1551   ca->parm_num = 1;
1552 }
1553
1554 /* Implements FUNCTION_ARG_ADVANCE.  force_mem is set for functions
1555    returning structures, so we always reset that.  Otherwise, we only
1556    need to know the sequence number of the argument to know what to do
1557    with it.  */
1558 void
1559 m32c_function_arg_advance (CUMULATIVE_ARGS * ca,
1560                            enum machine_mode mode ATTRIBUTE_UNUSED,
1561                            tree type ATTRIBUTE_UNUSED,
1562                            int named ATTRIBUTE_UNUSED)
1563 {
1564   if (ca->force_mem)
1565     ca->force_mem = 0;
1566   else
1567     ca->parm_num++;
1568 }
1569
1570 /* Implements FUNCTION_ARG_REGNO_P.  */
1571 int
1572 m32c_function_arg_regno_p (int r)
1573 {
1574   if (TARGET_A24)
1575     return (r == R0_REGNO);
1576   return (r == R1_REGNO || r == R2_REGNO);
1577 }
1578
1579 /* HImode and PSImode are the two "native" modes as far as GCC is
1580    concerned, but the chips also support a 32-bit mode which is used
1581    for some opcodes in R8C/M16C and for reset vectors and such.  */
1582 #undef TARGET_VALID_POINTER_MODE
1583 #define TARGET_VALID_POINTER_MODE m32c_valid_pointer_mode
1584 static bool
1585 m32c_valid_pointer_mode (enum machine_mode mode)
1586 {
1587   if (mode == HImode
1588       || mode == PSImode
1589       || mode == SImode
1590       )
1591     return 1;
1592   return 0;
1593 }
1594
1595 /* How Scalar Function Values Are Returned */
1596
1597 /* Implements LIBCALL_VALUE.  Most values are returned in $r0, or some
1598    combination of registers starting there (r2r0 for longs, r3r1r2r0
1599    for long long, r3r2r1r0 for doubles), except that that ABI
1600    currently doesn't work because it ends up using all available
1601    general registers and gcc often can't compile it.  So, instead, we
1602    return anything bigger than 16 bits in "mem0" (effectively, a
1603    memory location).  */
1604 rtx
1605 m32c_libcall_value (enum machine_mode mode)
1606 {
1607   /* return reg or parallel */
1608 #if 0
1609   /* FIXME: GCC has difficulty returning large values in registers,
1610      because that ties up most of the general registers and gives the
1611      register allocator little to work with.  Until we can resolve
1612      this, large values are returned in memory.  */
1613   if (mode == DFmode)
1614     {
1615       rtx rv;
1616
1617       rv = gen_rtx_PARALLEL (mode, rtvec_alloc (4));
1618       XVECEXP (rv, 0, 0) = gen_rtx_EXPR_LIST (VOIDmode,
1619                                               gen_rtx_REG (HImode,
1620                                                            R0_REGNO),
1621                                               GEN_INT (0));
1622       XVECEXP (rv, 0, 1) = gen_rtx_EXPR_LIST (VOIDmode,
1623                                               gen_rtx_REG (HImode,
1624                                                            R1_REGNO),
1625                                               GEN_INT (2));
1626       XVECEXP (rv, 0, 2) = gen_rtx_EXPR_LIST (VOIDmode,
1627                                               gen_rtx_REG (HImode,
1628                                                            R2_REGNO),
1629                                               GEN_INT (4));
1630       XVECEXP (rv, 0, 3) = gen_rtx_EXPR_LIST (VOIDmode,
1631                                               gen_rtx_REG (HImode,
1632                                                            R3_REGNO),
1633                                               GEN_INT (6));
1634       return rv;
1635     }
1636
1637   if (TARGET_A24 && GET_MODE_SIZE (mode) > 2)
1638     {
1639       rtx rv;
1640
1641       rv = gen_rtx_PARALLEL (mode, rtvec_alloc (1));
1642       XVECEXP (rv, 0, 0) = gen_rtx_EXPR_LIST (VOIDmode,
1643                                               gen_rtx_REG (mode,
1644                                                            R0_REGNO),
1645                                               GEN_INT (0));
1646       return rv;
1647     }
1648 #endif
1649
1650   if (GET_MODE_SIZE (mode) > 2)
1651     return gen_rtx_REG (mode, MEM0_REGNO);
1652   return gen_rtx_REG (mode, R0_REGNO);
1653 }
1654
1655 /* Implements FUNCTION_VALUE.  Functions and libcalls have the same
1656    conventions.  */
1657 rtx
1658 m32c_function_value (const_tree valtype, const_tree func ATTRIBUTE_UNUSED)
1659 {
1660   /* return reg or parallel */
1661   const enum machine_mode mode = TYPE_MODE (valtype);
1662   return m32c_libcall_value (mode);
1663 }
1664
1665 /* How Large Values Are Returned */
1666
1667 /* We return structures by pushing the address on the stack, even if
1668    we use registers for the first few "real" arguments.  */
1669 #undef TARGET_STRUCT_VALUE_RTX
1670 #define TARGET_STRUCT_VALUE_RTX m32c_struct_value_rtx
1671 static rtx
1672 m32c_struct_value_rtx (tree fndecl ATTRIBUTE_UNUSED,
1673                        int incoming ATTRIBUTE_UNUSED)
1674 {
1675   return 0;
1676 }
1677
1678 /* Function Entry and Exit */
1679
1680 /* Implements EPILOGUE_USES.  Interrupts restore all registers.  */
1681 int
1682 m32c_epilogue_uses (int regno ATTRIBUTE_UNUSED)
1683 {
1684   if (cfun->machine->is_interrupt)
1685     return 1;
1686   return 0;
1687 }
1688
1689 /* Implementing the Varargs Macros */
1690
1691 #undef TARGET_STRICT_ARGUMENT_NAMING
1692 #define TARGET_STRICT_ARGUMENT_NAMING m32c_strict_argument_naming
1693 static bool
1694 m32c_strict_argument_naming (CUMULATIVE_ARGS * ca ATTRIBUTE_UNUSED)
1695 {
1696   return 1;
1697 }
1698
1699 /* Trampolines for Nested Functions */
1700
1701 /*
1702    m16c:
1703    1 0000 75C43412              mov.w   #0x1234,a0
1704    2 0004 FC000000              jmp.a   label
1705
1706    m32c:
1707    1 0000 BC563412              mov.l:s #0x123456,a0
1708    2 0004 CC000000              jmp.a   label
1709 */
1710
1711 /* Implements TRAMPOLINE_SIZE.  */
1712 int
1713 m32c_trampoline_size (void)
1714 {
1715   /* Allocate extra space so we can avoid the messy shifts when we
1716      initialize the trampoline; we just write past the end of the
1717      opcode.  */
1718   return TARGET_A16 ? 8 : 10;
1719 }
1720
1721 /* Implements TRAMPOLINE_ALIGNMENT.  */
1722 int
1723 m32c_trampoline_alignment (void)
1724 {
1725   return 2;
1726 }
1727
1728 /* Implements INITIALIZE_TRAMPOLINE.  */
1729 void
1730 m32c_initialize_trampoline (rtx tramp, rtx function, rtx chainval)
1731 {
1732 #define A0(m,i) gen_rtx_MEM (m, plus_constant (tramp, i))
1733   if (TARGET_A16)
1734     {
1735       /* Note: we subtract a "word" because the moves want signed
1736          constants, not unsigned constants.  */
1737       emit_move_insn (A0 (HImode, 0), GEN_INT (0xc475 - 0x10000));
1738       emit_move_insn (A0 (HImode, 2), chainval);
1739       emit_move_insn (A0 (QImode, 4), GEN_INT (0xfc - 0x100));
1740       /* We use 16-bit addresses here, but store the zero to turn it
1741          into a 24-bit offset.  */
1742       emit_move_insn (A0 (HImode, 5), function);
1743       emit_move_insn (A0 (QImode, 7), GEN_INT (0x00));
1744     }
1745   else
1746     {
1747       /* Note that the PSI moves actually write 4 bytes.  Make sure we
1748          write stuff out in the right order, and leave room for the
1749          extra byte at the end.  */
1750       emit_move_insn (A0 (QImode, 0), GEN_INT (0xbc - 0x100));
1751       emit_move_insn (A0 (PSImode, 1), chainval);
1752       emit_move_insn (A0 (QImode, 4), GEN_INT (0xcc - 0x100));
1753       emit_move_insn (A0 (PSImode, 5), function);
1754     }
1755 #undef A0
1756 }
1757
1758 /* Implicit Calls to Library Routines */
1759
1760 #undef TARGET_INIT_LIBFUNCS
1761 #define TARGET_INIT_LIBFUNCS m32c_init_libfuncs
1762 static void
1763 m32c_init_libfuncs (void)
1764 {
1765   if (TARGET_A24)
1766     {
1767       /* We do this because the M32C has an HImode operand, but the
1768          M16C has an 8-bit operand.  Since gcc looks at the match data
1769          and not the expanded rtl, we have to reset the array so that
1770          the right modes are found. */
1771       setcc_gen_code[EQ] = CODE_FOR_seq_24;
1772       setcc_gen_code[NE] = CODE_FOR_sne_24;
1773       setcc_gen_code[GT] = CODE_FOR_sgt_24;
1774       setcc_gen_code[GE] = CODE_FOR_sge_24;
1775       setcc_gen_code[LT] = CODE_FOR_slt_24;
1776       setcc_gen_code[LE] = CODE_FOR_sle_24;
1777       setcc_gen_code[GTU] = CODE_FOR_sgtu_24;
1778       setcc_gen_code[GEU] = CODE_FOR_sgeu_24;
1779       setcc_gen_code[LTU] = CODE_FOR_sltu_24;
1780       setcc_gen_code[LEU] = CODE_FOR_sleu_24;
1781     }
1782 }
1783
1784 /* Addressing Modes */
1785
1786 /* Used by GO_IF_LEGITIMATE_ADDRESS.  The r8c/m32c family supports a
1787    wide range of non-orthogonal addressing modes, including the
1788    ability to double-indirect on *some* of them.  Not all insns
1789    support all modes, either, but we rely on predicates and
1790    constraints to deal with that.  */
1791 int
1792 m32c_legitimate_address_p (enum machine_mode mode, rtx x, int strict)
1793 {
1794   int mode_adjust;
1795   if (CONSTANT_P (x))
1796     return 1;
1797
1798   /* Wide references to memory will be split after reload, so we must
1799      ensure that all parts of such splits remain legitimate
1800      addresses.  */
1801   mode_adjust = GET_MODE_SIZE (mode) - 1;
1802
1803   /* allowing PLUS yields mem:HI(plus:SI(mem:SI(plus:SI in m32c_split_move */
1804   if (GET_CODE (x) == PRE_DEC
1805       || GET_CODE (x) == POST_INC || GET_CODE (x) == PRE_MODIFY)
1806     {
1807       return (GET_CODE (XEXP (x, 0)) == REG
1808               && REGNO (XEXP (x, 0)) == SP_REGNO);
1809     }
1810
1811 #if 0
1812   /* This is the double indirection detection, but it currently
1813      doesn't work as cleanly as this code implies, so until we've had
1814      a chance to debug it, leave it disabled.  */
1815   if (TARGET_A24 && GET_CODE (x) == MEM && GET_CODE (XEXP (x, 0)) != PLUS)
1816     {
1817 #if DEBUG_DOUBLE
1818       fprintf (stderr, "double indirect\n");
1819 #endif
1820       x = XEXP (x, 0);
1821     }
1822 #endif
1823
1824   encode_pattern (x);
1825   if (RTX_IS ("r"))
1826     {
1827       /* Most indexable registers can be used without displacements,
1828          although some of them will be emitted with an explicit zero
1829          to please the assembler.  */
1830       switch (REGNO (patternr[0]))
1831         {
1832         case A0_REGNO:
1833         case A1_REGNO:
1834         case SB_REGNO:
1835         case FB_REGNO:
1836         case SP_REGNO:
1837           return 1;
1838
1839         default:
1840           if (IS_PSEUDO (patternr[0], strict))
1841             return 1;
1842           return 0;
1843         }
1844     }
1845   if (RTX_IS ("+ri"))
1846     {
1847       /* This is more interesting, because different base registers
1848          allow for different displacements - both range and signedness
1849          - and it differs from chip series to chip series too.  */
1850       int rn = REGNO (patternr[1]);
1851       HOST_WIDE_INT offs = INTVAL (patternr[2]);
1852       switch (rn)
1853         {
1854         case A0_REGNO:
1855         case A1_REGNO:
1856         case SB_REGNO:
1857           /* The syntax only allows positive offsets, but when the
1858              offsets span the entire memory range, we can simulate
1859              negative offsets by wrapping.  */
1860           if (TARGET_A16)
1861             return (offs >= -65536 && offs <= 65535 - mode_adjust);
1862           if (rn == SB_REGNO)
1863             return (offs >= 0 && offs <= 65535 - mode_adjust);
1864           /* A0 or A1 */
1865           return (offs >= -16777216 && offs <= 16777215);
1866
1867         case FB_REGNO:
1868           if (TARGET_A16)
1869             return (offs >= -128 && offs <= 127 - mode_adjust);
1870           return (offs >= -65536 && offs <= 65535 - mode_adjust);
1871
1872         case SP_REGNO:
1873           return (offs >= -128 && offs <= 127 - mode_adjust);
1874
1875         default:
1876           if (IS_PSEUDO (patternr[1], strict))
1877             return 1;
1878           return 0;
1879         }
1880     }
1881   if (RTX_IS ("+rs") || RTX_IS ("+r+si"))
1882     {
1883       rtx reg = patternr[1];
1884
1885       /* We don't know where the symbol is, so only allow base
1886          registers which support displacements spanning the whole
1887          address range.  */
1888       switch (REGNO (reg))
1889         {
1890         case A0_REGNO:
1891         case A1_REGNO:
1892           /* $sb needs a secondary reload, but since it's involved in
1893              memory address reloads too, we don't deal with it very
1894              well.  */
1895           /*    case SB_REGNO: */
1896           return 1;
1897         default:
1898           if (IS_PSEUDO (reg, strict))
1899             return 1;
1900           return 0;
1901         }
1902     }
1903   return 0;
1904 }
1905
1906 /* Implements REG_OK_FOR_BASE_P.  */
1907 int
1908 m32c_reg_ok_for_base_p (rtx x, int strict)
1909 {
1910   if (GET_CODE (x) != REG)
1911     return 0;
1912   switch (REGNO (x))
1913     {
1914     case A0_REGNO:
1915     case A1_REGNO:
1916     case SB_REGNO:
1917     case FB_REGNO:
1918     case SP_REGNO:
1919       return 1;
1920     default:
1921       if (IS_PSEUDO (x, strict))
1922         return 1;
1923       return 0;
1924     }
1925 }
1926
1927 /* We have three choices for choosing fb->aN offsets.  If we choose -128,
1928    we need one MOVA -128[fb],aN opcode and 16-bit aN displacements,
1929    like this:
1930        EB 4B FF    mova    -128[$fb],$a0
1931        D8 0C FF FF mov.w:Q #0,-1[$a0]
1932
1933    Alternately, we subtract the frame size, and hopefully use 8-bit aN
1934    displacements:
1935        7B F4       stc $fb,$a0
1936        77 54 00 01 sub #256,$a0
1937        D8 08 01    mov.w:Q #0,1[$a0]
1938
1939    If we don't offset (i.e. offset by zero), we end up with:
1940        7B F4       stc $fb,$a0
1941        D8 0C 00 FF mov.w:Q #0,-256[$a0]
1942
1943    We have to subtract *something* so that we have a PLUS rtx to mark
1944    that we've done this reload.  The -128 offset will never result in
1945    an 8-bit aN offset, and the payoff for the second case is five
1946    loads *if* those loads are within 256 bytes of the other end of the
1947    frame, so the third case seems best.  Note that we subtract the
1948    zero, but detect that in the addhi3 pattern.  */
1949
1950 #define BIG_FB_ADJ 0
1951
1952 /* Implements LEGITIMIZE_ADDRESS.  The only address we really have to
1953    worry about is frame base offsets, as $fb has a limited
1954    displacement range.  We deal with this by attempting to reload $fb
1955    itself into an address register; that seems to result in the best
1956    code.  */
1957 int
1958 m32c_legitimize_address (rtx * x ATTRIBUTE_UNUSED,
1959                          rtx oldx ATTRIBUTE_UNUSED,
1960                          enum machine_mode mode ATTRIBUTE_UNUSED)
1961 {
1962 #if DEBUG0
1963   fprintf (stderr, "m32c_legitimize_address for mode %s\n", mode_name[mode]);
1964   debug_rtx (*x);
1965   fprintf (stderr, "\n");
1966 #endif
1967
1968   if (GET_CODE (*x) == PLUS
1969       && GET_CODE (XEXP (*x, 0)) == REG
1970       && REGNO (XEXP (*x, 0)) == FB_REGNO
1971       && GET_CODE (XEXP (*x, 1)) == CONST_INT
1972       && (INTVAL (XEXP (*x, 1)) < -128
1973           || INTVAL (XEXP (*x, 1)) > (128 - GET_MODE_SIZE (mode))))
1974     {
1975       /* reload FB to A_REGS */
1976       rtx temp = gen_reg_rtx (Pmode);
1977       *x = copy_rtx (*x);
1978       emit_insn (gen_rtx_SET (VOIDmode, temp, XEXP (*x, 0)));
1979       XEXP (*x, 0) = temp;
1980       return 1;
1981     }
1982
1983   return 0;
1984 }
1985
1986 /* Implements LEGITIMIZE_RELOAD_ADDRESS.  See comment above.  */
1987 int
1988 m32c_legitimize_reload_address (rtx * x,
1989                                 enum machine_mode mode,
1990                                 int opnum,
1991                                 int type, int ind_levels ATTRIBUTE_UNUSED)
1992 {
1993 #if DEBUG0
1994   fprintf (stderr, "\nm32c_legitimize_reload_address for mode %s\n",
1995            mode_name[mode]);
1996   debug_rtx (*x);
1997 #endif
1998
1999   /* At one point, this function tried to get $fb copied to an address
2000      register, which in theory would maximize sharing, but gcc was
2001      *also* still trying to reload the whole address, and we'd run out
2002      of address registers.  So we let gcc do the naive (but safe)
2003      reload instead, when the above function doesn't handle it for
2004      us.
2005
2006      The code below is a second attempt at the above.  */
2007
2008   if (GET_CODE (*x) == PLUS
2009       && GET_CODE (XEXP (*x, 0)) == REG
2010       && REGNO (XEXP (*x, 0)) == FB_REGNO
2011       && GET_CODE (XEXP (*x, 1)) == CONST_INT
2012       && (INTVAL (XEXP (*x, 1)) < -128
2013           || INTVAL (XEXP (*x, 1)) > (128 - GET_MODE_SIZE (mode))))
2014     {
2015       rtx sum;
2016       int offset = INTVAL (XEXP (*x, 1));
2017       int adjustment = -BIG_FB_ADJ;
2018
2019       sum = gen_rtx_PLUS (Pmode, XEXP (*x, 0),
2020                           GEN_INT (adjustment));
2021       *x = gen_rtx_PLUS (Pmode, sum, GEN_INT (offset - adjustment));
2022       if (type == RELOAD_OTHER)
2023         type = RELOAD_FOR_OTHER_ADDRESS;
2024       push_reload (sum, NULL_RTX, &XEXP (*x, 0), NULL,
2025                    A_REGS, Pmode, VOIDmode, 0, 0, opnum,
2026                    type);
2027       return 1;
2028     }
2029
2030   if (GET_CODE (*x) == PLUS
2031       && GET_CODE (XEXP (*x, 0)) == PLUS
2032       && GET_CODE (XEXP (XEXP (*x, 0), 0)) == REG
2033       && REGNO (XEXP (XEXP (*x, 0), 0)) == FB_REGNO
2034       && GET_CODE (XEXP (XEXP (*x, 0), 1)) == CONST_INT
2035       && GET_CODE (XEXP (*x, 1)) == CONST_INT
2036       )
2037     {
2038       if (type == RELOAD_OTHER)
2039         type = RELOAD_FOR_OTHER_ADDRESS;
2040       push_reload (XEXP (*x, 0), NULL_RTX, &XEXP (*x, 0), NULL,
2041                    A_REGS, Pmode, VOIDmode, 0, 0, opnum,
2042                    type);
2043       return 1;
2044     }
2045
2046   return 0;
2047 }
2048
2049 /* Implements LEGITIMATE_CONSTANT_P.  We split large constants anyway,
2050    so we can allow anything.  */
2051 int
2052 m32c_legitimate_constant_p (rtx x ATTRIBUTE_UNUSED)
2053 {
2054   return 1;
2055 }
2056
2057
2058 /* Condition Code Status */
2059
2060 #undef TARGET_FIXED_CONDITION_CODE_REGS
2061 #define TARGET_FIXED_CONDITION_CODE_REGS m32c_fixed_condition_code_regs
2062 static bool
2063 m32c_fixed_condition_code_regs (unsigned int *p1, unsigned int *p2)
2064 {
2065   *p1 = FLG_REGNO;
2066   *p2 = INVALID_REGNUM;
2067   return true;
2068 }
2069
2070 /* Describing Relative Costs of Operations */
2071
2072 /* Implements REGISTER_MOVE_COST.  We make impossible moves
2073    prohibitively expensive, like trying to put QIs in r2/r3 (there are
2074    no opcodes to do that).  We also discourage use of mem* registers
2075    since they're really memory.  */
2076 int
2077 m32c_register_move_cost (enum machine_mode mode, int from, int to)
2078 {
2079   int cost = COSTS_N_INSNS (3);
2080   int cc = class_contents[from][0] | class_contents[to][0];
2081   /* FIXME: pick real values, but not 2 for now.  */
2082   if (mode == QImode && (cc & class_contents[R23_REGS][0]))
2083     {
2084       if (!(cc & ~class_contents[R23_REGS][0]))
2085         cost = COSTS_N_INSNS (1000);
2086       else
2087         cost = COSTS_N_INSNS (80);
2088     }
2089
2090   if (!class_can_hold_mode (from, mode) || !class_can_hold_mode (to, mode))
2091     cost = COSTS_N_INSNS (1000);
2092
2093   if (classes_intersect (from, CR_REGS))
2094     cost += COSTS_N_INSNS (5);
2095
2096   if (classes_intersect (to, CR_REGS))
2097     cost += COSTS_N_INSNS (5);
2098
2099   if (from == MEM_REGS || to == MEM_REGS)
2100     cost += COSTS_N_INSNS (50);
2101   else if (classes_intersect (from, MEM_REGS)
2102            || classes_intersect (to, MEM_REGS))
2103     cost += COSTS_N_INSNS (10);
2104
2105 #if DEBUG0
2106   fprintf (stderr, "register_move_cost %s from %s to %s = %d\n",
2107            mode_name[mode], class_names[from], class_names[to], cost);
2108 #endif
2109   return cost;
2110 }
2111
2112 /*  Implements MEMORY_MOVE_COST.  */
2113 int
2114 m32c_memory_move_cost (enum machine_mode mode ATTRIBUTE_UNUSED,
2115                        int reg_class ATTRIBUTE_UNUSED,
2116                        int in ATTRIBUTE_UNUSED)
2117 {
2118   /* FIXME: pick real values.  */
2119   return COSTS_N_INSNS (10);
2120 }
2121
2122 /* Here we try to describe when we use multiple opcodes for one RTX so
2123    that gcc knows when to use them.  */
2124 #undef TARGET_RTX_COSTS
2125 #define TARGET_RTX_COSTS m32c_rtx_costs
2126 static bool
2127 m32c_rtx_costs (rtx x, int code, int outer_code, int *total,
2128                 bool speed ATTRIBUTE_UNUSED)
2129 {
2130   switch (code)
2131     {
2132     case REG:
2133       if (REGNO (x) >= MEM0_REGNO && REGNO (x) <= MEM7_REGNO)
2134         *total += COSTS_N_INSNS (500);
2135       else
2136         *total += COSTS_N_INSNS (1);
2137       return true;
2138
2139     case ASHIFT:
2140     case LSHIFTRT:
2141     case ASHIFTRT:
2142       if (GET_CODE (XEXP (x, 1)) != CONST_INT)
2143         {
2144           /* mov.b r1l, r1h */
2145           *total +=  COSTS_N_INSNS (1);
2146           return true;
2147         }
2148       if (INTVAL (XEXP (x, 1)) > 8
2149           || INTVAL (XEXP (x, 1)) < -8)
2150         {
2151           /* mov.b #N, r1l */
2152           /* mov.b r1l, r1h */
2153           *total +=  COSTS_N_INSNS (2);
2154           return true;
2155         }
2156       return true;
2157
2158     case LE:
2159     case LEU:
2160     case LT:
2161     case LTU:
2162     case GT:
2163     case GTU:
2164     case GE:
2165     case GEU:
2166     case NE:
2167     case EQ:
2168       if (outer_code == SET)
2169         {
2170           *total += COSTS_N_INSNS (2);
2171           return true;
2172         }
2173       break;
2174
2175     case ZERO_EXTRACT:
2176       {
2177         rtx dest = XEXP (x, 0);
2178         rtx addr = XEXP (dest, 0);
2179         switch (GET_CODE (addr))
2180           {
2181           case CONST_INT:
2182             *total += COSTS_N_INSNS (1);
2183             break;
2184           case SYMBOL_REF:
2185             *total += COSTS_N_INSNS (3);
2186             break;
2187           default:
2188             *total += COSTS_N_INSNS (2);
2189             break;
2190           }
2191         return true;
2192       }
2193       break;
2194
2195     default:
2196       /* Reasonable default.  */
2197       if (TARGET_A16 && GET_MODE(x) == SImode)
2198         *total += COSTS_N_INSNS (2);
2199       break;
2200     }
2201   return false;
2202 }
2203
2204 #undef TARGET_ADDRESS_COST
2205 #define TARGET_ADDRESS_COST m32c_address_cost
2206 static int
2207 m32c_address_cost (rtx addr, bool speed ATTRIBUTE_UNUSED)
2208 {
2209   int i;
2210   /*  fprintf(stderr, "\naddress_cost\n");
2211       debug_rtx(addr);*/
2212   switch (GET_CODE (addr))
2213     {
2214     case CONST_INT:
2215       i = INTVAL (addr);
2216       if (i == 0)
2217         return COSTS_N_INSNS(1);
2218       if (0 < i && i <= 255)
2219         return COSTS_N_INSNS(2);
2220       if (0 < i && i <= 65535)
2221         return COSTS_N_INSNS(3);
2222       return COSTS_N_INSNS(4);
2223     case SYMBOL_REF:
2224       return COSTS_N_INSNS(4);
2225     case REG:
2226       return COSTS_N_INSNS(1);
2227     case PLUS:
2228       if (GET_CODE (XEXP (addr, 1)) == CONST_INT)
2229         {
2230           i = INTVAL (XEXP (addr, 1));
2231           if (i == 0)
2232             return COSTS_N_INSNS(1);
2233           if (0 < i && i <= 255)
2234             return COSTS_N_INSNS(2);
2235           if (0 < i && i <= 65535)
2236             return COSTS_N_INSNS(3);
2237         }
2238       return COSTS_N_INSNS(4);
2239     default:
2240       return 0;
2241     }
2242 }
2243
2244 /* Defining the Output Assembler Language */
2245
2246 /* The Overall Framework of an Assembler File */
2247
2248 #undef TARGET_HAVE_NAMED_SECTIONS
2249 #define TARGET_HAVE_NAMED_SECTIONS true
2250
2251 /* Output of Data */
2252
2253 /* We may have 24 bit sizes, which is the native address size.
2254    Currently unused, but provided for completeness.  */
2255 #undef TARGET_ASM_INTEGER
2256 #define TARGET_ASM_INTEGER m32c_asm_integer
2257 static bool
2258 m32c_asm_integer (rtx x, unsigned int size, int aligned_p)
2259 {
2260   switch (size)
2261     {
2262     case 3:
2263       fprintf (asm_out_file, "\t.3byte\t");
2264       output_addr_const (asm_out_file, x);
2265       fputc ('\n', asm_out_file);
2266       return true;
2267     case 4:
2268       if (GET_CODE (x) == SYMBOL_REF)
2269         {
2270           fprintf (asm_out_file, "\t.long\t");
2271           output_addr_const (asm_out_file, x);
2272           fputc ('\n', asm_out_file);
2273           return true;
2274         }
2275       break;
2276     }
2277   return default_assemble_integer (x, size, aligned_p);
2278 }
2279
2280 /* Output of Assembler Instructions */
2281
2282 /* We use a lookup table because the addressing modes are non-orthogonal.  */
2283
2284 static struct
2285 {
2286   char code;
2287   char const *pattern;
2288   char const *format;
2289 }
2290 const conversions[] = {
2291   { 0, "r", "0" },
2292
2293   { 0, "mr", "z[1]" },
2294   { 0, "m+ri", "3[2]" },
2295   { 0, "m+rs", "3[2]" },
2296   { 0, "m+r+si", "4+5[2]" },
2297   { 0, "ms", "1" },
2298   { 0, "mi", "1" },
2299   { 0, "m+si", "2+3" },
2300
2301   { 0, "mmr", "[z[2]]" },
2302   { 0, "mm+ri", "[4[3]]" },
2303   { 0, "mm+rs", "[4[3]]" },
2304   { 0, "mm+r+si", "[5+6[3]]" },
2305   { 0, "mms", "[[2]]" },
2306   { 0, "mmi", "[[2]]" },
2307   { 0, "mm+si", "[4[3]]" },
2308
2309   { 0, "i", "#0" },
2310   { 0, "s", "#0" },
2311   { 0, "+si", "#1+2" },
2312   { 0, "l", "#0" },
2313
2314   { 'l', "l", "0" },
2315   { 'd', "i", "0" },
2316   { 'd', "s", "0" },
2317   { 'd', "+si", "1+2" },
2318   { 'D', "i", "0" },
2319   { 'D', "s", "0" },
2320   { 'D', "+si", "1+2" },
2321   { 'x', "i", "#0" },
2322   { 'X', "i", "#0" },
2323   { 'm', "i", "#0" },
2324   { 'b', "i", "#0" },
2325   { 'B', "i", "0" },
2326   { 'p', "i", "0" },
2327
2328   { 0, 0, 0 }
2329 };
2330
2331 /* This is in order according to the bitfield that pushm/popm use.  */
2332 static char const *pushm_regs[] = {
2333   "fb", "sb", "a1", "a0", "r3", "r2", "r1", "r0"
2334 };
2335
2336 /* Implements PRINT_OPERAND.  */
2337 void
2338 m32c_print_operand (FILE * file, rtx x, int code)
2339 {
2340   int i, j, b;
2341   const char *comma;
2342   HOST_WIDE_INT ival;
2343   int unsigned_const = 0;
2344   int force_sign;
2345
2346   /* Multiplies; constants are converted to sign-extended format but
2347    we need unsigned, so 'u' and 'U' tell us what size unsigned we
2348    need.  */
2349   if (code == 'u')
2350     {
2351       unsigned_const = 2;
2352       code = 0;
2353     }
2354   if (code == 'U')
2355     {
2356       unsigned_const = 1;
2357       code = 0;
2358     }
2359   /* This one is only for debugging; you can put it in a pattern to
2360      force this error.  */
2361   if (code == '!')
2362     {
2363       fprintf (stderr, "dj: unreviewed pattern:");
2364       if (current_output_insn)
2365         debug_rtx (current_output_insn);
2366       gcc_unreachable ();
2367     }
2368   /* PSImode operations are either .w or .l depending on the target.  */
2369   if (code == '&')
2370     {
2371       if (TARGET_A16)
2372         fprintf (file, "w");
2373       else
2374         fprintf (file, "l");
2375       return;
2376     }
2377   /* Inverted conditionals.  */
2378   if (code == 'C')
2379     {
2380       switch (GET_CODE (x))
2381         {
2382         case LE:
2383           fputs ("gt", file);
2384           break;
2385         case LEU:
2386           fputs ("gtu", file);
2387           break;
2388         case LT:
2389           fputs ("ge", file);
2390           break;
2391         case LTU:
2392           fputs ("geu", file);
2393           break;
2394         case GT:
2395           fputs ("le", file);
2396           break;
2397         case GTU:
2398           fputs ("leu", file);
2399           break;
2400         case GE:
2401           fputs ("lt", file);
2402           break;
2403         case GEU:
2404           fputs ("ltu", file);
2405           break;
2406         case NE:
2407           fputs ("eq", file);
2408           break;
2409         case EQ:
2410           fputs ("ne", file);
2411           break;
2412         default:
2413           gcc_unreachable ();
2414         }
2415       return;
2416     }
2417   /* Regular conditionals.  */
2418   if (code == 'c')
2419     {
2420       switch (GET_CODE (x))
2421         {
2422         case LE:
2423           fputs ("le", file);
2424           break;
2425         case LEU:
2426           fputs ("leu", file);
2427           break;
2428         case LT:
2429           fputs ("lt", file);
2430           break;
2431         case LTU:
2432           fputs ("ltu", file);
2433           break;
2434         case GT:
2435           fputs ("gt", file);
2436           break;
2437         case GTU:
2438           fputs ("gtu", file);
2439           break;
2440         case GE:
2441           fputs ("ge", file);
2442           break;
2443         case GEU:
2444           fputs ("geu", file);
2445           break;
2446         case NE:
2447           fputs ("ne", file);
2448           break;
2449         case EQ:
2450           fputs ("eq", file);
2451           break;
2452         default:
2453           gcc_unreachable ();
2454         }
2455       return;
2456     }
2457   /* Used in negsi2 to do HImode ops on the two parts of an SImode
2458      operand.  */
2459   if (code == 'h' && GET_MODE (x) == SImode)
2460     {
2461       x = m32c_subreg (HImode, x, SImode, 0);
2462       code = 0;
2463     }
2464   if (code == 'H' && GET_MODE (x) == SImode)
2465     {
2466       x = m32c_subreg (HImode, x, SImode, 2);
2467       code = 0;
2468     }
2469   if (code == 'h' && GET_MODE (x) == HImode)
2470     {
2471       x = m32c_subreg (QImode, x, HImode, 0);
2472       code = 0;
2473     }
2474   if (code == 'H' && GET_MODE (x) == HImode)
2475     {
2476       /* We can't actually represent this as an rtx.  Do it here.  */
2477       if (GET_CODE (x) == REG)
2478         {
2479           switch (REGNO (x))
2480             {
2481             case R0_REGNO:
2482               fputs ("r0h", file);
2483               return;
2484             case R1_REGNO:
2485               fputs ("r1h", file);
2486               return;
2487             default:
2488               gcc_unreachable();
2489             }
2490         }
2491       /* This should be a MEM.  */
2492       x = m32c_subreg (QImode, x, HImode, 1);
2493       code = 0;
2494     }
2495   /* This is for BMcond, which always wants word register names.  */
2496   if (code == 'h' && GET_MODE (x) == QImode)
2497     {
2498       if (GET_CODE (x) == REG)
2499         x = gen_rtx_REG (HImode, REGNO (x));
2500       code = 0;
2501     }
2502   /* 'x' and 'X' need to be ignored for non-immediates.  */
2503   if ((code == 'x' || code == 'X') && GET_CODE (x) != CONST_INT)
2504     code = 0;
2505
2506   encode_pattern (x);
2507   force_sign = 0;
2508   for (i = 0; conversions[i].pattern; i++)
2509     if (conversions[i].code == code
2510         && streq (conversions[i].pattern, pattern))
2511       {
2512         for (j = 0; conversions[i].format[j]; j++)
2513           /* backslash quotes the next character in the output pattern.  */
2514           if (conversions[i].format[j] == '\\')
2515             {
2516               fputc (conversions[i].format[j + 1], file);
2517               j++;
2518             }
2519           /* Digits in the output pattern indicate that the
2520              corresponding RTX is to be output at that point.  */
2521           else if (ISDIGIT (conversions[i].format[j]))
2522             {
2523               rtx r = patternr[conversions[i].format[j] - '0'];
2524               switch (GET_CODE (r))
2525                 {
2526                 case REG:
2527                   fprintf (file, "%s",
2528                            reg_name_with_mode (REGNO (r), GET_MODE (r)));
2529                   break;
2530                 case CONST_INT:
2531                   switch (code)
2532                     {
2533                     case 'b':
2534                     case 'B':
2535                       {
2536                         int v = INTVAL (r);
2537                         int i = (int) exact_log2 (v);
2538                         if (i == -1)
2539                           i = (int) exact_log2 ((v ^ 0xffff) & 0xffff);
2540                         if (i == -1)
2541                           i = (int) exact_log2 ((v ^ 0xff) & 0xff);
2542                         /* Bit position.  */
2543                         fprintf (file, "%d", i);
2544                       }
2545                       break;
2546                     case 'x':
2547                       /* Unsigned byte.  */
2548                       fprintf (file, HOST_WIDE_INT_PRINT_HEX,
2549                                INTVAL (r) & 0xff);
2550                       break;
2551                     case 'X':
2552                       /* Unsigned word.  */
2553                       fprintf (file, HOST_WIDE_INT_PRINT_HEX,
2554                                INTVAL (r) & 0xffff);
2555                       break;
2556                     case 'p':
2557                       /* pushm and popm encode a register set into a single byte.  */
2558                       comma = "";
2559                       for (b = 7; b >= 0; b--)
2560                         if (INTVAL (r) & (1 << b))
2561                           {
2562                             fprintf (file, "%s%s", comma, pushm_regs[b]);
2563                             comma = ",";
2564                           }
2565                       break;
2566                     case 'm':
2567                       /* "Minus".  Output -X  */
2568                       ival = (-INTVAL (r) & 0xffff);
2569                       if (ival & 0x8000)
2570                         ival = ival - 0x10000;
2571                       fprintf (file, HOST_WIDE_INT_PRINT_DEC, ival);
2572                       break;
2573                     default:
2574                       ival = INTVAL (r);
2575                       if (conversions[i].format[j + 1] == '[' && ival < 0)
2576                         {
2577                           /* We can simulate negative displacements by
2578                              taking advantage of address space
2579                              wrapping when the offset can span the
2580                              entire address range.  */
2581                           rtx base =
2582                             patternr[conversions[i].format[j + 2] - '0'];
2583                           if (GET_CODE (base) == REG)
2584                             switch (REGNO (base))
2585                               {
2586                               case A0_REGNO:
2587                               case A1_REGNO:
2588                                 if (TARGET_A24)
2589                                   ival = 0x1000000 + ival;
2590                                 else
2591                                   ival = 0x10000 + ival;
2592                                 break;
2593                               case SB_REGNO:
2594                                 if (TARGET_A16)
2595                                   ival = 0x10000 + ival;
2596                                 break;
2597                               }
2598                         }
2599                       else if (code == 'd' && ival < 0 && j == 0)
2600                         /* The "mova" opcode is used to do addition by
2601                            computing displacements, but again, we need
2602                            displacements to be unsigned *if* they're
2603                            the only component of the displacement
2604                            (i.e. no "symbol-4" type displacement).  */
2605                         ival = (TARGET_A24 ? 0x1000000 : 0x10000) + ival;
2606
2607                       if (conversions[i].format[j] == '0')
2608                         {
2609                           /* More conversions to unsigned.  */
2610                           if (unsigned_const == 2)
2611                             ival &= 0xffff;
2612                           if (unsigned_const == 1)
2613                             ival &= 0xff;
2614                         }
2615                       if (streq (conversions[i].pattern, "mi")
2616                           || streq (conversions[i].pattern, "mmi"))
2617                         {
2618                           /* Integers used as addresses are unsigned.  */
2619                           ival &= (TARGET_A24 ? 0xffffff : 0xffff);
2620                         }
2621                       if (force_sign && ival >= 0)
2622                         fputc ('+', file);
2623                       fprintf (file, HOST_WIDE_INT_PRINT_DEC, ival);
2624                       break;
2625                     }
2626                   break;
2627                 case CONST_DOUBLE:
2628                   /* We don't have const_double constants.  If it
2629                      happens, make it obvious.  */
2630                   fprintf (file, "[const_double 0x%lx]",
2631                            (unsigned long) CONST_DOUBLE_HIGH (r));
2632                   break;
2633                 case SYMBOL_REF:
2634                   assemble_name (file, XSTR (r, 0));
2635                   break;
2636                 case LABEL_REF:
2637                   output_asm_label (r);
2638                   break;
2639                 default:
2640                   fprintf (stderr, "don't know how to print this operand:");
2641                   debug_rtx (r);
2642                   gcc_unreachable ();
2643                 }
2644             }
2645           else
2646             {
2647               if (conversions[i].format[j] == 'z')
2648                 {
2649                   /* Some addressing modes *must* have a displacement,
2650                      so insert a zero here if needed.  */
2651                   int k;
2652                   for (k = j + 1; conversions[i].format[k]; k++)
2653                     if (ISDIGIT (conversions[i].format[k]))
2654                       {
2655                         rtx reg = patternr[conversions[i].format[k] - '0'];
2656                         if (GET_CODE (reg) == REG
2657                             && (REGNO (reg) == SB_REGNO
2658                                 || REGNO (reg) == FB_REGNO
2659                                 || REGNO (reg) == SP_REGNO))
2660                           fputc ('0', file);
2661                       }
2662                   continue;
2663                 }
2664               /* Signed displacements off symbols need to have signs
2665                  blended cleanly.  */
2666               if (conversions[i].format[j] == '+'
2667                   && (!code || code == 'D' || code == 'd')
2668                   && ISDIGIT (conversions[i].format[j + 1])
2669                   && (GET_CODE (patternr[conversions[i].format[j + 1] - '0'])
2670                       == CONST_INT))
2671                 {
2672                   force_sign = 1;
2673                   continue;
2674                 }
2675               fputc (conversions[i].format[j], file);
2676             }
2677         break;
2678       }
2679   if (!conversions[i].pattern)
2680     {
2681       fprintf (stderr, "unconvertible operand %c `%s'", code ? code : '-',
2682                pattern);
2683       debug_rtx (x);
2684       fprintf (file, "[%c.%s]", code ? code : '-', pattern);
2685     }
2686
2687   return;
2688 }
2689
2690 /* Implements PRINT_OPERAND_PUNCT_VALID_P.  See m32c_print_operand
2691    above for descriptions of what these do.  */
2692 int
2693 m32c_print_operand_punct_valid_p (int c)
2694 {
2695   if (c == '&' || c == '!')
2696     return 1;
2697   return 0;
2698 }
2699
2700 /* Implements PRINT_OPERAND_ADDRESS.  Nothing unusual here.  */
2701 void
2702 m32c_print_operand_address (FILE * stream, rtx address)
2703 {
2704   if (GET_CODE (address) == MEM)
2705     address = XEXP (address, 0);
2706   else
2707     /* cf: gcc.dg/asm-4.c.  */
2708     gcc_assert (GET_CODE (address) == REG);
2709
2710   m32c_print_operand (stream, address, 0);
2711 }
2712
2713 /* Implements ASM_OUTPUT_REG_PUSH.  Control registers are pushed
2714    differently than general registers.  */
2715 void
2716 m32c_output_reg_push (FILE * s, int regno)
2717 {
2718   if (regno == FLG_REGNO)
2719     fprintf (s, "\tpushc\tflg\n");
2720   else
2721     fprintf (s, "\tpush.%c\t%s\n",
2722              " bwll"[reg_push_size (regno)], reg_names[regno]);
2723 }
2724
2725 /* Likewise for ASM_OUTPUT_REG_POP.  */
2726 void
2727 m32c_output_reg_pop (FILE * s, int regno)
2728 {
2729   if (regno == FLG_REGNO)
2730     fprintf (s, "\tpopc\tflg\n");
2731   else
2732     fprintf (s, "\tpop.%c\t%s\n",
2733              " bwll"[reg_push_size (regno)], reg_names[regno]);
2734 }
2735
2736 /* Defining target-specific uses of `__attribute__' */
2737
2738 /* Used to simplify the logic below.  Find the attributes wherever
2739    they may be.  */
2740 #define M32C_ATTRIBUTES(decl) \
2741   (TYPE_P (decl)) ? TYPE_ATTRIBUTES (decl) \
2742                 : DECL_ATTRIBUTES (decl) \
2743                   ? (DECL_ATTRIBUTES (decl)) \
2744                   : TYPE_ATTRIBUTES (TREE_TYPE (decl))
2745
2746 /* Returns TRUE if the given tree has the "interrupt" attribute.  */
2747 static int
2748 interrupt_p (tree node ATTRIBUTE_UNUSED)
2749 {
2750   tree list = M32C_ATTRIBUTES (node);
2751   while (list)
2752     {
2753       if (is_attribute_p ("interrupt", TREE_PURPOSE (list)))
2754         return 1;
2755       list = TREE_CHAIN (list);
2756     }
2757   return 0;
2758 }
2759
2760 static tree
2761 interrupt_handler (tree * node ATTRIBUTE_UNUSED,
2762                    tree name ATTRIBUTE_UNUSED,
2763                    tree args ATTRIBUTE_UNUSED,
2764                    int flags ATTRIBUTE_UNUSED,
2765                    bool * no_add_attrs ATTRIBUTE_UNUSED)
2766 {
2767   return NULL_TREE;
2768 }
2769
2770 /* Returns TRUE if given tree has the "function_vector" attribute. */
2771 int
2772 m32c_special_page_vector_p (tree func)
2773 {
2774   if (TREE_CODE (func) != FUNCTION_DECL)
2775     return 0;
2776
2777   tree list = M32C_ATTRIBUTES (func);
2778   while (list)
2779     {
2780       if (is_attribute_p ("function_vector", TREE_PURPOSE (list)))
2781         return 1;
2782       list = TREE_CHAIN (list);
2783     }
2784   return 0;
2785 }
2786
2787 static tree
2788 function_vector_handler (tree * node ATTRIBUTE_UNUSED,
2789                          tree name ATTRIBUTE_UNUSED,
2790                          tree args ATTRIBUTE_UNUSED,
2791                          int flags ATTRIBUTE_UNUSED,
2792                          bool * no_add_attrs ATTRIBUTE_UNUSED)
2793 {
2794   if (TARGET_R8C)
2795     {
2796       /* The attribute is not supported for R8C target.  */
2797       warning (OPT_Wattributes,
2798                 "`%s' attribute is not supported for R8C target",
2799                 IDENTIFIER_POINTER (name));
2800       *no_add_attrs = true;
2801     }
2802   else if (TREE_CODE (*node) != FUNCTION_DECL)
2803     {
2804       /* The attribute must be applied to functions only.  */
2805       warning (OPT_Wattributes,
2806                 "`%s' attribute applies only to functions",
2807                 IDENTIFIER_POINTER (name));
2808       *no_add_attrs = true;
2809     }
2810   else if (TREE_CODE (TREE_VALUE (args)) != INTEGER_CST)
2811     {
2812       /* The argument must be a constant integer.  */
2813       warning (OPT_Wattributes,
2814                 "`%s' attribute argument not an integer constant",
2815                 IDENTIFIER_POINTER (name));
2816       *no_add_attrs = true;
2817     }
2818   else if (TREE_INT_CST_LOW (TREE_VALUE (args)) < 18
2819            || TREE_INT_CST_LOW (TREE_VALUE (args)) > 255)
2820     {
2821       /* The argument value must be between 18 to 255.  */
2822       warning (OPT_Wattributes,
2823                 "`%s' attribute argument should be between 18 to 255",
2824                 IDENTIFIER_POINTER (name));
2825       *no_add_attrs = true;
2826     }
2827   return NULL_TREE;
2828 }
2829
2830 /* If the function is assigned the attribute 'function_vector', it
2831    returns the function vector number, otherwise returns zero.  */
2832 int
2833 current_function_special_page_vector (rtx x)
2834 {
2835   int num;
2836
2837   if ((GET_CODE(x) == SYMBOL_REF)
2838       && (SYMBOL_REF_FLAGS (x) & SYMBOL_FLAG_FUNCVEC_FUNCTION))
2839     {
2840       tree t = SYMBOL_REF_DECL (x);
2841
2842       if (TREE_CODE (t) != FUNCTION_DECL)
2843         return 0;
2844
2845       tree list = M32C_ATTRIBUTES (t);
2846       while (list)
2847         {
2848           if (is_attribute_p ("function_vector", TREE_PURPOSE (list)))
2849             {
2850               num = TREE_INT_CST_LOW (TREE_VALUE (TREE_VALUE (list)));
2851               return num;
2852             }
2853
2854           list = TREE_CHAIN (list);
2855         }
2856
2857       return 0;
2858     }
2859   else
2860     return 0;
2861 }
2862
2863 #undef TARGET_ATTRIBUTE_TABLE
2864 #define TARGET_ATTRIBUTE_TABLE m32c_attribute_table
2865 static const struct attribute_spec m32c_attribute_table[] = {
2866   {"interrupt", 0, 0, false, false, false, interrupt_handler},
2867   {"function_vector", 1, 1, true,  false, false, function_vector_handler},
2868   {0, 0, 0, 0, 0, 0, 0}
2869 };
2870
2871 #undef TARGET_COMP_TYPE_ATTRIBUTES
2872 #define TARGET_COMP_TYPE_ATTRIBUTES m32c_comp_type_attributes
2873 static int
2874 m32c_comp_type_attributes (const_tree type1 ATTRIBUTE_UNUSED,
2875                            const_tree type2 ATTRIBUTE_UNUSED)
2876 {
2877   /* 0=incompatible 1=compatible 2=warning */
2878   return 1;
2879 }
2880
2881 #undef TARGET_INSERT_ATTRIBUTES
2882 #define TARGET_INSERT_ATTRIBUTES m32c_insert_attributes
2883 static void
2884 m32c_insert_attributes (tree node ATTRIBUTE_UNUSED,
2885                         tree * attr_ptr ATTRIBUTE_UNUSED)
2886 {
2887   /* Nothing to do here.  */
2888 }
2889
2890 /* Predicates */
2891
2892 /* This is a list of legal subregs of hard regs.  */
2893 static const struct {
2894   unsigned char outer_mode_size;
2895   unsigned char inner_mode_size;
2896   unsigned char byte_mask;
2897   unsigned char legal_when;
2898   unsigned int regno;
2899 } legal_subregs[] = {
2900   {1, 2, 0x03, 1, R0_REGNO}, /* r0h r0l */
2901   {1, 2, 0x03, 1, R1_REGNO}, /* r1h r1l */
2902   {1, 2, 0x01, 1, A0_REGNO},
2903   {1, 2, 0x01, 1, A1_REGNO},
2904
2905   {1, 4, 0x01, 1, A0_REGNO},
2906   {1, 4, 0x01, 1, A1_REGNO},
2907
2908   {2, 4, 0x05, 1, R0_REGNO}, /* r2 r0 */
2909   {2, 4, 0x05, 1, R1_REGNO}, /* r3 r1 */
2910   {2, 4, 0x05, 16, A0_REGNO}, /* a1 a0 */
2911   {2, 4, 0x01, 24, A0_REGNO}, /* a1 a0 */
2912   {2, 4, 0x01, 24, A1_REGNO}, /* a1 a0 */
2913
2914   {4, 8, 0x55, 1, R0_REGNO}, /* r3 r1 r2 r0 */
2915 };
2916
2917 /* Returns TRUE if OP is a subreg of a hard reg which we don't
2918    support.  */
2919 bool
2920 m32c_illegal_subreg_p (rtx op)
2921 {
2922   int offset;
2923   unsigned int i;
2924   int src_mode, dest_mode;
2925
2926   if (GET_CODE (op) != SUBREG)
2927     return false;
2928
2929   dest_mode = GET_MODE (op);
2930   offset = SUBREG_BYTE (op);
2931   op = SUBREG_REG (op);
2932   src_mode = GET_MODE (op);
2933
2934   if (GET_MODE_SIZE (dest_mode) == GET_MODE_SIZE (src_mode))
2935     return false;
2936   if (GET_CODE (op) != REG)
2937     return false;
2938   if (REGNO (op) >= MEM0_REGNO)
2939     return false;
2940
2941   offset = (1 << offset);
2942
2943   for (i = 0; i < ARRAY_SIZE (legal_subregs); i ++)
2944     if (legal_subregs[i].outer_mode_size == GET_MODE_SIZE (dest_mode)
2945         && legal_subregs[i].regno == REGNO (op)
2946         && legal_subregs[i].inner_mode_size == GET_MODE_SIZE (src_mode)
2947         && legal_subregs[i].byte_mask & offset)
2948       {
2949         switch (legal_subregs[i].legal_when)
2950           {
2951           case 1:
2952             return false;
2953           case 16:
2954             if (TARGET_A16)
2955               return false;
2956             break;
2957           case 24:
2958             if (TARGET_A24)
2959               return false;
2960             break;
2961           }
2962       }
2963   return true;
2964 }
2965
2966 /* Returns TRUE if we support a move between the first two operands.
2967    At the moment, we just want to discourage mem to mem moves until
2968    after reload, because reload has a hard time with our limited
2969    number of address registers, and we can get into a situation where
2970    we need three of them when we only have two.  */
2971 bool
2972 m32c_mov_ok (rtx * operands, enum machine_mode mode ATTRIBUTE_UNUSED)
2973 {
2974   rtx op0 = operands[0];
2975   rtx op1 = operands[1];
2976
2977   if (TARGET_A24)
2978     return true;
2979
2980 #define DEBUG_MOV_OK 0
2981 #if DEBUG_MOV_OK
2982   fprintf (stderr, "m32c_mov_ok %s\n", mode_name[mode]);
2983   debug_rtx (op0);
2984   debug_rtx (op1);
2985 #endif
2986
2987   if (GET_CODE (op0) == SUBREG)
2988     op0 = XEXP (op0, 0);
2989   if (GET_CODE (op1) == SUBREG)
2990     op1 = XEXP (op1, 0);
2991
2992   if (GET_CODE (op0) == MEM
2993       && GET_CODE (op1) == MEM
2994       && ! reload_completed)
2995     {
2996 #if DEBUG_MOV_OK
2997       fprintf (stderr, " - no, mem to mem\n");
2998 #endif
2999       return false;
3000     }
3001
3002 #if DEBUG_MOV_OK
3003   fprintf (stderr, " - ok\n");
3004 #endif
3005   return true;
3006 }
3007
3008 /* Returns TRUE if two consecutive HImode mov instructions, generated
3009    for moving an immediate double data to a double data type variable
3010    location, can be combined into single SImode mov instruction.  */
3011 bool
3012 m32c_immd_dbl_mov (rtx * operands, 
3013                    enum machine_mode mode ATTRIBUTE_UNUSED)
3014 {
3015   int flag = 0, okflag = 0, offset1 = 0, offset2 = 0, offsetsign = 0;
3016   const char *str1;
3017   const char *str2;
3018
3019   if (GET_CODE (XEXP (operands[0], 0)) == SYMBOL_REF
3020       && MEM_SCALAR_P (operands[0])
3021       && !MEM_IN_STRUCT_P (operands[0])
3022       && GET_CODE (XEXP (operands[2], 0)) == CONST
3023       && GET_CODE (XEXP (XEXP (operands[2], 0), 0)) == PLUS
3024       && GET_CODE (XEXP (XEXP (XEXP (operands[2], 0), 0), 0)) == SYMBOL_REF
3025       && GET_CODE (XEXP (XEXP (XEXP (operands[2], 0), 0), 1)) == CONST_INT
3026       && MEM_SCALAR_P (operands[2])
3027       && !MEM_IN_STRUCT_P (operands[2]))
3028     flag = 1; 
3029
3030   else if (GET_CODE (XEXP (operands[0], 0)) == CONST
3031            && GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == PLUS
3032            && GET_CODE (XEXP (XEXP (XEXP (operands[0], 0), 0), 0)) == SYMBOL_REF
3033            && MEM_SCALAR_P (operands[0])
3034            && !MEM_IN_STRUCT_P (operands[0])
3035            && !(INTVAL (XEXP (XEXP (XEXP (operands[0], 0), 0), 1)) %4)
3036            && GET_CODE (XEXP (operands[2], 0)) == CONST
3037            && GET_CODE (XEXP (XEXP (operands[2], 0), 0)) == PLUS
3038            && GET_CODE (XEXP (XEXP (XEXP (operands[2], 0), 0), 0)) == SYMBOL_REF
3039            && MEM_SCALAR_P (operands[2])
3040            && !MEM_IN_STRUCT_P (operands[2]))
3041     flag = 2; 
3042
3043   else if (GET_CODE (XEXP (operands[0], 0)) == PLUS
3044            &&  GET_CODE (XEXP (XEXP (operands[0], 0), 0)) == REG
3045            &&  REGNO (XEXP (XEXP (operands[0], 0), 0)) == FB_REGNO 
3046            &&  GET_CODE (XEXP (XEXP (operands[0], 0), 1)) == CONST_INT
3047            &&  MEM_SCALAR_P (operands[0])
3048            &&  !MEM_IN_STRUCT_P (operands[0])
3049            &&  !(INTVAL (XEXP (XEXP (operands[0], 0), 1)) %4)
3050            &&  REGNO (XEXP (XEXP (operands[2], 0), 0)) == FB_REGNO 
3051            &&  GET_CODE (XEXP (XEXP (operands[2], 0), 1)) == CONST_INT
3052            &&  MEM_SCALAR_P (operands[2])
3053            &&  !MEM_IN_STRUCT_P (operands[2]))
3054     flag = 3; 
3055
3056   else
3057     return false;
3058
3059   switch (flag)
3060     {
3061     case 1:
3062       str1 = XSTR (XEXP (operands[0], 0), 0);
3063       str2 = XSTR (XEXP (XEXP (XEXP (operands[2], 0), 0), 0), 0);
3064       if (strcmp (str1, str2) == 0)
3065         okflag = 1; 
3066       else
3067         okflag = 0; 
3068       break;
3069     case 2:
3070       str1 = XSTR (XEXP (XEXP (XEXP (operands[0], 0), 0), 0), 0);
3071       str2 = XSTR (XEXP (XEXP (XEXP (operands[2], 0), 0), 0), 0);
3072       if (strcmp(str1,str2) == 0)
3073         okflag = 1; 
3074       else
3075         okflag = 0; 
3076       break; 
3077     case 3:
3078       offset1 = INTVAL (XEXP (XEXP (operands[0], 0), 1));
3079       offset2 = INTVAL (XEXP (XEXP (operands[2], 0), 1));
3080       offsetsign = offset1 >> ((sizeof (offset1) * 8) -1);
3081       if (((offset2-offset1) == 2) && offsetsign != 0)
3082         okflag = 1;
3083       else 
3084         okflag = 0; 
3085       break; 
3086     default:
3087       okflag = 0; 
3088     } 
3089       
3090   if (okflag == 1)
3091     {
3092       HOST_WIDE_INT val;
3093       operands[4] = gen_rtx_MEM (SImode, XEXP (operands[0], 0));
3094
3095       val = (INTVAL (operands[3]) << 16) + (INTVAL (operands[1]) & 0xFFFF);
3096       operands[5] = gen_rtx_CONST_INT (VOIDmode, val);
3097      
3098       return true;
3099     }
3100
3101   return false;
3102 }  
3103
3104 /* Expanders */
3105
3106 /* Subregs are non-orthogonal for us, because our registers are all
3107    different sizes.  */
3108 static rtx
3109 m32c_subreg (enum machine_mode outer,
3110              rtx x, enum machine_mode inner, int byte)
3111 {
3112   int r, nr = -1;
3113
3114   /* Converting MEMs to different types that are the same size, we
3115      just rewrite them.  */
3116   if (GET_CODE (x) == SUBREG
3117       && SUBREG_BYTE (x) == 0
3118       && GET_CODE (SUBREG_REG (x)) == MEM
3119       && (GET_MODE_SIZE (GET_MODE (x))
3120           == GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))))
3121     {
3122       rtx oldx = x;
3123       x = gen_rtx_MEM (GET_MODE (x), XEXP (SUBREG_REG (x), 0));
3124       MEM_COPY_ATTRIBUTES (x, SUBREG_REG (oldx));
3125     }
3126
3127   /* Push/pop get done as smaller push/pops.  */
3128   if (GET_CODE (x) == MEM
3129       && (GET_CODE (XEXP (x, 0)) == PRE_DEC
3130           || GET_CODE (XEXP (x, 0)) == POST_INC))
3131     return gen_rtx_MEM (outer, XEXP (x, 0));
3132   if (GET_CODE (x) == SUBREG
3133       && GET_CODE (XEXP (x, 0)) == MEM
3134       && (GET_CODE (XEXP (XEXP (x, 0), 0)) == PRE_DEC
3135           || GET_CODE (XEXP (XEXP (x, 0), 0)) == POST_INC))
3136     return gen_rtx_MEM (outer, XEXP (XEXP (x, 0), 0));
3137
3138   if (GET_CODE (x) != REG)
3139     return simplify_gen_subreg (outer, x, inner, byte);
3140
3141   r = REGNO (x);
3142   if (r >= FIRST_PSEUDO_REGISTER || r == AP_REGNO)
3143     return simplify_gen_subreg (outer, x, inner, byte);
3144
3145   if (IS_MEM_REGNO (r))
3146     return simplify_gen_subreg (outer, x, inner, byte);
3147
3148   /* This is where the complexities of our register layout are
3149      described.  */
3150   if (byte == 0)
3151     nr = r;
3152   else if (outer == HImode)
3153     {
3154       if (r == R0_REGNO && byte == 2)
3155         nr = R2_REGNO;
3156       else if (r == R0_REGNO && byte == 4)
3157         nr = R1_REGNO;
3158       else if (r == R0_REGNO && byte == 6)
3159         nr = R3_REGNO;
3160       else if (r == R1_REGNO && byte == 2)
3161         nr = R3_REGNO;
3162       else if (r == A0_REGNO && byte == 2)
3163         nr = A1_REGNO;
3164     }
3165   else if (outer == SImode)
3166     {
3167       if (r == R0_REGNO && byte == 0)
3168         nr = R0_REGNO;
3169       else if (r == R0_REGNO && byte == 4)
3170         nr = R1_REGNO;
3171     }
3172   if (nr == -1)
3173     {
3174       fprintf (stderr, "m32c_subreg %s %s %d\n",
3175                mode_name[outer], mode_name[inner], byte);
3176       debug_rtx (x);
3177       gcc_unreachable ();
3178     }
3179   return gen_rtx_REG (outer, nr);
3180 }
3181
3182 /* Used to emit move instructions.  We split some moves,
3183    and avoid mem-mem moves.  */
3184 int
3185 m32c_prepare_move (rtx * operands, enum machine_mode mode)
3186 {
3187   if (TARGET_A16 && mode == PSImode)
3188     return m32c_split_move (operands, mode, 1);
3189   if ((GET_CODE (operands[0]) == MEM)
3190       && (GET_CODE (XEXP (operands[0], 0)) == PRE_MODIFY))
3191     {
3192       rtx pmv = XEXP (operands[0], 0);
3193       rtx dest_reg = XEXP (pmv, 0);
3194       rtx dest_mod = XEXP (pmv, 1);
3195
3196       emit_insn (gen_rtx_SET (Pmode, dest_reg, dest_mod));
3197       operands[0] = gen_rtx_MEM (mode, dest_reg);
3198     }
3199   if (can_create_pseudo_p () && MEM_P (operands[0]) && MEM_P (operands[1]))
3200     operands[1] = copy_to_mode_reg (mode, operands[1]);
3201   return 0;
3202 }
3203
3204 #define DEBUG_SPLIT 0
3205
3206 /* Returns TRUE if the given PSImode move should be split.  We split
3207    for all r8c/m16c moves, since it doesn't support them, and for
3208    POP.L as we can only *push* SImode.  */
3209 int
3210 m32c_split_psi_p (rtx * operands)
3211 {
3212 #if DEBUG_SPLIT
3213   fprintf (stderr, "\nm32c_split_psi_p\n");
3214   debug_rtx (operands[0]);
3215   debug_rtx (operands[1]);
3216 #endif
3217   if (TARGET_A16)
3218     {
3219 #if DEBUG_SPLIT
3220       fprintf (stderr, "yes, A16\n");
3221 #endif
3222       return 1;
3223     }
3224   if (GET_CODE (operands[1]) == MEM
3225       && GET_CODE (XEXP (operands[1], 0)) == POST_INC)
3226     {
3227 #if DEBUG_SPLIT
3228       fprintf (stderr, "yes, pop.l\n");
3229 #endif
3230       return 1;
3231     }
3232 #if DEBUG_SPLIT
3233   fprintf (stderr, "no, default\n");
3234 #endif
3235   return 0;
3236 }
3237
3238 /* Split the given move.  SPLIT_ALL is 0 if splitting is optional
3239    (define_expand), 1 if it is not optional (define_insn_and_split),
3240    and 3 for define_split (alternate api). */
3241 int
3242 m32c_split_move (rtx * operands, enum machine_mode mode, int split_all)
3243 {
3244   rtx s[4], d[4];
3245   int parts, si, di, rev = 0;
3246   int rv = 0, opi = 2;
3247   enum machine_mode submode = HImode;
3248   rtx *ops, local_ops[10];
3249
3250   /* define_split modifies the existing operands, but the other two
3251      emit new insns.  OPS is where we store the operand pairs, which
3252      we emit later.  */
3253   if (split_all == 3)
3254     ops = operands;
3255   else
3256     ops = local_ops;
3257
3258   /* Else HImode.  */
3259   if (mode == DImode)
3260     submode = SImode;
3261
3262   /* Before splitting mem-mem moves, force one operand into a
3263      register.  */
3264   if (can_create_pseudo_p () && MEM_P (operands[0]) && MEM_P (operands[1]))
3265     {
3266 #if DEBUG0
3267       fprintf (stderr, "force_reg...\n");
3268       debug_rtx (operands[1]);
3269 #endif
3270       operands[1] = force_reg (mode, operands[1]);
3271 #if DEBUG0
3272       debug_rtx (operands[1]);
3273 #endif
3274     }
3275
3276   parts = 2;
3277
3278 #if DEBUG_SPLIT
3279   fprintf (stderr, "\nsplit_move %d all=%d\n", !can_create_pseudo_p (),
3280            split_all);
3281   debug_rtx (operands[0]);
3282   debug_rtx (operands[1]);
3283 #endif
3284
3285   /* Note that split_all is not used to select the api after this
3286      point, so it's safe to set it to 3 even with define_insn.  */
3287   /* None of the chips can move SI operands to sp-relative addresses,
3288      so we always split those.  */
3289   if (m32c_extra_constraint_p (operands[0], 'S', "Ss"))
3290     split_all = 3;
3291
3292   /* We don't need to split these.  */
3293   if (TARGET_A24
3294       && split_all != 3
3295       && (mode == SImode || mode == PSImode)
3296       && !(GET_CODE (operands[1]) == MEM
3297            && GET_CODE (XEXP (operands[1], 0)) == POST_INC))
3298     return 0;
3299
3300   /* First, enumerate the subregs we'll be dealing with.  */
3301   for (si = 0; si < parts; si++)
3302     {
3303       d[si] =
3304         m32c_subreg (submode, operands[0], mode,
3305                      si * GET_MODE_SIZE (submode));
3306       s[si] =
3307         m32c_subreg (submode, operands[1], mode,
3308                      si * GET_MODE_SIZE (submode));
3309     }
3310
3311   /* Split pushes by emitting a sequence of smaller pushes.  */
3312   if (GET_CODE (d[0]) == MEM && GET_CODE (XEXP (d[0], 0)) == PRE_DEC)
3313     {
3314       for (si = parts - 1; si >= 0; si--)
3315         {
3316           ops[opi++] = gen_rtx_MEM (submode,
3317                                     gen_rtx_PRE_DEC (Pmode,
3318                                                      gen_rtx_REG (Pmode,
3319                                                                   SP_REGNO)));
3320           ops[opi++] = s[si];
3321         }
3322
3323       rv = 1;
3324     }
3325   /* Likewise for pops.  */
3326   else if (GET_CODE (s[0]) == MEM && GET_CODE (XEXP (s[0], 0)) == POST_INC)
3327     {
3328       for (di = 0; di < parts; di++)
3329         {
3330           ops[opi++] = d[di];
3331           ops[opi++] = gen_rtx_MEM (submode,
3332                                     gen_rtx_POST_INC (Pmode,
3333                                                       gen_rtx_REG (Pmode,
3334                                                                    SP_REGNO)));
3335         }
3336       rv = 1;
3337     }
3338   else if (split_all)
3339     {
3340       /* if d[di] == s[si] for any di < si, we'll early clobber. */
3341       for (di = 0; di < parts - 1; di++)
3342         for (si = di + 1; si < parts; si++)
3343           if (reg_mentioned_p (d[di], s[si]))
3344             rev = 1;
3345
3346       if (rev)
3347         for (si = 0; si < parts; si++)
3348           {
3349             ops[opi++] = d[si];
3350             ops[opi++] = s[si];
3351           }
3352       else
3353         for (si = parts - 1; si >= 0; si--)
3354           {
3355             ops[opi++] = d[si];
3356             ops[opi++] = s[si];
3357           }
3358       rv = 1;
3359     }
3360   /* Now emit any moves we may have accumulated.  */
3361   if (rv && split_all != 3)
3362     {
3363       int i;
3364       for (i = 2; i < opi; i += 2)
3365         emit_move_insn (ops[i], ops[i + 1]);
3366     }
3367   return rv;
3368 }
3369
3370 /* The m32c has a number of opcodes that act like memcpy, strcmp, and
3371    the like.  For the R8C they expect one of the addresses to be in
3372    R1L:An so we need to arrange for that.  Otherwise, it's just a
3373    matter of picking out the operands we want and emitting the right
3374    pattern for them.  All these expanders, which correspond to
3375    patterns in blkmov.md, must return nonzero if they expand the insn,
3376    or zero if they should FAIL.  */
3377
3378 /* This is a memset() opcode.  All operands are implied, so we need to
3379    arrange for them to be in the right registers.  The opcode wants
3380    addresses, not [mem] syntax.  $0 is the destination (MEM:BLK), $1
3381    the count (HI), and $2 the value (QI).  */
3382 int
3383 m32c_expand_setmemhi(rtx *operands)
3384 {
3385   rtx desta, count, val;
3386   rtx desto, counto;
3387
3388   desta = XEXP (operands[0], 0);
3389   count = operands[1];
3390   val = operands[2];
3391
3392   desto = gen_reg_rtx (Pmode);
3393   counto = gen_reg_rtx (HImode);
3394
3395   if (GET_CODE (desta) != REG
3396       || REGNO (desta) < FIRST_PSEUDO_REGISTER)
3397     desta = copy_to_mode_reg (Pmode, desta);
3398
3399   /* This looks like an arbitrary restriction, but this is by far the
3400      most common case.  For counts 8..14 this actually results in
3401      smaller code with no speed penalty because the half-sized
3402      constant can be loaded with a shorter opcode.  */
3403   if (GET_CODE (count) == CONST_INT
3404       && GET_CODE (val) == CONST_INT
3405       && ! (INTVAL (count) & 1)
3406       && (INTVAL (count) > 1)
3407       && (INTVAL (val) <= 7 && INTVAL (val) >= -8))
3408     {
3409       unsigned v = INTVAL (val) & 0xff;
3410       v = v | (v << 8);
3411       count = copy_to_mode_reg (HImode, GEN_INT (INTVAL (count) / 2));
3412       val = copy_to_mode_reg (HImode, GEN_INT (v));
3413       if (TARGET_A16)
3414         emit_insn (gen_setmemhi_whi_op (desto, counto, val, desta, count));
3415       else
3416         emit_insn (gen_setmemhi_wpsi_op (desto, counto, val, desta, count));
3417       return 1;
3418     }
3419
3420   /* This is the generalized memset() case.  */
3421   if (GET_CODE (val) != REG
3422       || REGNO (val) < FIRST_PSEUDO_REGISTER)
3423     val = copy_to_mode_reg (QImode, val);
3424
3425   if (GET_CODE (count) != REG
3426       || REGNO (count) < FIRST_PSEUDO_REGISTER)
3427     count = copy_to_mode_reg (HImode, count);
3428
3429   if (TARGET_A16)
3430     emit_insn (gen_setmemhi_bhi_op (desto, counto, val, desta, count));
3431   else
3432     emit_insn (gen_setmemhi_bpsi_op (desto, counto, val, desta, count));
3433
3434   return 1;
3435 }
3436
3437 /* This is a memcpy() opcode.  All operands are implied, so we need to
3438    arrange for them to be in the right registers.  The opcode wants
3439    addresses, not [mem] syntax.  $0 is the destination (MEM:BLK), $1
3440    is the source (MEM:BLK), and $2 the count (HI).  */
3441 int
3442 m32c_expand_movmemhi(rtx *operands)
3443 {
3444   rtx desta, srca, count;
3445   rtx desto, srco, counto;
3446
3447   desta = XEXP (operands[0], 0);
3448   srca = XEXP (operands[1], 0);
3449   count = operands[2];
3450
3451   desto = gen_reg_rtx (Pmode);
3452   srco = gen_reg_rtx (Pmode);
3453   counto = gen_reg_rtx (HImode);
3454
3455   if (GET_CODE (desta) != REG
3456       || REGNO (desta) < FIRST_PSEUDO_REGISTER)
3457     desta = copy_to_mode_reg (Pmode, desta);
3458
3459   if (GET_CODE (srca) != REG
3460       || REGNO (srca) < FIRST_PSEUDO_REGISTER)
3461     srca = copy_to_mode_reg (Pmode, srca);
3462
3463   /* Similar to setmem, but we don't need to check the value.  */
3464   if (GET_CODE (count) == CONST_INT
3465       && ! (INTVAL (count) & 1)
3466       && (INTVAL (count) > 1))
3467     {
3468       count = copy_to_mode_reg (HImode, GEN_INT (INTVAL (count) / 2));
3469       if (TARGET_A16)
3470         emit_insn (gen_movmemhi_whi_op (desto, srco, counto, desta, srca, count));
3471       else
3472         emit_insn (gen_movmemhi_wpsi_op (desto, srco, counto, desta, srca, count));
3473       return 1;
3474     }
3475
3476   /* This is the generalized memset() case.  */
3477   if (GET_CODE (count) != REG
3478       || REGNO (count) < FIRST_PSEUDO_REGISTER)
3479     count = copy_to_mode_reg (HImode, count);
3480
3481   if (TARGET_A16)
3482     emit_insn (gen_movmemhi_bhi_op (desto, srco, counto, desta, srca, count));
3483   else
3484     emit_insn (gen_movmemhi_bpsi_op (desto, srco, counto, desta, srca, count));
3485
3486   return 1;
3487 }
3488
3489 /* This is a stpcpy() opcode.  $0 is the destination (MEM:BLK) after
3490    the copy, which should point to the NUL at the end of the string,
3491    $1 is the destination (MEM:BLK), and $2 is the source (MEM:BLK).
3492    Since our opcode leaves the destination pointing *after* the NUL,
3493    we must emit an adjustment.  */
3494 int
3495 m32c_expand_movstr(rtx *operands)
3496 {
3497   rtx desta, srca;
3498   rtx desto, srco;
3499
3500   desta = XEXP (operands[1], 0);
3501   srca = XEXP (operands[2], 0);
3502
3503   desto = gen_reg_rtx (Pmode);
3504   srco = gen_reg_rtx (Pmode);
3505
3506   if (GET_CODE (desta) != REG
3507       || REGNO (desta) < FIRST_PSEUDO_REGISTER)
3508     desta = copy_to_mode_reg (Pmode, desta);
3509
3510   if (GET_CODE (srca) != REG
3511       || REGNO (srca) < FIRST_PSEUDO_REGISTER)
3512     srca = copy_to_mode_reg (Pmode, srca);
3513
3514   emit_insn (gen_movstr_op (desto, srco, desta, srca));
3515   /* desto ends up being a1, which allows this type of add through MOVA.  */
3516   emit_insn (gen_addpsi3 (operands[0], desto, GEN_INT (-1)));
3517
3518   return 1;