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 (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, 0, savepat, -1, 0);
 267   restinsn = gen_rtx_INSN (VOIDmode, 0, 0, 0, 0, 0, restpat, -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
 767               if (code == JUMP_INSN)
 768                 /* Restore all registers if this is a JUMP_INSN.  */
 769                 COPY_HARD_REG_SET (referenced_regs, hard_regs_saved);
 770               else
 771                 {
 772                   CLEAR_HARD_REG_SET (referenced_regs);
 773                   mark_referenced_regs (&PATTERN (insn),
 774                                         mark_reg_as_referenced, NULL);
 775                   AND_HARD_REG_SET (referenced_regs, hard_regs_saved);
 776                 }
 777
 778               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 779                 if (TEST_HARD_REG_BIT (referenced_regs, regno))
 780                   regno += insert_restore (chain, 1, regno, MOVE_MAX_WORDS, save_mode);
 781             }
 782
 783           if (code == CALL_INSN
 784               && ! SIBLING_CALL_P (insn)
 785               && ! find_reg_note (insn, REG_NORETURN, NULL))
 786             {
 787               unsigned regno;
 788               HARD_REG_SET hard_regs_to_save;
 789               reg_set_iterator rsi;
 790
 791               /* Use the register life information in CHAIN to compute which
 792                  regs are live during the call.  */
 793               REG_SET_TO_HARD_REG_SET (hard_regs_to_save,
 794                                        &chain->live_throughout);
 795               /* Save hard registers always in the widest mode available.  */
 796               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 797                 if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
 798                   save_mode [regno] = regno_save_mode [regno][1];
 799                 else
 800                   save_mode [regno] = VOIDmode;
 801
 802               /* Look through all live pseudos, mark their hard registers
 803                  and choose proper mode for saving.  */
 804               EXECUTE_IF_SET_IN_REG_SET
 805                 (&chain->live_throughout, FIRST_PSEUDO_REGISTER, regno, rsi)
 806                 {
 807                   int r = reg_renumber[regno];
 808                   int nregs;
 809                   enum machine_mode mode;
 810
 811                   if (r < 0)
 812                     continue;
 813                   nregs = hard_regno_nregs[r][PSEUDO_REGNO_MODE (regno)];
 814                   mode = HARD_REGNO_CALLER_SAVE_MODE
 815                     (r, nregs, PSEUDO_REGNO_MODE (regno));
 816                   if (GET_MODE_BITSIZE (mode)
 817                       > GET_MODE_BITSIZE (save_mode[r]))
 818                     save_mode[r] = mode;
 819                   while (nregs-- > 0)
 820                     SET_HARD_REG_BIT (hard_regs_to_save, r + nregs);
 821                 }
 822
 823               /* Record all registers set in this call insn.  These don't need
 824                  to be saved.  N.B. the call insn might set a subreg of a
 825                  multi-hard-reg pseudo; then the pseudo is considered live
 826                  during the call, but the subreg that is set isn't.  */
 827               CLEAR_HARD_REG_SET (this_insn_sets);
 828               note_stores (PATTERN (insn), mark_set_regs, &this_insn_sets);
 829
 830               /* Compute which hard regs must be saved before this call.  */
 831               AND_COMPL_HARD_REG_SET (hard_regs_to_save, call_fixed_reg_set);
 832               AND_COMPL_HARD_REG_SET (hard_regs_to_save, this_insn_sets);
 833               AND_COMPL_HARD_REG_SET (hard_regs_to_save, hard_regs_saved);
 834               AND_HARD_REG_SET (hard_regs_to_save, call_used_reg_set);
 835
 836               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 837                 if (TEST_HARD_REG_BIT (hard_regs_to_save, regno))
 838                   regno += insert_save (chain, 1, regno, &hard_regs_to_save, save_mode);
 839
 840               /* Must recompute n_regs_saved.  */
 841               n_regs_saved = 0;
 842               for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 843                 if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
 844                   n_regs_saved++;
 845             }
 846           last = chain;
 847         }
 848       else if (DEBUG_INSN_P (insn) && n_regs_saved)
 849         mark_referenced_regs (&PATTERN (insn),
 850                               replace_reg_with_saved_mem,
 851                               save_mode);
 852
 853       if (chain->next == 0 || chain->next->block != chain->block)
 854         {
 855           int regno;
 856           /* At the end of the basic block, we must restore any registers that
 857              remain saved.  If the last insn in the block is a JUMP_INSN, put
 858              the restore before the insn, otherwise, put it after the insn.  */
 859
 860           if (DEBUG_INSN_P (insn) && last && last->block == chain->block)
 861             {
 862               rtx ins, prev;
 863               basic_block bb = BLOCK_FOR_INSN (insn);
 864
 865               /* When adding hard reg restores after a DEBUG_INSN, move
 866                  all notes between last real insn and this DEBUG_INSN after
 867                  the DEBUG_INSN, otherwise we could get code
 868                  -g/-g0 differences.  */
 869               for (ins = PREV_INSN (insn); ins != last->insn; ins = prev)
 870                 {
 871                   prev = PREV_INSN (ins);
 872                   if (NOTE_P (ins))
 873                     {
 874                       NEXT_INSN (prev) = NEXT_INSN (ins);
 875                       PREV_INSN (NEXT_INSN (ins)) = prev;
 876                       PREV_INSN (ins) = insn;
 877                       NEXT_INSN (ins) = NEXT_INSN (insn);
 878                       NEXT_INSN (insn) = ins;
 879                       if (NEXT_INSN (ins))
 880                         PREV_INSN (NEXT_INSN (ins)) = ins;
 881                       if (BB_END (bb) == insn)
 882                         BB_END (bb) = ins;
 883                     }
 884                   else
 885                     gcc_assert (DEBUG_INSN_P (ins));
 886                 }
 887             }
 888           last = NULL;
 889
 890           if (n_regs_saved)
 891             for (regno = 0; regno < FIRST_PSEUDO_REGISTER; regno++)
 892               if (TEST_HARD_REG_BIT (hard_regs_saved, regno))
 893                 regno += insert_restore (chain, JUMP_P (insn),
 894                                          regno, MOVE_MAX_WORDS, save_mode);
 895         }
 896     }
 897 }
 898
 899 /* Here from note_stores, or directly from save_call_clobbered_regs, when
 900    an insn stores a value in a register.
 901    Set the proper bit or bits in this_insn_sets.  All pseudos that have
 902    been assigned hard regs have had their register number changed already,
 903    so we can ignore pseudos.  */
 904 static void
 905 mark_set_regs (rtx reg, const_rtx setter ATTRIBUTE_UNUSED, void *data)
 906 {
 907   int regno, endregno, i;
 908   HARD_REG_SET *this_insn_sets = (HARD_REG_SET *) data;
 909
 910   if (GET_CODE (reg) == SUBREG)
 911     {
 912       rtx inner = SUBREG_REG (reg);
 913       if (!REG_P (inner) || REGNO (inner) >= FIRST_PSEUDO_REGISTER)
 914         return;
 915       regno = subreg_regno (reg);
 916       endregno = regno + subreg_nregs (reg);
 917     }
 918   else if (REG_P (reg)
 919            && REGNO (reg) < FIRST_PSEUDO_REGISTER)
 920     {
 921       regno = REGNO (reg);
 922       endregno = END_HARD_REGNO (reg);
 923     }
 924   else
 925     return;
 926
 927   for (i = regno; i < endregno; i++)
 928     SET_HARD_REG_BIT (*this_insn_sets, i);
 929 }
 930
 931 /* Here from note_stores when an insn stores a value in a register.
 932    Set the proper bit or bits in the passed regset.  All pseudos that have
 933    been assigned hard regs have had their register number changed already,
 934    so we can ignore pseudos.  */
 935 static void
 936 add_stored_regs (rtx reg, const_rtx setter, void *data)
 937 {
 938   int regno, endregno, i;
 939   enum machine_mode mode = GET_MODE (reg);
 940   int offset = 0;
 941
 942   if (GET_CODE (setter) == CLOBBER)
 943     return;
 944
 945   if (GET_CODE (reg) == SUBREG
 946       && REG_P (SUBREG_REG (reg))
 947       && REGNO (SUBREG_REG (reg)) < FIRST_PSEUDO_REGISTER)
 948     {
 949       offset = subreg_regno_offset (REGNO (SUBREG_REG (reg)),
 950                                     GET_MODE (SUBREG_REG (reg)),
 951                                     SUBREG_BYTE (reg),
 952                                     GET_MODE (reg));
 953       regno = REGNO (SUBREG_REG (reg)) + offset;
 954       endregno = regno + subreg_nregs (reg);
 955     }
 956   else
 957     {
 958       if (!REG_P (reg) || REGNO (reg) >= FIRST_PSEUDO_REGISTER)
 959         return;
 960
 961       regno = REGNO (reg) + offset;
 962       endregno = end_hard_regno (mode, regno);
 963     }
 964
 965   for (i = regno; i < endregno; i++)
 966     SET_REGNO_REG_SET ((regset) data, i);
 967 }
 968
 969 /* Walk X and record all referenced registers in REFERENCED_REGS.  */
 970 static void
 971 mark_referenced_regs (rtx *loc, refmarker_fn *mark, void *arg)
 972 {
 973   enum rtx_code code = GET_CODE (*loc);
 974   const char *fmt;
 975   int i, j;
 976
 977   if (code == SET)
 978     mark_referenced_regs (&SET_SRC (*loc), mark, arg);
 979   if (code == SET || code == CLOBBER)
 980     {
 981       loc = &SET_DEST (*loc);
 982       code = GET_CODE (*loc);
 983       if ((code == REG && REGNO (*loc) < FIRST_PSEUDO_REGISTER)
 984           || code == PC || code == CC0
 985           || (code == SUBREG && REG_P (SUBREG_REG (*loc))
 986               && REGNO (SUBREG_REG (*loc)) < FIRST_PSEUDO_REGISTER
 987               /* If we're setting only part of a multi-word register,
 988                  we shall mark it as referenced, because the words
 989                  that are not being set should be restored.  */
 990               && ((GET_MODE_SIZE (GET_MODE (*loc))
 991                    >= GET_MODE_SIZE (GET_MODE (SUBREG_REG (*loc))))
 992                   || (GET_MODE_SIZE (GET_MODE (SUBREG_REG (*loc)))
 993                       <= UNITS_PER_WORD))))
 994         return;
 995     }
 996   if (code == MEM || code == SUBREG)
 997     {
 998       loc = &XEXP (*loc, 0);
 999       code = GET_CODE (*loc);
1000     }
1001
1002   if (code == REG)
1003     {
1004       int regno = REGNO (*loc);
1005       int hardregno = (regno < FIRST_PSEUDO_REGISTER ? regno
1006                        : reg_renumber[regno]);
1007
1008       if (hardregno >= 0)
1009         mark (loc, GET_MODE (*loc), hardregno, arg);
1010       else if (arg)
1011         /* ??? Will we ever end up with an equiv expression in a debug
1012            insn, that would have required restoring a reg, or will
1013            reload take care of it for us?  */
1014         return;
1015       /* If this is a pseudo that did not get a hard register, scan its
1016          memory location, since it might involve the use of another
1017          register, which might be saved.  */
1018       else if (reg_equiv_mem[regno] != 0)
1019         mark_referenced_regs (&XEXP (reg_equiv_mem[regno], 0), mark, arg);
1020       else if (reg_equiv_address[regno] != 0)
1021         mark_referenced_regs (&reg_equiv_address[regno], mark, arg);
1022       return;
1023     }
1024
1025   fmt = GET_RTX_FORMAT (code);
1026   for (i = GET_RTX_LENGTH (code) - 1; i >= 0; i--)
1027     {
1028       if (fmt[i] == 'e')
1029         mark_referenced_regs (&XEXP (*loc, i), mark, arg);
1030       else if (fmt[i] == 'E')
1031         for (j = XVECLEN (*loc, i) - 1; j >= 0; j--)
1032           mark_referenced_regs (&XVECEXP (*loc, i, j), mark, arg);
1033     }
1034 }
1035
1036 /* Parameter function for mark_referenced_regs() that adds registers
1037    present in the insn and in equivalent mems and addresses to
1038    referenced_regs.  */
1039
1040 static void
1041 mark_reg_as_referenced (rtx *loc ATTRIBUTE_UNUSED,
1042                         enum machine_mode mode,
1043                         int hardregno,
1044                         void *arg ATTRIBUTE_UNUSED)
1045 {
1046   add_to_hard_reg_set (&referenced_regs, mode, hardregno);
1047 }
1048
1049 /* Parameter function for mark_referenced_regs() that replaces
1050    registers referenced in a debug_insn that would have been restored,
1051    should it be a non-debug_insn, with their save locations.  */
1052
1053 static void
1054 replace_reg_with_saved_mem (rtx *loc,
1055                             enum machine_mode mode,
1056                             int regno,
1057                             void *arg)
1058 {
1059   unsigned int i, nregs = hard_regno_nregs [regno][mode];
1060   rtx mem;
1061   enum machine_mode *save_mode = (enum machine_mode *)arg;
1062
1063   for (i = 0; i < nregs; i++)
1064     if (TEST_HARD_REG_BIT (hard_regs_saved, regno + i))
1065       break;
1066
1067   /* If none of the registers in the range would need restoring, we're
1068      all set.  */
1069   if (i == nregs)
1070     return;
1071
1072   while (++i < nregs)
1073     if (!TEST_HARD_REG_BIT (hard_regs_saved, regno + i))
1074       break;
1075
1076   if (i == nregs
1077       && regno_save_mem[regno][nregs])
1078     {
1079       mem = copy_rtx (regno_save_mem[regno][nregs]);
1080
1081       if (nregs == (unsigned int) hard_regno_nregs[regno][save_mode[regno]])
1082         mem = adjust_address_nv (mem, save_mode[regno], 0);
1083
1084       if (GET_MODE (mem) != mode)
1085         {
1086           /* This is gen_lowpart_if_possible(), but without validating
1087              the newly-formed address.  */
1088           int offset = 0;
1089
1090           if (WORDS_BIG_ENDIAN)
1091             offset = (MAX (GET_MODE_SIZE (GET_MODE (mem)), UNITS_PER_WORD)
1092                       - MAX (GET_MODE_SIZE (mode), UNITS_PER_WORD));
1093           if (BYTES_BIG_ENDIAN)
1094             /* Adjust the address so that the address-after-the-data is
1095                unchanged.  */
1096             offset -= (MIN (UNITS_PER_WORD, GET_MODE_SIZE (mode))
1097                        - MIN (UNITS_PER_WORD, GET_MODE_SIZE (GET_MODE (mem))));
1098
1099           mem = adjust_address_nv (mem, mode, offset);
1100         }
1101     }
1102   else
1103     {
1104       mem = gen_rtx_CONCATN (mode, rtvec_alloc (nregs));
1105       for (i = 0; i < nregs; i++)
1106         if (TEST_HARD_REG_BIT (hard_regs_saved, regno + i))
1107           {
1108             gcc_assert (regno_save_mem[regno + i][1]);
1109             XVECEXP (mem, 0, i) = copy_rtx (regno_save_mem[regno + i][1]);
1110           }
1111         else
1112           {
1113             gcc_assert (save_mode[regno] != VOIDmode);
1114             XVECEXP (mem, 0, i) = gen_rtx_REG (save_mode [regno],
1115                                                regno + i);
1116           }
1117     }
1118
1119   gcc_assert (GET_MODE (mem) == mode);
1120   *loc = mem;
1121 }
1122
1123 \f
1124 /* Insert a sequence of insns to restore.  Place these insns in front of
1125    CHAIN if BEFORE_P is nonzero, behind the insn otherwise.  MAXRESTORE is
1126    the maximum number of registers which should be restored during this call.
1127    It should never be less than 1 since we only work with entire registers.
1128
1129    Note that we have verified in init_caller_save that we can do this
1130    with a simple SET, so use it.  Set INSN_CODE to what we save there
1131    since the address might not be valid so the insn might not be recognized.
1132    These insns will be reloaded and have register elimination done by
1133    find_reload, so we need not worry about that here.
1134
1135    Return the extra number of registers saved.  */
1136
1137 static int
1138 insert_restore (struct insn_chain *chain, int before_p, int regno,
1139                 int maxrestore, enum machine_mode *save_mode)
1140 {
1141   int i, k;
1142   rtx pat = NULL_RTX;
1143   int code;
1144   unsigned int numregs = 0;
1145   struct insn_chain *new_chain;
1146   rtx mem;
1147
1148   /* A common failure mode if register status is not correct in the
1149      RTL is for this routine to be called with a REGNO we didn't
1150      expect to save.  That will cause us to write an insn with a (nil)
1151      SET_DEST or SET_SRC.  Instead of doing so and causing a crash
1152      later, check for this common case here instead.  This will remove
1153      one step in debugging such problems.  */
1154   gcc_assert (regno_save_mem[regno][1]);
1155
1156   /* Get the pattern to emit and update our status.
1157
1158      See if we can restore `maxrestore' registers at once.  Work
1159      backwards to the single register case.  */
1160   for (i = maxrestore; i > 0; i--)
1161     {
1162       int j;
1163       int ok = 1;
1164
1165       if (regno_save_mem[regno][i] == 0)
1166         continue;
1167
1168       for (j = 0; j < i; j++)
1169         if (! TEST_HARD_REG_BIT (hard_regs_saved, regno + j))
1170           {
1171             ok = 0;
1172             break;
1173           }
1174       /* Must do this one restore at a time.  */
1175       if (! ok)
1176         continue;
1177
1178       numregs = i;
1179       break;
1180     }
1181
1182   mem = regno_save_mem [regno][numregs];
1183   if (save_mode [regno] != VOIDmode
1184       && save_mode [regno] != GET_MODE (mem)
1185       && numregs == (unsigned int) hard_regno_nregs[regno][save_mode [regno]]
1186       /* Check that insn to restore REGNO in save_mode[regno] is
1187          correct.  */
1188       && reg_save_code (regno, save_mode[regno]) >= 0)
1189     mem = adjust_address_nv (mem, save_mode[regno], 0);
1190   else
1191     mem = copy_rtx (mem);
1192
1193   /* Verify that the alignment of spill space is equal to or greater
1194      than required.  */
1195   gcc_assert (MIN (MAX_SUPPORTED_STACK_ALIGNMENT,
1196                    GET_MODE_ALIGNMENT (GET_MODE (mem))) <= MEM_ALIGN (mem));
1197
1198   pat = gen_rtx_SET (VOIDmode,
1199                      gen_rtx_REG (GET_MODE (mem),
1200                                   regno), mem);
1201   code = reg_restore_code (regno, GET_MODE (mem));
1202   new_chain = insert_one_insn (chain, before_p, code, pat);
1203
1204   /* Clear status for all registers we restored.  */
1205   for (k = 0; k < i; k++)
1206     {
1207       CLEAR_HARD_REG_BIT (hard_regs_saved, regno + k);
1208       SET_REGNO_REG_SET (&new_chain->dead_or_set, regno + k);
1209       n_regs_saved--;
1210     }
1211
1212   /* Tell our callers how many extra registers we saved/restored.  */
1213   return numregs - 1;
1214 }
1215
1216 /* Like insert_restore above, but save registers instead.  */
1217
1218 static int
1219 insert_save (struct insn_chain *chain, int before_p, int regno,
1220              HARD_REG_SET (*to_save), enum machine_mode *save_mode)
1221 {
1222   int i;
1223   unsigned int k;
1224   rtx pat = NULL_RTX;
1225   int code;
1226   unsigned int numregs = 0;
1227   struct insn_chain *new_chain;
1228   rtx mem;
1229
1230   /* A common failure mode if register status is not correct in the
1231      RTL is for this routine to be called with a REGNO we didn't
1232      expect to save.  That will cause us to write an insn with a (nil)
1233      SET_DEST or SET_SRC.  Instead of doing so and causing a crash
1234      later, check for this common case here.  This will remove one
1235      step in debugging such problems.  */
1236   gcc_assert (regno_save_mem[regno][1]);
1237
1238   /* Get the pattern to emit and update our status.
1239
1240      See if we can save several registers with a single instruction.
1241      Work backwards to the single register case.  */
1242   for (i = MOVE_MAX_WORDS; i > 0; i--)
1243     {
1244       int j;
1245       int ok = 1;
1246       if (regno_save_mem[regno][i] == 0)
1247         continue;
1248
1249       for (j = 0; j < i; j++)
1250         if (! TEST_HARD_REG_BIT (*to_save, regno + j))
1251           {
1252             ok = 0;
1253             break;
1254           }
1255       /* Must do this one save at a time.  */
1256       if (! ok)
1257         continue;
1258
1259       numregs = i;
1260       break;
1261     }
1262
1263   mem = regno_save_mem [regno][numregs];
1264   if (save_mode [regno] != VOIDmode
1265       && save_mode [regno] != GET_MODE (mem)
1266       && numregs == (unsigned int) hard_regno_nregs[regno][save_mode [regno]]
1267       /* Check that insn to save REGNO in save_mode[regno] is
1268          correct.  */
1269       && reg_save_code (regno, save_mode[regno]) >= 0)
1270     mem = adjust_address_nv (mem, save_mode[regno], 0);
1271   else
1272     mem = copy_rtx (mem);
1273
1274   /* Verify that the alignment of spill space is equal to or greater
1275      than required.  */
1276   gcc_assert (MIN (MAX_SUPPORTED_STACK_ALIGNMENT,
1277                    GET_MODE_ALIGNMENT (GET_MODE (mem))) <= MEM_ALIGN (mem));
1278
1279   pat = gen_rtx_SET (VOIDmode, mem,
1280                      gen_rtx_REG (GET_MODE (mem),
1281                                   regno));
1282   code = reg_save_code (regno, GET_MODE (mem));
1283   new_chain = insert_one_insn (chain, before_p, code, pat);
1284
1285   /* Set hard_regs_saved and dead_or_set for all the registers we saved.  */
1286   for (k = 0; k < numregs; k++)
1287     {
1288       SET_HARD_REG_BIT (hard_regs_saved, regno + k);
1289       SET_REGNO_REG_SET (&new_chain->dead_or_set, regno + k);
1290       n_regs_saved++;
1291     }
1292
1293   /* Tell our callers how many extra registers we saved/restored.  */
1294   return numregs - 1;
1295 }
1296
1297 /* A for_each_rtx callback used by add_used_regs.  Add the hard-register
1298    equivalent of each REG to regset DATA.  */
1299
1300 static int
1301 add_used_regs_1 (rtx *loc, void *data)
1302 {
1303   int regno, i;
1304   regset live;
1305   rtx x;
1306
1307   x = *loc;
1308   live = (regset) data;
1309   if (REG_P (x))
1310     {
1311       regno = REGNO (x);
1312       if (!HARD_REGISTER_NUM_P (regno))
1313         regno = reg_renumber[regno];
1314       if (regno >= 0)
1315         for (i = hard_regno_nregs[regno][GET_MODE (x)] - 1; i >= 0; i--)
1316           SET_REGNO_REG_SET (live, regno + i);
1317     }
1318   return 0;
1319 }
1320
1321 /* A note_uses callback used by insert_one_insn.  Add the hard-register
1322    equivalent of each REG to regset DATA.  */
1323
1324 static void
1325 add_used_regs (rtx *loc, void *data)
1326 {
1327   for_each_rtx (loc, add_used_regs_1, data);
1328 }
1329
1330 /* Emit a new caller-save insn and set the code.  */
1331 static struct insn_chain *
1332 insert_one_insn (struct insn_chain *chain, int before_p, int code, rtx pat)
1333 {
1334   rtx insn = chain->insn;
1335   struct insn_chain *new_chain;
1336
1337 #ifdef HAVE_cc0
1338   /* If INSN references CC0, put our insns in front of the insn that sets
1339      CC0.  This is always safe, since the only way we could be passed an
1340      insn that references CC0 is for a restore, and doing a restore earlier
1341      isn't a problem.  We do, however, assume here that CALL_INSNs don't
1342      reference CC0.  Guard against non-INSN's like CODE_LABEL.  */
1343
1344   if ((NONJUMP_INSN_P (insn) || JUMP_P (insn))
1345       && before_p
1346       && reg_referenced_p (cc0_rtx, PATTERN (insn)))
1347     chain = chain->prev, insn = chain->insn;
1348 #endif
1349
1350   new_chain = new_insn_chain ();
1351   if (before_p)
1352     {
1353       rtx link;
1354
1355       new_chain->prev = chain->prev;
1356       if (new_chain->prev != 0)
1357         new_chain->prev->next = new_chain;
1358       else
1359         reload_insn_chain = new_chain;
1360
1361       chain->prev = new_chain;
1362       new_chain->next = chain;
1363       new_chain->insn = emit_insn_before (pat, insn);
1364       /* ??? It would be nice if we could exclude the already / still saved
1365          registers from the live sets.  */
1366       COPY_REG_SET (&new_chain->live_throughout, &chain->live_throughout);
1367       note_uses (&PATTERN (chain->insn), add_used_regs,
1368                  &new_chain->live_throughout);
1369       /* If CHAIN->INSN is a call, then the registers which contain
1370          the arguments to the function are live in the new insn.  */
1371       if (CALL_P (chain->insn))
1372         for (link = CALL_INSN_FUNCTION_USAGE (chain->insn);
1373              link != NULL_RTX;
1374              link = XEXP (link, 1))
1375           note_uses (&XEXP (link, 0), add_used_regs,
1376                      &new_chain->live_throughout);
1377
1378       CLEAR_REG_SET (&new_chain->dead_or_set);
1379       if (chain->insn == BB_HEAD (BASIC_BLOCK (chain->block)))
1380         BB_HEAD (BASIC_BLOCK (chain->block)) = new_chain->insn;
1381     }
1382   else
1383     {
1384       new_chain->next = chain->next;
1385       if (new_chain->next != 0)
1386         new_chain->next->prev = new_chain;
1387       chain->next = new_chain;
1388       new_chain->prev = chain;
1389       new_chain->insn = emit_insn_after (pat, insn);
1390       /* ??? It would be nice if we could exclude the already / still saved
1391          registers from the live sets, and observe REG_UNUSED notes.  */
1392       COPY_REG_SET (&new_chain->live_throughout, &chain->live_throughout);
1393       /* Registers that are set in CHAIN->INSN live in the new insn.
1394          (Unless there is a REG_UNUSED note for them, but we don't
1395           look for them here.) */
1396       note_stores (PATTERN (chain->insn), add_stored_regs,
1397                    &new_chain->live_throughout);
1398       CLEAR_REG_SET (&new_chain->dead_or_set);
1399       if (chain->insn == BB_END (BASIC_BLOCK (chain->block)))
1400         BB_END (BASIC_BLOCK (chain->block)) = new_chain->insn;
1401     }
1402   new_chain->block = chain->block;
1403   new_chain->is_caller_save_insn = 1;
1404
1405   INSN_CODE (new_chain->insn) = code;
1406   return new_chain;
1407 }
1408 #include "gt-caller-save.h"