gcc/config/cris/cris.c

   1 /* Definitions for GCC.  Part of the machine description for CRIS.
   2    Copyright (C) 1998, 1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   3    Contributed by Axis Communications.  Written by Hans-Peter Nilsson.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify
   8 it under the terms of the GNU General Public License as published by
   9 the Free Software Foundation; either version 2, or (at your option)
  10 any later version.
  11
  12 GCC is distributed in the hope that it will be useful,
  13 but WITHOUT ANY WARRANTY; without even the implied warranty of
  14 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  15 GNU General Public License for more details.
  16
  17 You should have received a copy of the GNU General Public License
  18 along with GCC; see the file COPYING.  If not, write to
  19 the Free Software Foundation, 59 Temple Place - Suite 330,
  20 Boston, MA 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "rtl.h"
  25 #include "regs.h"
  26 #include "hard-reg-set.h"
  27 #include "real.h"
  28 #include "insn-config.h"
  29 #include "conditions.h"
  30 #include "insn-attr.h"
  31 #include "flags.h"
  32 #include "tree.h"
  33 #include "expr.h"
  34 #include "except.h"
  35 #include "function.h"
  36 #include "toplev.h"
  37 #include "recog.h"
  38 #include "tm_p.h"
  39 #include "debug.h"
  40 #include "output.h"
  41 #include "target.h"
  42 #include "target-def.h"
  43
  44 /* Usable when we have an amount to add or subtract, and want the
  45    optimal size of the insn.  */
  46 #define ADDITIVE_SIZE_MODIFIER(size) \
  47  ((size) <= 63 ? "q" : (size) <= 255 ? "u.b" : (size) <= 65535 ? "u.w" : ".d")
  48
  49 #define ASSERT_PLT_UNSPEC(x)                                    \
  50   do                                                            \
  51     {                                                           \
  52       if (XEXP (x, 1) != NULL_RTX                               \
  53           || (GET_CODE (XVECEXP (x, 0, 0)) != SYMBOL_REF        \
  54               && GET_CODE (XVECEXP (x, 0, 0)) != LABEL_REF))    \
  55         abort ();                                               \
  56     } while (0)
  57
  58 #define LOSE_AND_RETURN(msgid, x)                       \
  59   do                                            \
  60     {                                           \
  61       cris_operand_lossage (msgid, x);          \
  62       return;                                   \
  63     } while (0)
  64
  65 /* Per-function machine data.  */
  66 struct machine_function
  67  {
  68    int needs_return_address_on_stack;
  69  };
  70
  71 /* This little fix suppresses the 'u' or 's' when '%e' in assembly
  72    pattern.  */
  73 static char cris_output_insn_is_bound = 0;
  74
  75 /* This one suppresses printing out the "rPIC+" in
  76    "rPIC+sym:GOTOFF+offset" when doing PIC.  For a PLT symbol, it
  77    suppresses outputting it as [rPIC+sym:GOTPLT] and outputs similarly
  78    just the "sym:GOTOFF" part.  */
  79 static int cris_pic_sympart_only = 0;
  80
  81 /* Fix for reg_overlap_mentioned_p.  */
  82 static int cris_reg_overlap_mentioned_p PARAMS ((rtx, rtx));
  83
  84 static void cris_print_base PARAMS ((rtx, FILE *));
  85
  86 static void cris_print_index PARAMS ((rtx, FILE *));
  87
  88 static void cris_init_machine_status PARAMS ((struct function *));
  89
  90 static int cris_initial_frame_pointer_offset PARAMS ((void));
  91
  92 static int saved_regs_mentioned PARAMS ((rtx));
  93
  94 static void cris_target_asm_function_prologue
  95   PARAMS ((FILE *, HOST_WIDE_INT));
  96
  97 static void cris_target_asm_function_epilogue
  98   PARAMS ((FILE *, HOST_WIDE_INT));
  99
 100 static void cris_operand_lossage PARAMS ((const char *, rtx));
 101
 102 /* The function cris_target_asm_function_epilogue puts the last insn to
 103    output here.  It always fits; there won't be a symbol operand.  Used in
 104    delay_slots_for_epilogue and function_epilogue.  */
 105 static char save_last[80];
 106
 107 /* This is the argument from the "-max-stack-stackframe=" option.  */
 108 const char *cris_max_stackframe_str;
 109
 110 /* This is the argument from the "-march=" option.  */
 111 const char *cris_cpu_str;
 112
 113 /* This is the argument from the "-mtune=" option.  */
 114 const char *cris_tune_str;
 115
 116 /* This is the argument from the "-melinux-stacksize=" option.  */
 117 const char *cris_elinux_stacksize_str;
 118
 119 /* This is the parsed result of the "-max-stack-stackframe=" option.  If
 120    it (still) is zero, then there was no such option given.  */
 121 int cris_max_stackframe = 0;
 122
 123 /* This is the parsed result of the "-march=" option, if given.  */
 124 int cris_cpu_version = CRIS_DEFAULT_CPU_VERSION;
 125
 126 #undef TARGET_ASM_ALIGNED_HI_OP
 127 #define TARGET_ASM_ALIGNED_HI_OP "\t.word\t"
 128 #undef TARGET_ASM_ALIGNED_SI_OP
 129 #define TARGET_ASM_ALIGNED_SI_OP "\t.dword\t"
 130 #undef TARGET_ASM_ALIGNED_DI_OP
 131 #define TARGET_ASM_ALIGNED_DI_OP "\t.quad\t"
 132
 133 /* We need to define these, since the 2byte, 4byte, 8byte op:s are only
 134    available in ELF.  These "normal" pseudos do not have any alignment
 135    constraints or side-effects.  */
 136 #undef TARGET_ASM_UNALIGNED_HI_OP
 137 #define TARGET_ASM_UNALIGNED_HI_OP TARGET_ASM_ALIGNED_HI_OP
 138
 139 #undef TARGET_ASM_UNALIGNED_SI_OP
 140 #define TARGET_ASM_UNALIGNED_SI_OP TARGET_ASM_ALIGNED_SI_OP
 141
 142 #undef TARGET_ASM_UNALIGNED_DI_OP
 143 #define TARGET_ASM_UNALIGNED_DI_OP TARGET_ASM_ALIGNED_DI_OP
 144
 145 #undef TARGET_ASM_FUNCTION_PROLOGUE
 146 #define TARGET_ASM_FUNCTION_PROLOGUE cris_target_asm_function_prologue
 147
 148 #undef TARGET_ASM_FUNCTION_EPILOGUE
 149 #define TARGET_ASM_FUNCTION_EPILOGUE cris_target_asm_function_epilogue
 150
 151 struct gcc_target targetm = TARGET_INITIALIZER;
 152
 153 /* Predicate functions.  */
 154
 155 /* This checks a part of an address, the one that is not a plain register
 156    for an addressing mode using BDAP.
 157    Allowed operands is either:
 158    a) a register
 159    b) a CONST operand (but not a symbol when generating PIC)
 160    c) a [r] or [r+] in SImode, or sign-extend from HI or QI.  */
 161
 162 int
 163 cris_bdap_operand (op, mode)
 164      rtx op;
 165      enum machine_mode mode;
 166 {
 167   register enum rtx_code code = GET_CODE (op);
 168
 169   if (mode != SImode && (mode != VOIDmode || GET_MODE (op) != VOIDmode))
 170     return 0;
 171
 172   /* Just return whether this is a simple register or constant.  */
 173   if (register_operand (op, mode)
 174       || (CONSTANT_P (op) && !(flag_pic && cris_symbol (op))))
 175     return 1;
 176
 177   /* Is it a [r] or possibly a [r+]?  */
 178   if (code == MEM)
 179     {
 180       rtx tem = XEXP (op, 0);
 181
 182       if (mode == SImode
 183           && (register_operand (tem, SImode)
 184               || (GET_CODE (tem) == POST_INC
 185                   && register_operand (XEXP (tem, 0), SImode))))
 186         return 1;
 187       else
 188         return 0;
 189     }
 190
 191   /* Perhaps a sign-extended mem: [r].(b|w) or [r+].(b|w)?  */
 192   if (code == SIGN_EXTEND)
 193     {
 194       rtx tem = XEXP (op, 0);
 195
 196       if (GET_CODE (tem) != MEM)
 197         return 0;
 198
 199       tem = XEXP (tem, 0);
 200       if (mode == SImode
 201           && (register_operand (tem, SImode)
 202               || (GET_CODE (tem) == POST_INC
 203                   && register_operand (XEXP (tem, 0), SImode))))
 204         return 1;
 205       else
 206         return 0;
 207     }
 208
 209   return 0;
 210 }
 211
 212 /* This is similar to cris_bdap_operand:
 213    It checks a part of an address, the one that is not a plain register
 214    for an addressing mode using BDAP *or* BIAP.
 215    Allowed operands is either:
 216    a) a register
 217    b) a CONST operand (but not a symbol when generating PIC)
 218    c) a mult of (1, 2 or 4) and a register
 219    d) a [r] or [r+] in SImode, or sign-extend from HI or QI.  */
 220
 221 int
 222 cris_bdap_biap_operand (op, mode)
 223      rtx op;
 224      enum machine_mode mode;
 225 {
 226   register enum rtx_code code = GET_CODE (op);
 227   rtx reg;
 228   rtx val;
 229
 230   /* Check for bdap operand.  */
 231   if (cris_bdap_operand (op, mode))
 232     return 1;
 233
 234   if (mode != SImode && (mode != VOIDmode || GET_MODE (op) != VOIDmode))
 235     return 0;
 236
 237   /* Check that we're looking at a BIAP operand.  */
 238   if (code != MULT)
 239     return 0;
 240
 241   /* Canonicalize register and multiplicand.  */
 242   if (GET_CODE (XEXP (op, 0)) == CONST_INT)
 243     {
 244       val = XEXP (op, 0);
 245       reg = XEXP (op, 1);
 246     }
 247   else
 248     {
 249       val = XEXP (op, 1);
 250       reg = XEXP (op, 0);
 251     }
 252
 253   /* Check that the operands are correct after canonicalization.  */
 254   if (! register_operand (reg, SImode) || GET_CODE (val) != CONST_INT)
 255     return 0;
 256
 257   /* Check that the multiplicand has a valid value.  */
 258   if ((code == MULT
 259        && (INTVAL (val) == 1 || INTVAL (val) == 2 || INTVAL (val) == 4)))
 260     return 1;
 261
 262   return 0;
 263 }
 264
 265 /* Check if MODE is same as mode for X, and X is PLUS, MINUS, IOR or
 266    AND or UMIN.  */
 267
 268 int
 269 cris_orthogonal_operator (x, mode)
 270      rtx x;
 271      enum machine_mode mode;
 272 {
 273   enum rtx_code code = GET_CODE (x);
 274
 275   if (mode == VOIDmode)
 276     mode = GET_MODE (x);
 277
 278   return (GET_MODE (x) == mode
 279           && (code == PLUS || code == MINUS
 280               || code == IOR || code == AND || code == UMIN));
 281 }
 282
 283 /* Check if MODE is same as mode for X, and X is PLUS, IOR or AND or
 284    UMIN.  */
 285
 286 int
 287 cris_commutative_orth_op (x, mode)
 288      rtx x;
 289      enum machine_mode mode;
 290 {
 291   enum rtx_code code = GET_CODE (x);
 292
 293   if (mode == VOIDmode)
 294     mode = GET_MODE (x);
 295
 296   return (GET_MODE (x) == mode &&
 297           (code == PLUS
 298            || code == IOR || code == AND || code == UMIN));
 299 }
 300
 301 /* Check if MODE is same as mode for X, and X is PLUS or MINUS or UMIN.  */
 302
 303 int
 304 cris_operand_extend_operator (x, mode)
 305      rtx x;
 306      enum machine_mode mode;
 307 {
 308   enum rtx_code code = GET_CODE (x);
 309
 310   if (mode == VOIDmode)
 311     mode = GET_MODE (x);
 312
 313   return (GET_MODE (x) == mode
 314           && (code == PLUS || code == MINUS || code == UMIN));
 315 }
 316
 317 /* Check to see if MODE is same as mode for X, and X is SIGN_EXTEND or
 318    ZERO_EXTEND.  */
 319
 320 int
 321 cris_extend_operator (x, mode)
 322      rtx x;
 323      enum machine_mode mode;
 324 {
 325   enum rtx_code code = GET_CODE (x);
 326
 327   if (mode == VOIDmode)
 328     mode = GET_MODE (x);
 329
 330   return
 331     (GET_MODE (x) == mode && (code == SIGN_EXTEND || code == ZERO_EXTEND));
 332 }
 333
 334 /* Check to see if MODE is same as mode for X, and X is PLUS or BOUND.  */
 335
 336 int
 337 cris_plus_or_bound_operator (x, mode)
 338      rtx x;
 339      enum machine_mode mode;
 340 {
 341   enum rtx_code code = GET_CODE (x);
 342
 343   if (mode == VOIDmode)
 344     mode = GET_MODE (x);
 345
 346   return
 347     (GET_MODE (x) == mode && (code == UMIN || code == PLUS));
 348 }
 349
 350 /* Since with -fPIC, not all symbols are valid PIC symbols or indeed
 351    general_operands, we have to have a predicate that matches it for the
 352    "movsi" expander.  */
 353
 354 int
 355 cris_general_operand_or_symbol (op, mode)
 356      rtx op;
 357      enum machine_mode mode;
 358 {
 359   return general_operand (op, mode)
 360     || (CONSTANT_P (op) && cris_symbol (op));
 361 }
 362
 363 /* Since a PIC symbol without a GOT entry is not a general_operand, we
 364    have to have a predicate that matches it.  We use this in the expanded
 365    "movsi" anonymous pattern for PIC symbols.  */
 366
 367 int
 368 cris_general_operand_or_gotless_symbol (op, mode)
 369      rtx op;
 370      enum machine_mode mode;
 371 {
 372   return general_operand (op, mode)
 373     || (CONSTANT_P (op) && cris_gotless_symbol (op));
 374 }
 375
 376 /* Since a PLT symbol is not a general_operand, we have to have a
 377    predicate that matches it when we need it.  We use this in the expanded
 378    "call" and "call_value" anonymous patterns.  */
 379
 380 int
 381 cris_general_operand_or_plt_symbol (op, mode)
 382      rtx op;
 383      enum machine_mode mode;
 384 {
 385   return general_operand (op, mode)
 386     || (GET_CODE (op) == CONST
 387         && GET_CODE (XEXP (op, 0)) == UNSPEC
 388         && !TARGET_AVOID_GOTPLT);
 389 }
 390
 391 /* This matches a (MEM (general_operand)) or
 392    (MEM (cris_general_operand_or_symbol)).  The second one isn't a valid
 393    memory_operand, so we need this predicate to recognize call
 394    destinations before we change them to a PLT operand (by wrapping in
 395    UNSPEC 0).  */
 396
 397 int
 398 cris_mem_call_operand (op, mode)
 399      rtx op;
 400      enum machine_mode mode;
 401 {
 402   rtx xmem;
 403
 404   if (GET_CODE (op) != MEM)
 405     return 0;
 406
 407   if (memory_operand (op, mode))
 408     return 1;
 409
 410   xmem = XEXP (op, 0);
 411
 412   return cris_general_operand_or_symbol (xmem, GET_MODE (op));
 413 }
 414
 415 /* The CONDITIONAL_REGISTER_USAGE worker.   */
 416
 417 void
 418 cris_conditional_register_usage ()
 419 {
 420   /* FIXME: This isn't nice.  We should be able to use that register for
 421      something else if the PIC table isn't needed.  */
 422   if (flag_pic)
 423     fixed_regs[PIC_OFFSET_TABLE_REGNUM]
 424       = call_used_regs[PIC_OFFSET_TABLE_REGNUM] = 1;
 425 }
 426
 427 /* Return current_function_uses_pic_offset_table.  For use in cris.md,
 428    since some generated files do not include function.h.  */
 429
 430 int
 431 cris_cfun_uses_pic_table ()
 432 {
 433   return current_function_uses_pic_offset_table;
 434 }
 435
 436 /* Given an rtx, return the text string corresponding to the CODE of X.
 437    Intended for use in the assembly language output section of a
 438    define_insn.  */
 439
 440 const char *
 441 cris_op_str (x)
 442      rtx x;
 443 {
 444   cris_output_insn_is_bound = 0;
 445   switch (GET_CODE (x))
 446     {
 447     case PLUS:
 448       return "add";
 449       break;
 450
 451     case MINUS:
 452       return "sub";
 453       break;
 454
 455     case MULT:
 456       return "mul";
 457       break;
 458
 459     case DIV:
 460       return "div";
 461       break;
 462
 463     case AND:
 464       return "and";
 465       break;
 466
 467     case IOR:
 468       return "or";
 469       break;
 470
 471     case XOR:
 472       return "xor";
 473       break;
 474
 475     case NOT:
 476       return "not";
 477       break;
 478
 479     case ASHIFT:
 480       return "lsl";
 481       break;
 482
 483     case LSHIFTRT:
 484       return "lsr";
 485       break;
 486
 487     case ASHIFTRT:
 488       return "asr";
 489       break;
 490
 491     case UMIN:
 492       /* Used to control the sign/zero-extend character for the 'e' modifier.
 493          BOUND has none.  */
 494       cris_output_insn_is_bound = 1;
 495       return "bound";
 496       break;
 497
 498     default:
 499       return "Unknown operator";
 500       break;
 501   }
 502 }
 503
 504 /* Emit an error message when we're in an asm, and a fatal error for
 505    "normal" insns.  Formatted output isn't easily implemented, since we
 506    use output_operand_lossage to output the actual message and handle the
 507    categorization of the error.  */
 508
 509 static void
 510 cris_operand_lossage (msgid, op)
 511      const char *msgid;
 512      rtx op;
 513 {
 514   debug_rtx (op);
 515   output_operand_lossage ("%s", msgid);
 516 }
 517
 518 /* Print an index part of an address to file.  */
 519
 520 static void
 521 cris_print_index (index, file)
 522      rtx index;
 523      FILE * file;
 524 {
 525   rtx inner = XEXP (index, 0);
 526
 527   /* Make the index "additive" unless we'll output a negative number, in
 528      which case the sign character is free (as in free beer).  */
 529   if (GET_CODE (index) != CONST_INT || INTVAL (index) >= 0)
 530     putc ('+', file);
 531
 532   if (REG_P (index))
 533     fprintf (file, "$%s.b", reg_names[REGNO (index)]);
 534   else if (CONSTANT_P (index))
 535     cris_output_addr_const (file, index);
 536   else if (GET_CODE (index) == MULT)
 537     {
 538       fprintf (file, "$%s.",
 539                reg_names[REGNO (XEXP (index, 0))]);
 540
 541       putc (INTVAL (XEXP (index, 1)) == 2 ? 'w' : 'd', file);
 542     }
 543   else if (GET_CODE (index) == SIGN_EXTEND &&
 544            GET_CODE (inner) == MEM)
 545     {
 546       rtx inner_inner = XEXP (inner, 0);
 547
 548       if (GET_CODE (inner_inner) == POST_INC)
 549         {
 550           fprintf (file, "[$%s+].",
 551                    reg_names[REGNO (XEXP (inner_inner, 0))]);
 552           putc (GET_MODE (inner) == HImode ? 'w' : 'b', file);
 553         }
 554       else
 555         {
 556           fprintf (file, "[$%s].", reg_names[REGNO (inner_inner)]);
 557
 558           putc (GET_MODE (inner) == HImode ? 'w' : 'b', file);
 559         }
 560     }
 561   else if (GET_CODE (index) == MEM)
 562     {
 563       if (GET_CODE (inner) == POST_INC)
 564         fprintf (file, "[$%s+].d", reg_names[REGNO (XEXP (inner, 0))]);
 565       else
 566         fprintf (file, "[$%s].d", reg_names[REGNO (inner)]);
 567     }
 568   else
 569     cris_operand_lossage ("unexpected index-type in cris_print_index",
 570                           index);
 571 }
 572
 573 /* Print a base rtx of an address to file.  */
 574
 575 static void
 576 cris_print_base (base, file)
 577      rtx base;
 578      FILE *file;
 579 {
 580   if (REG_P (base))
 581     fprintf (file, "$%s", reg_names[REGNO (base)]);
 582   else if (GET_CODE (base) == POST_INC)
 583     fprintf (file, "$%s+", reg_names[REGNO (XEXP (base, 0))]);
 584   else
 585     cris_operand_lossage ("unexpected base-type in cris_print_base",
 586                           base);
 587 }
 588
 589 /* Usable as a guard in expressions.  */
 590
 591 int
 592 cris_fatal (arg)
 593      char *arg;
 594 {
 595   internal_error (arg);
 596
 597   /* We'll never get here; this is just to appease compilers.  */
 598   return 0;
 599 }
 600
 601 /* Textual function prologue.  */
 602
 603 static void
 604 cris_target_asm_function_prologue (file, size)
 605      FILE *file;
 606      HOST_WIDE_INT size;
 607 {
 608   int regno;
 609
 610   /* Shorten the used name for readability.  */
 611   int cfoa_size = current_function_outgoing_args_size;
 612   int last_movem_reg = -1;
 613   int doing_dwarf = dwarf2out_do_frame ();
 614   int framesize;
 615   int faked_args_size = 0;
 616   int cfa_write_offset = 0;
 617   char *cfa_label = NULL;
 618   int return_address_on_stack
 619     = regs_ever_live[CRIS_SRP_REGNUM]
 620     || cfun->machine->needs_return_address_on_stack != 0;
 621
 622   /* Don't do anything if no prologues or epilogues are wanted.  */
 623   if (!TARGET_PROLOGUE_EPILOGUE)
 624     return;
 625
 626   if (size < 0)
 627     abort ();
 628
 629   /* Align the size to what's best for the CPU model.  */
 630   if (TARGET_STACK_ALIGN)
 631     size = TARGET_ALIGN_BY_32 ? (size + 3) & ~3 : (size + 1) & ~1;
 632
 633   if (current_function_pretend_args_size)
 634     {
 635       int pretend = current_function_pretend_args_size;
 636       for (regno = CRIS_FIRST_ARG_REG + CRIS_MAX_ARGS_IN_REGS - 1;
 637            pretend > 0;
 638            regno--, pretend -= 4)
 639         {
 640           fprintf (file, "\tpush $%s\n", reg_names[regno]);
 641           faked_args_size += 4;
 642         }
 643     }
 644
 645   framesize = faked_args_size;
 646
 647   if (doing_dwarf)
 648     {
 649       /* FIXME: Slightly redundant calculation, as we do the same in
 650          pieces below.  This offset must be the total adjustment of the
 651          stack-pointer.  We can then def_cfa call at the end of this
 652          function with the current implementation of execute_cfa_insn, but
 653          that wouldn't really be clean.  */
 654
 655       int cfa_offset
 656         = faked_args_size
 657         + (return_address_on_stack ? 4 : 0)
 658         + (frame_pointer_needed ? 4 : 0);
 659
 660       int cfa_reg;
 661
 662       if (frame_pointer_needed)
 663         cfa_reg = FRAME_POINTER_REGNUM;
 664       else
 665         {
 666           cfa_reg = STACK_POINTER_REGNUM;
 667           cfa_offset += cris_initial_frame_pointer_offset ();
 668         }
 669
 670       cfa_label = dwarf2out_cfi_label ();
 671       dwarf2out_def_cfa (cfa_label, cfa_reg, cfa_offset);
 672
 673       cfa_write_offset = - faked_args_size - 4;
 674     }
 675
 676   /* Save SRP if not a leaf function.  */
 677   if (return_address_on_stack)
 678     {
 679       fprintf (file, "\tPush $srp\n");
 680       framesize += 4;
 681
 682       if (doing_dwarf)
 683         {
 684           dwarf2out_return_save (cfa_label, cfa_write_offset);
 685           cfa_write_offset -= 4;
 686         }
 687     }
 688
 689   /* Set up frame pointer if needed.  */
 690   if (frame_pointer_needed)
 691     {
 692       fprintf (file, "\tpush $%s\n\tmove.d $sp,$%s\n",
 693                reg_names[FRAME_POINTER_REGNUM],
 694                reg_names[FRAME_POINTER_REGNUM]);
 695       framesize += 4;
 696
 697       if (doing_dwarf)
 698         {
 699           dwarf2out_reg_save (cfa_label, FRAME_POINTER_REGNUM,
 700                               cfa_write_offset);
 701           cfa_write_offset -= 4;
 702         }
 703     }
 704
 705   /* Local vars are located above saved regs.  */
 706   cfa_write_offset -= size;
 707
 708   /* Get a contiguous sequence of registers, starting with r0, that need
 709      to be saved.  */
 710   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 711     {
 712       if ((((regs_ever_live[regno]
 713              && !call_used_regs[regno])
 714             || (regno == PIC_OFFSET_TABLE_REGNUM
 715                 && (current_function_uses_pic_offset_table
 716                     /* It is saved anyway, if there would be a gap.  */
 717                     || (flag_pic
 718                         && regs_ever_live[regno + 1]
 719                         && !call_used_regs[regno + 1]))))
 720            && (regno != FRAME_POINTER_REGNUM || !frame_pointer_needed)
 721            && regno != CRIS_SRP_REGNUM)
 722           || (current_function_calls_eh_return
 723               && (regno == EH_RETURN_DATA_REGNO (0)
 724                   || regno == EH_RETURN_DATA_REGNO (1)
 725                   || regno == EH_RETURN_DATA_REGNO (2)
 726                   || regno == EH_RETURN_DATA_REGNO (3))))
 727         {
 728           /* Check if movem may be used for registers so far.  */
 729           if (regno == last_movem_reg + 1)
 730             /* Yes, update next expected register.  */
 731             last_movem_reg++;
 732           else
 733             {
 734               /* We cannot use movem for all registers.  We have to flush
 735                  any movem:ed registers we got so far.  */
 736               if (last_movem_reg != -1)
 737                 {
 738                   /* It is a win to use a side-effect assignment for
 739                      64 <= size <= 128.  But side-effect on movem was
 740                      not usable for CRIS v0..3.  Also only do it if
 741                      side-effects insns are allowed.  */
 742                   if ((last_movem_reg + 1) * 4 + size >= 64
 743                       && (last_movem_reg + 1) * 4 + size <= 128
 744                       && cris_cpu_version >= CRIS_CPU_SVINTO
 745                       && TARGET_SIDE_EFFECT_PREFIXES)
 746                     fprintf (file, "\tmovem $%s,[$sp=$sp-%d]\n",
 747                              reg_names[last_movem_reg],
 748                              (last_movem_reg + 1) * 4 + size);
 749                   else
 750                     {
 751                       /* Avoid printing multiple subsequent sub:s for sp.  */
 752                       fprintf (file, "\tsub%s %d,$sp\n",
 753                                ADDITIVE_SIZE_MODIFIER ((last_movem_reg + 1)
 754                                                        * 4 + size),
 755                                (last_movem_reg + 1) * 4 + size);
 756
 757                       fprintf (file, "\tmovem $%s,[$sp]\n",
 758                                reg_names[last_movem_reg]);
 759                     }
 760
 761                   framesize += (last_movem_reg + 1) * 4 + size;
 762
 763                   if (TARGET_PDEBUG)
 764                     fprintf (file, "; frame %d, #regs %d, bytes %d args %d\n",
 765                              size,
 766                              last_movem_reg + 1,
 767                              (last_movem_reg + 1) * 4,
 768                              current_function_args_size);
 769
 770                   last_movem_reg = -1;
 771                   size = 0;
 772                 }
 773               else if (size > 0)
 774                 {
 775                   /* Local vars on stack, but there are no movem:s.
 776                      Just allocate space.  */
 777                   fprintf (file, "\tSub%s %d,$sp\n",
 778                            ADDITIVE_SIZE_MODIFIER (size),
 779                            size);
 780                   framesize += size;
 781                   size = 0;
 782                 }
 783
 784               fprintf (file, "\tPush $%s\n", reg_names[regno]);
 785               framesize += 4;
 786             }
 787
 788           if (doing_dwarf)
 789             {
 790               /* Registers are stored lowest numbered at highest address,
 791                  which matches the loop order; we just need to update the
 792                  write-offset.  */
 793               dwarf2out_reg_save (cfa_label, regno, cfa_write_offset);
 794               cfa_write_offset -= 4;
 795             }
 796         }
 797     }
 798
 799   /* Check after, if we can movem all registers.  This is the normal
 800      case.  */
 801   if (last_movem_reg != -1)
 802     {
 803       /* Side-effect assignment on movem was not supported for CRIS v0..3,
 804          and don't do it if we're asked not to.
 805
 806          The movem is already accounted for, for unwind.  */
 807
 808       if ((last_movem_reg + 1) * 4 + size >= 64
 809           && (last_movem_reg + 1) * 4 + size <= 128
 810           && cris_cpu_version >= CRIS_CPU_SVINTO
 811           && TARGET_SIDE_EFFECT_PREFIXES)
 812         fprintf (file, "\tmovem $%s,[$sp=$sp-%d]\n",
 813                  reg_names[last_movem_reg],
 814                  (last_movem_reg+1) * 4 + size);
 815       else
 816         {
 817           /* Avoid printing multiple subsequent sub:s for sp.  FIXME:
 818              Clean up the conditional expression.  */
 819           fprintf (file, "\tsub%s %d,$sp\n",
 820                    ADDITIVE_SIZE_MODIFIER ((last_movem_reg + 1) * 4 + size),
 821                    (last_movem_reg + 1) * 4 + size);
 822           /* To be compatible with v0..v3 means we do not use an assignment
 823              addressing mode with movem.  We normally don't need that
 824              anyway.  It would only be slightly more efficient for 64..128
 825              bytes frame size.  */
 826           fprintf (file, "\tmovem $%s,[$sp]\n", reg_names[last_movem_reg]);
 827         }
 828
 829       framesize += (last_movem_reg + 1) * 4 + size;
 830
 831       if (TARGET_PDEBUG)
 832         fprintf (file, "; frame %d, #regs %d, bytes %d args %d\n",
 833                  size,
 834                  last_movem_reg + 1,
 835                  (last_movem_reg + 1) * 4,
 836                  current_function_args_size);
 837
 838       /* We have to put outgoing argument space after regs.  */
 839       if (cfoa_size)
 840         {
 841           /* This does not need to be accounted for, for unwind.  */
 842
 843           fprintf (file, "\tSub%s %d,$sp\n",
 844                    ADDITIVE_SIZE_MODIFIER (cfoa_size),
 845                    cfoa_size);
 846           framesize += cfoa_size;
 847         }
 848     }
 849   else if ((size + cfoa_size) > 0)
 850     {
 851       /* This does not need to be accounted for, for unwind.  */
 852
 853       /* Local vars on stack, and we could not use movem.  Add a sub here.  */
 854       fprintf (file, "\tSub%s %d,$sp\n",
 855                ADDITIVE_SIZE_MODIFIER (size + cfoa_size),
 856                cfoa_size + size);
 857       framesize += size + cfoa_size;
 858     }
 859
 860   /* Set up the PIC register.  */
 861   if (current_function_uses_pic_offset_table)
 862     asm_fprintf (file, "\tmove.d $pc,$%s\n\tsub.d .:GOTOFF,$%s\n",
 863                  reg_names[PIC_OFFSET_TABLE_REGNUM],
 864                  reg_names[PIC_OFFSET_TABLE_REGNUM]);
 865
 866   if (TARGET_PDEBUG)
 867     fprintf (file,
 868              "; parm #%d @ %d; frame %d, FP-SP is %d; leaf: %s%s; fp %s, outg: %d arg %d\n",
 869              CRIS_MAX_ARGS_IN_REGS + 1, FIRST_PARM_OFFSET (0),
 870              get_frame_size (),
 871              cris_initial_frame_pointer_offset (),
 872              leaf_function_p () ? "yes" : "no",
 873              return_address_on_stack ? "no" :"yes",
 874              frame_pointer_needed ? "yes" : "no",
 875              cfoa_size, current_function_args_size);
 876
 877   if (cris_max_stackframe && framesize > cris_max_stackframe)
 878     warning ("stackframe too big: %d bytes", framesize);
 879 }
 880
 881 /* Return nonzero if there are regs mentioned in the insn that are not all
 882    in the call_used regs.  This is part of the decision whether an insn
 883    can be put in the epilogue.  */
 884
 885 static int
 886 saved_regs_mentioned (x)
 887      rtx x;
 888 {
 889   int i;
 890   const char *fmt;
 891   RTX_CODE code;
 892
 893   /* Mainly stolen from refers_to_regno_p in rtlanal.c.  */
 894
 895   code = GET_CODE (x);
 896
 897   switch (code)
 898     {
 899     case REG:
 900       i = REGNO (x);
 901       return !call_used_regs[i];
 902
 903     case SUBREG:
 904       /* If this is a SUBREG of a hard reg, we can see exactly which
 905          registers are being modified.  Otherwise, handle normally.  */
 906       i = REGNO (SUBREG_REG (x));
 907       return !call_used_regs[i];
 908
 909     default:
 910       ;
 911     }
 912
 913   fmt = GET_RTX_FORMAT (code);
 914   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 915     {
 916       if (fmt[i] == 'e')
 917         {
 918           if (saved_regs_mentioned (XEXP (x, i)))
 919             return 1;
 920         }
 921       else if (fmt[i] == 'E')
 922         {
 923           int j;
 924           for (j = XVECLEN (x, i) - 1; j >=0; j--)
 925             if (saved_regs_mentioned (XEXP (x, i)))
 926               return 1;
 927         }
 928     }
 929
 930   return 0;
 931 }
 932
 933 /* Figure out if the insn may be put in the epilogue.  */
 934
 935 int
 936 cris_eligible_for_epilogue_delay (insn)
 937      rtx insn;
 938 {
 939   /* First of all, it must be as slottable as for a delayed branch insn.  */
 940   if (get_attr_slottable (insn) != SLOTTABLE_YES)
 941     return 0;
 942
 943   /* It must not refer to the stack pointer (may be valid for some cases
 944      that I can't think of).  */
 945   if (reg_mentioned_p (stack_pointer_rtx, PATTERN (insn)))
 946     return 0;
 947
 948   /* The frame pointer will be restored in the epilogue, before the
 949      "ret", so it can't be referred to.  */
 950   if (frame_pointer_needed
 951       && reg_mentioned_p (frame_pointer_rtx, PATTERN (insn)))
 952     return 0;
 953
 954   /* All saved regs are restored before the delayed insn.
 955      This means that we cannot have any instructions that mention the
 956      registers that are restored by the epilogue.  */
 957   if (saved_regs_mentioned (PATTERN (insn)))
 958     return 0;
 959
 960   /* It seems to be ok.  */
 961   return 1;
 962 }
 963
 964 /* Return the number of delay-slots in the epilogue: return 1 if it
 965    contains "ret", else 0.  */
 966
 967 int
 968 cris_delay_slots_for_epilogue ()
 969 {
 970   /* Check if we use a return insn, which we only do for leaf functions.
 971      Else there is no slot to fill.  */
 972   if (regs_ever_live[CRIS_SRP_REGNUM]
 973       || cfun->machine->needs_return_address_on_stack != 0)
 974     return 0;
 975
 976   /* By calling function_epilogue with the same parameters as from gcc
 977      we can get info about if the epilogue can fill the delay-slot by itself.
 978      If it is filled from the epilogue, then the corresponding string
 979      is in save_last.
 980       This depends on that the "size" argument to function_epilogue
 981      always is get_frame_size.
 982      FIXME:  Kludgy.  At least make it a separate function that is not
 983      misnamed or abuses the stream parameter.  */
 984   cris_target_asm_function_epilogue (NULL, get_frame_size ());
 985
 986   if (*save_last)
 987     return 1;
 988   return 0;
 989 }
 990
 991 /* Textual function epilogue.  When file is NULL, it serves doubly as
 992    a test for whether the epilogue can fill any "ret" delay-slots by
 993    itself by storing the delay insn in save_last.  */
 994
 995 static void
 996 cris_target_asm_function_epilogue (file, size)
 997      FILE *file;
 998      HOST_WIDE_INT size;
 999 {
1000   int regno;
1001   int last_movem_reg = -1;
1002   rtx insn = get_last_insn ();
1003   int argspace_offset = current_function_outgoing_args_size;
1004   int pretend =  current_function_pretend_args_size;
1005   int return_address_on_stack
1006     = regs_ever_live[CRIS_SRP_REGNUM]
1007     || cfun->machine->needs_return_address_on_stack != 0;
1008
1009   save_last[0] = 0;
1010
1011   if (file && !TARGET_PROLOGUE_EPILOGUE)
1012     return;
1013
1014   if (TARGET_PDEBUG && file)
1015     fprintf (file, ";;\n");
1016
1017   /* Align byte count of stack frame.  */
1018   if (TARGET_STACK_ALIGN)
1019     size = TARGET_ALIGN_BY_32 ? (size + 3) & ~3 : (size + 1) & ~1;
1020
1021   /* If the last insn was a BARRIER, we don't have to write any code,
1022      then all returns were covered by "return" insns.  */
1023   if (GET_CODE (insn) == NOTE)
1024     insn = prev_nonnote_insn (insn);
1025   if (insn
1026       && (GET_CODE (insn) == BARRIER
1027           /* We must make sure that the insn really is a "return" and
1028              not a conditional branch.  Try to match the return exactly,
1029              and if it doesn't match, assume it is a conditional branch
1030              (and output an epilogue).  */
1031           || (GET_CODE (insn) == JUMP_INSN
1032               && GET_CODE (PATTERN (insn)) == RETURN)))
1033     {
1034       if (TARGET_PDEBUG && file)
1035         fprintf (file, ";;;;;\n");
1036       return;
1037     }
1038
1039   /* Check how many saved regs we can movem.  They start at r0 and must
1040      be contiguous.  */
1041   for (regno = 0;
1042        regno < FIRST_PSEUDO_REGISTER;
1043        regno++)
1044     if ((((regs_ever_live[regno]
1045            && !call_used_regs[regno])
1046           || (regno == PIC_OFFSET_TABLE_REGNUM
1047               && (current_function_uses_pic_offset_table
1048                   /* It is saved anyway, if there would be a gap.  */
1049                   || (flag_pic
1050                       && regs_ever_live[regno + 1]
1051                       && !call_used_regs[regno + 1]))))
1052          && (regno != FRAME_POINTER_REGNUM || !frame_pointer_needed)
1053          && regno != CRIS_SRP_REGNUM)
1054         || (current_function_calls_eh_return
1055             && (regno == EH_RETURN_DATA_REGNO (0)
1056                 || regno == EH_RETURN_DATA_REGNO (1)
1057                 || regno == EH_RETURN_DATA_REGNO (2)
1058                 || regno == EH_RETURN_DATA_REGNO (3))))
1059
1060       {
1061         if (regno == last_movem_reg + 1)
1062           last_movem_reg++;
1063         else
1064           break;
1065       }
1066
1067   for (regno = FIRST_PSEUDO_REGISTER - 1;
1068        regno > last_movem_reg;
1069        regno--)
1070     if ((((regs_ever_live[regno]
1071            && !call_used_regs[regno])
1072           || (regno == PIC_OFFSET_TABLE_REGNUM
1073               && (current_function_uses_pic_offset_table
1074                   /* It is saved anyway, if there would be a gap.  */
1075                   || (flag_pic
1076                       && regs_ever_live[regno + 1]
1077                       && !call_used_regs[regno + 1]))))
1078          && (regno != FRAME_POINTER_REGNUM || !frame_pointer_needed)
1079          && regno != CRIS_SRP_REGNUM)
1080         || (current_function_calls_eh_return
1081             && (regno == EH_RETURN_DATA_REGNO (0)
1082                 || regno == EH_RETURN_DATA_REGNO (1)
1083                 || regno == EH_RETURN_DATA_REGNO (2)
1084                 || regno == EH_RETURN_DATA_REGNO (3))))
1085       {
1086         if (argspace_offset)
1087           {
1088             /* There is an area for outgoing parameters located before
1089                the saved registers.  We have to adjust for that.  */
1090             if (file)
1091               fprintf (file, "\tAdd%s %d,$sp\n",
1092                        ADDITIVE_SIZE_MODIFIER (argspace_offset),
1093                        argspace_offset);
1094
1095             /* Make sure we only do this once.  */
1096             argspace_offset = 0;
1097           }
1098
1099         /* Flush previous non-movem:ed registers.  */
1100         if (*save_last && file)
1101           fprintf (file, save_last);
1102         sprintf (save_last, "\tPop $%s\n", reg_names[regno]);
1103       }
1104
1105   if (last_movem_reg != -1)
1106     {
1107       if (argspace_offset)
1108         {
1109           /* Adjust for the outgoing parameters area, if that's not
1110              handled yet.  */
1111           if (*save_last && file)
1112             {
1113               fprintf (file, save_last);
1114               *save_last = 0;
1115             }
1116
1117           if (file)
1118             fprintf (file, "\tAdd%s %d,$sp\n",
1119                      ADDITIVE_SIZE_MODIFIER (argspace_offset),
1120                      argspace_offset);
1121           argspace_offset = 0;
1122         }
1123       /* Flush previous non-movem:ed registers.  */
1124       else if (*save_last && file)
1125         fprintf (file, save_last);
1126       sprintf (save_last, "\tmovem [$sp+],$%s\n", reg_names[last_movem_reg]);
1127     }
1128
1129   /* Restore frame pointer if necessary.  */
1130   if (frame_pointer_needed)
1131     {
1132       if (*save_last && file)
1133         fprintf (file, save_last);
1134
1135       if (file)
1136         fprintf (file, "\tmove.d $%s,$sp\n",
1137                  reg_names[FRAME_POINTER_REGNUM]);
1138       sprintf (save_last, "\tPop $%s\n",
1139                reg_names[FRAME_POINTER_REGNUM]);
1140     }
1141   else
1142     {
1143       /* If there was no frame-pointer to restore sp from, we must
1144          explicitly deallocate local variables.  */
1145
1146       /* Handle space for outgoing parameters that hasn't been handled
1147          yet.  */
1148       size += argspace_offset;
1149
1150       if (size)
1151         {
1152           if (*save_last && file)
1153             fprintf (file, save_last);
1154
1155           sprintf (save_last, "\tadd%s %d,$sp\n",
1156                    ADDITIVE_SIZE_MODIFIER (size), size);
1157         }
1158
1159       /* If the size was not in the range for a "quick", we must flush
1160          it here.  */
1161       if (size > 63)
1162         {
1163           if (file)
1164             fprintf (file, save_last);
1165           *save_last = 0;
1166         }
1167     }
1168
1169   /* If this function has no pushed register parameters
1170      (stdargs/varargs), and if it is not a leaf function, then we can
1171      just jump-return here.  */
1172   if (return_address_on_stack && pretend == 0)
1173     {
1174       if (*save_last && file)
1175         fprintf (file, save_last);
1176       *save_last = 0;
1177
1178       if (file)
1179         {
1180           if (current_function_calls_eh_return)
1181             {
1182               /* The installed EH-return address is in *this* frame, so we
1183                  need to pop it before we return.  */
1184               fprintf (file, "\tpop $srp\n");
1185               fprintf (file, "\tret\n");
1186               fprintf (file, "\tadd.d $%s,$sp\n", reg_names[CRIS_STACKADJ_REG]);
1187             }
1188           else
1189             fprintf (file, "\tJump [$sp+]\n");
1190
1191           /* Do a sanity check to avoid generating invalid code.  */
1192           if (current_function_epilogue_delay_list)
1193             internal_error ("allocated but unused delay list in epilogue");
1194         }
1195       return;
1196     }
1197
1198   /* Rather than add current_function_calls_eh_return conditions
1199      everywhere in the following code (and not be able to test it
1200      thoroughly), assert the assumption that all usage of
1201      __builtin_eh_return are handled above.  */
1202   if (current_function_calls_eh_return)
1203     internal_error ("unexpected function type needing stack adjustment for\
1204  __builtin_eh_return");
1205
1206   /* If we pushed some register parameters, then adjust the stack for
1207      them.  */
1208   if (pretend)
1209     {
1210       /* Since srp is stored on the way, we need to restore it first.  */
1211       if (return_address_on_stack)
1212         {
1213           if (*save_last && file)
1214             fprintf (file, save_last);
1215           *save_last = 0;
1216
1217           if (file)
1218             fprintf (file, "\tpop $srp\n");
1219         }
1220
1221       if (*save_last && file)
1222         fprintf (file, save_last);
1223
1224       sprintf (save_last, "\tadd%s %d,$sp\n",
1225                ADDITIVE_SIZE_MODIFIER (pretend), pretend);
1226     }
1227
1228   /* Here's where we have a delay-slot we need to fill.  */
1229   if (file && current_function_epilogue_delay_list)
1230     {
1231       /* If gcc has allocated an insn for the epilogue delay slot, but
1232          things were arranged so we now thought we could do it
1233          ourselves, don't forget to flush that insn.  */
1234       if (*save_last)
1235         fprintf (file, save_last);
1236
1237       fprintf (file, "\tRet\n");
1238
1239       /* Output the delay-slot-insn the mandated way.  */
1240       final_scan_insn (XEXP (current_function_epilogue_delay_list, 0),
1241                        file, 1, -2, 1);
1242     }
1243   else if (file)
1244     {
1245       fprintf (file, "\tRet\n");
1246
1247       /* If the GCC did not do it, we have to use whatever insn we have,
1248          or a nop.  */
1249       if (*save_last)
1250         fprintf (file, save_last);
1251       else
1252         fprintf (file, "\tnOp\n");
1253     }
1254 }
1255
1256 /* The PRINT_OPERAND worker.  */
1257
1258 void
1259 cris_print_operand (file, x, code)
1260      FILE *file;
1261      rtx x;
1262      int code;
1263 {
1264   rtx operand = x;
1265
1266   /* Size-strings corresponding to MULT expressions.  */
1267   static const char *mults[] = { "BAD:0", ".b", ".w", "BAD:3", ".d" };
1268
1269   /* New code entries should just be added to the switch below.  If
1270      handling is finished, just return.  If handling was just a
1271      modification of the operand, the modified operand should be put in
1272      "operand", and then do a break to let default handling
1273      (zero-modifier) output the operand.  */
1274
1275   switch (code)
1276     {
1277     case 'b':
1278       /* Print the unsigned supplied integer as if it was signed
1279          and < 0, i.e print 255 or 65535 as -1, 254, 65534 as -2, etc.  */
1280       if (GET_CODE (x) != CONST_INT
1281           || ! CONST_OK_FOR_LETTER_P (INTVAL (x), 'O'))
1282         LOSE_AND_RETURN ("invalid operand for 'b' modifier", x);
1283       fprintf (file, "%d", INTVAL (x)| (INTVAL (x) <= 255 ? ~255 : ~65535));
1284       return;
1285
1286     case 'x':
1287       /* Print assembler code for operator.  */
1288       fprintf (file, "%s", cris_op_str (operand));
1289       return;
1290
1291     case 'v':
1292       /* Print the operand without the PIC register.  */
1293       if (! flag_pic || ! CONSTANT_P (x) || ! cris_gotless_symbol (x))
1294         LOSE_AND_RETURN ("invalid operand for 'v' modifier", x);
1295       cris_pic_sympart_only++;
1296       cris_output_addr_const (file, x);
1297       cris_pic_sympart_only--;
1298       return;
1299
1300     case 'P':
1301       /* Print the PIC register.  Applied to a GOT-less PIC symbol for
1302          sanity.  */
1303       if (! flag_pic || ! CONSTANT_P (x) || ! cris_gotless_symbol (x))
1304         LOSE_AND_RETURN ("invalid operand for 'P' modifier", x);
1305       fprintf (file, "$%s", reg_names [PIC_OFFSET_TABLE_REGNUM]);
1306       return;
1307
1308     case 'p':
1309       /* Adjust a power of two to its log2.  */
1310       if (GET_CODE (x) != CONST_INT || exact_log2 (INTVAL (x)) < 0 )
1311         LOSE_AND_RETURN ("invalid operand for 'p' modifier", x);
1312       fprintf (file, "%d", exact_log2 (INTVAL (x)));
1313       return;
1314
1315     case 's':
1316       /* For an integer, print 'b' or 'w' if <= 255 or <= 65535
1317          respectively.  This modifier also terminates the inhibiting
1318          effects of the 'x' modifier.  */
1319       cris_output_insn_is_bound = 0;
1320       if (GET_MODE (x) == VOIDmode && GET_CODE (x) == CONST_INT)
1321         {
1322           if (INTVAL (x) >= 0)
1323             {
1324               if (INTVAL (x) <= 255)
1325                 putc ('b', file);
1326               else if (INTVAL (x) <= 65535)
1327                 putc ('w', file);
1328               else
1329                 putc ('d', file);
1330             }
1331           else
1332             putc ('d', file);
1333           return;
1334         }
1335
1336       /* For a non-integer, print the size of the operand.  */
1337       putc ((GET_MODE (x) == SImode || GET_MODE (x) == SFmode)
1338             ? 'd' : GET_MODE (x) == HImode ? 'w'
1339             : GET_MODE (x) == QImode ? 'b'
1340             /* If none of the above, emit an erroneous size letter.  */
1341             : 'X',
1342             file);
1343       return;
1344
1345     case 'z':
1346       /* Const_int: print b for -127 <= x <= 255,
1347          w for -32768 <= x <= 65535, else abort.  */
1348       if (GET_CODE (x) != CONST_INT
1349           || INTVAL (x) < -32768 || INTVAL (x) > 65535)
1350         LOSE_AND_RETURN ("invalid operand for 'z' modifier", x);
1351       putc (INTVAL (x) >= -128 && INTVAL (x) <= 255 ? 'b' : 'w', file);
1352       return;
1353
1354     case '#':
1355       /* Output a 'nop' if there's nothing for the delay slot.
1356          This method stolen from the sparc files.  */
1357       if (dbr_sequence_length () == 0)
1358         fputs ("\n\tnop", file);
1359       return;
1360
1361     case 'H':
1362       /* Print high (most significant) part of something.  */
1363       switch (GET_CODE (operand))
1364         {
1365         case CONST_INT:
1366           if (HOST_BITS_PER_WIDE_INT == 32)
1367             /* Sign-extension from a normal int to a long long.  */
1368             fprintf (file, INTVAL (operand) < 0 ? "-1" : "0");
1369           else
1370             fprintf (file, "0x%x", (unsigned int)(INTVAL (x) >> 31 >> 1));
1371           return;
1372
1373         case CONST_DOUBLE:
1374           /* High part of a long long constant.  */
1375           if (GET_MODE (operand) == VOIDmode)
1376             {
1377               fprintf (file, "0x%x", CONST_DOUBLE_HIGH (x));
1378               return;
1379             }
1380           else
1381             LOSE_AND_RETURN ("invalid operand for 'H' modifier", x);
1382
1383         case REG:
1384           /* Print reg + 1.  Check that there's not an attempt to print
1385              high-parts of registers like stack-pointer or higher.  */
1386           if (REGNO (operand) > STACK_POINTER_REGNUM - 2)
1387             LOSE_AND_RETURN ("bad register", operand);
1388           fprintf (file, "$%s", reg_names[REGNO (operand) + 1]);
1389           return;
1390
1391         case MEM:
1392           /* Adjust memory address to high part.  */
1393           {
1394             rtx adj_mem = operand;
1395             int size
1396               = GET_MODE_BITSIZE (GET_MODE (operand)) / BITS_PER_UNIT;
1397
1398             /* Adjust so we can use two SImode in DImode.
1399                Calling adj_offsettable_operand will make sure it is an
1400                offsettable address.  Don't do this for a postincrement
1401                though; it should remain as it was.  */
1402             if (GET_CODE (XEXP (adj_mem, 0)) != POST_INC)
1403               adj_mem
1404                 = adjust_address (adj_mem, GET_MODE (adj_mem), size / 2);
1405
1406             output_address (XEXP (adj_mem, 0));
1407             return;
1408           }
1409
1410         default:
1411           LOSE_AND_RETURN ("invalid operand for 'H' modifier", x);
1412         }
1413
1414     case 'L':
1415       /* Strip the MEM expression.  */
1416       operand = XEXP (operand, 0);
1417       break;
1418
1419     case 'e':
1420       /* Print 's' if operand is SIGN_EXTEND or 'u' if ZERO_EXTEND unless
1421          cris_output_insn_is_bound is nonzero.  */
1422       if (GET_CODE (operand) != SIGN_EXTEND
1423           && GET_CODE (operand) != ZERO_EXTEND
1424           && GET_CODE (operand) != CONST_INT)
1425         LOSE_AND_RETURN ("invalid operand for 'e' modifier", x);
1426
1427       if (cris_output_insn_is_bound)
1428         {
1429           cris_output_insn_is_bound = 0;
1430           return;
1431         }
1432
1433       putc (GET_CODE (operand) == SIGN_EXTEND
1434             || (GET_CODE (operand) == CONST_INT && INTVAL (operand) < 0)
1435             ? 's' : 'u', file);
1436       return;
1437
1438     case 'm':
1439       /* Print the size letter of the inner element.  We can do it by
1440          calling ourselves with the 's' modifier.  */
1441       if (GET_CODE (operand) != SIGN_EXTEND && GET_CODE (operand) != ZERO_EXTEND)
1442         LOSE_AND_RETURN ("invalid operand for 'm' modifier", x);
1443       cris_print_operand (file, XEXP (operand, 0), 's');
1444       return;
1445
1446     case 'M':
1447       /* Print the least significant part of operand.  */
1448       if (GET_CODE (operand) == CONST_DOUBLE)
1449         {
1450           fprintf (file, "0x%x", CONST_DOUBLE_LOW (x));
1451           return;
1452         }
1453       else if (HOST_BITS_PER_WIDE_INT > 32 && GET_CODE (operand) == CONST_INT)
1454         {
1455           fprintf (file, "0x%x", (unsigned int)(INTVAL (x) & 0xffffffff));
1456           return;
1457         }
1458       /* Otherwise the least significant part equals the normal part,
1459          so handle it normally.  */
1460       break;
1461
1462     case 'A':
1463       /* When emitting an add for the high part of a DImode constant, we
1464          want to use addq for 0 and adds.w for -1.  */
1465       if (GET_CODE (operand) != CONST_INT)
1466         LOSE_AND_RETURN ("invalid operand for 'A' modifier", x);
1467       fprintf (file, INTVAL (operand) < 0 ? "adds.w" : "addq");
1468       return;
1469
1470     case 'D':
1471       /* When emitting an sub for the high part of a DImode constant, we
1472          want to use subq for 0 and subs.w for -1.  */
1473       if (GET_CODE (operand) != CONST_INT)
1474         LOSE_AND_RETURN ("invalid operand for 'D' modifier", x);
1475       fprintf (file, INTVAL (operand) < 0 ? "subs.w" : "subq");
1476       return;
1477
1478     case 'S':
1479       /* Print the operand as the index-part of an address.
1480          Easiest way out is to use cris_print_index.  */
1481       cris_print_index (operand, file);
1482       return;
1483
1484     case 'T':
1485       /* Print the size letter for an operand to a MULT, which must be a
1486          const_int with a suitable value.  */
1487       if (GET_CODE (operand) != CONST_INT || INTVAL (operand) > 4)
1488         LOSE_AND_RETURN ("invalid operand for 'T' modifier", x);
1489       fprintf (file, "%s", mults[INTVAL (operand)]);
1490       return;
1491
1492     case 0:
1493       /* No code, print as usual.  */
1494       break;
1495
1496     default:
1497       LOSE_AND_RETURN ("invalid operand modifier letter", x);
1498     }
1499
1500   /* Print an operand as without a modifier letter.  */
1501   switch (GET_CODE (operand))
1502     {
1503     case REG:
1504       if (REGNO (operand) > 15)
1505         internal_error ("internal error: bad register: %d", REGNO (operand));
1506       fprintf (file, "$%s", reg_names[REGNO (operand)]);
1507       return;
1508
1509     case MEM:
1510       output_address (XEXP (operand, 0));
1511       return;
1512
1513     case CONST_DOUBLE:
1514       if (GET_MODE (operand) == VOIDmode)
1515         /* A long long constant.  */
1516         output_addr_const (file, operand);
1517       else
1518         {
1519           /* Only single precision is allowed as plain operands the
1520              moment.  FIXME:  REAL_VALUE_FROM_CONST_DOUBLE isn't
1521              documented.  */
1522           REAL_VALUE_TYPE r;
1523           long l;
1524
1525           /* FIXME:  Perhaps check overflow of the "single".  */
1526           REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
1527           REAL_VALUE_TO_TARGET_SINGLE (r, l);
1528
1529           fprintf (file, "0x%lx", l);
1530         }
1531       return;
1532
1533     case UNSPEC:
1534       ASSERT_PLT_UNSPEC (operand);
1535       /* Fall through.  */
1536
1537     case CONST:
1538       cris_output_addr_const (file, operand);
1539       return;
1540
1541     case MULT:
1542     case ASHIFT:
1543       {
1544         /* For a (MULT (reg X) const_int) we output "rX.S".  */
1545         int i = GET_CODE (XEXP (operand, 1)) == CONST_INT
1546           ? INTVAL (XEXP (operand, 1)) : INTVAL (XEXP (operand, 0));
1547         rtx reg = GET_CODE (XEXP (operand, 1)) == CONST_INT
1548           ? XEXP (operand, 0) : XEXP (operand, 1);
1549
1550         if (GET_CODE (reg) != REG
1551             || (GET_CODE (XEXP (operand, 0)) != CONST_INT
1552                 && GET_CODE (XEXP (operand, 1)) != CONST_INT))
1553           LOSE_AND_RETURN ("unexpected multiplicative operand", x);
1554
1555         cris_print_base (reg, file);
1556         fprintf (file, ".%c",
1557                  i == 0 || (i == 1 && GET_CODE (operand) == MULT) ? 'b'
1558                  : i == 4 ? 'd'
1559                  : (i == 2 && GET_CODE (operand) == MULT) || i == 1 ? 'w'
1560                  : 'd');
1561         return;
1562       }
1563
1564     default:
1565       /* No need to handle all strange variants, let output_addr_const
1566          do it for us.  */
1567       if (CONSTANT_P (operand))
1568         {
1569           cris_output_addr_const (file, operand);
1570           return;
1571         }
1572
1573       LOSE_AND_RETURN ("unexpected operand", x);
1574     }
1575 }
1576
1577 /* The PRINT_OPERAND_ADDRESS worker.  */
1578
1579 void
1580 cris_print_operand_address (file, x)
1581      FILE *file;
1582      rtx x;
1583 {
1584   /* All these were inside MEM:s so output indirection characters.  */
1585   putc ('[', file);
1586
1587   if (CONSTANT_ADDRESS_P (x))
1588     cris_output_addr_const (file, x);
1589   else if (BASE_OR_AUTOINCR_P (x))
1590     cris_print_base (x, file);
1591   else if (GET_CODE (x) == PLUS)
1592     {
1593       rtx x1, x2;
1594
1595       x1 = XEXP (x, 0);
1596       x2 = XEXP (x, 1);
1597       if (BASE_P (x1))
1598         {
1599           cris_print_base (x1, file);
1600           cris_print_index (x2, file);
1601         }
1602       else if (BASE_P (x2))
1603         {
1604           cris_print_base (x2, file);
1605           cris_print_index (x1, file);
1606         }
1607       else
1608         LOSE_AND_RETURN ("unrecognized address", x);
1609     }
1610   else if (GET_CODE (x) == MEM)
1611     {
1612       /* A DIP.  Output more indirection characters.  */
1613       putc ('[', file);
1614       cris_print_base (XEXP (x, 0), file);
1615       putc (']', file);
1616     }
1617   else
1618     LOSE_AND_RETURN ("unrecognized address", x);
1619
1620   putc (']', file);
1621 }
1622
1623 /* The RETURN_ADDR_RTX worker.
1624    We mark that the return address is used, either by EH or
1625    __builtin_return_address, for use by the function prologue and
1626    epilogue.  FIXME: This isn't optimal; we just use the mark in the
1627    prologue and epilogue to say that the return address is to be stored
1628    in the stack frame.  We could return SRP for leaf-functions and use the
1629    initial-value machinery.  */
1630
1631 rtx
1632 cris_return_addr_rtx (count, frameaddr)
1633      int count;
1634      rtx frameaddr ATTRIBUTE_UNUSED;
1635 {
1636   cfun->machine->needs_return_address_on_stack = 1;
1637
1638   /* The return-address is stored just above the saved frame-pointer (if
1639      present).  Apparently we can't eliminate from the frame-pointer in
1640      that direction, so use the incoming args (maybe pretended) pointer.  */
1641   return count == 0
1642     ? gen_rtx_MEM (Pmode, plus_constant (virtual_incoming_args_rtx, -4))
1643     : NULL_RTX;
1644 }
1645
1646 /* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
1647    handles FP -> SP elimination offset.  */
1648
1649 static int
1650 cris_initial_frame_pointer_offset ()
1651 {
1652   int regno;
1653
1654   /* Initial offset is 0 if we don't have a frame pointer.  */
1655   int offs = 0;
1656
1657   /* And 4 for each register pushed.  */
1658   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1659     if ((((regs_ever_live[regno]
1660            && !call_used_regs[regno])
1661           || (regno == PIC_OFFSET_TABLE_REGNUM
1662               && (current_function_uses_pic_offset_table
1663                   /* It is saved anyway, if there would be a gap.  */
1664                   || (flag_pic
1665                       && regs_ever_live[regno + 1]
1666                       && !call_used_regs[regno + 1]))))
1667          && (regno != FRAME_POINTER_REGNUM || !frame_pointer_needed)
1668          && regno != CRIS_SRP_REGNUM)
1669         || (current_function_calls_eh_return
1670             && (regno == EH_RETURN_DATA_REGNO (0)
1671                 || regno == EH_RETURN_DATA_REGNO (1)
1672                 || regno == EH_RETURN_DATA_REGNO (2)
1673                 || regno == EH_RETURN_DATA_REGNO (3))))
1674       offs += 4;
1675
1676   /* And then, last, we add the locals allocated.  */
1677   offs += get_frame_size ();
1678
1679   /* And more; the accumulated args size.  */
1680   offs += current_function_outgoing_args_size;
1681
1682   /* Then round it off, in case we use aligned stack.  */
1683   if (TARGET_STACK_ALIGN)
1684     offs = TARGET_ALIGN_BY_32 ? (offs + 3) & ~3 : (offs + 1) & ~1;
1685
1686   return offs;
1687 }
1688
1689 /* The INITIAL_ELIMINATION_OFFSET worker.
1690    Calculate the difference between imaginary registers such as frame
1691    pointer and the stack pointer.  Used to eliminate the frame pointer
1692    and imaginary arg pointer.  */
1693
1694 int
1695 cris_initial_elimination_offset (fromreg, toreg)
1696      int fromreg;
1697      int toreg;
1698 {
1699   int fp_sp_offset
1700     = cris_initial_frame_pointer_offset ();
1701
1702   /* We should be able to use regs_ever_live and related prologue
1703      information here, or alpha should not as well.  */
1704   int return_address_on_stack
1705     = regs_ever_live[CRIS_SRP_REGNUM]
1706     || cfun->machine->needs_return_address_on_stack != 0;
1707
1708   /* Here we act as if the frame-pointer is needed.  */
1709   int ap_fp_offset = 4 + (return_address_on_stack ? 4 : 0);
1710
1711   if (fromreg == ARG_POINTER_REGNUM
1712       && toreg == FRAME_POINTER_REGNUM)
1713     return ap_fp_offset;
1714
1715   /* Between the frame pointer and the stack are only "normal" stack
1716      variables and saved registers.  */
1717   if (fromreg == FRAME_POINTER_REGNUM
1718       && toreg == STACK_POINTER_REGNUM)
1719     return fp_sp_offset;
1720
1721   /* We need to balance out the frame pointer here.  */
1722   if (fromreg == ARG_POINTER_REGNUM
1723       && toreg == STACK_POINTER_REGNUM)
1724     return ap_fp_offset + fp_sp_offset - 4;
1725
1726   abort ();
1727 }
1728
1729 /*  This function looks into the pattern to see how this insn affects
1730     condition codes.
1731
1732     Used when to eliminate test insns before a condition-code user,
1733     such as a "scc" insn or a conditional branch.  This includes
1734     checking if the entities that cc was updated by, are changed by the
1735     operation.
1736
1737     Currently a jumble of the old peek-inside-the-insn and the newer
1738     check-cc-attribute methods.  */
1739
1740 void
1741 cris_notice_update_cc (exp, insn)
1742      rtx exp;
1743      rtx insn;
1744 {
1745   /* Check if user specified "-mcc-init" as a bug-workaround.  FIXME:
1746      TARGET_CCINIT does not work; we must set CC_REVERSED as below.
1747      Several test-cases will otherwise fail, for example
1748      gcc.c-torture/execute/20000217-1.c -O0 and -O1.  */
1749   if (TARGET_CCINIT)
1750     {
1751       CC_STATUS_INIT;
1752       return;
1753     }
1754
1755   /* Slowly, we're converting to using attributes to control the setting
1756      of condition-code status.  */
1757   switch (get_attr_cc (insn))
1758     {
1759     case CC_NONE:
1760       /* Even if it is "none", a setting may clobber a previous
1761          cc-value, so check.  */
1762       if (GET_CODE (exp) == SET)
1763         {
1764           if (cc_status.value1
1765               && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1766                                              cc_status.value1))
1767             cc_status.value1 = 0;
1768
1769           if (cc_status.value2
1770               && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1771                                              cc_status.value2))
1772             cc_status.value2 = 0;
1773         }
1774       return;
1775
1776     case CC_CLOBBER:
1777       CC_STATUS_INIT;
1778       break;
1779
1780     case CC_NORMAL:
1781       /* Which means, for:
1782          (set (cc0) (...)):
1783          CC is (...).
1784
1785          (set (reg) (...)):
1786          CC is (reg) and (...) - unless (...) is 0, then CC does not change.
1787          CC_NO_OVERFLOW unless (...) is reg or mem.
1788
1789          (set (mem) (...)):
1790          CC does not change.
1791
1792          (set (pc) (...)):
1793          CC does not change.
1794
1795          (parallel
1796           (set (reg1) (mem (bdap/biap)))
1797           (set (reg2) (bdap/biap))):
1798          CC is (reg1) and (mem (reg2))
1799
1800          (parallel
1801           (set (mem (bdap/biap)) (reg1)) [or 0]
1802           (set (reg2) (bdap/biap))):
1803          CC does not change.
1804
1805          (where reg and mem includes strict_low_parts variants thereof)
1806
1807          For all others, assume CC is clobbered.
1808          Note that we do not have to care about setting CC_NO_OVERFLOW,
1809          since the overflow flag is set to 0 (i.e. right) for
1810          instructions where it does not have any sane sense, but where
1811          other flags have meanings.  (This includes shifts; the carry is
1812          not set by them).
1813
1814          Note that there are other parallel constructs we could match,
1815          but we don't do that yet.  */
1816
1817       if (GET_CODE (exp) == SET)
1818         {
1819           /* FIXME: Check when this happens.  It looks like we should
1820              actually do a CC_STATUS_INIT here to be safe.  */
1821           if (SET_DEST (exp) == pc_rtx)
1822             return;
1823
1824           /* Record CC0 changes, so we do not have to output multiple
1825              test insns.  */
1826           if (SET_DEST (exp) == cc0_rtx)
1827             {
1828               cc_status.value1 = SET_SRC (exp);
1829               cc_status.value2 = 0;
1830
1831               /* Handle flags for the special btstq on one bit.  */
1832               if (GET_CODE (SET_SRC (exp)) == ZERO_EXTRACT
1833                   && XEXP (SET_SRC (exp), 1) == const1_rtx)
1834                 {
1835                   if (GET_CODE (XEXP (SET_SRC (exp), 0)) == CONST_INT)
1836                     /* Using cmpq.  */
1837                     cc_status.flags = CC_INVERTED;
1838                   else
1839                     /* A one-bit btstq.  */
1840                     cc_status.flags = CC_Z_IN_NOT_N;
1841                 }
1842               else
1843                 cc_status.flags = 0;
1844
1845               if (GET_CODE (SET_SRC (exp)) == COMPARE)
1846                 {
1847                   if (!REG_P (XEXP (SET_SRC (exp), 0))
1848                       && XEXP (SET_SRC (exp), 1) != const0_rtx)
1849                     /* For some reason gcc will not canonicalize compare
1850                        operations, reversing the sign by itself if
1851                        operands are in wrong order.  */
1852                     /* (But NOT inverted; eq is still eq.) */
1853                     cc_status.flags = CC_REVERSED;
1854
1855                   /* This seems to be overlooked by gcc.  FIXME: Check again.
1856                      FIXME:  Is it really safe?  */
1857                   cc_status.value2
1858                     = gen_rtx_MINUS (GET_MODE (SET_SRC (exp)),
1859                                      XEXP (SET_SRC (exp), 0),
1860                                      XEXP (SET_SRC (exp), 1));
1861                 }
1862               return;
1863             }
1864           else if (REG_P (SET_DEST (exp))
1865                    || (GET_CODE (SET_DEST (exp)) == STRICT_LOW_PART
1866                        && REG_P (XEXP (SET_DEST (exp), 0))))
1867             {
1868               /* A register is set; normally CC is set to show that no
1869                  test insn is needed.  Catch the exceptions.  */
1870
1871               /* If not to cc0, then no "set"s in non-natural mode give
1872                  ok cc0...  */
1873               if (GET_MODE_SIZE (GET_MODE (SET_DEST (exp))) > UNITS_PER_WORD
1874                   || GET_MODE_CLASS (GET_MODE (SET_DEST (exp))) == MODE_FLOAT)
1875                 {
1876                   /* ... except add:s and sub:s in DImode.  */
1877                   if (GET_MODE (SET_DEST (exp)) == DImode
1878                       && (GET_CODE (SET_SRC (exp)) == PLUS
1879                           || GET_CODE (SET_SRC (exp)) == MINUS))
1880                     {
1881                       cc_status.flags = 0;
1882                       cc_status.value1 = SET_DEST (exp);
1883                       cc_status.value2 = SET_SRC (exp);
1884
1885                       if (cris_reg_overlap_mentioned_p (cc_status.value1,
1886                                                         cc_status.value2))
1887                         cc_status.value2 = 0;
1888
1889                       /* Add and sub may set V, which gets us
1890                          unoptimizable results in "gt" and "le" condition
1891                          codes.  */
1892                       cc_status.flags |= CC_NO_OVERFLOW;
1893
1894                       return;
1895                     }
1896                 }
1897               else if (SET_SRC (exp) == const0_rtx)
1898                 {
1899                   /* There's no CC0 change when clearing a register or
1900                      memory.  Just check for overlap.  */
1901                   if ((cc_status.value1
1902                        && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1903                                                         cc_status.value1)))
1904                     cc_status.value1 = 0;
1905
1906                   if ((cc_status.value2
1907                        && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1908                                                         cc_status.value2)))
1909                     cc_status.value2 = 0;
1910
1911                   return;
1912                 }
1913               else
1914                 {
1915                   cc_status.flags = 0;
1916                   cc_status.value1 = SET_DEST (exp);
1917                   cc_status.value2 = SET_SRC (exp);
1918
1919                   if (cris_reg_overlap_mentioned_p (cc_status.value1,
1920                                                     cc_status.value2))
1921                     cc_status.value2 = 0;
1922
1923                   /* Some operations may set V, which gets us
1924                      unoptimizable results in "gt" and "le" condition
1925                      codes.  */
1926                   if (GET_CODE (SET_SRC (exp)) == PLUS
1927                       || GET_CODE (SET_SRC (exp)) == MINUS
1928                       || GET_CODE (SET_SRC (exp)) == NEG)
1929                     cc_status.flags |= CC_NO_OVERFLOW;
1930
1931                   return;
1932                 }
1933             }
1934           else if (GET_CODE (SET_DEST (exp)) == MEM
1935                    || (GET_CODE (SET_DEST (exp)) == STRICT_LOW_PART
1936                        && GET_CODE (XEXP (SET_DEST (exp), 0)) == MEM))
1937             {
1938               /* When SET to MEM, then CC is not changed (except for
1939                  overlap).  */
1940               if ((cc_status.value1
1941                    && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1942                                                     cc_status.value1)))
1943                 cc_status.value1 = 0;
1944
1945               if ((cc_status.value2
1946                    && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1947                                                     cc_status.value2)))
1948                 cc_status.value2 = 0;
1949
1950               return;
1951             }
1952         }
1953       else if (GET_CODE (exp) == PARALLEL)
1954         {
1955           if (GET_CODE (XVECEXP (exp, 0, 0)) == SET
1956               && GET_CODE (XVECEXP (exp, 0, 1)) == SET
1957               && REG_P (XEXP (XVECEXP (exp, 0, 1), 0)))
1958             {
1959               if (REG_P (XEXP (XVECEXP (exp, 0, 0), 0))
1960                   && GET_CODE (XEXP (XVECEXP (exp, 0, 0), 1)) == MEM)
1961                 {
1962                   /* For "move.S [rx=ry+o],rz", say CC reflects
1963                      value1=rz and value2=[rx] */
1964                   cc_status.value1 = XEXP (XVECEXP (exp, 0, 0), 0);
1965                   cc_status.value2
1966                     = gen_rtx_MEM (GET_MODE (XEXP (XVECEXP (exp, 0, 0), 0)),
1967                                    XEXP (XVECEXP (exp, 0, 1), 0));
1968                   cc_status.flags = 0;
1969
1970                   /* Huh?  A side-effect cannot change the destination
1971                      register.  */
1972                   if (cris_reg_overlap_mentioned_p (cc_status.value1,
1973                                                     cc_status.value2))
1974                     internal_error ("internal error: sideeffect-insn affecting main effect");
1975                   return;
1976                 }
1977               else if ((REG_P (XEXP (XVECEXP (exp, 0, 0), 1))
1978                         || XEXP (XVECEXP (exp, 0, 0), 1) == const0_rtx)
1979                        && GET_CODE (XEXP (XVECEXP (exp, 0, 0), 0)) == MEM)
1980                 {
1981                   /* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
1982                      say flags are not changed, except for overlap.  */
1983                   if (cc_status.value1
1984                       && cris_reg_overlap_mentioned_p (XEXP
1985                                                        (XVECEXP
1986                                                         (exp, 0, 0), 0),
1987                                                        cc_status.value1))
1988                     cc_status.value1 = 0;
1989
1990                   if (cc_status.value1
1991                       && cris_reg_overlap_mentioned_p (XEXP
1992                                                        (XVECEXP
1993                                                         (exp, 0, 1), 0),
1994                                                        cc_status.value1))
1995                     cc_status.value1 = 0;
1996
1997                   if (cc_status.value2
1998                       && cris_reg_overlap_mentioned_p (XEXP
1999                                                        (XVECEXP
2000                                                         (exp, 0, 0), 0),
2001                                                        cc_status.value2))
2002                     cc_status.value2 = 0;
2003
2004                   if (cc_status.value2
2005                       && cris_reg_overlap_mentioned_p (XEXP
2006                                                        (XVECEXP
2007                                                         (exp, 0, 1), 0),
2008                                                        cc_status.value2))
2009                     cc_status.value2 = 0;
2010
2011                   return;
2012                 }
2013             }
2014         }
2015       break;
2016
2017     default:
2018       /* Unknown cc_attr value.  */
2019       abort ();
2020     }
2021
2022   CC_STATUS_INIT;
2023 }
2024
2025 /* Return != 0 if the return sequence for the current function is short,
2026    like "ret" or "jump [sp+]".  Prior to reloading, we can't tell how
2027    many registers must be saved, so return 0 then.  */
2028
2029 int
2030 cris_simple_epilogue ()
2031 {
2032   int regno;
2033   int reglimit = STACK_POINTER_REGNUM;
2034   int lastreg = -1;
2035
2036   if (! reload_completed
2037       || frame_pointer_needed
2038       || get_frame_size () != 0
2039       || current_function_pretend_args_size
2040       || current_function_args_size
2041       || current_function_outgoing_args_size
2042       || current_function_calls_eh_return
2043
2044       /* If we're not supposed to emit prologue and epilogue, we must
2045          not emit return-type instructions.  */
2046       || !TARGET_PROLOGUE_EPILOGUE)
2047     return 0;
2048
2049   /* We allow a "movem [sp+],rN" to sit in front if the "jump [sp+]" or
2050      in the delay-slot of the "ret".  */
2051   for (regno = 0; regno < reglimit; regno++)
2052     if ((regs_ever_live[regno] && ! call_used_regs[regno])
2053         || (regno == PIC_OFFSET_TABLE_REGNUM
2054             && (current_function_uses_pic_offset_table
2055                 /* It is saved anyway, if there would be a gap.  */
2056                 || (flag_pic
2057                     && regs_ever_live[regno + 1]
2058                     && !call_used_regs[regno + 1]))))
2059       {
2060         if (lastreg != regno - 1)
2061           return 0;
2062         lastreg = regno;
2063       }
2064
2065   return 1;
2066 }
2067
2068 /* The ADDRESS_COST worker.  */
2069
2070 int
2071 cris_address_cost (x)
2072      rtx x;
2073 {
2074   /* The metric to use for the cost-macros is unclear.
2075      The metric used here is (the number of cycles needed) / 2,
2076      where we consider equal a cycle for a word of code and a cycle to
2077      read memory.  */
2078
2079   /* The cheapest addressing modes get 0, since nothing extra is needed.  */
2080   if (BASE_OR_AUTOINCR_P (x))
2081     return 0;
2082
2083   /* An indirect mem must be a DIP.  This means two bytes extra for code,
2084      and 4 bytes extra for memory read, i.e.  (2 + 4) / 2.  */
2085   if (GET_CODE (x) == MEM)
2086     return (2 + 4) / 2;
2087
2088   /* Assume (2 + 4) / 2 for a single constant; a dword, since it needs
2089      an extra DIP prefix and 4 bytes of constant in most cases.
2090      For PIC and a symbol with a GOT entry, we double the cost since we
2091      add a [rPIC+...] offset.  A GOT-less symbol uses a BDAP prefix
2092      equivalent to the DIP prefix for non-PIC, hence the same cost.  */
2093   if (CONSTANT_P (x))
2094     return flag_pic && cris_got_symbol (x) ? 2 * (2 + 4) / 2 : (2 + 4) / 2;
2095
2096   /* Handle BIAP and BDAP prefixes.  */
2097   if (GET_CODE (x) == PLUS)
2098     {
2099       rtx tem1 = XEXP (x, 0);
2100       rtx tem2 = XEXP (x, 1);
2101
2102     /* A BIAP is 2 extra bytes for the prefix insn, nothing more.  We
2103        recognize the typical MULT which is always in tem1 because of
2104        insn canonicalization.  */
2105     if ((GET_CODE (tem1) == MULT && BIAP_INDEX_P (tem1))
2106         || REG_P (tem1))
2107       return 2 / 2;
2108
2109     /* A BDAP (quick) is 2 extra bytes.  Any constant operand to the
2110        PLUS is always found in tem2.  */
2111     if (GET_CODE (tem2) == CONST_INT
2112         && INTVAL (tem2) < 128 && INTVAL (tem2) >= -128)
2113       return 2 / 2;
2114
2115     /* A BDAP -32768 .. 32767 is like BDAP quick, but with 2 extra
2116        bytes.  */
2117     if (GET_CODE (tem2) == CONST_INT
2118         && CONST_OK_FOR_LETTER_P (INTVAL (tem2), 'L'))
2119       return (2 + 2) / 2;
2120
2121     /* A BDAP with some other constant is 2 bytes extra.  */
2122     if (CONSTANT_P (tem2))
2123       return (2 + 2 + 2) / 2;
2124
2125     /* BDAP with something indirect should have a higher cost than
2126        BIAP with register.   FIXME: Should it cost like a MEM or more?  */
2127     /* Don't need to check it, it's the only one left.
2128        FIXME:  There was a REG test missing, perhaps there are others.
2129        Think more.  */
2130     return (2 + 2 + 2) / 2;
2131   }
2132
2133   /* What else?  Return a high cost.  It matters only for valid
2134      addressing modes.  */
2135   return 10;
2136 }
2137
2138 /* Check various objections to the side-effect.  Used in the test-part
2139    of an anonymous insn describing an insn with a possible side-effect.
2140    Returns nonzero if the implied side-effect is ok.
2141
2142    code     : PLUS or MULT
2143    ops      : An array of rtx:es. lreg, rreg, rval,
2144               The variables multop and other_op are indexes into this,
2145               or -1 if they are not applicable.
2146    lreg     : The register that gets assigned in the side-effect.
2147    rreg     : One register in the side-effect expression
2148    rval     : The other register, or an int.
2149    multop   : An integer to multiply rval with.
2150    other_op : One of the entities of the main effect,
2151               whose mode we must consider.  */
2152
2153 int
2154 cris_side_effect_mode_ok (code, ops, lreg, rreg, rval, multop, other_op)
2155      enum rtx_code code;
2156      rtx *ops;
2157      int lreg, rreg, rval, multop, other_op;
2158 {
2159   /* Find what value to multiply with, for rx =ry + rz * n.  */
2160   int mult = multop < 0 ? 1 : INTVAL (ops[multop]);
2161
2162   rtx reg_rtx = ops[rreg];
2163   rtx val_rtx = ops[rval];
2164
2165   /* The operands may be swapped.  Canonicalize them in reg_rtx and
2166      val_rtx, where reg_rtx always is a reg (for this constraint to
2167      match).  */
2168   if (! BASE_P (reg_rtx))
2169     reg_rtx = val_rtx, val_rtx = ops[rreg];
2170
2171   /* Don't forget to check that reg_rtx really is a reg.  If it isn't,
2172      we have no business.  */
2173   if (! BASE_P (reg_rtx))
2174     return 0;
2175
2176   /* Don't do this when -mno-split.  */
2177   if (!TARGET_SIDE_EFFECT_PREFIXES)
2178     return 0;
2179
2180   /* The mult expression may be hidden in lreg.  FIXME:  Add more
2181      commentary about that.  */
2182   if (GET_CODE (val_rtx) == MULT)
2183     {
2184       mult = INTVAL (XEXP (val_rtx, 1));
2185       val_rtx = XEXP (val_rtx, 0);
2186       code = MULT;
2187     }
2188
2189   /* First check the "other operand".  */
2190   if (other_op >= 0)
2191     {
2192       if (GET_MODE_SIZE (GET_MODE (ops[other_op])) > UNITS_PER_WORD)
2193         return 0;
2194
2195       /* Check if the lvalue register is the same as the "other
2196          operand".  If so, the result is undefined and we shouldn't do
2197          this.  FIXME:  Check again.  */
2198       if ((BASE_P (ops[lreg])
2199            && BASE_P (ops[other_op])
2200            && REGNO (ops[lreg]) == REGNO (ops[other_op]))
2201           || rtx_equal_p (ops[other_op], ops[lreg]))
2202       return 0;
2203     }
2204
2205   /* Do not accept frame_pointer_rtx as any operand.  */
2206   if (ops[lreg] == frame_pointer_rtx || ops[rreg] == frame_pointer_rtx
2207       || ops[rval] == frame_pointer_rtx
2208       || (other_op >= 0 && ops[other_op] == frame_pointer_rtx))
2209     return 0;
2210
2211   if (code == PLUS
2212       && ! BASE_P (val_rtx))
2213     {
2214
2215       /* Do not allow rx = rx + n if a normal add or sub with same size
2216          would do.  */
2217       if (rtx_equal_p (ops[lreg], reg_rtx)
2218           && GET_CODE (val_rtx) == CONST_INT
2219           && (INTVAL (val_rtx) <= 63 && INTVAL (val_rtx) >= -63))
2220         return 0;
2221
2222       /* Check allowed cases, like [r(+)?].[bwd] and const.
2223          A symbol is not allowed with PIC.  */
2224       if (CONSTANT_P (val_rtx))
2225         return flag_pic == 0 || cris_symbol (val_rtx) == 0;
2226
2227       if (GET_CODE (val_rtx) == MEM
2228           && BASE_OR_AUTOINCR_P (XEXP (val_rtx, 0)))
2229         return 1;
2230
2231       if (GET_CODE (val_rtx) == SIGN_EXTEND
2232           && GET_CODE (XEXP (val_rtx, 0)) == MEM
2233           && BASE_OR_AUTOINCR_P (XEXP (XEXP (val_rtx, 0), 0)))
2234         return 1;
2235
2236       /* If we got here, it's not a valid addressing mode.  */
2237       return 0;
2238     }
2239   else if (code == MULT
2240            || (code == PLUS && BASE_P (val_rtx)))
2241     {
2242       /* Do not allow rx = rx + ry.S, since it doesn't give better code.  */
2243       if (rtx_equal_p (ops[lreg], reg_rtx)
2244           || (mult == 1 && rtx_equal_p (ops[lreg], val_rtx)))
2245         return 0;
2246
2247       /* Do not allow bad multiply-values.  */
2248       if (mult != 1 && mult != 2 && mult != 4)
2249         return 0;
2250
2251       /* Only allow  r + ...  */
2252       if (! BASE_P (reg_rtx))
2253         return 0;
2254
2255       /* If we got here, all seems ok.
2256          (All checks need to be done above).  */
2257       return 1;
2258     }
2259
2260   /* If we get here, the caller got its initial tests wrong.  */
2261   internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
2262 }
2263
2264 /* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
2265    does not handle the case where the IN operand is strict_low_part; it
2266    does handle it for X.  Test-case in Axis-20010516.  This function takes
2267    care of that for THIS port.  FIXME: strict_low_part is going away
2268    anyway.  */
2269
2270 static int
2271 cris_reg_overlap_mentioned_p (x, in)
2272      rtx x, in;
2273 {
2274   /* The function reg_overlap_mentioned now handles when X is
2275      strict_low_part, but not when IN is a STRICT_LOW_PART.  */
2276   if (GET_CODE (in) == STRICT_LOW_PART)
2277     in = XEXP (in, 0);
2278
2279   return reg_overlap_mentioned_p (x, in);
2280 }
2281
2282 /* The TARGET_ASM_NAMED_SECTION worker.
2283    We just dispatch to the functions for ELF and a.out.  */
2284
2285 void
2286 cris_target_asm_named_section (name, flags)
2287      const char *name;
2288      unsigned int flags;
2289 {
2290   if (! TARGET_ELF)
2291     default_no_named_section (name, flags);
2292   else
2293     default_elf_asm_named_section (name, flags);
2294 }
2295
2296 /* The LEGITIMATE_PIC_OPERAND_P worker.  */
2297
2298 int
2299 cris_legitimate_pic_operand (x)
2300      rtx x;
2301 {
2302   /* The PIC representation of a symbol with a GOT entry will be (for
2303      example; relocations differ):
2304       sym => [rPIC+sym:GOT]
2305      and for a GOT-less symbol it will be (for example, relocation differ):
2306       sym => rPIC+sym:GOTOFF
2307      so only a symbol with a GOT is by itself a valid operand, and it
2308      can't be a sum of a symbol and an offset.  */
2309   return ! cris_symbol (x) || cris_got_symbol (x);
2310 }
2311
2312 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2313    CONSTANT_P.  */
2314
2315 int
2316 cris_symbol (x)
2317      rtx x;
2318 {
2319   switch (GET_CODE (x))
2320     {
2321     case SYMBOL_REF:
2322     case LABEL_REF:
2323       return 1;
2324
2325     case UNSPEC:
2326       /* A PLT reference.  */
2327       ASSERT_PLT_UNSPEC (x);
2328       return 1;
2329
2330     case CONST:
2331       return cris_symbol (XEXP (x, 0));
2332
2333     case PLUS:
2334     case MINUS:
2335       return cris_symbol (XEXP (x, 0)) || cris_symbol (XEXP (x, 1));
2336
2337     case CONST_INT:
2338     case CONST_DOUBLE:
2339     case CONSTANT_P_RTX:
2340       return 0;
2341
2342     default:
2343       fatal_insn ("unrecognized supposed constant", x);
2344     }
2345
2346   return 1;
2347 }
2348
2349 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2350    CONSTANT_P, and the symbol does not need a GOT entry.  Also set
2351    current_function_uses_pic_offset_table if we're generating PIC and ever
2352    see something that would need one.  */
2353
2354 int
2355 cris_gotless_symbol (x)
2356      rtx x;
2357 {
2358   switch (GET_CODE (x))
2359     {
2360     case UNSPEC:
2361       ASSERT_PLT_UNSPEC (x);
2362       return 1;
2363
2364     case SYMBOL_REF:
2365       if (flag_pic && cfun != NULL)
2366         current_function_uses_pic_offset_table = 1;
2367       return SYMBOL_REF_FLAG (x);
2368
2369     case LABEL_REF:
2370       /* We don't set current_function_uses_pic_offset_table for
2371          LABEL_REF:s in here, since they are almost always originating
2372          from some branch.  The only time it does not come from a label is
2373          when GCC does something like __builtin_setjmp.  Then we get the
2374          LABEL_REF from the movsi expander, so we mark it there as a
2375          special case.  */
2376       return 1;
2377
2378     case CONST:
2379       return cris_gotless_symbol (XEXP (x, 0));
2380
2381     case PLUS:
2382     case MINUS:
2383       {
2384         int x0 = cris_gotless_symbol (XEXP (x, 0)) != 0;
2385         int x1 = cris_gotless_symbol (XEXP (x, 1)) != 0;
2386
2387         /* One and only one of them must be a local symbol.  Neither must
2388            be some other, more general kind of symbol.  */
2389         return
2390           (x0 ^ x1)
2391           && ! (x0 == 0 && cris_symbol (XEXP (x, 0)))
2392           && ! (x1 == 0 && cris_symbol (XEXP (x, 1)));
2393       }
2394
2395     case CONST_INT:
2396     case CONST_DOUBLE:
2397     case CONSTANT_P_RTX:
2398       return 0;
2399
2400     default:
2401       fatal_insn ("unrecognized supposed constant", x);
2402     }
2403
2404   return 1;
2405 }
2406
2407 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2408    CONSTANT_P, and the symbol needs a GOT entry.  */
2409
2410 int
2411 cris_got_symbol (x)
2412      rtx x;
2413 {
2414   switch (GET_CODE (x))
2415     {
2416     case UNSPEC:
2417       ASSERT_PLT_UNSPEC (x);
2418       return 0;
2419
2420     case SYMBOL_REF:
2421       if (flag_pic && cfun != NULL)
2422         current_function_uses_pic_offset_table = 1;
2423       return ! SYMBOL_REF_FLAG (x);
2424
2425     case CONST:
2426       return cris_got_symbol (XEXP (x, 0));
2427
2428     case LABEL_REF:
2429       /* A LABEL_REF is never visible as a symbol outside the local
2430          function.  */
2431     case PLUS:
2432     case MINUS:
2433       /* Nope, can't access the GOT for "symbol + offset".  */
2434       return 0;
2435
2436     case CONST_INT:
2437     case CONST_DOUBLE:
2438     case CONSTANT_P_RTX:
2439       return 0;
2440
2441     default:
2442       fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
2443                   x);
2444     }
2445
2446   return 1;
2447 }
2448
2449 /* The OVERRIDE_OPTIONS worker.
2450    As is the norm, this also parses -mfoo=bar type parameters.  */
2451
2452 void
2453 cris_override_options ()
2454 {
2455   if (cris_max_stackframe_str)
2456     {
2457       cris_max_stackframe = atoi (cris_max_stackframe_str);
2458
2459       /* Do some sanity checking.  */
2460       if (cris_max_stackframe < 0 || cris_max_stackframe > 0x20000000)
2461         internal_error ("-max-stackframe=%d is not usable, not between 0 and %d",
2462                         cris_max_stackframe, 0x20000000);
2463     }
2464
2465   /* Let "-metrax4" and "-metrax100" change the cpu version.  */
2466   if (TARGET_SVINTO && cris_cpu_version < CRIS_CPU_SVINTO)
2467     cris_cpu_version = CRIS_CPU_SVINTO;
2468   else if (TARGET_ETRAX4_ADD && cris_cpu_version < CRIS_CPU_ETRAX4)
2469     cris_cpu_version = CRIS_CPU_ETRAX4;
2470
2471   /* Parse -march=... and its synonym, the deprecated -mcpu=...  */
2472   if (cris_cpu_str)
2473     {
2474       cris_cpu_version
2475         = (*cris_cpu_str == 'v' ? atoi (cris_cpu_str + 1) : -1);
2476
2477       if (strcmp ("etrax4", cris_cpu_str) == 0)
2478         cris_cpu_version = 3;
2479
2480       if (strcmp ("svinto", cris_cpu_str) == 0
2481           || strcmp ("etrax100", cris_cpu_str) == 0)
2482         cris_cpu_version = 8;
2483
2484       if (strcmp ("ng", cris_cpu_str) == 0
2485           || strcmp ("etrax100lx", cris_cpu_str) == 0)
2486         cris_cpu_version = 10;
2487
2488       if (cris_cpu_version < 0 || cris_cpu_version > 10)
2489         error ("unknown CRIS version specification in -march= or -mcpu= : %s",
2490                cris_cpu_str);
2491
2492       /* Set the target flags.  */
2493       if (cris_cpu_version >= CRIS_CPU_ETRAX4)
2494         target_flags |= TARGET_MASK_ETRAX4_ADD;
2495
2496       /* If this is Svinto or higher, align for 32 bit accesses.  */
2497       if (cris_cpu_version >= CRIS_CPU_SVINTO)
2498         target_flags
2499           |= (TARGET_MASK_SVINTO | TARGET_MASK_ALIGN_BY_32
2500               | TARGET_MASK_STACK_ALIGN | TARGET_MASK_CONST_ALIGN
2501               | TARGET_MASK_DATA_ALIGN);
2502
2503       /* Note that we do not add new flags when it can be completely
2504          described with a macro that uses -mcpu=X.  So
2505          TARGET_HAS_MUL_INSNS is (cris_cpu_version >= CRIS_CPU_NG).  */
2506     }
2507
2508   if (cris_tune_str)
2509     {
2510       int cris_tune
2511         = (*cris_tune_str == 'v' ? atoi (cris_tune_str + 1) : -1);
2512
2513       if (strcmp ("etrax4", cris_tune_str) == 0)
2514         cris_tune = 3;
2515
2516       if (strcmp ("svinto", cris_tune_str) == 0
2517           || strcmp ("etrax100", cris_tune_str) == 0)
2518         cris_tune = 8;
2519
2520       if (strcmp ("ng", cris_tune_str) == 0
2521           || strcmp ("etrax100lx", cris_tune_str) == 0)
2522         cris_tune = 10;
2523
2524       if (cris_tune < 0 || cris_tune > 10)
2525         error ("unknown CRIS cpu version specification in -mtune= : %s",
2526                cris_tune_str);
2527
2528       if (cris_tune >= CRIS_CPU_SVINTO)
2529         /* We have currently nothing more to tune than alignment for
2530            memory accesses.  */
2531         target_flags
2532           |= (TARGET_MASK_STACK_ALIGN | TARGET_MASK_CONST_ALIGN
2533               | TARGET_MASK_DATA_ALIGN | TARGET_MASK_ALIGN_BY_32);
2534     }
2535
2536   if (flag_pic)
2537     {
2538       /* Use error rather than warning, so invalid use is easily
2539          detectable.  Still change to the values we expect, to avoid
2540          further errors.  */
2541       if (! TARGET_LINUX)
2542         {
2543           error ("-fPIC not supported in this configuration");
2544           flag_pic = 0;
2545         }
2546
2547       /* Turn off function CSE.  We need to have the addresses reach the
2548          call expanders to get PLT-marked, as they could otherwise be
2549          compared against zero directly or indirectly.  After visiting the
2550          call expanders they will then be cse:ed, as the call expanders
2551          force_reg the addresses, effectively forcing flag_no_function_cse
2552          to 0.  */
2553       flag_no_function_cse = 1;
2554     }
2555
2556   if ((write_symbols == DWARF_DEBUG
2557        || write_symbols == DWARF2_DEBUG) && ! TARGET_ELF)
2558     {
2559       warning ("that particular -g option is invalid with -maout and -melinux");
2560       write_symbols = DBX_DEBUG;
2561     }
2562
2563   /* Set the per-function-data initializer.  */
2564   init_machine_status = cris_init_machine_status;
2565 }
2566
2567 /* The ASM_OUTPUT_MI_THUNK worker.  */
2568
2569 void
2570 cris_asm_output_mi_thunk (stream, thunkdecl, delta, funcdecl)
2571      FILE *stream;
2572      tree thunkdecl ATTRIBUTE_UNUSED;
2573      int delta;
2574      tree funcdecl;
2575 {
2576   if (delta > 0)
2577     asm_fprintf (stream, "\tadd%s %d,$%s\n",
2578                  ADDITIVE_SIZE_MODIFIER (delta), delta,
2579                  reg_names[CRIS_FIRST_ARG_REG]);
2580   else if (delta < 0)
2581     asm_fprintf (stream, "\tsub%s %d,$%s\n",
2582                  ADDITIVE_SIZE_MODIFIER (-delta), -delta,
2583                  reg_names[CRIS_FIRST_ARG_REG]);
2584
2585   if (flag_pic)
2586     {
2587       const char *name = XSTR (XEXP (DECL_RTL (funcdecl), 0), 0);
2588
2589       STRIP_NAME_ENCODING (name, name);
2590       fprintf (stream, "add.d ");
2591       assemble_name (stream, name);
2592       fprintf (stream, "%s,$pc\n", CRIS_PLT_PCOFFSET_SUFFIX);
2593     }
2594   else
2595     {
2596       fprintf (stream, "jump ");
2597       assemble_name (stream, XSTR (XEXP (DECL_RTL (funcdecl), 0), 0));
2598       fprintf (stream, "\n");
2599     }
2600 }
2601
2602 /* The EXPAND_BUILTIN_VA_ARG worker.  This is modified from the
2603    "standard" implementation of va_arg: read the value from the current
2604    address and increment by the size of one or two registers.  The
2605    important difference for CRIS is that if the type is
2606    pass-by-reference, then perform an indirection.  */
2607
2608 rtx
2609 cris_expand_builtin_va_arg (valist, type)
2610      tree valist;
2611      tree type;
2612 {
2613   tree addr_tree, t;
2614   rtx addr;
2615   enum machine_mode mode = TYPE_MODE (type);
2616   int passed_size;
2617
2618   /* Get AP.  */
2619   addr_tree = valist;
2620
2621   /* Check if the type is passed by value or by reference.  */
2622   if (MUST_PASS_IN_STACK (mode, type)
2623       || CRIS_FUNCTION_ARG_SIZE (mode, type) > 8)
2624     {
2625       tree type_ptr = build_pointer_type (type);
2626       addr_tree = build1 (INDIRECT_REF, type_ptr, addr_tree);
2627       passed_size = 4;
2628     }
2629   else
2630     passed_size = (CRIS_FUNCTION_ARG_SIZE (mode, type) > 4) ? 8 : 4;
2631
2632   addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
2633   addr = copy_to_reg (addr);
2634
2635   /* Compute new value for AP.  */
2636   t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
2637              build (PLUS_EXPR, TREE_TYPE (valist), valist,
2638                     build_int_2 (passed_size, 0)));
2639   TREE_SIDE_EFFECTS (t) = 1;
2640   expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2641
2642   return addr;
2643 }
2644
2645 /* The INIT_EXPANDERS worker sets the per-function-data initializer and
2646    mark functions.  */
2647
2648 void
2649 cris_init_expanders ()
2650 {
2651   /* Nothing here at the moment.  */
2652 }
2653
2654 /* Zero initialization is OK for all current fields.  */
2655
2656 static void
2657 cris_init_machine_status (p)
2658      struct function *p;
2659 {
2660   p->machine = xcalloc (1, sizeof (struct machine_function));
2661 }
2662
2663 /* Split a 2 word move (DI or presumably DF) into component parts.
2664    Originally a copy of gen_split_move_double in m32r.c.  */
2665
2666 rtx
2667 cris_split_movdx (operands)
2668      rtx *operands;
2669 {
2670   enum machine_mode mode = GET_MODE (operands[0]);
2671   rtx dest = operands[0];
2672   rtx src  = operands[1];
2673   rtx val;
2674
2675   /* We used to have to handle (SUBREG (MEM)) here, but that should no
2676      longer happen; after reload there are no SUBREGs any more, and we're
2677      only called after reload.  */
2678   if (GET_CODE (dest) == SUBREG || GET_CODE (src) == SUBREG)
2679     abort ();
2680
2681   start_sequence ();
2682   if (GET_CODE (dest) == REG)
2683     {
2684       int dregno = REGNO (dest);
2685
2686       /* Reg-to-reg copy.  */
2687       if (GET_CODE (src) == REG)
2688         {
2689           int sregno = REGNO (src);
2690
2691           int reverse = (dregno == sregno + 1);
2692
2693           /* We normally copy the low-numbered register first.  However, if
2694              the first register operand 0 is the same as the second register of
2695              operand 1, we must copy in the opposite order.  */
2696           emit_insn (gen_rtx_SET (VOIDmode,
2697                                   operand_subword (dest, reverse, TRUE, mode),
2698                                   operand_subword (src, reverse, TRUE, mode)));
2699
2700           emit_insn (gen_rtx_SET (VOIDmode,
2701                                   operand_subword (dest, !reverse, TRUE, mode),
2702                                   operand_subword (src, !reverse, TRUE, mode)));
2703         }
2704       /* Constant-to-reg copy.  */
2705       else if (GET_CODE (src) == CONST_INT || GET_CODE (src) == CONST_DOUBLE)
2706         {
2707           rtx words[2];
2708           split_double (src, &words[0], &words[1]);
2709           emit_insn (gen_rtx_SET (VOIDmode,
2710                                   operand_subword (dest, 0, TRUE, mode),
2711                                   words[0]));
2712
2713           emit_insn (gen_rtx_SET (VOIDmode,
2714                                   operand_subword (dest, 1, TRUE, mode),
2715                                   words[1]));
2716         }
2717       /* Mem-to-reg copy.  */
2718       else if (GET_CODE (src) == MEM)
2719         {
2720           /* If the high-address word is used in the address, we must load it
2721              last.  Otherwise, load it first.  */
2722           rtx addr = XEXP (src, 0);
2723           int reverse
2724             = (refers_to_regno_p (dregno, dregno + 1, addr, NULL) != 0);
2725
2726           /* The original code imples that we can't do
2727              move.x [rN+],rM  move.x [rN],rM+1
2728              when rN is dead, because of REG_NOTES damage.  That is
2729              consistent with what I've seen, so don't try it.
2730
2731              We have two different cases here; if the addr is POST_INC,
2732              just pass it through, otherwise add constants.  */
2733
2734           if (GET_CODE (addr) == POST_INC)
2735             {
2736               emit_insn (gen_rtx_SET (VOIDmode,
2737                                       operand_subword (dest, 0, TRUE, mode),
2738                                       change_address (src, SImode, addr)));
2739               emit_insn (gen_rtx_SET (VOIDmode,
2740                                       operand_subword (dest, 1, TRUE, mode),
2741                                       change_address (src, SImode, addr)));
2742             }
2743           else
2744             {
2745               /* Make sure we don't get any other addresses with
2746                  embedded postincrements.  They should be stopped in
2747                  GO_IF_LEGITIMATE_ADDRESS, but we're here for your
2748                  safety.  */
2749               if (side_effects_p (addr))
2750                 fatal_insn ("unexpected side-effects in address", addr);
2751
2752               emit_insn (gen_rtx_SET
2753                          (VOIDmode,
2754                           operand_subword (dest, reverse, TRUE, mode),
2755                           change_address
2756                           (src, SImode,
2757                            plus_constant (addr,
2758                                           reverse * UNITS_PER_WORD))));
2759               emit_insn (gen_rtx_SET
2760                          (VOIDmode,
2761                           operand_subword (dest, ! reverse, TRUE, mode),
2762                           change_address
2763                           (src, SImode,
2764                            plus_constant (addr,
2765                                           (! reverse) *
2766                                           UNITS_PER_WORD))));
2767             }
2768         }
2769       else
2770         abort ();
2771     }
2772   /* Reg-to-mem copy or clear mem.  */
2773   else if (GET_CODE (dest) == MEM
2774            && (GET_CODE (src) == REG
2775                || src == const0_rtx
2776                || src == CONST0_RTX (DFmode)))
2777     {
2778       rtx addr = XEXP (dest, 0);
2779
2780       if (GET_CODE (addr) == POST_INC)
2781         {
2782           emit_insn (gen_rtx_SET (VOIDmode,
2783                                   change_address (dest, SImode, addr),
2784                                   operand_subword (src, 0, TRUE, mode)));
2785           emit_insn (gen_rtx_SET (VOIDmode,
2786                                   change_address (dest, SImode, addr),
2787                                   operand_subword (src, 1, TRUE, mode)));
2788         }
2789       else
2790         {
2791           /* Make sure we don't get any other addresses with embedded
2792              postincrements.  They should be stopped in
2793              GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety.  */
2794           if (side_effects_p (addr))
2795             fatal_insn ("unexpected side-effects in address", addr);
2796
2797           emit_insn (gen_rtx_SET
2798                      (VOIDmode,
2799                       change_address (dest, SImode, addr),
2800                       operand_subword (src, 0, TRUE, mode)));
2801
2802           emit_insn (gen_rtx_SET
2803                      (VOIDmode,
2804                       change_address (dest, SImode,
2805                                       plus_constant (addr,
2806                                                      UNITS_PER_WORD)),
2807                       operand_subword (src, 1, TRUE, mode)));
2808         }
2809     }
2810
2811   else
2812     abort ();
2813
2814   val = gen_sequence ();
2815   end_sequence ();
2816   return val;
2817 }
2818
2819 /* This is in essence a copy of output_addr_const altered to output
2820    symbolic operands as PIC.
2821
2822    FIXME: Add hooks similar to ASM_OUTPUT_SYMBOL_REF to get this effect in
2823    the "real" output_addr_const.  All we need is one for LABEL_REF (and
2824    one for CODE_LABEL?).  */
2825
2826 void
2827 cris_output_addr_const (file, x)
2828      FILE *file;
2829      rtx x;
2830 {
2831   int is_plt = 0;
2832
2833 restart:
2834   switch (GET_CODE (x))
2835     {
2836     case UNSPEC:
2837       ASSERT_PLT_UNSPEC (x);
2838       x = XVECEXP (x, 0, 0);
2839       is_plt = 1;
2840
2841       /* Fall through.  */
2842     case SYMBOL_REF:
2843       if (flag_pic)
2844         {
2845           const char *origstr = XSTR (x, 0);
2846           const char *str;
2847
2848           STRIP_NAME_ENCODING (str, origstr);
2849
2850           if (is_plt)
2851             {
2852               if (cris_pic_sympart_only)
2853                 {
2854                   assemble_name (file, str);
2855                   fprintf (file, ":PLTG");
2856                 }
2857               else
2858                 {
2859                   if (TARGET_AVOID_GOTPLT)
2860                     /* We shouldn't get here.  */
2861                     abort ();
2862
2863                   fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
2864                   assemble_name (file, XSTR (x, 0));
2865
2866                   if (flag_pic == 1)
2867                     fprintf (file, ":GOTPLT16]");
2868                   else
2869                     fprintf (file, ":GOTPLT]");
2870                 }
2871             }
2872           else if (cris_gotless_symbol (x))
2873             {
2874               if (! cris_pic_sympart_only)
2875                 fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
2876               assemble_name (file, str);
2877               fprintf (file, ":GOTOFF");
2878             }
2879           else if (cris_got_symbol (x))
2880             {
2881               if (cris_pic_sympart_only)
2882                 abort ();
2883               fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
2884               assemble_name (file, XSTR (x, 0));
2885
2886               if (flag_pic == 1)
2887                 fprintf (file, ":GOT16]");
2888               else
2889                 fprintf (file, ":GOT]");
2890             }
2891           else
2892             LOSE_AND_RETURN ("unexpected PIC symbol", x);
2893
2894           /* Sanity check.  */
2895           if (! current_function_uses_pic_offset_table)
2896             output_operand_lossage ("PIC register isn't set up");
2897         }
2898       else
2899         assemble_name (file, XSTR (x, 0));
2900       break;
2901
2902     case LABEL_REF:
2903       /* If we get one of those here, it should be dressed as PIC.  Branch
2904          labels are normally output with the 'l' specifier, which means it
2905          will go directly to output_asm_label and not end up here.  */
2906       if (GET_CODE (XEXP (x, 0)) != CODE_LABEL
2907           && (GET_CODE (XEXP (x, 0)) != NOTE
2908               || NOTE_LINE_NUMBER (XEXP (x, 0)) != NOTE_INSN_DELETED_LABEL))
2909         fatal_insn ("unexpected address expression", x);
2910
2911       if (flag_pic)
2912         {
2913           if (cris_gotless_symbol (x))
2914             {
2915               if (! cris_pic_sympart_only)
2916                 fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
2917               cris_output_addr_const (file, XEXP (x, 0));
2918
2919               fprintf (file, ":GOTOFF");
2920             }
2921           else
2922             /* Labels are never marked as global symbols.  */
2923             fatal_insn ("unexpected PIC symbol", x);
2924
2925           /* Sanity check.  */
2926           if (! current_function_uses_pic_offset_table)
2927             internal_error ("emitting PIC operand, but PIC register isn't set up");
2928           break;
2929         }
2930
2931       output_addr_const (file, x);
2932       break;
2933
2934     case NOTE:
2935       if (NOTE_LINE_NUMBER (x) != NOTE_INSN_DELETED_LABEL)
2936         fatal_insn ("unexpected NOTE as addr_const:", x);
2937     case CODE_LABEL:
2938     case CONST_INT:
2939     case CONST_DOUBLE:
2940     case ZERO_EXTEND:
2941     case SIGN_EXTEND:
2942       output_addr_const (file, x);
2943       break;
2944
2945     case CONST:
2946       /* This used to output parentheses around the expression,
2947          but that does not work on the 386 (either ATT or BSD assembler).  */
2948       cris_output_addr_const (file, XEXP (x, 0));
2949       break;
2950
2951     case PLUS:
2952       /* Some assemblers need integer constants to appear last (eg masm).  */
2953       if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2954         {
2955           cris_output_addr_const (file, XEXP (x, 1));
2956           if (INTVAL (XEXP (x, 0)) >= 0)
2957             fprintf (file, "+");
2958           output_addr_const (file, XEXP (x, 0));
2959         }
2960       else
2961         {
2962           cris_output_addr_const (file, XEXP (x, 0));
2963           if (GET_CODE (XEXP (x, 1)) != CONST_INT
2964               || INTVAL (XEXP (x, 1)) >= 0)
2965             fprintf (file, "+");
2966           cris_output_addr_const (file, XEXP (x, 1));
2967         }
2968       break;
2969
2970     case MINUS:
2971       /* Avoid outputting things like x-x or x+5-x,
2972          since some assemblers can't handle that.  */
2973       x = simplify_subtraction (x);
2974       if (GET_CODE (x) != MINUS)
2975         goto restart;
2976
2977       cris_output_addr_const (file, XEXP (x, 0));
2978       fprintf (file, "-");
2979       if ((GET_CODE (XEXP (x, 1)) == CONST_INT
2980            && INTVAL (XEXP (x, 1)) < 0)
2981           || GET_CODE (XEXP (x, 1)) != CONST_INT)
2982         {
2983           fprintf (file, "%s", targetm.asm_out.open_paren);
2984           cris_output_addr_const (file, XEXP (x, 1));
2985           fprintf (file, "%s", targetm.asm_out.close_paren);
2986         }
2987       else
2988         output_addr_const (file, XEXP (x, 1));
2989       break;
2990
2991     default:
2992       LOSE_AND_RETURN ("unexpected address expression", x);
2993     }
2994 }
2995
2996 /* The ENCODE_SECTION_INFO worker.  Code-in whether we can get away
2997    without a GOT entry (needed for externally visible objects but not for
2998    functions) into SYMBOL_REF_FLAG and add the PLT suffix for global
2999    functions.  */
3000
3001 void
3002 cris_encode_section_info (exp, first)
3003      tree exp;
3004      int first ATTRIBUTE_UNUSED;
3005 {
3006   if (flag_pic)
3007     {
3008       if (DECL_P (exp))
3009         {
3010           if (TREE_CODE (exp) == FUNCTION_DECL
3011               && (TREE_PUBLIC (exp) || DECL_WEAK (exp)))
3012             SYMBOL_REF_FLAG (XEXP (DECL_RTL (exp), 0)) = 0;
3013           else
3014             SYMBOL_REF_FLAG (XEXP (DECL_RTL (exp), 0))
3015               = ! TREE_PUBLIC (exp) && ! DECL_WEAK (exp);
3016         }
3017       else
3018         /* Others are local entities.  */
3019         SYMBOL_REF_FLAG (XEXP (TREE_CST_RTL (exp), 0)) = 1;
3020     }
3021 }
3022
3023 #if 0
3024 /* Various small functions to replace macros.  Only called from a
3025    debugger.  They might collide with gcc functions or system functions,
3026    so only emit them when '#if 1' above.  */
3027
3028 enum rtx_code Get_code PARAMS ((rtx));
3029
3030 enum rtx_code
3031 Get_code (x)
3032      rtx x;
3033 {
3034   return GET_CODE (x);
3035 }
3036
3037 const char *Get_mode PARAMS ((rtx));
3038
3039 const char *
3040 Get_mode (x)
3041      rtx x;
3042 {
3043   return GET_MODE_NAME (GET_MODE (x));
3044 }
3045
3046 rtx Xexp PARAMS ((rtx, int));
3047
3048 rtx
3049 Xexp (x, n)
3050      rtx x;
3051      int n;
3052 {
3053   return XEXP (x, n);
3054 }
3055
3056 rtx Xvecexp PARAMS ((rtx, int, int));
3057
3058 rtx
3059 Xvecexp (x, n, m)
3060      rtx x;
3061      int n;
3062 {
3063   return XVECEXP (x, n, m);
3064 }
3065
3066 int Get_rtx_len PARAMS ((rtx));
3067
3068 int
3069 Get_rtx_len (x)
3070      rtx x;
3071 {
3072   return GET_RTX_LENGTH (GET_CODE (x));
3073 }
3074
3075 /* Use upper-case to distinguish from local variables that are sometimes
3076    called next_insn and prev_insn.  */
3077
3078 rtx Next_insn PARAMS ((rtx));
3079
3080 rtx
3081 Next_insn (insn)
3082      rtx insn;
3083 {
3084   return NEXT_INSN (insn);
3085 }
3086
3087 rtx Prev_insn PARAMS ((rtx));
3088
3089 rtx
3090 Prev_insn (insn)
3091      rtx insn;
3092 {
3093   return PREV_INSN (insn);
3094 }
3095 #endif
3096
3097 /*
3098  * Local variables:
3099  * eval: (c-set-style "gnu")
3100  * indent-tabs-mode: t
3101  * End:
3102  */