gcc/explow.c

   1 /* Subroutines for manipulating rtx's in semantically interesting ways.
   2    Copyright (C) 1987, 1991, 1994, 1995, 1996 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
  22 #include "config.h"
  23 #include "rtl.h"
  24 #include "tree.h"
  25 #include "flags.h"
  26 #include "expr.h"
  27 #include "hard-reg-set.h"
  28 #include "insn-config.h"
  29 #include "recog.h"
  30 #include "insn-flags.h"
  31 #include "insn-codes.h"
  32
  33 static rtx break_out_memory_refs        PROTO((rtx));
  34
  35 /* Return an rtx for the sum of X and the integer C.
  36
  37    This function should be used via the `plus_constant' macro.  */
  38
  39 rtx
  40 plus_constant_wide (x, c)
  41      register rtx x;
  42      register HOST_WIDE_INT c;
  43 {
  44   register RTX_CODE code;
  45   register enum machine_mode mode;
  46   register rtx tem;
  47   int all_constant = 0;
  48
  49   if (c == 0)
  50     return x;
  51
  52  restart:
  53
  54   code = GET_CODE (x);
  55   mode = GET_MODE (x);
  56   switch (code)
  57     {
  58     case CONST_INT:
  59       return GEN_INT (INTVAL (x) + c);
  60
  61     case CONST_DOUBLE:
  62       {
  63         HOST_WIDE_INT l1 = CONST_DOUBLE_LOW (x);
  64         HOST_WIDE_INT h1 = CONST_DOUBLE_HIGH (x);
  65         HOST_WIDE_INT l2 = c;
  66         HOST_WIDE_INT h2 = c < 0 ? ~0 : 0;
  67         HOST_WIDE_INT lv, hv;
  68
  69         add_double (l1, h1, l2, h2, &lv, &hv);
  70
  71         return immed_double_const (lv, hv, VOIDmode);
  72       }
  73
  74     case MEM:
  75       /* If this is a reference to the constant pool, try replacing it with
  76          a reference to a new constant.  If the resulting address isn't
  77          valid, don't return it because we have no way to validize it.  */
  78       if (GET_CODE (XEXP (x, 0)) == SYMBOL_REF
  79           && CONSTANT_POOL_ADDRESS_P (XEXP (x, 0)))
  80         {
  81           tem
  82             = force_const_mem (GET_MODE (x),
  83                                plus_constant (get_pool_constant (XEXP (x, 0)),
  84                                               c));
  85           if (memory_address_p (GET_MODE (tem), XEXP (tem, 0)))
  86             return tem;
  87         }
  88       break;
  89
  90     case CONST:
  91       /* If adding to something entirely constant, set a flag
  92          so that we can add a CONST around the result.  */
  93       x = XEXP (x, 0);
  94       all_constant = 1;
  95       goto restart;
  96
  97     case SYMBOL_REF:
  98     case LABEL_REF:
  99       all_constant = 1;
 100       break;
 101
 102     case PLUS:
 103       /* The interesting case is adding the integer to a sum.
 104          Look for constant term in the sum and combine
 105          with C.  For an integer constant term, we make a combined
 106          integer.  For a constant term that is not an explicit integer,
 107          we cannot really combine, but group them together anyway.
 108
 109          Use a recursive call in case the remaining operand is something
 110          that we handle specially, such as a SYMBOL_REF.  */
 111
 112       if (GET_CODE (XEXP (x, 1)) == CONST_INT)
 113         return plus_constant (XEXP (x, 0), c + INTVAL (XEXP (x, 1)));
 114       else if (CONSTANT_P (XEXP (x, 0)))
 115         return gen_rtx (PLUS, mode,
 116                         plus_constant (XEXP (x, 0), c),
 117                         XEXP (x, 1));
 118       else if (CONSTANT_P (XEXP (x, 1)))
 119         return gen_rtx (PLUS, mode,
 120                         XEXP (x, 0),
 121                         plus_constant (XEXP (x, 1), c));
 122     }
 123
 124   if (c != 0)
 125     x = gen_rtx (PLUS, mode, x, GEN_INT (c));
 126
 127   if (GET_CODE (x) == SYMBOL_REF || GET_CODE (x) == LABEL_REF)
 128     return x;
 129   else if (all_constant)
 130     return gen_rtx (CONST, mode, x);
 131   else
 132     return x;
 133 }
 134
 135 /* This is the same as `plus_constant', except that it handles LO_SUM.
 136
 137    This function should be used via the `plus_constant_for_output' macro.  */
 138
 139 rtx
 140 plus_constant_for_output_wide (x, c)
 141      register rtx x;
 142      register HOST_WIDE_INT c;
 143 {
 144   register RTX_CODE code = GET_CODE (x);
 145   register enum machine_mode mode = GET_MODE (x);
 146   int all_constant = 0;
 147
 148   if (GET_CODE (x) == LO_SUM)
 149     return gen_rtx (LO_SUM, mode, XEXP (x, 0),
 150                     plus_constant_for_output (XEXP (x, 1), c));
 151
 152   else
 153     return plus_constant (x, c);
 154 }
 155 \f
 156 /* If X is a sum, return a new sum like X but lacking any constant terms.
 157    Add all the removed constant terms into *CONSTPTR.
 158    X itself is not altered.  The result != X if and only if
 159    it is not isomorphic to X.  */
 160
 161 rtx
 162 eliminate_constant_term (x, constptr)
 163      rtx x;
 164      rtx *constptr;
 165 {
 166   register rtx x0, x1;
 167   rtx tem;
 168
 169   if (GET_CODE (x) != PLUS)
 170     return x;
 171
 172   /* First handle constants appearing at this level explicitly.  */
 173   if (GET_CODE (XEXP (x, 1)) == CONST_INT
 174       && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x), *constptr,
 175                                                 XEXP (x, 1)))
 176       && GET_CODE (tem) == CONST_INT)
 177     {
 178       *constptr = tem;
 179       return eliminate_constant_term (XEXP (x, 0), constptr);
 180     }
 181
 182   tem = const0_rtx;
 183   x0 = eliminate_constant_term (XEXP (x, 0), &tem);
 184   x1 = eliminate_constant_term (XEXP (x, 1), &tem);
 185   if ((x1 != XEXP (x, 1) || x0 != XEXP (x, 0))
 186       && 0 != (tem = simplify_binary_operation (PLUS, GET_MODE (x),
 187                                                 *constptr, tem))
 188       && GET_CODE (tem) == CONST_INT)
 189     {
 190       *constptr = tem;
 191       return gen_rtx (PLUS, GET_MODE (x), x0, x1);
 192     }
 193
 194   return x;
 195 }
 196
 197 /* Returns the insn that next references REG after INSN, or 0
 198    if REG is clobbered before next referenced or we cannot find
 199    an insn that references REG in a straight-line piece of code.  */
 200
 201 rtx
 202 find_next_ref (reg, insn)
 203      rtx reg;
 204      rtx insn;
 205 {
 206   rtx next;
 207
 208   for (insn = NEXT_INSN (insn); insn; insn = next)
 209     {
 210       next = NEXT_INSN (insn);
 211       if (GET_CODE (insn) == NOTE)
 212         continue;
 213       if (GET_CODE (insn) == CODE_LABEL
 214           || GET_CODE (insn) == BARRIER)
 215         return 0;
 216       if (GET_CODE (insn) == INSN
 217           || GET_CODE (insn) == JUMP_INSN
 218           || GET_CODE (insn) == CALL_INSN)
 219         {
 220           if (reg_set_p (reg, insn))
 221             return 0;
 222           if (reg_mentioned_p (reg, PATTERN (insn)))
 223             return insn;
 224           if (GET_CODE (insn) == JUMP_INSN)
 225             {
 226               if (simplejump_p (insn))
 227                 next = JUMP_LABEL (insn);
 228               else
 229                 return 0;
 230             }
 231           if (GET_CODE (insn) == CALL_INSN
 232               && REGNO (reg) < FIRST_PSEUDO_REGISTER
 233               && call_used_regs[REGNO (reg)])
 234             return 0;
 235         }
 236       else
 237         abort ();
 238     }
 239   return 0;
 240 }
 241
 242 /* Return an rtx for the size in bytes of the value of EXP.  */
 243
 244 rtx
 245 expr_size (exp)
 246      tree exp;
 247 {
 248   tree size = size_in_bytes (TREE_TYPE (exp));
 249
 250   if (TREE_CODE (size) != INTEGER_CST
 251       && contains_placeholder_p (size))
 252     size = build (WITH_RECORD_EXPR, sizetype, size, exp);
 253
 254   return expand_expr (size, NULL_RTX, TYPE_MODE (sizetype), 0);
 255 }
 256 \f
 257 /* Return a copy of X in which all memory references
 258    and all constants that involve symbol refs
 259    have been replaced with new temporary registers.
 260    Also emit code to load the memory locations and constants
 261    into those registers.
 262
 263    If X contains no such constants or memory references,
 264    X itself (not a copy) is returned.
 265
 266    If a constant is found in the address that is not a legitimate constant
 267    in an insn, it is left alone in the hope that it might be valid in the
 268    address.
 269
 270    X may contain no arithmetic except addition, subtraction and multiplication.
 271    Values returned by expand_expr with 1 for sum_ok fit this constraint.  */
 272
 273 static rtx
 274 break_out_memory_refs (x)
 275      register rtx x;
 276 {
 277   if (GET_CODE (x) == MEM
 278       || (CONSTANT_P (x) && CONSTANT_ADDRESS_P (x)
 279           && GET_MODE (x) != VOIDmode))
 280     x = force_reg (GET_MODE (x), x);
 281   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
 282            || GET_CODE (x) == MULT)
 283     {
 284       register rtx op0 = break_out_memory_refs (XEXP (x, 0));
 285       register rtx op1 = break_out_memory_refs (XEXP (x, 1));
 286
 287       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
 288         x = gen_rtx (GET_CODE (x), Pmode, op0, op1);
 289     }
 290
 291   return x;
 292 }
 293
 294 #ifdef POINTERS_EXTEND_UNSIGNED
 295
 296 /* Given X, a memory address in ptr_mode, convert it to an address
 297    in Pmode, or vice versa (TO_MODE says which way).  We take advantage of
 298    the fact that pointers are not allowed to overflow by commuting arithmetic
 299    operations over conversions so that address arithmetic insns can be
 300    used.  */
 301
 302 rtx
 303 convert_memory_address (to_mode, x)
 304      enum machine_mode to_mode;
 305      rtx x;
 306 {
 307   enum machine_mode from_mode = to_mode == ptr_mode ? Pmode : ptr_mode;
 308   rtx temp;
 309
 310   /* Here we handle some special cases.  If none of them apply, fall through
 311      to the default case.  */
 312   switch (GET_CODE (x))
 313     {
 314     case CONST_INT:
 315     case CONST_DOUBLE:
 316       return x;
 317
 318     case LABEL_REF:
 319       return gen_rtx (LABEL_REF, to_mode, XEXP (x, 0));
 320
 321     case SYMBOL_REF:
 322       temp = gen_rtx (SYMBOL_REF, to_mode, XSTR (x, 0));
 323       SYMBOL_REF_FLAG (temp) = SYMBOL_REF_FLAG (x);
 324       return temp;
 325
 326     case CONST:
 327       return gen_rtx (CONST, to_mode,
 328                       convert_memory_address (to_mode, XEXP (x, 0)));
 329
 330     case PLUS:
 331     case MULT:
 332       /* For addition the second operand is a small constant, we can safely
 333          permute the converstion and addition operation.  We can always safely
 334          permute them if we are making the address narrower.  In addition,
 335          always permute the operations if this is a constant.  */
 336       if (GET_MODE_SIZE (to_mode) < GET_MODE_SIZE (from_mode)
 337           || (GET_CODE (x) == PLUS && GET_CODE (XEXP (x, 1)) == CONST_INT
 338               && (INTVAL (XEXP (x, 1)) + 20000 < 40000
 339                   || CONSTANT_P (XEXP (x, 0)))))
 340         return gen_rtx (GET_CODE (x), to_mode,
 341                         convert_memory_address (to_mode, XEXP (x, 0)),
 342                         convert_memory_address (to_mode, XEXP (x, 1)));
 343     }
 344
 345   return convert_modes (to_mode, from_mode,
 346                         x, POINTERS_EXTEND_UNSIGNED);
 347 }
 348 #endif
 349
 350 /* Given a memory address or facsimile X, construct a new address,
 351    currently equivalent, that is stable: future stores won't change it.
 352
 353    X must be composed of constants, register and memory references
 354    combined with addition, subtraction and multiplication:
 355    in other words, just what you can get from expand_expr if sum_ok is 1.
 356
 357    Works by making copies of all regs and memory locations used
 358    by X and combining them the same way X does.
 359    You could also stabilize the reference to this address
 360    by copying the address to a register with copy_to_reg;
 361    but then you wouldn't get indexed addressing in the reference.  */
 362
 363 rtx
 364 copy_all_regs (x)
 365      register rtx x;
 366 {
 367   if (GET_CODE (x) == REG)
 368     {
 369       if (REGNO (x) != FRAME_POINTER_REGNUM
 370 #if HARD_FRAME_POINTER_REGNUM != FRAME_POINTER_REGNUM
 371           && REGNO (x) != HARD_FRAME_POINTER_REGNUM
 372 #endif
 373           )
 374         x = copy_to_reg (x);
 375     }
 376   else if (GET_CODE (x) == MEM)
 377     x = copy_to_reg (x);
 378   else if (GET_CODE (x) == PLUS || GET_CODE (x) == MINUS
 379            || GET_CODE (x) == MULT)
 380     {
 381       register rtx op0 = copy_all_regs (XEXP (x, 0));
 382       register rtx op1 = copy_all_regs (XEXP (x, 1));
 383       if (op0 != XEXP (x, 0) || op1 != XEXP (x, 1))
 384         x = gen_rtx (GET_CODE (x), Pmode, op0, op1);
 385     }
 386   return x;
 387 }
 388 \f
 389 /* Return something equivalent to X but valid as a memory address
 390    for something of mode MODE.  When X is not itself valid, this
 391    works by copying X or subexpressions of it into registers.  */
 392
 393 rtx
 394 memory_address (mode, x)
 395      enum machine_mode mode;
 396      register rtx x;
 397 {
 398   register rtx oldx = x;
 399
 400 #ifdef POINTERS_EXTEND_UNSIGNED
 401   if (GET_MODE (x) == ptr_mode)
 402     x = convert_memory_address (Pmode, x);
 403 #endif
 404
 405   /* By passing constant addresses thru registers
 406      we get a chance to cse them.  */
 407   if (! cse_not_expected && CONSTANT_P (x) && CONSTANT_ADDRESS_P (x))
 408     x = force_reg (Pmode, x);
 409
 410   /* Accept a QUEUED that refers to a REG
 411      even though that isn't a valid address.
 412      On attempting to put this in an insn we will call protect_from_queue
 413      which will turn it into a REG, which is valid.  */
 414   else if (GET_CODE (x) == QUEUED
 415       && GET_CODE (QUEUED_VAR (x)) == REG)
 416     ;
 417
 418   /* We get better cse by rejecting indirect addressing at this stage.
 419      Let the combiner create indirect addresses where appropriate.
 420      For now, generate the code so that the subexpressions useful to share
 421      are visible.  But not if cse won't be done!  */
 422   else
 423     {
 424       if (! cse_not_expected && GET_CODE (x) != REG)
 425         x = break_out_memory_refs (x);
 426
 427       /* At this point, any valid address is accepted.  */
 428       GO_IF_LEGITIMATE_ADDRESS (mode, x, win);
 429
 430       /* If it was valid before but breaking out memory refs invalidated it,
 431          use it the old way.  */
 432       if (memory_address_p (mode, oldx))
 433         goto win2;
 434
 435       /* Perform machine-dependent transformations on X
 436          in certain cases.  This is not necessary since the code
 437          below can handle all possible cases, but machine-dependent
 438          transformations can make better code.  */
 439       LEGITIMIZE_ADDRESS (x, oldx, mode, win);
 440
 441       /* PLUS and MULT can appear in special ways
 442          as the result of attempts to make an address usable for indexing.
 443          Usually they are dealt with by calling force_operand, below.
 444          But a sum containing constant terms is special
 445          if removing them makes the sum a valid address:
 446          then we generate that address in a register
 447          and index off of it.  We do this because it often makes
 448          shorter code, and because the addresses thus generated
 449          in registers often become common subexpressions.  */
 450       if (GET_CODE (x) == PLUS)
 451         {
 452           rtx constant_term = const0_rtx;
 453           rtx y = eliminate_constant_term (x, &constant_term);
 454           if (constant_term == const0_rtx
 455               || ! memory_address_p (mode, y))
 456             x = force_operand (x, NULL_RTX);
 457           else
 458             {
 459               y = gen_rtx (PLUS, GET_MODE (x), copy_to_reg (y), constant_term);
 460               if (! memory_address_p (mode, y))
 461                 x = force_operand (x, NULL_RTX);
 462               else
 463                 x = y;
 464             }
 465         }
 466
 467       else if (GET_CODE (x) == MULT || GET_CODE (x) == MINUS)
 468         x = force_operand (x, NULL_RTX);
 469
 470       /* If we have a register that's an invalid address,
 471          it must be a hard reg of the wrong class.  Copy it to a pseudo.  */
 472       else if (GET_CODE (x) == REG)
 473         x = copy_to_reg (x);
 474
 475       /* Last resort: copy the value to a register, since
 476          the register is a valid address.  */
 477       else
 478         x = force_reg (Pmode, x);
 479
 480       goto done;
 481
 482     win2:
 483       x = oldx;
 484     win:
 485       if (flag_force_addr && ! cse_not_expected && GET_CODE (x) != REG
 486           /* Don't copy an addr via a reg if it is one of our stack slots.  */
 487           && ! (GET_CODE (x) == PLUS
 488                 && (XEXP (x, 0) == virtual_stack_vars_rtx
 489                     || XEXP (x, 0) == virtual_incoming_args_rtx)))
 490         {
 491           if (general_operand (x, Pmode))
 492             x = force_reg (Pmode, x);
 493           else
 494             x = force_operand (x, NULL_RTX);
 495         }
 496     }
 497
 498  done:
 499
 500   /* If we didn't change the address, we are done.  Otherwise, mark
 501      a reg as a pointer if we have REG or REG + CONST_INT.  */
 502   if (oldx == x)
 503     return x;
 504   else if (GET_CODE (x) == REG)
 505     mark_reg_pointer (x, 1);
 506   else if (GET_CODE (x) == PLUS
 507            && GET_CODE (XEXP (x, 0)) == REG
 508            && GET_CODE (XEXP (x, 1)) == CONST_INT)
 509     mark_reg_pointer (XEXP (x, 0), 1);
 510
 511   /* OLDX may have been the address on a temporary.  Update the address
 512      to indicate that X is now used.  */
 513   update_temp_slot_address (oldx, x);
 514
 515   return x;
 516 }
 517
 518 /* Like `memory_address' but pretend `flag_force_addr' is 0.  */
 519
 520 rtx
 521 memory_address_noforce (mode, x)
 522      enum machine_mode mode;
 523      rtx x;
 524 {
 525   int ambient_force_addr = flag_force_addr;
 526   rtx val;
 527
 528   flag_force_addr = 0;
 529   val = memory_address (mode, x);
 530   flag_force_addr = ambient_force_addr;
 531   return val;
 532 }
 533
 534 /* Convert a mem ref into one with a valid memory address.
 535    Pass through anything else unchanged.  */
 536
 537 rtx
 538 validize_mem (ref)
 539      rtx ref;
 540 {
 541   if (GET_CODE (ref) != MEM)
 542     return ref;
 543   if (memory_address_p (GET_MODE (ref), XEXP (ref, 0)))
 544     return ref;
 545   /* Don't alter REF itself, since that is probably a stack slot.  */
 546   return change_address (ref, GET_MODE (ref), XEXP (ref, 0));
 547 }
 548 \f
 549 /* Return a modified copy of X with its memory address copied
 550    into a temporary register to protect it from side effects.
 551    If X is not a MEM, it is returned unchanged (and not copied).
 552    Perhaps even if it is a MEM, if there is no need to change it.  */
 553
 554 rtx
 555 stabilize (x)
 556      rtx x;
 557 {
 558   register rtx addr;
 559   if (GET_CODE (x) != MEM)
 560     return x;
 561   addr = XEXP (x, 0);
 562   if (rtx_unstable_p (addr))
 563     {
 564       rtx temp = copy_all_regs (addr);
 565       rtx mem;
 566       if (GET_CODE (temp) != REG)
 567         temp = copy_to_reg (temp);
 568       mem = gen_rtx (MEM, GET_MODE (x), temp);
 569
 570       /* Mark returned memref with in_struct if it's in an array or
 571          structure.  Copy const and volatile from original memref.  */
 572
 573       MEM_IN_STRUCT_P (mem) = MEM_IN_STRUCT_P (x) || GET_CODE (addr) == PLUS;
 574       RTX_UNCHANGING_P (mem) = RTX_UNCHANGING_P (x);
 575       MEM_VOLATILE_P (mem) = MEM_VOLATILE_P (x);
 576       return mem;
 577     }
 578   return x;
 579 }
 580 \f
 581 /* Copy the value or contents of X to a new temp reg and return that reg.  */
 582
 583 rtx
 584 copy_to_reg (x)
 585      rtx x;
 586 {
 587   register rtx temp = gen_reg_rtx (GET_MODE (x));
 588
 589   /* If not an operand, must be an address with PLUS and MULT so
 590      do the computation.  */
 591   if (! general_operand (x, VOIDmode))
 592     x = force_operand (x, temp);
 593
 594   if (x != temp)
 595     emit_move_insn (temp, x);
 596
 597   return temp;
 598 }
 599
 600 /* Like copy_to_reg but always give the new register mode Pmode
 601    in case X is a constant.  */
 602
 603 rtx
 604 copy_addr_to_reg (x)
 605      rtx x;
 606 {
 607   return copy_to_mode_reg (Pmode, x);
 608 }
 609
 610 /* Like copy_to_reg but always give the new register mode MODE
 611    in case X is a constant.  */
 612
 613 rtx
 614 copy_to_mode_reg (mode, x)
 615      enum machine_mode mode;
 616      rtx x;
 617 {
 618   register rtx temp = gen_reg_rtx (mode);
 619
 620   /* If not an operand, must be an address with PLUS and MULT so
 621      do the computation.  */
 622   if (! general_operand (x, VOIDmode))
 623     x = force_operand (x, temp);
 624
 625   if (GET_MODE (x) != mode && GET_MODE (x) != VOIDmode)
 626     abort ();
 627   if (x != temp)
 628     emit_move_insn (temp, x);
 629   return temp;
 630 }
 631
 632 /* Load X into a register if it is not already one.
 633    Use mode MODE for the register.
 634    X should be valid for mode MODE, but it may be a constant which
 635    is valid for all integer modes; that's why caller must specify MODE.
 636
 637    The caller must not alter the value in the register we return,
 638    since we mark it as a "constant" register.  */
 639
 640 rtx
 641 force_reg (mode, x)
 642      enum machine_mode mode;
 643      rtx x;
 644 {
 645   register rtx temp, insn, set;
 646
 647   if (GET_CODE (x) == REG)
 648     return x;
 649   temp = gen_reg_rtx (mode);
 650   insn = emit_move_insn (temp, x);
 651
 652   /* Let optimizers know that TEMP's value never changes
 653      and that X can be substituted for it.  Don't get confused
 654      if INSN set something else (such as a SUBREG of TEMP).  */
 655   if (CONSTANT_P (x)
 656       && (set = single_set (insn)) != 0
 657       && SET_DEST (set) == temp)
 658     {
 659       rtx note = find_reg_note (insn, REG_EQUAL, NULL_RTX);
 660
 661       if (note)
 662         XEXP (note, 0) = x;
 663       else
 664         REG_NOTES (insn) = gen_rtx (EXPR_LIST, REG_EQUAL, x, REG_NOTES (insn));
 665     }
 666   return temp;
 667 }
 668
 669 /* If X is a memory ref, copy its contents to a new temp reg and return
 670    that reg.  Otherwise, return X.  */
 671
 672 rtx
 673 force_not_mem (x)
 674      rtx x;
 675 {
 676   register rtx temp;
 677   if (GET_CODE (x) != MEM || GET_MODE (x) == BLKmode)
 678     return x;
 679   temp = gen_reg_rtx (GET_MODE (x));
 680   emit_move_insn (temp, x);
 681   return temp;
 682 }
 683
 684 /* Copy X to TARGET (if it's nonzero and a reg)
 685    or to a new temp reg and return that reg.
 686    MODE is the mode to use for X in case it is a constant.  */
 687
 688 rtx
 689 copy_to_suggested_reg (x, target, mode)
 690      rtx x, target;
 691      enum machine_mode mode;
 692 {
 693   register rtx temp;
 694
 695   if (target && GET_CODE (target) == REG)
 696     temp = target;
 697   else
 698     temp = gen_reg_rtx (mode);
 699
 700   emit_move_insn (temp, x);
 701   return temp;
 702 }
 703 \f
 704 /* Return the mode to use to store a scalar of TYPE and MODE.
 705    PUNSIGNEDP points to the signedness of the type and may be adjusted
 706    to show what signedness to use on extension operations.
 707
 708    FOR_CALL is non-zero if this call is promoting args for a call.  */
 709
 710 enum machine_mode
 711 promote_mode (type, mode, punsignedp, for_call)
 712      tree type;
 713      enum machine_mode mode;
 714      int *punsignedp;
 715      int for_call;
 716 {
 717   enum tree_code code = TREE_CODE (type);
 718   int unsignedp = *punsignedp;
 719
 720 #ifdef PROMOTE_FOR_CALL_ONLY
 721   if (! for_call)
 722     return mode;
 723 #endif
 724
 725   switch (code)
 726     {
 727 #ifdef PROMOTE_MODE
 728     case INTEGER_TYPE:   case ENUMERAL_TYPE:   case BOOLEAN_TYPE:
 729     case CHAR_TYPE:      case REAL_TYPE:       case OFFSET_TYPE:
 730       PROMOTE_MODE (mode, unsignedp, type);
 731       break;
 732 #endif
 733
 734 #ifdef POINTERS_EXTEND_UNSIGNED
 735     case POINTER_TYPE:
 736       mode = Pmode;
 737       unsignedp = POINTERS_EXTEND_UNSIGNED;
 738       break;
 739 #endif
 740     }
 741
 742   *punsignedp = unsignedp;
 743   return mode;
 744 }
 745 \f
 746 /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes).
 747    This pops when ADJUST is positive.  ADJUST need not be constant.  */
 748
 749 void
 750 adjust_stack (adjust)
 751      rtx adjust;
 752 {
 753   rtx temp;
 754   adjust = protect_from_queue (adjust, 0);
 755
 756   if (adjust == const0_rtx)
 757     return;
 758
 759   temp = expand_binop (Pmode,
 760 #ifdef STACK_GROWS_DOWNWARD
 761                        add_optab,
 762 #else
 763                        sub_optab,
 764 #endif
 765                        stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
 766                        OPTAB_LIB_WIDEN);
 767
 768   if (temp != stack_pointer_rtx)
 769     emit_move_insn (stack_pointer_rtx, temp);
 770 }
 771
 772 /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes).
 773    This pushes when ADJUST is positive.  ADJUST need not be constant.  */
 774
 775 void
 776 anti_adjust_stack (adjust)
 777      rtx adjust;
 778 {
 779   rtx temp;
 780   adjust = protect_from_queue (adjust, 0);
 781
 782   if (adjust == const0_rtx)
 783     return;
 784
 785   temp = expand_binop (Pmode,
 786 #ifdef STACK_GROWS_DOWNWARD
 787                        sub_optab,
 788 #else
 789                        add_optab,
 790 #endif
 791                        stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
 792                        OPTAB_LIB_WIDEN);
 793
 794   if (temp != stack_pointer_rtx)
 795     emit_move_insn (stack_pointer_rtx, temp);
 796 }
 797
 798 /* Round the size of a block to be pushed up to the boundary required
 799    by this machine.  SIZE is the desired size, which need not be constant.  */
 800
 801 rtx
 802 round_push (size)
 803      rtx size;
 804 {
 805 #ifdef STACK_BOUNDARY
 806   int align = STACK_BOUNDARY / BITS_PER_UNIT;
 807   if (align == 1)
 808     return size;
 809   if (GET_CODE (size) == CONST_INT)
 810     {
 811       int new = (INTVAL (size) + align - 1) / align * align;
 812       if (INTVAL (size) != new)
 813         size = GEN_INT (new);
 814     }
 815   else
 816     {
 817       /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
 818          but we know it can't.  So add ourselves and then do TRUNC_DIV_EXPR. */
 819       size = expand_binop (Pmode, add_optab, size, GEN_INT (align - 1),
 820                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
 821       size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, GEN_INT (align),
 822                             NULL_RTX, 1);
 823       size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
 824     }
 825 #endif /* STACK_BOUNDARY */
 826   return size;
 827 }
 828 \f
 829 /* Save the stack pointer for the purpose in SAVE_LEVEL.  PSAVE is a pointer
 830    to a previously-created save area.  If no save area has been allocated,
 831    this function will allocate one.  If a save area is specified, it
 832    must be of the proper mode.
 833
 834    The insns are emitted after insn AFTER, if nonzero, otherwise the insns
 835    are emitted at the current position.  */
 836
 837 void
 838 emit_stack_save (save_level, psave, after)
 839      enum save_level save_level;
 840      rtx *psave;
 841      rtx after;
 842 {
 843   rtx sa = *psave;
 844   /* The default is that we use a move insn and save in a Pmode object.  */
 845   rtx (*fcn) () = gen_move_insn;
 846   enum machine_mode mode = Pmode;
 847
 848   /* See if this machine has anything special to do for this kind of save.  */
 849   switch (save_level)
 850     {
 851 #ifdef HAVE_save_stack_block
 852     case SAVE_BLOCK:
 853       if (HAVE_save_stack_block)
 854         {
 855           fcn = gen_save_stack_block;
 856           mode = insn_operand_mode[CODE_FOR_save_stack_block][0];
 857         }
 858       break;
 859 #endif
 860 #ifdef HAVE_save_stack_function
 861     case SAVE_FUNCTION:
 862       if (HAVE_save_stack_function)
 863         {
 864           fcn = gen_save_stack_function;
 865           mode = insn_operand_mode[CODE_FOR_save_stack_function][0];
 866         }
 867       break;
 868 #endif
 869 #ifdef HAVE_save_stack_nonlocal
 870     case SAVE_NONLOCAL:
 871       if (HAVE_save_stack_nonlocal)
 872         {
 873           fcn = gen_save_stack_nonlocal;
 874           mode = insn_operand_mode[(int) CODE_FOR_save_stack_nonlocal][0];
 875         }
 876       break;
 877 #endif
 878     }
 879
 880   /* If there is no save area and we have to allocate one, do so.  Otherwise
 881      verify the save area is the proper mode.  */
 882
 883   if (sa == 0)
 884     {
 885       if (mode != VOIDmode)
 886         {
 887           if (save_level == SAVE_NONLOCAL)
 888             *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
 889           else
 890             *psave = sa = gen_reg_rtx (mode);
 891         }
 892     }
 893   else
 894     {
 895       if (mode == VOIDmode || GET_MODE (sa) != mode)
 896         abort ();
 897     }
 898
 899   if (after)
 900     {
 901       rtx seq;
 902
 903       start_sequence ();
 904       /* We must validize inside the sequence, to ensure that any instructions
 905          created by the validize call also get moved to the right place.  */
 906       if (sa != 0)
 907         sa = validize_mem (sa);
 908       emit_insn (fcn (sa, stack_pointer_rtx));
 909       seq = gen_sequence ();
 910       end_sequence ();
 911       emit_insn_after (seq, after);
 912     }
 913   else
 914     {
 915       if (sa != 0)
 916         sa = validize_mem (sa);
 917       emit_insn (fcn (sa, stack_pointer_rtx));
 918     }
 919 }
 920
 921 /* Restore the stack pointer for the purpose in SAVE_LEVEL.  SA is the save
 922    area made by emit_stack_save.  If it is zero, we have nothing to do.
 923
 924    Put any emitted insns after insn AFTER, if nonzero, otherwise at
 925    current position.  */
 926
 927 void
 928 emit_stack_restore (save_level, sa, after)
 929      enum save_level save_level;
 930      rtx after;
 931      rtx sa;
 932 {
 933   /* The default is that we use a move insn.  */
 934   rtx (*fcn) () = gen_move_insn;
 935
 936   /* See if this machine has anything special to do for this kind of save.  */
 937   switch (save_level)
 938     {
 939 #ifdef HAVE_restore_stack_block
 940     case SAVE_BLOCK:
 941       if (HAVE_restore_stack_block)
 942         fcn = gen_restore_stack_block;
 943       break;
 944 #endif
 945 #ifdef HAVE_restore_stack_function
 946     case SAVE_FUNCTION:
 947       if (HAVE_restore_stack_function)
 948         fcn = gen_restore_stack_function;
 949       break;
 950 #endif
 951 #ifdef HAVE_restore_stack_nonlocal
 952
 953     case SAVE_NONLOCAL:
 954       if (HAVE_restore_stack_nonlocal)
 955         fcn = gen_restore_stack_nonlocal;
 956       break;
 957 #endif
 958     }
 959
 960   if (sa != 0)
 961     sa = validize_mem (sa);
 962
 963   if (after)
 964     {
 965       rtx seq;
 966
 967       start_sequence ();
 968       emit_insn (fcn (stack_pointer_rtx, sa));
 969       seq = gen_sequence ();
 970       end_sequence ();
 971       emit_insn_after (seq, after);
 972     }
 973   else
 974     emit_insn (fcn (stack_pointer_rtx, sa));
 975 }
 976 \f
 977 /* Return an rtx representing the address of an area of memory dynamically
 978    pushed on the stack.  This region of memory is always aligned to
 979    a multiple of BIGGEST_ALIGNMENT.
 980
 981    Any required stack pointer alignment is preserved.
 982
 983    SIZE is an rtx representing the size of the area.
 984    TARGET is a place in which the address can be placed.
 985
 986    KNOWN_ALIGN is the alignment (in bits) that we know SIZE has.  */
 987
 988 rtx
 989 allocate_dynamic_stack_space (size, target, known_align)
 990      rtx size;
 991      rtx target;
 992      int known_align;
 993 {
 994   /* If we're asking for zero bytes, it doesn't matter what we point
 995      to since we can't dereference it.  But return a reasonable
 996      address anyway.  */
 997   if (size == const0_rtx)
 998     return virtual_stack_dynamic_rtx;
 999
1000   /* Otherwise, show we're calling alloca or equivalent.  */
1001   current_function_calls_alloca = 1;
1002
1003   /* Ensure the size is in the proper mode.  */
1004   if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1005     size = convert_to_mode (Pmode, size, 1);
1006
1007   /* We will need to ensure that the address we return is aligned to
1008      BIGGEST_ALIGNMENT.  If STACK_DYNAMIC_OFFSET is defined, we don't
1009      always know its final value at this point in the compilation (it
1010      might depend on the size of the outgoing parameter lists, for
1011      example), so we must align the value to be returned in that case.
1012      (Note that STACK_DYNAMIC_OFFSET will have a default non-zero value if
1013      STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
1014      We must also do an alignment operation on the returned value if
1015      the stack pointer alignment is less strict that BIGGEST_ALIGNMENT.
1016
1017      If we have to align, we must leave space in SIZE for the hole
1018      that might result from the alignment operation.  */
1019
1020 #if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET) || defined (ALLOCATE_OUTGOING_ARGS) || ! defined (STACK_BOUNDARY)
1021 #define MUST_ALIGN 1
1022 #else
1023 #define MUST_ALIGN (STACK_BOUNDARY < BIGGEST_ALIGNMENT)
1024 #endif
1025
1026   if (MUST_ALIGN)
1027     {
1028       if (GET_CODE (size) == CONST_INT)
1029         size = GEN_INT (INTVAL (size)
1030                         + (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1));
1031       else
1032         size = expand_binop (Pmode, add_optab, size,
1033                              GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1034                              NULL_RTX, 1, OPTAB_LIB_WIDEN);
1035     }
1036
1037 #ifdef SETJMP_VIA_SAVE_AREA
1038   /* If setjmp restores regs from a save area in the stack frame,
1039      avoid clobbering the reg save area.  Note that the offset of
1040      virtual_incoming_args_rtx includes the preallocated stack args space.
1041      It would be no problem to clobber that, but it's on the wrong side
1042      of the old save area.  */
1043   {
1044     rtx dynamic_offset
1045       = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx,
1046                       stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN);
1047     size = expand_binop (Pmode, add_optab, size, dynamic_offset,
1048                          NULL_RTX, 1, OPTAB_LIB_WIDEN);
1049   }
1050 #endif /* SETJMP_VIA_SAVE_AREA */
1051
1052   /* Round the size to a multiple of the required stack alignment.
1053      Since the stack if presumed to be rounded before this allocation,
1054      this will maintain the required alignment.
1055
1056      If the stack grows downward, we could save an insn by subtracting
1057      SIZE from the stack pointer and then aligning the stack pointer.
1058      The problem with this is that the stack pointer may be unaligned
1059      between the execution of the subtraction and alignment insns and
1060      some machines do not allow this.  Even on those that do, some
1061      signal handlers malfunction if a signal should occur between those
1062      insns.  Since this is an extremely rare event, we have no reliable
1063      way of knowing which systems have this problem.  So we avoid even
1064      momentarily mis-aligning the stack.  */
1065
1066 #ifdef STACK_BOUNDARY
1067   /* If we added a variable amount to SIZE,
1068      we can no longer assume it is aligned.  */
1069 #if !defined (SETJMP_VIA_SAVE_AREA)
1070   if (MUST_ALIGN || known_align % STACK_BOUNDARY != 0)
1071 #endif
1072     size = round_push (size);
1073 #endif
1074
1075   do_pending_stack_adjust ();
1076
1077   /* Don't use a TARGET that isn't a pseudo.  */
1078   if (target == 0 || GET_CODE (target) != REG
1079       || REGNO (target) < FIRST_PSEUDO_REGISTER)
1080     target = gen_reg_rtx (Pmode);
1081
1082   mark_reg_pointer (target, known_align / BITS_PER_UNIT);
1083
1084 #ifndef STACK_GROWS_DOWNWARD
1085   emit_move_insn (target, virtual_stack_dynamic_rtx);
1086 #endif
1087
1088   /* Perform the required allocation from the stack.  Some systems do
1089      this differently than simply incrementing/decrementing from the
1090      stack pointer.  */
1091 #ifdef HAVE_allocate_stack
1092   if (HAVE_allocate_stack)
1093     {
1094       enum machine_mode mode
1095         = insn_operand_mode[(int) CODE_FOR_allocate_stack][0];
1096
1097       size = convert_modes (mode, ptr_mode, size, 1);
1098
1099       if (insn_operand_predicate[(int) CODE_FOR_allocate_stack][0]
1100           && ! ((*insn_operand_predicate[(int) CODE_FOR_allocate_stack][0])
1101                 (size, mode)))
1102         size = copy_to_mode_reg (mode, size);
1103
1104       emit_insn (gen_allocate_stack (size));
1105     }
1106   else
1107 #endif
1108     {
1109       size = convert_modes (Pmode, ptr_mode, size, 1);
1110       anti_adjust_stack (size);
1111     }
1112
1113 #ifdef STACK_GROWS_DOWNWARD
1114   emit_move_insn (target, virtual_stack_dynamic_rtx);
1115 #endif
1116
1117   if (MUST_ALIGN)
1118     {
1119       /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
1120          but we know it can't.  So add ourselves and then do TRUNC_DIV_EXPR. */
1121       target = expand_binop (Pmode, add_optab, target,
1122                              GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1123                              NULL_RTX, 1, OPTAB_LIB_WIDEN);
1124       target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
1125                               GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1126                               NULL_RTX, 1);
1127       target = expand_mult (Pmode, target,
1128                             GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1129                             NULL_RTX, 1);
1130     }
1131
1132   /* Some systems require a particular insn to refer to the stack
1133      to make the pages exist.  */
1134 #ifdef HAVE_probe
1135   if (HAVE_probe)
1136     emit_insn (gen_probe ());
1137 #endif
1138
1139   /* Record the new stack level for nonlocal gotos.  */
1140   if (nonlocal_goto_handler_slot != 0)
1141     emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
1142
1143   return target;
1144 }
1145 \f
1146 /* Return an rtx representing the register or memory location
1147    in which a scalar value of data type VALTYPE
1148    was returned by a function call to function FUNC.
1149    FUNC is a FUNCTION_DECL node if the precise function is known,
1150    otherwise 0.  */
1151
1152 rtx
1153 hard_function_value (valtype, func)
1154      tree valtype;
1155      tree func;
1156 {
1157   rtx val = FUNCTION_VALUE (valtype, func);
1158   if (GET_CODE (val) == REG
1159       && GET_MODE (val) == BLKmode)
1160     {
1161       int bytes = int_size_in_bytes (valtype);
1162       enum machine_mode tmpmode;
1163       for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1164            tmpmode != MAX_MACHINE_MODE;
1165            tmpmode = GET_MODE_WIDER_MODE (tmpmode))
1166         {
1167           /* Have we found a large enough mode?  */
1168           if (GET_MODE_SIZE (tmpmode) >= bytes)
1169             break;
1170         }
1171
1172       /* No suitable mode found.  */
1173       if (tmpmode == MAX_MACHINE_MODE)
1174         abort ();
1175
1176       PUT_MODE (val, tmpmode);
1177     }
1178   return val;
1179 }
1180
1181 /* Return an rtx representing the register or memory location
1182    in which a scalar value of mode MODE was returned by a library call.  */
1183
1184 rtx
1185 hard_libcall_value (mode)
1186      enum machine_mode mode;
1187 {
1188   return LIBCALL_VALUE (mode);
1189 }
1190
1191 /* Look up the tree code for a given rtx code
1192    to provide the arithmetic operation for REAL_ARITHMETIC.
1193    The function returns an int because the caller may not know
1194    what `enum tree_code' means.  */
1195
1196 int
1197 rtx_to_tree_code (code)
1198      enum rtx_code code;
1199 {
1200   enum tree_code tcode;
1201
1202   switch (code)
1203     {
1204     case PLUS:
1205       tcode = PLUS_EXPR;
1206       break;
1207     case MINUS:
1208       tcode = MINUS_EXPR;
1209       break;
1210     case MULT:
1211       tcode = MULT_EXPR;
1212       break;
1213     case DIV:
1214       tcode = RDIV_EXPR;
1215       break;
1216     case SMIN:
1217       tcode = MIN_EXPR;
1218       break;
1219     case SMAX:
1220       tcode = MAX_EXPR;
1221       break;
1222     default:
1223       tcode = LAST_AND_UNUSED_TREE_CODE;
1224       break;
1225     }
1226   return ((int) tcode);
1227 }