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 == (int) 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 == (int) 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 == (int) 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 *const 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",
1456                    INTVAL (x) & ((unsigned int) 0x7fffffff * 2 + 1));
1457           return;
1458         }
1459       /* Otherwise the least significant part equals the normal part,
1460          so handle it normally.  */
1461       break;
1462
1463     case 'A':
1464       /* When emitting an add for the high part of a DImode constant, we
1465          want to use addq for 0 and adds.w for -1.  */
1466       if (GET_CODE (operand) != CONST_INT)
1467         LOSE_AND_RETURN ("invalid operand for 'A' modifier", x);
1468       fprintf (file, INTVAL (operand) < 0 ? "adds.w" : "addq");
1469       return;
1470
1471     case 'D':
1472       /* When emitting an sub for the high part of a DImode constant, we
1473          want to use subq for 0 and subs.w for -1.  */
1474       if (GET_CODE (operand) != CONST_INT)
1475         LOSE_AND_RETURN ("invalid operand for 'D' modifier", x);
1476       fprintf (file, INTVAL (operand) < 0 ? "subs.w" : "subq");
1477       return;
1478
1479     case 'S':
1480       /* Print the operand as the index-part of an address.
1481          Easiest way out is to use cris_print_index.  */
1482       cris_print_index (operand, file);
1483       return;
1484
1485     case 'T':
1486       /* Print the size letter for an operand to a MULT, which must be a
1487          const_int with a suitable value.  */
1488       if (GET_CODE (operand) != CONST_INT || INTVAL (operand) > 4)
1489         LOSE_AND_RETURN ("invalid operand for 'T' modifier", x);
1490       fprintf (file, "%s", mults[INTVAL (operand)]);
1491       return;
1492
1493     case 0:
1494       /* No code, print as usual.  */
1495       break;
1496
1497     default:
1498       LOSE_AND_RETURN ("invalid operand modifier letter", x);
1499     }
1500
1501   /* Print an operand as without a modifier letter.  */
1502   switch (GET_CODE (operand))
1503     {
1504     case REG:
1505       if (REGNO (operand) > 15)
1506         internal_error ("internal error: bad register: %d", REGNO (operand));
1507       fprintf (file, "$%s", reg_names[REGNO (operand)]);
1508       return;
1509
1510     case MEM:
1511       output_address (XEXP (operand, 0));
1512       return;
1513
1514     case CONST_DOUBLE:
1515       if (GET_MODE (operand) == VOIDmode)
1516         /* A long long constant.  */
1517         output_addr_const (file, operand);
1518       else
1519         {
1520           /* Only single precision is allowed as plain operands the
1521              moment.  FIXME:  REAL_VALUE_FROM_CONST_DOUBLE isn't
1522              documented.  */
1523           REAL_VALUE_TYPE r;
1524           long l;
1525
1526           /* FIXME:  Perhaps check overflow of the "single".  */
1527           REAL_VALUE_FROM_CONST_DOUBLE (r, operand);
1528           REAL_VALUE_TO_TARGET_SINGLE (r, l);
1529
1530           fprintf (file, "0x%lx", l);
1531         }
1532       return;
1533
1534     case UNSPEC:
1535       ASSERT_PLT_UNSPEC (operand);
1536       /* Fall through.  */
1537
1538     case CONST:
1539       cris_output_addr_const (file, operand);
1540       return;
1541
1542     case MULT:
1543     case ASHIFT:
1544       {
1545         /* For a (MULT (reg X) const_int) we output "rX.S".  */
1546         int i = GET_CODE (XEXP (operand, 1)) == CONST_INT
1547           ? INTVAL (XEXP (operand, 1)) : INTVAL (XEXP (operand, 0));
1548         rtx reg = GET_CODE (XEXP (operand, 1)) == CONST_INT
1549           ? XEXP (operand, 0) : XEXP (operand, 1);
1550
1551         if (GET_CODE (reg) != REG
1552             || (GET_CODE (XEXP (operand, 0)) != CONST_INT
1553                 && GET_CODE (XEXP (operand, 1)) != CONST_INT))
1554           LOSE_AND_RETURN ("unexpected multiplicative operand", x);
1555
1556         cris_print_base (reg, file);
1557         fprintf (file, ".%c",
1558                  i == 0 || (i == 1 && GET_CODE (operand) == MULT) ? 'b'
1559                  : i == 4 ? 'd'
1560                  : (i == 2 && GET_CODE (operand) == MULT) || i == 1 ? 'w'
1561                  : 'd');
1562         return;
1563       }
1564
1565     default:
1566       /* No need to handle all strange variants, let output_addr_const
1567          do it for us.  */
1568       if (CONSTANT_P (operand))
1569         {
1570           cris_output_addr_const (file, operand);
1571           return;
1572         }
1573
1574       LOSE_AND_RETURN ("unexpected operand", x);
1575     }
1576 }
1577
1578 /* The PRINT_OPERAND_ADDRESS worker.  */
1579
1580 void
1581 cris_print_operand_address (file, x)
1582      FILE *file;
1583      rtx x;
1584 {
1585   /* All these were inside MEM:s so output indirection characters.  */
1586   putc ('[', file);
1587
1588   if (CONSTANT_ADDRESS_P (x))
1589     cris_output_addr_const (file, x);
1590   else if (BASE_OR_AUTOINCR_P (x))
1591     cris_print_base (x, file);
1592   else if (GET_CODE (x) == PLUS)
1593     {
1594       rtx x1, x2;
1595
1596       x1 = XEXP (x, 0);
1597       x2 = XEXP (x, 1);
1598       if (BASE_P (x1))
1599         {
1600           cris_print_base (x1, file);
1601           cris_print_index (x2, file);
1602         }
1603       else if (BASE_P (x2))
1604         {
1605           cris_print_base (x2, file);
1606           cris_print_index (x1, file);
1607         }
1608       else
1609         LOSE_AND_RETURN ("unrecognized address", x);
1610     }
1611   else if (GET_CODE (x) == MEM)
1612     {
1613       /* A DIP.  Output more indirection characters.  */
1614       putc ('[', file);
1615       cris_print_base (XEXP (x, 0), file);
1616       putc (']', file);
1617     }
1618   else
1619     LOSE_AND_RETURN ("unrecognized address", x);
1620
1621   putc (']', file);
1622 }
1623
1624 /* The RETURN_ADDR_RTX worker.
1625    We mark that the return address is used, either by EH or
1626    __builtin_return_address, for use by the function prologue and
1627    epilogue.  FIXME: This isn't optimal; we just use the mark in the
1628    prologue and epilogue to say that the return address is to be stored
1629    in the stack frame.  We could return SRP for leaf-functions and use the
1630    initial-value machinery.  */
1631
1632 rtx
1633 cris_return_addr_rtx (count, frameaddr)
1634      int count;
1635      rtx frameaddr ATTRIBUTE_UNUSED;
1636 {
1637   cfun->machine->needs_return_address_on_stack = 1;
1638
1639   /* The return-address is stored just above the saved frame-pointer (if
1640      present).  Apparently we can't eliminate from the frame-pointer in
1641      that direction, so use the incoming args (maybe pretended) pointer.  */
1642   return count == 0
1643     ? gen_rtx_MEM (Pmode, plus_constant (virtual_incoming_args_rtx, -4))
1644     : NULL_RTX;
1645 }
1646
1647 /* This used to be the INITIAL_FRAME_POINTER_OFFSET worker; now only
1648    handles FP -> SP elimination offset.  */
1649
1650 static int
1651 cris_initial_frame_pointer_offset ()
1652 {
1653   int regno;
1654
1655   /* Initial offset is 0 if we don't have a frame pointer.  */
1656   int offs = 0;
1657
1658   /* And 4 for each register pushed.  */
1659   for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
1660     if ((((regs_ever_live[regno]
1661            && !call_used_regs[regno])
1662           || (regno == (int) PIC_OFFSET_TABLE_REGNUM
1663               && (current_function_uses_pic_offset_table
1664                   /* It is saved anyway, if there would be a gap.  */
1665                   || (flag_pic
1666                       && regs_ever_live[regno + 1]
1667                       && !call_used_regs[regno + 1]))))
1668          && (regno != FRAME_POINTER_REGNUM || !frame_pointer_needed)
1669          && regno != CRIS_SRP_REGNUM)
1670         || (current_function_calls_eh_return
1671             && (regno == EH_RETURN_DATA_REGNO (0)
1672                 || regno == EH_RETURN_DATA_REGNO (1)
1673                 || regno == EH_RETURN_DATA_REGNO (2)
1674                 || regno == EH_RETURN_DATA_REGNO (3))))
1675       offs += 4;
1676
1677   /* And then, last, we add the locals allocated.  */
1678   offs += get_frame_size ();
1679
1680   /* And more; the accumulated args size.  */
1681   offs += current_function_outgoing_args_size;
1682
1683   /* Then round it off, in case we use aligned stack.  */
1684   if (TARGET_STACK_ALIGN)
1685     offs = TARGET_ALIGN_BY_32 ? (offs + 3) & ~3 : (offs + 1) & ~1;
1686
1687   return offs;
1688 }
1689
1690 /* The INITIAL_ELIMINATION_OFFSET worker.
1691    Calculate the difference between imaginary registers such as frame
1692    pointer and the stack pointer.  Used to eliminate the frame pointer
1693    and imaginary arg pointer.  */
1694
1695 int
1696 cris_initial_elimination_offset (fromreg, toreg)
1697      int fromreg;
1698      int toreg;
1699 {
1700   int fp_sp_offset
1701     = cris_initial_frame_pointer_offset ();
1702
1703   /* We should be able to use regs_ever_live and related prologue
1704      information here, or alpha should not as well.  */
1705   int return_address_on_stack
1706     = regs_ever_live[CRIS_SRP_REGNUM]
1707     || cfun->machine->needs_return_address_on_stack != 0;
1708
1709   /* Here we act as if the frame-pointer is needed.  */
1710   int ap_fp_offset = 4 + (return_address_on_stack ? 4 : 0);
1711
1712   if (fromreg == ARG_POINTER_REGNUM
1713       && toreg == FRAME_POINTER_REGNUM)
1714     return ap_fp_offset;
1715
1716   /* Between the frame pointer and the stack are only "normal" stack
1717      variables and saved registers.  */
1718   if (fromreg == FRAME_POINTER_REGNUM
1719       && toreg == STACK_POINTER_REGNUM)
1720     return fp_sp_offset;
1721
1722   /* We need to balance out the frame pointer here.  */
1723   if (fromreg == ARG_POINTER_REGNUM
1724       && toreg == STACK_POINTER_REGNUM)
1725     return ap_fp_offset + fp_sp_offset - 4;
1726
1727   abort ();
1728 }
1729
1730 /*  This function looks into the pattern to see how this insn affects
1731     condition codes.
1732
1733     Used when to eliminate test insns before a condition-code user,
1734     such as a "scc" insn or a conditional branch.  This includes
1735     checking if the entities that cc was updated by, are changed by the
1736     operation.
1737
1738     Currently a jumble of the old peek-inside-the-insn and the newer
1739     check-cc-attribute methods.  */
1740
1741 void
1742 cris_notice_update_cc (exp, insn)
1743      rtx exp;
1744      rtx insn;
1745 {
1746   /* Check if user specified "-mcc-init" as a bug-workaround.  FIXME:
1747      TARGET_CCINIT does not work; we must set CC_REVERSED as below.
1748      Several test-cases will otherwise fail, for example
1749      gcc.c-torture/execute/20000217-1.c -O0 and -O1.  */
1750   if (TARGET_CCINIT)
1751     {
1752       CC_STATUS_INIT;
1753       return;
1754     }
1755
1756   /* Slowly, we're converting to using attributes to control the setting
1757      of condition-code status.  */
1758   switch (get_attr_cc (insn))
1759     {
1760     case CC_NONE:
1761       /* Even if it is "none", a setting may clobber a previous
1762          cc-value, so check.  */
1763       if (GET_CODE (exp) == SET)
1764         {
1765           if (cc_status.value1
1766               && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1767                                              cc_status.value1))
1768             cc_status.value1 = 0;
1769
1770           if (cc_status.value2
1771               && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1772                                              cc_status.value2))
1773             cc_status.value2 = 0;
1774         }
1775       return;
1776
1777     case CC_CLOBBER:
1778       CC_STATUS_INIT;
1779       break;
1780
1781     case CC_NORMAL:
1782       /* Which means, for:
1783          (set (cc0) (...)):
1784          CC is (...).
1785
1786          (set (reg) (...)):
1787          CC is (reg) and (...) - unless (...) is 0, then CC does not change.
1788          CC_NO_OVERFLOW unless (...) is reg or mem.
1789
1790          (set (mem) (...)):
1791          CC does not change.
1792
1793          (set (pc) (...)):
1794          CC does not change.
1795
1796          (parallel
1797           (set (reg1) (mem (bdap/biap)))
1798           (set (reg2) (bdap/biap))):
1799          CC is (reg1) and (mem (reg2))
1800
1801          (parallel
1802           (set (mem (bdap/biap)) (reg1)) [or 0]
1803           (set (reg2) (bdap/biap))):
1804          CC does not change.
1805
1806          (where reg and mem includes strict_low_parts variants thereof)
1807
1808          For all others, assume CC is clobbered.
1809          Note that we do not have to care about setting CC_NO_OVERFLOW,
1810          since the overflow flag is set to 0 (i.e. right) for
1811          instructions where it does not have any sane sense, but where
1812          other flags have meanings.  (This includes shifts; the carry is
1813          not set by them).
1814
1815          Note that there are other parallel constructs we could match,
1816          but we don't do that yet.  */
1817
1818       if (GET_CODE (exp) == SET)
1819         {
1820           /* FIXME: Check when this happens.  It looks like we should
1821              actually do a CC_STATUS_INIT here to be safe.  */
1822           if (SET_DEST (exp) == pc_rtx)
1823             return;
1824
1825           /* Record CC0 changes, so we do not have to output multiple
1826              test insns.  */
1827           if (SET_DEST (exp) == cc0_rtx)
1828             {
1829               cc_status.value1 = SET_SRC (exp);
1830               cc_status.value2 = 0;
1831
1832               /* Handle flags for the special btstq on one bit.  */
1833               if (GET_CODE (SET_SRC (exp)) == ZERO_EXTRACT
1834                   && XEXP (SET_SRC (exp), 1) == const1_rtx)
1835                 {
1836                   if (GET_CODE (XEXP (SET_SRC (exp), 0)) == CONST_INT)
1837                     /* Using cmpq.  */
1838                     cc_status.flags = CC_INVERTED;
1839                   else
1840                     /* A one-bit btstq.  */
1841                     cc_status.flags = CC_Z_IN_NOT_N;
1842                 }
1843               else
1844                 cc_status.flags = 0;
1845
1846               if (GET_CODE (SET_SRC (exp)) == COMPARE)
1847                 {
1848                   if (!REG_P (XEXP (SET_SRC (exp), 0))
1849                       && XEXP (SET_SRC (exp), 1) != const0_rtx)
1850                     /* For some reason gcc will not canonicalize compare
1851                        operations, reversing the sign by itself if
1852                        operands are in wrong order.  */
1853                     /* (But NOT inverted; eq is still eq.) */
1854                     cc_status.flags = CC_REVERSED;
1855
1856                   /* This seems to be overlooked by gcc.  FIXME: Check again.
1857                      FIXME:  Is it really safe?  */
1858                   cc_status.value2
1859                     = gen_rtx_MINUS (GET_MODE (SET_SRC (exp)),
1860                                      XEXP (SET_SRC (exp), 0),
1861                                      XEXP (SET_SRC (exp), 1));
1862                 }
1863               return;
1864             }
1865           else if (REG_P (SET_DEST (exp))
1866                    || (GET_CODE (SET_DEST (exp)) == STRICT_LOW_PART
1867                        && REG_P (XEXP (SET_DEST (exp), 0))))
1868             {
1869               /* A register is set; normally CC is set to show that no
1870                  test insn is needed.  Catch the exceptions.  */
1871
1872               /* If not to cc0, then no "set"s in non-natural mode give
1873                  ok cc0...  */
1874               if (GET_MODE_SIZE (GET_MODE (SET_DEST (exp))) > UNITS_PER_WORD
1875                   || GET_MODE_CLASS (GET_MODE (SET_DEST (exp))) == MODE_FLOAT)
1876                 {
1877                   /* ... except add:s and sub:s in DImode.  */
1878                   if (GET_MODE (SET_DEST (exp)) == DImode
1879                       && (GET_CODE (SET_SRC (exp)) == PLUS
1880                           || GET_CODE (SET_SRC (exp)) == MINUS))
1881                     {
1882                       cc_status.flags = 0;
1883                       cc_status.value1 = SET_DEST (exp);
1884                       cc_status.value2 = SET_SRC (exp);
1885
1886                       if (cris_reg_overlap_mentioned_p (cc_status.value1,
1887                                                         cc_status.value2))
1888                         cc_status.value2 = 0;
1889
1890                       /* Add and sub may set V, which gets us
1891                          unoptimizable results in "gt" and "le" condition
1892                          codes.  */
1893                       cc_status.flags |= CC_NO_OVERFLOW;
1894
1895                       return;
1896                     }
1897                 }
1898               else if (SET_SRC (exp) == const0_rtx)
1899                 {
1900                   /* There's no CC0 change when clearing a register or
1901                      memory.  Just check for overlap.  */
1902                   if ((cc_status.value1
1903                        && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1904                                                         cc_status.value1)))
1905                     cc_status.value1 = 0;
1906
1907                   if ((cc_status.value2
1908                        && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1909                                                         cc_status.value2)))
1910                     cc_status.value2 = 0;
1911
1912                   return;
1913                 }
1914               else
1915                 {
1916                   cc_status.flags = 0;
1917                   cc_status.value1 = SET_DEST (exp);
1918                   cc_status.value2 = SET_SRC (exp);
1919
1920                   if (cris_reg_overlap_mentioned_p (cc_status.value1,
1921                                                     cc_status.value2))
1922                     cc_status.value2 = 0;
1923
1924                   /* Some operations may set V, which gets us
1925                      unoptimizable results in "gt" and "le" condition
1926                      codes.  */
1927                   if (GET_CODE (SET_SRC (exp)) == PLUS
1928                       || GET_CODE (SET_SRC (exp)) == MINUS
1929                       || GET_CODE (SET_SRC (exp)) == NEG)
1930                     cc_status.flags |= CC_NO_OVERFLOW;
1931
1932                   return;
1933                 }
1934             }
1935           else if (GET_CODE (SET_DEST (exp)) == MEM
1936                    || (GET_CODE (SET_DEST (exp)) == STRICT_LOW_PART
1937                        && GET_CODE (XEXP (SET_DEST (exp), 0)) == MEM))
1938             {
1939               /* When SET to MEM, then CC is not changed (except for
1940                  overlap).  */
1941               if ((cc_status.value1
1942                    && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1943                                                     cc_status.value1)))
1944                 cc_status.value1 = 0;
1945
1946               if ((cc_status.value2
1947                    && cris_reg_overlap_mentioned_p (SET_DEST (exp),
1948                                                     cc_status.value2)))
1949                 cc_status.value2 = 0;
1950
1951               return;
1952             }
1953         }
1954       else if (GET_CODE (exp) == PARALLEL)
1955         {
1956           if (GET_CODE (XVECEXP (exp, 0, 0)) == SET
1957               && GET_CODE (XVECEXP (exp, 0, 1)) == SET
1958               && REG_P (XEXP (XVECEXP (exp, 0, 1), 0)))
1959             {
1960               if (REG_P (XEXP (XVECEXP (exp, 0, 0), 0))
1961                   && GET_CODE (XEXP (XVECEXP (exp, 0, 0), 1)) == MEM)
1962                 {
1963                   /* For "move.S [rx=ry+o],rz", say CC reflects
1964                      value1=rz and value2=[rx] */
1965                   cc_status.value1 = XEXP (XVECEXP (exp, 0, 0), 0);
1966                   cc_status.value2
1967                     = gen_rtx_MEM (GET_MODE (XEXP (XVECEXP (exp, 0, 0), 0)),
1968                                    XEXP (XVECEXP (exp, 0, 1), 0));
1969                   cc_status.flags = 0;
1970
1971                   /* Huh?  A side-effect cannot change the destination
1972                      register.  */
1973                   if (cris_reg_overlap_mentioned_p (cc_status.value1,
1974                                                     cc_status.value2))
1975                     internal_error ("internal error: sideeffect-insn affecting main effect");
1976                   return;
1977                 }
1978               else if ((REG_P (XEXP (XVECEXP (exp, 0, 0), 1))
1979                         || XEXP (XVECEXP (exp, 0, 0), 1) == const0_rtx)
1980                        && GET_CODE (XEXP (XVECEXP (exp, 0, 0), 0)) == MEM)
1981                 {
1982                   /* For "move.S rz,[rx=ry+o]" and "clear.S [rx=ry+o]",
1983                      say flags are not changed, except for overlap.  */
1984                   if (cc_status.value1
1985                       && cris_reg_overlap_mentioned_p (XEXP
1986                                                        (XVECEXP
1987                                                         (exp, 0, 0), 0),
1988                                                        cc_status.value1))
1989                     cc_status.value1 = 0;
1990
1991                   if (cc_status.value1
1992                       && cris_reg_overlap_mentioned_p (XEXP
1993                                                        (XVECEXP
1994                                                         (exp, 0, 1), 0),
1995                                                        cc_status.value1))
1996                     cc_status.value1 = 0;
1997
1998                   if (cc_status.value2
1999                       && cris_reg_overlap_mentioned_p (XEXP
2000                                                        (XVECEXP
2001                                                         (exp, 0, 0), 0),
2002                                                        cc_status.value2))
2003                     cc_status.value2 = 0;
2004
2005                   if (cc_status.value2
2006                       && cris_reg_overlap_mentioned_p (XEXP
2007                                                        (XVECEXP
2008                                                         (exp, 0, 1), 0),
2009                                                        cc_status.value2))
2010                     cc_status.value2 = 0;
2011
2012                   return;
2013                 }
2014             }
2015         }
2016       break;
2017
2018     default:
2019       /* Unknown cc_attr value.  */
2020       abort ();
2021     }
2022
2023   CC_STATUS_INIT;
2024 }
2025
2026 /* Return != 0 if the return sequence for the current function is short,
2027    like "ret" or "jump [sp+]".  Prior to reloading, we can't tell how
2028    many registers must be saved, so return 0 then.  */
2029
2030 int
2031 cris_simple_epilogue ()
2032 {
2033   int regno;
2034   int reglimit = STACK_POINTER_REGNUM;
2035   int lastreg = -1;
2036
2037   if (! reload_completed
2038       || frame_pointer_needed
2039       || get_frame_size () != 0
2040       || current_function_pretend_args_size
2041       || current_function_args_size
2042       || current_function_outgoing_args_size
2043       || current_function_calls_eh_return
2044
2045       /* If we're not supposed to emit prologue and epilogue, we must
2046          not emit return-type instructions.  */
2047       || !TARGET_PROLOGUE_EPILOGUE)
2048     return 0;
2049
2050   /* We allow a "movem [sp+],rN" to sit in front if the "jump [sp+]" or
2051      in the delay-slot of the "ret".  */
2052   for (regno = 0; regno < reglimit; regno++)
2053     if ((regs_ever_live[regno] && ! call_used_regs[regno])
2054         || (regno == (int) PIC_OFFSET_TABLE_REGNUM
2055             && (current_function_uses_pic_offset_table
2056                 /* It is saved anyway, if there would be a gap.  */
2057                 || (flag_pic
2058                     && regs_ever_live[regno + 1]
2059                     && !call_used_regs[regno + 1]))))
2060       {
2061         if (lastreg != regno - 1)
2062           return 0;
2063         lastreg = regno;
2064       }
2065
2066   return 1;
2067 }
2068
2069 /* The ADDRESS_COST worker.  */
2070
2071 int
2072 cris_address_cost (x)
2073      rtx x;
2074 {
2075   /* The metric to use for the cost-macros is unclear.
2076      The metric used here is (the number of cycles needed) / 2,
2077      where we consider equal a cycle for a word of code and a cycle to
2078      read memory.  */
2079
2080   /* The cheapest addressing modes get 0, since nothing extra is needed.  */
2081   if (BASE_OR_AUTOINCR_P (x))
2082     return 0;
2083
2084   /* An indirect mem must be a DIP.  This means two bytes extra for code,
2085      and 4 bytes extra for memory read, i.e.  (2 + 4) / 2.  */
2086   if (GET_CODE (x) == MEM)
2087     return (2 + 4) / 2;
2088
2089   /* Assume (2 + 4) / 2 for a single constant; a dword, since it needs
2090      an extra DIP prefix and 4 bytes of constant in most cases.
2091      For PIC and a symbol with a GOT entry, we double the cost since we
2092      add a [rPIC+...] offset.  A GOT-less symbol uses a BDAP prefix
2093      equivalent to the DIP prefix for non-PIC, hence the same cost.  */
2094   if (CONSTANT_P (x))
2095     return flag_pic && cris_got_symbol (x) ? 2 * (2 + 4) / 2 : (2 + 4) / 2;
2096
2097   /* Handle BIAP and BDAP prefixes.  */
2098   if (GET_CODE (x) == PLUS)
2099     {
2100       rtx tem1 = XEXP (x, 0);
2101       rtx tem2 = XEXP (x, 1);
2102
2103     /* A BIAP is 2 extra bytes for the prefix insn, nothing more.  We
2104        recognize the typical MULT which is always in tem1 because of
2105        insn canonicalization.  */
2106     if ((GET_CODE (tem1) == MULT && BIAP_INDEX_P (tem1))
2107         || REG_P (tem1))
2108       return 2 / 2;
2109
2110     /* A BDAP (quick) is 2 extra bytes.  Any constant operand to the
2111        PLUS is always found in tem2.  */
2112     if (GET_CODE (tem2) == CONST_INT
2113         && INTVAL (tem2) < 128 && INTVAL (tem2) >= -128)
2114       return 2 / 2;
2115
2116     /* A BDAP -32768 .. 32767 is like BDAP quick, but with 2 extra
2117        bytes.  */
2118     if (GET_CODE (tem2) == CONST_INT
2119         && CONST_OK_FOR_LETTER_P (INTVAL (tem2), 'L'))
2120       return (2 + 2) / 2;
2121
2122     /* A BDAP with some other constant is 2 bytes extra.  */
2123     if (CONSTANT_P (tem2))
2124       return (2 + 2 + 2) / 2;
2125
2126     /* BDAP with something indirect should have a higher cost than
2127        BIAP with register.   FIXME: Should it cost like a MEM or more?  */
2128     /* Don't need to check it, it's the only one left.
2129        FIXME:  There was a REG test missing, perhaps there are others.
2130        Think more.  */
2131     return (2 + 2 + 2) / 2;
2132   }
2133
2134   /* What else?  Return a high cost.  It matters only for valid
2135      addressing modes.  */
2136   return 10;
2137 }
2138
2139 /* Check various objections to the side-effect.  Used in the test-part
2140    of an anonymous insn describing an insn with a possible side-effect.
2141    Returns nonzero if the implied side-effect is ok.
2142
2143    code     : PLUS or MULT
2144    ops      : An array of rtx:es. lreg, rreg, rval,
2145               The variables multop and other_op are indexes into this,
2146               or -1 if they are not applicable.
2147    lreg     : The register that gets assigned in the side-effect.
2148    rreg     : One register in the side-effect expression
2149    rval     : The other register, or an int.
2150    multop   : An integer to multiply rval with.
2151    other_op : One of the entities of the main effect,
2152               whose mode we must consider.  */
2153
2154 int
2155 cris_side_effect_mode_ok (code, ops, lreg, rreg, rval, multop, other_op)
2156      enum rtx_code code;
2157      rtx *ops;
2158      int lreg, rreg, rval, multop, other_op;
2159 {
2160   /* Find what value to multiply with, for rx =ry + rz * n.  */
2161   int mult = multop < 0 ? 1 : INTVAL (ops[multop]);
2162
2163   rtx reg_rtx = ops[rreg];
2164   rtx val_rtx = ops[rval];
2165
2166   /* The operands may be swapped.  Canonicalize them in reg_rtx and
2167      val_rtx, where reg_rtx always is a reg (for this constraint to
2168      match).  */
2169   if (! BASE_P (reg_rtx))
2170     reg_rtx = val_rtx, val_rtx = ops[rreg];
2171
2172   /* Don't forget to check that reg_rtx really is a reg.  If it isn't,
2173      we have no business.  */
2174   if (! BASE_P (reg_rtx))
2175     return 0;
2176
2177   /* Don't do this when -mno-split.  */
2178   if (!TARGET_SIDE_EFFECT_PREFIXES)
2179     return 0;
2180
2181   /* The mult expression may be hidden in lreg.  FIXME:  Add more
2182      commentary about that.  */
2183   if (GET_CODE (val_rtx) == MULT)
2184     {
2185       mult = INTVAL (XEXP (val_rtx, 1));
2186       val_rtx = XEXP (val_rtx, 0);
2187       code = MULT;
2188     }
2189
2190   /* First check the "other operand".  */
2191   if (other_op >= 0)
2192     {
2193       if (GET_MODE_SIZE (GET_MODE (ops[other_op])) > UNITS_PER_WORD)
2194         return 0;
2195
2196       /* Check if the lvalue register is the same as the "other
2197          operand".  If so, the result is undefined and we shouldn't do
2198          this.  FIXME:  Check again.  */
2199       if ((BASE_P (ops[lreg])
2200            && BASE_P (ops[other_op])
2201            && REGNO (ops[lreg]) == REGNO (ops[other_op]))
2202           || rtx_equal_p (ops[other_op], ops[lreg]))
2203       return 0;
2204     }
2205
2206   /* Do not accept frame_pointer_rtx as any operand.  */
2207   if (ops[lreg] == frame_pointer_rtx || ops[rreg] == frame_pointer_rtx
2208       || ops[rval] == frame_pointer_rtx
2209       || (other_op >= 0 && ops[other_op] == frame_pointer_rtx))
2210     return 0;
2211
2212   if (code == PLUS
2213       && ! BASE_P (val_rtx))
2214     {
2215
2216       /* Do not allow rx = rx + n if a normal add or sub with same size
2217          would do.  */
2218       if (rtx_equal_p (ops[lreg], reg_rtx)
2219           && GET_CODE (val_rtx) == CONST_INT
2220           && (INTVAL (val_rtx) <= 63 && INTVAL (val_rtx) >= -63))
2221         return 0;
2222
2223       /* Check allowed cases, like [r(+)?].[bwd] and const.
2224          A symbol is not allowed with PIC.  */
2225       if (CONSTANT_P (val_rtx))
2226         return flag_pic == 0 || cris_symbol (val_rtx) == 0;
2227
2228       if (GET_CODE (val_rtx) == MEM
2229           && BASE_OR_AUTOINCR_P (XEXP (val_rtx, 0)))
2230         return 1;
2231
2232       if (GET_CODE (val_rtx) == SIGN_EXTEND
2233           && GET_CODE (XEXP (val_rtx, 0)) == MEM
2234           && BASE_OR_AUTOINCR_P (XEXP (XEXP (val_rtx, 0), 0)))
2235         return 1;
2236
2237       /* If we got here, it's not a valid addressing mode.  */
2238       return 0;
2239     }
2240   else if (code == MULT
2241            || (code == PLUS && BASE_P (val_rtx)))
2242     {
2243       /* Do not allow rx = rx + ry.S, since it doesn't give better code.  */
2244       if (rtx_equal_p (ops[lreg], reg_rtx)
2245           || (mult == 1 && rtx_equal_p (ops[lreg], val_rtx)))
2246         return 0;
2247
2248       /* Do not allow bad multiply-values.  */
2249       if (mult != 1 && mult != 2 && mult != 4)
2250         return 0;
2251
2252       /* Only allow  r + ...  */
2253       if (! BASE_P (reg_rtx))
2254         return 0;
2255
2256       /* If we got here, all seems ok.
2257          (All checks need to be done above).  */
2258       return 1;
2259     }
2260
2261   /* If we get here, the caller got its initial tests wrong.  */
2262   internal_error ("internal error: cris_side_effect_mode_ok with bad operands");
2263 }
2264
2265 /* The function reg_overlap_mentioned_p in CVS (still as of 2001-05-16)
2266    does not handle the case where the IN operand is strict_low_part; it
2267    does handle it for X.  Test-case in Axis-20010516.  This function takes
2268    care of that for THIS port.  FIXME: strict_low_part is going away
2269    anyway.  */
2270
2271 static int
2272 cris_reg_overlap_mentioned_p (x, in)
2273      rtx x, in;
2274 {
2275   /* The function reg_overlap_mentioned now handles when X is
2276      strict_low_part, but not when IN is a STRICT_LOW_PART.  */
2277   if (GET_CODE (in) == STRICT_LOW_PART)
2278     in = XEXP (in, 0);
2279
2280   return reg_overlap_mentioned_p (x, in);
2281 }
2282
2283 /* The TARGET_ASM_NAMED_SECTION worker.
2284    We just dispatch to the functions for ELF and a.out.  */
2285
2286 void
2287 cris_target_asm_named_section (name, flags)
2288      const char *name;
2289      unsigned int flags;
2290 {
2291   if (! TARGET_ELF)
2292     default_no_named_section (name, flags);
2293   else
2294     default_elf_asm_named_section (name, flags);
2295 }
2296
2297 /* The LEGITIMATE_PIC_OPERAND_P worker.  */
2298
2299 int
2300 cris_legitimate_pic_operand (x)
2301      rtx x;
2302 {
2303   /* The PIC representation of a symbol with a GOT entry will be (for
2304      example; relocations differ):
2305       sym => [rPIC+sym:GOT]
2306      and for a GOT-less symbol it will be (for example, relocation differ):
2307       sym => rPIC+sym:GOTOFF
2308      so only a symbol with a GOT is by itself a valid operand, and it
2309      can't be a sum of a symbol and an offset.  */
2310   return ! cris_symbol (x) || cris_got_symbol (x);
2311 }
2312
2313 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2314    CONSTANT_P.  */
2315
2316 int
2317 cris_symbol (x)
2318      rtx x;
2319 {
2320   switch (GET_CODE (x))
2321     {
2322     case SYMBOL_REF:
2323     case LABEL_REF:
2324       return 1;
2325
2326     case UNSPEC:
2327       /* A PLT reference.  */
2328       ASSERT_PLT_UNSPEC (x);
2329       return 1;
2330
2331     case CONST:
2332       return cris_symbol (XEXP (x, 0));
2333
2334     case PLUS:
2335     case MINUS:
2336       return cris_symbol (XEXP (x, 0)) || cris_symbol (XEXP (x, 1));
2337
2338     case CONST_INT:
2339     case CONST_DOUBLE:
2340     case CONSTANT_P_RTX:
2341       return 0;
2342
2343     default:
2344       fatal_insn ("unrecognized supposed constant", x);
2345     }
2346
2347   return 1;
2348 }
2349
2350 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2351    CONSTANT_P, and the symbol does not need a GOT entry.  Also set
2352    current_function_uses_pic_offset_table if we're generating PIC and ever
2353    see something that would need one.  */
2354
2355 int
2356 cris_gotless_symbol (x)
2357      rtx x;
2358 {
2359   switch (GET_CODE (x))
2360     {
2361     case UNSPEC:
2362       ASSERT_PLT_UNSPEC (x);
2363       return 1;
2364
2365     case SYMBOL_REF:
2366       if (flag_pic && cfun != NULL)
2367         current_function_uses_pic_offset_table = 1;
2368       return SYMBOL_REF_FLAG (x);
2369
2370     case LABEL_REF:
2371       /* We don't set current_function_uses_pic_offset_table for
2372          LABEL_REF:s in here, since they are almost always originating
2373          from some branch.  The only time it does not come from a label is
2374          when GCC does something like __builtin_setjmp.  Then we get the
2375          LABEL_REF from the movsi expander, so we mark it there as a
2376          special case.  */
2377       return 1;
2378
2379     case CONST:
2380       return cris_gotless_symbol (XEXP (x, 0));
2381
2382     case PLUS:
2383     case MINUS:
2384       {
2385         int x0 = cris_gotless_symbol (XEXP (x, 0)) != 0;
2386         int x1 = cris_gotless_symbol (XEXP (x, 1)) != 0;
2387
2388         /* One and only one of them must be a local symbol.  Neither must
2389            be some other, more general kind of symbol.  */
2390         return
2391           (x0 ^ x1)
2392           && ! (x0 == 0 && cris_symbol (XEXP (x, 0)))
2393           && ! (x1 == 0 && cris_symbol (XEXP (x, 1)));
2394       }
2395
2396     case CONST_INT:
2397     case CONST_DOUBLE:
2398     case CONSTANT_P_RTX:
2399       return 0;
2400
2401     default:
2402       fatal_insn ("unrecognized supposed constant", x);
2403     }
2404
2405   return 1;
2406 }
2407
2408 /* Return non-zero if there's a SYMBOL_REF or LABEL_REF hiding inside this
2409    CONSTANT_P, and the symbol needs a GOT entry.  */
2410
2411 int
2412 cris_got_symbol (x)
2413      rtx x;
2414 {
2415   switch (GET_CODE (x))
2416     {
2417     case UNSPEC:
2418       ASSERT_PLT_UNSPEC (x);
2419       return 0;
2420
2421     case SYMBOL_REF:
2422       if (flag_pic && cfun != NULL)
2423         current_function_uses_pic_offset_table = 1;
2424       return ! SYMBOL_REF_FLAG (x);
2425
2426     case CONST:
2427       return cris_got_symbol (XEXP (x, 0));
2428
2429     case LABEL_REF:
2430       /* A LABEL_REF is never visible as a symbol outside the local
2431          function.  */
2432     case PLUS:
2433     case MINUS:
2434       /* Nope, can't access the GOT for "symbol + offset".  */
2435       return 0;
2436
2437     case CONST_INT:
2438     case CONST_DOUBLE:
2439     case CONSTANT_P_RTX:
2440       return 0;
2441
2442     default:
2443       fatal_insn ("unrecognized supposed constant in cris_global_pic_symbol",
2444                   x);
2445     }
2446
2447   return 1;
2448 }
2449
2450 /* The OVERRIDE_OPTIONS worker.
2451    As is the norm, this also parses -mfoo=bar type parameters.  */
2452
2453 void
2454 cris_override_options ()
2455 {
2456   if (cris_max_stackframe_str)
2457     {
2458       cris_max_stackframe = atoi (cris_max_stackframe_str);
2459
2460       /* Do some sanity checking.  */
2461       if (cris_max_stackframe < 0 || cris_max_stackframe > 0x20000000)
2462         internal_error ("-max-stackframe=%d is not usable, not between 0 and %d",
2463                         cris_max_stackframe, 0x20000000);
2464     }
2465
2466   /* Let "-metrax4" and "-metrax100" change the cpu version.  */
2467   if (TARGET_SVINTO && cris_cpu_version < CRIS_CPU_SVINTO)
2468     cris_cpu_version = CRIS_CPU_SVINTO;
2469   else if (TARGET_ETRAX4_ADD && cris_cpu_version < CRIS_CPU_ETRAX4)
2470     cris_cpu_version = CRIS_CPU_ETRAX4;
2471
2472   /* Parse -march=... and its synonym, the deprecated -mcpu=...  */
2473   if (cris_cpu_str)
2474     {
2475       cris_cpu_version
2476         = (*cris_cpu_str == 'v' ? atoi (cris_cpu_str + 1) : -1);
2477
2478       if (strcmp ("etrax4", cris_cpu_str) == 0)
2479         cris_cpu_version = 3;
2480
2481       if (strcmp ("svinto", cris_cpu_str) == 0
2482           || strcmp ("etrax100", cris_cpu_str) == 0)
2483         cris_cpu_version = 8;
2484
2485       if (strcmp ("ng", cris_cpu_str) == 0
2486           || strcmp ("etrax100lx", cris_cpu_str) == 0)
2487         cris_cpu_version = 10;
2488
2489       if (cris_cpu_version < 0 || cris_cpu_version > 10)
2490         error ("unknown CRIS version specification in -march= or -mcpu= : %s",
2491                cris_cpu_str);
2492
2493       /* Set the target flags.  */
2494       if (cris_cpu_version >= CRIS_CPU_ETRAX4)
2495         target_flags |= TARGET_MASK_ETRAX4_ADD;
2496
2497       /* If this is Svinto or higher, align for 32 bit accesses.  */
2498       if (cris_cpu_version >= CRIS_CPU_SVINTO)
2499         target_flags
2500           |= (TARGET_MASK_SVINTO | TARGET_MASK_ALIGN_BY_32
2501               | TARGET_MASK_STACK_ALIGN | TARGET_MASK_CONST_ALIGN
2502               | TARGET_MASK_DATA_ALIGN);
2503
2504       /* Note that we do not add new flags when it can be completely
2505          described with a macro that uses -mcpu=X.  So
2506          TARGET_HAS_MUL_INSNS is (cris_cpu_version >= CRIS_CPU_NG).  */
2507     }
2508
2509   if (cris_tune_str)
2510     {
2511       int cris_tune
2512         = (*cris_tune_str == 'v' ? atoi (cris_tune_str + 1) : -1);
2513
2514       if (strcmp ("etrax4", cris_tune_str) == 0)
2515         cris_tune = 3;
2516
2517       if (strcmp ("svinto", cris_tune_str) == 0
2518           || strcmp ("etrax100", cris_tune_str) == 0)
2519         cris_tune = 8;
2520
2521       if (strcmp ("ng", cris_tune_str) == 0
2522           || strcmp ("etrax100lx", cris_tune_str) == 0)
2523         cris_tune = 10;
2524
2525       if (cris_tune < 0 || cris_tune > 10)
2526         error ("unknown CRIS cpu version specification in -mtune= : %s",
2527                cris_tune_str);
2528
2529       if (cris_tune >= CRIS_CPU_SVINTO)
2530         /* We have currently nothing more to tune than alignment for
2531            memory accesses.  */
2532         target_flags
2533           |= (TARGET_MASK_STACK_ALIGN | TARGET_MASK_CONST_ALIGN
2534               | TARGET_MASK_DATA_ALIGN | TARGET_MASK_ALIGN_BY_32);
2535     }
2536
2537   if (flag_pic)
2538     {
2539       /* Use error rather than warning, so invalid use is easily
2540          detectable.  Still change to the values we expect, to avoid
2541          further errors.  */
2542       if (! TARGET_LINUX)
2543         {
2544           error ("-fPIC and -fpic are not supported in this configuration");
2545           flag_pic = 0;
2546         }
2547
2548       /* Turn off function CSE.  We need to have the addresses reach the
2549          call expanders to get PLT-marked, as they could otherwise be
2550          compared against zero directly or indirectly.  After visiting the
2551          call expanders they will then be cse:ed, as the call expanders
2552          force_reg the addresses, effectively forcing flag_no_function_cse
2553          to 0.  */
2554       flag_no_function_cse = 1;
2555     }
2556
2557   if ((write_symbols == DWARF_DEBUG
2558        || write_symbols == DWARF2_DEBUG) && ! TARGET_ELF)
2559     {
2560       warning ("that particular -g option is invalid with -maout and -melinux");
2561       write_symbols = DBX_DEBUG;
2562     }
2563
2564   /* Set the per-function-data initializer.  */
2565   init_machine_status = cris_init_machine_status;
2566 }
2567
2568 /* The ASM_OUTPUT_MI_THUNK worker.  */
2569
2570 void
2571 cris_asm_output_mi_thunk (stream, thunkdecl, delta, funcdecl)
2572      FILE *stream;
2573      tree thunkdecl ATTRIBUTE_UNUSED;
2574      int delta;
2575      tree funcdecl;
2576 {
2577   if (delta > 0)
2578     asm_fprintf (stream, "\tadd%s %d,$%s\n",
2579                  ADDITIVE_SIZE_MODIFIER (delta), delta,
2580                  reg_names[CRIS_FIRST_ARG_REG]);
2581   else if (delta < 0)
2582     asm_fprintf (stream, "\tsub%s %d,$%s\n",
2583                  ADDITIVE_SIZE_MODIFIER (-delta), -delta,
2584                  reg_names[CRIS_FIRST_ARG_REG]);
2585
2586   if (flag_pic)
2587     {
2588       const char *name = XSTR (XEXP (DECL_RTL (funcdecl), 0), 0);
2589
2590       STRIP_NAME_ENCODING (name, name);
2591       fprintf (stream, "add.d ");
2592       assemble_name (stream, name);
2593       fprintf (stream, "%s,$pc\n", CRIS_PLT_PCOFFSET_SUFFIX);
2594     }
2595   else
2596     {
2597       fprintf (stream, "jump ");
2598       assemble_name (stream, XSTR (XEXP (DECL_RTL (funcdecl), 0), 0));
2599       fprintf (stream, "\n");
2600     }
2601 }
2602
2603 /* The EXPAND_BUILTIN_VA_ARG worker.  This is modified from the
2604    "standard" implementation of va_arg: read the value from the current
2605    address and increment by the size of one or two registers.  The
2606    important difference for CRIS is that if the type is
2607    pass-by-reference, then perform an indirection.  */
2608
2609 rtx
2610 cris_expand_builtin_va_arg (valist, type)
2611      tree valist;
2612      tree type;
2613 {
2614   tree addr_tree, t;
2615   rtx addr;
2616   tree passed_size = size_zero_node;
2617   tree type_size = NULL;
2618   tree size3 = size_int (3);
2619   tree size4 = size_int (4);
2620   tree size8 = size_int (8);
2621   tree rounded_size;
2622
2623   /* Get AP.  */
2624   addr_tree = valist;
2625
2626   if (type == error_mark_node
2627       || (type_size = TYPE_SIZE_UNIT (TYPE_MAIN_VARIANT (type))) == NULL
2628       || TREE_OVERFLOW (type_size))
2629     /* Presumably an error; the size isn't computable.  A message has
2630        supposedly been emitted elsewhere.  */
2631     rounded_size = size_zero_node;
2632   else
2633     rounded_size
2634       = fold (build (MULT_EXPR, sizetype,
2635                      fold (build (TRUNC_DIV_EXPR, sizetype,
2636                                   fold (build (PLUS_EXPR, sizetype,
2637                                                type_size, size3)),
2638                                   size4)),
2639                      size4));
2640
2641   if (!integer_zerop (rounded_size))
2642     {
2643       /* Check if the type is passed by value or by reference.  Values up
2644          to 8 bytes are passed by-value, padded to register-size (4
2645          bytes).  Larger values and varying-size types are passed
2646          by reference.  */
2647       passed_size
2648         = (!really_constant_p (type_size)
2649            ? size4
2650            : fold (build (COND_EXPR, sizetype,
2651                           fold (build (GT_EXPR, sizetype,
2652                                        rounded_size,
2653                                        size8)),
2654                           size4,
2655                           rounded_size)));
2656
2657       addr_tree
2658         = (!really_constant_p (type_size)
2659            ? build1 (INDIRECT_REF, build_pointer_type (type), addr_tree)
2660            : fold (build (COND_EXPR, TREE_TYPE (addr_tree),
2661                           fold (build (GT_EXPR, sizetype,
2662                                        rounded_size,
2663                                        size8)),
2664                           build1 (INDIRECT_REF, build_pointer_type (type),
2665                                   addr_tree),
2666                           addr_tree)));
2667     }
2668
2669   addr = expand_expr (addr_tree, NULL_RTX, Pmode, EXPAND_NORMAL);
2670   addr = copy_to_reg (addr);
2671
2672   if (!integer_zerop (rounded_size))
2673     {
2674       /* Compute new value for AP.  */
2675       t = build (MODIFY_EXPR, TREE_TYPE (valist), valist,
2676                  build (PLUS_EXPR, TREE_TYPE (valist), valist,
2677                         passed_size));
2678       TREE_SIDE_EFFECTS (t) = 1;
2679       expand_expr (t, const0_rtx, VOIDmode, EXPAND_NORMAL);
2680     }
2681
2682   return addr;
2683 }
2684
2685 /* The INIT_EXPANDERS worker sets the per-function-data initializer and
2686    mark functions.  */
2687
2688 void
2689 cris_init_expanders ()
2690 {
2691   /* Nothing here at the moment.  */
2692 }
2693
2694 /* Zero initialization is OK for all current fields.  */
2695
2696 static void
2697 cris_init_machine_status (p)
2698      struct function *p;
2699 {
2700   p->machine = xcalloc (1, sizeof (struct machine_function));
2701 }
2702
2703 /* Split a 2 word move (DI or presumably DF) into component parts.
2704    Originally a copy of gen_split_move_double in m32r.c.  */
2705
2706 rtx
2707 cris_split_movdx (operands)
2708      rtx *operands;
2709 {
2710   enum machine_mode mode = GET_MODE (operands[0]);
2711   rtx dest = operands[0];
2712   rtx src  = operands[1];
2713   rtx val;
2714
2715   /* We used to have to handle (SUBREG (MEM)) here, but that should no
2716      longer happen; after reload there are no SUBREGs any more, and we're
2717      only called after reload.  */
2718   if (GET_CODE (dest) == SUBREG || GET_CODE (src) == SUBREG)
2719     abort ();
2720
2721   start_sequence ();
2722   if (GET_CODE (dest) == REG)
2723     {
2724       int dregno = REGNO (dest);
2725
2726       /* Reg-to-reg copy.  */
2727       if (GET_CODE (src) == REG)
2728         {
2729           int sregno = REGNO (src);
2730
2731           int reverse = (dregno == sregno + 1);
2732
2733           /* We normally copy the low-numbered register first.  However, if
2734              the first register operand 0 is the same as the second register of
2735              operand 1, we must copy in the opposite order.  */
2736           emit_insn (gen_rtx_SET (VOIDmode,
2737                                   operand_subword (dest, reverse, TRUE, mode),
2738                                   operand_subword (src, reverse, TRUE, mode)));
2739
2740           emit_insn (gen_rtx_SET (VOIDmode,
2741                                   operand_subword (dest, !reverse, TRUE, mode),
2742                                   operand_subword (src, !reverse, TRUE, mode)));
2743         }
2744       /* Constant-to-reg copy.  */
2745       else if (GET_CODE (src) == CONST_INT || GET_CODE (src) == CONST_DOUBLE)
2746         {
2747           rtx words[2];
2748           split_double (src, &words[0], &words[1]);
2749           emit_insn (gen_rtx_SET (VOIDmode,
2750                                   operand_subword (dest, 0, TRUE, mode),
2751                                   words[0]));
2752
2753           emit_insn (gen_rtx_SET (VOIDmode,
2754                                   operand_subword (dest, 1, TRUE, mode),
2755                                   words[1]));
2756         }
2757       /* Mem-to-reg copy.  */
2758       else if (GET_CODE (src) == MEM)
2759         {
2760           /* If the high-address word is used in the address, we must load it
2761              last.  Otherwise, load it first.  */
2762           rtx addr = XEXP (src, 0);
2763           int reverse
2764             = (refers_to_regno_p (dregno, dregno + 1, addr, NULL) != 0);
2765
2766           /* The original code imples that we can't do
2767              move.x [rN+],rM  move.x [rN],rM+1
2768              when rN is dead, because of REG_NOTES damage.  That is
2769              consistent with what I've seen, so don't try it.
2770
2771              We have two different cases here; if the addr is POST_INC,
2772              just pass it through, otherwise add constants.  */
2773
2774           if (GET_CODE (addr) == POST_INC)
2775             {
2776               emit_insn (gen_rtx_SET (VOIDmode,
2777                                       operand_subword (dest, 0, TRUE, mode),
2778                                       change_address (src, SImode, addr)));
2779               emit_insn (gen_rtx_SET (VOIDmode,
2780                                       operand_subword (dest, 1, TRUE, mode),
2781                                       change_address (src, SImode, addr)));
2782             }
2783           else
2784             {
2785               /* Make sure we don't get any other addresses with
2786                  embedded postincrements.  They should be stopped in
2787                  GO_IF_LEGITIMATE_ADDRESS, but we're here for your
2788                  safety.  */
2789               if (side_effects_p (addr))
2790                 fatal_insn ("unexpected side-effects in address", addr);
2791
2792               emit_insn (gen_rtx_SET
2793                          (VOIDmode,
2794                           operand_subword (dest, reverse, TRUE, mode),
2795                           change_address
2796                           (src, SImode,
2797                            plus_constant (addr,
2798                                           reverse * UNITS_PER_WORD))));
2799               emit_insn (gen_rtx_SET
2800                          (VOIDmode,
2801                           operand_subword (dest, ! reverse, TRUE, mode),
2802                           change_address
2803                           (src, SImode,
2804                            plus_constant (addr,
2805                                           (! reverse) *
2806                                           UNITS_PER_WORD))));
2807             }
2808         }
2809       else
2810         abort ();
2811     }
2812   /* Reg-to-mem copy or clear mem.  */
2813   else if (GET_CODE (dest) == MEM
2814            && (GET_CODE (src) == REG
2815                || src == const0_rtx
2816                || src == CONST0_RTX (DFmode)))
2817     {
2818       rtx addr = XEXP (dest, 0);
2819
2820       if (GET_CODE (addr) == POST_INC)
2821         {
2822           emit_insn (gen_rtx_SET (VOIDmode,
2823                                   change_address (dest, SImode, addr),
2824                                   operand_subword (src, 0, TRUE, mode)));
2825           emit_insn (gen_rtx_SET (VOIDmode,
2826                                   change_address (dest, SImode, addr),
2827                                   operand_subword (src, 1, TRUE, mode)));
2828         }
2829       else
2830         {
2831           /* Make sure we don't get any other addresses with embedded
2832              postincrements.  They should be stopped in
2833              GO_IF_LEGITIMATE_ADDRESS, but we're here for your safety.  */
2834           if (side_effects_p (addr))
2835             fatal_insn ("unexpected side-effects in address", addr);
2836
2837           emit_insn (gen_rtx_SET
2838                      (VOIDmode,
2839                       change_address (dest, SImode, addr),
2840                       operand_subword (src, 0, TRUE, mode)));
2841
2842           emit_insn (gen_rtx_SET
2843                      (VOIDmode,
2844                       change_address (dest, SImode,
2845                                       plus_constant (addr,
2846                                                      UNITS_PER_WORD)),
2847                       operand_subword (src, 1, TRUE, mode)));
2848         }
2849     }
2850
2851   else
2852     abort ();
2853
2854   val = gen_sequence ();
2855   end_sequence ();
2856   return val;
2857 }
2858
2859 /* This is in essence a copy of output_addr_const altered to output
2860    symbolic operands as PIC.
2861
2862    FIXME: Add hooks similar to ASM_OUTPUT_SYMBOL_REF to get this effect in
2863    the "real" output_addr_const.  All we need is one for LABEL_REF (and
2864    one for CODE_LABEL?).  */
2865
2866 void
2867 cris_output_addr_const (file, x)
2868      FILE *file;
2869      rtx x;
2870 {
2871   int is_plt = 0;
2872
2873 restart:
2874   switch (GET_CODE (x))
2875     {
2876     case UNSPEC:
2877       ASSERT_PLT_UNSPEC (x);
2878       x = XVECEXP (x, 0, 0);
2879       is_plt = 1;
2880
2881       /* Fall through.  */
2882     case SYMBOL_REF:
2883       if (flag_pic)
2884         {
2885           const char *origstr = XSTR (x, 0);
2886           const char *str;
2887
2888           STRIP_NAME_ENCODING (str, origstr);
2889
2890           if (is_plt)
2891             {
2892               if (cris_pic_sympart_only)
2893                 {
2894                   assemble_name (file, str);
2895                   fprintf (file, ":PLTG");
2896                 }
2897               else
2898                 {
2899                   if (TARGET_AVOID_GOTPLT)
2900                     /* We shouldn't get here.  */
2901                     abort ();
2902
2903                   fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
2904                   assemble_name (file, XSTR (x, 0));
2905
2906                   if (flag_pic == 1)
2907                     fprintf (file, ":GOTPLT16]");
2908                   else
2909                     fprintf (file, ":GOTPLT]");
2910                 }
2911             }
2912           else if (cris_gotless_symbol (x))
2913             {
2914               if (! cris_pic_sympart_only)
2915                 fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
2916               assemble_name (file, str);
2917               fprintf (file, ":GOTOFF");
2918             }
2919           else if (cris_got_symbol (x))
2920             {
2921               if (cris_pic_sympart_only)
2922                 abort ();
2923               fprintf (file, "[$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
2924               assemble_name (file, XSTR (x, 0));
2925
2926               if (flag_pic == 1)
2927                 fprintf (file, ":GOT16]");
2928               else
2929                 fprintf (file, ":GOT]");
2930             }
2931           else
2932             LOSE_AND_RETURN ("unexpected PIC symbol", x);
2933
2934           /* Sanity check.  */
2935           if (! current_function_uses_pic_offset_table)
2936             output_operand_lossage ("PIC register isn't set up");
2937         }
2938       else
2939         assemble_name (file, XSTR (x, 0));
2940       break;
2941
2942     case LABEL_REF:
2943       /* If we get one of those here, it should be dressed as PIC.  Branch
2944          labels are normally output with the 'l' specifier, which means it
2945          will go directly to output_asm_label and not end up here.  */
2946       if (GET_CODE (XEXP (x, 0)) != CODE_LABEL
2947           && (GET_CODE (XEXP (x, 0)) != NOTE
2948               || NOTE_LINE_NUMBER (XEXP (x, 0)) != NOTE_INSN_DELETED_LABEL))
2949         fatal_insn ("unexpected address expression", x);
2950
2951       if (flag_pic)
2952         {
2953           if (cris_gotless_symbol (x))
2954             {
2955               if (! cris_pic_sympart_only)
2956                 fprintf (file, "$%s+", reg_names [PIC_OFFSET_TABLE_REGNUM]);
2957               cris_output_addr_const (file, XEXP (x, 0));
2958
2959               fprintf (file, ":GOTOFF");
2960             }
2961           else
2962             /* Labels are never marked as global symbols.  */
2963             fatal_insn ("unexpected PIC symbol", x);
2964
2965           /* Sanity check.  */
2966           if (! current_function_uses_pic_offset_table)
2967             internal_error ("emitting PIC operand, but PIC register isn't set up");
2968           break;
2969         }
2970
2971       output_addr_const (file, x);
2972       break;
2973
2974     case NOTE:
2975       if (NOTE_LINE_NUMBER (x) != NOTE_INSN_DELETED_LABEL)
2976         fatal_insn ("unexpected NOTE as addr_const:", x);
2977     case CODE_LABEL:
2978     case CONST_INT:
2979     case CONST_DOUBLE:
2980     case ZERO_EXTEND:
2981     case SIGN_EXTEND:
2982       output_addr_const (file, x);
2983       break;
2984
2985     case CONST:
2986       /* This used to output parentheses around the expression,
2987          but that does not work on the 386 (either ATT or BSD assembler).  */
2988       cris_output_addr_const (file, XEXP (x, 0));
2989       break;
2990
2991     case PLUS:
2992       /* Some assemblers need integer constants to appear last (eg masm).  */
2993       if (GET_CODE (XEXP (x, 0)) == CONST_INT)
2994         {
2995           cris_output_addr_const (file, XEXP (x, 1));
2996           if (INTVAL (XEXP (x, 0)) >= 0)
2997             fprintf (file, "+");
2998           output_addr_const (file, XEXP (x, 0));
2999         }
3000       else
3001         {
3002           cris_output_addr_const (file, XEXP (x, 0));
3003           if (GET_CODE (XEXP (x, 1)) != CONST_INT
3004               || INTVAL (XEXP (x, 1)) >= 0)
3005             fprintf (file, "+");
3006           cris_output_addr_const (file, XEXP (x, 1));
3007         }
3008       break;
3009
3010     case MINUS:
3011       /* Avoid outputting things like x-x or x+5-x,
3012          since some assemblers can't handle that.  */
3013       x = simplify_subtraction (x);
3014       if (GET_CODE (x) != MINUS)
3015         goto restart;
3016
3017       cris_output_addr_const (file, XEXP (x, 0));
3018       fprintf (file, "-");
3019       if ((GET_CODE (XEXP (x, 1)) == CONST_INT
3020            && INTVAL (XEXP (x, 1)) < 0)
3021           || GET_CODE (XEXP (x, 1)) != CONST_INT)
3022         {
3023           fprintf (file, "%s", targetm.asm_out.open_paren);
3024           cris_output_addr_const (file, XEXP (x, 1));
3025           fprintf (file, "%s", targetm.asm_out.close_paren);
3026         }
3027       else
3028         output_addr_const (file, XEXP (x, 1));
3029       break;
3030
3031     default:
3032       LOSE_AND_RETURN ("unexpected address expression", x);
3033     }
3034 }
3035
3036 /* The ENCODE_SECTION_INFO worker.  Code-in whether we can get away
3037    without a GOT entry (needed for externally visible objects but not for
3038    functions) into SYMBOL_REF_FLAG and add the PLT suffix for global
3039    functions.  */
3040
3041 void
3042 cris_encode_section_info (exp, first)
3043      tree exp;
3044      int first ATTRIBUTE_UNUSED;
3045 {
3046   if (flag_pic)
3047     {
3048       if (DECL_P (exp))
3049         {
3050           if (TREE_CODE (exp) == FUNCTION_DECL
3051               && (TREE_PUBLIC (exp) || DECL_WEAK (exp))
3052               && ! MODULE_LOCAL_P (exp))
3053             SYMBOL_REF_FLAG (XEXP (DECL_RTL (exp), 0)) = 0;
3054           else
3055             SYMBOL_REF_FLAG (XEXP (DECL_RTL (exp), 0))
3056               = ((! TREE_PUBLIC (exp) && ! DECL_WEAK (exp))
3057                  || MODULE_LOCAL_P (exp));
3058         }
3059       else
3060         /* Others are local entities.  */
3061         SYMBOL_REF_FLAG (XEXP (TREE_CST_RTL (exp), 0)) = 1;
3062     }
3063 }
3064
3065 #if 0
3066 /* Various small functions to replace macros.  Only called from a
3067    debugger.  They might collide with gcc functions or system functions,
3068    so only emit them when '#if 1' above.  */
3069
3070 enum rtx_code Get_code PARAMS ((rtx));
3071
3072 enum rtx_code
3073 Get_code (x)
3074      rtx x;
3075 {
3076   return GET_CODE (x);
3077 }
3078
3079 const char *Get_mode PARAMS ((rtx));
3080
3081 const char *
3082 Get_mode (x)
3083      rtx x;
3084 {
3085   return GET_MODE_NAME (GET_MODE (x));
3086 }
3087
3088 rtx Xexp PARAMS ((rtx, int));
3089
3090 rtx
3091 Xexp (x, n)
3092      rtx x;
3093      int n;
3094 {
3095   return XEXP (x, n);
3096 }
3097
3098 rtx Xvecexp PARAMS ((rtx, int, int));
3099
3100 rtx
3101 Xvecexp (x, n, m)
3102      rtx x;
3103      int n;
3104 {
3105   return XVECEXP (x, n, m);
3106 }
3107
3108 int Get_rtx_len PARAMS ((rtx));
3109
3110 int
3111 Get_rtx_len (x)
3112      rtx x;
3113 {
3114   return GET_RTX_LENGTH (GET_CODE (x));
3115 }
3116
3117 /* Use upper-case to distinguish from local variables that are sometimes
3118    called next_insn and prev_insn.  */
3119
3120 rtx Next_insn PARAMS ((rtx));
3121
3122 rtx
3123 Next_insn (insn)
3124      rtx insn;
3125 {
3126   return NEXT_INSN (insn);
3127 }
3128
3129 rtx Prev_insn PARAMS ((rtx));
3130
3131 rtx
3132 Prev_insn (insn)
3133      rtx insn;
3134 {
3135   return PREV_INSN (insn);
3136 }
3137 #endif
3138
3139 /*
3140  * Local variables:
3141  * eval: (c-set-style "gnu")
3142  * indent-tabs-mode: t
3143  * End:
3144  */