gcc/caller-save.c

   1 /* Save and restore call-clobbered registers which are live across a call.
   2    Copyright (C) 1989, 1992, 1994, 1995, 1997, 1998,
   3    1999, 2000, 2001, 2002 Free Software Foundation, Inc.
   4
   5 This file is part of GCC.
   6
   7 GCC is free software; you can redistribute it and/or modify it under
   8 the terms of the GNU General Public License as published by the Free
   9 Software Foundation; either version 2, or (at your option) any later
  10 version.
  11
  12 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  13 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  14 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  15 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 the Free
  19 Software Foundation, 59 Temple Place - Suite 330, Boston, MA
  20 02111-1307, USA.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "rtl.h"
  25 #include "insn-config.h"
  26 #include "flags.h"
  27 #include "regs.h"
  28 #include "hard-reg-set.h"
  29 #include "recog.h"
  30 #include "basic-block.h"
  31 #include "reload.h"
  32 #include "function.h"
  33 #include "expr.h"
  34 #include "toplev.h"
  35 #include "tm_p.h"
  36
  37 #ifndef MAX_MOVE_MAX
  38 #define MAX_MOVE_MAX MOVE_MAX
  39 #endif
  40
  41 #ifndef MIN_UNITS_PER_WORD
  42 #define MIN_UNITS_PER_WORD UNITS_PER_WORD
  43 #endif
  44
  45 #define MOVE_MAX_WORDS (MOVE_MAX / UNITS_PER_WORD)
  46
  47 /* Modes for each hard register that we can save.  The smallest mode is wide
  48    enough to save the entire contents of the register.  When saving the
  49    register because it is live we first try to save in multi-register modes.
  50    If that is not possible the save is done one register at a time.  */
  51
  52 static enum machine_mode
  53   regno_save_mode[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
  54
  55 /* For each hard register, a place on the stack where it can be saved,
  56    if needed.  */
  57
  58 static rtx
  59   regno_save_mem[FIRST_PSEUDO_REGISTER][MAX_MOVE_MAX / MIN_UNITS_PER_WORD + 1];
  60
  61 /* We will only make a register eligible for caller-save if it can be
  62    saved in its widest mode with a simple SET insn as long as the memory
  63    address is valid.  We record the INSN_CODE is those insns here since
  64    when we emit them, the addresses might not be valid, so they might not
  65    be recognized.  */
  66
  67 static int
  68   reg_save_code[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
  69 static int
  70   reg_restore_code[FIRST_PSEUDO_REGISTER][MAX_MACHINE_MODE];
  71
  72 /* Set of hard regs currently residing in save area (during insn scan).  */
  73
  74 static HARD_REG_SET hard_regs_saved;
  75
  76 /* Number of registers currently in hard_regs_saved.  */
  77
  78 static int n_regs_saved;
  79
  80 /* Computed by mark_referenced_regs, all regs referenced in a given
  81    insn.  */
  82 static HARD_REG_SET referenced_regs;
  83
  84 /* Computed in mark_set_regs, holds all registers set by the current
  85    instruction.  */
  86 static HARD_REG_SET this_insn_sets;
  87
  88
  89 static void mark_set_regs               PARAMS ((rtx, rtx, void *));
  90 static void mark_referenced_regs        PARAMS ((rtx));
  91 static int insert_save                  PARAMS ((struct insn_chain *, int, int,
  92                                                  HARD_REG_SET *,
  93                                                  enum machine_mode *));
  94 static int insert_restore               PARAMS ((struct insn_chain *, int, int,
  95                                                  int, enum machine_mode *));
  96 static struct insn_chain *insert_one_insn PARAMS ((struct insn_chain *, int,
  97                                                    int, rtx));
  98 static void add_stored_regs             PARAMS ((rtx, rtx, void *));
  99 \f
 100 /* Initialize for caller-save.
 101
 102    Look at all the hard registers that are used by a call and for which
 103    regclass.c has not already excluded from being used across a call.
 104
 105    Ensure that we can find a mode to save the register and that there is a
 106    simple insn to save and restore the register.  This latter check avoids
 107    problems that would occur if we tried to save the MQ register of some
 108    machines directly into memory.  */
 109
 110 void
 111 init_caller_save ()
 112 {
 113   rtx addr_reg;
 114   int offset;
 115   rtx address;
 116   int i, j;
 117   enum machine_mode mode;
 118   rtx savepat, restpat;
 119   rtx test_reg, test_mem;
 120   rtx saveinsn, restinsn;
 121
 122   /* First find all the registers that we need to deal with and all
 123      the modes that they can have.  If we can't find a mode to use,
 124      we can't have the register live over calls.  */
 125
 126   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 127     {
 128       if (call_used_regs[i] && ! call_fixed_regs[i])
 129         {
 130           for (j = 1; j <= MOVE_MAX_WORDS; j++)
 131             {
 132               regno_save_mode[i][j] = HARD_REGNO_CALLER_SAVE_MODE (i, j,
 133                                                                    VOIDmode);
 134               if (regno_save_mode[i][j] == VOIDmode && j == 1)
 135                 {
 136                   call_fixed_regs[i] = 1;
 137                   SET_HARD_REG_BIT (call_fixed_reg_set, i);
 138                 }
 139             }
 140         }
 141       else
 142         regno_save_mode[i][1] = VOIDmode;
 143     }
 144
 145   /* The following code tries to approximate the conditions under which
 146      we can easily save and restore a register without scratch registers or
 147      other complexities.  It will usually work, except under conditions where
 148      the validity of an insn operand is dependent on the address offset.
 149      No such cases are currently known.
 150
 151      We first find a typical offset from some BASE_REG_CLASS register.
 152      This address is chosen by finding the first register in the class
 153      and by finding the smallest power of two that is a valid offset from
 154      that register in every mode we will use to save registers.  */
 155
 156   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 157     if (TEST_HARD_REG_BIT
 158         (reg_class_contents
 159          [(int) MODE_BASE_REG_CLASS (regno_save_mode [i][1])], i))
 160       break;
 161
 162   if (i == FIRST_PSEUDO_REGISTER)
 163     abort ();
 164
 165   addr_reg = gen_rtx_REG (Pmode, i);
 166
 167   for (offset = 1 << (HOST_BITS_PER_INT / 2); offset; offset >>= 1)
 168     {
 169       address = gen_rtx_PLUS (Pmode, addr_reg, GEN_INT (offset));
 170
 171       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 172         if (regno_save_mode[i][1] != VOIDmode
 173           && ! strict_memory_address_p (regno_save_mode[i][1], address))
 174           break;
 175
 176       if (i == FIRST_PSEUDO_REGISTER)
 177         break;
 178     }
 179
 180   /* If we didn't find a valid address, we must use register indirect.  */
 181   if (offset == 0)
 182     address = addr_reg;
 183
 184   /* Next we try to form an insn to save and restore the register.  We
 185      see if such an insn is recognized and meets its constraints.
 186
 187      To avoid lots of unnecessary RTL allocation, we construct all the RTL
 188      once, then modify the memory and register operands in-place.  */
 189
 190   test_reg = gen_rtx_REG (VOIDmode, 0);
 191   test_mem = gen_rtx_MEM (VOIDmode, address);
 192   savepat = gen_rtx_SET (VOIDmode, test_mem, test_reg);
 193   restpat = gen_rtx_SET (VOIDmode, test_reg, test_mem);
 194
 195   start_sequence ();
 196
 197   saveinsn = emit_insn (savepat);
 198   restinsn = emit_insn (restpat);
 199
 200   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 201     for (mode = 0 ; mode < MAX_MACHINE_MODE; mode++)
 202       if (HARD_REGNO_MODE_OK (i, mode))
 203         {
 204           int ok;
 205
 206           /* Update the register number and modes of the register
 207              and memory operand.  */
 208           REGNO (test_reg) = i;
 209           PUT_MODE (test_reg, mode);
 210           PUT_MODE (test_mem, mode);
 211
 212           /* Force re-recognition of the modified insns.  */
 213           INSN_CODE (saveinsn) = -1;
 214           INSN_CODE (restinsn) = -1;
 215
 216           reg_save_code[i][mode] = recog_memoized (saveinsn);
 217           reg_restore_code[i][mode] = recog_memoized (restinsn);
 218
 219           /* Now extract both insns and see if we can meet their
 220              constraints.  */
 221           ok = (reg_save_code[i][mode] != -1
 222                 && reg_restore_code[i][mode] != -1);
 223           if (ok)
 224             {
 225               extract_insn (saveinsn);
 226               ok = constrain_operands (1);
 227               extract_insn (restinsn);
 228               ok &= constrain_operands (1);
 229             }
 230
 231           if (! ok)
 232             {
 233               reg_save_code[i][mode] = -1;
 234               reg_restore_code[i][mode] = -1;
 235             }
 236         }
 237       else
 238         {
 239           reg_save_code[i][mode] = -1;
 240           reg_restore_code[i][mode] = -1;
 241         }
 242
 243   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 244     for (j = 1; j <= MOVE_MAX_WORDS; j++)
 245       if (reg_save_code [i][regno_save_mode[i][j]] == -1)
 246         {
 247           regno_save_mode[i][j] = VOIDmode;
 248           if (j == 1)
 249             {
 250               call_fixed_regs[i] = 1;
 251               SET_HARD_REG_BIT (call_fixed_reg_set, i);
 252             }
 253         }
 254
 255   end_sequence ();
 256 }
 257 \f
 258 /* Initialize save areas by showing that we haven't allocated any yet.  */
 259
 260 void
 261 init_save_areas ()
 262 {
 263   int i, j;
 264
 265   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 266     for (j = 1; j <= MOVE_MAX_WORDS; j++)
 267       regno_save_mem[i][j] = 0;
 268 }
 269
 270 /* Allocate save areas for any hard registers that might need saving.
 271    We take a conservative approach here and look for call-clobbered hard
 272    registers that are assigned to pseudos that cross calls.  This may
 273    overestimate slightly (especially if some of these registers are later
 274    used as spill registers), but it should not be significant.
 275
 276    Future work:
 277
 278      In the fallback case we should iterate backwards across all possible
 279      modes for the save, choosing the largest available one instead of
 280      falling back to the smallest mode immediately.  (eg TF -> DF -> SF).
 281
 282      We do not try to use "move multiple" instructions that exist
 283      on some machines (such as the 68k moveml).  It could be a win to try
 284      and use them when possible.  The hard part is doing it in a way that is
 285      machine independent since they might be saving non-consecutive
 286      registers. (imagine caller-saving d0,d1,a0,a1 on the 68k) */
 287
 288 void
 289 setup_save_areas ()
 290 {
 291   int i, j, k;
 292   unsigned int r;
 293   HARD_REG_SET hard_regs_used;
 294
 295   /* Allocate space in the save area for the largest multi-register
 296      pseudos first, then work backwards to single register
 297      pseudos.  */
 298
 299   /* Find and record all call-used hard-registers in this function.  */
 300   CLEAR_HARD_REG_SET (hard_regs_used);
 301   for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
 302     if (reg_renumber[i] >= 0 && REG_N_CALLS_CROSSED (i) > 0)
 303       {
 304         unsigned int regno = reg_renumber[i];
 305         unsigned int endregno
 306           = regno + HARD_REGNO_NREGS (regno, GET_MODE (regno_reg_rtx[i]));
 307
 308         for (r = regno; r < endregno; r++)
 309           if (call_used_regs[r])
 310             SET_HARD_REG_BIT (hard_regs_used, r);
 311       }
 312
 313   /* Now run through all the call-used hard-registers and allocate
 314      space for them in the caller-save area.  Try to allocate space
 315      in a manner which allows multi-register saves/restores to be done.  */
 316
 317   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 318     for (j = MOVE_MAX_WORDS; j > 0; j--)
 319       {
 320         int do_save = 1;
 321
 322         /* If no mode exists for this size, try another.  Also break out
 323            if we have already saved this hard register.  */
 324         if (regno_save_mode[i][j] == VOIDmode || regno_save_mem[i][1] != 0)
 325           continue;
 326
 327         /* See if any register in this group has been saved.  */
 328         for (k = 0; k < j; k++)
 329           if (regno_save_mem[i + k][1])
 330             {
 331               do_save = 0;
 332               break;
 333             }
 334         if (! do_save)
 335           continue;
 336
 337         for (k = 0; k < j; k++)
 338           if (! TEST_HARD_REG_BIT (hard_regs_used, i + k))
 339             {
 340               do_save = 0;
 341               break;
 342             }
 343         if (! do_save)
 344           continue;
 345
 346         /* We have found an acceptable mode to store in.  */
 347         regno_save_mem[i][j]
 348           = assign_stack_local (regno_save_mode[i][j],
 349                                 GET_MODE_SIZE (regno_save_mode[i][j]), 0);
 350
 351         /* Setup single word save area just in case...  */
 352         for (k = 0; k < j; k++)
 353           /* This should not depend on WORDS_BIG_ENDIAN.
 354              The order of words in regs is the same as in memory.  */
 355           regno_save_mem[i + k][1]
 356             = adjust_address_nv (regno_save_mem[i][j],
 357                                  regno_save_mode[i + k][1],
 358                                  k * UNITS_PER_WORD);
 359       }
 360
 361   /* Now loop again and set the alias set of any save areas we made to
 362      the alias set used to represent frame objects.  */
 363   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 364     for (j = MOVE_MAX_WORDS; j > 0; j--)
 365       if (regno_save_mem[i][j] != 0)
 366         set_mem_alias_set (regno_save_mem[i][j], get_frame_alias_set ());
 367 }
 368 \f
 369 /* Find the places where hard regs are live across calls and save them.  */
 370
 371 void
 372 save_call_clobbered_regs ()
 373 {
 374   struct insn_chain *chain, *next;
 375   enum machine_mode save_mode [FIRST_PSEUDO_REGISTER];
 376
 377   CLEAR_HARD_REG_SET (hard_regs_saved);
 378   n_regs_saved = 0;
 379
 380   for (chain = reload_insn_chain; chain != 0; chain = next)
 381     {
 382       rtx insn = chain->insn;
 383       enum rtx_code code = GET_CODE (insn);
 384
 385       next = chain->next;
 386
 387       if (chain->is_caller_save_insn)
 388         abort ();
 389
 390       if (GET_RTX_CLASS (code) == 'i')
 391         {
 392           /* If some registers have been saved, see if INSN references
 393              any of them.  We must restore them before the insn if so.  */
 394
 395           if (n_regs_saved)
 396             {
 397               int regno;
 398
 399               if (code == JUMP_INSN)
 400                 /* Restore all registers if this is a JUMP_INSN.  */
 401                 COPY_HARD_REG_SET (referenced_regs, hard_regs_saved);
 402               else
 403                 {
 404                   CLEAR_HARD_REG_SET (referenced_regs);
 405                   mark_referenced_regs (PATTERN (insn));
 406                   AND_HARD_REG_SET (referenced_regs, hard_regs_saved);
 407                 }
 408
 409               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 410                 if (TEST_HARD_REG_BIT (referenced_regs, regno))
 411                   regno += insert_restore (chain, 1, regno, MOVE_MAX_WORDS, save_mode);
 412             }
 413
 414           if (code == CALL_INSN)
 415             {
 416               int regno;
 417               HARD_REG_SET hard_regs_to_save;
 418
 419               /* Use the register life information in CHAIN to compute which
 420                  regs are live during the call.  */
 421               REG_SET_TO_HARD_REG_SET (hard_regs_to_save,
 422                                        &chain->live_throughout);
 423               /* Save hard registers always in the widest mode available.  */
 424               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 425                 if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
 426                   save_mode [regno] = regno_save_mode [regno][1];
 427                 else
 428                   save_mode [regno] = VOIDmode;
 429
 430               /* Look through all live pseudos, mark their hard registers
 431                  and choose proper mode for saving.  */
 432               EXECUTE_IF_SET_IN_REG_SET
 433                 (&chain->live_throughout, FIRST_PSEUDO_REGISTER, regno,
 434                  {
 435                    int r = reg_renumber[regno];
 436                    int nregs;
 437
 438                    if (r >= 0)
 439                      {
 440                        enum machine_mode mode;
 441
 442                        nregs = HARD_REGNO_NREGS (r, PSEUDO_REGNO_MODE (regno));
 443                        mode = HARD_REGNO_CALLER_SAVE_MODE
 444                                 (r, nregs, PSEUDO_REGNO_MODE (regno));
 445                        if (GET_MODE_BITSIZE (mode)
 446                            > GET_MODE_BITSIZE (save_mode[r]))
 447                          save_mode[r] = mode;
 448                        while (nregs-- > 0)
 449                          SET_HARD_REG_BIT (hard_regs_to_save, r + nregs);
 450                      }
 451                    else
 452                      abort ();
 453                  });
 454
 455               /* Record all registers set in this call insn.  These don't need
 456                  to be saved.  N.B. the call insn might set a subreg of a
 457                  multi-hard-reg pseudo; then the pseudo is considered live
 458                  during the call, but the subreg that is set isn't.  */
 459               CLEAR_HARD_REG_SET (this_insn_sets);
 460               note_stores (PATTERN (insn), mark_set_regs, NULL);
 461
 462               /* Compute which hard regs must be saved before this call.  */
 463               AND_COMPL_HARD_REG_SET (hard_regs_to_save, call_fixed_reg_set);
 464               AND_COMPL_HARD_REG_SET (hard_regs_to_save, this_insn_sets);
 465               AND_COMPL_HARD_REG_SET (hard_regs_to_save, hard_regs_saved);
 466               AND_HARD_REG_SET (hard_regs_to_save, call_used_reg_set);
 467
 468               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 469                 if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
 470                   regno += insert_save (chain, 1, regno, &hard_regs_to_save, save_mode);
 471
 472               /* Must recompute n_regs_saved.  */
 473               n_regs_saved = 0;
 474               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 475                 if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
 476                   n_regs_saved++;
 477             }
 478         }
 479
 480       if (chain->next == 0 || chain->next->block > chain->block)
 481         {
 482           int regno;
 483           /* At the end of the basic block, we must restore any registers that
 484              remain saved.  If the last insn in the block is a JUMP_INSN, put
 485              the restore before the insn, otherwise, put it after the insn.  */
 486
 487           if (n_regs_saved)
 488             for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 489               if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
 490                 regno += insert_restore (chain, GET_CODE (insn) == JUMP_INSN,
 491                                          regno, MOVE_MAX_WORDS, save_mode);
 492         }
 493     }
 494 }
 495
 496 /* Here from note_stores when an insn stores a value in a register.
 497    Set the proper bit or bits in this_insn_sets.  All pseudos that have
 498    been assigned hard regs have had their register number changed already,
 499    so we can ignore pseudos.  */
 500 static void
 501 mark_set_regs (reg, setter, data)
 502      rtx reg;
 503      rtx setter ATTRIBUTE_UNUSED;
 504      void *data ATTRIBUTE_UNUSED;
 505 {
 506   int regno, endregno, i;
 507   enum machine_mode mode = GET_MODE (reg);
 508
 509   if (GET_CODE (reg) == SUBREG)
 510     {
 511       rtx inner = SUBREG_REG (reg);
 512       if (GET_CODE (inner) != REG || REGNO (inner) >= FIRST_PSEUDO_REGISTER)
 513         return;
 514
 515       regno = subreg_hard_regno (reg, 1);
 516     }
 517   else if (GET_CODE (reg) == REG
 518            && REGNO (reg) < FIRST_PSEUDO_REGISTER)
 519     regno = REGNO (reg);
 520   else
 521     return;
 522
 523   endregno = regno + HARD_REGNO_NREGS (regno, mode);
 524
 525   for (i = regno; i < endregno; i++)
 526     SET_HARD_REG_BIT (this_insn_sets, i);
 527 }
 528
 529 /* Here from note_stores when an insn stores a value in a register.
 530    Set the proper bit or bits in the passed regset.  All pseudos that have
 531    been assigned hard regs have had their register number changed already,
 532    so we can ignore pseudos.  */
 533 static void
 534 add_stored_regs (reg, setter, data)
 535      rtx reg;
 536      rtx setter;
 537      void *data;
 538 {
 539   int regno, endregno, i;
 540   enum machine_mode mode = GET_MODE (reg);
 541   int offset = 0;
 542
 543   if (GET_CODE (setter) == CLOBBER)
 544     return;
 545
 546   if (GET_CODE (reg) == SUBREG && GET_CODE (SUBREG_REG (reg)) == REG)
 547     {
 548       offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)),
 549                                     GET_MODE (SUBREG_REG (reg)),
 550                                     SUBREG_BYTE (reg),
 551                                     GET_MODE (reg));
 552       reg = SUBREG_REG (reg);
 553     }
 554
 555   if (GET_CODE (reg) != REG || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
 556     return;
 557
 558   regno = REGNO (reg) + offset;
 559   endregno = regno + HARD_REGNO_NREGS (regno, mode);
 560
 561   for (i = regno; i < endregno; i++)
 562     SET_REGNO_REG_SET ((regset) data, i);
 563 }
 564
 565 /* Walk X and record all referenced registers in REFERENCED_REGS.  */
 566 static void
 567 mark_referenced_regs (x)
 568      rtx x;
 569 {
 570   enum rtx_code code = GET_CODE (x);
 571   const char *fmt;
 572   int i, j;
 573
 574   if (code == SET)
 575     mark_referenced_regs (SET_SRC (x));
 576   if (code == SET || code == CLOBBER)
 577     {
 578       x = SET_DEST (x);
 579       code = GET_CODE (x);
 580       if (code == REG || code == PC || code == CC0
 581           || (code == SUBREG && GET_CODE (SUBREG_REG (x)) == REG
 582               /* If we're setting only part of a multi-word register,
 583                  we shall mark it as referenced, because the words
 584                  that are not being set should be restored.  */
 585               && ((GET_MODE_SIZE (GET_MODE (x))
 586                    >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (x))))
 587                   || (GET_MODE_SIZE (GET_MODE (SUBREG_REG (x)))
 588                       <= UNITS_PER_WORD))))
 589         return;
 590     }
 591   if (code == MEM || code == SUBREG)
 592     {
 593       x = XEXP (x, 0);
 594       code = GET_CODE (x);
 595     }
 596
 597   if (code == REG)
 598     {
 599       int regno = REGNO (x);
 600       int hardregno = (regno < FIRST_PSEUDO_REGISTER ? regno
 601                        : reg_renumber[regno]);
 602
 603       if (hardregno >= 0)
 604         {
 605           int nregs = HARD_REGNO_NREGS (hardregno, GET_MODE (x));
 606           while (nregs-- > 0)
 607             SET_HARD_REG_BIT (referenced_regs, hardregno + nregs);
 608         }
 609       /* If this is a pseudo that did not get a hard register, scan its
 610          memory location, since it might involve the use of another
 611          register, which might be saved.  */
 612       else if (reg_equiv_mem[regno] != 0)
 613         mark_referenced_regs (XEXP (reg_equiv_mem[regno], 0));
 614       else if (reg_equiv_address[regno] != 0)
 615         mark_referenced_regs (reg_equiv_address[regno]);
 616       return;
 617     }
 618
 619   fmt = GET_RTX_FORMAT (code);
 620   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
 621     {
 622       if (fmt[i] == 'e')
 623         mark_referenced_regs (XEXP (x, i));
 624       else if (fmt[i] == 'E')
 625         for (j = XVECLEN (x, i) - 1; j >= 0; j--)
 626           mark_referenced_regs (XVECEXP (x, i, j));
 627     }
 628 }
 629 \f
 630 /* Insert a sequence of insns to restore.  Place these insns in front of
 631    CHAIN if BEFORE_P is nonzero, behind the insn otherwise.  MAXRESTORE is
 632    the maximum number of registers which should be restored during this call.
 633    It should never be less than 1 since we only work with entire registers.
 634
 635    Note that we have verified in init_caller_save that we can do this
 636    with a simple SET, so use it.  Set INSN_CODE to what we save there
 637    since the address might not be valid so the insn might not be recognized.
 638    These insns will be reloaded and have register elimination done by
 639    find_reload, so we need not worry about that here.
 640
 641    Return the extra number of registers saved.  */
 642
 643 static int
 644 insert_restore (chain, before_p, regno, maxrestore, save_mode)
 645      struct insn_chain *chain;
 646      int before_p;
 647      int regno;
 648      int maxrestore;
 649      enum machine_mode *save_mode;
 650 {
 651   int i, k;
 652   rtx pat = NULL_RTX;
 653   int code;
 654   unsigned int numregs = 0;
 655   struct insn_chain *new;
 656   rtx mem;
 657
 658   /* A common failure mode if register status is not correct in the RTL
 659      is for this routine to be called with a REGNO we didn't expect to
 660      save.  That will cause us to write an insn with a (nil) SET_DEST
 661      or SET_SRC.  Instead of doing so and causing a crash later, check
 662      for this common case and abort here instead.  This will remove one
 663      step in debugging such problems.  */
 664
 665   if (regno_save_mem[regno][1] == 0)
 666     abort ();
 667
 668   /* Get the pattern to emit and update our status.
 669
 670      See if we can restore `maxrestore' registers at once.  Work
 671      backwards to the single register case.  */
 672   for (i = maxrestore; i > 0; i--)
 673     {
 674       int j;
 675       int ok = 1;
 676
 677       if (regno_save_mem[regno][i] == 0)
 678         continue;
 679
 680       for (j = 0; j < i; j++)
 681         if (! TEST_HARD_REG_BIT (hard_regs_saved, regno + j))
 682           {
 683             ok = 0;
 684             break;
 685           }
 686       /* Must do this one restore at a time */
 687       if (! ok)
 688         continue;
 689
 690       numregs = i;
 691       break;
 692     }
 693
 694   mem = regno_save_mem [regno][numregs];
 695   if (save_mode [regno] != VOIDmode
 696       && save_mode [regno] != GET_MODE (mem)
 697       && numregs == (unsigned int) HARD_REGNO_NREGS (regno, save_mode [regno]))
 698     mem = adjust_address (mem, save_mode[regno], 0);
 699   pat = gen_rtx_SET (VOIDmode,
 700                      gen_rtx_REG (GET_MODE (mem),
 701                                   regno), mem);
 702   code = reg_restore_code[regno][GET_MODE (mem)];
 703   new = insert_one_insn (chain, before_p, code, pat);
 704
 705   /* Clear status for all registers we restored.  */
 706   for (k = 0; k < i; k++)
 707     {
 708       CLEAR_HARD_REG_BIT (hard_regs_saved, regno + k);
 709       SET_REGNO_REG_SET (&new->dead_or_set, regno + k);
 710       n_regs_saved--;
 711     }
 712
 713   /* Tell our callers how many extra registers we saved/restored */
 714   return numregs - 1;
 715 }
 716
 717 /* Like insert_restore above, but save registers instead.  */
 718
 719 static int
 720 insert_save (chain, before_p, regno, to_save, save_mode)
 721      struct insn_chain *chain;
 722      int before_p;
 723      int regno;
 724      HARD_REG_SET *to_save;
 725      enum machine_mode *save_mode;
 726 {
 727   int i;
 728   unsigned int k;
 729   rtx pat = NULL_RTX;
 730   int code;
 731   unsigned int numregs = 0;
 732   struct insn_chain *new;
 733   rtx mem;
 734
 735   /* A common failure mode if register status is not correct in the RTL
 736      is for this routine to be called with a REGNO we didn't expect to
 737      save.  That will cause us to write an insn with a (nil) SET_DEST
 738      or SET_SRC.  Instead of doing so and causing a crash later, check
 739      for this common case and abort here instead.  This will remove one
 740      step in debugging such problems.  */
 741
 742   if (regno_save_mem[regno][1] == 0)
 743     abort ();
 744
 745   /* Get the pattern to emit and update our status.
 746
 747      See if we can save several registers with a single instruction.
 748      Work backwards to the single register case.  */
 749   for (i = MOVE_MAX_WORDS; i > 0; i--)
 750     {
 751       int j;
 752       int ok = 1;
 753       if (regno_save_mem[regno][i] == 0)
 754         continue;
 755
 756       for (j = 0; j < i; j++)
 757         if (! TEST_HARD_REG_BIT (*to_save, regno + j))
 758           {
 759             ok = 0;
 760             break;
 761           }
 762       /* Must do this one save at a time */
 763       if (! ok)
 764         continue;
 765
 766       numregs = i;
 767       break;
 768     }
 769
 770   mem = regno_save_mem [regno][numregs];
 771   if (save_mode [regno] != VOIDmode
 772       && save_mode [regno] != GET_MODE (mem)
 773       && numregs == (unsigned int) HARD_REGNO_NREGS (regno, save_mode [regno]))
 774     mem = adjust_address (mem, save_mode[regno], 0);
 775   pat = gen_rtx_SET (VOIDmode, mem,
 776                      gen_rtx_REG (GET_MODE (mem),
 777                                   regno));
 778   code = reg_save_code[regno][GET_MODE (mem)];
 779   new = insert_one_insn (chain, before_p, code, pat);
 780
 781   /* Set hard_regs_saved and dead_or_set for all the registers we saved.  */
 782   for (k = 0; k < numregs; k++)
 783     {
 784       SET_HARD_REG_BIT (hard_regs_saved, regno + k);
 785       SET_REGNO_REG_SET (&new->dead_or_set, regno + k);
 786       n_regs_saved++;
 787     }
 788
 789   /* Tell our callers how many extra registers we saved/restored */
 790   return numregs - 1;
 791 }
 792
 793 /* Emit a new caller-save insn and set the code.  */
 794 static struct insn_chain *
 795 insert_one_insn (chain, before_p, code, pat)
 796      struct insn_chain *chain;
 797      int before_p;
 798      int code;
 799      rtx pat;
 800 {
 801   rtx insn = chain->insn;
 802   struct insn_chain *new;
 803
 804 #ifdef HAVE_cc0
 805   /* If INSN references CC0, put our insns in front of the insn that sets
 806      CC0.  This is always safe, since the only way we could be passed an
 807      insn that references CC0 is for a restore, and doing a restore earlier
 808      isn't a problem.  We do, however, assume here that CALL_INSNs don't
 809      reference CC0.  Guard against non-INSN's like CODE_LABEL.  */
 810
 811   if ((GET_CODE (insn) == INSN || GET_CODE (insn) == JUMP_INSN)
 812       && before_p
 813       && reg_referenced_p (cc0_rtx, PATTERN (insn)))
 814     chain = chain->prev, insn = chain->insn;
 815 #endif
 816
 817   new = new_insn_chain ();
 818   if (before_p)
 819     {
 820       rtx link;
 821
 822       new->prev = chain->prev;
 823       if (new->prev != 0)
 824         new->prev->next = new;
 825       else
 826         reload_insn_chain = new;
 827
 828       chain->prev = new;
 829       new->next = chain;
 830       new->insn = emit_insn_before (pat, insn);
 831       /* ??? It would be nice if we could exclude the already / still saved
 832          registers from the live sets.  */
 833       COPY_REG_SET (&new->live_throughout, &chain->live_throughout);
 834       /* Registers that die in CHAIN->INSN still live in the new insn.  */
 835       for (link = REG_NOTES (chain->insn); link; link = XEXP (link, 1))
 836         {
 837           if (REG_NOTE_KIND (link) == REG_DEAD)
 838             {
 839               rtx reg = XEXP (link, 0);
 840               int regno, i;
 841
 842               if (GET_CODE (reg) != REG)
 843                 abort ();
 844
 845               regno = REGNO (reg);
 846               if (regno >= FIRST_PSEUDO_REGISTER)
 847                 regno = reg_renumber[regno];
 848               if (regno < 0)
 849                 continue;
 850               for (i = HARD_REGNO_NREGS (regno, GET_MODE (reg)) - 1;
 851                    i >= 0; i--)
 852                 SET_REGNO_REG_SET (&new->live_throughout, regno + i);
 853             }
 854         }
 855       CLEAR_REG_SET (&new->dead_or_set);
 856       if (chain->insn == BLOCK_HEAD (chain->block))
 857         BLOCK_HEAD (chain->block) = new->insn;
 858     }
 859   else
 860     {
 861       new->next = chain->next;
 862       if (new->next != 0)
 863         new->next->prev = new;
 864       chain->next = new;
 865       new->prev = chain;
 866       new->insn = emit_insn_after (pat, insn);
 867       /* ??? It would be nice if we could exclude the already / still saved
 868          registers from the live sets, and observe REG_UNUSED notes.  */
 869       COPY_REG_SET (&new->live_throughout, &chain->live_throughout);
 870       /* Registers that are set in CHAIN->INSN live in the new insn.
 871          (Unless there is a REG_UNUSED note for them, but we don't
 872           look for them here.) */
 873       note_stores (PATTERN (chain->insn), add_stored_regs,
 874                    &new->live_throughout);
 875       CLEAR_REG_SET (&new->dead_or_set);
 876       if (chain->insn == BLOCK_END (chain->block))
 877         BLOCK_END (chain->block) = new->insn;
 878     }
 879   new->block = chain->block;
 880   new->is_caller_save_insn = 1;
 881
 882   INSN_CODE (new->insn) = code;
 883   return new;
 884 }