gcc/resource.c

   1 /* Definitions for computing resource usage of specific insns.
   2    Copyright (C) 1999 Free Software Foundation, Inc.
   3
   4 This file is part of GNU CC.
   5
   6 GNU CC is free software; you can redistribute it and/or modify
   7 it under the terms of the GNU General Public License as published by
   8 the Free Software Foundation; either version 2, or (at your option)
   9 any later version.
  10
  11 GNU CC is distributed in the hope that it will be useful,
  12 but WITHOUT ANY WARRANTY; without even the implied warranty of
  13 MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
  14 GNU General Public License for more details.
  15
  16 You should have received a copy of the GNU General Public License
  17 along with GNU CC; see the file COPYING.  If not, write to
  18 the Free Software Foundation, 59 Temple Place - Suite 330,
  19 Boston, MA 02111-1307, USA.  */
  20
  21 #include "config.h"
  22 #include "toplev.h"
  23 #include "rtl.h"
  24 #include "hard-reg-set.h"
  25 #include "system.h"
  26 #include "basic-block.h"
  27 #include "regs.h"
  28 #include "flags.h"
  29 #include "output.h"
  30 #include "resource.h"
  31
  32 /* This structure is used to record liveness information at the targets or
  33    fallthrough insns of branches.  We will most likely need the information
  34    at targets again, so save them in a hash table rather than recomputing them
  35    each time.  */
  36
  37 struct target_info
  38 {
  39   int uid;                      /* INSN_UID of target.  */
  40   struct target_info *next;     /* Next info for same hash bucket.  */
  41   HARD_REG_SET live_regs;       /* Registers live at target.  */
  42   int block;                    /* Basic block number containing target.  */
  43   int bb_tick;                  /* Generation count of basic block info.  */
  44 };
  45
  46 #define TARGET_HASH_PRIME 257
  47
  48 /* Indicates what resources are required at the beginning of the epilogue.  */
  49 static struct resources start_of_epilogue_needs;
  50
  51 /* Indicates what resources are required at function end.  */
  52 static struct resources end_of_function_needs;
  53
  54 /* Define the hash table itself.  */
  55 static struct target_info **target_hash_table = NULL;
  56
  57 /* For each basic block, we maintain a generation number of its basic
  58    block info, which is updated each time we move an insn from the
  59    target of a jump.  This is the generation number indexed by block
  60    number.  */
  61
  62 static int *bb_ticks;
  63
  64 /* Marks registers possibly live at the current place being scanned by
  65    mark_target_live_regs.  Used only by next two function.    */
  66
  67 static HARD_REG_SET current_live_regs;
  68
  69 /* Marks registers for which we have seen a REG_DEAD note but no assignment.
  70    Also only used by the next two functions.  */
  71
  72 static HARD_REG_SET pending_dead_regs;
  73 \f
  74 static void update_live_status          PROTO ((rtx, rtx));
  75 static int find_basic_block             PROTO ((rtx));
  76 static rtx next_insn_no_annul           PROTO ((rtx));
  77 static rtx find_dead_or_set_registers   PROTO ((rtx, struct resources*,
  78                                                 rtx*, int, struct resources,
  79                                                 struct resources));
  80 \f
  81 /* Utility function called from mark_target_live_regs via note_stores.
  82    It deadens any CLOBBERed registers and livens any SET registers.  */
  83
  84 static void
  85 update_live_status (dest, x)
  86      rtx dest;
  87      rtx x;
  88 {
  89   int first_regno, last_regno;
  90   int i;
  91
  92   if (GET_CODE (dest) != REG
  93       && (GET_CODE (dest) != SUBREG || GET_CODE (SUBREG_REG (dest)) != REG))
  94     return;
  95
  96   if (GET_CODE (dest) == SUBREG)
  97     first_regno = REGNO (SUBREG_REG (dest)) + SUBREG_WORD (dest);
  98   else
  99     first_regno = REGNO (dest);
 100
 101   last_regno = first_regno + HARD_REGNO_NREGS (first_regno, GET_MODE (dest));
 102
 103   if (GET_CODE (x) == CLOBBER)
 104     for (i = first_regno; i < last_regno; i++)
 105       CLEAR_HARD_REG_BIT (current_live_regs, i);
 106   else
 107     for (i = first_regno; i < last_regno; i++)
 108       {
 109         SET_HARD_REG_BIT (current_live_regs, i);
 110         CLEAR_HARD_REG_BIT (pending_dead_regs, i);
 111       }
 112 }
 113 /* Find the number of the basic block that starts closest to INSN.  Return -1
 114    if we couldn't find such a basic block.  */
 115
 116 static int
 117 find_basic_block (insn)
 118      rtx insn;
 119 {
 120   int i;
 121
 122   /* Scan backwards to the previous BARRIER.  Then see if we can find a
 123      label that starts a basic block.  Return the basic block number.  */
 124
 125   for (insn = prev_nonnote_insn (insn);
 126        insn && GET_CODE (insn) != BARRIER;
 127        insn = prev_nonnote_insn (insn))
 128     ;
 129
 130   /* The start of the function is basic block zero.  */
 131   if (insn == 0)
 132     return 0;
 133
 134   /* See if any of the upcoming CODE_LABELs start a basic block.  If we reach
 135      anything other than a CODE_LABEL or note, we can't find this code.  */
 136   for (insn = next_nonnote_insn (insn);
 137        insn && GET_CODE (insn) == CODE_LABEL;
 138        insn = next_nonnote_insn (insn))
 139     {
 140       for (i = 0; i < n_basic_blocks; i++)
 141         if (insn == BLOCK_HEAD (i))
 142           return i;
 143     }
 144
 145   return -1;
 146 }
 147 \f
 148 /* Similar to next_insn, but ignores insns in the delay slots of
 149    an annulled branch.  */
 150
 151 static rtx
 152 next_insn_no_annul (insn)
 153      rtx insn;
 154 {
 155   if (insn)
 156     {
 157       /* If INSN is an annulled branch, skip any insns from the target
 158          of the branch.  */
 159       if (INSN_ANNULLED_BRANCH_P (insn)
 160           && NEXT_INSN (PREV_INSN (insn)) != insn)
 161         while (INSN_FROM_TARGET_P (NEXT_INSN (insn)))
 162           insn = NEXT_INSN (insn);
 163
 164       insn = NEXT_INSN (insn);
 165       if (insn && GET_CODE (insn) == INSN
 166           && GET_CODE (PATTERN (insn)) == SEQUENCE)
 167         insn = XVECEXP (PATTERN (insn), 0, 0);
 168     }
 169
 170   return insn;
 171 }
 172 \f
 173 /* Given X, some rtl, and RES, a pointer to a `struct resource', mark
 174    which resources are references by the insn.  If INCLUDE_DELAYED_EFFECTS
 175    is TRUE, resources used by the called routine will be included for
 176    CALL_INSNs.  */
 177
 178 void
 179 mark_referenced_resources (x, res, include_delayed_effects)
 180      register rtx x;
 181      register struct resources *res;
 182      register int include_delayed_effects;
 183 {
 184   register enum rtx_code code = GET_CODE (x);
 185   register int i, j;
 186   register char *format_ptr;
 187
 188   /* Handle leaf items for which we set resource flags.  Also, special-case
 189      CALL, SET and CLOBBER operators.  */
 190   switch (code)
 191     {
 192     case CONST:
 193     case CONST_INT:
 194     case CONST_DOUBLE:
 195     case PC:
 196     case SYMBOL_REF:
 197     case LABEL_REF:
 198       return;
 199
 200     case SUBREG:
 201       if (GET_CODE (SUBREG_REG (x)) != REG)
 202         mark_referenced_resources (SUBREG_REG (x), res, 0);
 203       else
 204         {
 205           int regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
 206           int last_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
 207           for (i = regno; i < last_regno; i++)
 208             SET_HARD_REG_BIT (res->regs, i);
 209         }
 210       return;
 211
 212     case REG:
 213       for (i = 0; i < HARD_REGNO_NREGS (REGNO (x), GET_MODE (x)); i++)
 214         SET_HARD_REG_BIT (res->regs, REGNO (x) + i);
 215       return;
 216
 217     case MEM:
 218       /* If this memory shouldn't change, it really isn't referencing
 219          memory.  */
 220       if (RTX_UNCHANGING_P (x))
 221         res->unch_memory = 1;
 222       else
 223         res->memory = 1;
 224       res->volatil = MEM_VOLATILE_P (x);
 225
 226       /* Mark registers used to access memory.  */
 227       mark_referenced_resources (XEXP (x, 0), res, 0);
 228       return;
 229
 230     case CC0:
 231       res->cc = 1;
 232       return;
 233
 234     case UNSPEC_VOLATILE:
 235     case ASM_INPUT:
 236       /* Traditional asm's are always volatile.  */
 237       res->volatil = 1;
 238       return;
 239
 240     case TRAP_IF:
 241       res->volatil = 1;
 242       break;
 243
 244     case ASM_OPERANDS:
 245       res->volatil = MEM_VOLATILE_P (x);
 246
 247       /* For all ASM_OPERANDS, we must traverse the vector of input operands.
 248          We can not just fall through here since then we would be confused
 249          by the ASM_INPUT rtx inside ASM_OPERANDS, which do not indicate
 250          traditional asms unlike their normal usage.  */
 251
 252       for (i = 0; i < ASM_OPERANDS_INPUT_LENGTH (x); i++)
 253         mark_referenced_resources (ASM_OPERANDS_INPUT (x, i), res, 0);
 254       return;
 255
 256     case CALL:
 257       /* The first operand will be a (MEM (xxx)) but doesn't really reference
 258          memory.  The second operand may be referenced, though.  */
 259       mark_referenced_resources (XEXP (XEXP (x, 0), 0), res, 0);
 260       mark_referenced_resources (XEXP (x, 1), res, 0);
 261       return;
 262
 263     case SET:
 264       /* Usually, the first operand of SET is set, not referenced.  But
 265          registers used to access memory are referenced.  SET_DEST is
 266          also referenced if it is a ZERO_EXTRACT or SIGN_EXTRACT.  */
 267
 268       mark_referenced_resources (SET_SRC (x), res, 0);
 269
 270       x = SET_DEST (x);
 271       if (GET_CODE (x) == SIGN_EXTRACT || GET_CODE (x) == ZERO_EXTRACT)
 272         mark_referenced_resources (x, res, 0);
 273       else if (GET_CODE (x) == SUBREG)
 274         x = SUBREG_REG (x);
 275       if (GET_CODE (x) == MEM)
 276         mark_referenced_resources (XEXP (x, 0), res, 0);
 277       return;
 278
 279     case CLOBBER:
 280       return;
 281
 282     case CALL_INSN:
 283       if (include_delayed_effects)
 284         {
 285           /* A CALL references memory, the frame pointer if it exists, the
 286              stack pointer, any global registers and any registers given in
 287              USE insns immediately in front of the CALL.
 288
 289              However, we may have moved some of the parameter loading insns
 290              into the delay slot of this CALL.  If so, the USE's for them
 291              don't count and should be skipped.  */
 292           rtx insn = PREV_INSN (x);
 293           rtx sequence = 0;
 294           int seq_size = 0;
 295           rtx next = NEXT_INSN (x);
 296           int i;
 297
 298           /* If we are part of a delay slot sequence, point at the SEQUENCE.  */
 299           if (NEXT_INSN (insn) != x)
 300             {
 301               next = NEXT_INSN (NEXT_INSN (insn));
 302               sequence = PATTERN (NEXT_INSN (insn));
 303               seq_size = XVECLEN (sequence, 0);
 304               if (GET_CODE (sequence) != SEQUENCE)
 305                 abort ();
 306             }
 307
 308           res->memory = 1;
 309           SET_HARD_REG_BIT (res->regs, STACK_POINTER_REGNUM);
 310           if (frame_pointer_needed)
 311             {
 312               SET_HARD_REG_BIT (res->regs, FRAME_POINTER_REGNUM);
 313 #if FRAME_POINTER_REGNUM != HARD_FRAME_POINTER_REGNUM
 314               SET_HARD_REG_BIT (res->regs, HARD_FRAME_POINTER_REGNUM);
 315 #endif
 316             }
 317
 318           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 319             if (global_regs[i])
 320               SET_HARD_REG_BIT (res->regs, i);
 321
 322           /* Check for a NOTE_INSN_SETJMP.  If it exists, then we must
 323              assume that this call can need any register.
 324
 325              This is done to be more conservative about how we handle setjmp.
 326              We assume that they both use and set all registers.  Using all
 327              registers ensures that a register will not be considered dead
 328              just because it crosses a setjmp call.  A register should be
 329              considered dead only if the setjmp call returns non-zero.  */
 330           if (next && GET_CODE (next) == NOTE
 331               && NOTE_LINE_NUMBER (next) == NOTE_INSN_SETJMP)
 332             SET_HARD_REG_SET (res->regs);
 333
 334           {
 335             rtx link;
 336
 337             for (link = CALL_INSN_FUNCTION_USAGE (x);
 338                  link;
 339                  link = XEXP (link, 1))
 340               if (GET_CODE (XEXP (link, 0)) == USE)
 341                 {
 342                   for (i = 1; i < seq_size; i++)
 343                     {
 344                       rtx slot_pat = PATTERN (XVECEXP (sequence, 0, i));
 345                       if (GET_CODE (slot_pat) == SET
 346                           && rtx_equal_p (SET_DEST (slot_pat),
 347                                           SET_DEST (XEXP (link, 0))))
 348                         break;
 349                     }
 350                   if (i >= seq_size)
 351                     mark_referenced_resources (SET_DEST (XEXP (link, 0)),
 352                                                res, 0);
 353                 }
 354           }
 355         }
 356
 357       /* ... fall through to other INSN processing ...  */
 358
 359     case INSN:
 360     case JUMP_INSN:
 361
 362 #ifdef INSN_REFERENCES_ARE_DELAYED
 363       if (! include_delayed_effects
 364           && INSN_REFERENCES_ARE_DELAYED (x))
 365         return;
 366 #endif
 367
 368       /* No special processing, just speed up.  */
 369       mark_referenced_resources (PATTERN (x), res, include_delayed_effects);
 370       return;
 371
 372     default:
 373       break;
 374     }
 375
 376   /* Process each sub-expression and flag what it needs.  */
 377   format_ptr = GET_RTX_FORMAT (code);
 378   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 379     switch (*format_ptr++)
 380       {
 381       case 'e':
 382         mark_referenced_resources (XEXP (x, i), res, include_delayed_effects);
 383         break;
 384
 385       case 'E':
 386         for (j = 0; j < XVECLEN (x, i); j++)
 387           mark_referenced_resources (XVECEXP (x, i, j), res,
 388                                      include_delayed_effects);
 389         break;
 390       }
 391 }
 392 \f
 393 /* A subroutine of mark_target_live_regs.  Search forward from TARGET
 394    looking for registers that are set before they are used.  These are dead.
 395    Stop after passing a few conditional jumps, and/or a small
 396    number of unconditional branches.  */
 397
 398 static rtx
 399 find_dead_or_set_registers (target, res, jump_target, jump_count, set, needed)
 400      rtx target;
 401      struct resources *res;
 402      rtx *jump_target;
 403      int jump_count;
 404      struct resources set, needed;
 405 {
 406   HARD_REG_SET scratch;
 407   rtx insn, next;
 408   rtx jump_insn = 0;
 409   int i;
 410
 411   for (insn = target; insn; insn = next)
 412     {
 413       rtx this_jump_insn = insn;
 414
 415       next = NEXT_INSN (insn);
 416       switch (GET_CODE (insn))
 417         {
 418         case CODE_LABEL:
 419           /* After a label, any pending dead registers that weren't yet
 420              used can be made dead.  */
 421           AND_COMPL_HARD_REG_SET (pending_dead_regs, needed.regs);
 422           AND_COMPL_HARD_REG_SET (res->regs, pending_dead_regs);
 423           CLEAR_HARD_REG_SET (pending_dead_regs);
 424
 425           continue;
 426
 427         case BARRIER:
 428         case NOTE:
 429           continue;
 430
 431         case INSN:
 432           if (GET_CODE (PATTERN (insn)) == USE)
 433             {
 434               /* If INSN is a USE made by update_block, we care about the
 435                  underlying insn.  Any registers set by the underlying insn
 436                  are live since the insn is being done somewhere else.  */
 437               if (GET_RTX_CLASS (GET_CODE (XEXP (PATTERN (insn), 0))) == 'i')
 438                 mark_set_resources (XEXP (PATTERN (insn), 0), res, 0, 1);
 439
 440               /* All other USE insns are to be ignored.  */
 441               continue;
 442             }
 443           else if (GET_CODE (PATTERN (insn)) == CLOBBER)
 444             continue;
 445           else if (GET_CODE (PATTERN (insn)) == SEQUENCE)
 446             {
 447               /* An unconditional jump can be used to fill the delay slot
 448                  of a call, so search for a JUMP_INSN in any position.  */
 449               for (i = 0; i < XVECLEN (PATTERN (insn), 0); i++)
 450                 {
 451                   this_jump_insn = XVECEXP (PATTERN (insn), 0, i);
 452                   if (GET_CODE (this_jump_insn) == JUMP_INSN)
 453                     break;
 454                 }
 455             }
 456
 457         default:
 458           break;
 459         }
 460
 461       if (GET_CODE (this_jump_insn) == JUMP_INSN)
 462         {
 463           if (jump_count++ < 10)
 464             {
 465               if (simplejump_p (this_jump_insn)
 466                   || GET_CODE (PATTERN (this_jump_insn)) == RETURN)
 467                 {
 468                   next = JUMP_LABEL (this_jump_insn);
 469                   if (jump_insn == 0)
 470                     {
 471                       jump_insn = insn;
 472                       if (jump_target)
 473                         *jump_target = JUMP_LABEL (this_jump_insn);
 474                     }
 475                 }
 476               else if (condjump_p (this_jump_insn)
 477                        || condjump_in_parallel_p (this_jump_insn))
 478                 {
 479                   struct resources target_set, target_res;
 480                   struct resources fallthrough_res;
 481
 482                   /* We can handle conditional branches here by following
 483                      both paths, and then IOR the results of the two paths
 484                      together, which will give us registers that are dead
 485                      on both paths.  Since this is expensive, we give it
 486                      a much higher cost than unconditional branches.  The
 487                      cost was chosen so that we will follow at most 1
 488                      conditional branch.  */
 489
 490                   jump_count += 4;
 491                   if (jump_count >= 10)
 492                     break;
 493
 494                   mark_referenced_resources (insn, &needed, 1);
 495
 496                   /* For an annulled branch, mark_set_resources ignores slots
 497                      filled by instructions from the target.  This is correct
 498                      if the branch is not taken.  Since we are following both
 499                      paths from the branch, we must also compute correct info
 500                      if the branch is taken.  We do this by inverting all of
 501                      the INSN_FROM_TARGET_P bits, calling mark_set_resources,
 502                      and then inverting the INSN_FROM_TARGET_P bits again.  */
 503
 504                   if (GET_CODE (PATTERN (insn)) == SEQUENCE
 505                       && INSN_ANNULLED_BRANCH_P (this_jump_insn))
 506                     {
 507                       for (i = 1; i < XVECLEN (PATTERN (insn), 0); i++)
 508                         INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i))
 509                           = ! INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i));
 510
 511                       target_set = set;
 512                       mark_set_resources (insn, &target_set, 0, 1);
 513
 514                       for (i = 1; i < XVECLEN (PATTERN (insn), 0); i++)
 515                         INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i))
 516                           = ! INSN_FROM_TARGET_P (XVECEXP (PATTERN (insn), 0, i));
 517
 518                       mark_set_resources (insn, &set, 0, 1);
 519                     }
 520                   else
 521                     {
 522                       mark_set_resources (insn, &set, 0, 1);
 523                       target_set = set;
 524                     }
 525
 526                   target_res = *res;
 527                   COPY_HARD_REG_SET (scratch, target_set.regs);
 528                   AND_COMPL_HARD_REG_SET (scratch, needed.regs);
 529                   AND_COMPL_HARD_REG_SET (target_res.regs, scratch);
 530
 531                   fallthrough_res = *res;
 532                   COPY_HARD_REG_SET (scratch, set.regs);
 533                   AND_COMPL_HARD_REG_SET (scratch, needed.regs);
 534                   AND_COMPL_HARD_REG_SET (fallthrough_res.regs, scratch);
 535
 536                   find_dead_or_set_registers (JUMP_LABEL (this_jump_insn),
 537                                               &target_res, 0, jump_count,
 538                                               target_set, needed);
 539                   find_dead_or_set_registers (next,
 540                                               &fallthrough_res, 0, jump_count,
 541                                               set, needed);
 542                   IOR_HARD_REG_SET (fallthrough_res.regs, target_res.regs);
 543                   AND_HARD_REG_SET (res->regs, fallthrough_res.regs);
 544                   break;
 545                 }
 546               else
 547                 break;
 548             }
 549           else
 550             {
 551               /* Don't try this optimization if we expired our jump count
 552                  above, since that would mean there may be an infinite loop
 553                  in the function being compiled.  */
 554               jump_insn = 0;
 555               break;
 556             }
 557         }
 558
 559       mark_referenced_resources (insn, &needed, 1);
 560       mark_set_resources (insn, &set, 0, 1);
 561
 562       COPY_HARD_REG_SET (scratch, set.regs);
 563       AND_COMPL_HARD_REG_SET (scratch, needed.regs);
 564       AND_COMPL_HARD_REG_SET (res->regs, scratch);
 565     }
 566
 567   return jump_insn;
 568 }
 569 \f
 570 /* Given X, a part of an insn, and a pointer to a `struct resource',
 571    RES, indicate which resources are modified by the insn. If
 572    INCLUDE_DELAYED_EFFECTS is nonzero, also mark resources potentially
 573    set by the called routine.
 574
 575    If IN_DEST is nonzero, it means we are inside a SET.  Otherwise,
 576    objects are being referenced instead of set.
 577
 578    We never mark the insn as modifying the condition code unless it explicitly
 579    SETs CC0 even though this is not totally correct.  The reason for this is
 580    that we require a SET of CC0 to immediately precede the reference to CC0.
 581    So if some other insn sets CC0 as a side-effect, we know it cannot affect
 582    our computation and thus may be placed in a delay slot.   */
 583
 584 void
 585 mark_set_resources (x, res, in_dest, include_delayed_effects)
 586      register rtx x;
 587      register struct resources *res;
 588      int in_dest;
 589      int include_delayed_effects;
 590 {
 591   register enum rtx_code code;
 592   register int i, j;
 593   register char *format_ptr;
 594
 595  restart:
 596
 597   code = GET_CODE (x);
 598
 599   switch (code)
 600     {
 601     case NOTE:
 602     case BARRIER:
 603     case CODE_LABEL:
 604     case USE:
 605     case CONST_INT:
 606     case CONST_DOUBLE:
 607     case LABEL_REF:
 608     case SYMBOL_REF:
 609     case CONST:
 610     case PC:
 611       /* These don't set any resources.  */
 612       return;
 613
 614     case CC0:
 615       if (in_dest)
 616         res->cc = 1;
 617       return;
 618
 619     case CALL_INSN:
 620       /* Called routine modifies the condition code, memory, any registers
 621          that aren't saved across calls, global registers and anything
 622          explicitly CLOBBERed immediately after the CALL_INSN.  */
 623
 624       if (include_delayed_effects)
 625         {
 626           rtx next = NEXT_INSN (x);
 627           rtx prev = PREV_INSN (x);
 628           rtx link;
 629
 630           res->cc = res->memory = 1;
 631           for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 632             if (call_used_regs[i] || global_regs[i])
 633               SET_HARD_REG_BIT (res->regs, i);
 634
 635           /* If X is part of a delay slot sequence, then NEXT should be
 636              the first insn after the sequence.  */
 637           if (NEXT_INSN (prev) != x)
 638             next = NEXT_INSN (NEXT_INSN (prev));
 639
 640           for (link = CALL_INSN_FUNCTION_USAGE (x);
 641                link; link = XEXP (link, 1))
 642             if (GET_CODE (XEXP (link, 0)) == CLOBBER)
 643               mark_set_resources (SET_DEST (XEXP (link, 0)), res, 1, 0);
 644
 645           /* Check for a NOTE_INSN_SETJMP.  If it exists, then we must
 646              assume that this call can clobber any register.  */
 647           if (next && GET_CODE (next) == NOTE
 648               && NOTE_LINE_NUMBER (next) == NOTE_INSN_SETJMP)
 649             SET_HARD_REG_SET (res->regs);
 650         }
 651
 652       /* ... and also what its RTL says it modifies, if anything.  */
 653
 654     case JUMP_INSN:
 655     case INSN:
 656
 657         /* An insn consisting of just a CLOBBER (or USE) is just for flow
 658            and doesn't actually do anything, so we ignore it.  */
 659
 660 #ifdef INSN_SETS_ARE_DELAYED
 661       if (! include_delayed_effects
 662           && INSN_SETS_ARE_DELAYED (x))
 663         return;
 664 #endif
 665
 666       x = PATTERN (x);
 667       if (GET_CODE (x) != USE && GET_CODE (x) != CLOBBER)
 668         goto restart;
 669       return;
 670
 671     case SET:
 672       /* If the source of a SET is a CALL, this is actually done by
 673          the called routine.  So only include it if we are to include the
 674          effects of the calling routine.  */
 675
 676       mark_set_resources (SET_DEST (x), res,
 677                           (include_delayed_effects
 678                            || GET_CODE (SET_SRC (x)) != CALL),
 679                           0);
 680
 681       mark_set_resources (SET_SRC (x), res, 0, 0);
 682       return;
 683
 684     case CLOBBER:
 685       mark_set_resources (XEXP (x, 0), res, 1, 0);
 686       return;
 687
 688     case SEQUENCE:
 689       for (i = 0; i < XVECLEN (x, 0); i++)
 690         if (! (INSN_ANNULLED_BRANCH_P (XVECEXP (x, 0, 0))
 691                && INSN_FROM_TARGET_P (XVECEXP (x, 0, i))))
 692           mark_set_resources (XVECEXP (x, 0, i), res, 0,
 693                               include_delayed_effects);
 694       return;
 695
 696     case POST_INC:
 697     case PRE_INC:
 698     case POST_DEC:
 699     case PRE_DEC:
 700       mark_set_resources (XEXP (x, 0), res, 1, 0);
 701       return;
 702
 703     case ZERO_EXTRACT:
 704       mark_set_resources (XEXP (x, 0), res, in_dest, 0);
 705       mark_set_resources (XEXP (x, 1), res, 0, 0);
 706       mark_set_resources (XEXP (x, 2), res, 0, 0);
 707       return;
 708
 709     case MEM:
 710       if (in_dest)
 711         {
 712           res->memory = 1;
 713           res->unch_memory = RTX_UNCHANGING_P (x);
 714           res->volatil = MEM_VOLATILE_P (x);
 715         }
 716
 717       mark_set_resources (XEXP (x, 0), res, 0, 0);
 718       return;
 719
 720     case SUBREG:
 721       if (in_dest)
 722         {
 723           if (GET_CODE (SUBREG_REG (x)) != REG)
 724             mark_set_resources (SUBREG_REG (x), res,
 725                                 in_dest, include_delayed_effects);
 726           else
 727             {
 728               int regno = REGNO (SUBREG_REG (x)) + SUBREG_WORD (x);
 729               int last_regno = regno + HARD_REGNO_NREGS (regno, GET_MODE (x));
 730               for (i = regno; i < last_regno; i++)
 731                 SET_HARD_REG_BIT (res->regs, i);
 732             }
 733         }
 734       return;
 735
 736     case REG:
 737       if (in_dest)
 738         for (i = 0; i < HARD_REGNO_NREGS (REGNO (x), GET_MODE (x)); i++)
 739           SET_HARD_REG_BIT (res->regs, REGNO (x) + i);
 740       return;
 741
 742     default:
 743       break;
 744     }
 745
 746   /* Process each sub-expression and flag what it needs.  */
 747   format_ptr = GET_RTX_FORMAT (code);
 748   for (i = 0; i < GET_RTX_LENGTH (code); i++)
 749     switch (*format_ptr++)
 750       {
 751       case 'e':
 752         mark_set_resources (XEXP (x, i), res, in_dest, include_delayed_effects);
 753         break;
 754
 755       case 'E':
 756         for (j = 0; j < XVECLEN (x, i); j++)
 757           mark_set_resources (XVECEXP (x, i, j), res, in_dest,
 758                               include_delayed_effects);
 759         break;
 760       }
 761 }
 762 \f
 763 /* Set the resources that are live at TARGET.
 764
 765    If TARGET is zero, we refer to the end of the current function and can
 766    return our precomputed value.
 767
 768    Otherwise, we try to find out what is live by consulting the basic block
 769    information.  This is tricky, because we must consider the actions of
 770    reload and jump optimization, which occur after the basic block information
 771    has been computed.
 772
 773    Accordingly, we proceed as follows::
 774
 775    We find the previous BARRIER and look at all immediately following labels
 776    (with no intervening active insns) to see if any of them start a basic
 777    block.  If we hit the start of the function first, we use block 0.
 778
 779    Once we have found a basic block and a corresponding first insns, we can
 780    accurately compute the live status from basic_block_live_regs and
 781    reg_renumber.  (By starting at a label following a BARRIER, we are immune
 782    to actions taken by reload and jump.)  Then we scan all insns between
 783    that point and our target.  For each CLOBBER (or for call-clobbered regs
 784    when we pass a CALL_INSN), mark the appropriate registers are dead.  For
 785    a SET, mark them as live.
 786
 787    We have to be careful when using REG_DEAD notes because they are not
 788    updated by such things as find_equiv_reg.  So keep track of registers
 789    marked as dead that haven't been assigned to, and mark them dead at the
 790    next CODE_LABEL since reload and jump won't propagate values across labels.
 791
 792    If we cannot find the start of a basic block (should be a very rare
 793    case, if it can happen at all), mark everything as potentially live.
 794
 795    Next, scan forward from TARGET looking for things set or clobbered
 796    before they are used.  These are not live.
 797
 798    Because we can be called many times on the same target, save our results
 799    in a hash table indexed by INSN_UID.  This is only done if the function
 800    init_resource_info () was invoked before we are called.  */
 801
 802 void
 803 mark_target_live_regs (insns, target, res)
 804      rtx insns;
 805      rtx target;
 806      struct resources *res;
 807 {
 808   int b = -1;
 809   int i;
 810   struct target_info *tinfo = NULL;
 811   rtx insn;
 812   rtx jump_insn = 0;
 813   rtx jump_target;
 814   HARD_REG_SET scratch;
 815   struct resources set, needed;
 816
 817   /* Handle end of function.  */
 818   if (target == 0)
 819     {
 820       *res = end_of_function_needs;
 821       return;
 822     }
 823
 824   /* We have to assume memory is needed, but the CC isn't.  */
 825   res->memory = 1;
 826   res->volatil = res->unch_memory = 0;
 827   res->cc = 0;
 828
 829   /* See if we have computed this value already.  */
 830   if (target_hash_table != NULL)
 831     {
 832       for (tinfo = target_hash_table[INSN_UID (target) % TARGET_HASH_PRIME];
 833            tinfo; tinfo = tinfo->next)
 834         if (tinfo->uid == INSN_UID (target))
 835           break;
 836
 837       /* Start by getting the basic block number.  If we have saved
 838          information, we can get it from there unless the insn at the
 839          start of the basic block has been deleted.  */
 840       if (tinfo && tinfo->block != -1
 841           && ! INSN_DELETED_P (BLOCK_HEAD (tinfo->block)))
 842         b = tinfo->block;
 843     }
 844
 845   if (b == -1)
 846     b = find_basic_block (target);
 847
 848   if (target_hash_table != NULL)
 849     {
 850       if (tinfo)
 851         {
 852           /* If the information is up-to-date, use it.  Otherwise, we will
 853              update it below.  */
 854           if (b == tinfo->block && b != -1 && tinfo->bb_tick == bb_ticks[b])
 855             {
 856               COPY_HARD_REG_SET (res->regs, tinfo->live_regs);
 857               return;
 858             }
 859         }
 860       else
 861         {
 862           /* Allocate a place to put our results and chain it into the
 863              hash table.  */
 864           tinfo = (struct target_info *) oballoc (sizeof (struct target_info));
 865           tinfo->uid = INSN_UID (target);
 866           tinfo->block = b;
 867           tinfo->next = target_hash_table[INSN_UID (target) % TARGET_HASH_PRIME];
 868           target_hash_table[INSN_UID (target) % TARGET_HASH_PRIME] = tinfo;
 869         }
 870     }
 871
 872   CLEAR_HARD_REG_SET (pending_dead_regs);
 873
 874   /* If we found a basic block, get the live registers from it and update
 875      them with anything set or killed between its start and the insn before
 876      TARGET.  Otherwise, we must assume everything is live.  */
 877   if (b != -1)
 878     {
 879       regset regs_live = BASIC_BLOCK (b)->global_live_at_start;
 880       int j;
 881       int regno;
 882       rtx start_insn, stop_insn;
 883
 884       /* Compute hard regs live at start of block -- this is the real hard regs
 885          marked live, plus live pseudo regs that have been renumbered to
 886          hard regs.  */
 887
 888       REG_SET_TO_HARD_REG_SET (current_live_regs, regs_live);
 889
 890       EXECUTE_IF_SET_IN_REG_SET
 891         (regs_live, FIRST_PSEUDO_REGISTER, i,
 892          {
 893            if ((regno = reg_renumber[i]) >= 0)
 894              for (j = regno;
 895                   j < regno + HARD_REGNO_NREGS (regno,
 896                                                 PSEUDO_REGNO_MODE (i));
 897                   j++)
 898                SET_HARD_REG_BIT (current_live_regs, j);
 899          });
 900
 901       /* Get starting and ending insn, handling the case where each might
 902          be a SEQUENCE.  */
 903       start_insn = (b == 0 ? insns : BLOCK_HEAD (b));
 904       stop_insn = target;
 905
 906       if (GET_CODE (start_insn) == INSN
 907           && GET_CODE (PATTERN (start_insn)) == SEQUENCE)
 908         start_insn = XVECEXP (PATTERN (start_insn), 0, 0);
 909
 910       if (GET_CODE (stop_insn) == INSN
 911           && GET_CODE (PATTERN (stop_insn)) == SEQUENCE)
 912         stop_insn = next_insn (PREV_INSN (stop_insn));
 913
 914       for (insn = start_insn; insn != stop_insn;
 915            insn = next_insn_no_annul (insn))
 916         {
 917           rtx link;
 918           rtx real_insn = insn;
 919
 920           /* If this insn is from the target of a branch, it isn't going to
 921              be used in the sequel.  If it is used in both cases, this
 922              test will not be true.  */
 923           if (INSN_FROM_TARGET_P (insn))
 924             continue;
 925
 926           /* If this insn is a USE made by update_block, we care about the
 927              underlying insn.  */
 928           if (GET_CODE (insn) == INSN && GET_CODE (PATTERN (insn)) == USE
 929               && GET_RTX_CLASS (GET_CODE (XEXP (PATTERN (insn), 0))) == 'i')
 930               real_insn = XEXP (PATTERN (insn), 0);
 931
 932           if (GET_CODE (real_insn) == CALL_INSN)
 933             {
 934               /* CALL clobbers all call-used regs that aren't fixed except
 935                  sp, ap, and fp.  Do this before setting the result of the
 936                  call live.  */
 937               for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 938                 if (call_used_regs[i]
 939                     && i != STACK_POINTER_REGNUM && i != FRAME_POINTER_REGNUM
 940                     && i != ARG_POINTER_REGNUM
 941 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
 942                     && i != HARD_FRAME_POINTER_REGNUM
 943 #endif
 944 #if ARG_POINTER_REGNUM != FRAME_POINTER_REGNUM
 945                     && ! (i == ARG_POINTER_REGNUM && fixed_regs[i])
 946 #endif
 947 #ifdef PIC_OFFSET_TABLE_REGNUM
 948                     && ! (i == PIC_OFFSET_TABLE_REGNUM && flag_pic)
 949 #endif
 950                     )
 951                   CLEAR_HARD_REG_BIT (current_live_regs, i);
 952
 953               /* A CALL_INSN sets any global register live, since it may
 954                  have been modified by the call.  */
 955               for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
 956                 if (global_regs[i])
 957                   SET_HARD_REG_BIT (current_live_regs, i);
 958             }
 959
 960           /* Mark anything killed in an insn to be deadened at the next
 961              label.  Ignore USE insns; the only REG_DEAD notes will be for
 962              parameters.  But they might be early.  A CALL_INSN will usually
 963              clobber registers used for parameters.  It isn't worth bothering
 964              with the unlikely case when it won't.  */
 965           if ((GET_CODE (real_insn) == INSN
 966                && GET_CODE (PATTERN (real_insn)) != USE
 967                && GET_CODE (PATTERN (real_insn)) != CLOBBER)
 968               || GET_CODE (real_insn) == JUMP_INSN
 969               || GET_CODE (real_insn) == CALL_INSN)
 970             {
 971               for (link = REG_NOTES (real_insn); link; link = XEXP (link, 1))
 972                 if (REG_NOTE_KIND (link) == REG_DEAD
 973                     && GET_CODE (XEXP (link, 0)) == REG
 974                     && REGNO (XEXP (link, 0)) < FIRST_PSEUDO_REGISTER)
 975                   {
 976                     int first_regno = REGNO (XEXP (link, 0));
 977                     int last_regno
 978                       = (first_regno
 979                          + HARD_REGNO_NREGS (first_regno,
 980                                              GET_MODE (XEXP (link, 0))));
 981
 982                     for (i = first_regno; i < last_regno; i++)
 983                       SET_HARD_REG_BIT (pending_dead_regs, i);
 984                   }
 985
 986               note_stores (PATTERN (real_insn), update_live_status);
 987
 988               /* If any registers were unused after this insn, kill them.
 989                  These notes will always be accurate.  */
 990               for (link = REG_NOTES (real_insn); link; link = XEXP (link, 1))
 991                 if (REG_NOTE_KIND (link) == REG_UNUSED
 992                     && GET_CODE (XEXP (link, 0)) == REG
 993                     && REGNO (XEXP (link, 0)) < FIRST_PSEUDO_REGISTER)
 994                   {
 995                     int first_regno = REGNO (XEXP (link, 0));
 996                     int last_regno
 997                       = (first_regno
 998                          + HARD_REGNO_NREGS (first_regno,
 999                                              GET_MODE (XEXP (link, 0))));
1000
1001                     for (i = first_regno; i < last_regno; i++)
1002                       CLEAR_HARD_REG_BIT (current_live_regs, i);
1003                   }
1004             }
1005
1006           else if (GET_CODE (real_insn) == CODE_LABEL)
1007             {
1008               /* A label clobbers the pending dead registers since neither
1009                  reload nor jump will propagate a value across a label.  */
1010               AND_COMPL_HARD_REG_SET (current_live_regs, pending_dead_regs);
1011               CLEAR_HARD_REG_SET (pending_dead_regs);
1012             }
1013
1014           /* The beginning of the epilogue corresponds to the end of the
1015              RTL chain when there are no epilogue insns.  Certain resources
1016              are implicitly required at that point.  */
1017           else if (GET_CODE (real_insn) == NOTE
1018                    && NOTE_LINE_NUMBER (real_insn) == NOTE_INSN_EPILOGUE_BEG)
1019             IOR_HARD_REG_SET (current_live_regs, start_of_epilogue_needs.regs);
1020         }
1021
1022       COPY_HARD_REG_SET (res->regs, current_live_regs);
1023       if (tinfo != NULL)
1024         {
1025           tinfo->block = b;
1026           tinfo->bb_tick = bb_ticks[b];
1027         }
1028     }
1029   else
1030     /* We didn't find the start of a basic block.  Assume everything
1031        in use.  This should happen only extremely rarely.  */
1032     SET_HARD_REG_SET (res->regs);
1033
1034   CLEAR_RESOURCE (&set);
1035   CLEAR_RESOURCE (&needed);
1036
1037   jump_insn = find_dead_or_set_registers (target, res, &jump_target, 0,
1038                                           set, needed);
1039
1040   /* If we hit an unconditional branch, we have another way of finding out
1041      what is live: we can see what is live at the branch target and include
1042      anything used but not set before the branch.  The only things that are
1043      live are those that are live using the above test and the test below.  */
1044
1045   if (jump_insn)
1046     {
1047       struct resources new_resources;
1048       rtx stop_insn = next_active_insn (jump_insn);
1049
1050       mark_target_live_regs (insns, next_active_insn (jump_target),
1051                              &new_resources);
1052       CLEAR_RESOURCE (&set);
1053       CLEAR_RESOURCE (&needed);
1054
1055       /* Include JUMP_INSN in the needed registers.  */
1056       for (insn = target; insn != stop_insn; insn = next_active_insn (insn))
1057         {
1058           mark_referenced_resources (insn, &needed, 1);
1059
1060           COPY_HARD_REG_SET (scratch, needed.regs);
1061           AND_COMPL_HARD_REG_SET (scratch, set.regs);
1062           IOR_HARD_REG_SET (new_resources.regs, scratch);
1063
1064           mark_set_resources (insn, &set, 0, 1);
1065         }
1066
1067       AND_HARD_REG_SET (res->regs, new_resources.regs);
1068     }
1069
1070   if (tinfo != NULL)
1071     {
1072       COPY_HARD_REG_SET (tinfo->live_regs, res->regs);
1073     }
1074 }
1075 \f
1076 /* Initialize the resources required by mark_target_live_regs ().
1077    This should be invoked before the first call to mark_target_live_regs.  */
1078
1079 void
1080 init_resource_info (epilogue_insn)
1081      rtx epilogue_insn;
1082 {
1083   int i;
1084
1085   /* Indicate what resources are required to be valid at the end of the current
1086      function.  The condition code never is and memory always is.  If the
1087      frame pointer is needed, it is and so is the stack pointer unless
1088      EXIT_IGNORE_STACK is non-zero.  If the frame pointer is not needed, the
1089      stack pointer is.  Registers used to return the function value are
1090      needed.  Registers holding global variables are needed.  */
1091
1092   end_of_function_needs.cc = 0;
1093   end_of_function_needs.memory = 1;
1094   end_of_function_needs.unch_memory = 0;
1095   CLEAR_HARD_REG_SET (end_of_function_needs.regs);
1096
1097   if (frame_pointer_needed)
1098     {
1099       SET_HARD_REG_BIT (end_of_function_needs.regs, FRAME_POINTER_REGNUM);
1100 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
1101       SET_HARD_REG_BIT (end_of_function_needs.regs, HARD_FRAME_POINTER_REGNUM);
1102 #endif
1103 #ifdef EXIT_IGNORE_STACK
1104       if (! EXIT_IGNORE_STACK
1105           || current_function_sp_is_unchanging)
1106 #endif
1107         SET_HARD_REG_BIT (end_of_function_needs.regs, STACK_POINTER_REGNUM);
1108     }
1109   else
1110     SET_HARD_REG_BIT (end_of_function_needs.regs, STACK_POINTER_REGNUM);
1111
1112   if (current_function_return_rtx != 0)
1113     mark_referenced_resources (current_function_return_rtx,
1114                                &end_of_function_needs, 1);
1115
1116   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1117     if (global_regs[i]
1118 #ifdef EPILOGUE_USES
1119         || EPILOGUE_USES (i)
1120 #endif
1121         )
1122       SET_HARD_REG_BIT (end_of_function_needs.regs, i);
1123
1124   /* The registers required to be live at the end of the function are
1125      represented in the flow information as being dead just prior to
1126      reaching the end of the function.  For example, the return of a value
1127      might be represented by a USE of the return register immediately
1128      followed by an unconditional jump to the return label where the
1129      return label is the end of the RTL chain.  The end of the RTL chain
1130      is then taken to mean that the return register is live.
1131
1132      This sequence is no longer maintained when epilogue instructions are
1133      added to the RTL chain.  To reconstruct the original meaning, the
1134      start of the epilogue (NOTE_INSN_EPILOGUE_BEG) is regarded as the
1135      point where these registers become live (start_of_epilogue_needs).
1136      If epilogue instructions are present, the registers set by those
1137      instructions won't have been processed by flow.  Thus, those
1138      registers are additionally required at the end of the RTL chain
1139      (end_of_function_needs).  */
1140
1141   start_of_epilogue_needs = end_of_function_needs;
1142
1143   while ((epilogue_insn = next_nonnote_insn (epilogue_insn)))
1144     mark_set_resources (epilogue_insn, &end_of_function_needs, 0, 1);
1145
1146   /* Allocate and initialize the tables used by mark_target_live_regs.  */
1147   target_hash_table
1148     = (struct target_info **) xmalloc ((TARGET_HASH_PRIME
1149                                        * sizeof (struct target_info *)));
1150   bzero ((char *) target_hash_table,
1151          TARGET_HASH_PRIME * sizeof (struct target_info *));
1152
1153   bb_ticks = (int *) xmalloc (n_basic_blocks * sizeof (int));
1154   bzero ((char *) bb_ticks, n_basic_blocks * sizeof (int));
1155 }
1156 \f
1157 /* Free up the resources allcated to mark_target_live_regs ().  This
1158    should be invoked after the last call to mark_target_live_regs ().  */
1159
1160 void
1161 free_resource_info ()
1162 {
1163   if (target_hash_table != NULL)
1164     {
1165       free (target_hash_table);
1166       target_hash_table = NULL;
1167     }
1168
1169   if (bb_ticks != NULL)
1170     {
1171       free (bb_ticks);
1172       bb_ticks = NULL;
1173     }
1174 }
1175 \f
1176 /* Clear any hashed information that we have stored for INSN.  */
1177
1178 void
1179 clear_hashed_info_for_insn (insn)
1180      rtx insn;
1181 {
1182   struct target_info *tinfo;
1183
1184   if (target_hash_table != NULL)
1185     {
1186       for (tinfo = target_hash_table[INSN_UID (insn) % TARGET_HASH_PRIME];
1187            tinfo; tinfo = tinfo->next)
1188         if (tinfo->uid == INSN_UID (insn))
1189           break;
1190
1191       if (tinfo)
1192         tinfo->block = -1;
1193     }
1194 }
1195 \f
1196 /* Increment the tick count for the basic block that contains INSN.  */
1197
1198 void
1199 incr_ticks_for_insn (insn)
1200      rtx insn;
1201 {
1202   int b = find_basic_block (insn);
1203
1204   if (b != -1)
1205     bb_ticks[b]++;
1206 }
1207 \f
1208 /* Add TRIAL to the set of resources used at the end of the current
1209    function. */
1210 void
1211 mark_end_of_function_resources (trial, include_delayed_effects)
1212      rtx trial;
1213      int include_delayed_effects;
1214 {
1215   mark_referenced_resources (trial, &end_of_function_needs,
1216                              include_delayed_effects);
1217 }
1218 \f
1219 /* Try to find an available hard register of mode MODE at
1220    CURRENT_INSN, matching the register class in CLASS_STR. Registers
1221    that already have bits set in REG_SET will not be considered.
1222
1223    If an appropriate register is available, it will be returned and the
1224    corresponding bit(s) in REG_SET will be set; otherwise, NULL_RTX is
1225    returned.  */
1226
1227 rtx
1228 find_free_register (current_insn, class_str, mode, reg_set)
1229      rtx current_insn;
1230      char *class_str;
1231      int mode;
1232      HARD_REG_SET *reg_set;
1233 {
1234   int i, j;
1235   struct resources used;
1236   unsigned char clet = class_str[0];
1237   enum reg_class class
1238     = (clet == 'r' ? GENERAL_REGS :  REG_CLASS_FROM_LETTER (clet));
1239
1240   mark_target_live_regs (get_insns (), current_insn, &used);
1241
1242   for (i = 0; i < FIRST_PSEUDO_REGISTER; i++)
1243     {
1244       int success = 1;
1245
1246       if (! TEST_HARD_REG_BIT (reg_class_contents[class], i))
1247         continue;
1248       for (j = HARD_REGNO_NREGS (i, mode) - 1; j >= 0; j--)
1249         {
1250           if (TEST_HARD_REG_BIT (*reg_set, i + j)
1251               || TEST_HARD_REG_BIT (used.regs, i + j))
1252             {
1253               success = 0;
1254               break;
1255             }
1256         }
1257       if (success)
1258         {
1259           for (j = HARD_REGNO_NREGS (i, mode) - 1; j >= 0; j--)
1260             {
1261               SET_HARD_REG_BIT (*reg_set, i + j);
1262             }
1263           return gen_rtx_REG (mode, i);
1264         }
1265     }
1266   return NULL_RTX;
1267 }