gcc/config/m32c/m32c.c

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