gcc/caller-save.c

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