gcc/caller-save.c

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