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, 1999, 2000,
   3    2001, 2002, 2003, 2004, 2005, 2006, 2007, 2008, 2009, 2010
   4    Free Software Foundation, Inc.
   5
   6 This file is part of GCC.
   7
   8 GCC is free software; you can redistribute it and/or modify it under
   9 the terms of the GNU General Public License as published by the Free
  10 Software Foundation; either version 3, or (at your option) any later
  11 version.
  12
  13 GCC is distributed in the hope that it will be useful, but WITHOUT ANY
  14 WARRANTY; without even the implied warranty of MERCHANTABILITY or
  15 FITNESS FOR A PARTICULAR PURPOSE.  See the GNU General Public License
  16 for more details.
  17
  18 You should have received a copy of the GNU General Public License
  19 along with GCC; see the file COPYING3.  If not see
  20 <http://www.gnu.org/licenses/>.  */
  21
  22 #include "config.h"
  23 #include "system.h"
  24 #include "coretypes.h"
  25 #include "tm.h"
  26 #include "rtl.h"
  27 #include "regs.h"
  28 #include "insn-config.h"
  29 #include "flags.h"
  30 #include "hard-reg-set.h"
  31 #include "recog.h"
  32 #include "basic-block.h"
  33 #include "df.h"
  34 #include "reload.h"
  35 #include "function.h"
  36 #include "expr.h"
  37 #include "diagnostic-core.h"
  38 #include "toplev.h"
  39 #include "tm_p.h"
  40 #include "addresses.h"
  41 #include "output.h"
  42 #include "ggc.h"
  43
  44 #define MOVE_MAX_WORDS (MOVE_MAX / UNITS_PER_WORD)
  45
  46 #define regno_save_mode \
  47   (this_target_reload->x_regno_save_mode)
  48 #define cached_reg_save_code \
  49   (this_target_reload->x_cached_reg_save_code)
  50 #define cached_reg_restore_code \
  51   (this_target_reload->x_cached_reg_restore_code)
  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 /* The number of elements in the subsequent array.  */
  60 static int save_slots_num;
  61
  62 /* Allocated slots so far.  */
  63 static rtx save_slots[FIRST_PSEUDO_REGISTER];
  64
  65 /* Set of hard regs currently residing in save area (during insn scan).  */
  66
  67 static HARD_REG_SET hard_regs_saved;
  68
  69 /* Number of registers currently in hard_regs_saved.  */
  70
  71 static int n_regs_saved;
  72
  73 /* Computed by mark_referenced_regs, all regs referenced in a given
  74    insn.  */
  75 static HARD_REG_SET referenced_regs;
  76
  77
  78 typedef void refmarker_fn (rtx *loc, enum machine_mode mode, int hardregno,
  79                            void *mark_arg);
  80
  81 static int reg_save_code (int, enum machine_mode);
  82 static int reg_restore_code (int, enum machine_mode);
  83
  84 struct saved_hard_reg;
  85 static void initiate_saved_hard_regs (void);
  86 static struct saved_hard_reg *new_saved_hard_reg (int, int);
  87 static void finish_saved_hard_regs (void);
  88 static int saved_hard_reg_compare_func (const void *, const void *);
  89
  90 static void mark_set_regs (rtx, const_rtx, void *);
  91 static void mark_referenced_regs (rtx *, refmarker_fn *mark, void *mark_arg);
  92 static refmarker_fn mark_reg_as_referenced;
  93 static refmarker_fn replace_reg_with_saved_mem;
  94 static int insert_save (struct insn_chain *, int, int, HARD_REG_SET *,
  95                         enum machine_mode *);
  96 static int insert_restore (struct insn_chain *, int, int, int,
  97                            enum machine_mode *);
  98 static struct insn_chain *insert_one_insn (struct insn_chain *, int, int,
  99                                            rtx);
 100 static void add_stored_regs (rtx, const_rtx, void *);
 101
 102 \f
 103
 104 static GTY(()) rtx savepat;
 105 static GTY(()) rtx restpat;
 106 static GTY(()) rtx test_reg;
 107 static GTY(()) rtx test_mem;
 108 static GTY(()) rtx saveinsn;
 109 static GTY(()) rtx restinsn;
 110
 111 /* Return the INSN_CODE used to save register REG in mode MODE.  */
 112 static int
 113 reg_save_code (int reg, enum machine_mode mode)
 114 {
 115   bool ok;
 116   if (cached_reg_save_code[reg][mode])
 117      return cached_reg_save_code[reg][mode];
 118   if (!HARD_REGNO_MODE_OK (reg, mode))
 119      {
 120        cached_reg_save_code[reg][mode] = -1;
 121        cached_reg_restore_code[reg][mode] = -1;
 122        return -1;
 123      }
 124
 125   /* Update the register number and modes of the register
 126      and memory operand.  */
 127   SET_REGNO_RAW (test_reg, reg);
 128   PUT_MODE (test_reg, mode);
 129   PUT_MODE (test_mem, mode);
 130
 131   /* Force re-recognition of the modified insns.  */
 132   INSN_CODE (saveinsn) = -1;
 133   INSN_CODE (restinsn) = -1;
 134
 135   cached_reg_save_code[reg][mode] = recog_memoized (saveinsn);
 136   cached_reg_restore_code[reg][mode] = recog_memoized (restinsn);
 137
 138   /* Now extract both insns and see if we can meet their
 139      constraints.  */
 140   ok = (cached_reg_save_code[reg][mode] != -1
 141         && cached_reg_restore_code[reg][mode] != -1);
 142   if (ok)
 143     {
 144       extract_insn (saveinsn);
 145       ok = constrain_operands (1);
 146       extract_insn (restinsn);
 147       ok &= constrain_operands (1);
 148     }
 149
 150   if (! ok)
 151     {
 152       cached_reg_save_code[reg][mode] = -1;
 153       cached_reg_restore_code[reg][mode] = -1;
 154     }
 155   gcc_assert (cached_reg_save_code[reg][mode]);
 156   return cached_reg_save_code[reg][mode];
 157 }
 158
 159 /* Return the INSN_CODE used to restore register REG in mode MODE.  */
 160 static int
 161 reg_restore_code (int reg, enum machine_mode mode)
 162 {
 163   if (cached_reg_restore_code[reg][mode])
 164      return cached_reg_restore_code[reg][mode];
 165   /* Populate our cache.  */
 166   reg_save_code (reg, mode);
 167   return cached_reg_restore_code[reg][mode];
 168 }
 169 \f
 170 /* Initialize for caller-save.
 171
 172    Look at all the hard registers that are used by a call and for which
 173    reginfo.c has not already excluded from being used across a call.
 174
 175    Ensure that we can find a mode to save the register and that there is a
 176    simple insn to save and restore the register.  This latter check avoids
 177    problems that would occur if we tried to save the MQ register of some
 178    machines directly into memory.  */
 179
 180 void
 181 init_caller_save (void)
 182 {
 183   rtx addr_reg;
 184   int offset;
 185   rtx address;
 186   int i, j;
 187
 188   if (caller_save_initialized_p)
 189     return;
 190
 191   caller_save_initialized_p = true;
 192
 193   CLEAR_HARD_REG_SET (no_caller_save_reg_set);
 194   /* First find all the registers that we need to deal with and all
 195      the modes that they can have.  If we can't find a mode to use,
 196      we can't have the register live over calls.  */
 197
 198   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 199     {
 200       if (call_used_regs[i]
 201           && !TEST_HARD_REG_BIT (call_fixed_reg_set, i))
 202         {
 203           for (j = 1; j <= MOVE_MAX_WORDS; j++)
 204             {
 205               regno_save_mode[i][j] = HARD_REGNO_CALLER_SAVE_MODE (i, j,
 206                                                                    VOIDmode);
 207               if (regno_save_mode[i][j] == VOIDmode && j == 1)
 208                 {
 209                   SET_HARD_REG_BIT (call_fixed_reg_set, i);
 210                 }
 211             }
 212         }
 213       else
 214         regno_save_mode[i][1] = VOIDmode;
 215     }
 216
 217   /* The following code tries to approximate the conditions under which
 218      we can easily save and restore a register without scratch registers or
 219      other complexities.  It will usually work, except under conditions where
 220      the validity of an insn operand is dependent on the address offset.
 221      No such cases are currently known.
 222
 223      We first find a typical offset from some BASE_REG_CLASS register.
 224      This address is chosen by finding the first register in the class
 225      and by finding the smallest power of two that is a valid offset from
 226      that register in every mode we will use to save registers.  */
 227
 228   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 229     if (TEST_HARD_REG_BIT
 230         (reg_class_contents
 231          [(int) base_reg_class (regno_save_mode[i][1], PLUS, CONST_INT)], i))
 232       break;
 233
 234   gcc_assert (i < FIRST_PSEUDO_REGISTER);
 235
 236   addr_reg = gen_rtx_REG (Pmode, i);
 237
 238   for (offset = 1 << (HOST_BITS_PER_INT / 2); offset; offset >>= 1)
 239     {
 240       address = gen_rtx_PLUS (Pmode, addr_reg, GEN_INT (offset));
 241
 242       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 243         if (regno_save_mode[i][1] != VOIDmode
 244           && ! strict_memory_address_p (regno_save_mode[i][1], address))
 245           break;
 246
 247       if (i == FIRST_PSEUDO_REGISTER)
 248         break;
 249     }
 250
 251   /* If we didn't find a valid address, we must use register indirect.  */
 252   if (offset == 0)
 253     address = addr_reg;
 254
 255   /* Next we try to form an insn to save and restore the register.  We
 256      see if such an insn is recognized and meets its constraints.
 257
 258      To avoid lots of unnecessary RTL allocation, we construct all the RTL
 259      once, then modify the memory and register operands in-place.  */
 260
 261   test_reg = gen_rtx_REG (VOIDmode, 0);
 262   test_mem = gen_rtx_MEM (VOIDmode, address);
 263   savepat = gen_rtx_SET (VOIDmode, test_mem, test_reg);
 264   restpat = gen_rtx_SET (VOIDmode, test_reg, test_mem);
 265
 266   saveinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, savepat, 0, -1, 0);
 267   restinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, restpat, 0, -1, 0);
 268
 269   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 270     for (j = 1; j <= MOVE_MAX_WORDS; j++)
 271       if (reg_save_code (i,regno_save_mode[i][j]) == -1)
 272         {
 273           regno_save_mode[i][j] = VOIDmode;
 274           if (j == 1)
 275             {
 276               SET_HARD_REG_BIT (call_fixed_reg_set, i);
 277               if (call_used_regs[i])
 278                 SET_HARD_REG_BIT (no_caller_save_reg_set, i);
 279             }
 280         }
 281 }
 282
 283 \f
 284
 285 /* Initialize save areas by showing that we haven't allocated any yet.  */
 286
 287 void
 288 init_save_areas (void)
 289 {
 290   int i, j;
 291
 292   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 293     for (j = 1; j <= MOVE_MAX_WORDS; j++)
 294       regno_save_mem[i][j] = 0;
 295   save_slots_num = 0;
 296
 297 }
 298
 299 /* The structure represents a hard register which should be saved
 300    through the call.  It is used when the integrated register
 301    allocator (IRA) is used and sharing save slots is on.  */
 302 struct saved_hard_reg
 303 {
 304   /* Order number starting with 0.  */
 305   int num;
 306   /* The hard regno.  */
 307   int hard_regno;
 308   /* Execution frequency of all calls through which given hard
 309      register should be saved.  */
 310   int call_freq;
 311   /* Stack slot reserved to save the hard register through calls.  */
 312   rtx slot;
 313   /* True if it is first hard register in the chain of hard registers
 314      sharing the same stack slot.  */
 315   int first_p;
 316   /* Order number of the next hard register structure with the same
 317      slot in the chain.  -1 represents end of the chain.  */
 318   int next;
 319 };
 320
 321 /* Map: hard register number to the corresponding structure.  */
 322 static struct saved_hard_reg *hard_reg_map[FIRST_PSEUDO_REGISTER];
 323
 324 /* The number of all structures representing hard registers should be
 325    saved, in order words, the number of used elements in the following
 326    array.  */
 327 static int saved_regs_num;
 328
 329 /* Pointers to all the structures.  Index is the order number of the
 330    corresponding structure.  */
 331 static struct saved_hard_reg *all_saved_regs[FIRST_PSEUDO_REGISTER];
 332
 333 /* First called function for work with saved hard registers.  */
 334 static void
 335 initiate_saved_hard_regs (void)
 336 {
 337   int i;
 338
 339   saved_regs_num = 0;
 340   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 341     hard_reg_map[i] = NULL;
 342 }
 343
 344 /* Allocate and return new saved hard register with given REGNO and
 345    CALL_FREQ.  */
 346 static struct saved_hard_reg *
 347 new_saved_hard_reg (int regno, int call_freq)
 348 {
 349   struct saved_hard_reg *saved_reg;
 350
 351   saved_reg
 352     = (struct saved_hard_reg *) xmalloc (sizeof (struct saved_hard_reg));
 353   hard_reg_map[regno] = all_saved_regs[saved_regs_num] = saved_reg;
 354   saved_reg->num = saved_regs_num++;
 355   saved_reg->hard_regno = regno;
 356   saved_reg->call_freq = call_freq;
 357   saved_reg->first_p = FALSE;
 358   saved_reg->next = -1;
 359   return saved_reg;
 360 }
 361
 362 /* Free memory allocated for the saved hard registers.  */
 363 static void
 364 finish_saved_hard_regs (void)
 365 {
 366   int i;
 367
 368   for (i = 0; i < saved_regs_num; i++)
 369     free (all_saved_regs[i]);
 370 }
 371
 372 /* The function is used to sort the saved hard register structures
 373    according their frequency.  */
 374 static int
 375 saved_hard_reg_compare_func (const void *v1p, const void *v2p)
 376 {
 377   const struct saved_hard_reg *p1 = *(struct saved_hard_reg * const *) v1p;
 378   const struct saved_hard_reg *p2 = *(struct saved_hard_reg * const *) v2p;
 379
 380   if (flag_omit_frame_pointer)
 381     {
 382       if (p1->call_freq - p2->call_freq != 0)
 383         return p1->call_freq - p2->call_freq;
 384     }
 385   else if (p2->call_freq - p1->call_freq != 0)
 386     return p2->call_freq - p1->call_freq;
 387
 388   return p1->num - p2->num;
 389 }
 390
 391 /* Allocate save areas for any hard registers that might need saving.
 392    We take a conservative approach here and look for call-clobbered hard
 393    registers that are assigned to pseudos that cross calls.  This may
 394    overestimate slightly (especially if some of these registers are later
 395    used as spill registers), but it should not be significant.
 396
 397    For IRA we use priority coloring to decrease stack slots needed for
 398    saving hard registers through calls.  We build conflicts for them
 399    to do coloring.
 400
 401    Future work:
 402
 403      In the fallback case we should iterate backwards across all possible
 404      modes for the save, choosing the largest available one instead of
 405      falling back to the smallest mode immediately.  (eg TF -> DF -> SF).
 406
 407      We do not try to use "move multiple" instructions that exist
 408      on some machines (such as the 68k moveml).  It could be a win to try
 409      and use them when possible.  The hard part is doing it in a way that is
 410      machine independent since they might be saving non-consecutive
 411      registers. (imagine caller-saving d0,d1,a0,a1 on the 68k) */
 412
 413 void
 414 setup_save_areas (void)
 415 {
 416   int i, j, k;
 417   unsigned int r;
 418   HARD_REG_SET hard_regs_used;
 419
 420   /* Allocate space in the save area for the largest multi-register
 421      pseudos first, then work backwards to single register
 422      pseudos.  */
 423
 424   /* Find and record all call-used hard-registers in this function.  */
 425   CLEAR_HARD_REG_SET (hard_regs_used);
 426   for (i = FIRST_PSEUDO_REGISTER; i < max_regno; i++)
 427     if (reg_renumber[i] >= 0 && REG_N_CALLS_CROSSED (i) > 0)
 428       {
 429         unsigned int regno = reg_renumber[i];
 430         unsigned int endregno
 431           = end_hard_regno (GET_MODE (regno_reg_rtx[i]), regno);
 432         for (r = regno; r < endregno; r++)
 433           if (call_used_regs[r])
 434             SET_HARD_REG_BIT (hard_regs_used, r);
 435       }
 436
 437   if (optimize && flag_ira_share_save_slots)
 438     {
 439       rtx insn, slot;
 440       struct insn_chain *chain, *next;
 441       char *saved_reg_conflicts;
 442       unsigned int regno;
 443       int next_k, freq;
 444       struct saved_hard_reg *saved_reg, *saved_reg2, *saved_reg3;
 445       int call_saved_regs_num;
 446       struct saved_hard_reg *call_saved_regs[FIRST_PSEUDO_REGISTER];
 447       HARD_REG_SET hard_regs_to_save, used_regs, this_insn_sets;
 448       reg_set_iterator rsi;
 449       int best_slot_num;
 450       int prev_save_slots_num;
 451       rtx prev_save_slots[FIRST_PSEUDO_REGISTER];
 452
 453       initiate_saved_hard_regs ();
 454       /* Create hard reg saved regs.  */
 455       for (chain = reload_insn_chain; chain != 0; chain = next)
 456         {
 457           insn = chain->insn;
 458           next = chain->next;
 459           if (!CALL_P (insn)
 460               || find_reg_note (insn, REG_NORETURN, NULL))
 461             continue;
 462           freq = REG_FREQ_FROM_BB (BLOCK_FOR_INSN (insn));
 463           REG_SET_TO_HARD_REG_SET (hard_regs_to_save,
 464                                    &chain->live_throughout);
 465           COPY_HARD_REG_SET (used_regs, call_used_reg_set);
 466
 467           /* Record all registers set in this call insn.  These don't
 468              need to be saved.  N.B. the call insn might set a subreg
 469              of a multi-hard-reg pseudo; then the pseudo is considered
 470              live during the call, but the subreg that is set
 471              isn't.  */
 472           CLEAR_HARD_REG_SET (this_insn_sets);
 473           note_stores (PATTERN (insn), mark_set_regs, &this_insn_sets);
 474           /* Sibcalls are considered to set the return value.  */
 475           if (SIBLING_CALL_P (insn) && crtl->return_rtx)
 476             mark_set_regs (crtl->return_rtx, NULL_RTX, &this_insn_sets);
 477
 478           AND_COMPL_HARD_REG_SET (used_regs, call_fixed_reg_set);
 479           AND_COMPL_HARD_REG_SET (used_regs, this_insn_sets);
 480           AND_HARD_REG_SET (hard_regs_to_save, used_regs);
 481           for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 482             if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
 483               {
 484                 if (hard_reg_map[regno] != NULL)
 485                   hard_reg_map[regno]->call_freq += freq;
 486                 else
 487                   saved_reg = new_saved_hard_reg (regno, freq);
 488               }
 489           /* Look through all live pseudos, mark their hard registers.  */
 490           EXECUTE_IF_SET_IN_REG_SET
 491             (&chain->live_throughout, FIRST_PSEUDO_REGISTER, regno, rsi)
 492             {
 493               int r = reg_renumber[regno];
 494               int bound;
 495
 496               if (r < 0)
 497                 continue;
 498
 499               bound = r + hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
 500               for (; r < bound; r++)
 501                 if (TEST_HARD_REG_BIT (used_regs, r))
 502                   {
 503                     if (hard_reg_map[r] != NULL)
 504                       hard_reg_map[r]->call_freq += freq;
 505                     else
 506                       saved_reg = new_saved_hard_reg (r, freq);
 507                     SET_HARD_REG_BIT (hard_regs_to_save, r);
 508                   }
 509             }
 510         }
 511       /* Find saved hard register conflicts.  */
 512       saved_reg_conflicts = (char *) xmalloc (saved_regs_num * saved_regs_num);
 513       memset (saved_reg_conflicts, 0, saved_regs_num * saved_regs_num);
 514       for (chain = reload_insn_chain; chain != 0; chain = next)
 515         {
 516           call_saved_regs_num = 0;
 517           insn = chain->insn;
 518           next = chain->next;
 519           if (!CALL_P (insn)
 520               || find_reg_note (insn, REG_NORETURN, NULL))
 521             continue;
 522           REG_SET_TO_HARD_REG_SET (hard_regs_to_save,
 523                                    &chain->live_throughout);
 524           COPY_HARD_REG_SET (used_regs, call_used_reg_set);
 525
 526           /* Record all registers set in this call insn.  These don't
 527              need to be saved.  N.B. the call insn might set a subreg
 528              of a multi-hard-reg pseudo; then the pseudo is considered
 529              live during the call, but the subreg that is set
 530              isn't.  */
 531           CLEAR_HARD_REG_SET (this_insn_sets);
 532           note_stores (PATTERN (insn), mark_set_regs, &this_insn_sets);
 533           /* Sibcalls are considered to set the return value,
 534              compare df-scan.c:df_get_call_refs.  */
 535           if (SIBLING_CALL_P (insn) && crtl->return_rtx)
 536             mark_set_regs (crtl->return_rtx, NULL_RTX, &this_insn_sets);
 537
 538           AND_COMPL_HARD_REG_SET (used_regs, call_fixed_reg_set);
 539           AND_COMPL_HARD_REG_SET (used_regs, this_insn_sets);
 540           AND_HARD_REG_SET (hard_regs_to_save, used_regs);
 541           for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 542             if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
 543               {
 544                 gcc_assert (hard_reg_map[regno] != NULL);
 545                 call_saved_regs[call_saved_regs_num++] = hard_reg_map[regno];
 546               }
 547           /* Look through all live pseudos, mark their hard registers.  */
 548           EXECUTE_IF_SET_IN_REG_SET
 549             (&chain->live_throughout, FIRST_PSEUDO_REGISTER, regno, rsi)
 550             {
 551               int r = reg_renumber[regno];
 552               int bound;
 553
 554               if (r < 0)
 555                 continue;
 556
 557               bound = r + hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
 558               for (; r < bound; r++)
 559                 if (TEST_HARD_REG_BIT (used_regs, r))
 560                   call_saved_regs[call_saved_regs_num++] = hard_reg_map[r];
 561             }
 562           for (i = 0; i < call_saved_regs_num; i++)
 563             {
 564               saved_reg = call_saved_regs[i];
 565               for (j = 0; j < call_saved_regs_num; j++)
 566                 if (i != j)
 567                   {
 568                     saved_reg2 = call_saved_regs[j];
 569                     saved_reg_conflicts[saved_reg->num * saved_regs_num
 570                                         + saved_reg2->num]
 571                       = saved_reg_conflicts[saved_reg2->num * saved_regs_num
 572                                             + saved_reg->num]
 573                       = TRUE;
 574                   }
 575             }
 576         }
 577       /* Sort saved hard regs.  */
 578       qsort (all_saved_regs, saved_regs_num, sizeof (struct saved_hard_reg *),
 579              saved_hard_reg_compare_func);
 580       /* Initiate slots available from the previous reload
 581          iteration.  */
 582       prev_save_slots_num = save_slots_num;
 583       memcpy (prev_save_slots, save_slots, save_slots_num * sizeof (rtx));
 584       save_slots_num = 0;
 585       /* Allocate stack slots for the saved hard registers.  */
 586       for (i = 0; i < saved_regs_num; i++)
 587         {
 588           saved_reg = all_saved_regs[i];
 589           regno = saved_reg->hard_regno;
 590           for (j = 0; j < i; j++)
 591             {
 592               saved_reg2 = all_saved_regs[j];
 593               if (! saved_reg2->first_p)
 594                 continue;
 595               slot = saved_reg2->slot;
 596               for (k = j; k >= 0; k = next_k)
 597                 {
 598                   saved_reg3 = all_saved_regs[k];
 599                   next_k = saved_reg3->next;
 600                   if (saved_reg_conflicts[saved_reg->num * saved_regs_num
 601                                           + saved_reg3->num])
 602                     break;
 603                 }
 604               if (k < 0
 605                   && (GET_MODE_SIZE (regno_save_mode[regno][1])
 606                       <= GET_MODE_SIZE (regno_save_mode
 607                                         [saved_reg2->hard_regno][1])))
 608                 {
 609                   saved_reg->slot
 610                     = adjust_address_nv
 611                       (slot, regno_save_mode[saved_reg->hard_regno][1], 0);
 612                   regno_save_mem[regno][1] = saved_reg->slot;
 613                   saved_reg->next = saved_reg2->next;
 614                   saved_reg2->next = i;
 615                   if (dump_file != NULL)
 616                     fprintf (dump_file, "%d uses slot of %d\n",
 617                              regno, saved_reg2->hard_regno);
 618                   break;
 619                 }
 620             }
 621           if (j == i)
 622             {
 623               saved_reg->first_p = TRUE;
 624               for (best_slot_num = -1, j = 0; j < prev_save_slots_num; j++)
 625                 {
 626                   slot = prev_save_slots[j];
 627                   if (slot == NULL_RTX)
 628                     continue;
 629                   if (GET_MODE_SIZE (regno_save_mode[regno][1])
 630                       <= GET_MODE_SIZE (GET_MODE (slot))
 631                       && best_slot_num < 0)
 632                     best_slot_num = j;
 633                   if (GET_MODE (slot) == regno_save_mode[regno][1])
 634                     break;
 635                 }
 636               if (best_slot_num >= 0)
 637                 {
 638                   saved_reg->slot = prev_save_slots[best_slot_num];
 639                   saved_reg->slot
 640                     = adjust_address_nv
 641                       (saved_reg->slot,
 642                        regno_save_mode[saved_reg->hard_regno][1], 0);
 643                   if (dump_file != NULL)
 644                     fprintf (dump_file,
 645                              "%d uses a slot from prev iteration\n", regno);
 646                   prev_save_slots[best_slot_num] = NULL_RTX;
 647                   if (best_slot_num + 1 == prev_save_slots_num)
 648                     prev_save_slots_num--;
 649                 }
 650               else
 651                 {
 652                   saved_reg->slot
 653                     = assign_stack_local_1
 654                       (regno_save_mode[regno][1],
 655                        GET_MODE_SIZE (regno_save_mode[regno][1]), 0, true);
 656                   if (dump_file != NULL)
 657                     fprintf (dump_file, "%d uses a new slot\n", regno);
 658                 }
 659               regno_save_mem[regno][1] = saved_reg->slot;
 660               save_slots[save_slots_num++] = saved_reg->slot;
 661             }
 662         }
 663       free (saved_reg_conflicts);
 664       finish_saved_hard_regs ();
 665     }
 666   else
 667     {
 668       /* Now run through all the call-used hard-registers and allocate
 669          space for them in the caller-save area.  Try to allocate space
 670          in a manner which allows multi-register saves/restores to be done.  */
 671
 672       for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 673         for (j = MOVE_MAX_WORDS; j > 0; j--)
 674           {
 675             int do_save = 1;
 676
 677             /* If no mode exists for this size, try another.  Also break out
 678                if we have already saved this hard register.  */
 679             if (regno_save_mode[i][j] == VOIDmode || regno_save_mem[i][1] != 0)
 680               continue;
 681
 682             /* See if any register in this group has been saved.  */
 683             for (k = 0; k < j; k++)
 684               if (regno_save_mem[i + k][1])
 685                 {
 686                   do_save = 0;
 687                   break;
 688                 }
 689             if (! do_save)
 690               continue;
 691
 692             for (k = 0; k < j; k++)
 693               if (! TEST_HARD_REG_BIT (hard_regs_used, i + k))
 694                 {
 695                   do_save = 0;
 696                   break;
 697                 }
 698             if (! do_save)
 699               continue;
 700
 701             /* We have found an acceptable mode to store in.  Since
 702                hard register is always saved in the widest mode
 703                available, the mode may be wider than necessary, it is
 704                OK to reduce the alignment of spill space.  We will
 705                verify that it is equal to or greater than required
 706                when we restore and save the hard register in
 707                insert_restore and insert_save.  */
 708             regno_save_mem[i][j]
 709               = assign_stack_local_1 (regno_save_mode[i][j],
 710                                       GET_MODE_SIZE (regno_save_mode[i][j]),
 711                                       0, true);
 712
 713             /* Setup single word save area just in case...  */
 714             for (k = 0; k < j; k++)
 715               /* This should not depend on WORDS_BIG_ENDIAN.
 716                  The order of words in regs is the same as in memory.  */
 717               regno_save_mem[i + k][1]
 718                 = adjust_address_nv (regno_save_mem[i][j],
 719                                      regno_save_mode[i + k][1],
 720                                      k * UNITS_PER_WORD);
 721           }
 722     }
 723
 724   /* Now loop again and set the alias set of any save areas we made to
 725      the alias set used to represent frame objects.  */
 726   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 727     for (j = MOVE_MAX_WORDS; j > 0; j--)
 728       if (regno_save_mem[i][j] != 0)
 729         set_mem_alias_set (regno_save_mem[i][j], get_frame_alias_set ());
 730 }
 731
 732 \f
 733
 734 /* Find the places where hard regs are live across calls and save them.  */
 735
 736 void
 737 save_call_clobbered_regs (void)
 738 {
 739   struct insn_chain *chain, *next, *last = NULL;
 740   enum machine_mode save_mode [FIRST_PSEUDO_REGISTER];
 741
 742   /* Computed in mark_set_regs, holds all registers set by the current
 743      instruction.  */
 744   HARD_REG_SET this_insn_sets;
 745
 746   CLEAR_HARD_REG_SET (hard_regs_saved);
 747   n_regs_saved = 0;
 748
 749   for (chain = reload_insn_chain; chain != 0; chain = next)
 750     {
 751       rtx insn = chain->insn;
 752       enum rtx_code code = GET_CODE (insn);
 753
 754       next = chain->next;
 755
 756       gcc_assert (!chain->is_caller_save_insn);
 757
 758       if (NONDEBUG_INSN_P (insn))
 759         {
 760           /* If some registers have been saved, see if INSN references
 761              any of them.  We must restore them before the insn if so.  */
 762
 763           if (n_regs_saved)
 764             {
 765               int regno;
 766               HARD_REG_SET this_insn_sets;
 767
 768               if (code == JUMP_INSN)
 769                 /* Restore all registers if this is a JUMP_INSN.  */
 770                 COPY_HARD_REG_SET (referenced_regs, hard_regs_saved);
 771               else
 772                 {
 773                   CLEAR_HARD_REG_SET (referenced_regs);
 774                   mark_referenced_regs (&PATTERN (insn),
 775                                         mark_reg_as_referenced, NULL);
 776                   AND_HARD_REG_SET (referenced_regs, hard_regs_saved);
 777                 }
 778
 779               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 780                 if (TEST_HARD_REG_BIT (referenced_regs, regno))
 781                   regno += insert_restore (chain, 1, regno, MOVE_MAX_WORDS,
 782                                            save_mode);
 783               /* If a saved register is set after the call, this means we no
 784                  longer should restore it.  This can happen when parts of a
 785                  multi-word pseudo do not conflict with other pseudos, so
 786                  IRA may allocate the same hard register for both.  One may
 787                  be live across the call, while the other is set
 788                  afterwards.  */
 789               CLEAR_HARD_REG_SET (this_insn_sets);
 790               note_stores (PATTERN (insn), mark_set_regs, &this_insn_sets);
 791               AND_COMPL_HARD_REG_SET (hard_regs_saved, this_insn_sets);
 792             }
 793
 794           if (code == CALL_INSN
 795               && ! SIBLING_CALL_P (insn)
 796               && ! find_reg_note (insn, REG_NORETURN, NULL))
 797             {
 798               unsigned regno;
 799               HARD_REG_SET hard_regs_to_save;
 800               reg_set_iterator rsi;
 801
 802               /* Use the register life information in CHAIN to compute which
 803                  regs are live during the call.  */
 804               REG_SET_TO_HARD_REG_SET (hard_regs_to_save,
 805                                        &chain->live_throughout);
 806               /* Save hard registers always in the widest mode available.  */
 807               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 808                 if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
 809                   save_mode [regno] = regno_save_mode [regno][1];
 810                 else
 811                   save_mode [regno] = VOIDmode;
 812
 813               /* Look through all live pseudos, mark their hard registers
 814                  and choose proper mode for saving.  */
 815               EXECUTE_IF_SET_IN_REG_SET
 816                 (&chain->live_throughout, FIRST_PSEUDO_REGISTER, regno, rsi)
 817                 {
 818                   int r = reg_renumber[regno];
 819                   int nregs;
 820                   enum machine_mode mode;
 821
 822                   if (r < 0)
 823                     continue;
 824                   nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
 825                   mode = HARD_REGNO_CALLER_SAVE_MODE
 826                     (r, nregs, PSEUDO_REGNO_MODE (regno));
 827                   if (GET_MODE_BITSIZE (mode)
 828                       > GET_MODE_BITSIZE (save_mode[r]))
 829                     save_mode[r] = mode;
 830                   while (nregs-- > 0)
 831                     SET_HARD_REG_BIT (hard_regs_to_save, r + nregs);
 832                 }
 833
 834               /* Record all registers set in this call insn.  These don't need
 835                  to be saved.  N.B. the call insn might set a subreg of a
 836                  multi-hard-reg pseudo; then the pseudo is considered live
 837                  during the call, but the subreg that is set isn't.  */
 838               CLEAR_HARD_REG_SET (this_insn_sets);
 839               note_stores (PATTERN (insn), mark_set_regs, &this_insn_sets);
 840
 841               /* Compute which hard regs must be saved before this call.  */
 842               AND_COMPL_HARD_REG_SET (hard_regs_to_save, call_fixed_reg_set);
 843               AND_COMPL_HARD_REG_SET (hard_regs_to_save, this_insn_sets);
 844               AND_COMPL_HARD_REG_SET (hard_regs_to_save, hard_regs_saved);
 845               AND_HARD_REG_SET (hard_regs_to_save, call_used_reg_set);
 846
 847               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 848                 if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
 849                   regno += insert_save (chain, 1, regno, &hard_regs_to_save, save_mode);
 850
 851               /* Must recompute n_regs_saved.  */
 852               n_regs_saved = 0;
 853               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 854                 if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
 855                   n_regs_saved++;
 856             }
 857           last = chain;
 858         }
 859       else if (DEBUG_INSN_P (insn) && n_regs_saved)
 860         mark_referenced_regs (&PATTERN (insn),
 861                               replace_reg_with_saved_mem,
 862                               save_mode);
 863
 864       if (chain->next == 0 || chain->next->block != chain->block)
 865         {
 866           int regno;
 867           /* At the end of the basic block, we must restore any registers that
 868              remain saved.  If the last insn in the block is a JUMP_INSN, put
 869              the restore before the insn, otherwise, put it after the insn.  */
 870
 871           if (n_regs_saved
 872               && DEBUG_INSN_P (insn)
 873               && last
 874               && last->block == chain->block)
 875             {
 876               rtx ins, prev;
 877               basic_block bb = BLOCK_FOR_INSN (insn);
 878
 879               /* When adding hard reg restores after a DEBUG_INSN, move
 880                  all notes between last real insn and this DEBUG_INSN after
 881                  the DEBUG_INSN, otherwise we could get code
 882                  -g/-g0 differences.  */
 883               for (ins = PREV_INSN (insn); ins != last->insn; ins = prev)
 884                 {
 885                   prev = PREV_INSN (ins);
 886                   if (NOTE_P (ins))
 887                     {
 888                       NEXT_INSN (prev) = NEXT_INSN (ins);
 889                       PREV_INSN (NEXT_INSN (ins)) = prev;
 890                       PREV_INSN (ins) = insn;
 891                       NEXT_INSN (ins) = NEXT_INSN (insn);
 892                       NEXT_INSN (insn) = ins;
 893                       if (NEXT_INSN (ins))
 894                         PREV_INSN (NEXT_INSN (ins)) = ins;
 895                       if (BB_END (bb) == insn)
 896                         BB_END (bb) = ins;
 897                     }
 898                   else
 899                     gcc_assert (DEBUG_INSN_P (ins));
 900                 }
 901             }
 902           last = NULL;
 903
 904           if (n_regs_saved)
 905             for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 906               if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
 907                 regno += insert_restore (chain, JUMP_P (insn),
 908                                          regno, MOVE_MAX_WORDS, save_mode);
 909         }
 910     }
 911 }
 912
 913 /* Here from note_stores, or directly from save_call_clobbered_regs, when
 914    an insn stores a value in a register.
 915    Set the proper bit or bits in this_insn_sets.  All pseudos that have
 916    been assigned hard regs have had their register number changed already,
 917    so we can ignore pseudos.  */
 918 static void
 919 mark_set_regs (rtx reg, const_rtx setter ATTRIBUTE_UNUSED, void *data)
 920 {
 921   int regno, endregno, i;
 922   HARD_REG_SET *this_insn_sets = (HARD_REG_SET *) data;
 923
 924   if (GET_CODE (reg) == SUBREG)
 925     {
 926       rtx inner = SUBREG_REG (reg);
 927       if (!REG_P (inner) || REGNO (inner) >= FIRST_PSEUDO_REGISTER)
 928         return;
 929       regno = subreg_regno (reg);
 930       endregno = regno + subreg_nregs (reg);
 931     }
 932   else if (REG_P (reg)
 933            && REGNO (reg) < FIRST_PSEUDO_REGISTER)
 934     {
 935       regno = REGNO (reg);
 936       endregno = END_HARD_REGNO (reg);
 937     }
 938   else
 939     return;
 940
 941   for (i = regno; i < endregno; i++)
 942     SET_HARD_REG_BIT (*this_insn_sets, i);
 943 }
 944
 945 /* Here from note_stores when an insn stores a value in a register.
 946    Set the proper bit or bits in the passed regset.  All pseudos that have
 947    been assigned hard regs have had their register number changed already,
 948    so we can ignore pseudos.  */
 949 static void
 950 add_stored_regs (rtx reg, const_rtx setter, void *data)
 951 {
 952   int regno, endregno, i;
 953   enum machine_mode mode = GET_MODE (reg);
 954   int offset = 0;
 955
 956   if (GET_CODE (setter) == CLOBBER)
 957     return;
 958
 959   if (GET_CODE (reg) == SUBREG
 960       && REG_P (SUBREG_REG (reg))
 961       && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER)
 962     {
 963       offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)),
 964                                     GET_MODE (SUBREG_REG (reg)),
 965                                     SUBREG_BYTE (reg),
 966                                     GET_MODE (reg));
 967       regno = REGNO (SUBREG_REG (reg)) + offset;
 968       endregno = regno + subreg_nregs (reg);
 969     }
 970   else
 971     {
 972       if (!REG_P (reg) || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
 973         return;
 974
 975       regno = REGNO (reg) + offset;
 976       endregno = end_hard_regno (mode, regno);
 977     }
 978
 979   for (i = regno; i < endregno; i++)
 980     SET_REGNO_REG_SET ((regset) data, i);
 981 }
 982
 983 /* Walk X and record all referenced registers in REFERENCED_REGS.  */
 984 static void
 985 mark_referenced_regs (rtx *loc, refmarker_fn *mark, void *arg)
 986 {
 987   enum rtx_code code = GET_CODE (*loc);
 988   const char *fmt;
 989   int i, j;
 990
 991   if (code == SET)
 992     mark_referenced_regs (&SET_SRC (*loc), mark, arg);
 993   if (code == SET || code == CLOBBER)
 994     {
 995       loc = &SET_DEST (*loc);
 996       code = GET_CODE (*loc);
 997       if ((code == REG && REGNO (*loc) < FIRST_PSEUDO_REGISTER)
 998           || code == PC || code == CC0
 999           || (code == SUBREG && REG_P (SUBREG_REG (*loc))
1000               && REGNO (SUBREG_REG (*loc)) < FIRST_PSEUDO_REGISTER
1001               /* If we're setting only part of a multi-word register,
1002                  we shall mark it as referenced, because the words
1003                  that are not being set should be restored.  */
1004               && ((GET_MODE_SIZE (GET_MODE (*loc))
1005                    >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (*loc))))
1006                   || (GET_MODE_SIZE (GET_MODE (SUBREG_REG (*loc)))
1007                       <= UNITS_PER_WORD))))
1008         return;
1009     }
1010   if (code == MEM || code == SUBREG)
1011     {
1012       loc = &XEXP (*loc, 0);
1013       code = GET_CODE (*loc);
1014     }
1015
1016   if (code == REG)
1017     {
1018       int regno = REGNO (*loc);
1019       int hardregno = (regno < FIRST_PSEUDO_REGISTER ? regno
1020                        : reg_renumber[regno]);
1021
1022       if (hardregno >= 0)
1023         mark (loc, GET_MODE (*loc), hardregno, arg);
1024       else if (arg)
1025         /* ??? Will we ever end up with an equiv expression in a debug
1026            insn, that would have required restoring a reg, or will
1027            reload take care of it for us?  */
1028         return;
1029       /* If this is a pseudo that did not get a hard register, scan its
1030          memory location, since it might involve the use of another
1031          register, which might be saved.  */
1032       else if (reg_equiv_mem[regno] != 0)
1033         mark_referenced_regs (&XEXP (reg_equiv_mem[regno], 0), mark, arg);
1034       else if (reg_equiv_address[regno] != 0)
1035         mark_referenced_regs (&reg_equiv_address[regno], mark, arg);
1036       return;
1037     }
1038
1039   fmt = GET_RTX_FORMAT (code);
1040   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1041     {
1042       if (fmt[i] == 'e')
1043         mark_referenced_regs (&XEXP (*loc, i), mark, arg);
1044       else if (fmt[i] == 'E')
1045         for (j = XVECLEN (*loc, i) - 1; j >= 0; j--)
1046           mark_referenced_regs (&XVECEXP (*loc, i, j), mark, arg);
1047     }
1048 }
1049
1050 /* Parameter function for mark_referenced_regs() that adds registers
1051    present in the insn and in equivalent mems and addresses to
1052    referenced_regs.  */
1053
1054 static void
1055 mark_reg_as_referenced (rtx *loc ATTRIBUTE_UNUSED,
1056                         enum machine_mode mode,
1057                         int hardregno,
1058                         void *arg ATTRIBUTE_UNUSED)
1059 {
1060   add_to_hard_reg_set (&referenced_regs, mode, hardregno);
1061 }
1062
1063 /* Parameter function for mark_referenced_regs() that replaces
1064    registers referenced in a debug_insn that would have been restored,
1065    should it be a non-debug_insn, with their save locations.  */
1066
1067 static void
1068 replace_reg_with_saved_mem (rtx *loc,
1069                             enum machine_mode mode,
1070                             int regno,
1071                             void *arg)
1072 {
1073   unsigned int i, nregs = hard_regno_nregs [regno][mode];
1074   rtx mem;
1075   enum machine_mode *save_mode = (enum machine_mode *)arg;
1076
1077   for (i = 0; i < nregs; i++)
1078     if (TEST_HARD_REG_BIT (hard_regs_saved, regno + i))
1079       break;
1080
1081   /* If none of the registers in the range would need restoring, we're
1082      all set.  */
1083   if (i == nregs)
1084     return;
1085
1086   while (++i < nregs)
1087     if (!TEST_HARD_REG_BIT (hard_regs_saved, regno + i))
1088       break;
1089
1090   if (i == nregs
1091       && regno_save_mem[regno][nregs])
1092     {
1093       mem = copy_rtx (regno_save_mem[regno][nregs]);
1094
1095       if (nregs == (unsigned int) hard_regno_nregs[regno][save_mode[regno]])
1096         mem = adjust_address_nv (mem, save_mode[regno], 0);
1097
1098       if (GET_MODE (mem) != mode)
1099         {
1100           /* This is gen_lowpart_if_possible(), but without validating
1101              the newly-formed address.  */
1102           int offset = 0;
1103
1104           if (WORDS_BIG_ENDIAN)
1105             offset = (MAX (GET_MODE_SIZE (GET_MODE (mem)), UNITS_PER_WORD)
1106                       - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
1107           if (BYTES_BIG_ENDIAN)
1108             /* Adjust the address so that the address-after-the-data is
1109                unchanged.  */
1110             offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
1111                        - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (mem))));
1112
1113           mem = adjust_address_nv (mem, mode, offset);
1114         }
1115     }
1116   else
1117     {
1118       mem = gen_rtx_CONCATN (mode, rtvec_alloc (nregs));
1119       for (i = 0; i < nregs; i++)
1120         if (TEST_HARD_REG_BIT (hard_regs_saved, regno + i))
1121           {
1122             gcc_assert (regno_save_mem[regno + i][1]);
1123             XVECEXP (mem, 0, i) = copy_rtx (regno_save_mem[regno + i][1]);
1124           }
1125         else
1126           {
1127             gcc_assert (save_mode[regno] != VOIDmode);
1128             XVECEXP (mem, 0, i) = gen_rtx_REG (save_mode [regno],
1129                                                regno + i);
1130           }
1131     }
1132
1133   gcc_assert (GET_MODE (mem) == mode);
1134   *loc = mem;
1135 }
1136
1137 \f
1138 /* Insert a sequence of insns to restore.  Place these insns in front of
1139    CHAIN if BEFORE_P is nonzero, behind the insn otherwise.  MAXRESTORE is
1140    the maximum number of registers which should be restored during this call.
1141    It should never be less than 1 since we only work with entire registers.
1142
1143    Note that we have verified in init_caller_save that we can do this
1144    with a simple SET, so use it.  Set INSN_CODE to what we save there
1145    since the address might not be valid so the insn might not be recognized.
1146    These insns will be reloaded and have register elimination done by
1147    find_reload, so we need not worry about that here.
1148
1149    Return the extra number of registers saved.  */
1150
1151 static int
1152 insert_restore (struct insn_chain *chain, int before_p, int regno,
1153                 int maxrestore, enum machine_mode *save_mode)
1154 {
1155   int i, k;
1156   rtx pat = NULL_RTX;
1157   int code;
1158   unsigned int numregs = 0;
1159   struct insn_chain *new_chain;
1160   rtx mem;
1161
1162   /* A common failure mode if register status is not correct in the
1163      RTL is for this routine to be called with a REGNO we didn't
1164      expect to save.  That will cause us to write an insn with a (nil)
1165      SET_DEST or SET_SRC.  Instead of doing so and causing a crash
1166      later, check for this common case here instead.  This will remove
1167      one step in debugging such problems.  */
1168   gcc_assert (regno_save_mem[regno][1]);
1169
1170   /* Get the pattern to emit and update our status.
1171
1172      See if we can restore `maxrestore' registers at once.  Work
1173      backwards to the single register case.  */
1174   for (i = maxrestore; i > 0; i--)
1175     {
1176       int j;
1177       int ok = 1;
1178
1179       if (regno_save_mem[regno][i] == 0)
1180         continue;
1181
1182       for (j = 0; j < i; j++)
1183         if (! TEST_HARD_REG_BIT (hard_regs_saved, regno + j))
1184           {
1185             ok = 0;
1186             break;
1187           }
1188       /* Must do this one restore at a time.  */
1189       if (! ok)
1190         continue;
1191
1192       numregs = i;
1193       break;
1194     }
1195
1196   mem = regno_save_mem [regno][numregs];
1197   if (save_mode [regno] != VOIDmode
1198       && save_mode [regno] != GET_MODE (mem)
1199       && numregs == (unsigned int) hard_regno_nregs[regno][save_mode [regno]]
1200       /* Check that insn to restore REGNO in save_mode[regno] is
1201          correct.  */
1202       && reg_save_code (regno, save_mode[regno]) >= 0)
1203     mem = adjust_address_nv (mem, save_mode[regno], 0);
1204   else
1205     mem = copy_rtx (mem);
1206
1207   /* Verify that the alignment of spill space is equal to or greater
1208      than required.  */
1209   gcc_assert (MIN (MAX_SUPPORTED_STACK_ALIGNMENT,
1210                    GET_MODE_ALIGNMENT (GET_MODE (mem))) <= MEM_ALIGN (mem));
1211
1212   pat = gen_rtx_SET (VOIDmode,
1213                      gen_rtx_REG (GET_MODE (mem),
1214                                   regno), mem);
1215   code = reg_restore_code (regno, GET_MODE (mem));
1216   new_chain = insert_one_insn (chain, before_p, code, pat);
1217
1218   /* Clear status for all registers we restored.  */
1219   for (k = 0; k < i; k++)
1220     {
1221       CLEAR_HARD_REG_BIT (hard_regs_saved, regno + k);
1222       SET_REGNO_REG_SET (&new_chain->dead_or_set, regno + k);
1223       n_regs_saved--;
1224     }
1225
1226   /* Tell our callers how many extra registers we saved/restored.  */
1227   return numregs - 1;
1228 }
1229
1230 /* Like insert_restore above, but save registers instead.  */
1231
1232 static int
1233 insert_save (struct insn_chain *chain, int before_p, int regno,
1234              HARD_REG_SET (*to_save), enum machine_mode *save_mode)
1235 {
1236   int i;
1237   unsigned int k;
1238   rtx pat = NULL_RTX;
1239   int code;
1240   unsigned int numregs = 0;
1241   struct insn_chain *new_chain;
1242   rtx mem;
1243
1244   /* A common failure mode if register status is not correct in the
1245      RTL is for this routine to be called with a REGNO we didn't
1246      expect to save.  That will cause us to write an insn with a (nil)
1247      SET_DEST or SET_SRC.  Instead of doing so and causing a crash
1248      later, check for this common case here.  This will remove one
1249      step in debugging such problems.  */
1250   gcc_assert (regno_save_mem[regno][1]);
1251
1252   /* Get the pattern to emit and update our status.
1253
1254      See if we can save several registers with a single instruction.
1255      Work backwards to the single register case.  */
1256   for (i = MOVE_MAX_WORDS; i > 0; i--)
1257     {
1258       int j;
1259       int ok = 1;
1260       if (regno_save_mem[regno][i] == 0)
1261         continue;
1262
1263       for (j = 0; j < i; j++)
1264         if (! TEST_HARD_REG_BIT (*to_save, regno + j))
1265           {
1266             ok = 0;
1267             break;
1268           }
1269       /* Must do this one save at a time.  */
1270       if (! ok)
1271         continue;
1272
1273       numregs = i;
1274       break;
1275     }
1276
1277   mem = regno_save_mem [regno][numregs];
1278   if (save_mode [regno] != VOIDmode
1279       && save_mode [regno] != GET_MODE (mem)
1280       && numregs == (unsigned int) hard_regno_nregs[regno][save_mode [regno]]
1281       /* Check that insn to save REGNO in save_mode[regno] is
1282          correct.  */
1283       && reg_save_code (regno, save_mode[regno]) >= 0)
1284     mem = adjust_address_nv (mem, save_mode[regno], 0);
1285   else
1286     mem = copy_rtx (mem);
1287
1288   /* Verify that the alignment of spill space is equal to or greater
1289      than required.  */
1290   gcc_assert (MIN (MAX_SUPPORTED_STACK_ALIGNMENT,
1291                    GET_MODE_ALIGNMENT (GET_MODE (mem))) <= MEM_ALIGN (mem));
1292
1293   pat = gen_rtx_SET (VOIDmode, mem,
1294                      gen_rtx_REG (GET_MODE (mem),
1295                                   regno));
1296   code = reg_save_code (regno, GET_MODE (mem));
1297   new_chain = insert_one_insn (chain, before_p, code, pat);
1298
1299   /* Set hard_regs_saved and dead_or_set for all the registers we saved.  */
1300   for (k = 0; k < numregs; k++)
1301     {
1302       SET_HARD_REG_BIT (hard_regs_saved, regno + k);
1303       SET_REGNO_REG_SET (&new_chain->dead_or_set, regno + k);
1304       n_regs_saved++;
1305     }
1306
1307   /* Tell our callers how many extra registers we saved/restored.  */
1308   return numregs - 1;
1309 }
1310
1311 /* A for_each_rtx callback used by add_used_regs.  Add the hard-register
1312    equivalent of each REG to regset DATA.  */
1313
1314 static int
1315 add_used_regs_1 (rtx *loc, void *data)
1316 {
1317   int regno, i;
1318   regset live;
1319   rtx x;
1320
1321   x = *loc;
1322   live = (regset) data;
1323   if (REG_P (x))
1324     {
1325       regno = REGNO (x);
1326       if (!HARD_REGISTER_NUM_P (regno))
1327         regno = reg_renumber[regno];
1328       if (regno >= 0)
1329         for (i = hard_regno_nregs[regno][GET_MODE (x)] - 1; i >= 0; i--)
1330           SET_REGNO_REG_SET (live, regno + i);
1331     }
1332   return 0;
1333 }
1334
1335 /* A note_uses callback used by insert_one_insn.  Add the hard-register
1336    equivalent of each REG to regset DATA.  */
1337
1338 static void
1339 add_used_regs (rtx *loc, void *data)
1340 {
1341   for_each_rtx (loc, add_used_regs_1, data);
1342 }
1343
1344 /* Emit a new caller-save insn and set the code.  */
1345 static struct insn_chain *
1346 insert_one_insn (struct insn_chain *chain, int before_p, int code, rtx pat)
1347 {
1348   rtx insn = chain->insn;
1349   struct insn_chain *new_chain;
1350
1351 #ifdef HAVE_cc0
1352   /* If INSN references CC0, put our insns in front of the insn that sets
1353      CC0.  This is always safe, since the only way we could be passed an
1354      insn that references CC0 is for a restore, and doing a restore earlier
1355      isn't a problem.  We do, however, assume here that CALL_INSNs don't
1356      reference CC0.  Guard against non-INSN's like CODE_LABEL.  */
1357
1358   if ((NONJUMP_INSN_P (insn) || JUMP_P (insn))
1359       && before_p
1360       && reg_referenced_p (cc0_rtx, PATTERN (insn)))
1361     chain = chain->prev, insn = chain->insn;
1362 #endif
1363
1364   new_chain = new_insn_chain ();
1365   if (before_p)
1366     {
1367       rtx link;
1368
1369       new_chain->prev = chain->prev;
1370       if (new_chain->prev != 0)
1371         new_chain->prev->next = new_chain;
1372       else
1373         reload_insn_chain = new_chain;
1374
1375       chain->prev = new_chain;
1376       new_chain->next = chain;
1377       new_chain->insn = emit_insn_before (pat, insn);
1378       /* ??? It would be nice if we could exclude the already / still saved
1379          registers from the live sets.  */
1380       COPY_REG_SET (&new_chain->live_throughout, &chain->live_throughout);
1381       note_uses (&PATTERN (chain->insn), add_used_regs,
1382                  &new_chain->live_throughout);
1383       /* If CHAIN->INSN is a call, then the registers which contain
1384          the arguments to the function are live in the new insn.  */
1385       if (CALL_P (chain->insn))
1386         for (link = CALL_INSN_FUNCTION_USAGE (chain->insn);
1387              link != NULL_RTX;
1388              link = XEXP (link, 1))
1389           note_uses (&XEXP (link, 0), add_used_regs,
1390                      &new_chain->live_throughout);
1391
1392       CLEAR_REG_SET (&new_chain->dead_or_set);
1393       if (chain->insn == BB_HEAD (BASIC_BLOCK (chain->block)))
1394         BB_HEAD (BASIC_BLOCK (chain->block)) = new_chain->insn;
1395     }
1396   else
1397     {
1398       new_chain->next = chain->next;
1399       if (new_chain->next != 0)
1400         new_chain->next->prev = new_chain;
1401       chain->next = new_chain;
1402       new_chain->prev = chain;
1403       new_chain->insn = emit_insn_after (pat, insn);
1404       /* ??? It would be nice if we could exclude the already / still saved
1405          registers from the live sets, and observe REG_UNUSED notes.  */
1406       COPY_REG_SET (&new_chain->live_throughout, &chain->live_throughout);
1407       /* Registers that are set in CHAIN->INSN live in the new insn.
1408          (Unless there is a REG_UNUSED note for them, but we don't
1409           look for them here.) */
1410       note_stores (PATTERN (chain->insn), add_stored_regs,
1411                    &new_chain->live_throughout);
1412       CLEAR_REG_SET (&new_chain->dead_or_set);
1413       if (chain->insn == BB_END (BASIC_BLOCK (chain->block)))
1414         BB_END (BASIC_BLOCK (chain->block)) = new_chain->insn;
1415     }
1416   new_chain->block = chain->block;
1417   new_chain->is_caller_save_insn = 1;
1418
1419   INSN_CODE (new_chain->insn) = code;
1420   return new_chain;
1421 }
1422 #include "gt-caller-save.h"