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