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 REFERENCE_TYPE:
 736     case POINTER_TYPE:
 737       mode = Pmode;
 738       unsignedp = POINTERS_EXTEND_UNSIGNED;
 739       break;
 740 #endif
 741     }
 742
 743   *punsignedp = unsignedp;
 744   return mode;
 745 }
 746 \f
 747 /* Adjust the stack pointer by ADJUST (an rtx for a number of bytes).
 748    This pops when ADJUST is positive.  ADJUST need not be constant.  */
 749
 750 void
 751 adjust_stack (adjust)
 752      rtx adjust;
 753 {
 754   rtx temp;
 755   adjust = protect_from_queue (adjust, 0);
 756
 757   if (adjust == const0_rtx)
 758     return;
 759
 760   temp = expand_binop (Pmode,
 761 #ifdef STACK_GROWS_DOWNWARD
 762                        add_optab,
 763 #else
 764                        sub_optab,
 765 #endif
 766                        stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
 767                        OPTAB_LIB_WIDEN);
 768
 769   if (temp != stack_pointer_rtx)
 770     emit_move_insn (stack_pointer_rtx, temp);
 771 }
 772
 773 /* Adjust the stack pointer by minus ADJUST (an rtx for a number of bytes).
 774    This pushes when ADJUST is positive.  ADJUST need not be constant.  */
 775
 776 void
 777 anti_adjust_stack (adjust)
 778      rtx adjust;
 779 {
 780   rtx temp;
 781   adjust = protect_from_queue (adjust, 0);
 782
 783   if (adjust == const0_rtx)
 784     return;
 785
 786   temp = expand_binop (Pmode,
 787 #ifdef STACK_GROWS_DOWNWARD
 788                        sub_optab,
 789 #else
 790                        add_optab,
 791 #endif
 792                        stack_pointer_rtx, adjust, stack_pointer_rtx, 0,
 793                        OPTAB_LIB_WIDEN);
 794
 795   if (temp != stack_pointer_rtx)
 796     emit_move_insn (stack_pointer_rtx, temp);
 797 }
 798
 799 /* Round the size of a block to be pushed up to the boundary required
 800    by this machine.  SIZE is the desired size, which need not be constant.  */
 801
 802 rtx
 803 round_push (size)
 804      rtx size;
 805 {
 806 #ifdef STACK_BOUNDARY
 807   int align = STACK_BOUNDARY / BITS_PER_UNIT;
 808   if (align == 1)
 809     return size;
 810   if (GET_CODE (size) == CONST_INT)
 811     {
 812       int new = (INTVAL (size) + align - 1) / align * align;
 813       if (INTVAL (size) != new)
 814         size = GEN_INT (new);
 815     }
 816   else
 817     {
 818       /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
 819          but we know it can't.  So add ourselves and then do
 820          TRUNC_DIV_EXPR.  */
 821       size = expand_binop (Pmode, add_optab, size, GEN_INT (align - 1),
 822                            NULL_RTX, 1, OPTAB_LIB_WIDEN);
 823       size = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, size, GEN_INT (align),
 824                             NULL_RTX, 1);
 825       size = expand_mult (Pmode, size, GEN_INT (align), NULL_RTX, 1);
 826     }
 827 #endif /* STACK_BOUNDARY */
 828   return size;
 829 }
 830 \f
 831 /* Save the stack pointer for the purpose in SAVE_LEVEL.  PSAVE is a pointer
 832    to a previously-created save area.  If no save area has been allocated,
 833    this function will allocate one.  If a save area is specified, it
 834    must be of the proper mode.
 835
 836    The insns are emitted after insn AFTER, if nonzero, otherwise the insns
 837    are emitted at the current position.  */
 838
 839 void
 840 emit_stack_save (save_level, psave, after)
 841      enum save_level save_level;
 842      rtx *psave;
 843      rtx after;
 844 {
 845   rtx sa = *psave;
 846   /* The default is that we use a move insn and save in a Pmode object.  */
 847   rtx (*fcn) () = gen_move_insn;
 848   enum machine_mode mode = Pmode;
 849
 850   /* See if this machine has anything special to do for this kind of save.  */
 851   switch (save_level)
 852     {
 853 #ifdef HAVE_save_stack_block
 854     case SAVE_BLOCK:
 855       if (HAVE_save_stack_block)
 856         {
 857           fcn = gen_save_stack_block;
 858           mode = insn_operand_mode[CODE_FOR_save_stack_block][0];
 859         }
 860       break;
 861 #endif
 862 #ifdef HAVE_save_stack_function
 863     case SAVE_FUNCTION:
 864       if (HAVE_save_stack_function)
 865         {
 866           fcn = gen_save_stack_function;
 867           mode = insn_operand_mode[CODE_FOR_save_stack_function][0];
 868         }
 869       break;
 870 #endif
 871 #ifdef HAVE_save_stack_nonlocal
 872     case SAVE_NONLOCAL:
 873       if (HAVE_save_stack_nonlocal)
 874         {
 875           fcn = gen_save_stack_nonlocal;
 876           mode = insn_operand_mode[(int) CODE_FOR_save_stack_nonlocal][0];
 877         }
 878       break;
 879 #endif
 880     }
 881
 882   /* If there is no save area and we have to allocate one, do so.  Otherwise
 883      verify the save area is the proper mode.  */
 884
 885   if (sa == 0)
 886     {
 887       if (mode != VOIDmode)
 888         {
 889           if (save_level == SAVE_NONLOCAL)
 890             *psave = sa = assign_stack_local (mode, GET_MODE_SIZE (mode), 0);
 891           else
 892             *psave = sa = gen_reg_rtx (mode);
 893         }
 894     }
 895   else
 896     {
 897       if (mode == VOIDmode || GET_MODE (sa) != mode)
 898         abort ();
 899     }
 900
 901   if (after)
 902     {
 903       rtx seq;
 904
 905       start_sequence ();
 906       /* We must validize inside the sequence, to ensure that any instructions
 907          created by the validize call also get moved to the right place.  */
 908       if (sa != 0)
 909         sa = validize_mem (sa);
 910       emit_insn (fcn (sa, stack_pointer_rtx));
 911       seq = gen_sequence ();
 912       end_sequence ();
 913       emit_insn_after (seq, after);
 914     }
 915   else
 916     {
 917       if (sa != 0)
 918         sa = validize_mem (sa);
 919       emit_insn (fcn (sa, stack_pointer_rtx));
 920     }
 921 }
 922
 923 /* Restore the stack pointer for the purpose in SAVE_LEVEL.  SA is the save
 924    area made by emit_stack_save.  If it is zero, we have nothing to do.
 925
 926    Put any emitted insns after insn AFTER, if nonzero, otherwise at
 927    current position.  */
 928
 929 void
 930 emit_stack_restore (save_level, sa, after)
 931      enum save_level save_level;
 932      rtx after;
 933      rtx sa;
 934 {
 935   /* The default is that we use a move insn.  */
 936   rtx (*fcn) () = gen_move_insn;
 937
 938   /* See if this machine has anything special to do for this kind of save.  */
 939   switch (save_level)
 940     {
 941 #ifdef HAVE_restore_stack_block
 942     case SAVE_BLOCK:
 943       if (HAVE_restore_stack_block)
 944         fcn = gen_restore_stack_block;
 945       break;
 946 #endif
 947 #ifdef HAVE_restore_stack_function
 948     case SAVE_FUNCTION:
 949       if (HAVE_restore_stack_function)
 950         fcn = gen_restore_stack_function;
 951       break;
 952 #endif
 953 #ifdef HAVE_restore_stack_nonlocal
 954
 955     case SAVE_NONLOCAL:
 956       if (HAVE_restore_stack_nonlocal)
 957         fcn = gen_restore_stack_nonlocal;
 958       break;
 959 #endif
 960     }
 961
 962   if (sa != 0)
 963     sa = validize_mem (sa);
 964
 965   if (after)
 966     {
 967       rtx seq;
 968
 969       start_sequence ();
 970       emit_insn (fcn (stack_pointer_rtx, sa));
 971       seq = gen_sequence ();
 972       end_sequence ();
 973       emit_insn_after (seq, after);
 974     }
 975   else
 976     emit_insn (fcn (stack_pointer_rtx, sa));
 977 }
 978 \f
 979 /* Return an rtx representing the address of an area of memory dynamically
 980    pushed on the stack.  This region of memory is always aligned to
 981    a multiple of BIGGEST_ALIGNMENT.
 982
 983    Any required stack pointer alignment is preserved.
 984
 985    SIZE is an rtx representing the size of the area.
 986    TARGET is a place in which the address can be placed.
 987
 988    KNOWN_ALIGN is the alignment (in bits) that we know SIZE has.  */
 989
 990 rtx
 991 allocate_dynamic_stack_space (size, target, known_align)
 992      rtx size;
 993      rtx target;
 994      int known_align;
 995 {
 996   /* If we're asking for zero bytes, it doesn't matter what we point
 997      to since we can't dereference it.  But return a reasonable
 998      address anyway.  */
 999   if (size == const0_rtx)
1000     return virtual_stack_dynamic_rtx;
1001
1002   /* Otherwise, show we're calling alloca or equivalent.  */
1003   current_function_calls_alloca = 1;
1004
1005   /* Ensure the size is in the proper mode.  */
1006   if (GET_MODE (size) != VOIDmode && GET_MODE (size) != Pmode)
1007     size = convert_to_mode (Pmode, size, 1);
1008
1009   /* We will need to ensure that the address we return is aligned to
1010      BIGGEST_ALIGNMENT.  If STACK_DYNAMIC_OFFSET is defined, we don't
1011      always know its final value at this point in the compilation (it
1012      might depend on the size of the outgoing parameter lists, for
1013      example), so we must align the value to be returned in that case.
1014      (Note that STACK_DYNAMIC_OFFSET will have a default non-zero value if
1015      STACK_POINTER_OFFSET or ACCUMULATE_OUTGOING_ARGS are defined).
1016      We must also do an alignment operation on the returned value if
1017      the stack pointer alignment is less strict that BIGGEST_ALIGNMENT.
1018
1019      If we have to align, we must leave space in SIZE for the hole
1020      that might result from the alignment operation.  */
1021
1022 #if defined (STACK_DYNAMIC_OFFSET) || defined (STACK_POINTER_OFFSET) || ! defined (STACK_BOUNDARY)
1023 #define MUST_ALIGN 1
1024 #else
1025 #define MUST_ALIGN (STACK_BOUNDARY < BIGGEST_ALIGNMENT)
1026 #endif
1027
1028   if (MUST_ALIGN)
1029     {
1030       if (GET_CODE (size) == CONST_INT)
1031         size = GEN_INT (INTVAL (size)
1032                         + (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1));
1033       else
1034         size = expand_binop (Pmode, add_optab, size,
1035                              GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1036                              NULL_RTX, 1, OPTAB_LIB_WIDEN);
1037     }
1038
1039 #ifdef SETJMP_VIA_SAVE_AREA
1040   /* If setjmp restores regs from a save area in the stack frame,
1041      avoid clobbering the reg save area.  Note that the offset of
1042      virtual_incoming_args_rtx includes the preallocated stack args space.
1043      It would be no problem to clobber that, but it's on the wrong side
1044      of the old save area.  */
1045   {
1046     rtx dynamic_offset
1047       = expand_binop (Pmode, sub_optab, virtual_stack_dynamic_rtx,
1048                       stack_pointer_rtx, NULL_RTX, 1, OPTAB_LIB_WIDEN);
1049     size = expand_binop (Pmode, add_optab, size, dynamic_offset,
1050                          NULL_RTX, 1, OPTAB_LIB_WIDEN);
1051   }
1052 #endif /* SETJMP_VIA_SAVE_AREA */
1053
1054   /* Round the size to a multiple of the required stack alignment.
1055      Since the stack if presumed to be rounded before this allocation,
1056      this will maintain the required alignment.
1057
1058      If the stack grows downward, we could save an insn by subtracting
1059      SIZE from the stack pointer and then aligning the stack pointer.
1060      The problem with this is that the stack pointer may be unaligned
1061      between the execution of the subtraction and alignment insns and
1062      some machines do not allow this.  Even on those that do, some
1063      signal handlers malfunction if a signal should occur between those
1064      insns.  Since this is an extremely rare event, we have no reliable
1065      way of knowing which systems have this problem.  So we avoid even
1066      momentarily mis-aligning the stack.  */
1067
1068 #ifdef STACK_BOUNDARY
1069   /* If we added a variable amount to SIZE,
1070      we can no longer assume it is aligned.  */
1071 #if !defined (SETJMP_VIA_SAVE_AREA)
1072   if (MUST_ALIGN || known_align % STACK_BOUNDARY != 0)
1073 #endif
1074     size = round_push (size);
1075 #endif
1076
1077   do_pending_stack_adjust ();
1078
1079   /* Don't use a TARGET that isn't a pseudo.  */
1080   if (target == 0 || GET_CODE (target) != REG
1081       || REGNO (target) < FIRST_PSEUDO_REGISTER)
1082     target = gen_reg_rtx (Pmode);
1083
1084   mark_reg_pointer (target, known_align / BITS_PER_UNIT);
1085
1086 #ifndef STACK_GROWS_DOWNWARD
1087   emit_move_insn (target, virtual_stack_dynamic_rtx);
1088 #endif
1089
1090   /* Perform the required allocation from the stack.  Some systems do
1091      this differently than simply incrementing/decrementing from the
1092      stack pointer.  */
1093 #ifdef HAVE_allocate_stack
1094   if (HAVE_allocate_stack)
1095     {
1096       enum machine_mode mode
1097         = insn_operand_mode[(int) CODE_FOR_allocate_stack][0];
1098
1099       size = convert_modes (mode, ptr_mode, size, 1);
1100
1101       if (insn_operand_predicate[(int) CODE_FOR_allocate_stack][0]
1102           && ! ((*insn_operand_predicate[(int) CODE_FOR_allocate_stack][0])
1103                 (size, mode)))
1104         size = copy_to_mode_reg (mode, size);
1105
1106       emit_insn (gen_allocate_stack (size));
1107     }
1108   else
1109 #endif
1110     {
1111       size = convert_modes (Pmode, ptr_mode, size, 1);
1112       anti_adjust_stack (size);
1113     }
1114
1115 #ifdef STACK_GROWS_DOWNWARD
1116   emit_move_insn (target, virtual_stack_dynamic_rtx);
1117 #endif
1118
1119   if (MUST_ALIGN)
1120     {
1121       /* CEIL_DIV_EXPR needs to worry about the addition overflowing,
1122          but we know it can't.  So add ourselves and then do
1123          TRUNC_DIV_EXPR.  */
1124       target = expand_binop (Pmode, add_optab, target,
1125                              GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT - 1),
1126                              NULL_RTX, 1, OPTAB_LIB_WIDEN);
1127       target = expand_divmod (0, TRUNC_DIV_EXPR, Pmode, target,
1128                               GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1129                               NULL_RTX, 1);
1130       target = expand_mult (Pmode, target,
1131                             GEN_INT (BIGGEST_ALIGNMENT / BITS_PER_UNIT),
1132                             NULL_RTX, 1);
1133     }
1134
1135   /* Some systems require a particular insn to refer to the stack
1136      to make the pages exist.  */
1137 #ifdef HAVE_probe
1138   if (HAVE_probe)
1139     emit_insn (gen_probe ());
1140 #endif
1141
1142   /* Record the new stack level for nonlocal gotos.  */
1143   if (nonlocal_goto_handler_slot != 0)
1144     emit_stack_save (SAVE_NONLOCAL, &nonlocal_goto_stack_level, NULL_RTX);
1145
1146   return target;
1147 }
1148 \f
1149 /* Return an rtx representing the register or memory location
1150    in which a scalar value of data type VALTYPE
1151    was returned by a function call to function FUNC.
1152    FUNC is a FUNCTION_DECL node if the precise function is known,
1153    otherwise 0.  */
1154
1155 rtx
1156 hard_function_value (valtype, func)
1157      tree valtype;
1158      tree func;
1159 {
1160   rtx val = FUNCTION_VALUE (valtype, func);
1161   if (GET_CODE (val) == REG
1162       && GET_MODE (val) == BLKmode)
1163     {
1164       int bytes = int_size_in_bytes (valtype);
1165       enum machine_mode tmpmode;
1166       for (tmpmode = GET_CLASS_NARROWEST_MODE (MODE_INT);
1167            tmpmode != MAX_MACHINE_MODE;
1168            tmpmode = GET_MODE_WIDER_MODE (tmpmode))
1169         {
1170           /* Have we found a large enough mode?  */
1171           if (GET_MODE_SIZE (tmpmode) >= bytes)
1172             break;
1173         }
1174
1175       /* No suitable mode found.  */
1176       if (tmpmode == MAX_MACHINE_MODE)
1177         abort ();
1178
1179       PUT_MODE (val, tmpmode);
1180     }
1181   return val;
1182 }
1183
1184 /* Return an rtx representing the register or memory location
1185    in which a scalar value of mode MODE was returned by a library call.  */
1186
1187 rtx
1188 hard_libcall_value (mode)
1189      enum machine_mode mode;
1190 {
1191   return LIBCALL_VALUE (mode);
1192 }
1193
1194 /* Look up the tree code for a given rtx code
1195    to provide the arithmetic operation for REAL_ARITHMETIC.
1196    The function returns an int because the caller may not know
1197    what `enum tree_code' means.  */
1198
1199 int
1200 rtx_to_tree_code (code)
1201      enum rtx_code code;
1202 {
1203   enum tree_code tcode;
1204
1205   switch (code)
1206     {
1207     case PLUS:
1208       tcode = PLUS_EXPR;
1209       break;
1210     case MINUS:
1211       tcode = MINUS_EXPR;
1212       break;
1213     case MULT:
1214       tcode = MULT_EXPR;
1215       break;
1216     case DIV:
1217       tcode = RDIV_EXPR;
1218       break;
1219     case SMIN:
1220       tcode = MIN_EXPR;
1221       break;
1222     case SMAX:
1223       tcode = MAX_EXPR;
1224       break;
1225     default:
1226       tcode = LAST_AND_UNUSED_TREE_CODE;
1227       break;
1228     }
1229   return ((int) tcode);
1230 }